feat: add solutions to lc problem: No.1579

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

@@ -63,66 +63,19 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-并查集。对于本题，构造两个并查集。同时操作两个并查集 ufa, ufb，遵从优先添加公共边的策略，即：优先添加 `type = 3` 的边。添加的过程中，若两点已连通，则累加多余的边 ans。
+**方法一：贪心 + 并查集**
 
-然后遍历 `type = 1` 的边添加到 ufa 中，而 `type = 2` 的边则添加到 ufb 中。此过程同样判断两点是否已连通，若是，则累加多余的边 ans。
+题目要求我们删除最多数目的边，使得 Alice 和 Bob 都可以遍历整个图。也即是说，我们需要保留尽可能少的边，并且要求这些边能够使得 Alice 和 Bob 都可以遍历整个图。
 
-最后判断两个并查集是否都只有一个连通分量，若是，返回 ans，否则返回 -1。
+我们可以用两个并查集 $ufa$ 和 $ufb$ 分别维护 Alice 和 Bob 的遍历情况。
 
-以下是并查集的几个常用模板。
+接下来，我们优先遍历公共边，即 $type=3$ 的边。对于每一条公共边的两个端点 $u$ 和 $v$，如果这两个点已经在同一个连通分量中，那么我们就可以删去这条边，因此答案加一；否则我们就将这两个点合并，即执行 $ufa.union(u, v)$ 和 $ufb.union(u, v)$。
 
-模板 1——朴素并查集：
+然后，我们再遍历 Alice 独有的边，即 $type=1$ 的边。对于每一条 Alice 独有的边的两个端点 $u$ 和 $v$，如果这两个点已经在同一个连通分量中，那么我们就可以删去这条边，答案加一；否则我们就将这两个点合并，即执行 $ufa.union(u, v)$。同理，对于 Bob 独有的边，我们也可以执行相同的操作。
 
-```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)
-```
+最后，如果 Alice 和 Bob 都可以遍历整个图，那么答案就是我们删除的边数；否则答案就是 $-1$。
 
-模板 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
-```
+时间复杂度 $O(m \times \alpha(n))$，空间复杂度 $O(n)$。其中 $m$ 是边数，而 $\alpha(n)$ 是阿克曼函数的反函数。
 
 <!-- tabs:start -->
 
@@ -134,93 +87,116 @@ d[find(a)] = distance
 class UnionFind:
     def __init__(self, n):
         self.p = list(range(n))
-        self.n = n
+        self.size = [1] * n
+        self.cnt = n
+
+    def find(self, x):
+        if self.p[x] != x:
+            self.p[x] = self.find(self.p[x])
+        return self.p[x]
 
     def union(self, a, b):
         pa, pb = self.find(a - 1), self.find(b - 1)
         if pa == pb:
             return False
-        self.p[pa] = pb
-        self.n -= 1
+        if self.size[pa] > self.size[pb]:
+            self.p[pb] = pa
+            self.size[pa] += self.size[pb]
+        else:
+            self.p[pa] = pb
+            self.size[pb] += self.size[pa]
+        self.cnt -= 1
         return True
 
-    def find(self, x):
-        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)
+        ufa = UnionFind(n)
+        ufb = UnionFind(n)
         ans = 0
         for t, u, v in edges:
             if t == 3:
                 if ufa.union(u, v):
                     ufb.union(u, v)
                 else:
                     ans += 1
-        ans += sum((t == 1 and not ufa.union(u, v))
-                   or (t == 2 and not ufb.union(u, v)) for t, u, v in edges)
-        return ans if ufa.n == 1 and ufb.n == 1 else -1
+        for t, u, v in edges:
+            if t == 1:
+                ans += not ufa.union(u, v)
+            if t == 2:
+                ans += not ufb.union(u, v)
+        return ans if ufa.cnt == 1 and ufb.cnt == 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 ans = 0;
-        for (int[] e : edges) {
-            if (e[0] == 3) {
-                if (ufa.union(e[1], e[2])) {
-                    ufb.union(e[1], e[2]);
-                } else {
-                    ++ans;
-                }
-            }
-        }
-        for (int[] e : edges) {
-            if ((e[0] == 1 && !ufa.union(e[1], e[2])) || (e[0] == 2 && !ufb.union(e[1], e[2]))) {
-                ++ans;
-            }
-        }
-        return ufa.n == 1 && ufb.n == 1 ? ans : -1;
-    }
-}
-
 class UnionFind {
-    public int[] p;
-    public int n;
+    private int[] p;
+    private int[] size;
+    public int cnt;
 
     public UnionFind(int n) {
         p = new int[n];
+        size = new int[n];
         for (int i = 0; i < n; ++i) {
             p[i] = i;
+            size[i] = 1;
+        }
+        cnt = n;
+    }
+
+    public int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
         }
-        this.n = n;
+        return p[x];
     }
 
     public boolean union(int a, int b) {
-        int pa = find(a - 1);
-        int pb = find(b - 1);
+        int pa = find(a - 1), pb = find(b - 1);
         if (pa == pb) {
             return false;
         }
-        p[pa] = pb;
-        --n;
+        if (size[pa] > size[pb]) {
+            p[pb] = pa;
+            size[pa] += size[pb];
+        } else {
+            p[pa] = pb;
+            size[pb] += size[pa];
+        }
+        --cnt;
         return true;
     }
+}
 
-    public int find(int x) {
-        if (p[x] != x) {
-            p[x] = find(p[x]);
+class Solution {
+    public int maxNumEdgesToRemove(int n, int[][] edges) {
+        UnionFind ufa = new UnionFind(n);
+        UnionFind ufb = new UnionFind(n);
+        int ans = 0;
+        for (var e : edges) {
+            int t = e[0], u = e[1], v = e[2];
+            if (t == 3) {
+                if (ufa.union(u, v)) {
+                    ufb.union(u, v);
+                } else {
+                    ++ans;
+                }
+            }
         }
-        return p[x];
+        for (var e : edges) {
+            int t = e[0], u = e[1], v = e[2];
+            if (t == 1 && !ufa.union(u, v)) {
+                ++ans;
+            }
+            if (t == 2 && !ufb.union(u, v)) {
+                ++ans;
+            }
+        }
+        return ufa.cnt == 1 && ufb.cnt == 1 ? ans : -1;
     }
 }
 ```
