feat: add solutions to lc problem: No.0684. Redundant Connection

Author: yanglbme

solution/0500-0599/0547.Number of Provinces/README.md

@@ -54,7 +54,7 @@
 
 **方法一：深度优先搜索**
 
-判断学生与学生之间是否属于同一个连通分量，最后连通分量的总数即为结果。
+判断城市之间是否属于同一个连通分量，最后连通分量的总数即为结果。
 
 **方法二：并查集**
 

solution/0600-0699/0684.Redundant Connection/README.md

@@ -44,27 +44,177 @@
 <p><strong>更新(2017-09-26):</strong><br>
 我们已经重新检查了问题描述及测试用例，明确图是<em><strong>无向&nbsp;</strong></em>图。对于有向图详见<strong><a href="https://leetcodechina.com/problems/redundant-connection-ii/description/">冗余连接II</a>。</strong>对于造成任何不便，我们深感歉意。</p>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+并查集。
+
+模板 1——朴素并查集：
+
+```python
+# 初始化，p存储每个点的祖宗节点
+p = [i for i in range(n)]
+# 返回x的祖宗节点
+def find(x):
+    if p[x] != x:
+        # 路径压缩
+        p[x] = find(p[x])
+    return p[x]
+# 合并a和b所在的两个集合
+p[find(a)] = find(b)
+```
+
+模板 2——维护 size 的并查集：
+
+```python
+# 初始化，p存储每个点的祖宗节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
+p = [i for i in range(n)]
+size = [1] * n
+# 返回x的祖宗节点
+def find(x):
+    if p[x] != x:
+        # 路径压缩
+        p[x] = find(p[x])
+    return p[x]
+# 合并a和b所在的两个集合
+size[find(b)] += size[find(a)]
+p[find(a)] = find(b)
+```
+
+模板 3——维护到祖宗节点距离的并查集：
+
+```python
+# 初始化，p存储每个点的祖宗节点，d[x]存储x到p[x]的距离
+p = [i for i in range(n)]
+d = [0] * n
+# 返回x的祖宗节点
+def find(x):
+    if p[x] != x:
+        t = find(p[x])
+        d[x] += d[p[x]]
+        p[x] = t
+    return p[x]
+# 合并a和b所在的两个集合
+p[find(a)] = find(b)
+d[find(a)] = dinstance
+```
+
+对于本题，先遍历所有的边，如果边的两个节点已经属于同个集合，说明两个节点已经相连，若再将这条件加入集合中，就会出现环，因此可以直接返回这条边。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
+        p = [i for i in range(1010)]
+
+        def find(x):
+            if p[x] != x:
+                p[x] = find(p[x])
+            return p[x]
+
+        for a, b in edges:
+            if find(a) == find(b):
+                return [a, b]
+            p[find(a)] = find(b)
+        return []
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int[] p;
+
+    public int[] findRedundantConnection(int[][] edges) {
+        p = new int[1010];
+        for (int i = 0; i < p.length; ++i) {
+            p[i] = i;
+        }
+        for (int[] e : edges) {
+            if (find(e[0]) == find(e[1])) {
+                return e;
+            }
+            p[find(e[0])] = find(e[1]);
+        }
+        return null;
+    }
+
+    private int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> p;
+
+    vector<int> findRedundantConnection(vector<vector<int>> &edges) {
+        p.resize(1010);
+        for (int i = 0; i < p.size(); ++i)
+        {
+            p[i] = i;
+        }
+        for (auto e : edges)
+        {
+            if (find(e[0]) == find(e[1]))
+            {
+                return e;
+            }
+            p[find(e[0])] = find(e[1]);
+        }
+        return {};
+    }
+
+    int find(int x) {
+        if (p[x] != x)
+        {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+};
+```
 
+### **Go**
+
+```go
+var p []int
+
+func findRedundantConnection(edges [][]int) []int {
+	p = make([]int, 1010)
+	for i := 0; i < len(p); i++ {
+		p[i] = i
+	}
+	for _, e := range edges {
+		if find(e[0]) == find(e[1]) {
+			return e
+		}
+		p[find(e[0])] = find(e[1])
+	}
+	return nil
+}
+
+func find(x int) int {
+	if p[x] != x {
+		p[x] = find(p[x])
+	}
+	return p[x]
+}
 ```
 
 ### **...**

solution/0600-0699/0684.Redundant Connection/README_EN.md

@@ -10,15 +10,15 @@ In this problem, a tree is an <b>undirected</b> graph that is connected and has
 
 </p><p>
 
-The given input is a graph that started as a tree with N nodes (with distinct values 1, 2, ..., N), with one additional edge added.  The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.
+The given input is a graph that started as a tree with N nodes (with distinct values 1, 2, ..., N), with one additional edge added. The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.
 
 </p><p>
 
-The resulting graph is given as a 2D-array of <code>edges</code>.  Each element of <code>edges</code> is a pair <code>[u, v]</code> with <code>u < v</code>, that represents an <b>undirected</b> edge connecting nodes <code>u</code> and <code>v</code>.
+The resulting graph is given as a 2D-array of <code>edges</code>. Each element of <code>edges</code> is a pair <code>[u, v]</code> with <code>u < v</code>, that represents an <b>undirected</b> edge connecting nodes <code>u</code> and <code>v</code>.
 
 </p><p>
 
-Return an edge that can be removed so that the resulting graph is a tree of N nodes.  If there are multiple answers, return the answer that occurs last in the given 2D-array.  The answer edge <code>[u, v]</code> should be in the same format, with <code>u < v</code>.
+Return an edge that can be removed so that the resulting graph is a tree of N nodes. If there are multiple answers, return the answer that occurs last in the given 2D-array. The answer edge <code>[u, v]</code> should be in the same format, with <code>u < v</code>.
 
 </p><p><b>Example 1:</b><br />
 
@@ -68,12 +68,8 @@ Return an edge that can be removed so that the resulting graph is a tree of N no
 
 </p>
 
-
-
 <br />
 
-
-
 <p>
 
 <b><font color="red">Update (2017-09-26):</font></b><br>
@@ -89,13 +85,110 @@ We have overhauled the problem description + test cases and specified clearly th
 ### **Python3**
 
 ```python
-
+class Solution:
+    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
+        p = [i for i in range(1010)]
+
+        def find(x):
+            if p[x] != x:
+                p[x] = find(p[x])
+            return p[x]
+
+        for a, b in edges:
+            if find(a) == find(b):
+                return [a, b]
+            p[find(a)] = find(b)
+        return []
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    private int[] p;
+
+    public int[] findRedundantConnection(int[][] edges) {
+        p = new int[1010];
+        for (int i = 0; i < p.length; ++i) {
+            p[i] = i;
+        }
+        for (int[] e : edges) {
+            if (find(e[0]) == find(e[1])) {
+                return e;
+            }
+            p[find(e[0])] = find(e[1]);
+        }
+        return null;
+    }
+
+    private int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> p;
+
+    vector<int> findRedundantConnection(vector<vector<int>> &edges) {
+        p.resize(1010);
+        for (int i = 0; i < p.size(); ++i)
+        {
+            p[i] = i;
+        }
+        for (auto e : edges)
+        {
+            if (find(e[0]) == find(e[1]))
+            {
+                return e;
+            }
+            p[find(e[0])] = find(e[1]);
+        }
+        return {};
+    }
+
+    int find(int x) {
+        if (p[x] != x)
+        {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+};
+```
 
+### **Go**
+
+```go
+var p []int
+
+func findRedundantConnection(edges [][]int) []int {
+	p = make([]int, 1010)
+	for i := 0; i < len(p); i++ {
+		p[i] = i
+	}
+	for _, e := range edges {
+		if find(e[0]) == find(e[1]) {
+			return e
+		}
+		p[find(e[0])] = find(e[1])
+	}
+	return nil
+}
+
+func find(x int) int {
+	if p[x] != x {
+		p[x] = find(p[x])
+	}
+	return p[x]
+}
 ```
 
 ### **...**

solution/0600-0699/0684.Redundant Connection/Solution.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    vector<int> p;
+
+    vector<int> findRedundantConnection(vector<vector<int>> &edges) {
+        p.resize(1010);
+        for (int i = 0; i < p.size(); ++i)
+        {
+            p[i] = i;
+        }
+        for (auto e : edges)
+        {
+            if (find(e[0]) == find(e[1]))
+            {
+                return e;
+            }
+            p[find(e[0])] = find(e[1]);
+        }
+        return {};
+    }
+
+    int find(int x) {
+        if (p[x] != x)
+        {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+};

solution/0600-0699/0684.Redundant Connection/Solution.go

@@ -0,0 +1,22 @@
+var p []int
+
+func findRedundantConnection(edges [][]int) []int {
+	p = make([]int, 1010)
+	for i := 0; i < len(p); i++ {
+		p[i] = i
+	}
+	for _, e := range edges {
+		if find(e[0]) == find(e[1]) {
+			return e
+		}
+		p[find(e[0])] = find(e[1])
+	}
+	return nil
+}
+
+func find(x int) int {
+	if p[x] != x {
+		p[x] = find(p[x])
+	}
+	return p[x]
+}