leetcode 200. 岛屿数量 medium

leetcode 200. 岛屿数量   medium          

题目描述：

给定一个由 '1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。

示例 1:

输入:
11110
11010
11000
00000

输出: 1
示例 2:

输入:
11000
11000
00100
00011

输出: 3

解题思路：

方法1： dfs or bfs

方法2： 并查集，不过我觉得这道题用并查集实现没有太大的必要（把所有水域都给合并在一起，他们的id都是-1）

代码：

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        
        int ret = 0;
        for (int i = 0; i < grid.size(); i++){
            for (int j = 0; j<grid[0].size(); j++){
                if (grid[i][j] == '1'){
                    ret++;
                    dfs(grid, i, j);
                }
            }
        }

        return ret;


    }

    void dfs(vector<vector<char>> &grid, int cur_r, int cur_c){
        if (cur_r >= grid.size() || cur_r < 0 || cur_c >= grid[0].size() || cur_c < 0)
            return;
        if (grid[cur_r][cur_c] != '1')
            return;
        grid[cur_r][cur_c] = '#';
        for (int i = 0; i< 4;i++){
            dfs(grid, cur_r+dx[i], cur_c+dy[i]);
        }

    }

    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1, 0,0};

};



//并查集
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);
            ++count;
          }
          else parent.push_back(-1);
          rank.push_back(0);
        }
    }
  }

  int find(int i) { // path compression
    if (parent[i] != i) parent[i] = find(parent[i]);
    return parent[i];
  }

  void Union(int x, int y) { // union with rank
    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;
    }
  }

  int getCount() const {
    return count;
  }

private:
  vector<int> parent;
  vector<int> rank;
  int count; // # of connected components
};

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);
    int num_islands = 0;
    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();
  }
};