Leetcode200-岛屿数量

题目链接
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。

示例1：

示例2：

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值为 ‘0’ 或 ‘1’

题解

题解转载自nette
1.网格dfs的基本结构：

• 判断basecase:是否越界
  
• 上下左右访问相邻节点
  

void dfs(int[][] grid, int r, int c) {
    // 判断 base case
    // 如果坐标 (r, c) 超出了网格范围，直接返回
    if (!inArea(grid, r, c)) {
        return;
    }
    // 访问上、下、左、右四个相邻结点
    dfs(grid, r - 1, c);
    dfs(grid, r + 1, c);
    dfs(grid, r, c - 1);
    dfs(grid, r, c + 1);
}

// 判断坐标 (r, c) 是否在网格中
boolean inArea(int[][] grid, int r, int c) {
    return 0 <= r && r < grid.length 
        	&& 0 <= c && c < grid[0].length;
}

2.将访问过的格子标记

void dfs(int[][] grid, int r, int c) {
    // 判断 base case
    if (!inArea(grid, r, c)) {
        return;
    }
    // 如果这个格子不是岛屿，直接返回
    if (grid[r][c] != 1) {
        return;
    }
    grid[r][c] = 2; // 将格子标记为「已遍历过」
    
    // 访问上、下、左、右四个相邻结点
    dfs(grid, r - 1, c);
    dfs(grid, r + 1, c);
    dfs(grid, r, c - 1);
    dfs(grid, r, c + 1);
}

// 判断坐标 (r, c) 是否在网格中
boolean inArea(int[][] grid, int r, int c) {
    return 0 <= r && r < grid.length 
        	&& 0 <= c && c < grid[0].length;
}

方法：深度优先遍历
对于这道题来说，就是从一个是 “陆地” 的格子开始进行一次 “深度优先遍历” ，把与之相连的所有的格子都标记上，视为发现了一个 “岛屿”。

那么每一次进行 “深度优先遍历” 的条件就是：

1、这个格子是陆地 1，如果是水域 0 就无从谈论 “岛屿”；

2、这个格子不能是之前发现 “岛屿” 的过程中执行了 “深度优先遍历” 操作而被标记的格子

3、这个格子在岛屿中(base case)

具体到代码层面就是：

定义属于类的静态变量：

• private boolean[][] marked;//标记数组，标记了grid坐标对应的格子是否被访问过, 使用boolean而不是int数组可以避免初始化

定义方法：

• numIsIands()方法：遍历二维数组，如果grid[i][j]是岛屿中的一个点，且没有被访问过，就调用dfs()方法进行深度优先遍历
• dfs()方法：通过将gird[i][j]与directions数组相加从(i,j)开始向四周遍历,如果下一个点不越界、没有被访问过，并且是陆地，就从该点开始向四周遍历，对遍历过的点在marked数组中做标记
• inArea()方法：判断（i，j)是否在岛屿内

class Solution {
    public boolean[][] marked;
    public char[][] grid;
    public int numIslands(char[][] grid) {
        this.grid=grid;
        if(grid.length==0){
            return 0;
        }
        marked=new boolean[grid.length][grid[0].length];

        int count = 0;
        //遍历grid数组
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                //如果是岛屿中的一个点，且没有被访问过，就进行深度优先遍历
                if(!marked[i][j]&&grid[i][j]=='1'){
                    count++;
                    dfs(i,j);
                }
            }
        }
        return count;
    }

    public void dfs(int i, int j){
        if(!inArea(i,j)){
            return;
        }
        if(grid[i][j]=='1'){
            marked[i][j]=true;
            if(inArea(i+1,j)&&!marked[i+1][j]){
                dfs(i+1,j);
            }
            if(inArea(i-1,j)&&!marked[i-1][j]){
                dfs(i-1,j);
            }
            if(inArea(i,j+1)&&!marked[i][j+1]){
                dfs(i,j+1);
            }
            if(inArea(i,j-1)&&!marked[i][j-1]){
                dfs(i,j-1);
            }
        }
    }

    public boolean inArea(int i,int j){
        if(i<grid.length&&i>=0&&j<grid[0].length&&j>=0){
            return true;
        }
        return false;
    }
}