力扣 hot100 Day53

200. 岛屿数量

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

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

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

//改写的
class Solution {

public:
    void dft(vector>& grid,int i,int j)
    {
        grid[i][j]='0';
        if(i-1>=0&&grid[i-1][j]=='1')dft(grid,i-1,j);
        if(i+1=0&&grid[i][j-1]=='1')dft(grid,i,j-1);
        if(j+1>& grid) {
        int num=0;
        for(int i=0;i

基本的dft递归逻辑，先判断再递归可以减少递归次数

//抄的
class Solution {
public:
    int numIslands(vector>& grid) {
        if (grid.empty() || grid[0].empty()) return 0;
        
        int m = grid.size();
        int n = grid[0].size();
        int islands = 0;
        
        int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == '1') {
                    ++islands;
                    queue> q;
                    q.push({i, j});
                    grid[i][j] = '0'; 
                    //弹出推入循环，直至队列变空
                    while (!q.empty()) {
                        auto [x, y] = q.front();
                        q.pop();
                        for (auto [dx, dy] : dirs) {
                            int nx = x + dx;
                            int ny = y + dy;
                            if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] == '1') {
                                grid[nx][ny] = '0';
                                q.push({nx, ny});
                            }
                        }
                    }
                }
            }
        }
        
        return islands;
    }
};

bfs算法，利用队列逐步排除每个岛屿，引入方向数组方便操作

994. 腐烂的橘子

在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：

• 值 0 代表空单元格；
• 值 1 代表新鲜橘子；
• 值 2 代表腐烂的橘子。

每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。

//抄的
class Solution {
public:
    int orangesRotting(vector>& grid) {
        if (grid.empty() || grid[0].empty()) return 0;
        
        int m = grid.size();
        int n = grid[0].size();
        queue> q;
        int fresh = 0;
        int time = 0;

        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 2) {
                    q.push({i, j});
                } else if (grid[i][j] == 1) {
                    fresh++;
                }
            }
        }
        
        if (fresh == 0) return 0;
        
        int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        
        while (!q.empty() && fresh > 0) {
            int size = q.size();
            for (int i = 0; i < size; ++i) {
                auto [x, y] = q.front();
                q.pop();
                for (auto [dx, dy] : dirs) {
                    int nx = x + dx, ny = y + dy;
                    if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] == 1) {
                        grid[nx][ny] = 2;
                        q.push({nx, ny});
                        fresh--;
                    }
                }
            }
            if (!q.empty()) time++; // 时间增加（处理完上下左右一层）
        }
        return fresh == 0 ? time : -1;
    }
};

由于需要一层一层记录天数，所以需要用bfs算法

所有腐烂的橘子同步开始传染，所以先遍历找到所有烂橘子加入队列

队列中每完成一轮上下左右传染，时间加一

最后检测fresh是否全部被传染