LeetCode-200-岛屿数量

1、并查集

为了判断每一个为’1’的数是否与别的‘1’相连，最终计算整个矩阵中的岛屿个数，我们可以考虑使用并查集来记录集合之间的相交关系。在并查集中，我们使用parent数组记录该节点的父节点，使用父节点来区分每一棵树。为了优化并查集的操作，我们将每一个节点都与父节点相连，并且始终将较矮的树连到较高的树上。我们使用count记录矩阵中的孤立岛屿个数，首先我们遍历矩阵，将每一个为‘1’的点对应的parent记为自己的序号。而后我们继续遍历矩阵中的每一个节点，为了避免遍历过的节点对之后的节点判断产生影响，我们在遍历过节点之后将其赋为‘0’。同时我们观察该节点上下左右的四个节点，若该节点存在且为‘1’，说明两个节点相连，应当加到同一个集合中，我们将较矮的树添加到较高的树中，并更新parent的值和count的值。最终遍历完所有节点之后，剩余的count值即为矩阵中不同的集合个数，即岛屿个数。

class Solution {
public:
    int find(int x, vector<int> &parent) {
        return x == parent[x] ? x : (parent[x] = find(parent[x], parent));
    }

    void to_union(int x1, int x2, vector<int> &parent, vector<int> &rank, int &count) {
        int f1 = find(x1, parent);
        int f2 = find(x2, parent);
        if (f1 != f2) {
            if (rank[f1] > rank[f2]) {
                parent[f2] = f1;
            } else {
                parent[f1] = f2;
                if (rank[f1] == rank[f2])
                    ++rank[f2];

            }
            --count;
        }
    }

    int numIslands(vector<vector<char>> &grid) {
        vector<int> parent;
        vector<int> rank;
        int 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);
            }
        }
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == '1') {
                    grid[i][j] = '0';
                    if (i - 1 >= 0 && grid[i - 1][j] == '1') to_union(i * n + j, (i - 1) * n + j, parent, rank, count);
                    if (i + 1 < m && grid[i + 1][j] == '1') to_union(i * n + j, (i + 1) * n + j, parent, rank, count);
                    if (j - 1 >= 0 && grid[i][j - 1] == '1') to_union(i * n + j, i * n + j - 1, parent, rank, count);
                    if (j + 1 < n && grid[i][j + 1] == '1') to_union(i * n + j, i * n + j + 1, parent, rank, count);
                }
            }
        }
        return count;
    }
};

2、深度优先搜索

我们遍历矩阵中的每一个节点并将其赋值为‘0’，之后遍历该节点上下左右的节点，若为‘1’则继续赋值为‘0’并遍历。最终统计矩阵中岛屿的个数。

class Solution {
private:
    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);
    }

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

        int num_islands = 0;
        for (int r = 0; r < nr; ++r) {
            for (int c = 0; c < nc; ++c) {
                if (grid[r][c] == '1') {
                    ++num_islands;
                    dfs(grid, r, c);
                }
            }
        }

        return num_islands;
    }
};

2、广度优先搜索

具体思路同上，区别在于遍历时采用广度优先。

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

        int num_islands = 0;
        for (int r = 0; r < nr; ++r) {
            for (int c = 0; c < nc; ++c) {
                if (grid[r][c] == '1') {
                    ++num_islands;
                    grid[r][c] = '0';
                    queue<pair<int, int>> neighbors;
                    neighbors.push({r, c});
                    while (!neighbors.empty()) {
                        auto rc = neighbors.front();
                        neighbors.pop();
                        int row = rc.first, col = rc.second;
                        if (row - 1 >= 0 && grid[row-1][col] == '1') {
                            neighbors.push({row-1, col});
                            grid[row-1][col] = '0';
                        }
                        if (row + 1 < nr && grid[row+1][col] == '1') {
                            neighbors.push({row+1, col});
                            grid[row+1][col] = '0';
                        }
                        if (col - 1 >= 0 && grid[row][col-1] == '1') {
                            neighbors.push({row, col-1});
                            grid[row][col-1] = '0';
                        }
                        if (col + 1 < nc && grid[row][col+1] == '1') {
                            neighbors.push({row, col+1});
                            grid[row][col+1] = '0';
                        }
                    }
                }
            }
        }

        return num_islands;
    }
};