Skip to content

Commit 1481f7d

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1514
No.1514.Path with Maximum Probability
1 parent a0dfd72 commit 1481f7d

File tree

3 files changed

+324
-0
lines changed

3 files changed

+324
-0
lines changed

‎solution/1500-1599/1514.Path with Maximum Probability/README.md

Lines changed: 146 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,8 @@
6161

6262
**方法一：堆优化 Dijkstra 算法**
6363

64+
**方法二：SPFA 算法**
65+
6466
<!-- tabs:start -->
6567

6668
### **Python3**
@@ -89,6 +91,30 @@ class Solution:
8991
return d[end]
9092
```
9193

94+
```python
95+
class Solution:
96+
def maxProbability(self, n: int, edges: List[List[int]], succProb: List[float], start: int, end: int) -> float:
97+
g = defaultdict(list)
98+
for (a, b), s in zip(edges, succProb):
99+
g[a].append((b, s))
100+
g[b].append((a, s))
101+
d = [0] * n
102+
vis = [False] * n
103+
d[start] = 1
104+
q = deque([start])
105+
vis[start] = True
106+
while q:
107+
i = q.popleft()
108+
vis[i] = False
109+
for j, s in g[i]:
110+
if d[j] < d[i] * s:
111+
d[j] = d[i] * s
112+
if not vis[j]:
113+
q.append(j)
114+
vis[j] = True
115+
return d[end]
116+
```
117+
92118
### **Java**
93119

94120
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -129,6 +155,45 @@ class Solution {
129155
}
130156
```
131157

158+
```java
159+
class Solution {
160+
public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {
161+
List<Pair<Integer, Double>>[] g = new List[n];
162+
for (int i = 0; i < n; ++i) {
163+
g[i] = new ArrayList<>();
164+
}
165+
for (int i = 0; i < edges.length; ++i) {
166+
int a = edges[i][0], b = edges[i][1];
167+
double s = succProb[i];
168+
g[a].add(new Pair<>(b, s));
169+
g[b].add(new Pair<>(a, s));
170+
}
171+
double[] d = new double[n];
172+
d[start] = 1.0;
173+
boolean[] vis = new boolean[n];
174+
Deque<Integer> q = new ArrayDeque<>();
175+
q.offer(start);
176+
vis[start] = true;
177+
while (!q.isEmpty()) {
178+
int i = q.poll();
179+
vis[i] = false;
180+
for (Pair<Integer, Double> ne : g[i]) {
181+
int j = ne.getKey();
182+
double s = ne.getValue();
183+
if (d[j] < d[i] * s) {
184+
d[j] = d[i] * s;
185+
if (!vis[j]) {
186+
q.offer(j);
187+
vis[j] = true;
188+
}
189+
}
190+
}
191+
}
192+
return d[end];
193+
}
194+
}
195+
```
196+
132197
### **C++**
133198

134199
```cpp
@@ -170,6 +235,87 @@ public:
170235
};
171236
```
172237
238+
```cpp
239+
class Solution {
240+
public:
241+
double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {
242+
vector<vector<pair<int, double>>> g(n);
243+
for (int i = 0; i < edges.size(); ++i)
244+
{
245+
int a = edges[i][0], b = edges[i][1];
246+
double s = succProb[i];
247+
g[a].push_back({b, s});
248+
g[b].push_back({a, s});
249+
}
250+
vector<double> d(n);
251+
vector<bool> vis(n);
252+
d[start] = 1.0;
253+
queue<int> q{{start}};
254+
vis[start] = true;
255+
while (!q.empty())
256+
{
257+
int i = q.front();
258+
q.pop();
259+
vis[i] = false;
260+
for (auto& ne : g[i])
261+
{
262+
int j = ne.first;
263+
double s = ne.second;
264+
if (d[j] < d[i] * s)
265+
{
266+
d[j] = d[i] * s;
267+
if (!vis[j])
268+
{
269+
q.push(j);
270+
vis[j] = true;
271+
}
272+
}
273+
}
274+
}
275+
return d[end];
276+
}
277+
};
278+
```
279+
280+
### **Go**
281+
282+
```go
283+
func maxProbability(n int, edges [][]int, succProb []float64, start int, end int) float64 {
284+
g := make([][]pair, n)
285+
for i, e := range edges {
286+
a, b, s := e[0], e[1], succProb[i]
287+
g[a] = append(g[a], pair{b, s})
288+
g[b] = append(g[b], pair{a, s})
289+
}
290+
d := make([]float64, n)
291+
d[start] = 1
292+
vis := make([]bool, n)
293+
q := []int{start}
294+
vis[start] = true
295+
for len(q) > 0 {
296+
i := q[0]
297+
q = q[1:]
298+
vis[i] = false
299+
for _, ne := range g[i] {
300+
j, s := ne.idx, ne.s
301+
if d[j] < d[i]*s {
302+
d[j] = d[i] * s
303+
if !vis[j] {
304+
q = append(q, j)
305+
vis[j] = true
306+
}
307+
}
308+
}
309+
}
310+
return d[end]
311+
}
312+
313+
type pair struct {
314+
idx int
315+
s float64
316+
}
317+
```
318+
173319
### **...**
174320

175321
```

‎solution/1500-1599/1514.Path with Maximum Probability/README_EN.md

Lines changed: 144 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -96,6 +96,30 @@ class Solution:
9696
return d[end]
9797
```
9898

