feat: add solutions to lc problem: No.1579.Remove Max Number of Edges to

Keep Graph Fully Traversable

Author: yanglbme

solution/1500-1599/1579.Remove Max Number of Edges to Keep Graph Fully Traversable/README.md

@@ -59,27 +59,297 @@
 	<li>所有元组 <code>(type<sub>i</sub>, u<sub>i</sub>, v<sub>i</sub>)</code> 互不相同</li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+并查集。
+
+模板 1——朴素并查集：
+
+```python
+# 初始化，p存储每个点的父节点
+p = list(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 = list(range(n))
+size = [1] * n
+# 返回x的祖宗节点
+def find(x):
+    if p[x] != x:
+        # 路径压缩
+        p[x] = find(p[x])
+    return p[x]
+# 合并a和b所在的两个集合
+if find(a) != find(b):
+    size[find(b)] += size[find(a)]
+    p[find(a)] = find(b)
+```
+
+模板 3——维护到祖宗节点距离的并查集：
+
+```python
+# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
+p = list(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)] = distance
+```
+
+对于本题，构造两个并查集。同时操作两个并查集 ufa, ufb，优先添加 `type = 3` 的边，添加的过程中，若两点已连通，则累加多余的边 res。
+
+然后遍历 `type = 1` 的边添加到 ufa 中，而 `type = 2` 的边则添加到 ufb 中。此过程同样判断两点是否已连通，若是，则累加多余的边 res。
+
+最后判断两个并查集是否都只有一个连通分量，若是，返回 res，否则返回 -1。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class UnionFind:
+    def __init__(self, n):
+        self.p = list(range(n))
+        self.n = n
+
+    def union(self, a, b) -> bool:
+        pa, pb = self.find(a - 1), self.find(b - 1)
+        if pa == pb:
+            return False
+        self.p[pa] = pb
+        self.n -= 1
+        return True
+
+    def find(self, x) -> int:
+        if self.p[x] != x:
+            self.p[x] = self.find(self.p[x])
+        return self.p[x]
+
+class Solution:
+    def maxNumEdgesToRemove(self, n: int, edges: List[List[int]]) -> int:
+        ufa, ufb = UnionFind(n), UnionFind(n)
+        res = 0
+        for t, u, v in edges:
+            if t == 3:
+                if not ufa.union(u, v):
+                    res += 1
+                else:
+                    ufb.union(u, v)
+        for t, u, v in edges:
+            if t == 1:
+                if not ufa.union(u, v):
+                    res += 1
+            elif t == 2:
+                if not ufb.union(u, v):
+                    res += 1
+        return res if ufa.n == 1 and ufb.n == 1 else -1
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int maxNumEdgesToRemove(int n, int[][] edges) {
+        UnionFind ufa = new UnionFind(n);
+        UnionFind ufb = new UnionFind(n);
+        int res = 0;
+        for (int[] e : edges) {
+            if (e[0] == 3) {
+                if (!ufa.union(e[1], e[2])) {
+                    ++res;
+                } else {
+                    ufb.union(e[1], e[2]);
+                }
+            }
+        }
+        for (int[] e : edges) {
+            if (e[0] == 1) {
+                if (!ufa.union(e[1], e[2])) {
+                    ++res;
+                }
+            } else if (e[0] == 2) {
+                if (!ufb.union(e[1], e[2])) {
+                    ++res;
+                }
+            }
+        }
+        return ufa.n == 1 && ufb.n == 1 ? res : -1;
+    }
+}
+
+class UnionFind {
+    public int[] p;
+    public int n;
+
+    public UnionFind(int n) {
+        p = new int[n];
+        for (int i = 0; i < n; ++i) {
+            p[i] = i;
+        }
+        this.n = n;
+    }
+
+    public boolean union(int a, int b) {
+        int pa = find(a - 1), pb = find(b - 1);
+        if (pa == pb) {
+            return false;
+        }
+        p[pa] = pb;
+        --n;
+        return true;
+    }
+
+    public int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class UnionFind {
+public:
+    vector<int> p;
+    int n;
+
+    UnionFind(int _n): n(_n), p(_n) {
+        iota(p.begin(), p.end(), 0);
+    }
+
+    bool unite(int a, int b) {
+        int pa = find(a - 1), pb = find(b - 1);
+        if (pa == pb)
+            return false;
+        p[pa] = pb;
+        --n;
+        return true;
+    }
+
+    int find(int x) {
+        if (p[x] != x)
+            p[x] = find(p[x]);
+        return p[x];
+    }
+};
+
+class Solution {
+public:
+    int maxNumEdgesToRemove(int n, vector<vector<int>>& edges) {
+        UnionFind ufa(n), ufb(n);
+        int res = 0;
+        for (auto e : edges)
+        {
+            if (e[0] == 3)
+            {
+                if (!ufa.unite(e[1], e[2])) ++res;
+                else ufb.unite(e[1], e[2]);
+            }
+        }
+        for (auto e : edges)
+        {
+            if (e[0] == 1)
+            {
+                if (!ufa.unite(e[1], e[2])) ++res;
+            }
+            else if (e[0] == 2)
+            {
+                if (!ufb.unite(e[1], e[2])) ++res;
+            }
+        }
+        return ufa.n == 1 && ufb.n == 1 ? res : -1;
+    }
+};
+```
 
+### **Go**
+
+```go
+type unionFind struct {
+	p []int
+	n int
+}
+
+func newUnionFind(n int) *unionFind {
+	p := make([]int, n)
+	for i := range p {
+		p[i] = i
+	}
+	return &unionFind{p, n}
+}
+
+func (uf *unionFind) find(x int) int {
+	if uf.p[x] != x {
+		uf.p[x] = uf.find(uf.p[x])
+	}
+	return uf.p[x]
+}
+
+func (uf *unionFind) union(a, b int) bool {
+	pa, pb := uf.find(a-1), uf.find(b-1)
+	if pa == pb {
+		return false
+	}
+	uf.p[pa] = pb
+	uf.n--
+	return true
+}
+
+func maxNumEdgesToRemove(n int, edges [][]int) int {
+	ufa, ufb := newUnionFind(n), newUnionFind(n)
+	res := 0
+	for _, e := range edges {
+		if e[0] == 3 {
+			if !ufa.union(e[1], e[2]) {
+				res++
+			} else {
+				ufb.union(e[1], e[2])
+			}
+		}
+	}
+	for _, e := range edges {
+		if e[0] == 1 {
+			if !ufa.union(e[1], e[2]) {
+				res++
+			}
+		} else if e[0] == 2 {
+			if !ufb.union(e[1], e[2]) {
+				res++
+			}
+		}
+	}
+	if ufa.n == 1 && ufb.n == 1 {
+		return res
+	}
+	return -1
+}
 ```
 
 ### **...**