feat: add solutions to lc problem: No.2608

No.2609.Find the Longest Balanced Substring of a Binary String

Author: yanglbme

solution/2600-2699/2608.Shortest Cycle in a Graph/README.md

@@ -45,12 +45,51 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：枚举删除的边 + BFS**
+
+我们先根据数组 $edges$ 构建出邻接表 $g$，其中 $g[u]$ 表示顶点 $u$ 的所有邻接点。
+
+接下来，我们枚举双向边 $(u, v)$，如果删除该边后，从顶点 $u$ 到顶点 $v$ 的路径依然存在，则包含该边的最短环的长度为 $dist[v] + 1$，其中 $dist[v]$ 表示从顶点 $u$ 到顶点 $v$ 的最短路径长度。我们取所有这样的环的最小值即可。
+
+时间复杂度 $O(m^2)$，空间复杂度 $O(m + n)$。其中 $m$ 和 $n$ 分别为数组 $edges$ 的长度以及顶点数。
+
+**方法二：枚举点 + BFS**
+
+与方法一类似，我们先根据数组 $edges$ 构建出邻接表 $g$，其中 $g[u]$ 表示顶点 $u$ 的所有邻接点。
+
+接下来，我们枚举顶点 $u$，如果从顶点 $u$ 出发，有两条路径都到达了顶点 $v$，说明当前找到了一个环，长度为两条路径的长度之和。我们取所有这样的环的最小值即可。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m + n)$。其中 $m$ 和 $n$ 分别为数组 $edges$ 的长度以及顶点数。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```python
+class Solution:
+    def findShortestCycle(self, n: int, edges: List[List[int]]) -> int:
+        def bfs(u: int, v: int) -> int:
+            dist = [inf] * n
+            dist[u] = 0
+            q = deque([u])
+            while q:
+                i = q.popleft()
+                for j in g[i]:
+                    if (i, j) != (u, v) and (j, i) != (u, v) and dist[j] == inf:
+                        dist[j] = dist[i] + 1
+                        q.append(j)
+            return dist[v] + 1
+
+        g = defaultdict(set)
+        for u, v in edges:
+            g[u].add(v)
+            g[v].add(u)
+        ans = min(bfs(u, v) for u, v in edges)
+        return ans if ans < inf else -1
+```
+
 ```python
 class Solution:
     def findShortestCycle(self, n: int, edges: List[List[int]]) -> int:
@@ -80,6 +119,48 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```java
+class Solution {
+    private List<Integer>[] g;
+    private final int inf = 1 << 30;
+
+    public int findShortestCycle(int n, int[][] edges) {
+        g = new List[n];
+        Arrays.setAll(g, k -> new ArrayList<>());
+        for (var e : edges) {
+            int u = e[0], v = e[1];
+            g[u].add(v);
+            g[v].add(u);
+        }
+        int ans = inf;
+        for (var e : edges) {
+            int u = e[0], v = e[1];
+            ans = Math.min(ans, bfs(u, v));
+        }
+        return ans < inf ? ans : -1;
+    }
+
+    private int bfs(int u, int v) {
+        int[] dist = new int[g.length];
+        Arrays.fill(dist, inf);
+        dist[u] = 0;
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(u);
+        while (!q.isEmpty()) {
+            int i = q.poll();
+            for (int j : g[i]) {
+                if ((i == u && j == v) || (i == v && j == u) || dist[j] != inf) {
+                    continue;
+                }
+                dist[j] = dist[i] + 1;
+                q.offer(j);
+            }
+        }
+        return dist[v] + 1;
+    }
+}
+```
+
 ```java
 class Solution {
     private List<Integer>[] g;
@@ -126,6 +207,45 @@ class Solution {
 
 ### **C++**
 
+```cpp
+class Solution {
+public:
+    int findShortestCycle(int n, vector<vector<int>>& edges) {
+        vector<vector<int>> g(n);
+        for (auto& e : edges) {
+            int u = e[0], v = e[1];
+            g[u].push_back(v);
+            g[v].push_back(u);
+        }
+        const int inf = 1 << 30;
+        auto bfs = [&](int u, int v) -> int {
+            int dist[n];
+            fill(dist, dist + n, inf);
+            dist[u] = 0;
+            queue<int> q{{u}};
+            while (!q.empty()) {
+                int i = q.front();
+                q.pop();
+                for (int j : g[i]) {
+                    if ((i == u && j == v) || (i == v && j == u) || dist[j] != inf) {
+                        continue;
+                    }
+                    dist[j] = dist[i] + 1;
+                    q.push(j);
+                }
+            }
+            return dist[v] + 1;
+        };
+        int ans = inf;
+        for (auto& e : edges) {
+            int u = e[0], v = e[1];
+            ans = min(ans, bfs(u, v));
+        }
+        return ans < inf ? ans : -1;
+    }
+};
+```
+
 ```cpp
 class Solution {
 public:
@@ -170,6 +290,54 @@ public:
 
 ### **Go**
 
+```go
+func findShortestCycle(n int, edges [][]int) int {
+	g := make([][]int, n)
+	for _, e := range edges {
+		u, v := e[0], e[1]
+		g[u] = append(g[u], v)
+		g[v] = append(g[v], u)
+	}
+	const inf = 1 << 30
+	bfs := func(u, v int) int {
+		dist := make([]int, n)
+		for i := range dist {
+			dist[i] = inf
+		}
+		dist[u] = 0
+		q := []int{u}
+		for len(q) > 0 {
+			i := q[0]
+			q = q[1:]
+			for _, j := range g[i] {
+				if (i == u && j == v) || (i == v && j == u) || dist[j] != inf {
+					continue
+				}
+				dist[j] = dist[i] + 1
+				q = append(q, j)
+			}
+		}
+		return dist[v] + 1
+	}
+	ans := inf
+	for _, e := range edges {
+		u, v := e[0], e[1]
+		ans = min(ans, bfs(u, v))
+	}
+	if ans < inf {
+		return ans
+	}
+	return -1
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
+
 ```go
 func findShortestCycle(n int, edges [][]int) int {
 	g := make([][]int, n)
@@ -222,6 +390,42 @@ func min(a, b int) int {
 
 ### **TypeScript**
 
+```ts
+function findShortestCycle(n: number, edges: number[][]): number {
+    const g: number[][] = new Array(n).fill(0).map(() => []);
+    for (const [u, v] of edges) {
+        g[u].push(v);
+        g[v].push(u);
+    }
+    const inf = 1 << 30;
+    let ans = inf;
+    const bfs = (u: number, v: number) => {
+        const dist: number[] = new Array(n).fill(inf);
+        dist[u] = 0;
+        const q: number[] = [u];
+        while (q.length) {
+            const i = q.shift()!;
+            for (const j of g[i]) {
+                if (
+                    (i == u && j == v) ||
+                    (i == v && j == u) ||
+                    dist[j] != inf
+                ) {
+                    continue;
+                }
+                dist[j] = dist[i] + 1;
+                q.push(j);
+            }
+        }
+        return 1 + dist[v];
+    };
+    for (const [u, v] of edges) {
+        ans = Math.min(ans, bfs(u, v));
+    }
+    return ans < inf ? ans : -1;
+}
+```
+
 ```ts
 function findShortestCycle(n: number, edges: number[][]): number {
     const g: number[][] = new Array(n).fill(0).map(() => []);