7070
7171时间复杂度 $O(n^3),ドル空间复杂度 $O(n^2)$。其中 $n$ 为城市个数。
7272
73+ ** 方法二:Floyd 算法**
74+ 75+ 我们定义 $g[ i] [ j ] $ 表示城市 $i$ 到城市 $j$ 的最短距离,初始时 $g[ i] [ j ] = \infty,ドル $g[ i] [ i ] = 0,ドル然后我们遍历所有边,对于每条边 $(f, t, w),ドル我们令 $g[ f] [ t ] = g[ t] [ f ] = w$。
76+ 77+ 接下来,我们用 Floyd 算法求出任意两点之间的最短距离。具体地,我们先枚举中间点 $k,ドル再枚举起点 $i$ 和终点 $j,ドル如果 $g[ i] [ k ] + g[ k] [ j ] \lt g[ i] [ j ] ,ドル那么我们就用更短的距离 $g[ i] [ k ] + g[ k] [ j ] $ 更新 $g[ i] [ j ] $。
78+ 79+ 最后,我们枚举每个城市 $i$ 作为起点,统计距离不超过阈值的城市个数,最后取最小的个数且编号最大的城市。
80+ 81+ 时间复杂度 $O(n^3),ドル空间复杂度 $O(n^2)$。其中 $n$ 为城市个数。
82+ 7383<!-- tabs:start -->
7484
7585### ** Python3**
@@ -81,7 +91,7 @@ class Solution:
8191 def findTheCity (
8292 self n : int , edges : List[List[int ]], distanceThreshold : int
8393 ) -> int :
84- def dijkstra (u ) :
94+ def dijkstra (u : int ) -> int :
8595 dist = [inf] * n
8696 dist[u] = 0
8797 vis = [False ] * n
@@ -92,19 +102,43 @@ class Solution:
92102 k = j
93103 vis[k] = True
94104 for j in range (n):
95- dist[j] = min (dist[j], dist[k] + g[k][j])
105+ # dist[j] = min(dist[j], dist[k] + g[k][j])
106+ if dist[k] + g[k][j] < dist[j]:
107+ dist[j] = dist[k] + g[k][j]
96108 return sum (d <= distanceThreshold for d in dist)
97109
98110 g = [[inf] * n for _ in range (n)]
99111 for f, t, w in edges:
100112 g[f][t] = g[t][f] = w
113+ ans, cnt = n, inf
114+ for i in range (n - 1 , - 1 , - 1 ):
115+ if (t := dijkstra(i)) < cnt:
116+ cnt, ans = t, i
117+ return ans
118+ ```
101119
102- ans = n
103- t = inf
120+ ``` python
121+ class Solution :
122+ def findTheCity (
123+ self n : int , edges : List[List[int ]], distanceThreshold : int
124+ ) -> int :
125+ g = [[inf] * n for _ in range (n)]
126+ for f, t, w in edges:
127+ g[f][t] = g[t][f] = w
128+ 129+ for k in range (n):
130+ g[k][k] = 0
131+ for i in range (n):
132+ for j in range (n):
133+ # g[i][j] = min(g[i][j], g[i][k] + g[k][j])
134+ if g[i][k] + g[k][j] < g[i][j]:
135+ g[i][j] = g[i][k] + g[k][j]
136+ 137+ ans, cnt = n, inf
104138 for i in range (n - 1 , - 1 , - 1 ):
105- if (cnt := dijkstra(i)) < t:
106- t = cnt
107- ans = i
139+ t = sum (d <= distanceThreshold for d in g[i])
140+ if t < cnt:
141+ cnt, ans = t, i
108142 return ans
109143```
110144
@@ -118,7 +152,7 @@ class Solution {
118152 private int [][] g;
119153 private int [] dist;
120154 private boolean [] vis;
121- private int inf = 1 << 30 ;
155+ private final int inf = 1 << 30 ;
122156 private int distanceThreshold;
123157
124158 public int findTheCity (int n , int [][] edges , int distanceThreshold ) {
@@ -135,11 +169,11 @@ class Solution {
135169 g[f][t] = w;
136170 g[t][f] = w;
137171 }
138- int ans = n, t = inf;
172+ int ans = n, cnt = inf;
139173 for (int i = n - 1 ; i >= 0 ; -- i) {
140- int cnt = dijkstra(i);
141- if (t > cnt) {
142- t = cnt ;
174+ int t = dijkstra(i);
175+ if (t < cnt) {
176+ cnt = t ;
143177 ans = i;
144178 }
145179 }
@@ -173,23 +207,62 @@ class Solution {
173207}
174208```
175209
210+ ``` java
211+ class Solution {
212+ public int findTheCity (int n , int [][] edges , int distanceThreshold ) {
213+ final int inf = 1 << 29 ;
214+ int [][] g = new int [n][n];
215+ for (var e : g) {
216+ Arrays . fill(e, inf);
217+ }
218+ for (var e : edges) {
219+ int f = e[0 ], t = e[1 ], w = e[2 ];
220+ g[f][t] = w;
221+ g[t][f] = w;
222+ }
223+ for (int k = 0 ; k < n; ++ k) {
224+ g[k][k] = 0 ;
225+ for (int i = 0 ; i < n; ++ i) {
226+ for (int j = 0 ; j < n; ++ j) {
227+ g[i][j] = Math . min(g[i][j], g[i][k] + g[k][j]);
228+ }
229+ }
230+ }
231+ int ans = n, cnt = inf;
232+ for (int i = n - 1 ; i >= 0 ; -- i) {
233+ int t = 0 ;
234+ for (int d : g[i]) {
235+ if (d <= distanceThreshold) {
236+ ++ t;
237+ }
238+ }
239+ if (t < cnt) {
240+ cnt = t;
241+ ans = i;
242+ }
243+ }
244+ return ans;
245+ }
246+ }
247+ ```
248+ 176249### ** C++**
177250
178251``` cpp
179252class Solution {
180253public:
181254 int findTheCity(int n, vector<vector<int >>& edges, int distanceThreshold) {
182- const int inf = 1e7 ;
183- vector<vector< int >> g(n, vector< int >(n, inf)) ;
184- vector< int > dist(n, inf) ;
185- vector< bool > vis(n );
255+ int g [ n ] [ n ] ;
256+ int dist [ n ] ;
257+ bool vis [ n ] ;
258+ memset(g, 0x3f, sizeof(g) );
186259 for (auto& e : edges) {
187260 int f = e[ 0] , t = e[ 1] , w = e[ 2] ;
188261 g[ f] [ t ] = g[ t] [ f ] = w;
189262 }
190263 auto dijkstra = [ &] (int u) {
191- dist.assign(n, inf );
192- vis.assign(n, false );
264+ memset(dist, 0x3f, sizeof(dist) );
265+ memset(vis, 0, sizeof(vis) );
193266 dist[ u] = 0;
194267 for (int i = 0; i < n; ++i) {
195268 int k = -1;
@@ -203,17 +276,44 @@ public:
203276 dist[ j] = min(dist[ j] , dist[ k] + g[ k] [ j ] );
204277 }
205278 }
206- int cnt = 0;
207- for (int& d : dist) {
208- cnt += d <= distanceThreshold;
209- }
210- return cnt;
279+ return count_if(dist, dist + n, [ &] (int d) { return d <= distanceThreshold; });
211280 };
212- int ans = n, t = inf;
281+ int ans = n, cnt = n + 1;
282+ for (int i = n - 1; ~ i; --i) {
283+ int t = dijkstra(i);
284+ if (t < cnt) {
285+ cnt = t;
286+ ans = i;
287+ }
288+ }
289+ return ans;
290+ }
291+ };
292+ ```
293+
294+ ```cpp
295+ class Solution {
296+ public:
297+ int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {
298+ int g[n][n];
299+ memset(g, 0x3f, sizeof(g));
300+ for (auto& e : edges) {
301+ int f = e[0], t = e[1], w = e[2];
302+ g[f][t] = g[t][f] = w;
303+ }
304+ for (int k = 0; k < n; ++k) {
305+ g[k][k] = 0;
306+ for (int i = 0; i < n; ++i) {
307+ for (int j = 0; j < n; ++j) {
308+ g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
309+ }
310+ }
311+ }
312+ int ans = n, cnt = n + 1;
213313 for (int i = n - 1; ~i; --i) {
214- int cnt = dijkstra(i );
215- if (t > cnt) {
216- t = cnt ;
314+ int t = count_if(g[i], g[i] + n, [&](int x) { return x <= distanceThreshold; } );
315+ if (t < cnt) {
316+ cnt = t ;
217317 ans = i;
218318 }
219319 }
@@ -241,7 +341,6 @@ func findTheCity(n int, edges [][]int, distanceThreshold int) int {
241341 g[f][t], g[t][f] = w, w
242342 }
243343
244- ans, t := n, inf
245344 dijkstra := func (u int ) (cnt int ) {
246345 for i := range vis {
247346 vis[i] = false
@@ -267,17 +366,132 @@ func findTheCity(n int, edges [][]int, distanceThreshold int) int {
267366 }
268367 return
269368 }
369+ 370+ ans , cnt := n, inf
270371 for i := n - 1 ; i >= 0 ; i-- {
271- cnt := dijkstra(i)
272- if t > cnt {
273- t = cnt
372+ if t := dijkstra (i); t < cnt {
373+ cnt = t
274374 ans = i
275375 }
276376 }
277377 return ans
278378}
279379```
280380
381+ ``` go
382+ func findTheCity (n int , edges [][]int , distanceThreshold int ) int {
383+ g := make ([][]int , n)
384+ const inf int = 1e7
385+ for i := range g {
386+ g[i] = make ([]int , n)
387+ for j := range g[i] {
388+ g[i][j] = inf
389+ }
390+ }
391+ 392+ for _ , e := range edges {
393+ f , t , w := e[0 ], e[1 ], e[2 ]
394+ g[f][t], g[t][f] = w, w
395+ }
396+ 397+ for k := 0 ; k < n; k++ {
398+ g[k][k] = 0
399+ for i := 0 ; i < n; i++ {
400+ for j := 0 ; j < n; j++ {
401+ g[i][j] = min (g[i][j], g[i][k]+g[k][j])
402+ }
403+ }
404+ }
405+ 406+ ans , cnt := n, n+1
407+ for i := n - 1 ; i >= 0 ; i-- {
408+ t := 0
409+ for _ , x := range g[i] {
410+ if x <= distanceThreshold {
411+ t++
412+ }
413+ }
414+ if t < cnt {
415+ cnt, ans = t, i
416+ }
417+ }
418+ 419+ return ans
420+ }
421+ ```
422+ 423+ ### ** TypeScript**
424+ 425+ ``` ts
426+ function findTheCity(n : number , edges : number [][], distanceThreshold : number ): number {
427+ const : number [][] = Array .from ({ length: n }, () => Array (n ).fill (Infinity ));
428+ const : number [] = Array (n ).fill (Infinity );
429+ const : boolean [] = Array (n ).fill (false );
430+ for (const of edges ) {
431+ g [f ][t ] = g [t ][f ] = w ;
432+ }
433+ 434+ const = (u : number ): number => {
435+ dist .fill (Infinity );
436+ vis .fill (false );
437+ dist [u ] = 0 ;
438+ for (let i = 0 ; i < n ; ++ i ) {
439+ let k = - 1 ;
440+ for (let j = 0 ; j < n ; ++ j ) {
441+ if (! vis [j ] && (k === - 1 || dist [j ] < dist [k ])) {
442+ k = j ;
443+ }
444+ }
445+ vis [k ] = true ;
446+ for (let j = 0 ; j < n ; ++ j ) {
447+ dist [j ] = Math .min (dist [j ], dist [k ] + g [k ][j ]);
448+ }
449+ }
450+ return dist .filter (d => d <= distanceThreshold ).length ;
451+ };
452+ 453+ let ans = n ;
454+ let cnt = Infinity ;
455+ for (let i = n - 1 ; i >= 0 ; -- i ) {
456+ const = dijkstra (i );
457+ if (t < cnt ) {
458+ cnt = t ;
459+ ans = i ;
460+ }
461+ }
462+ 463+ return ans ;
464+ }
465+ ```
466+ 467+ ``` ts
468+ function findTheCity(n : number , edges : number [][], distanceThreshold : number ): number {
469+ const : number [][] = Array .from ({ length: n }, () => Array (n ).fill (Infinity ));
470+ for (const of edges ) {
471+ g [f ][t ] = g [t ][f ] = w ;
472+ }
473+ for (let k = 0 ; k < n ; ++ k ) {
474+ g [k ][k ] = 0 ;
475+ for (let i = 0 ; i < n ; ++ i ) {
476+ for (let j = 0 ; j < n ; ++ j ) {
477+ g [i ][j ] = Math .min (g [i ][j ], g [i ][k ] + g [k ][j ]);
478+ }
479+ }
480+ }
481+ 482+ let ans = n ,
483+ cnt = n + 1 ;
484+ for (let i = n - 1 ; i >= 0 ; -- i ) {
485+ const = g [i ].filter (x => x <= distanceThreshold ).length ;
486+ if (t < cnt ) {
487+ cnt = t ;
488+ ans = i ;
489+ }
490+ }
491+ return ans ;
492+ }
493+ ```
494+ 281495### ** ...**
282496
283497```
0 commit comments