Skip to content

Commit 3d11db3

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems
* No.0743.Network Delay Time * No.1514.Path with Maximum Probability
1 parent 44de295 commit 3d11db3

File tree

8 files changed

+536
-13
lines changed

8 files changed

+536
-13
lines changed

‎solution/0700-0799/0743.Network Delay Time/README.md

Lines changed: 126 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,8 @@
5757

5858
**方法一：朴素 Dijkstra 算法**
5959

60+
**方法二：堆优化 Dijkstra 算法**
61+
6062
<!-- tabs:start -->
6163

6264
### **Python3**
@@ -87,6 +89,31 @@ class Solution:
8789
return -1 if ans == INF else ans
8890
```
8991

92+
```python
93+
class Solution:
94+
def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
95+
N = 110
96+
INF = 0x3f3f
97+
g = defaultdict(list)
98+
for u, v, w in times:
99+
g[u].append((v, w))
100+
dist = [INF] * N
101+
dist[k] = 0
102+
q = [(0, k)]
103+
while q:
104+
t, u = heappop(q)
105+
if dist[u] < t:
106+
continue
107+
for v, t in g[u]:
108+
d = dist[u] + t
109+
if d < dist[v]:
110+
dist[v] = d
111+
heappush(q, (dist[v], v))
112+
113+
ans = max(dist[1: n + 1])
114+
return -1 if ans == INF else ans
115+
```
116+
90117
### **Java**
91118

92119
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -129,8 +156,107 @@ class Solution {
129156
}
130157
```
131158

159+
```java
160+
class Solution {
161+
private static final int N = 110;
162+
private static final int INF = 0x3f3f;
163+
164+
public int networkDelayTime(int[][] times, int n, int k) {
165+
List<int[]>[] g = new List[N];
166+
for (int i = 0; i < N; ++i) {
167+
g[i] = new ArrayList<>();
168+
}
169+
for (int[] e : times) {
170+
g[e[0]].add(new int[]{e[1], e[2]});
171+
}
172+
int[] dist = new int[N];
173+
Arrays.fill(dist, INF);
174+
dist[k] = 0;
175+
PriorityQueue<Pair<Integer, Integer>> q = new PriorityQueue<>(Comparator.comparingInt(Pair::getKey));
176+
q.offer(new Pair<>(0, k));
177+
while (!q.isEmpty()) {
178+
Pair<Integer, Integer> p = q.poll();
179+
int t = p.getKey();
180+
int u = p.getValue();
181+
if (dist[u] < t) {
182+
continue;
183+
}
184+
for (int[] ne : g[u]) {
185+
int v = ne[0];
186+
int w = ne[1];
187+
if (dist[u] + w < dist[v]) {
188+
dist[v] = dist[u] + w;
189+
q.offer(new Pair<>(dist[v], v));
190+
}
191+
}
192+
}
193+
int ans = 0;
194+
for (int i = 1; i <= n; ++i) {
195+
ans = Math.max(ans, dist[i]);
196+
}
197+
return ans == INF ? -1 : ans;
198+
}
199+
}
200+
```
201+
132202
### **Go**
133203

204+
```go
205+
const INF = 0x3f3f
206+
const N = 110
207+
208+
func networkDelayTime(times [][]int, n int, k int) int {
209+
g := make([][]int, N)
210+
dist := make([]int, N)
211+
for i := range g {
212+
dist[i] = INF
213+
g[i] = make([]int, N)
214+
for j := range g[i] {
215+
g[i][j] = INF
216+
}
217+
}
218+
for _, e := range times {
219+
g[e[0]][e[1]] = e[2]
220+
}
221+
vis := make([]bool, N)
222+
dist[k] = 0
223+
for i := 0; i < n; i++ {
224+
t := -1
225+
for j := 1; j <= n; j++ {
226+
if !vis[j] && (t == -1 || dist[t] > dist[j]) {
227+
t = j
228+
}
229+
}
230+
vis[t] = true
231+
for j := 1; j <= n; j++ {
232+
dist[j] = min(dist[j], dist[t]+g[t][j])
233+
}
234+
}
235+
ans := 0
236+
for i := 1; i <= n; i++ {
237+
ans = max(ans, dist[i])
238+
}
239+
if ans == INF {
240+
return -1
241+
}
242+
return ans
243+
}
244+
245+
func max(a, b int) int {
246+
if a > b {
247+
return a
248+
}
249+
return b
250+
}
251+
252+
func min(a, b int) int {
253+
if a < b {
254+
return a
255+
}
256+
return b
257+
}
258+
```
259+
134260
```go
135261
const Inf = 0x3f3f3f3f
136262

‎solution/0700-0799/0743.Network Delay Time/README_EN.md

Lines changed: 124 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,31 @@ class Solution:
7373
return -1 if ans == INF else ans
7474
```
7575

