LeetCode 200.岛屿数量

题目

LeetCode 200.岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。

示例 1：
输入：grid = [
[“1”,“1”,“1”,“1”,“0”],
[“1”,“1”,“0”,“1”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“0”,“0”,“0”]
]
输出：1

示例 2：
输入：grid = [
[“1”,“1”,“0”,“0”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“1”,“0”,“0”],
[“0”,“0”,“0”,“1”,“1”]
]
输出：3

思路

DFS
要点1：为了得出岛屿数量，需要先遍历二维数组，如果当前位置是陆地，即1， 则以其为起始点使用DFS算法找到整块岛屿，并使岛屿数量+1。

要点2：使用DFS遍历岛屿的过程，其实是图的遍历，需要使用visited数组去记录是否已经访问过，以防止重复遍历同一个点。
对于此题， 有一个技巧是直接在DFS时将当前点从1置为0，即所有访问过的点都已经置为0，之后的dfs过程如果访问到这个点会直接返回，作用等同于visited数组。

BFS的思路类似
为了求出岛屿的数量，先扫描整个二维数组。如果当前位置为 1，则将其加入队列，开始进行广度优先搜索。直到队列为空，搜索结束。
同样，在广度优先搜索的过程中，将搜索到的 1 重新标记为 0。

代码（cpp）

1.DFS

class Solution {
public:
    int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
    
    int numIslands(vector<vector<char>>& grid) {
        int res = 0;        
        int m = grid.size(), n = grid[0].size();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '1') res++;
                dfs(grid, i, j);
            }
        }
        return res;
    }

    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) return;
        if (grid[i][j] == '0') return;
        
        grid[i][j] = '0';

        for (int k = 0; k < 4; k++) {
            dfs(grid, i + dx[k], j + dy[k]);
        }
    }

};

2.BFS

class Solution {
public:
    int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
    int numIslands(vector<vector<char>>& grid) {
        int res = 0;
        int m = grid.size(), n = grid[0].size();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '1') {
                    res++;
                    grid[i][j] = '0';
                    
                    queue<pair<int, int>> que;
                    que.push({i, j});
                    
                    while (!que.empty()) {
                        auto node = que.front();
                        que.pop();

                        for (int k = 0; k < 4; k++) {
                            int nx = node.first + dx[k], ny = node.second + dy[k];
                            if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
                            if (grid[nx][ny] == '1') que.push({nx, ny}), grid[nx][ny] = '0';
                        }
                    }
                }
            }
        }
        return res;
    }
};

总结

DFS
时间复杂度：$O(mn)$, m、n分别为二维数组行数、列数；
空间复杂度：$O(mn)$， dfs的深度，最坏情况下全是陆地1时，达到$mn$；

BFS
时间复杂度：$O(mn)$, m、n分别为二维数组行数、列数；
空间复杂度：$O(min(m,n))$， 队列的大小，最坏情况下全是陆地1时，达到$min(m,n))$；