LeetCode 200. 岛屿数量（Java代码）

https://leetcode-cn.com/problems/number-of-islands/

题目描述

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

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

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

输入输出样例

输入:
11110
11010
11000
00000
输出: 1

输入:
11000
11000
00100
00011
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

题解

题目有一点让人摸不着头脑，真实的理解就是如果数组全是1，也看做是一个岛屿。所以只需要找出数组中不相邻的1的群体个数即可。

使用广度优先搜索策略，将为1的周围的1全部感染，之后再去遍历

class Solution {
    public int numIslands(char[][] grid) {
        if(grid.length == 0 || grid[0].length == 0) return 0;
        
        int 
            rows = grid.length,             // 行数
            columns = grid[0].length,       // 列数
            count = 0;                      // 岛屿数量
        
        // 从第一行第一列开始遍历
        for(int i=0; i<rows; i++){
            for(int j=0; j<columns; j++){
                if(grid[i][j] == '1'){
                    count++;
                    // 开始广度优先搜索
                    grid[i][j] = '0';
                    Queue<Integer> queue = new LinkedList<Integer>();
                    queue.offer(i*columns + j);   // 等价于从左往右，从上往下第几个
                    while(!queue.isEmpty()){
                        int id = queue.poll();
                        // 得到行和列
                        int row = id / columns;
                        int col = id % columns;
                        // 遍历行和列，将符合条件的也加入到队列中
                        if(row-1>=0 && grid[row-1][col] == '1'){
                            queue.offer((row-1)*columns + col);
                            grid[row-1][col] = '0';
                        }
                        if(row+1<rows && grid[row+1][col] == '1'){
                            queue.offer((row+1)*columns + col);
                            grid[row+1][col] = '0';
                        }
                        if(col-1>=0 && grid[row][col-1] == '1'){
                            queue.offer(row*columns + col -1);
                            grid[row][col-1] = '0';
                        }
                        if(col+1<columns && grid[row][col+1] == '1'){
                            queue.offer(row*columns + col + 1);
                            grid[row][col+1] = '0';
                        }
                    }
                    
                }
            }
        }
        
        return count;
    }
}

这里需要注意一点，在将符合要求的元素添加到队列中的时候，需要将该元素位置为 0。因为两个连着的11，虽然都会添加进队列里头，但是第一个1从队列里头出来的时候，会再次将第二个1入队列。（队列中就有两个该元素，等等）

使用深度优先搜索：

递归可以进行剪枝操作

class Solution {
    public int numIslands(char[][] grid) {
        if(grid.length == 0 || grid[0].length == 0) return 0;
        int rows = grid.length;
        int columns = grid[0].length;

        int count = 0;
        for(int i=0; i<rows; i++){
            for(int j=0; j<columns; j++){
                // 如果当前元素是 1，开始计数
                if(grid[i][j] == '1'){
                    count++;
                    // 开始深度优先搜索
                    dfs(grid, i, j);
                }
            }
        }

        return count;
    }

    // 感染函数，将所有的这个1的旁边的1都置为0
    public void dfs(char[][] grid, int i, int j){
        int rows = grid.length, columns = grid[0].length;
        // ******剪枝******
        if(i<0||j<0||i>=rows||j>=columns||grid[i][j]== '0')
            return;
        grid[i][j] = '0';
        dfs(grid, i-1, j);
        dfs(grid, i+1, j);
        dfs(grid, i, j-1);
        dfs(grid, i, j+1);
    }
}