feat: add solutions to lc problem: No.1334 (doocs#1963)

No.1334.Find the City With the Smallest Number of Neighbors at a
Threshold Distance

Author: yanglbme

Diff for: solution/1300-1399/1334.Find the City With the Smallest Number of Neighbors at a Threshold Distance/README.md

@@ -70,6 +70,16 @@
 
 时间复杂度 $O(n^3)$，空间复杂度 $O(n^2)$。其中 $n$ 为城市个数。
 
+**方法二：Floyd 算法**
+
+我们定义 $g[i][j]$ 表示城市 $i$ 到城市 $j$ 的最短距离，初始时 $g[i][j] = \infty$, $g[i][i] = 0$，然后我们遍历所有边，对于每条边 $(f, t, w)$，我们令 $g[f][t] = g[t][f] = w$。
+
+接下来，我们用 Floyd 算法求出任意两点之间的最短距离。具体地，我们先枚举中间点 $k$，再枚举起点 $i$ 和终点 $j$，如果 $g[i][k] + g[k][j] \lt g[i][j]$，那么我们就用更短的距离 $g[i][k] + g[k][j]$ 更新 $g[i][j]$。
+
+最后，我们枚举每个城市 $i$ 作为起点，统计距离不超过阈值的城市个数，最后取最小的个数且编号最大的城市。
+
+时间复杂度 $O(n^3)$，空间复杂度 $O(n^2)$。其中 $n$ 为城市个数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -81,7 +91,7 @@ class Solution:
     def findTheCity(
         self, n: int, edges: List[List[int]], distanceThreshold: int
     ) -> int:
-        def dijkstra(u):
+        def dijkstra(u: int) -> int:
             dist = [inf] * n
             dist[u] = 0
             vis = [False] * n
@@ -92,19 +102,43 @@ class Solution:
                         k = j
                 vis[k] = True
                 for j in range(n):
-                    dist[j] = min(dist[j], dist[k] + g[k][j])
+                    # dist[j] = min(dist[j], dist[k] + g[k][j])
+                    if dist[k] + g[k][j] < dist[j]:
+                        dist[j] = dist[k] + g[k][j]
             return sum(d <= distanceThreshold for d in dist)
 
         g = [[inf] * n for _ in range(n)]
         for f, t, w in edges:
             g[f][t] = g[t][f] = w
+        ans, cnt = n, inf
+        for i in range(n - 1, -1, -1):
+            if (t := dijkstra(i)) < cnt:
+                cnt, ans = t, i
+        return ans
+```
 
-        ans = n
-        t = inf
+```python
+class Solution:
+    def findTheCity(
+        self, n: int, edges: List[List[int]], distanceThreshold: int
+    ) -> int:
+        g = [[inf] * n for _ in range(n)]
+        for f, t, w in edges:
+            g[f][t] = g[t][f] = w
+
+        for k in range(n):
+            g[k][k] = 0
+            for i in range(n):
+                for j in range(n):
+                    # g[i][j] = min(g[i][j], g[i][k] + g[k][j])
+                    if g[i][k] + g[k][j] < g[i][j]:
+                        g[i][j] = g[i][k] + g[k][j]
+
+        ans, cnt = n, inf
         for i in range(n - 1, -1, -1):
-            if (cnt := dijkstra(i)) < t:
-                t = cnt
-                ans = i
+            t = sum(d <= distanceThreshold for d in g[i])
+            if t < cnt:
+                cnt, ans = t, i
         return ans
 ```
 
@@ -118,7 +152,7 @@ class Solution {
     private int[][] g;
     private int[] dist;
     private boolean[] vis;
-    private int inf = 1 << 30;
+    private final int inf = 1 << 30;
     private int distanceThreshold;
 
     public int findTheCity(int n, int[][] edges, int distanceThreshold) {
@@ -135,11 +169,11 @@ class Solution {
             g[f][t] = w;
             g[t][f] = w;
         }
-        int ans = n, t = inf;
+        int ans = n, cnt = inf;
         for (int i = n - 1; i >= 0; --i) {
-            int cnt = dijkstra(i);
-            if (t > cnt) {
-                t = cnt;
+            int t = dijkstra(i);
+            if (t < cnt) {
+                cnt = t;
                 ans = i;
             }
         }
@@ -173,23 +207,62 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int findTheCity(int n, int[][] edges, int distanceThreshold) {
+        final int inf = 1 << 29;
+        int[][] g = new int[n][n];
+        for (var e : g) {
+            Arrays.fill(e, inf);
+        }
+        for (var e : edges) {
+            int f = e[0], t = e[1], w = e[2];
+            g[f][t] = w;
+            g[t][f] = w;
+        }
+        for (int k = 0; k < n; ++k) {
+            g[k][k] = 0;
+            for (int i = 0; i < n; ++i) {
+                for (int j = 0; j < n; ++j) {
+                    g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j]);
+                }
+            }
+        }
+        int ans = n, cnt = inf;
+        for (int i = n - 1; i >= 0; --i) {
+            int t = 0;
+            for (int d : g[i]) {
+                if (d <= distanceThreshold) {
+                    ++t;
+                }
+            }
+            if (t < cnt) {
+                cnt = t;
+                ans = i;
+            }
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
 class Solution {
 public:
     int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {
-        const int inf = 1e7;
-        vector<vector<int>> g(n, vector<int>(n, inf));
-        vector<int> dist(n, inf);
-        vector<bool> vis(n);
+        int g[n][n];
+        int dist[n];
+        bool vis[n];
+        memset(g, 0x3f, sizeof(g));
         for (auto& e : edges) {
             int f = e[0], t = e[1], w = e[2];
             g[f][t] = g[t][f] = w;
         }
         auto dijkstra = [&](int u) {
-            dist.assign(n, inf);
-            vis.assign(n, false);
+            memset(dist, 0x3f, sizeof(dist));
+            memset(vis, 0, sizeof(vis));
             dist[u] = 0;
             for (int i = 0; i < n; ++i) {
                 int k = -1;
@@ -203,17 +276,44 @@ public:
                     dist[j] = min(dist[j], dist[k] + g[k][j]);
                 }
             }
-            int cnt = 0;
-            for (int& d : dist) {
-                cnt += d <= distanceThreshold;
-            }
-            return cnt;
+            return count_if(dist, dist + n, [&](int d) { return d <= distanceThreshold; });
         };
-        int ans = n, t = inf;
+        int ans = n, cnt = n + 1;
+        for (int i = n - 1; ~i; --i) {
+            int t = dijkstra(i);
+            if (t < cnt) {
+                cnt = t;
+                ans = i;
+            }
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {
+        int g[n][n];
+        memset(g, 0x3f, sizeof(g));
+        for (auto& e : edges) {
+            int f = e[0], t = e[1], w = e[2];
+            g[f][t] = g[t][f] = w;
+        }
+        for (int k = 0; k < n; ++k) {
+            g[k][k] = 0;
+            for (int i = 0; i < n; ++i) {
+                for (int j = 0; j < n; ++j) {
+                    g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
+                }
+            }
+        }
+        int ans = n, cnt = n + 1;
         for (int i = n - 1; ~i; --i) {
-            int cnt = dijkstra(i);
-            if (t > cnt) {
-                t = cnt;
+            int t = count_if(g[i], g[i] + n, [&](int x) { return x <= distanceThreshold; });
+            if (t < cnt) {
+                cnt = t;
                 ans = i;
             }
         }
@@ -241,7 +341,6 @@ func findTheCity(n int, edges [][]int, distanceThreshold int) int {
 		g[f][t], g[t][f] = w, w
 	}
 
-	ans, t := n, inf
 	dijkstra := func(u int) (cnt int) {
 		for i := range vis {
 			vis[i] = false
@@ -267,17 +366,132 @@ func findTheCity(n int, edges [][]int, distanceThreshold int) int {
 		}
 		return
 	}
+
+	ans, cnt := n, inf
 	for i := n - 1; i >= 0; i-- {
-		cnt := dijkstra(i)
-		if t > cnt {
-			t = cnt
+		if t := dijkstra(i); t < cnt {
+			cnt = t
 			ans = i
 		}
 	}
 	return ans
 }
 ```
 
+```go
+func findTheCity(n int, edges [][]int, distanceThreshold int) int {
+	g := make([][]int, n)
+	const inf int = 1e7
+	for i := range g {
+		g[i] = make([]int, n)
+		for j := range g[i] {
+			g[i][j] = inf
+		}
+	}
+
+	for _, e := range edges {
+		f, t, w := e[0], e[1], e[2]
+		g[f][t], g[t][f] = w, w
+	}
+
+	for k := 0; k < n; k++ {
+		g[k][k] = 0
+		for i := 0; i < n; i++ {
+			for j := 0; j < n; j++ {
+				g[i][j] = min(g[i][j], g[i][k]+g[k][j])
+			}
+		}
+	}
+
+	ans, cnt := n, n+1
+	for i := n - 1; i >= 0; i-- {
+		t := 0
+		for _, x := range g[i] {
+			if x <= distanceThreshold {
+				t++
+			}
+		}
+		if t < cnt {
+			cnt, ans = t, i
+		}
+	}
+
+	return ans
+}
+```
+
+### **TypeScript**
+
+```ts
+function findTheCity(n: number, edges: number[][], distanceThreshold: number): number {
+    const g: number[][] = Array.from({ length: n }, () => Array(n).fill(Infinity));
+    const dist: number[] = Array(n).fill(Infinity);
+    const vis: boolean[] = Array(n).fill(false);
+    for (const [f, t, w] of edges) {
+        g[f][t] = g[t][f] = w;
+    }
+
+    const dijkstra = (u: number): number => {
+        dist.fill(Infinity);
+        vis.fill(false);
+        dist[u] = 0;
+        for (let i = 0; i < n; ++i) {
+            let k = -1;
+            for (let j = 0; j < n; ++j) {
+                if (!vis[j] && (k === -1 || dist[j] < dist[k])) {
+                    k = j;
+                }
+            }
+            vis[k] = true;
+            for (let j = 0; j < n; ++j) {
+                dist[j] = Math.min(dist[j], dist[k] + g[k][j]);
+            }
+        }
+        return dist.filter(d => d <= distanceThreshold).length;
+    };
+
+    let ans = n;
+    let cnt = Infinity;
+    for (let i = n - 1; i >= 0; --i) {
+        const t = dijkstra(i);
+        if (t < cnt) {
+            cnt = t;
+            ans = i;
+        }
+    }
+
+    return ans;
+}
+```
+
+```ts
+function findTheCity(n: number, edges: number[][], distanceThreshold: number): number {
+    const g: number[][] = Array.from({ length: n }, () => Array(n).fill(Infinity));
+    for (const [f, t, w] of edges) {
+        g[f][t] = g[t][f] = w;
+    }
+    for (let k = 0; k < n; ++k) {
+        g[k][k] = 0;
+        for (let i = 0; i < n; ++i) {
+            for (let j = 0; j < n; ++j) {
+                g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j]);
+            }
+        }
+    }
+
+    let ans = n,
+        cnt = n + 1;
+    for (let i = n - 1; i >= 0; --i) {
+        const t = g[i].filter(x => x <= distanceThreshold).length;
+        if (t < cnt) {
+            cnt = t;
+            ans = i;
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```