200. Number of Islands

仅供自己学习

 

思路：
题目的意思寻找有多少块全是 ‘1’的区域，即搜索 ‘1’直到其周围全是0为一个 计数。考虑使用BFS，从一个1向四周扩散的寻找。

首先判断grid是否为空，即行数是否为0，是则返回0。否则获取grid行列数。用两个for循环遍历所有的方格，用一个队列存储为‘1’的方格，每次找到一个为‘1’的方格就将它设为0，从队列获取一个‘1’的方格，搜索其上下左右的方格是否为1，如果为1则加入队列并设为0，当队列为空的时候，则找到了一个全为1并被0所包围的区域。

代码：

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int nr=grid.size();
        if(!nr) return 0;
        int nc=grid[0].size();
        int nums_land=0;
        for(int r=0;r<nr;++r){
            for(int c=0;c<nc;++c){
                if(grid[r][c]=='1'){
                    ++nums_land;
                    grid[r][c]='0';
                    queue<pair<int,int>> place;
                    place.push({r,c});
                    while(!place.empty()){
                        auto rc=place.front();
                        place.pop();
                        int row=rc.first;
                        int col=rc.second;
                        if(row-1>=0&&grid[row-1][col]=='1'){
                            place.push({row-1,col});
                            grid[row-1][col]='0';
                        }
                        if(row+1<nr&&grid[row+1][col]=='1'){
                            place.push({row+1,col});
                            grid[row+1][col]='0';
                        }
                        if(col-1>=0&&grid[row][col-1]=='1'){
                            place.push({row,col-1});
                            grid[row][col-1]='0';
                        }
                        if(col+1<nc&&grid[row][col+1]=='1'){
                            place.push({row,col+1});
                            grid[row][col+1]='0';
                        }
                    }
                }
            }
        }
        return nums_land;
    }
};

 

既然BFS能解决那么DFS同样也可以。思路大体是一样的，只是将BFS的地方循环调用DFS，DFS中再在每个方向递归调用DFS即可。

 

代码：

class Solution {
public:
    void DFS(vector<vector<char>>& grid,int r,int c){   
        int nr=grid.size();
        int nc=grid[0].size();

        grid[r][c] ='0';
        if(r-1>= 0 && grid[r-1][c]=='1') DFS(grid,r-1,c);
        if(r+1< nr && grid[r+1][c]=='1') DFS(grid,r+1,c);
        if(c-1>= 0 && grid[r][c-1]=='1') DFS(grid,r,c-1);
        if(c+1< nc && grid[r][c+1]=='1') DFS(grid,r,c+1);
    }
    int numIslands(vector<vector<char>>& grid) {
        int nr = grid.size();
        if(!nr) return 0;
        int nc = grid[0].size();
        int nums_land=0;
        for(int r=0;r< nr;++r){
            for(int c=0;c< nc;++c){
                if(grid[r][c]=='1'){
                    ++nums_land;
                    DFS(grid,r,c);
                }
            }
        }
        return nums_land;
    }

};

 

BFS这种将 1变0的方法和查并集思想相同，那么同样也可以用查并集解决。

直接调用查并集的模板，两个for循环遍历所有方格，判断如果该方格四周是方格1的，那么就将其设为同一个leader，思想和BFS一样。

代码：

class UnionFind {
public:
    UnionFind(vector<vector<char>>& grid) {
        count = 0;
        int m = grid.size();
        int n = grid[0].size();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == '1') {
                    parent.push_back(i * n + j); //不为0的方格的leader设为其位置
                    ++count;         //记录有1的方格数
                }
                else {
                    parent.push_back(-1);//为0的方格leader设为-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;
            if (rank[rootx] == rank[rooty]) rank[rootx] += 1;
            --count;  //每将一个方格leader改为相同的就减去1，最后剩下的就是count就是岛屿数
        }
    }

    int getCount() const {
        return count;
    }

private:
    vector<int> parent;
    vector<int> rank;
    int count;
};

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int nr = grid.size();
        if (!nr) return 0;
        int nc = grid[0].size();

        UnionFind uf(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.unite(r * nc + c, (r-1) * nc + c);
                    if (r + 1 < nr && grid[r+1][c] == '1') uf.unite(r * nc + c, (r+1) * nc + c);
                    if (c - 1 >= 0 && grid[r][c-1] == '1') uf.unite(r * nc + c, r * nc + c - 1);
                    if (c + 1 < nc && grid[r][c+1] == '1') uf.unite(r * nc + c, r * nc + c + 1);
                } //这部分和BFS将1改为0的部分意思相同，将其四周为1的方格的leader设为相同的 也就是记为同一块区域
            }
        }

        return uf.getCount();
    }
};