【深度优先搜索】leetcode 200. 岛屿数量

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

提示

• $m==grid.length$
• $n==grid[i].length$
• $1<=m,n<=300$
• $grid[i][j]的值{为}^{\prime }{0}^{\prime }{或}^{\prime }{1}^{\prime }$

方法一：深度优先搜索

解题思路

我们可以将二维网格看成一个无向图，竖直或水平相邻的 1 之间有边相连。

为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 1，则以其为起始节点开始进行深度优先搜索。在深度优先搜索的过程中，每个搜索到的 1 都会被重新标记为 0。

最终岛屿的数量就是我们进行深度优先搜索的次数。

代码

class Solution {
public:
    const int dx[4] = {1, 0, -1, 0};
    const int dy[4] = {0, 1, 0, -1};
    void dfs(vector<vector<char>>& grid, int x, int y) {
        if(grid[x][y] == '0') return;
        grid[x][y] = '0';
        for(int i = 0; i < 4; i++)
        {
            int mx = x + dx[i], my = y + dy[i];
            if(mx >= 0 && mx < grid.size() && my >= 0 && my < grid[0].size())
                dfs(grid, mx, my);
        }
    }
    int numIslands(vector<vector<char>>& grid) {
        int cnt = 0;
        int nr = grid.size();
        if(!nr) return 0;
        int nc = grid[0].size();
        for(int r = 0; r < nr; r++)
        {
            for(int c = 0; c < nc; c++)
            {
                if(grid[r][c] == '1')
                {
                    cnt++;
                    dfs(grid, r, c);
                }
            }
        }
        return cnt;
    }
};

复杂度分析

• 时间复杂度：$O(m\ast n)$。
• 空间复杂度：$O(m\ast n)$。

方法二：广度优先搜索

解题思路

同样地，我们也可以使用广度优先搜索代替深度优先搜索。

为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 1，则将其加入队列，开始进行广度优先搜索。在广度优先搜索的过程中，每个搜索到的 1 都会被重新标记为 0。直到队列为空，搜索结束。

最终岛屿的数量就是我们进行广度优先搜索的次数。

代码

class Solution {
public:
    const int dx[4] = {1, 0, -1, 0};
    const int dy[4] = {0, 1, 0, -1};
    int numIslands(vector<vector<char>>& grid) {
        int cnt = 0;
        int nr = grid.size();
        if(!nr) return 0;
        int nc = grid[0].size();
        for(int r = 0; r < nr; r++)
        {
            for(int c = 0; c < nc; c++)
            {
                if(grid[r][c] == '1')
                {
                    cnt++;
                    queue<pair<int, int>> neighbours;
                    neighbours.push({r, c});
                    while(!neighbours.empty())
                    {
                        auto rc = neighbours.front();
                        neighbours.pop();
                        int row = rc.first, col = rc.second;
                        for(int i = 0; i < 4; i++)
                        {
                            int mx = row + dx[i], my = col + dy[i];
                            if(mx >= 0 && mx < nr && my >= 0 && my < nc && grid[mx][my] == '1')
                            {
                                grid[mx][my] = 0;
                                neighbours.push({mx, my});
                            }
                        }
                    }
                }
            }
        }
        return cnt;
    }
};

复杂度分析

• 时间复杂度：$O(m\ast n)$。
• 空间复杂度：$O(min(m,n))$。