fix: update solutions to lc problem: No.2608

yanglbme · yanglbme · commit 3ba04807cc9f · 2023-04-08T08:41:46.000+08:00
No.2608.Shortest Cycle in a Graph
diff --git a/solution/2600-2699/2608.Shortest Cycle in a Graph/README.md b/solution/2600-2699/2608.Shortest Cycle in a Graph/README.md
@@ -97,15 +97,16 @@ class Solution:
             dist = [-1] * n
             dist[u] = 0
             q = deque([(u, -1)])
+            ans = inf
             while q:
                 u, fa = q.popleft()
                 for v in g[u]:
                     if dist[v] < 0:
                         dist[v] = dist[u] + 1
                         q.append((v, u))
                     elif v != fa:
-                        return dist[u] + dist[v] + 1
-            return inf
+                        ans = min(ans, dist[u] + dist[v] + 1)
+            return ans
 
         g = defaultdict(list)
         for u, v in edges:
@@ -187,6 +188,7 @@ class Solution {
         dist[u] = 0;
         Deque<int[]> q = new ArrayDeque<>();
         q.offer(new int[] {u, -1});
+        int ans = inf;
         while (!q.isEmpty()) {
             var p = q.poll();
             u = p[0];
@@ -196,11 +198,11 @@ class Solution {
                     dist[v] = dist[u] + 1;
                     q.offer(new int[] {v, u});
                 } else if (v != fa) {
-                    return dist[u] + dist[v] + 1;
+                    ans = Math.min(ans, dist[u] + dist[v] + 1);
                 }
             }
         }
-        return inf;
+        return ans;
     }
 }
 ```
@@ -263,6 +265,7 @@ public:
             dist[u] = 0;
             queue<pair<int, int>> q;
             q.emplace(u, -1);
+            int ans = inf;
             while (!q.empty()) {
                 auto p = q.front();
                 u = p.first;
@@ -273,11 +276,11 @@ public:
                         dist[v] = dist[u] + 1;
                         q.emplace(v, u);
                     } else if (v != fa) {
-                        return dist[u] + dist[v] + 1;
+                        ans = min(ans, dist[u] + dist[v] + 1);
                     }
                 }
             }
-            return inf;
+            return ans;
         };
         int ans = inf;
         for (int i = 0; i < n; ++i) {
@@ -354,6 +357,7 @@ func findShortestCycle(n int, edges [][]int) int {
 		}
 		dist[u] = 0
 		q := [][2]int{{u, -1}}
+		ans := inf
 		for len(q) > 0 {
 			p := q[0]
 			u = p[0]
@@ -364,11 +368,11 @@ func findShortestCycle(n int, edges [][]int) int {
 					dist[v] = dist[u] + 1
 					q = append(q, [2]int{v, u})
 				} else if v != fa {
-					return dist[u] + dist[v] + 1
+					ans = min(ans, dist[u]+dist[v]+1)
 				}
 			}
 		}
-		return inf
+		return ans
 	}
 	ans := inf
 	for i := 0; i < n; i++ {
@@ -439,6 +443,7 @@ function findShortestCycle(n: number, edges: number[][]): number {
         const dist: number[] = new Array(n).fill(-1);
         dist[u] = 0;
         const q: number[][] = [[u, -1]];
+        let ans = inf;
         while (q.length) {
             const p = q.shift()!;
             u = p[0];
@@ -447,12 +452,12 @@ function findShortestCycle(n: number, edges: number[][]): number {
                 if (dist[v] < 0) {
                     dist[v] = dist[u] + 1;
                     q.push([v, u]);
-                } else if (v != fa) {
-                    return dist[u] + dist[v] + 1;
+                } else if (v !== fa) {
+                    ans = Math.min(ans, dist[u] + dist[v] + 1);
                 }
             }
         }
-        return inf;
+        return ans;
     };
     for (let i = 0; i < n; ++i) {
         ans = Math.min(ans, bfs(i));
diff --git a/solution/2600-2699/2608.Shortest Cycle in a Graph/README_EN.md b/solution/2600-2699/2608.Shortest Cycle in a Graph/README_EN.md
@@ -75,15 +75,16 @@ class Solution:
             dist = [-1] * n
             dist[u] = 0
             q = deque([(u, -1)])
+            ans = inf
             while q:
                 u, fa = q.popleft()
                 for v in g[u]:
                     if dist[v] < 0:
                         dist[v] = dist[u] + 1
                         q.append((v, u))
                     elif v != fa:
-                        return dist[u] + dist[v] + 1
-            return inf
+                        ans = min(ans, dist[u] + dist[v] + 1)
+            return ans
 
         g = defaultdict(list)
         for u, v in edges:
@@ -163,6 +164,7 @@ class Solution {
         dist[u] = 0;
         Deque<int[]> q = new ArrayDeque<>();
         q.offer(new int[] {u, -1});
+        int ans = inf;
         while (!q.isEmpty()) {
             var p = q.poll();
             u = p[0];
@@ -172,11 +174,11 @@ class Solution {
                     dist[v] = dist[u] + 1;
                     q.offer(new int[] {v, u});
                 } else if (v != fa) {
-                    return dist[u] + dist[v] + 1;
+                    ans = Math.min(ans, dist[u] + dist[v] + 1);
                 }
             }
         }
-        return inf;
+        return ans;
     }
 }
 ```
