牛客热题：岛屿数量

📟作者主页：慢热的陕西人

🌴专栏链接：力扣刷题日记

📣欢迎各位大佬👍点赞🔥关注🚓收藏，🍉留言

牛客热题：岛屿数量

题目链接

岛屿数量_牛客题霸_牛客网 (nowcoder.com)

方法一：dfs

思路

1. 深度优先搜索（DFS）
   • dfs 函数用于遍历给定位置 (x, y) 的所有相邻陆地块。如果一个位置是陆地 (‘1’)，则将其置为 ‘0’ 以避免重复遍历。
   • 从当前块向上下左右四个方向递归进行深度优先搜索。
2. 岛屿计数
   • solve 函数中遍历整个矩阵，对每个位置 (i, j) 进行检查。
   • 如果发现当前位置是陆地 (‘1’)，则说明发现了一个新的岛屿，岛屿计数器 count 加一，并调用 dfs 函数将这个岛屿的所有部分标记为 ‘0’。

代码

void dfs(vector<vector<char>>& grid, int x, int y)
    {
        if(x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] == '0')
        return ;

        //将当前pos的位置置为0
        grid[x][y] = '0';
    
        dfs(grid, x - 1, y);
        dfs(grid, x, y + 1);
        dfs(grid, x + 1, y);
        dfs(grid, x, y - 1);
    }
    int solve(vector<vector<char>>& grid) 
    {
        int n = grid.size();
        int m = grid[0].size();

        int count = 0;

        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(grid[i][j] == '1')
                {
                    count++;

                    //将其岛屿内的pos都置为0
                    dfs(grid, i, j);
                }
            }
        }

        return count;
    }

复杂度

时间复杂度

• 遍历整个矩阵需要 O(m * n) 的时间。
• 在最坏情况下，每个位置都需要进行递归遍历，且每个位置只会被访问一次。因此，深度优先搜索也会在 O(m * n) 时间内完成。

综合以上两者，整体时间复杂度为: O(m * n)

空间复杂度

• 主要的空间消耗来自深度优先搜索的递归调用栈。
• 在最坏情况下，递归栈的深度与矩阵的较大维度成正比，即矩阵的行数或列数中的较大者。

因此，空间复杂度为: O(min⁡(m,n))

方法二：bfs

思路

1. BFS 函数
   • bfs 函数用于从给定位置 (x, y) 开始进行广度优先搜索。使用队列 q 来存储待处理的陆地块。
   • 标记开始位置为 ‘0’，然后将其加入队列。
   • 使用一个 directions 向量来存储可能的四个移动方向（上、右、下、左）。
   • 在队列非空时，不断处理队列中的元素，检查四个方向上的相邻块，如果是陆地（‘1’），将其置为 ‘0’ 并加入队列进行后续处理。
2. 岛屿计数
   • solve 函数遍历整个矩阵，对于每个陆地块（‘1’），调用 bfs 函数，并增加岛屿计数。

代码

void bfs(vector<vector<char>>& grid, int x, int y) {
    int n = grid.size();
    int m = grid[0].size();
    
    queue<pair<int, int>> q;
    q.push({x, y});
    grid[x][y] = '0'; // 标记为已访问

    // 定义四个可能的移动方向：上、右、下、左
    vector<pair<int, int>> directions = {
        {-1, 0},
        {0, 1},
        {1, 0},
        {0, -1}
    };

    while (!q.empty()) {
        auto [curX, curY] = q.front();
        q.pop();

        for (auto [dx, dy] : directions) {
            int newX = curX + dx;
            int newY = curY + dy;

            if (newX >= 0 && newX < n && newY >= 0 && newY < m && grid[newX][newY] == '1') {
                grid[newX][newY] = '0';
                q.push({newX, newY});
            }
        }
    }
}

int solve(vector<vector<char>>& grid) {
    int n = grid.size();
    int m = grid[0].size();

    int count = 0;

    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (grid[i][j] == '1') {
                count++;
                bfs(grid, i, j);
            }
        }
    }

    return count;
}

复杂度

时间复杂度

• 与 DFS 实现类似，整体复杂度仍然为遍历矩阵的时间加上遍历所有相邻陆地块的时间。
• 时间复杂度为 O(m * n)。

空间复杂度

• BFS 使用队列来存储待处理的陆地块。最坏情况下队列会包含矩阵中的所有元素。
• 空间复杂度为 O(m * n)。