深度優先搜索島嶼數量

首先回顧一下圖的深度優先遍歷(DFS)和廣度優先遍歷(BFS)算法分析

方法一：深度優先搜索

我們可以將二維網格看成一個無向圖，豎直或水平相鄰的 1 之間有邊相連。
爲了求出島嶼的數量，我們可以掃描整個二維網格。如果一個位置爲 1，則以其爲起始節點開始進行深度優先搜索。在深度優先搜索的過程中，每個搜索到的 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'; //在深度優先搜索的過程中，每個搜索到的 1 都會被重新標記爲 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')//如果一個位置爲 1，則以其爲起始節點開始進行深度優先搜索。
                {
                    ++num_islands;  //島嶼的數量
                    dfs(grid, r, c); //深度優先搜索
                }
            }
        }
        return num_islands;
    }
};

複雜度分析
時間複雜度：O(MN)，其中 M 和 N 分別爲行數和列數。
空間複雜度：O(MN)，在最壞情況下，整個網格均爲陸地，深度優先搜索的深度達到 MN。

方法二：廣度優先搜索

爲了求出島嶼的數量，我們可以掃描整個二維網格。如果一個位置爲 1，則將其加入隊列，開始進行廣度優先搜索。在廣度優先搜索的過程中，每個搜索到的 1 都會被重新標記爲 0。直到隊列爲空，搜索結束。
最終島嶼的數量就是我們進行廣度優先搜索的次數。

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;
    }
};

時間複雜度：O(MN)，其中 M 和 N 分別爲行數和列數。
空間複雜度：O(min(M, N))，在最壞情況下，整個網格均爲陸地，隊列的大小可以達到 min(M, N)。

方法三：並查集

爲了求出島嶼的數量，我們可以掃描整個二維網格。如果一個位置爲 1，則將其與相鄰四個方向上的 1 在並查集中進行合併。
最終島嶼的數量就是並查集中連通分量的數目。
下面的動畫展示了整個算法。

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) {
        if (parent[i] != i) {
            parent[i] = find(parent[i]);
        }
        return parent[i];
    }

    void unite(int x, int y) {
        int rootx = find(x);
        int rooty = find(y);
        if (rootx != rooty) {
            if (rank[rootx] < rank[rooty]) {
                swap(rootx, rooty);
            }
            parent[rooty] = rootx;
            if (rank[rootx] == rank[rooty]) rank[rootx] += 1;
            --count;
        }
    }

    int getCount() const {
        return count;
    }

private:
    vector<int> parent;
    vector<int> rank;
    int count;
};

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.unite(r * nc + c, (r-1) * nc + c);
                    if (r + 1 < nr && grid[r+1][c] == '1') uf.unite(r * nc + c, (r+1) * nc + c);
                    if (c - 1 >= 0 && grid[r][c-1] == '1') uf.unite(r * nc + c, r * nc + c - 1);
                    if (c + 1 < nc && grid[r][c+1] == '1') uf.unite(r * nc + c, r * nc + c + 1);
                }
            }
        }

        return uf.getCount();
    }
};

複雜度分析

時間複雜度：O(MN∗α(MN))，其中 M 和 N 分別爲行數和列數。注意當使用路徑壓縮（見 find 函數）和按秩合併（見數組 rank）實現並查集時，單次操作的時間複雜度爲 α(MN)，其中 α(x) 爲反阿克曼函數，當自變量 x 的值在人類可觀測的範圍內（宇宙中粒子的數量）時，函數 α(x) 的值不會超過 55，因此也可以看成是常數時間複雜度。

空間複雜度：O(MN)，這是並查集需要使用的空間。

參考
https://leetcode-cn.com/problems/number-of-islands/solution/dao-yu-shu-liang-by-leetcode