Number of Islands

最新推荐文章于 2022-06-12 16:55:07 发布

原创最新推荐文章于 2022-06-12 16:55:07 发布 · 577 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#unit #BFS #DFS #图算法

leetcode 专栏收录该内容

29 篇文章

订阅专栏

本文介绍了一种计算二维网格中岛屿数量的方法，通过并查集、深度优先搜索（DFS）及广度优先搜索（BFS）三种算法实现。并查集算法通过记录相连的陆地进行分类合并，而DFS和BFS则遍历整个网格标记已访问过的陆地。

思考：与Surrounded Regions类似。并查集图算法

方法

1、利用num计数，遇到gird[i][j] = ‘1’,就让num++; 然后查看grid[i - 1][j]和grid[i - 1][j]。如果为1，则unit。在unit中，如果两个类的根不同，则num - 1；并且将两个类的根置为同一个。例如：grid[i - 1][j] == grid[i][j] == 1，则比较grid[i - 1][j]的根rootX和grid[i][j]的根rootY,如果相同则不做运算，如果不同则num - 1，并且置rootX = rootY。(数组中每个元素的根初始化为i*m+j)；
2、思考图算法，连通分量问题。DFS和BFS

代码

public class Solution {
    int num = 0;
    int[] unitArray;
    public int numIslands(char[][] grid) {
        if(grid.length == 0 || grid[0].length == 0)
            return 0;
        int n = grid.length;
        int m = grid[0].length;
        unitArray = new int[n * m];
        for (int i = 0; i < unitArray.length; i++)
            unitArray[i] = i;
        if(grid[0][0] == '1')
            num++;
        for(int i = 1; i < n; i++)
            if(grid[i][0] == '1'){
                num++;
                if(grid[i - 1][0] == '1')
                    unit(i * m, i * m - m);
            }
        for(int j = 1; j < m; j++)
            if(grid[0][j] == '1'){
                num++;
                if(grid[0][j - 1] == '1')
                    unit(j, j - 1);
            }
        for(int i = 1; i < n; i ++)
            for(int j = 1; j < m; j++)
                if(grid[i][j] == '1'){
                    num++;
                    if(grid[i][j] == grid[i - 1][j])
                        unit(i * m + j, i * m - m + j);
                    if(grid[i][j] == grid[i][j - 1])
                        unit(i * m + j, i * m + j - 1);
                }
        return num;
    }

    void unit(int i, int j){
        int rootI = find(i);
        int rootJ = find(j);
        if(rootI != rootJ){
            num--;
            unitArray[rootI] = rootJ;
        }
    }

    int find(int index){
        if(unitArray[index] == index) return index;
        unitArray[index] = find(unitArray[index]);
        return unitArray[index];
    }
}

DFS

class Solution {
public:
    void help(vector<vector<char>>& g, int row, int col){
       if((row < 0) || (row >= g.size()) || (col < 0) || (col >= g[row].size()) || g[row][col] != '1')
            return;
        g[row][col] = '0';
        help(g,row + 1,col);
        help(g,row - 1,col);
        help(g,row,col + 1);
        help(g,row,col - 1);
    }
    int numIslands(vector<vector<char>>& grid) {
        int answer = 0;
        for(int i  = 0; i < grid.size(); i++)
            for(int j = 0; j < grid[i].size(); j++)
                if(grid[i][j] == '1'){
                    answer++;
                    help(grid,i,j);              
                }
        return answer;
    }
};

BFS

class Solution {
public:
    void help(vector<vector<char>>& g, int x, int y){
      queue<pair<int,int>> q;
      const int dx[] = {1,-1,0,0};
      const int dy[] = {0,0,1,-1};
      g[x][y] = '0';
      for(q.push(make_pair(x,y)); !q.empty(); q.pop()){
          x = q.front().first;
          y = q.front().second;
          for(int i = 0; i < 4; i++){
              int tx = x + dx[i];
              int ty = y + dy[i];
              if((tx >= 0) && (tx < g.size()) && (ty >=0) && (ty < g[tx].size()) && g[tx][ty] == '1'){
                  q.push(make_pair(tx,ty));
                  g[tx][ty] = '0';
              }
          }
       }
    }
    int numIslands(vector<vector<char>>& grid) {
        int answer = 0;
        for(int i  = 0; i < grid.size(); i++)
            for(int j = 0; j < grid[i].size(); j++)
                if(grid[i][j] == '1'){
                    answer++;
                    help(grid,i,j);                
                }
        return answer;
    }
};