Leetcode200-岛屿数量

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

示例1：

示例2：

提示：

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

题解

法一 dfs

题解转载自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 int[][] dir ={{0,1},{1,0},{-1,0},{0,-1}};//四个方向
    public boolean[][] visited;
    //public int[][] dir = {{-1,0},{0,-1},{1,0},{0,1}};
    public int numIslands(char[][] grid) {
        visited=new boolean[grid.length][grid[0].length];
        int count=0;
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                //没有被访问过且为陆地
                if(!visited[i][j]&&grid[i][j]=='1'){
                    count++;
                    //从(i,j)开始深度搜索
                    dfs(grid,i,j);
                    
                }
            }
        }
        return count;
    }
    // X：横轴坐标 Y：纵轴坐标
    private void dfs(char[][] grid,int x, int y){
        //把visited[x][y]=true放在这里，避免numIslands函数中要将搜索起点置为true，dfs中还要将岛屿中
        visited[x][y]=true;
        //遍历4个方向
        for(int i=0;i<4;i++){
            int nextX=x+dir[i][0];
            int nextY=y+dir[i][1];
            //1.边界条件
            //注意这块不能是continue，否则会跳过后续的i
            if(nextX<0||nextX>=grid.length||nextY<0||nextY>=grid[0].length) continue;
            //没有被访问过且为陆地
            if(!visited[nextX][nextY]&&grid[nextX][nextY]=='1'){
                // //标记为访问
                // visited[nextX][nextY]=true;
                dfs(grid,nextX,nextY);
            }
        }
    }
}

法二 bfs

代码转载自liweiwei1419

import java.util.LinkedList;
import java.util.Queue;

public class Solution {

    private final static int[][] DIRECTIONS = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
    private int rows;
    private int cols;
    private char[][] grid;
    private boolean[][] visited;

    public int numIslands(char[][] grid) {
        rows = grid.length;
        if (rows == 0) {
            return 0;
        }
        cols = grid[0].length;
        this.grid = grid;
        visited = new boolean[rows][cols];

        int count = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (!visited[i][j] && grid[i][j] == '1') {
                    bfs(i, j);
                    count++;
                }
            }
        }
        return count;
    }

    private void bfs(int i, int j) {
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(i * cols + j);
        // 注意：这里要标记上已经访问过
        visited[i][j] = true;
        while (!queue.isEmpty()) {
            int cur = queue.poll();
            int curX = cur / cols;
            int curY = cur % cols;
            for (int k = 0; k < 4; k++) {
                int newX = curX + DIRECTIONS[k][0];
                int newY = curY + DIRECTIONS[k][1];
                if (inArea(newX, newY) && grid[newX][newY] == '1' && !visited[newX][newY]) {
                    queue.offer(newX * cols + newY);
                    // 特别注意：在放入队列以后，要马上标记成已经访问过，语义也是十分清楚的：反正只要进入了队列，迟早都会遍历到它
                    // 而不是在出队列的时候再标记，如果是出队列的时候再标记，会造成很多重复的结点进入队列，造成重复的操作，这句话如果你没有写对地方，代码会严重超时的
                    visited[newX][newY] = true;
                }
            }
        }
    }

    private boolean inArea(int x, int y) {
        return x >= 0 && x < rows && y >= 0 && y < cols;
    }
}