Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 6a9916f

Browse files
solves #1514: Path with Maximum Probability in java
1 parent 1bb0219 commit 6a9916f

File tree

3 files changed

+109
-54
lines changed

3 files changed

+109
-54
lines changed

‎README.md

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -606,6 +606,7 @@
606606
| 1502 | [Can Make Arithmetic Progression From Sequence](https://leetcode.com/problems/can-make-arithmetic-progression-from-sequence) | [![Java](assets/java.png)](src/CanMakeArithmeticProgressionFromSequence.java) | |
607607
| 1507 | [Reformat Date](https://leetcode.com/problems/reformat-date) | [![Java](assets/java.png)](src/ReformatDate.java) | |
608608
| 1512 | [Number of Good Pairs](https://leetcode.com/problems/number-of-good-pairs) | [![Java](assets/java.png)](src/NumberOfGoodPairs.java) | |
609+
| 1514 | [Path with Maximum Probability](https://leetcode.com/problems/path-with-maximum-probability) | [![Java](assets/java.png)](src/PathWithMaximumProbability.java) | |
609610
| 1518 | [Water Bottles](https://leetcode.com/problems/water-bottles) | [![Java](assets/java.png)](src/WaterBottles.java) | |
610611
| 1523 | [Count Odd Numbers In Interval Range](https://leetcode.com/problems/count-odd-numbers-in-an-interval-range) | [![Java](assets/java.png)](src/CountOddNumbersInIntervalRange.java) | |
611612
| 1528 | [Shuffle Strings](https://leetcode.com/problems/shuffle-string) | [![Java](assets/java.png)](src/ShuffleString.java) | |

‎src/HelloWorld.java

Lines changed: 42 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -1,78 +1,66 @@
1-
// T: O(N + E alp(N))
2-
// S: O(N)
1+
// T: O(V + EllogV)
2+
// S: O(E + V)
33

4-
import java.security.cert.Certificate;
5-
import java.util.ArrayList;
6-
import java.util.LinkedList;
7-
import java.util.List;
4+
import java.util.Comparator;
5+
import java.util.HashMap;
6+
import java.util.HashSet;
7+
import java.util.Map;
8+
import java.util.PriorityQueue;
89
import java.util.Queue;
9-
10+
importjava.util.Set;
1011

1112

1213
public class HelloWorld {
13-
private static final List<List<Integer>> DIRECTIONS = List.of(
14-
List.of(1, 0),
15-
List.of(0, 1),
16-
List.of(-1, 0),
17-
List.of(0, -1)
18-
);
14+
private static final recordPair(intvertex, intdistance) {}
15+
16+
publicintnetworkDelayTime(int[][] times, intn, intk) {
17+
finalMap<Integer, Map<Integer, Integer>> graph = createGraph(times);
18+
finalMap<Integer, Integer> distances = newHashMap<>();
19+
finalQueue<Pair> minHeap = newPriorityQueue<>(Comparator.comparingInt(a -> a.distance));
1920

20-
public int orangesRotting(int[][] grid) {
21-
final Queue<int[]> queue = new LinkedList<>();
22-
addRottenOrangesToQueue(queue, grid);
23-
int maxTime = 0;
21+
minHeap.add(new Pair(k, 0));
2422

25-
while (!queue.isEmpty()) {
26-
final int[] info = queue.poll();
27-
final int row = info[0], column = info[1], time = info[2];
23+
while (!minHeap.isEmpty()) {
24+
final Pair pair = minHeap.poll();
25+
final int vertex = pair.vertex, distanceToVertex = pair.distance;
26+
final int currentVertexTime = distances.getOrDefault(vertex, Integer.MAX_VALUE);
2827

29-
if (grid[row][column] == 0) {
28+
if (currentVertexTime < distanceToVertex) {
3029
continue;
3130
}
3231

33-
maxTime = Math.max(time, maxTime);
34-
grid[row][column] = 0;
35-
36-
for (int[] neighbour : getNeighbours(grid, row, column)) {
37-
queue.add(new int[] { neighbour[0], neighbour[1], time + 1});
38-
}
39-
}
32+
distances.put(vertex, distanceToVertex);
4033

41-
if (containsFreshOranges(grid)) {
42-
return -1;
43-
}
44-
return maxTime;
45-
}
34+
for (Map.Entry<Integer, Integer> entry : graph.getOrDefault(pair.vertex, new HashMap<>()).entrySet()) {
35+
final int neighbour = entry.getKey(), distance = entry.getValue();
36+
final int currentMinDistance = distances.getOrDefault(neighbour, Integer.MAX_VALUE);
37+
final int minDistance = Math.min(currentMinDistance, distances.get(pair.vertex) + distance);
4638

47-
private static boolean containsFreshOranges(int[][] grid) {
48-
for (int[] row : grid) {
49-
for (int orange : row) {
50-
if (orange == 1) {
51-
return true;
39+
if (minDistance < currentMinDistance) {
40+
distances.put(neighbour, minDistance);
41+
minHeap.add(new Pair(neighbour, minDistance));
5242
}
5343
}
5444
}
55-
return false;
45+
46+
return minTimeRequired(distances, n);
5647
}
5748

58-
private static voidaddRottenOrangesToQueue(Queue<int[]> queue, int[][] grid) {
59-
for(introw = 0 ; row < grid.length ; row++) {
60-
for (intcolumn = 0 ; column < grid[0].length ; column++) {
61-
if (grid[row][column] == 2) {
62-
queue.add(newint[] { row, column, 0 });
63-
}
64-
}
49+
private static Map<Integer, Map<Integer, Integer>> createGraph(int[][] edges) {
50+
finalMap<Integer, Map<Integer, Integer>> result = newHashMap<>();
51+
for (int[] edge : edges) {
52+
finalintfrom = edge[0], to = edge[1], weight = edge[2];
53+
finalMap<Integer, Integer> weights = result.getOrDefault(from, newHashMap<>());
54+
weights.put(to, weight);
55+
result.putIfAbsent(from, weights);
6556
}
57+
return result;
6658
}
6759

68-
private static List<int[]> getNeighbours(int[][] grid, int row, int column) {
69-
final List<int[]> result = new ArrayList<>();
70-
for (List<Integer> direction : DIRECTIONS) {
71-
final int r = row + direction.get(0), c = column + direction.get(1);
72-
if (r >= 0 && r < grid.length && c >= 0 && c < grid[0].length && grid[r][c] == 1) {
73-
result.add(new int[] {r, c});
74-
}
60+
private static int minTimeRequired(Map<Integer, Integer> distances, int n) {
61+
if (distances.size() != n) {
62+
return -1;
7563
}
76-
return result;
64+
return distances.values().stream().max(Integer::compareTo).get();
7765
}
7866
}

‎src/PathWithMaximumProbability.java

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,66 @@
1+
// https://leetcode.com/problems/path-with-maximum-probability
2+
// T: O(E + N + E logN)
3+
// S: O(E + N)
4+
5+
import java.util.Comparator;
6+
import java.util.HashMap;
7+
import java.util.Map;
8+
import java.util.PriorityQueue;
9+
import java.util.Queue;
10+
11+
public class PathWithMaximumProbability {
12+
private record Pair(int vertex, double probability) {}
13+
14+
public static double maxProbability(int n, int[][] edges, double[] probabilities, int start, int end) {
15+
final Map<Integer, Map<Integer, Double>> graph = createGraph(edges, probabilities);
16+
final Map<Integer, Double> distances = dijkstra(graph, start, end);
17+
return distances.getOrDefault(end, 0.0);
18+
}
19+
20+
private static Map<Integer, Map<Integer, Double>> createGraph(int[][] edges, double[] probabilities) {
21+
final Map<Integer, Map<Integer, Double>> graph = new HashMap<>();
22+
int k = 0;
23+
for (int[] edge : edges) {
24+
final int from = edge[0], to = edge[1];
25+
final double weight = probabilities[k++];
26+
final Map<Integer, Double> fromNeighbours = graph.getOrDefault(from, new HashMap<>());
27+
final Map<Integer, Double> toNeighbours = graph.getOrDefault(to, new HashMap<>());
28+
fromNeighbours.put(to, weight);
29+
toNeighbours.put(from, weight);
30+
graph.putIfAbsent(from, fromNeighbours);
31+
graph.putIfAbsent(to, toNeighbours);
32+
}
33+
return graph;
34+
}
35+
36+
private static Map<Integer, Double> dijkstra(Map<Integer, Map<Integer, Double>> graph, int start, int end) {
37+
final Map<Integer, Double> distances = new HashMap<>();
38+
final Queue<Pair> minHeap = new PriorityQueue<>(Comparator.comparingDouble(a -> a.probability));
39+
minHeap.add(new Pair(start, 1));
40+
distances.put(start, 1.0);
41+
42+
while (!minHeap.isEmpty()) {
43+
final Pair pair = minHeap.poll();
44+
45+
if (pair.vertex == end) {
46+
break;
47+
}
48+
49+
for (Map.Entry<Integer, Double> neighbour : graph.getOrDefault(pair.vertex, new HashMap<>()).entrySet()) {
50+
final int edgeVertex = neighbour.getKey();
51+
final double edgeWeight = neighbour.getValue();
52+
final double currentProbability = distances.getOrDefault(edgeVertex, 0.0);
53+
final double edgeProbability = Math.max(
54+
currentProbability,
55+
pair.probability * edgeWeight
56+
);
57+
if (edgeProbability > currentProbability) {
58+
distances.put(edgeVertex, edgeProbability);
59+
minHeap.add(new Pair(edgeVertex, edgeProbability));
60+
}
61+
}
62+
}
63+
64+
return distances;
65+
}
66+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /