feat: add solutions to lc problem: No.0684

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

@@ -1,20 +1,19 @@
 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) {
-            int a = e[0], b = e[1];
-            if (find(a) == find(b)) return e;
-            p[find(a)] = find(b);
+        int n = edges.size();
+        vector<int> p(n);
+        iota(p.begin(), p.end(), 0);
+        function<int(int)> find = [&](int x) {
+            return x == p[x] ? x : p[x] = find(p[x]);
+        };
+        for (int i = 0;; ++i) {
+            int pa = find(edges[i][0] - 1);
+            int pb = find(edges[i][1] - 1);
+            if (pa == pb) {
+                return edges[i];
+            }
+            p[pa] = pb;
         }
-        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

@@ -1,21 +1,21 @@
 func findRedundantConnection(edges [][]int) []int {
-	p := make([]int, 1010)
+	n := len(edges)
+	p := make([]int, n)
 	for i := range p {
 		p[i] = i
 	}
-	var find func(x int) int
+	var find func(int) int
 	find = func(x int) int {
 		if p[x] != x {
 			p[x] = find(p[x])
 		}
 		return p[x]
 	}
-	for _, e := range edges {
-		a, b := e[0], e[1]
-		if find(a) == find(b) {
-			return e
+	for i := 0; ; i++ {
+		pa, pb := find(edges[i][0]-1), find(edges[i][1]-1)
+		if pa == pb {
+			return edges[i]
 		}
-		p[find(a)] = find(b)
+		p[pa] = pb
 	}
-	return []int{}
-}
+}

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

@@ -2,18 +2,19 @@ class Solution {
     private int[] p;
 
     public int[] findRedundantConnection(int[][] edges) {
-        p = new int[1010];
-        for (int i = 0; i < p.length; ++i) {
+        int n = edges.length;
+        p = new int[n];
+        for (int i = 0; i < n; ++i) {
             p[i] = i;
         }
-        for (int[] e : edges) {
-            int a = e[0], b = e[1];
-            if (find(a) == find(b)) {
-                return e;
+        for (int i = 0;; ++i) {
+            int pa = find(edges[i][0] - 1);
+            int pb = find(edges[i][1] - 1);
+            if (pa == pb) {
+                return edges[i];
             }
-            p[find(a)] = find(b);
+            p[pa] = pb;
         }
-        return null;
     }
 
     private int find(int x) {
@@ -22,4 +23,4 @@ private int find(int x) {
         }
         return p[x];
     }
-}
+}

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

@@ -3,18 +3,20 @@
  * @return {number[]}
  */
 var findRedundantConnection = function (edges) {
-    let p = Array.from({ length: 1010 }, (_, i) => i);
-    function find(x) {
-        if (p[x] != x) {
+    const n = edges.length;
+    const p = Array.from({ length: n }, (_, i) => i);
+    const find = x => {
+        if (p[x] !== x) {
             p[x] = find(p[x]);
         }
         return p[x];
-    }
-    for (let [a, b] of edges) {
-        if (find(a) == find(b)) {
-            return [a, b];
+    };
+    for (let i = 0; ; ++i) {
+        const pa = find(edges[i][0] - 1);
+        const pb = find(edges[i][1] - 1);
+        if (pa === pb) {
+            return edges[i];
         }
-        p[find(a)] = find(b);
+        p[pa] = pb;
     }
-    return [];
 };

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

@@ -1,13 +1,13 @@
 class Solution:
     def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
-        def find(x):
+        def find(x: int) -> int:
             if p[x] != x:
                 p[x] = find(p[x])
             return p[x]
 
-        p = list(range(1010))
+        p = list(range(len(edges)))
         for a, b in edges:
-            if find(a) == find(b):
+            pa, pb = find(a - 1), find(b - 1)
+            if pa == pb:
                 return [a, b]
-            p[find(a)] = find(b)
-        return []
+            p[pa] = pb

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

@@ -0,0 +1,18 @@
+function findRedundantConnection(edges: number[][]): number[] {
+    const n = edges.length;
+    const p: number[] = Array.from({ length: n }, (_, i) => i);
+    const find = (x: number): number => {
+        if (p[x] !== x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    };
+    for (let i = 0; ; ++i) {
+        const pa = find(edges[i][0] - 1);
+        const pb = find(edges[i][1] - 1);
+        if (pa === pb) {
+            return edges[i];
+        }
+        p[pa] = pb;
+    }
+}

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

@@ -0,0 +1,45 @@
+class UnionFind {
+public:
+    UnionFind(int n) {
+        p = vector<int>(n);
+        size = vector<int>(n, 1);
+        iota(p.begin(), p.end(), 0);
+    }
+
+    bool unite(int a, int b) {
+        int pa = find(a), pb = find(b);
+        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];
+        }
+        return true;
+    }
+
+    int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+
+private:
+    vector<int> p, size;
+};
+
+class Solution {
+public:
+    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
+        UnionFind uf(edges.size());
+        for (int i = 0;; ++i) {
+            if (!uf.unite(edges[i][0] - 1, edges[i][1] - 1)) {
+                return edges[i];
+            }
+        }
+    }
+};

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

@@ -0,0 +1,44 @@
+type unionFind struct {
+	p, size []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, size}
+}
+
+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), uf.find(b)
+	if pa == pb {
+		return false
+	}
+	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]
+	}
+	return true
+}
+
+func findRedundantConnection(edges [][]int) []int {
+	uf := newUnionFind(len(edges))
+	for i := 0; ; i++ {
+		if !uf.union(edges[i][0]-1, edges[i][1]-1) {
+			return edges[i]
+		}
+	}
+}

