200. 岛屿数量

200. 岛屿数量

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

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

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

 

 

示例 1:

输入:
[
['1','1','1','1','0'],
['1','1','0','1','0'],
['1','1','0','0','0'],
['0','0','0','0','0']
]
输出: 1

示例 2:

输入:
[
['1','1','0','0','0'],
['1','1','0','0','0'],
['0','0','1','0','0'],
['0','0','0','1','1']
]
输出: 3

 

思路：DFS 递归

我们可以将二维网格看成一个无向图，竖直或水平相邻的 1 之间有边相连。
为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 1，则以其为起始节点开始进行深度优先搜索。在深度优先搜索的过程中，每个搜索到的 1 都会被重新标记为 0。
最终岛屿的数量就是我们进行深度优先搜索的次数。

时间复杂度 o(MN),其中 M 和 N 分别为行数和列数。空间复杂度o(MN)(全是陆地的情况)。

 

代码：

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int i, j, lr, lc;
        lr = grid.size();
        if(!lr)
            return 0;
        lc = grid[0].size();
        int island = 0;
        for(i = 0; i < lr; i++)
        {
            for(j = 0; j < lc; j++)
            {
                if(grid[i][j] == '1' && dfs(grid, i, j, lr, lc) >= 1)
                    island++;
            }
        }

        return island;

    }

    int dfs(vector<vector<char>>&grid, int i, int j, int lr, int lc)
    {
        if(i<0||i>=lr||j<0||j>=lc)
            return 0;
        if(grid[i][j]=='1')
        {
            grid[i][j] = '0';
            return dfs(grid, i-1, j, lr, lc)+dfs(grid, i+1, j, lr, lc)+dfs(grid, i, j-1, lr, lc)+dfs(grid, i, j+1, lr, lc)+1;
        }
        else
            return 0;
    }
};

 

思路：BFS 借助队列

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

 

时间复杂度：O(MN)，其中 M 和 N 分别为行数和列数。

空间复杂度：O(min(M,N))，在最坏情况下，整个网格均为陆地，队列的大小可以达到 min(M,N)。

 

代码：

class Solution {
    struct Node{
        int x, y;
    }node;
    int X[4] = {-1, 1, 0, 0};
    int Y[4] = {0, 0, -1, 1};
public:
    int numIslands(vector<vector<char>>& grid) {
        int i, j, lr, lc;
        lr = grid.size();
        if(!lr)
            return 0;
        lc = grid[0].size();
        int island = 0;
        for(i = 0; i < lr; i++)
        {
            for(j = 0; j < lc; j++)
            {
                if(grid[i][j] == '1')
                {
                    if(bfs(grid, i, j, lr, lc)>=1)
                    island++;
                }
                    
            }
        }

        return island;

    }

    int bfs(vector<vector<char>> &grid, int i, int j, int lr, int lc)
    {
        int count = 0;
        queue<Node> Q;
        node.x = i;
        node.y = j;
        Q.push(node);
        count++;
        grid[i][j] = '0';
        while(!Q.empty())
        {
            Node top = Q.front();
            Q.pop();
            for(int k = 0; k < 4; k++)
            {
                node.x = top.x + X[k];
                node.y = top.y + Y[k];
                if(node.x>=0&&node.x<lr&&node.y>=0&&node.y<lc&&grid[node.x][node.y]=='1')
                {
                    Q.push(node);
                    grid[node.x][node.y] = '0';
                    count++;
                }
            }
        }
        return count;
        
    }
};