leetcode刷题 200. 岛屿数量 Medium Java DFS+BFS+并查集

最新推荐文章于 2022-09-30 01:01:52 发布

Sueko

最新推荐文章于 2022-09-30 01:01:52 发布

阅读量680

点赞数

分类专栏： Leetcode刷题 Medium DFS&BFS 文章标签： leetcode

本文链接：https://blog.csdn.net/Sueko/article/details/123699255

版权

Leetcode刷题同时被 3 个专栏收录

51 篇文章 0 订阅

订阅专栏

Medium

16 篇文章 0 订阅

订阅专栏

DFS&BFS

5 篇文章 0 订阅

订阅专栏

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’

来源：力扣（LeetCode）

链接：200. 岛屿数量

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.题解

2.1 深度优先搜索（DFS）

2.1.1 思路

DFS除了用递归就是用栈，这道题用递归会好写很多。

思路就是从第一个‘1’开始，深度遍历上下左右四个方向，从这四个方向再继续向四周遍历。

只要能遍历到的值为‘1’的位置，就将值改为‘0’，这样下次遍历就不会再遍历到了。

然后在原函数能遍历到的‘1’的值都是所谓的‘岛屿’，这个数目之和就是答案。

2.1.2 Java代码

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

    void dfs(char[][]grid, int row,int column){
        int numr = grid.length,numc = grid[0].length;
        if(grid[row][column]=='0'){
            return;
        }
        grid[row][column] = '0';
        if(row-1>=0){
            dfs(grid,row-1,column);
        }
        if(row+1<numr){
            dfs(grid,row+1,column);
        }
        if(column-1>=0){
            dfs(grid,row,column-1);
        }
        if(column+1<numc){
            dfs(grid,row,column+1);
        }
    }
}

2.2 广度优先搜索（BFS）

2.2.1 思路

BFS肯定需要用到队列。这道题看起来代码很多，但其实思路不是很复杂就是单纯代码多。

思路肯定也是遍历，但是DFS的遍历是用递归来直接遍历四周的点，BFS的遍历用队列先存储要遍历的四周的点，通过while来遍历。

第一个点先存进去，再将第一个点的四周为‘1’的点存进去，再通过while取出来存进去的第二个点，依次往下遍历。

一个while结束了就说明这一个“岛屿”全部遍历完了，然后通过外面的两个for循环，继续找下一个“岛屿”进行遍历。

2.2.2 Java代码

class Solution {
    public int numIslands(char[][] grid) {
        if(grid == null || grid.length == 0){
            return 0;
        }
        int numr = grid.length,numc = grid[0].length;
        int ans = 0;
        for(int i =0;i<numr;i++){
            for(int j=0;j<numc;j++){
                if(grid[i][j] == '1'){
                    ans++;
                    grid[i][j] = '0';
                    List<Integer> queue = new ArrayList<Integer>();
                    queue.add(i*numc +j);
                    while(!queue.isEmpty()){
                        int position = queue.remove(0);
                        int row = position/numc;
                        int column = position%numc;
                        if(row-1>=0&&grid[row-1][column]=='1'){
                            grid[row-1][column]='0';
                            queue.add((row-1)*numc+column);
                        }
                        if(row+1<numr&&grid[row+1][column]=='1'){
                            grid[row+1][column] = '0';
                            queue.add((row+1)*numc+column);
                        }
                        if(column-1>=0&&grid[row][column-1]=='1'){
                            grid[row][column-1] ='0';
                            queue.add(position-1); 
                        }
                        if(column+1<numc&&grid[row][column+1]=='1'){
                            grid[row][column+1] = '0';
                            queue.add(position+1);
                        }
                    }
                }
            }
        }
        return ans;
    }
}

2.3 并查集

2.3.1 思路

并查集忘光了/(ㄒoㄒ)/~~，先复习了一下。
再贴油管上的讲解,这个博主讲的很清楚。

难点在于并查集的实现，如果会写并查集了，题目要求的函数其实和DFS差不多。

如果复习或者学会了并查集，就知道除了初始化，并查集还需要些查找（Find）和合并（Union）操作。

而本题的并查集是这样实现的：

初始化：首先对一整个grid遍历，将所有值为‘1’的点都作为一个单独的节点，存在parent[]里，而rank[]也就是秩数组也全都设为0。同时与其他的并查集相比还增加了一个count,用来记录‘岛屿’也就是集合的个数。现在的岛屿个数当然是所有为‘1’的节点的个数。
查找（Find）：查找是用来查找节点的parent，find只需要通过parent[]查找就行。
合并（Union）：合并操作是用来合并集合，在这里也可以看成合并节点的。并查集的合并首先要找到两个点的parent节点，对两个parent节点进行合并。代码里用到了秩，也就是把秩小的parent节点接到秩大的parent节点上（认贼作父）。两个集合就合并了。

并查集建立好了，就可以通过遍历grid，将上下左右的点通过union合并到一起了。最后拿一下count就行。
贴一下官方题解的。

2.3.2 Java代码

class Solution {
    class UnionFind {
        int count;
        int[] parent;
        int[] rank;

        public UnionFind(char[][] grid) {
            count = 0;
            int m = grid.length;
            int n = grid[0].length;
            parent = new int[m * n];
            rank = new int[m * n];
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < n; ++j) {
                    if (grid[i][j] == '1') {
                        parent[i * n + j] = i * n + j;
                        ++count;
                    }
                    rank[i * n + j] = 0;
                }
            }
        }

        public int find(int i) {
            if (parent[i] != i) parent[i] = find(parent[i]);
            return parent[i];
        }

        public void union(int x, int y) {
            int rootx = find(x);
            int rooty = find(y);
            if (rootx != rooty) {
                if (rank[rootx] > rank[rooty]) {
                    parent[rooty] = rootx;
                } else if (rank[rootx] < rank[rooty]) {
                    parent[rootx] = rooty;
                } else {
                    parent[rooty] = rootx;
                    rank[rootx] += 1;
                }
                --count;
            }
        }

        public int getCount() {
            return count;
        }
    }

    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0) {
            return 0;
        }

        int nr = grid.length;
        int nc = grid[0].length;
        int num_islands = 0;
        UnionFind uf = new UnionFind(grid);
        for (int r = 0; r < nr; ++r) {
            for (int c = 0; c < nc; ++c) {
                if (grid[r][c] == '1') {
                    grid[r][c] = '0';
                    if (r - 1 >= 0 && grid[r-1][c] == '1') {
                        uf.union(r * nc + c, (r-1) * nc + c);
                    }
                    if (r + 1 < nr && grid[r+1][c] == '1') {
                        uf.union(r * nc + c, (r+1) * nc + c);
                    }
                    if (c - 1 >= 0 && grid[r][c-1] == '1') {
                        uf.union(r * nc + c, r * nc + c - 1);
                    }
                    if (c + 1 < nc && grid[r][c+1] == '1') {
                        uf.union(r * nc + c, r * nc + c + 1);
                    }
                }
            }
        }

        return uf.getCount();
    }
}