feat: add solutions to lc problem: No.0947

solution/0900-0999/0947.Most Stones Removed with Same Row or Column/Solution.cpp

@@ -1,19 +1,50 @@
-class Solution {
+class UnionFind {
 public:
-    vector<int> p;
+    UnionFind(int n) {
+        p = vector<int>(n);
+        size = vector<int>(n, 1);
+        iota(p.begin(), p.end(), 0);
+    }
 
-    int removeStones(vector<vector<int>>& stones) {
-        int n = 10010;
-        p.resize(n << 1);
-        for (int i = 0; i < p.size(); ++i) p[i] = i;
-        for (auto& stone : stones) p[find(stone[0])] = find(stone[1] + n);
-        unordered_set<int> s;
-        for (auto& stone : stones) s.insert(find(stone[0]));
-        return stones.size() - s.size();
+    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]);
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
         return p[x];
     }
+
+private:
+    vector<int> p, size;
+};
+
+class Solution {
+public:
+    int removeStones(vector<vector<int>>& stones) {
+        int n = stones.size();
+        UnionFind uf(n);
+        int ans = 0;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (stones[i][0] == stones[j][0] || stones[i][1] == stones[j][1]) {
+                    ans += uf.unite(i, j);
+                }
+            }
+        }
+        return ans;
+    }
 };

solution/0900-0999/0947.Most Stones Removed with Same Row or Column/Solution.go

@@ -1,22 +1,50 @@
-func removeStones(stones [][]int) int {
-	n := 10010
-	p := make([]int, n<<1)
+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
 	}
-	var find func(x int) int
-	find = func(x int) int {
-		if p[x] != x {
-			p[x] = find(p[x])
-		}
-		return p[x]
+	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
 	}
-	for _, stone := range stones {
-		p[find(stone[0])] = find(stone[1] + 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]
 	}
-	s := make(map[int]bool)
-	for _, stone := range stones {
-		s[find(stone[0])] = true
+	return true
+}
+
+func removeStones(stones [][]int) (ans int) {
+	n := len(stones)
+	uf := newUnionFind(n)
+	for i, s1 := range stones {
+		for j, s2 := range stones[:i] {
+			if s1[0] == s2[0] || s1[1] == s2[1] {
+				if uf.union(i, j) {
+					ans++
+				}
+			}
+		}
 	}
-	return len(stones) - len(s)
+	return
 }

solution/0900-0999/0947.Most Stones Removed with Same Row or Column/Solution.java

@@ -1,26 +1,51 @@
-class Solution {
-    private int[] p;
+class UnionFind {
+    private final int[] p;
+    private final int[] size;
 
-    public int removeStones(int[][] stones) {
-        int n = 10010;
-        p = new int[n << 1];
-        for (int i = 0; i < p.length; ++i) {
+    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;
         }
-        for (int[] stone : stones) {
-            p[find(stone[0])] = find(stone[1] + n);
-        }
-        Set<Integer> s = new HashSet<>();
-        for (int[] stone : stones) {
-            s.add(find(stone[0]));
-        }
-        return stones.length - s.size();
     }
 
-    private int find(int x) {
+    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 removeStones(int[][] stones) {
+        int n = stones.length;
+        UnionFind uf = new UnionFind(n);
+        int ans = 0;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (stones[i][0] == stones[j][0] || stones[i][1] == stones[j][1]) {
+                    ans += uf.union(i, j) ? 1 : 0;
+                }
+            }
+        }
+        return ans;
+    }
 }

solution/0900-0999/0947.Most Stones Removed with Same Row or Column/Solution.py

@@ -1,14 +1,32 @@
+class UnionFind:
+    def __init__(self, n):
+        self.p = list(range(n))
+        self.size = [1] * 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), 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 removeStones(self, stones: List[List[int]]) -> int:
-        def find(x):
-            if p[x] != x:
-                p[x] = find(p[x])
-            return p[x]
-
-        n = 10010
-        p = list(range(n << 1))
-        for x, y in stones:
-            p[find(x)] = find(y + n)
-
-        s = {find(x) for x, _ in stones}
-        return len(stones) - len(s)
+        uf = UnionFind(len(stones))
+        ans = 0
+        for i, (x1, y1) in enumerate(stones):
+            for j, (x2, y2) in enumerate(stones[:i]):
+                if x1 == x2 or y1 == y2:
+                    ans += uf.union(i, j)
+        return ans

solution/0900-0999/0947.Most Stones Removed with Same Row or Column/Solution.ts

@@ -0,0 +1,44 @@
+class UnionFind {
+    p: number[];
+    size: number[];
+    constructor(n: number) {
+        this.p = Array.from({ length: n }, (_, i) => i);
+        this.size = Array(n).fill(1);
+    }
+
+    find(x: number): number {
+        if (this.p[x] !== x) {
+            this.p[x] = this.find(this.p[x]);
+        }
+        return this.p[x];
+    }
+
+    union(a: number, b: number): boolean {
+        const [pa, pb] = [this.find(a), 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;
+    }
+}
+
+function removeStones(stones: number[][]): number {
+    const n = stones.length;
+    const uf = new UnionFind(n);
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (stones[i][0] === stones[j][0] || stones[i][1] === stones[j][1]) {
+                ans += uf.union(i, j) ? 1 : 0;
+            }
+        }
+    }
+    return ans;
+}

solution/0900-0999/0947.Most Stones Removed with Same Row or Column/Solution2.cpp

@@ -0,0 +1,49 @@
+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:
+    int removeStones(vector<vector<int>>& stones) {
+        int m = 10001;
+        UnionFind uf(m << 1);
+        for (auto& st : stones) {
+            uf.unite(st[0], st[1] + m);
+        }
+        unordered_set<int> s;
+        for (auto& st : stones) {
+            s.insert(uf.find(st[0]));
+        }
+        return stones.size() - s.size();
+    }
+};

solution/0900-0999/0947.Most Stones Removed with Same Row or Column/Solution2.go

@@ -0,0 +1,48 @@
+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 removeStones(stones [][]int) (ans int) {
+	m := 10001
+	uf := newUnionFind(m << 1)
+	for _, st := range stones {
+		uf.union(st[0], st[1]+m)
+	}
+	s := map[int]bool{}
+	for _, st := range stones {
+		s[uf.find(st[0])] = true
+	}
+	return len(stones) - len(s)
+}