test: 827 solution

QuBenhao · QuBenhao · commit 5adf9e1cd595 · 2025-09-12T22:59:56.000+08:00
py, c++, go, java
diff --git a/problems/problems_827/Solution.cpp b/problems/problems_827/Solution.cpp
@@ -1,28 +1,104 @@
 //go:build ignore
 #include "cpp/common/Solution.h"
 
-
 using namespace std;
 using json = nlohmann::json;
 
+class UnionFind {
+  vector<int> fa;
+  vector<int> size;
+
+public:
+  int cc;
+  explicit UnionFind(int n) : fa(n), size(n, 1), cc(n) {
+    for (int i = 0; i < n; i++) {
+      fa[i] = i;
+    }
+  }
+
+  int find(int x) {
+    if (fa[x] != x) {
+      fa[x] = find(fa[x]);
+    }
+    return fa[x];
+  }
+
+  bool merge(int x, int y) {
+    int px = find(x), py = find(y);
+    if (px == py) {
+      return false;
+    }
+    fa[px] = py;
+    size[py] += size[px];
+    cc--;
+    return true;
+  }
+
+  int get_size(int x) { return size[find(x)]; }
+};
+
+constexpr array<array<int, 2>, 4> DIRS({{0, 1}, {1, 0}, {0, -1}, {-1, 0}});
+
 class Solution {
 public:
-    int largestIsland(vector<vector<int>>& grid) {
-        
+  int largestIsland(const vector<vector<int>> &grid) {
+    int n = grid.size();
+    auto pointToIdx = [&n](int x, int y) -> int { return x * n + y; };
+    UnionFind uf(n * n);
+    int ans = 0;
+    for (int i = 0; i < n; ++i) {
+      for (int j = 0; j < n; ++j) {
+        if (grid[i][j] == 0) {
+          continue;
+        }
+        int p = pointToIdx(i, j);
+        for (const auto &dir : DIRS) {
+          int nx = i + dir[0], ny = j + dir[1];
+          if (nx < 0 || nx >= n || ny < 0 || ny >= n || grid[nx][ny] != 1) {
+            continue;
+          }
+          uf.merge(p, pointToIdx(nx, ny));
+        }
+        ans = max(ans, uf.get_size(uf.find(p)));
+      }
+    }
+    for (int i = 0; i < n; ++i) {
+      for (int j = 0; j < n; ++j) {
+        if (grid[i][j] != 0) {
+          continue;
+        }
+        int tot = 1;
+        unordered_set<int> explored;
+        for (const auto &dir : DIRS) {
+          int nx = i + dir[0], ny = j + dir[1];
+          if (nx < 0 || nx >= n || ny < 0 || ny >= n || grid[nx][ny] != 1) {
+            continue;
+          }
+          int root = uf.find(pointToIdx(nx, ny));
+          if (explored.contains(root)) {
+            continue;
+          }
+          explored.insert(root);
+          tot += uf.get_size(root);
+        }
+        ans = max(ans, tot);
+      }
     }
+    return ans;
+  }
 };
 
 json leetcode::qubh::Solve(string input_json_values) {
-	vector<string> inputArray;
-	size_t pos = input_json_values.find('\n');
-	while (pos != string::npos) {
-		inputArray.push_back(input_json_values.substr(0, pos));
-		input_json_values = input_json_values.substr(pos + 1);
-		pos = input_json_values.find('\n');
-	}
-	inputArray.push_back(input_json_values);
-
-	Solution solution;
-	vector<vector<int>> grid = json::parse(inputArray.at(0));
-	return solution.largestIsland(grid);
+  vector<string> inputArray;
+  size_t pos = input_json_values.find('\n');
+  while (pos != string::npos) {
+    inputArray.push_back(input_json_values.substr(0, pos));
+    input_json_values = input_json_values.substr(pos + 1);
+    pos = input_json_values.find('\n');
+  }
+  inputArray.push_back(input_json_values);
+
+  Solution solution;
+  vector<vector<int>> grid = json::parse(inputArray.at(0));
+  return solution.largestIsland(grid);
 }
diff --git a/problems/problems_827/Solution.java b/problems/problems_827/Solution.java
@@ -6,8 +6,99 @@
 
 
 public class Solution extends BaseSolution {
+    class UnionFind {
+        private int[] parent;
+        private int[] size;
+        private int count;
+
+        public UnionFind(int n) {
+            parent = new int[n];
+            size = new int[n];
+            count = n;
+            for (int i = 0; i < n; i++) {
+                parent[i] = i;
+                size[i] = 1;
+            }
+        }
+
+        public int find(int x) {
+            if (parent[x] != x) {
+                parent[x] = find(parent[x]); // Path compression
+            }
+            return parent[x];
+        }
+
+        public boolean union(int x, int y) {
+            int px = find(x);
+            int py = find(y);
+            if (px == py) {
+                return false; // Already in the same set
+            }
+            if (size[px] < size[py]) {
+                parent[px] = py;
+                size[py] += size[px];
+            } else {
+                parent[py] = px;
+                size[px] += size[py];
+            }
+            count--;
+            return true; // Union successful
+        }
+
+        public int getCount() {
+            return count;
+        }
+
+        public int getSize(int x) {
+            return size[find(x)];
+        }
+    }
+
+    private static final int[][] DIRS = new int[][]{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+
     public int largestIsland(int[][] grid) {
-        
+        int n = grid.length;
+        int ans = 0;
+        UnionFind uf = new UnionFind(n * n);
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 0) {
+                    continue;
+                }
+                int p = i * n + j;
+                for (int[] dir: DIRS) {
+                    int nx = i + dir[0], ny = j + dir[1];
+                    if (nx < 0 || nx == n || ny < 0 || ny == n || grid[nx][ny] == 0) {
+                        continue;
+                    }
+                    uf.union(p, nx * n + ny);
+                }
+                ans = Math.max(ans, uf.getSize(p));
+            }
+        }
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] != 0) {
+                    continue;
+                }
+                int tot = 1;
+                Set<Integer> s = new HashSet<>();
+                for (int[] dir: DIRS) {
+                    int nx = i + dir[0], ny = j + dir[1];
+                    if (nx < 0 || nx == n || ny < 0 || ny == n || grid[nx][ny] == 0) {
+                        continue;
+                    }
+                    int root = uf.find(nx * n + ny);
+                    if (s.contains(root)) {
+                        continue;
+                    }
+                    s.add(root);
+                    tot += uf.getSize(root);
+                }
+                ans = Math.max(ans, tot);
+            }
+        }
+        return ans;
     }
 
     @Override