@@ -239,6 +241,7 @@ public:
             dist[u] = 0;
             queue<pair<int, int>> q;
             q.emplace(u, -1);
+            int ans = inf;
             while (!q.empty()) {
                 auto p = q.front();
                 u = p.first;
@@ -249,11 +252,11 @@ public:
                         dist[v] = dist[u] + 1;
                         q.emplace(v, u);
                     } else if (v != fa) {
-                        return dist[u] + dist[v] + 1;
+                        ans = min(ans, dist[u] + dist[v] + 1);
                     }
                 }
             }
-            return inf;
+            return ans;
         };
         int ans = inf;
         for (int i = 0; i < n; ++i) {
@@ -330,6 +333,7 @@ func findShortestCycle(n int, edges [][]int) int {
 		}
 		dist[u] = 0
 		q := [][2]int{{u, -1}}
+		ans := inf
 		for len(q) > 0 {
 			p := q[0]
 			u = p[0]
@@ -340,11 +344,11 @@ func findShortestCycle(n int, edges [][]int) int {
 					dist[v] = dist[u] + 1
 					q = append(q, [2]int{v, u})
 				} else if v != fa {
-					return dist[u] + dist[v] + 1
+					ans = min(ans, dist[u]+dist[v]+1)
 				}
 			}
 		}
-		return inf
+		return ans
 	}
 	ans := inf
 	for i := 0; i < n; i++ {
@@ -415,6 +419,7 @@ function findShortestCycle(n: number, edges: number[][]): number {
         const dist: number[] = new Array(n).fill(-1);
         dist[u] = 0;
         const q: number[][] = [[u, -1]];
+        let ans = inf;
         while (q.length) {
             const p = q.shift()!;
             u = p[0];
@@ -423,12 +428,12 @@ function findShortestCycle(n: number, edges: number[][]): number {
                 if (dist[v] < 0) {
                     dist[v] = dist[u] + 1;
                     q.push([v, u]);
-                } else if (v != fa) {
-                    return dist[u] + dist[v] + 1;
+                } else if (v !== fa) {
+                    ans = Math.min(ans, dist[u] + dist[v] + 1);
                 }
             }
         }
-        return inf;
+        return ans;
     };
     for (let i = 0; i < n; ++i) {
         ans = Math.min(ans, bfs(i));
diff --git a/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.cpp b/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.cpp
@@ -14,6 +14,7 @@ class Solution {
             dist[u] = 0;
             queue<pair<int, int>> q;
             q.emplace(u, -1);
+            int ans = inf;
             while (!q.empty()) {
                 auto p = q.front();
                 u = p.first;
@@ -24,11 +25,11 @@ class Solution {
                         dist[v] = dist[u] + 1;
                         q.emplace(v, u);
                     } else if (v != fa) {
-                        return dist[u] + dist[v] + 1;
+                        ans = min(ans, dist[u] + dist[v] + 1);
                     }
                 }
             }
-            return inf;
+            return ans;
         };
         int ans = inf;
         for (int i = 0; i < n; ++i) {
diff --git a/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.go b/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.go
@@ -13,6 +13,7 @@ func findShortestCycle(n int, edges [][]int) int {
 		}
 		dist[u] = 0
 		q := [][2]int{{u, -1}}
+		ans := inf
 		for len(q) > 0 {
 			p := q[0]
 			u = p[0]
@@ -23,11 +24,11 @@ func findShortestCycle(n int, edges [][]int) int {
 					dist[v] = dist[u] + 1
 					q = append(q, [2]int{v, u})
 				} else if v != fa {
-					return dist[u] + dist[v] + 1
+					ans = min(ans, dist[u]+dist[v]+1)
 				}
 			}
 		}
-		return inf
+		return ans
 	}
 	ans := inf
 	for i := 0; i < n; i++ {
diff --git a/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.java b/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.java
@@ -23,6 +23,7 @@ private int bfs(int u) {
         dist[u] = 0;
         Deque<int[]> q = new ArrayDeque<>();
         q.offer(new int[] {u, -1});
+        int ans = inf;
         while (!q.isEmpty()) {
             var p = q.poll();
             u = p[0];
@@ -32,10 +33,10 @@ private int bfs(int u) {
                     dist[v] = dist[u] + 1;
                     q.offer(new int[] {v, u});
                 } else if (v != fa) {
-                    return dist[u] + dist[v] + 1;
+                    ans = Math.min(ans, dist[u] + dist[v] + 1);
                 }
             }
         }
-        return inf;
+        return ans;
     }
 }
