994. 腐烂的橘子

问题描述

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

• 0 代表空单元格

• 1 代表新鲜橘子

• 2 代表腐烂橘子

每分钟，任何与腐烂橘子相邻（4个方向）的新鲜橘子都会腐烂。返回直到没有新鲜橘子为止所需的最小分钟数。如果不可能使所有橘子都腐烂，则返回-1。

注意到每分钟橘子会向四个方向传播腐烂，这种情况适合采用BFS（广度优先搜索）算法进行求解，因为BFS具有"逐层"搜索的特性，能够有效模拟橘子的腐烂过程。

具体思路

我们使用一个fresh变量来记录新鲜橘子的数量，同时用一个数组存储腐烂橘子的位置。遍历腐烂橘子时，如果发现相邻位置有新鲜橘子，就将其变为腐烂状态（grid[i][j] = 2），并将新腐烂的橘子加入数组，作为下一轮处理的起点。每轮遍历耗时一分钟。最终，如果fresh仍大于0，说明无法使所有橘子腐烂；否则，返回总耗时。

代码

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int m = grid.size(),n = grid[0].size();
        int fresh = 0;//新鲜橘子的数量
        vector<pair<int,int>> q;//当前弗兰的橘子
        for (int i = 0;i < m;i++) {
            for (int j = 0;j < n;j++) {
                if (grid[i][j] == 1) fresh++;
                else if (grid[i][j] == 2) {
                    q.push_back({i,j});
                }
            }
        }
        vector<vector<int>> dic = {{0,1},{0,-1},{1,0},{-1,0}};
        int ans = 0;
        while (fresh && !q.empty()) {
            vector<pair<int,int>> nxt;//下一层橘子
            ans++;
            for (auto it:q) {
                int x = it.first,y = it.second;
                for (int i = 0;i < 4;i++) {
                    int bx = x + dic[i][0],by = y + dic[i][1];
                    if (bx < 0 || bx >= m || by < 0 || by >= n || grid[bx][by] != 1) continue;
                    grid[bx][by] = 2;
                    nxt.push_back({bx,by});
                    fresh--;
                }
            }
            q = move(nxt);
        }
        if(fresh > 0) {
            return -1;
        }else{
            return ans;
        }
    }
};

时间复杂度：O(m*n),m，n为矩阵的行列数，每个格子最多遍历一次

空间复杂度：O(m*n),最坏时，将所有腐烂的橘子存储