feat: add solutions to lc/lcof2 problem: Max Area of Island

Author: yanglbme

lcof2/剑指 Offer II 105. 岛屿的最大面积/README.md

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int maxAreaOfIsland(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        int res = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                int t = dfs(grid, i, j, m, n);
+                res = max(res, t);
+            }
+        }
+        return res;
+    }
+private:
+    vector<vector<int>> directions = {{0, 1}, {0, - 1}, {1, 0}, {-1, 0}};
+
+    int dfs(vector<vector<int>>& grid, int i, int j, int m, int n) {
+        if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == 0) {
+            return 0;
+        }
+        grid[i][j] = 0;
+        int res = 1;
+        for (auto direction : directions) {
+            res += dfs(grid, i + direction[0], j + direction[1], m, n);
+        }
+        return res;
+    }
+
+};

lcof2/剑指 Offer II 105. 岛屿的最大面积/Solution.cpp

@@ -0,0 +1,56 @@
+var p []int
+
+func maxAreaOfIsland(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	p = make([]int, m*n)
+	size := make([]int, m*n)
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			p[i*n+j] = i*n + j
+			size[i*n+j] = 1
+		}
+	}
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 1 {
+				if i < m-1 && grid[i+1][j] == 1 {
+					a, b := find(i*n+j), find((i+1)*n+j)
+					if a != b {
+						size[a] += size[b]
+					}
+					p[b] = a
+				}
+				if j < n-1 && grid[i][j+1] == 1 {
+					a, b := find(i*n+j), find(i*n+j+1)
+					if a != b {
+						size[a] += size[b]
+					}
+					p[b] = a
+				}
+			}
+		}
+	}
+	res := 0
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 1 {
+				res = max(res, size[i*n+j])
+			}
+		}
+	}
+	return res
+}
+
+func find(x int) int {
+	if p[x] != x {
+		p[x] = find(p[x])
+	}
+	return p[x]
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

lcof2/剑指 Offer II 105. 岛屿的最大面积/Solution.go

@@ -0,0 +1,27 @@
+class Solution {
+    private int[][] directions = {{0, 1}, {0, - 1}, {1, 0}, {-1, 0}};
+
+    public int maxAreaOfIsland(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        int res = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                int t = dfs(grid, i, j, m, n);
+                res = Math.max(res, t);
+            }
+        }
+        return res;
+    }
+
+    private int dfs(int[][] grid, int i, int j, int m, int n) {
+        if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == 0) {
+            return 0;
+        }
+        grid[i][j] = 0;
+        int res = 1;
+        for (int[] direction : directions) {
+            res += dfs(grid, i + direction[0], j + direction[1], m, n);
+        }
+        return res;
+    }
+}

lcof2/剑指 Offer II 105. 岛屿的最大面积/Solution.java

@@ -0,0 +1,18 @@
+class Solution:
+    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
+        def dfs(grid, i, j, m, n):
+            if i < 0 or i >= m or j < 0 or j >= n or grid[i][j] == 0:
+                return 0
+            grid[i][j] = 0
+            res = 1
+            for x, y in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
+                res += dfs(grid, i + x, j + y, m, n)
+            return res
+        
+        m, n = len(grid), len(grid[0])
+        res = 0
+        for i in range(m):
+            for j in range(n):
+                t = dfs(grid, i, j, m, n)
+                res = max(res, t)
+        return res

lcof2/剑指 Offer II 105. 岛屿的最大面积/Solution.py

@@ -0,0 +1,25 @@
+function maxAreaOfIsland(grid: number[][]): number {
+    let m = grid.length, n = grid[0].length;
+    let res = 0;
+    for (let i = 0; i < m; ++i) {
+        for (let j = 0; j < n; ++j) {
+            if (grid[i][j] == 1) {
+                res = Math.max(dfs(grid, i, j), res);
+            }
+        }
+    }
+    return res;
+};
+
+function dfs(grid: number[][], i: number, j: number): number {
+    let m = grid.length, n = grid[0].length;
+    if (i < 0 || i > m - 1 || j < 0 || j > n - 1 || grid[i][j] == 0) {
+        return 0;
+    }
+    grid[i][j] = 0;
+    let res = 1;
+    for (let [dx, dy] of [[0, 1], [0, -1], [1, 0], [-1, 0]]) {
+        res += dfs(grid, i + dx, j + dy);
+    }
+    return res;
+}