LeetCode200.岛屿数量

题目

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

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

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

示例

输入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
输出：1

思路

这道题可以使用**深度优先搜索（DFS）或广度优先搜索（BFS）**来解决。具体的思路如下：

• 遍历整个二维网格，如果当前位置是陆地，则进行 DFS 或 BFS 搜索，将该位置及其相邻的陆地标记为已访问。
• 对于每个未访问过的陆地，进行一次 DFS 或 BFS 搜索，并将该陆地及其相邻的陆地都标记为已访问。
• 统计搜索次数，即为岛屿数量。

接下来给出使用 DFS 和 BFS 两种方法的代码实现。

Code

DFS代码

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int m = grid.size();
        if (m == 0) {
            return 0;
        }
        int n = grid[0].size();
        int count = 0;
        // 遍历整个二维网格
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '1') {
                    // 如果当前位置是陆地，进行 DFS 搜索
                    dfs(grid, i, j);
                    count++;
                }
            }
        }
        return count;
    }

private:
    void dfs(vector<vector<char>>& grid, int i, int j) {
        int m = grid.size(), n = grid[0].size();
        // 如果当前位置不是陆地或已访问过，直接返回
        if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') {
            return;
        }
        // 将当前位置标记为已访问
        grid[i][j] = '0';
        // 对当前位置的相邻位置进行 DFS 搜索
        dfs(grid, i - 1, j);
        dfs(grid, i + 1, j);
        dfs(grid, i, j - 1);
        dfs(grid, i, j + 1);
    }
};

BFS代码

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int m = grid.size();
        if (m == 0) {
            return 0;
        }
        int n = grid[0].size();
        int count = 0;
        // 遍历整个二维网格
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '1') {
                    // 如果当前位置是陆地，进行 BFS 搜索
                    bfs(grid, i, j);
                    count++;
                }
            }
        }
        return count;
    }

private:
    void bfs(vector<vector<char>>& grid, int i, int j) {
        int m = grid.size(), n = grid[0].size();
        queue<pair<int, int>> q;
        // 将当前位置入队列
        q.push({i, j});
        // 标记当前位置为已访问
        grid[i][j] = '0';
        // 使用 BFS 进行搜索
        while (!q.empty()) {
            auto [x, y] = q.front();
            q.pop();
            // 对当前位置的相邻位置进行 BFS 搜索
            if (x > 0 && grid[x - 1][y] == '1') {
                q.push({x - 1, y});
                grid[x - 1][y] = '0';
            }
            if (x < m - 1 && grid[x + 1][y] == '1') {
                q.push({x + 1, y});
                grid[x + 1][y] = '0';
            }
            if (y > 0 && grid[x][y - 1] == '1') {
                q.push({x, y - 1});
                grid[x][y - 1] = '0';
            }
            if (y < n - 1 && grid[x][y + 1] == '1') {
                q.push({x, y + 1});
                grid[x][y + 1] = '0';
            }
        }
    }
};