feat: add solutions to lc problem: No.0827

No.0827.Making A Large Island

Author: yanglbme

solution/0800-0899/0827.Making A Large Island/README.md

@@ -53,10 +53,6 @@
 
 **方法一：并查集**
 
-由题意，我们知道，相邻的 $1$ 组成一个岛屿。这涉及到一个合并的操作，也就是说，我们可以将相邻的 $1$ 合并到一个集合中。
-
-这里我们可以使用并查集来实现，时间复杂度 $O(n^2\times \alpha(n))$。其中 $n$ 为矩阵的边长。
-
 并查集是一种树形的数据结构，顾名思义，它用于处理一些不交集的**合并**及**查询**问题。 它支持两种操作：
 
 1. 查找（Find）：确定某个元素处于哪个子集，单次操作时间复杂度 $O(\alpha(n))$
@@ -91,6 +87,24 @@ def union(a, b):
     size[pb] += size[pa]
 ```
 
+在这道题中，相邻的 $1$ 组成一个岛屿，因此，我们需要将相邻的 $1$ 归到同一个集合中。这可以视为一个合并操作，不难想到用并查集来实现。
+
+第一次遍历 `grid`，通过并查集的 `union` 操作合并所有相邻的 $1$，并且统计每个岛屿的面积，记录在 $size$ 数组中。
+
+再次遍历 `grid`，对于每个 $0$，我们统计相邻的四个点中 $1$ 所在的岛屿（通过并查集的 `find` 操作找到所在岛屿），累加去重后的岛屿面积，更新最大值。
+
+时间复杂度 $O(n^2\times \alpha(n))$。其中 $n$ 为矩阵 `grid` 的边长。
+
+**方法二：DFS**
+
+我们也可以通过 DFS，找到每个岛屿。
+
+同一个岛屿中的所有点都属于同一个集合，我们可以用不同的 `root` 值标识不同的岛屿，用 $p$ 记录每个 $grid[i][j]$ 对应的 `root` 值，用 $cnt$ 记录每个岛屿的面积。
+
+遍历 `grid`，对于每个 $0$，我们统计相邻的四个点中 $1$ 所在的岛屿（与方法一不同的是，我们这里直接取 $p[i][j]$ 作为 `root`），累加去重后的岛屿面积，更新最大值。
+
+时间复杂度 $O(n^2)$。其中 $n$ 为矩阵 `grid` 的边长。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -139,6 +153,44 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def largestIsland(self, grid: List[List[int]]) -> int:
+        def dfs(i, j):
+            p[i][j] = root
+            cnt[root] += 1
+            for a, b in [[0, -1], [0, 1], [-1, 0], [1, 0]]:
+                x, y = i + a, j + b
+                if 0 <= x < n and 0 <= y < n and grid[x][y] and p[x][y] == 0:
+                    dfs(x, y)
+
+        n = len(grid)
+        cnt = Counter()
+        p = [[0] * n for _ in range(n)]
+        root = 0
+        for i, row in enumerate(grid):
+            for j, v in enumerate(row):
+                if v and p[i][j] == 0:
+                    root += 1
+                    dfs(i, j)
+
+        ans = max(cnt.values(), default=0)
+        for i, row in enumerate(grid):
+            for j, v in enumerate(row):
+                if v == 0:
+                    t = 1
+                    vis = set()
+                    for a, b in [[0, -1], [0, 1], [-1, 0], [1, 0]]:
+                        x, y = i + a, j + b
+                        if 0 <= x < n and 0 <= y < n:
+                            root = p[x][y]
+                            if root not in vis:
+                                vis.add(root)
+                                t += cnt[root]
+                    ans = max(ans, t)
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -208,6 +260,65 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    private int n;
+    private int ans;
+    private int root;
+    private int[][] p;
+    private int[][] grid;
+    private int[] cnt;
+    private int[] dirs = new int[] {-1, 0, 1, 0, -1};
+
+    public int largestIsland(int[][] grid) {
+        n = grid.length;
+        cnt = new int[n * n + 1];
+        p = new int[n][n];
+        this.grid = grid;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 1 && p[i][j] == 0) {
+                    ++root;
+                    dfs(i, j);
+                }
+            }
+        }
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 0) {
+                    int t = 1;
+                    Set<Integer> vis = new HashSet<>();
+                    for (int k = 0; k < 4; ++k) {
+                        int x = i + dirs[k], y = j + dirs[k + 1];
+                        if (x >= 0 && x < n && y >= 0 && y < n) {
+                            int root = p[x][y];
+                            if (!vis.contains(root)) {
+                                vis.add(root);
+                                t += cnt[root];
+                            }
+                        }
+                    }
+                    ans = Math.max(ans, t);
+                }
+            }
+        }
+        return ans;
+    }
+
+    private void dfs(int i, int j) {
+        p[i][j] = root;
+        ++cnt[root];
+        ans = Math.max(ans, cnt[root]);
+        for (int k = 0; k < 4; ++k) {
+            int x = i + dirs[k], y = j + dirs[k + 1];
+            if (x >= 0 && x < n && y >= 0 && y < n && grid[x][y] == 1 && p[x][y] == 0) {
+                dfs(x, y);
+            }
+        }
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -270,6 +381,64 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    const static inline vector<int> dirs = {-1, 0, 1, 0, -1};
+
+    int largestIsland(vector<vector<int>>& grid) {
+        int n = grid.size();
+        int ans = 0;
+        int root = 0;
+        vector<vector<int>> p(n, vector<int>(n));
+        vector<int> cnt(n * n + 1);
+
+        function<void(int, int)> dfs;
+        dfs = [&](int i, int j) {
+            p[i][j] = root;
+            ++cnt[root];
+            ans = max(ans, cnt[root]);
+            for (int k = 0; k < 4; ++k) {
+                int x = i + dirs[k], y = j + dirs[k + 1];
+                if (x >= 0 && x < n && y >= 0 && y < n && grid[x][y] && p[x][y] == 0) {
+                    dfs(x, y);
+                }
+            }
+        };
+
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] && p[i][j] == 0) {
+                    ++root;
+                    dfs(i, j);
+                }
+            }
+        }
+
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (!grid[i][j]) {
+                    int t = 1;
+                    unordered_set<int> vis;
+                    for (int k = 0; k < 4; ++k) {
+                        int x = i + dirs[k], y = j + dirs[k + 1];
+                        if (x >= 0 && x < n && y >= 0 && y < n) {
+                            int root = p[x][y];
+                            if (!vis.count(root)) {
+                                vis.insert(root);
+                                t += cnt[root];
+                            }
+                        }
+                    }
+                    ans = max(ans, t);
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -337,6 +506,68 @@ func max(a, b int) int {
 }
 ```
 