solution/0600-0699/0684.Redundant Connection/Solution2.java

@@ -0,0 +1,46 @@
+class UnionFind {
+    private final int[] p;
+    private final int[] size;
+
+    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;
+        }
+    }
+
+    public int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+
+    public boolean union(int a, int b) {
+        int pa = find(a), pb = find(b);
+        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];
+        }
+        return true;
+    }
+}
+
+class Solution {
+    public int[] findRedundantConnection(int[][] edges) {
+        UnionFind uf = new UnionFind(edges.length);
+        for (int i = 0;; ++i) {
+            if (!uf.union(edges[i][0] - 1, edges[i][1] - 1)) {
+                return edges[i];
+            }
+        }
+    }
+}

solution/0600-0699/0684.Redundant Connection/Solution2.js

@@ -0,0 +1,42 @@
+class UnionFind {
+    constructor(n) {
+        this.p = Array.from({ length: n }, (_, i) => i);
+        this.size = Array(n).fill(1);
+    }
+
+    find(x) {
+        if (this.p[x] !== x) {
+            this.p[x] = this.find(this.p[x]);
+        }
+        return this.p[x];
+    }
+
+    union(a, b) {
+        const pa = this.find(a);
+        const pb = this.find(b);
+        if (pa === pb) {
+            return false;
+        }
+        if (this.size[pa] > this.size[pb]) {
+            this.p[pb] = pa;
+            this.size[pa] += this.size[pb];
+        } else {
+            this.p[pa] = pb;
+            this.size[pb] += this.size[pa];
+        }
+        return true;
+    }
+}
+
+/**
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+var findRedundantConnection = function (edges) {
+    const uf = new UnionFind(edges.length);
+    for (let i = 0; i < edges.length; i++) {
+        if (!uf.union(edges[i][0] - 1, edges[i][1] - 1)) {
+            return edges[i];
+        }
+    }
+};

solution/0600-0699/0684.Redundant Connection/Solution2.py

@@ -0,0 +1,31 @@
+class UnionFind:
+    __slots__ = "p", "size"
+
+    def __init__(self, n: int):
+        self.p: List[int] = list(range(n))
+        self.size: List[int] = [1] * n
+
+    def find(self, x: int) -> int:
+        if self.p[x] != x:
+            self.p[x] = self.find(self.p[x])
+        return self.p[x]
+
+    def union(self, a: int, b: int) -> bool:
+        pa, pb = self.find(a), self.find(b)
+        if pa == pb:
+            return False
+        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]
+        return True
+
+
+class Solution:
+    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
+        uf = UnionFind(len(edges))
+        for a, b in edges:
+            if not uf.union(a - 1, b - 1):
+                return [a, b]