feat: add solutions to lc/lcof2 problems

lc No.0695 & lcof2 No.105. Max Area of Island

Author: yanglbme

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

@@ -1,29 +1,30 @@
 class Solution {
 public:
+    int m;
+    int n;
+
     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;
+        m = grid.size();
+        n = grid[0].size();
+        int ans = 0;
+        for (int i = 0; i < m; ++i)
+            for (int j = 0; j < n; ++j)
+                if (grid[i][j] == 1)
+                    ans = max(ans, dfs(i, j, grid));
+        return ans;
     }
-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;
-        }
+    int dfs(int i, int j, vector<vector<int>>& grid) {
         grid[i][j] = 0;
-        int res = 1;
-        for (auto direction : directions) {
-            res += dfs(grid, i + direction[0], j + direction[1], m, n);
+        int ans = 1;
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        for (int k = 0; k < 4; ++k)
+        {
+            int x = i + dirs[k];
+            int y = j + dirs[k + 1];
+            if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1)
+                ans += dfs(x, y, grid);
         }
-        return res;
+        return ans;
     }
-
 };

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

@@ -1,51 +1,27 @@
-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
-				}
+	dirs := []int{-1, 0, 1, 0, -1}
+	var dfs func(i, j int) int
+	dfs = func(i, j int) int {
+		grid[i][j] = 0
+		ans := 1
+		for k := 0; k < 4; k++ {
+			x, y := i+dirs[k], j+dirs[k+1]
+			if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 {
+				ans += dfs(x, y)
 			}
 		}
+		return ans
 	}
-	res := 0
+	ans := 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])
+				ans = max(ans, dfs(i, j))
 			}
 		}
 	}
-	return res
-}
-
-func find(x int) int {
-	if p[x] != x {
-		p[x] = find(p[x])
-	}
-	return p[x]
+	return ans
 }
 
 func max(a, b int) int {

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

@@ -1,27 +1,34 @@
 class Solution {
-    private int[][] directions = {{0, 1}, {0, - 1}, {1, 0}, {-1, 0}};
+    private int[][] grid;
+    private int m;
+    private int n;
 
     public int maxAreaOfIsland(int[][] grid) {
-        int m = grid.length, n = grid[0].length;
-        int res = 0;
+        m = grid.length;
+        n = grid[0].length;
+        this.grid = grid;
+        int ans = 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);
+                if (grid[i][j] == 1) {
+                    ans = Math.max(ans, dfs(i, j));
+                }
             }
         }
-        return res;
+        return ans;
     }
 
-    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;
-        }
+    private int dfs(int i, int j) {
         grid[i][j] = 0;
-        int res = 1;
-        for (int[] direction : directions) {
-            res += dfs(grid, i + direction[0], j + direction[1], m, n);
+        int[] dirs = {-1, 0, 1, 0, -1};
+        int ans = 1;
+        for (int k = 0; k < 4; ++k) {
+            int x = i + dirs[k];
+            int y = j + dirs[k + 1];
+            if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1) {
+                ans += dfs(x, y);
+            }
         }
-        return res;
+        return ans;
     }
 }

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

@@ -1,18 +1,13 @@
 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
+        def dfs(i, j):
             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
-        
+            ans = 1
+            for a, b in [[0, -1], [0, 1], [-1, 0], [1, 0]]:
+                x, y = i + a, j + b
+                if 0 <= x < m and 0 <= y < n and grid[x][y] == 1:
+                    ans += dfs(x, y)
+            return ans
+
         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
+        return max([dfs(i, j) for i in range(m) for j in range(n) if grid[i][j] == 1], default=0)

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

@@ -1,32 +1,26 @@
 function maxAreaOfIsland(grid: number[][]): number {
-    let m = grid.length,
-        n = grid[0].length;
-    let res = 0;
+    const m = grid.length;
+    const n = grid[0].length;
+    let ans = 0;
+    const dirs = [-1, 0, 1, 0, -1];
+    let dfs = function (i, j) {
+        grid[i][j] = 0;
+        let ans = 1;
+        for (let k = 0; k < 4; ++k) {
+            const x = i + dirs[k];
+            const y = j + dirs[k + 1];
+            if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1) {
+                ans += dfs(x, y);
+            }
+        }
+        return ans;
+    };
     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);
+                ans = Math.max(ans, dfs(i, j));
             }
         }
     }
-    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;
+    return ans;
 }