695. Max Area of Island

Given a non-empty 2D array grid of 0‘s and 1‘s, an island is a group of 1‘s (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.
Find the maximum area of an island in the given 2D array. (If there is no island, the maximum area is 0.)
Example 1:?
[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]
Given the above grid, return 6. Note the answer is not 11, because the island must be connected 4-directionally.

Example 2:?
[[0,0,0,0,0,0,0,0]]
Given the above grid, return 0.



// correct 
class Solution {
    private static final int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    public int maxAreaOfIsland(int[][] grid) {
        int res = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    int[] area = new int[1];
                    dfs(i, j, area, grid);
                    res = Math.max(res, area[0]);
                }
            }
        }
        return res;
    }
    private void dfs(int i, int j, int[] area, int[][] grid){
        // base case 
        if(i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || grid[i][j] == 0) return;
        // mark it after visiting 
        grid[i][j] = 0;
        area[0]++;
        for(int[] dir : dirs){
            int x = i + dir[0];
            int y = j + dir[1];
            dfs(x, y, area, grid);
        }
    }
}



//  idk why it’s wrong 
//         grid[i][j] = 0;
//         // base case : 
//         // out of bound or 0 
//         area[0]++;
//         for(int[] dir : dirs){
//             int x = i + dir[0];
//             int y = j + dir[1];
//             if(i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || grid[i][j] == 0) continue;
//             dfs(x, y, area, grid);
//         }
        
//     }
// }


// wrong , my code, area should be int[] as a parameter  , not int, because in java , pass by reference .. 
class Solution {
    private static final int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    public int maxAreaOfIsland(int[][] grid) {
        int res = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    int area = 0;
                    dfs(i, j, area, grid);
                    res = Math.max(res, area);
                }
            }
        }
        return res;
    }
    private void dfs(int i, int j, int area, int[][] grid){
        grid[i][j] = 0;
        // base case : 
        // out of bound or 0 
        area++;
        for(int[] dir : dirs){
            int x = i + dir[0];
            int y = j + dir[1];
            if(i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || grid[i][j] == 0) continue;
            dfs(x, y, area, grid);
        }
        
    }
}








// correct , other’s code 
public int maxAreaOfIsland(int[][] grid) {
        if (grid == null || grid.length == 0) {
            return 0;
        }
        int m = grid.length;
        int n = grid[0].length;
        int max = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    int area = dfs(grid, i, j, m, n, 0);
                    max = Math.max(area, max);
                }
            }
        }
        return max;
    }

    int dfs(int[][] grid, int i, int j, int m, int n, int area) {
        if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == 0) {
            return area;
        }
        grid[i][j] = 0;
        area++;
        area = dfs(grid, i + 1, j, m, n, area);
        area = dfs(grid, i, j + 1, m, n, area);
        area = dfs(grid, i - 1, j, m, n, area);
        area = dfs(grid, i, j - 1, m, n, area);
        return area;
    }