+```go
+func largestIsland(grid [][]int) int {
+	n := len(grid)
+	p := make([][]int, n)
+	for i := range p {
+		p[i] = make([]int, n)
+	}
+	cnt := make([]int, n*n+1)
+	dirs := []int{-1, 0, 1, 0, -1}
+	ans, root := 0, 0
+
+	var dfs func(i, j int)
+	dfs = func(i, j int) {
+		p[i][j] = root
+		cnt[root]++
+		ans = max(ans, cnt[root])
+		for k := 0; k < 4; k++ {
+			x, y := i+dirs[k], j+dirs[k+1]
+			if x >= 0 && x < n && y >= 0 && y < n && grid[x][y] == 1 && p[x][y] == 0 {
+				dfs(x, y)
+			}
+		}
+	}
+
+	for i, row := range grid {
+		for j, v := range row {
+			if v == 1 && p[i][j] == 0 {
+				root++
+				dfs(i, j)
+			}
+		}
+	}
+	for i, row := range grid {
+		for j, v := range row {
+			if v == 0 {
+				t := 1
+				vis := map[int]struct{}{}
+				for k := 0; k < 4; k++ {
+					x, y := i+dirs[k], j+dirs[k+1]
+					if x >= 0 && x < n && y >= 0 && y < n {
+						root := p[x][y]
+						if _, ok := vis[root]; !ok {
+							vis[root] = struct{}{}
+							t += cnt[root]
+						}
+					}
+				}
+				ans = max(ans, t)
+			}
+		}
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
 ### **...**
 
 ```