diff --git a/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.py b/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.py
@@ -4,15 +4,16 @@ def bfs(u: int) -> int:
             dist = [-1] * n
             dist[u] = 0
             q = deque([(u, -1)])
+            ans = inf
             while q:
                 u, fa = q.popleft()
                 for v in g[u]:
                     if dist[v] < 0:
                         dist[v] = dist[u] + 1
                         q.append((v, u))
                     elif v != fa:
-                        return dist[u] + dist[v] + 1
-            return inf
+                        ans = min(ans, dist[u] + dist[v] + 1)
+            return ans
 
         g = defaultdict(list)
         for u, v in edges:
diff --git a/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.ts b/solution/2600-2699/2608.Shortest Cycle in a Graph/Solution.ts
@@ -10,6 +10,7 @@ function findShortestCycle(n: number, edges: number[][]): number {
         const dist: number[] = new Array(n).fill(-1);
         dist[u] = 0;
         const q: number[][] = [[u, -1]];
+        let ans = inf;
         while (q.length) {
             const p = q.shift()!;
             u = p[0];
@@ -18,12 +19,12 @@ function findShortestCycle(n: number, edges: number[][]): number {
                 if (dist[v] < 0) {
                     dist[v] = dist[u] + 1;
                     q.push([v, u]);
-                } else if (v != fa) {
-                    return dist[u] + dist[v] + 1;
+                } else if (v !== fa) {
+                    ans = Math.min(ans, dist[u] + dist[v] + 1);
                 }
             }
         }
-        return inf;
+        return ans;
     };
     for (let i = 0; i < n; ++i) {
         ans = Math.min(ans, bfs(i));

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ func findShortestCycle(n int, edges [][]int) int {`
`13`	`13`	`}`
`14`	`14`	`dist[u] = 0`
`15`	`15`	`q := [][2]int{{u, -1}}`
	`16`	`+ ans := inf`
`16`	`17`	`for len(q) > 0 {`
`17`	`18`	`p := q[0]`
`18`	`19`	`u = p[0]`
`@@ -23,11 +24,11 @@ func findShortestCycle(n int, edges [][]int) int {`
`23`	`24`	`dist[v] = dist[u] + 1`
`24`	`25`	`q = append(q, [2]int{v, u})`
`25`	`26`	`} else if v != fa {`
`26`		`- return dist[u] + dist[v] + 1`
	`27`	`+ ans = min(ans, dist[u]+dist[v]+1)`
`27`	`28`	`}`
`28`	`29`	`}`
`29`	`30`	`}`
`30`		`- return inf`
	`31`	`+ return ans`
`31`	`32`	`}`
`32`	`33`	`ans := inf`
`33`	`34`	`for i := 0; i < n; i++ {`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ private int bfs(int u) {`
`23`	`23`	`dist[u] = 0;`
`24`	`24`	`Deque<int[]> q = new ArrayDeque<>();`
`25`	`25`	`q.offer(new int[] {u, -1});`
	`26`	`+ int ans = inf;`
`26`	`27`	`while (!q.isEmpty()) {`
`27`	`28`	`var p = q.poll();`
`28`	`29`	`u = p[0];`
`@@ -32,10 +33,10 @@ private int bfs(int u) {`
`32`	`33`	`dist[v] = dist[u] + 1;`
`33`	`34`	`q.offer(new int[] {v, u});`
`34`	`35`	`} else if (v != fa) {`
`35`		`- return dist[u] + dist[v] + 1;`
	`36`	`+ ans = Math.min(ans, dist[u] + dist[v] + 1);`
`36`	`37`	`}`
`37`	`38`	`}`
`38`	`39`	`}`
`39`		`- return inf;`
	`40`	`+ return ans;`
`40`	`41`	`}`
`41`	`42`	`}`