岛屿问题合集

题目链接：岛屿数量

题目描述：
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1:

输入:
[
[‘1’,‘1’,‘1’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘0’,‘0’,‘0’,‘0’,‘0’]
]
输出: 1

示例 2:

输入:
[
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘0’,‘0’,‘1’,‘0’,‘0’],
[‘0’,‘0’,‘0’,‘1’,‘1’]
]
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

分析：即统计能连接起来的1的区域块个数，使用dfs遍历，同时标记即可

class Solution {
    static int m,n;
    static void dfs(char[][] grid,int x,int y){
        if(x<0||y<0||x>=m||y>=n||grid[x][y]=='0') return;
        grid[x][y] = '0';
        dfs(grid,x,y+1);
        dfs(grid,x+1,y);
        dfs(grid,x,y-1);
        dfs(grid,x-1,y);

    }
    public int numIslands(char[][] grid) {
        if(grid == null||grid.length == 0) return 0;
        m = grid.length;
        n = grid[0].length;
        int cnt = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                 if(grid[i][j]=='1'){
                     cnt++;
                     dfs(grid,i,j);
                 }
            }
        }
        return cnt;
    }
}

变式：岛屿的最大面积
题目链接：岛屿的最大面积
题目描述：
给定一个包含了一些 0 和 1 的非空二维数组 grid 。

一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 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的个数

class Solution {
    static int m,n;
    static int dfs(int[][] grid,int x,int y){
        if(x<0||y<0||x>=m||y>=n||grid[x][y]==0) return 0;
        int t = 0;
        if(grid[x][y] == 1) t+=1;
        grid[x][y] = 0;       
        t += dfs(grid,x,y+1);
        t += dfs(grid,x+1,y);
        t += dfs(grid,x,y-1);
        t += dfs(grid,x-1,y);
        return t;
    }
    public int maxAreaOfIsland(int[][] grid) {
        if(grid == null||grid.length == 0) return 0;
        m = grid.length;
        n = grid[0].length;
        int ans = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                 if(grid[i][j]==1){
                     ans = Math.max(ans,dfs(grid,i,j));
                 }
            }
        }
        return ans;
    }
}

变式：统计封闭岛屿的数目
题目链接：统计封闭岛屿的数目
题目描述：
有一个二维矩阵 grid ，每个位置要么是陆地（记号为 0 ）要么是水域（记号为 1 ）。

我们从一块陆地出发，每次可以往上下左右 4 个方向相邻区域走，能走到的所有陆地区域，我们将其称为一座「岛屿」。

如果一座岛屿 完全 由水域包围，即陆地边缘上下左右所有相邻区域都是水域，那么我们将其称为 「封闭岛屿」。

请返回封闭岛屿的数目。
示例 1：

输入：grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
输出：2
解释：
灰色区域的岛屿是封闭岛屿，因为这座岛屿完全被水域包围（即被 1 区域包围）。
示例 2：

输入：grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
输出：1

示例 3：

输入：grid = [[1,1,1,1,1,1,1],
[1,0,0,0,0,0,1],
[1,0,1,1,1,0,1],
[1,0,1,0,1,0,1],
[1,0,1,1,1,0,1],
[1,0,0,0,0,0,1],
[1,1,1,1,1,1,1]]
输出：2

分析：只要在边界里面的又是1的就会形成封闭岛屿，而当达到边界之外时，证明边界处时不是1 ，那么肯定不会构成封闭岛屿。

class Solution {
    public boolean dfs(int[][] grid,int x,int y){
        if(x<0||y<0||x>=grid.length||y>=grid[0].length)
           return false;
        if(grid[x][y] == 1) return true;
        grid[x][y] = 1;//标记为海洋即走过
        boolean r = dfs(grid,x,y+1);
        boolean d = dfs(grid,x+1,y);
        boolean l = dfs(grid,x,y-1);
        boolean u = dfs(grid,x-1,y);
        return r&&d&&l&&u;
    }
    public int closedIsland(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        if(n == 0) return 0;
        int ans = 0;
        for(int i = 0;i < n;i++)
          for(int j = 0;j < m;j++){
              if(grid[i][j] == 0){
                  if(dfs(grid,i,j)) ans++;
              }
          }
        return ans;
    }
}