76+
```python
77+
class Solution:
78+
def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
79+
N = 110
80+
INF = 0x3f3f
81+
g = defaultdict(list)
82+
for u, v, w in times:
83+
g[u].append((v, w))
84+
dist = [INF] * N
85+
dist[k] = 0
86+
q = [(0, k)]
87+
while q:
88+
t, u = heappop(q)
89+
if dist[u] < t:
90+
continue
91+
for v, t in g[u]:
92+
d = dist[u] + t
93+
if d < dist[v]:
94+
dist[v] = d
95+
heappush(q, (dist[v], v))
96+
97+
ans = max(dist[1: n + 1])
98+
return -1 if ans == INF else ans
99+
```
100+
76101
### **Java**
77102

78103
```java
@@ -113,8 +138,107 @@ class Solution {
113138
}
114139
```
115140

141+
```java
142+
class Solution {
143+
private static final int N = 110;
144+
private static final int INF = 0x3f3f;
145+
146+
public int networkDelayTime(int[][] times, int n, int k) {
147+
List<int[]>[] g = new List[N];
148+
for (int i = 0; i < N; ++i) {
149+
g[i] = new ArrayList<>();
150+
}
151+
for (int[] e : times) {
152+
g[e[0]].add(new int[]{e[1], e[2]});
153+
}
154+
int[] dist = new int[N];
155+
Arrays.fill(dist, INF);
156+
dist[k] = 0;
157+
PriorityQueue<Pair<Integer, Integer>> q = new PriorityQueue<>(Comparator.comparingInt(Pair::getKey));
158+
q.offer(new Pair<>(0, k));
159+
while (!q.isEmpty()) {
160+
Pair<Integer, Integer> p = q.poll();
161+
int t = p.getKey();
162+
int u = p.getValue();
163+
if (dist[u] < t) {
164+
continue;
165+
}
166+
for (int[] ne : g[u]) {
167+
int v = ne[0];
168+
int w = ne[1];
169+
if (dist[u] + w < dist[v]) {
170+
dist[v] = dist[u] + w;
171+
q.offer(new Pair<>(dist[v], v));
172+
}
173+
}
174+
}
175+
int ans = 0;
176+
for (int i = 1; i <= n; ++i) {
177+
ans = Math.max(ans, dist[i]);
178+
}
179+
return ans == INF ? -1 : ans;
180+
}
181+
}
182+
```
183+
116184
### **Go**
117185

186+
```go
187+
const INF = 0x3f3f
188+
const N = 110
189+
190+
func networkDelayTime(times [][]int, n int, k int) int {
191+
g := make([][]int, N)
192+
dist := make([]int, N)
193+
for i := range g {
194+
dist[i] = INF
195+
g[i] = make([]int, N)
196+
for j := range g[i] {
197+
g[i][j] = INF
198+
}
199+
}
200+
for _, e := range times {
201+
g[e[0]][e[1]] = e[2]
202+
}
203+
vis := make([]bool, N)
204+
dist[k] = 0
205+
for i := 0; i < n; i++ {
206+
t := -1
207+
for j := 1; j <= n; j++ {
208+
if !vis[j] && (t == -1 || dist[t] > dist[j]) {
209+
t = j
210+
}
211+
}
212+
vis[t] = true
213+
for j := 1; j <= n; j++ {
214+
dist[j] = min(dist[j], dist[t]+g[t][j])
215+
}
216+
}
217+
ans := 0
218+
for i := 1; i <= n; i++ {
219+
ans = max(ans, dist[i])
220+
}
221+
if ans == INF {
222+
return -1
223+
}
224+
return ans
225+
}
226+
227+
func max(a, b int) int {
228+
if a > b {
229+
return a
230+
}
231+
return b
232+
}
233+
234+
func min(a, b int) int {
235+
if a < b {
236+
return a
237+
}
238+
return b
239+
}
240+
```
241+
118242
```go
119243
const Inf = 0x3f3f3f3f
120244

‎solution/0700-0799/0743.Network Delay Time/Solution.py

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -2,20 +2,21 @@ class Solution:
22
def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
33
N = 110
44
INF = 0x3f3f
5-
g = [[INF] * N for _ in range(N)]
5+
g = defaultdict(list)
66
for u, v, w in times:
7-
g[u][v] = w
7+
g[u].append((v, w))
88
dist = [INF] * N
99
dist[k] = 0
10-
vis = [False] * N
11-
for i in range(n):
12-
t = -1
13-
for j in range(1, n + 1):
14-
if not vis[j] and (t == -1 or dist[t] > dist[j]):
15-
t = j
16-
vis[t] = True
17-
for j in range(1, n + 1):
18-
dist[j] = min(dist[j], dist[t] + g[t][j])
10+
q = [(0, k)]
11+
while q:
12+
t, u = heappop(q)
13+
if dist[u] < t:
14+
continue
15+
for v, t in g[u]:
16+
d = dist[u] + t
17+
if d < dist[v]:
18+
dist[v] = d
19+
heappush(q, (dist[v], v))
1920

2021
ans = max(dist[1: n + 1])
2122
return -1 if ans == INF else ans

0 commit comments

Comments
 (0)