1.岛屿最大面积

给定一个包含了一些 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。

 

正好以前学过深度优先遍历，这道题比较简单，可以练练手。

 

1、深度优先求岛屿面积：

设int h为某岛屿的面积，初始化int h=0

遍历二维数组grid[m][n]，如果grid[i][j]==1，以（i，j）为起点，进行顺序为上左下右顺时针方向的深度优先遍历；

如果深度优先遍历中grid[i][j]==1，则把grid[i][j]1的值改为0，表示已经探索，同时++h;

 

2、若干岛屿面积比较

设int area为这片海域最大岛屿的面积，初始化area=0；

每检测到一个岛屿，就拿area与岛屿的面积h对比，area等于其中最大一个

即area>h ? area=area : area=h;

 

代码：

class Solution {
    int h=0;
    public int maxAreaOfIsland(int[][] grid) {
        int ares=0;
        int k=grid.length;
        int m=grid[0].length;
        for(int p=0;p<k;++p){
            for(int v=0;v<m;++v){
                if(grid[p][v]==1){
                    grid[p][v]=-1;
                    h=1;
                    DSF(grid,v,p,k,m);
                    ares=Math.max(ares,h);
                }
            }
        }
        return ares;
    }
    
    int DSF(int [][]g,int i,int j,int m,int k){
        if(j>0){
            if(g[j-1][i]==1){g[j-1][i]=-1;++h;
                DSF(g,i,j-1,m,k);}
        }
        if(i+1<k){
            if(g[j][i+1]==1){g[j][i+1]=-1;++h;
                DSF(g,i+1,j,m,k);}
        }
        if(j+1<m){
            if(g[j+1][i]==1){g[j+1][i]=-1;++h;
                DSF(g,i,j+1,m,k);}
        }
        if(i>0){
            if(g[j][i-1]==1){g[j][i-1]=-1;++h;
                DSF(g,i-1,j,m,k);}}
        return h;
    }
}

 

为了方便起见，可以用 坐标改变量+原坐标 的方式表示该点上下左右四个点

对于点(x,y)，(x+0,y-1)表示其上，(x+0,y+1)表示其下，(x+1,y+0)表示其左，(x-1,y+0)表示其右

把(0,-1),(0,1),(1,0),(-1,0)存入数组dir[4][2]中，到时候遍历dir数组，用dir[c][0]+x,dir[c][1]+y即可表示上下左右

当然，这样写效率会降低。

 int dir[][]={{1,0},{0,1},{0,-1},{-1,0}};
 int DSF(int [][]g,int i,int j,int m,int k){
        for(int c=0;c<4;++c){
            int I=i+dir[c][0],J=j+dir[c][1];
            if(I>=0 && J>=0 && I<k && J<m && g[J][I]==1){
                ++h;g[J][I]=-1;
                DSF(g,I,J,m,k);
            }
        }
        return h;
    }