diff --git a/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/README.md b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/README.md
index d9f202d34e672..72242597cbaec 100644
--- a/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/README.md
+++ b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/README.md
@@ -67,6 +67,24 @@
<!-- 这里可写通用的实现逻辑 -->
+**方法一：拓扑排序**
+
+我们可以先将 $edges$ 中的边转换成邻接表 $g$，其中 $g[i]$ 表示节点 $i$ 的所有邻接节点，用集合表示。
+
+接下来，我们由外向内，逐层删除节点，直到最终只剩下一个环。具体做法如下：
+
+我们先找出所有度为 $1$ 的节点，将这些节点从图中删除，如果删除后，其邻接节点的度变为 $1$，则将其加入队列 $q$ 中。过程中，我们按顺序记录下所有被删除的节点，记为 $seq$；并且，我们用一个数组 $f$ 记录每个节点相邻的且更接近环的节点，即 $f[i]$ 表示节点 $i$ 的相邻且更接近环的节点。
+
+最后，我们初始化一个长度为 $n$ 的答案数组 $ans$，其中 $ans[i]$ 表示节点 $i$ 到环中任意节点的最小距离，初始时 $ans[i] = 0$。然后，我们从 $seq$ 的末尾开始遍历，对于每个节点 $i$，我们可以由它的相邻节点 $f[i]$ 得到 $ans[i]$ 的值，即 $ans[i] = ans[f[i]] + 1$。
+
+遍历结束后，返回答案数组 $ans$ 即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点数。
+
+相似题目：
+
+- [2603. 收集树中金币](/solution/2600-2699/2603.Collect%20Coins%20in%20a%20Tree/README.md)
+
<!-- tabs:start -->
### **Python3**
@@ -74,7 +92,28 @@
<!-- 这里可写当前语言的特殊实现逻辑 -->
```python
-
+class Solution:
+ def distanceToCycle(self, n: int, edges: List[List[int]]) -> List[int]:
+ g = defaultdict(set)
+ for a, b in edges:
+ g[a].add(b)
+ g[b].add(a)
+ q = deque(i for i in range(n) if len(g[i]) == 1)
+ f = [0] * n
+ seq = []
+ while q:
+ i = q.popleft()
+ seq.append(i)
+ for j in g[i]:
+ g[j].remove(i)
+ f[i] = j
+ if len(g[j]) == 1:
+ q.append(j)
+ g[i].clear()
+ ans = [0] * n
+ for i in seq[::-1]:
+ ans[i] = ans[f[i]] + 1
+ return ans
```
### **Java**
@@ -82,13 +121,167 @@
<!-- 这里可写当前语言的特殊实现逻辑 -->
```java
+class Solution {
+ public int[] distanceToCycle(int n, int[][] edges) {
+ Set<Integer>[] g = new Set[n];
+ Arrays.setAll(g, k -> new HashSet<>());
+ for (var e : edges) {
+ int a = e[0], b = e[1];
+ g[a].add(b);
+ g[b].add(a);
+ }
+ Deque<Integer> q = new ArrayDeque<>();
+ for (int i = 0; i < n; ++i) {
+ if (g[i].size() == 1) {
+ q.offer(i);
+ }
+ }
+ int[] f = new int[n];
+ Deque<Integer> seq = new ArrayDeque<>();
+ while (!q.isEmpty()) {
+ int i = q.poll();
+ seq.push(i);
+ for (int j : g[i]) {
+ g[j].remove(i);
+ f[i] = j;
+ if (g[j].size() == 1) {
+ q.offer(j);
+ }
+ }
+ }
+ int[] ans = new int[n];
+ while (!seq.isEmpty()) {
+ int i = seq.pop();
+ ans[i] = ans[f[i]] + 1;
+ }
+ return ans;
+ }
+}
+```
+
+### **C++**
+```cpp
+class Solution {
+public:
+ vector<int> distanceToCycle(int n, vector<vector<int>>& edges) {
+ unordered_set<int> g[n];
+ for (auto& e : edges) {
+ int a = e[0], b = e[1];
+ g[a].insert(b);
+ g[b].insert(a);
+ }
+ queue<int> q;
+ for (int i = 0; i < n; ++i) {
+ if (g[i].size() == 1) {
+ q.push(i);
+ }
+ }
+ int f[n];
+ int seq[n];
+ int k = 0;
+ while (!q.empty()) {
+ int i = q.front();
+ q.pop();
+ seq[k++] = i;
+ for (int j : g[i]) {
+ g[j].erase(i);
+ f[i] = j;
+ if (g[j].size() == 1) {
+ q.push(j);
+ }
+ }
+ g[i].clear();
+ }
+ vector<int> ans(n);
+ for (; k; --k) {
+ int i = seq[k - 1];
+ ans[i] = ans[f[i]] + 1;
+ }
+ return ans;
+ }
+};
+```
+
+### **Go**
+
+```go
+func distanceToCycle(n int, edges [][]int) []int {
+ g := make([]map[int]bool, n)
+ for i := range g {
+ g[i] = map[int]bool{}
+ }
+ for _, e := range edges {
+ a, b := e[0], e[1]
+ g[a][b] = true
+ g[b][a] = true
+ }
+ q := []int{}
+ for i := 0; i < n; i++ {
+ if len(g[i]) == 1 {
+ q = append(q, i)
+ }
+ }
+ f := make([]int, n)
+ seq := []int{}
+ for len(q) > 0 {
+ i := q[0]
+ q = q[1:]
+ seq = append(seq, i)
+ for j := range g[i] {
+ delete(g[j], i)
+ f[i] = j
+ if len(g[j]) == 1 {
+ q = append(q, j)
+ }
+ }
+ g[i] = map[int]bool{}
+ }
+ ans := make([]int, n)
+ for k := len(seq) - 1; k >= 0; k-- {
+ i := seq[k]
+ ans[i] = ans[f[i]] + 1
+ }
+ return ans
+}
```
### **TypeScript**
```ts
-
+function distanceToCycle(n: number, edges: number[][]): number[] {
+ const g: Set<number>[] = new Array(n).fill(0).map(() => new Set<number>());
+ for (const [a, b] of edges) {
+ g[a].add(b);
+ g[b].add(a);
+ }
+ const q: number[] = [];
+ for (let i = 0; i < n; ++i) {
+ if (g[i].size === 1) {
+ q.push(i);
+ }
+ }
+ const f: number[] = Array(n).fill(0);
+ const seq: number[] = [];
+ while (q.length) {
+ const i = q.pop()!;
+ seq.push(i);
+ for (const j of g[i]) {
+ g[j].delete(i);
+ f[i] = j;
+ if (g[j].size === 1) {
+ q.push(j);
+ }
+ }
+ g[i].clear();
+ }
+ const ans: number[] = Array(n).fill(0);
+ while (seq.length) {
+ const i = seq.pop()!;
+ ans[i] = ans[f[i]] + 1;
+ }
+ return ans;
+}
```
### **...**
diff --git a/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/README_EN.md b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/README_EN.md
index f9156978d69b9..692491ea38914 100644
--- a/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/README_EN.md
+++ b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/README_EN.md
@@ -63,24 +63,217 @@ The distance from 8 to 2 is 2.
## Solutions
+**Solution 1: Topological Sorting**
+
+We can first convert the edges in $edges$ into an adjacency list $g$, where $g[i]$ represents all adjacent nodes of node $i$, represented as a set.
+
+Next, we delete nodes layer by layer from the outside to the inside until only a cycle remains. The specific method is as follows:
+
+We first find all nodes with a degree of $1$ and remove these nodes from the graph. If after deletion, the degree of its adjacent node becomes $1$, then we add it to the queue $q$. During this process, we record all deleted nodes in order as $seq$; and we use an array $f$ to record the adjacent node of each node that is closer to the cycle, i.e., $f[i]$ represents the adjacent node of node $i$ that is closer to the cycle.
+
+Finally, we initialize an answer array $ans$ of length $n$, where $ans[i]$ represents the minimum distance from node $i$ to any node in the cycle, initially $ans[i] = 0$. Then, we start traversing from the end of $seq$. For each node $i$, we can get the value of $ans[i]$ from its adjacent node $f[i]$, i.e., $ans[i] = ans[f[i]] + 1$.
+
+After the traversal, return the answer array $ans$.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the number of nodes.
+
+Similar problems:
+
+- [2603. Collect Coins in a Tree](/solution/2600-2699/2603.Collect%20Coins%20in%20a%20Tree/README_EN.md)
+
<!-- tabs:start -->
### **Python3**
```python
-
+class Solution:
+ def distanceToCycle(self, n: int, edges: List[List[int]]) -> List[int]:
+ g = defaultdict(set)
+ for a, b in edges:
+ g[a].add(b)
+ g[b].add(a)
+ q = deque(i for i in range(n) if len(g[i]) == 1)
+ f = [0] * n
+ seq = []
+ while q:
+ i = q.popleft()
+ seq.append(i)
+ for j in g[i]:
+ g[j].remove(i)
+ f[i] = j
+ if len(g[j]) == 1:
+ q.append(j)
+ g[i].clear()
+ ans = [0] * n
+ for i in seq[::-1]:
+ ans[i] = ans[f[i]] + 1
+ return ans
```
### **Java**
```java
+class Solution {
+ public int[] distanceToCycle(int n, int[][] edges) {
+ Set<Integer>[] g = new Set[n];
+ Arrays.setAll(g, k -> new HashSet<>());
+ for (var e : edges) {
+ int a = e[0], b = e[1];
+ g[a].add(b);
+ g[b].add(a);
+ }
+ Deque<Integer> q = new ArrayDeque<>();
+ for (int i = 0; i < n; ++i) {
+ if (g[i].size() == 1) {
+ q.offer(i);
+ }
+ }
+ int[] f = new int[n];
+ Deque<Integer> seq = new ArrayDeque<>();
+ while (!q.isEmpty()) {
+ int i = q.poll();
+ seq.push(i);
+ for (int j : g[i]) {
+ g[j].remove(i);
+ f[i] = j;
+ if (g[j].size() == 1) {
+ q.offer(j);
+ }
+ }
+ }
+ int[] ans = new int[n];
+ while (!seq.isEmpty()) {
+ int i = seq.pop();
+ ans[i] = ans[f[i]] + 1;
+ }
+ return ans;
+ }
+}
+```
+
+### **C++**
+```cpp
+class Solution {
+public:
+ vector<int> distanceToCycle(int n, vector<vector<int>>& edges) {
+ unordered_set<int> g[n];
+ for (auto& e : edges) {
+ int a = e[0], b = e[1];
+ g[a].insert(b);
+ g[b].insert(a);
+ }
+ queue<int> q;
+ for (int i = 0; i < n; ++i) {
+ if (g[i].size() == 1) {
+ q.push(i);
+ }
+ }
+ int f[n];
+ int seq[n];
+ int k = 0;
+ while (!q.empty()) {
+ int i = q.front();
+ q.pop();
+ seq[k++] = i;
+ for (int j : g[i]) {
+ g[j].erase(i);
+ f[i] = j;
+ if (g[j].size() == 1) {
+ q.push(j);
+ }
+ }
+ g[i].clear();
+ }
+ vector<int> ans(n);
+ for (; k; --k) {
+ int i = seq[k - 1];
+ ans[i] = ans[f[i]] + 1;
+ }
+ return ans;
+ }
+};
+```
+
+### **Go**
+
+```go
+func distanceToCycle(n int, edges [][]int) []int {
+ g := make([]map[int]bool, n)
+ for i := range g {
+ g[i] = map[int]bool{}
+ }
+ for _, e := range edges {
+ a, b := e[0], e[1]
+ g[a][b] = true
+ g[b][a] = true
+ }
+ q := []int{}
+ for i := 0; i < n; i++ {
+ if len(g[i]) == 1 {
+ q = append(q, i)
+ }
+ }
+ f := make([]int, n)
+ seq := []int{}
+ for len(q) > 0 {
+ i := q[0]
+ q = q[1:]
+ seq = append(seq, i)
+ for j := range g[i] {
+ delete(g[j], i)
+ f[i] = j
+ if len(g[j]) == 1 {
+ q = append(q, j)
+ }
+ }
+ g[i] = map[int]bool{}
+ }
+ ans := make([]int, n)
+ for k := len(seq) - 1; k >= 0; k-- {
+ i := seq[k]
+ ans[i] = ans[f[i]] + 1
+ }
+ return ans
+}
```
### **TypeScript**
```ts
-
+function distanceToCycle(n: number, edges: number[][]): number[] {
+ const g: Set<number>[] = new Array(n).fill(0).map(() => new Set<number>());
+ for (const [a, b] of edges) {
+ g[a].add(b);
+ g[b].add(a);
+ }
+ const q: number[] = [];
+ for (let i = 0; i < n; ++i) {
+ if (g[i].size === 1) {
+ q.push(i);
+ }
+ }
+ const f: number[] = Array(n).fill(0);
+ const seq: number[] = [];
+ while (q.length) {
+ const i = q.pop()!;
+ seq.push(i);
+ for (const j of g[i]) {
+ g[j].delete(i);
+ f[i] = j;
+ if (g[j].size === 1) {
+ q.push(j);
+ }
+ }
+ g[i].clear();
+ }
+ const ans: number[] = Array(n).fill(0);
+ while (seq.length) {
+ const i = seq.pop()!;
+ ans[i] = ans[f[i]] + 1;
+ }
+ return ans;
+}
```
### **...**
diff --git a/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.cpp b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.cpp
new file mode 100644
index 0000000000000..839bb94b7ddc8
--- /dev/null
+++ b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.cpp
@@ -0,0 +1,39 @@
+class Solution {
+public:
+ vector<int> distanceToCycle(int n, vector<vector<int>>& edges) {
+ unordered_set<int> g[n];
+ for (auto& e : edges) {
+ int a = e[0], b = e[1];
+ g[a].insert(b);
+ g[b].insert(a);
+ }
+ queue<int> q;
+ for (int i = 0; i < n; ++i) {
+ if (g[i].size() == 1) {
+ q.push(i);
+ }
+ }
+ int f[n];
+ int seq[n];
+ int k = 0;
+ while (!q.empty()) {
+ int i = q.front();
+ q.pop();
+ seq[k++] = i;
+ for (int j : g[i]) {
+ g[j].erase(i);
+ f[i] = j;
+ if (g[j].size() == 1) {
+ q.push(j);
+ }
+ }
+ g[i].clear();
+ }
+ vector<int> ans(n);
+ for (; k; --k) {
+ int i = seq[k - 1];
+ ans[i] = ans[f[i]] + 1;
+ }
+ return ans;
+ }
+};
\ No newline at end of file
diff --git a/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.go b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.go
new file mode 100644
index 0000000000000..4aba610315b42
--- /dev/null
+++ b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.go
@@ -0,0 +1,38 @@
+func distanceToCycle(n int, edges [][]int) []int {
+ g := make([]map[int]bool, n)
+ for i := range g {
+ g[i] = map[int]bool{}
+ }
+ for _, e := range edges {
+ a, b := e[0], e[1]
+ g[a][b] = true
+ g[b][a] = true
+ }
+ q := []int{}
+ for i := 0; i < n; i++ {
+ if len(g[i]) == 1 {
+ q = append(q, i)
+ }
+ }
+ f := make([]int, n)
+ seq := []int{}
+ for len(q) > 0 {
+ i := q[0]
+ q = q[1:]
+ seq = append(seq, i)
+ for j := range g[i] {
+ delete(g[j], i)
+ f[i] = j
+ if len(g[j]) == 1 {
+ q = append(q, j)
+ }
+ }
+ g[i] = map[int]bool{}
+ }
+ ans := make([]int, n)
+ for k := len(seq) - 1; k >= 0; k-- {
+ i := seq[k]
+ ans[i] = ans[f[i]] + 1
+ }
+ return ans
+}
\ No newline at end of file
diff --git a/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.java b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.java
new file mode 100644
index 0000000000000..72b963fb175ba
--- /dev/null
+++ b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.java
@@ -0,0 +1,36 @@
+class Solution {
+ public int[] distanceToCycle(int n, int[][] edges) {
+ Set<Integer>[] g = new Set[n];
+ Arrays.setAll(g, k -> new HashSet<>());
+ for (var e : edges) {
+ int a = e[0], b = e[1];
+ g[a].add(b);
+ g[b].add(a);
+ }
+ Deque<Integer> q = new ArrayDeque<>();
+ for (int i = 0; i < n; ++i) {
+ if (g[i].size() == 1) {
+ q.offer(i);
+ }
+ }
+ int[] f = new int[n];
+ Deque<Integer> seq = new ArrayDeque<>();
+ while (!q.isEmpty()) {
+ int i = q.poll();
+ seq.push(i);
+ for (int j : g[i]) {
+ g[j].remove(i);
+ f[i] = j;
+ if (g[j].size() == 1) {
+ q.offer(j);
+ }
+ }
+ }
+ int[] ans = new int[n];
+ while (!seq.isEmpty()) {
+ int i = seq.pop();
+ ans[i] = ans[f[i]] + 1;
+ }
+ return ans;
+ }
+}
\ No newline at end of file
diff --git a/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.py b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.py
new file mode 100644
index 0000000000000..55596d07f9d45
--- /dev/null
+++ b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.py
@@ -0,0 +1,22 @@
+class Solution:
+ def distanceToCycle(self, n: int, edges: List[List[int]]) -> List[int]:
+ g = defaultdict(set)
+ for a, b in edges:
+ g[a].add(b)
+ g[b].add(a)
+ q = deque(i for i in range(n) if len(g[i]) == 1)
+ f = [0] * n
+ seq = []
+ while q:
+ i = q.popleft()
+ seq.append(i)
+ for j in g[i]:
+ g[j].remove(i)
+ f[i] = j
+ if len(g[j]) == 1:
+ q.append(j)
+ g[i].clear()
+ ans = [0] * n
+ for i in seq[::-1]:
+ ans[i] = ans[f[i]] + 1
+ return ans
diff --git a/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.ts b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.ts
new file mode 100644
index 0000000000000..3767854bcf2d3
--- /dev/null
+++ b/solution/2200-2299/2204.Distance to a Cycle in Undirected Graph/Solution.ts
@@ -0,0 +1,33 @@
+function distanceToCycle(n: number, edges: number[][]): number[] {
+ const g: Set<number>[] = new Array(n).fill(0).map(() => new Set<number>());
+ for (const [a, b] of edges) {
+ g[a].add(b);
+ g[b].add(a);
+ }
+ const q: number[] = [];
+ for (let i = 0; i < n; ++i) {
+ if (g[i].size === 1) {
+ q.push(i);
+ }
+ }
+ const f: number[] = Array(n).fill(0);
+ const seq: number[] = [];
+ while (q.length) {
+ const i = q.pop()!;
+ seq.push(i);
+ for (const j of g[i]) {
+ g[j].delete(i);
+ f[i] = j;
+ if (g[j].size === 1) {
+ q.push(j);
+ }
+ }
+ g[i].clear();
+ }
+ const ans: number[] = Array(n).fill(0);
+ while (seq.length) {
+ const i = seq.pop()!;
+ ans[i] = ans[f[i]] + 1;
+ }
+ return ans;
+}
diff --git a/solution/2600-2699/2603.Collect Coins in a Tree/README.md b/solution/2600-2699/2603.Collect Coins in a Tree/README.md
index 241897dba4506..836fbaf2c3162 100644
--- a/solution/2600-2699/2603.Collect Coins in a Tree/README.md
+++ b/solution/2600-2699/2603.Collect Coins in a Tree/README.md
@@ -72,6 +72,10 @@
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点数。
+相似题目：
+
+- [2204. 无向图中到环的距离](/solution/2200-2299/2204.Distance%20to%20a%20Cycle%20in%20Undirected%20Graph/README.md)
+
<!-- tabs:start -->
### **Python3**
diff --git a/solution/2600-2699/2603.Collect Coins in a Tree/README_EN.md b/solution/2600-2699/2603.Collect Coins in a Tree/README_EN.md
index caddc56bb8852..6873c465c2bca 100644
--- a/solution/2600-2699/2603.Collect Coins in a Tree/README_EN.md
+++ b/solution/2600-2699/2603.Collect Coins in a Tree/README_EN.md
@@ -62,7 +62,11 @@ After the above operation, we get a new tree, and the leaf nodes of the tree are
Then, we delete the remaining two layers of leaf nodes, and finally get a tree where all nodes need to be visited. We only need to count the number of edges and multiply it by $2$ to get the answer.
-The time complexity is $O(n)$ and the space complexity is $O(n)$, where $n$ is the number of nodes
+The time complexity is $O(n)$ and the space complexity is $O(n)$, where $n$ is the number of nodes.
+
+Similar problems:
+
+- [2204. Distance to a Cycle in Undirected Graph](/solution/2200-2299/2204.Distance%20to%20a%20Cycle%20in%20Undirected%20Graph/README_EN.md)
<!-- tabs:start -->