695.岛屿的最大面积（Java）

题目描述

给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)

示例 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]]
对于上面这个给定矩阵应返回 6。注意答案不应该是11，因为岛屿只能包含水平或垂直的四个方向的‘1’。

示例 2:

[[0,0,0,0,0,0,0,0]]
对于上面这个给定的矩阵, 返回 0。

注意: 给定的矩阵grid 的长度和宽度都不超过 50。

---

解法一：dfs

class Solution {
    int[][] mark;
    int maxSize;
    int count;
    public int maxAreaOfIsland(int[][] grid) {
        int n=grid.length,m=grid[0].length;
        //标记数组mark，用来标记已经搜索过的位置
        mark = new int[n][m];
        maxSize=0;
        //全部扫描一遍
        for(int i=0;i<n;i++){
            //二维矩阵常见错误，把m写成n
            for(int j=0;j<m;j++){
                //值为1但还没扫描过
                if(grid[i][j]==1&&mark[i][j]==0){
                    //计数为1，设置标记，进行深度搜索，搜完更新最大值
                    count=1;
                    mark[i][j]=1;
                    dfs(grid,i,j,n,m);
                    maxSize=Math.max(maxSize,count);
                }
            }
        }
        return maxSize;
    }
    public void dfs(int[][] grid,int i,int j,int n,int m){
        //上下左右4个方向，如果不超过边界、值为1且没标记过，递归搜索，直至周围全搜索过
        if(i>0&&grid[i-1][j]==1&&mark[i-1][j]==0){
            count++;
            mark[i-1][j]=1;
            dfs(grid,i-1,j,n,m);
        }
        if(i<n-1&&grid[i+1][j]==1&&mark[i+1][j]==0){
            count++;
            mark[i+1][j]=1;
            dfs(grid,i+1,j,n,m);
        }
        if(j>0&&grid[i][j-1]==1&&mark[i][j-1]==0){
            count++;
            mark[i][j-1]=1;
            dfs(grid,i,j-1,n,m);
        }
        if(j<m-1&&grid[i][j+1]==1&&mark[i][j+1]==0){
            count++;
            mark[i][j+1]=1;
            dfs(grid,i,j+1,n,m);
        }
    }
}

---

空间优化（沉船思想）+递归优化

class Solution {
    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){
                    res=Math.max(res,dfs(grid,i,j));
                }
            }
        }
        return res;
    }
    public int dfs(int[][] grid,int i,int j){
        if(i<0||i>=grid.length||j<0||j>=grid[0].length||grid[i][j]==0){
            return 0;
        }
        //沉岛
        grid[i][j]=0;
        //1为自身，加上4个方向
        return 1+dfs(grid,i-1,j)+dfs(grid,i+1,j)+dfs(grid,i,j-1)+dfs(grid,i,j+1);
    }
}