diff --git a/problems/problems_827/solution.go b/problems/problems_827/solution.go
@@ -6,8 +6,115 @@ import (
 	"strings"
 )
 
-func largestIsland(grid [][]int) int {
-    
+type UnionFind struct {
+	parent []int
+	rank   []int
+	size   []int
+	cc     int
+}
+
+func NewUnionFind(n int) *UnionFind {
+	uf := &UnionFind{
+		parent: make([]int, n),
+		rank:   make([]int, n),
+		size:   make([]int, n),
+		cc:     n,
+	}
+	for i := range uf.parent {
+		uf.parent[i] = i
+		uf.rank[i] = 1
+		uf.size[i] = 1
+	}
+	return uf
+}
+
+func (uf *UnionFind) Find(x int) int {
+	for uf.parent[x] != x {
+		uf.parent[x] = uf.parent[uf.parent[x]] // 路径压缩
+		x = uf.parent[x]
+	}
+	return x
+}
+
+func (uf *UnionFind) Union(x, y int) bool {
+	rootX := uf.Find(x)
+	rootY := uf.Find(y)
+
+	if rootX == rootY {
+		return false // 已经在同一集合
+	}
+
+	// 按秩合并
+	if uf.rank[rootX] > uf.rank[rootY] {
+		uf.parent[rootY] = rootX
+		uf.size[rootX] += uf.size[rootY]
+	} else {
+		uf.parent[rootX] = rootY
+		if uf.rank[rootX] == uf.rank[rootY] {
+			uf.rank[rootY]++
+		}
+		uf.size[rootY] += uf.size[rootX]
+	}
+	uf.cc-- // 合并后集合数减少
+	return true
+}
+
+func (uf *UnionFind) IsConnected(x, y int) bool {
+	return uf.Find(x) == uf.Find(y)
+}
+
+func (uf *UnionFind) GetSize(x int) int {
+	return uf.size[uf.Find(x)]
+}
+
+var DIRS = [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}
+
+func largestIsland(grid [][]int) (ans int) {
+	n := len(grid)
+	pointToIdx := func(x int, y int) int {
+		return x*n + y
+	}
+
+	uf := NewUnionFind(n * n)
+	for i := range n {
+		for j := range n {
+			if grid[i][j] == 0 {
+				continue
+			}
+			p := pointToIdx(i, j)
+			for _, dir := range DIRS {
+				nx, ny := i+dir[0], j+dir[1]
+				if nx < 0 || nx == n || ny < 0 || ny == n || grid[nx][ny] == 0 {
+					continue
+				}
+				uf.Union(p, uf.Find(pointToIdx(nx, ny)))
+			}
+			ans = max(ans, uf.GetSize(p))
+		}
+	}
+	for i := range n {
+		for j := range n {
+			if grid[i][j] != 0 {
+				continue
+			}
+			tot := 1
+			explored := map[int]bool{}
+			for _, dir := range DIRS {
+				nx, ny := i+dir[0], j+dir[1]
+				if nx < 0 || nx == n || ny < 0 || ny == n || grid[nx][ny] == 0 {
+					continue
+				}
+				root := uf.Find(pointToIdx(nx, ny))
+				if _, ok := explored[root]; ok {
+					continue
+				}
+				explored[root] = true
+				tot += uf.GetSize(root)
+			}
+			ans = max(ans, tot)
+		}
+	}
+	return
 }
 
 func Solve(inputJsonValues string) any {
diff --git a/templates/data_structure/union_find_set.md b/templates/data_structure/union_find_set.md