99+
```python
100+
class Solution:
101+
def maxProbability(self, n: int, edges: List[List[int]], succProb: List[float], start: int, end: int) -> float:
102+
g = defaultdict(list)
103+
for (a, b), s in zip(edges, succProb):
104+
g[a].append((b, s))
105+
g[b].append((a, s))
106+
d = [0] * n
107+
vis = [False] * n
108+
d[start] = 1
109+
q = deque([start])
110+
vis[start] = True
111+
while q:
112+
i = q.popleft()
113+
vis[i] = False
114+
for j, s in g[i]:
115+
if d[j] < d[i] * s:
116+
d[j] = d[i] * s
117+
if not vis[j]:
118+
q.append(j)
119+
vis[j] = True
120+
return d[end]
121+
```
122+
99123
### **Java**
100124

101125
```java
@@ -134,6 +158,45 @@ class Solution {
134158
}
135159
```
136160

161+
```java
162+
class Solution {
163+
public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {
164+
List<Pair<Integer, Double>>[] g = new List[n];
165+
for (int i = 0; i < n; ++i) {
166+
g[i] = new ArrayList<>();
167+
}
168+
for (int i = 0; i < edges.length; ++i) {
169+
int a = edges[i][0], b = edges[i][1];
170+
double s = succProb[i];
171+
g[a].add(new Pair<>(b, s));
172+
g[b].add(new Pair<>(a, s));
173+
}
174+
double[] d = new double[n];
175+
d[start] = 1.0;
176+
boolean[] vis = new boolean[n];
177+
Deque<Integer> q = new ArrayDeque<>();
178+
q.offer(start);
179+
vis[start] = true;
180+
while (!q.isEmpty()) {
181+
int i = q.poll();
182+
vis[i] = false;
183+
for (Pair<Integer, Double> ne : g[i]) {
184+
int j = ne.getKey();
185+
double s = ne.getValue();
186+
if (d[j] < d[i] * s) {
187+
d[j] = d[i] * s;
188+
if (!vis[j]) {
189+
q.offer(j);
190+
vis[j] = true;
191+
}
192+
}
193+
}
194+
}
195+
return d[end];
196+
}
197+
}
198+
```
199+
137200
### **C++**
138201

139202
```cpp
@@ -175,6 +238,87 @@ public:
175238
};
176239
```
177240
241+
```cpp
242+
class Solution {
243+
public:
244+
double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {
245+
vector<vector<pair<int, double>>> g(n);
246+
for (int i = 0; i < edges.size(); ++i)
247+
{
248+
int a = edges[i][0], b = edges[i][1];
249+
double s = succProb[i];
250+
g[a].push_back({b, s});
251+
g[b].push_back({a, s});
252+
}
253+
vector<double> d(n);
254+
vector<bool> vis(n);
255+
d[start] = 1.0;
256+
queue<int> q{{start}};
257+
vis[start] = true;
258+
while (!q.empty())
259+
{
260+
int i = q.front();
261+
q.pop();
262+
vis[i] = false;
263+
for (auto& ne : g[i])
264+
{
265+
int j = ne.first;
266+
double s = ne.second;
267+
if (d[j] < d[i] * s)
268+
{
269+
d[j] = d[i] * s;
270+
if (!vis[j])
271+
{
272+
q.push(j);
273+
vis[j] = true;
274+
}
275+
}
276+
}
277+
}
278+
return d[end];
279+
}
280+
};
281+
```
282+
283+
### **Go**
284+
285+
```go
286+
func maxProbability(n int, edges [][]int, succProb []float64, start int, end int) float64 {
287+
g := make([][]pair, n)
288+
for i, e := range edges {
289+
a, b, s := e[0], e[1], succProb[i]
290+
g[a] = append(g[a], pair{b, s})
291+
g[b] = append(g[b], pair{a, s})
292+
}
293+
d := make([]float64, n)
294+
d[start] = 1
295+
vis := make([]bool, n)
296+
q := []int{start}
297+
vis[start] = true
298+
for len(q) > 0 {
299+
i := q[0]
300+
q = q[1:]
301+
vis[i] = false
302+
for _, ne := range g[i] {
303+
j, s := ne.idx, ne.s
304+
if d[j] < d[i]*s {
305+
d[j] = d[i] * s
306+
if !vis[j] {
307+
q = append(q, j)
308+
vis[j] = true
309+
}
310+
}
311+
}
312+
}
313+
return d[end]
314+
}
315+
316+
type pair struct {
317+
idx int
318+
s float64
319+
}
320+
```
321+
178322
### **...**
179323

180324
```

‎solution/1500-1599/1514.Path with Maximum Probability/Solution.go

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
func maxProbability(n int, edges [][]int, succProb []float64, start int, end int) float64 {
2+
g := make([][]pair, n)
3+
for i, e := range edges {
4+
a, b, s := e[0], e[1], succProb[i]
5+
g[a] = append(g[a], pair{b, s})
6+
g[b] = append(g[b], pair{a, s})
7+
}
8+
d := make([]float64, n)
9+
d[start] = 1
10+
vis := make([]bool, n)
11+
q := []int{start}
12+
vis[start] = true
13+
for len(q) > 0 {
14+
i := q[0]
15+
q = q[1:]
16+
vis[i] = false
17+
for _, ne := range g[i] {
18+
j, s := ne.idx, ne.s
19+
if d[j] < d[i]*s {
20+
d[j] = d[i] * s
21+
if !vis[j] {
22+
q = append(q, j)
23+
vis[j] = true
24+
}
25+
}
26+
}
27+
}
28+
return d[end]
29+
}
30+
31+
type pair struct {
32+
idx int
33+
s float64
34+
}

0 commit comments

Comments
 (0)