LeetCode——第十七天（岛屿数量）

LeetCode——第十七天

200. 岛屿数量

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

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

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

示例 1:

输入:
11110
11010
11000
00000
输出: 1

示例 2:

输入:
11000
11000
00100
00011
输出: 3

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

分析：跟之前做过一题类似，之前好像是统计孤立1的个数，其实差不多，深度优先搜索，广度当然也可以，最后复习了下并查集。

深度优先搜索代码

class Solution {
private:
    void dfs(vector<vector<char>>& grid,int i,int j){
        int rows = grid.size();//记录行列
        int column = grid[0].size();
        grid[i][j]='0';//访问过的位置标记为0

        if(i-1>=0 && grid[i-1][j] == '1') dfs(grid,i-1,j);//向上遍历，顺序上下左右
        if(i+1<rows && grid[i+1][j] == '1') dfs(grid,i+1,j);
        if(j-1>=0 && grid[i][j-1] == '1') dfs(grid,i,j-1);
        if(j+1<column && grid[i][j+1] == '1') dfs(grid,i,j+1);
    }
public:
    int numIslands(vector<vector<char>>& grid) {
        int res = 0;//记录岛屿数量
        int rows = grid.size();//记录行列
        if(!rows)return res;//空列表处理
        int column = grid[0].size();

        for(int i=0;i<rows;i++){
            for(int j=0;j<column;j++)
                if(grid[i][j]=='1'){
                    res++;
                    dfs(grid,i,j);
                }
        }
        return res;
    }
};

广度优先搜索代码

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int res = 0;//记录岛屿数量
        int rows = grid.size();//记录行列
        if(!rows)return res;//空列表处理
        int column = grid[0].size();

        for(int i=0;i<rows;i++){
            for(int j=0;j<column;j++)
                if(grid[i][j]=='1'){
                    res++;
                    queue<pair<int, int>> neighbor;//广度遍历的队列
                    neighbor.push({i,j});
                    grid[i][j] = '0';
                    
                    while(!neighbor.empty()){
                        auto rc = neighbor.front();//队列第一个元素
                        int i = rc.first;//记录第一个元素的行列位置
                        int j = rc.second;
                        neighbor.pop();
                        //上下左右,符号条件则压入队列，作为下一层遍历节点
                        if(i-1>=0 && grid[i-1][j] == '1'){
                            neighbor.push({i-1,j});
                            grid[i-1][j] = '0';
                        };
                        if(i+1<rows && grid[i+1][j] == '1'){
                            neighbor.push({i+1,j});
                            grid[i+1][j] = '0';
                        };
                        if(j-1>=0 && grid[i][j-1] == '1'){
                            neighbor.push({i,j-1});
                            grid[i][j-1] = '0';
                        };
                        if(j+1<column && grid[i][j+1] == '1'){
                            neighbor.push({i,j+1});
                            grid[i][j+1] = '0';
                        };
                    }
                }
        }
        return res;
    }
};

并查集不是很了解的，可以查看这个视频。并查集
并查集

class UnionFind{
public:
    //初始化并查集，1的地方父亲为自己，0的地方父亲为-1
    UnionFind(vector<vector<char>>& grid,int rows,int column){
        for(int i = 0;i<rows;i++){
            for(int j = 0;j<column;j++){
                if(grid[i][j] == '1'){
                    parent.push_back(i*column+j);
                    count++;//一开始一个1就是一个岛屿，后续合并一个减一个岛
                }
                else parent.push_back(-1);
                rank.push_back(0);//高度初始化
            }
        }
    }
    //查找该点的父节点
    int find(int i){
        if(parent[i]!=i){
            parent[i] = find(parent[i]);
        }
        return parent[i];
    }

    void unite(int x,int y){
        int rootx = find(x);
        int rooty = find(y);
        if(rootx!=rooty){
            if(rank[rootx] < rank[rooty]) swap(rootx,rooty);
            parent[rooty] = rootx;//高度高的作为根节点，相同情况也是用y
            if(rank[rootx] == rank[rooty]) rank[rootx] += 1;//高度相同，则随意选取一个，且该树高度加1
            count--;//合并一个岛屿，所以岛屿数量减1
        }
    }

    int getCount() const{
        return count;
    }

private:
    vector<int> parent;//并查集各节点父亲
    vector<int> rank;//并查集高度
    int count = 0;//记录岛屿个数
};

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int rows = grid.size();//记录行列
        if(!rows)return 0;//空列表处理
        int column = grid[0].size();

        UnionFind uf(grid,rows,column);//初始化并查集

        for(int i=0;i<rows;i++){
            for(int j=0;j<column;j++){
                if(grid[i][j]=='1'){
                    grid[i][j] = '0';
                    //上下左右进行合并
                    if(i-1>=0 && grid[i-1][j] == '1') uf.unite(i*column+j,(i-1)*column+j);
                    if(i+1<rows && grid[i+1][j] == '1') uf.unite(i*column+j,(i+1)*column+j);
                    if(j-1>=0 && grid[i][j-1] == '1') uf.unite(i*column+j,i*column+j-1);
                    if(j+1<column && grid[i][j+1] == '1') uf.unite(i*column+j,i*column+j+1);
                }
            }
        }
        return uf.getCount();
    }
};

2.总结

看了LeetCode总共1600多题，按顺序做是不可能了，所以今天选择官方给出的常见公司面试题，按这节奏先做。深度优先遍历用了递归，广度应用一个队列，并查集其最主要作用应该是搜索父节点可以线性时间就找到，在这道题目中因为看评论提到了，所以就复习了一下。