@@ -230,46 +206,64 @@ class UnionFind {
 ```cpp
 class UnionFind {
 public:
-    vector<int> p;
-    int n;
+    int cnt;
 
-    UnionFind(int _n)
-        : n(_n)
-        , p(_n) {
+    UnionFind(int n) {
+        p = vector<int>(n);
+        size = vector<int>(n, 1);
         iota(p.begin(), p.end(), 0);
+        cnt = n;
     }
 
     bool unite(int a, int b) {
         int pa = find(a - 1), pb = find(b - 1);
-        if (pa == pb) return false;
-        p[pa] = pb;
-        --n;
+        if (pa == pb) {
+            return false;
+        }
+        if (size[pa] > size[pb]) {
+            p[pb] = pa;
+            size[pa] += size[pb];
+        } else {
+            p[pa] = pb;
+            size[pb] += size[pa];
+        }
+        --cnt;
         return true;
     }
 
     int find(int x) {
-        if (p[x] != x) p[x] = find(p[x]);
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
         return p[x];
     }
+
+private:
+    vector<int> p, size;
 };
 
 class Solution {
 public:
     int maxNumEdgesToRemove(int n, vector<vector<int>>& edges) {
-        UnionFind ufa(n), ufb(n);
+        UnionFind ufa(n);
+        UnionFind ufb(n);
         int ans = 0;
         for (auto& e : edges) {
-            if (e[0] == 3) {
-                if (ufa.unite(e[1], e[2]))
-                    ufb.unite(e[1], e[2]);
-                else
+            int t = e[0], u = e[1], v = e[2];
+            if (t == 3) {
+                if (ufa.unite(u, v)) {
+                    ufb.unite(u, v);
+                } else {
                     ++ans;
+                }
             }
         }
-        for (auto& e : edges)
-            if ((e[0] == 1 && !ufa.unite(e[1], e[2])) || (e[0] == 2 && !ufb.unite(e[1], e[2])))
-                ++ans;
-        return ufa.n == 1 && ufb.n == 1 ? ans : -1;
+        for (auto& e : edges) {
+            int t = e[0], u = e[1], v = e[2];
+            ans += t == 1 && !ufa.unite(u, v);
+            ans += t == 2 && !ufb.unite(u, v);
+        }
+        return ufa.cnt == 1 && ufb.cnt == 1 ? ans : -1;
     }
 };
 ```
@@ -278,16 +272,18 @@ public:
 
 ```go
 type unionFind struct {
-	p []int
-	n int
+	p, size []int
+	cnt     int
 }
 
 func newUnionFind(n int) *unionFind {
 	p := make([]int, n)
+	size := make([]int, n)
 	for i := range p {
 		p[i] = i
+		size[i] = 1
 	}
-	return &unionFind{p, n}
+	return &unionFind{p, size, n}
 }
 
 func (uf *unionFind) find(x int) int {
@@ -302,30 +298,41 @@ func (uf *unionFind) union(a, b int) bool {
 	if pa == pb {
 		return false
 	}
-	uf.p[pa] = pb
-	uf.n--
+	if uf.size[pa] > uf.size[pb] {
+		uf.p[pb] = pa
+		uf.size[pa] += uf.size[pb]
+	} else {
+		uf.p[pa] = pb
+		uf.size[pb] += uf.size[pa]
+	}
+	uf.cnt--
 	return true
 }
 
-func maxNumEdgesToRemove(n int, edges [][]int) int {
-	ufa, ufb := newUnionFind(n), newUnionFind(n)
-	ans := 0
+func maxNumEdgesToRemove(n int, edges [][]int) (ans int) {
+	ufa := newUnionFind(n)
+	ufb := newUnionFind(n)
 	for _, e := range edges {
-		if e[0] == 3 {
-			if ufa.union(e[1], e[2]) {
-				ufb.union(e[1], e[2])
+		t, u, v := e[0], e[1], e[2]
+		if t == 3 {
+			if ufa.union(u, v) {
+				ufb.union(u, v)
 			} else {
 				ans++
 			}
 		}
 	}
 	for _, e := range edges {
-		if (e[0] == 1 && !ufa.union(e[1], e[2])) || (e[0] == 2 && !ufb.union(e[1], e[2])) {
+		t, u, v := e[0], e[1], e[2]
+		if t == 1 && !ufa.union(u, v) {
+			ans++
+		}
+		if t == 2 && !ufb.union(u, v) {
 			ans++
 		}
 	}
-	if ufa.n == 1 && ufb.n == 1 {
-		return ans
+	if ufa.cnt == 1 && ufb.cnt == 1 {
+		return
 	}
 	return -1
 }