LeetCode 200. Number of Islands

最新推荐文章于 2025-05-07 17:27:01 发布

原创最新推荐文章于 2025-05-07 17:27:01 发布 · 192 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 题解专栏收录该内容

288 篇文章

订阅专栏

本文介绍了一种计算二维网格中岛屿数量的方法。使用深度优先搜索（DFS）和并查集（Union-Find）两种算法来实现。通过遍历网格，将相连的陆地标记为已访问，最终统计未被水覆盖的独立陆地区域数量。

Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

Answer: 1

Example 2:

Answer: 3

DFS method.

#include <string>
#include <vector>
#include <iostream>
using namespace std;
/*
    11110
    11010
    11000
    00000  ->Island = 1

    11000
    11000
    00100
    00011  ->Island = 3
*/

void flipBoard(vector< vector<char> >& grid, int i, int j, vector< vector<bool> >& used) {
    grid[i][j] = '0';
    vector< vector<int> > dir {
        {0, 1},
        {0, -1},
        {-1, 0},
        {1, 0}};
    for(int k = 0; k < 4; ++k) {
        int tx = dir[k][0] + i;
        int ty = dir[k][1] + j;
        if(tx >= 0 && tx < grid.size() && ty >= 0 && ty < grid[i].size() && grid[tx][ty] == '1' && !used[tx][ty]) {
            used[tx][ty] = true;
            flipBoard(grid, tx, ty, used);
        }
    }
}
int numIslands(vector< vector<char> >& grid) {
    if(grid.size() == 0 || grid[0].size() == 0) return 0;
    int m = grid.size();
    int n = grid[0].size();
    vector< vector<bool> > used(m, vector<bool>(n, false));
    int number = 0;
    for(int i = 0; i < m; ++i) {
        for(int j = 0; j < n; ++j) {
            if(grid[i][j] == '1' && !used[i][j]) {
                used[i][j] = true;
                flipBoard(grid, i, j, used);
                number++;
            }
        }
    }
    return number;
}

int main(void) {
    vector< vector<char> > matrix {
        {'1', '1', '0', '0', '0'},
        {'1', '1', '1', '0', '0'},
        {'0', '0', '1', '0', '0'},
        {'0', '0', '0', '1', '1'}};
    int num = numIslands(matrix);
    cout << num << endl;
}

Second solution: Using Union-Find. Just to simply illustrate the idea, the code is not clean.

#include <iostream>
#include <vector>
using namespace std;

vector<int> dp(20, 0);

void makeSet(int m, int n) {
  for(int i = 0; i < m; ++i) {
    for(int j = 0; j < n; ++j) {
      dp[i * m + j] = i * m + j;
    }
  }
}

int root(int i) {
  while(i != dp[i]) {
    i = dp[i];
  }
  return i;
}

bool find(vector< vector<int> >& matrix, int i, int j) {
  vector< vector<int> > dir {
  {0, 1},
  {0, -1},
  {1, 0},
  {-1, 0}};
  for(int k = 0; k < 4; ++k) {
    int next_i = i + dir[k][0];
    int next_j = j + dir[k][1];
    if(next_i >= 0 && next_i < matrix.size() && next_j >= 0 && next_j < matrix[i].size() && matrix[next_i][next_j] == 1) {
    int root_i = root(i * matrix.size() + j);
    int root_j = root(next_i * matrix.size() + next_j);
    if(root_i != root_j) {
      dp[root_i] = root_j;
      find(matrix, next_i, next_j);
    }
   }
  }
} 
int countIsland(vector< vector<int> >& matrix) {
int count = 0;
  int m = matrix.size();
  int n = matrix[0].size();
  makeSet(m, n);
  for(int i = 0; i < m; ++i) {
    for(int j = 0; j < n; ++j) {
      if(matrix[i][j] == 1) find(matrix, i, j);
    }
  }
  for(int i = 0;  i < m; ++i) {
    for(int j = 0; j < n; ++j) {
      if(matrix[i][j] == 1 && dp[i * m + j] == (i * m + j)) count++;
    }
  }
  return count;
}

int main(void) {
  vector< vector<int> > matrix {
  {1, 0, 1},
  {0, 0, 1},
  {0, 1, 0}};
  cout << "the number is:" << countIsland(matrix) << endl;
}

Third: a much cleaner way of DFS

void dfs(vector< vector<char> >& grid, int i, int j) {
  if(i < 0 || i >= grid.size() || j < 0 || j >= grid[i].size()) return;
  if(grid[i][j] == '1') {
    grid[i][j] = '0';
    dfs(grid, i - 1, j);
    dfs(grid, i + 1, j);
    dfs(grid, i, j + 1);
    dfs(grid, i, j - 1);
  }
  return;
}
int numIslands(vector< vector<char> >& grid) {
    if(grid.size() == 0 || grid[0].size() == 0) return 0;
    int m = grid.size();
    int n = grid[0].size();
    int number = 0;
    for(int i = 0; i < m; ++i) {
        for(int j = 0; j < n; ++j) {
            if(grid[i][j] == '1') {
                dfs(grid, i, j);
                number++;
            }
        }
    }
    return number;
}