算法---LeetCode 200. 岛屿数量

1. 题目

原题链接

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

示例 1：

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

示例 2：

输入：grid = [
[“1”,“1”,“0”,“0”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“1”,“0”,“0”],
[“0”,“0”,“0”,“1”,“1”]
]
输出：3

提示：

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

Related Topics 深度优先搜索 广度优先搜索 并查集
👍 1170 👎 0

2. 题解

2.1 解法1: DFS 递归

寻找岛屿数量, 上下左右相连的 1 都被认为是连续岛屿。

dfs方法： 设目前指针指向一个岛屿中的某一点 (i, j)，寻找包括此点的岛屿边界。同时将该岛屿变成海, 设置为 0 从 (i, j) 向此点的上下左右 (i+1,j),(i-1,j),(i,j+1),(i,j-1) 做深度搜索。

1.终止条件：
(1)(i, j) 越过矩阵边界;
(2)grid[i][j] == 0，代表此分支已越过岛屿边界。

搜索岛屿的同时，执行 grid[i][j] = ‘0’，即将岛屿所有节点删除，以免之后重复搜索相同岛屿。

主循环： 遍历整个矩阵，当遇到 grid[i][j] == '1' 时，从此点开始做深度优先搜索 dfs，岛屿数 count + 1 且在深度优先搜索中删除此岛屿。 最终返回岛屿数 count 即可。

    class Solution {
        public int numIslands(char[][] grid) {
            int ans = 0;
            for (int i = 0; i < grid.length; i++) {
                for (int j = 0; j < grid[0].length; j++) {
                    if (grid[i][j] == '1') {
                        ans++;
                        dfs(grid, i, j);
                    }
                }
            }
            return ans;
        }

        public void dfs(char[][] grid, int i, int j) {
            if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') {
                return;
            }
            grid[i][j] = '0';
            dfs(grid, i - 1, j);
            dfs(grid, i, j - 1);
            dfs(grid, i + 1, j);
            dfs(grid, i, j + 1);
        }

    }

2.2 解法2: BFS

每次取出队头元素, 将符合范围的点置为’0’

流程:
1.借用一个队列 queue，判断队列首部节点 (i, j) 是否未越界且为 1：
若是则置零（删除岛屿节点），并将此节点上下左右节点 (i+1,j),(i-1,j),(i,j+1),(i,j-1) 加入队列；
若不是则跳过此节点；

2.循环 pop 队列首节点，直到整个队列为空，此时已经遍历完此岛屿。

    class Solution {
        public int numIslands(char[][] grid) {
            int ans = 0;
            for (int i = 0; i < grid.length; i++) {
                for (int j = 0; j < grid[0].length; j++) {
                    if (grid[i][j] == '1') {
                        ans++;
                        bfs(grid, i, j);
                    }
                }
            }
            return ans;
        }

        public void bfs(char[][] grid, int i, int j) {
            Queue<int[]> queue = new LinkedList<>();
            queue.offer(new int[]{i, j});
            while (!queue.isEmpty()) {
                int[] temp = queue.poll();
                i = temp[0];
                j = temp[1];
                // 在数组范围内的点置为 '0'
                if (i >= 0 && i < grid.length && j >= 0 && j <= grid[0].length && grid[i][j] == '1') {
                    grid[i][j] = '0';
                    queue.add(new int[]{i + 1, j});
                    queue.add(new int[]{i - 1, j});
                    queue.add(new int[]{i, j + 1});
                    queue.add(new int[]{i, j - 1});
                }
            }

        }

    }

参考:
200. 岛屿数量（DFS / BFS）
岛屿类问题的通用解法、DFS 遍历框架