feat: add solutions to lc problem: No.0743

No.0743.Network Delay Time

Author: yanglbme

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

@@ -55,18 +55,24 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+设 n 表示点数，m 表示边数。
+
 **方法一：朴素 Dijkstra 算法**
 
-时间复杂度 O(n²)。
+时间复杂度 O(n²+m)。
 
 **方法二：堆优化 Dijkstra 算法**
 
-时间复杂度 O(nlogm)。
+时间复杂度 O(mlogn)。
 
 **方法三：Bellman Ford 算法**
 
 时间复杂度 O(nm)。
 
+**方法四：SPFA 算法**
+
+时间复杂度，平均情况下 O(m)，最坏情况下 O(nm)，n 表示点数，m 表示边数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -136,6 +142,32 @@ class Solution:
         return -1 if ans == INF else ans
 ```
 
+```python
+class Solution:
+    def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
+        INF = 0x3f3f
+        dist = [INF] * n
+        vis = [False] * n
+        g = defaultdict(list)
+        for u, v, w in times:
+            g[u - 1].append((v - 1, w))
+        k -= 1
+        dist[k] = 0
+        q = deque([k])
+        vis[k] = True
+        while q:
+            u = q.popleft()
+            vis[u] = False
+            for v, w in g[u]:
+                if dist[v] > dist[u] + w:
+                    dist[v] = dist[u] + w
+                    if not vis[v]:
+                        q.append(v)
+                        vis[v] = True
+        ans = max(dist)
+        return -1 if ans == INF else ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -246,6 +278,50 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    private static final int INF = 0x3f3f;
+
+    public int networkDelayTime(int[][] times, int n, int k) {
+        int[] dist = new int[n];
+        boolean[] vis = new boolean[n];
+        List<int[]>[] g = new List[n];
+        for (int i = 0; i < n; ++i) {
+            dist[i] = INF;
+            g[i] = new ArrayList<>();
+        }
+        for (int[] t : times) {
+            int u = t[0] - 1, v = t[1] - 1, w = t[2];
+            g[u].add(new int[]{v, w});
+        }
+        --k;
+        dist[k] = 0;
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(k);
+        vis[k] = true;
+        while (!q.isEmpty()) {
+            int u = q.poll();
+            vis[u] = false;
+            for (int[] ne : g[u]) {
+                int v = ne[0], w = ne[1];
+                if (dist[v] > dist[u] + w) {
+                    dist[v] = dist[u] + w;
+                    if (!vis[v]) {
+                        q.offer(v);
+                        vis[v] = true;
+                    }
+                }
+            }
+        }
+        int ans = 0;
+        for (int i = 0; i < n; ++i) {
+            ans = Math.max(ans, dist[i]);
+        }
+        return ans == INF ? -1 : ans;
+    }
+}
+```
+
 ### **Go**
 
 ```go
@@ -414,6 +490,56 @@ func min(a, b int) int {
 }
 ```
 
+```go
+func networkDelayTime(times [][]int, n int, k int) int {
+	const inf = 0x3f3f
+	dist := make([]int, n)
+	vis := make([]bool, n)
+	g := make([][][]int, n)
+	for i := range dist {
+		dist[i] = inf
+	}
+	for _, t := range times {
+		u, v, w := t[0]-1, t[1]-1, t[2]
+		g[u] = append(g[u], []int{v, w})
+	}
+	k--
+	dist[k] = 0
+	q := []int{k}
+	vis[k] = true
+	for len(q) > 0 {
+		u := q[0]
+		q = q[1:]
+		vis[u] = false
+		for _, ne := range g[u] {
+			v, w := ne[0], ne[1]
+			if dist[v] > dist[u]+w {
+				dist[v] = dist[u] + w
+				if !vis[v] {
+					q = append(q, v)
+					vis[v] = true
+				}
+			}
+		}
+	}
+	ans := 0
+	for _, v := range dist {
+		ans = max(ans, v)
+	}
+	if ans == inf {
+		return -1
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -473,6 +599,49 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    const int inf = 0x3f3f;
+
+    int networkDelayTime(vector<vector<int>>& times, int n, int k) {  
+        vector<int> dist(n, inf);
+        vector<vector<vector<int>>> g(n);
+        for (auto& e : times)
+        {
+            int u = e[0] - 1, v = e[1] - 1, w = e[2];
+            g[u].push_back({v, w});
+        }
+        vector<bool> vis(n);
+        --k;
+        queue<int> q{{k}};
+        vis[k] = true;
+        dist[k] = 0;
+        while (!q.empty())
+        {
+            int u = q.front();
+            q.pop();
+            vis[u] = false;
+            for (auto& ne : g[u])
+            {
+                int v = ne[0], w = ne[1];
+                if (dist[v] > dist[u] + w)
+                {
+                    dist[v] = dist[u] + w;
+                    if (!vis[v])
+                    {
+                        q.push(v);
+                        vis[v] = true;
+                    }
+                }
+            }
+        }
+        int ans = *max_element(dist.begin(), dist.end());
+        return ans == inf ? -1 : ans;
+    }
+};
+```
+
 ### **...**
 
 ```