题目

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

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

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

示例 1：

输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4
示例 2：

输入：grid = [[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。
示例 3：

输入：grid = [[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。
 

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 10
grid[i][j] 仅为 0、1 或 2

思路

BFS，传播的轮次起始就是距离腐烂橘子的路径长度。腐烂橘子可能不止一个，因此我们需要先将腐烂的橘子插入到队列中，然后进行遍历。初始化时记录好橘子的个数cnt值，然后如果被腐化了，则cnt--，最终若cnt>0则返回-1。

代码

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int d[20][20];//距离，传播的轮次
        memset(d, -1, sizeof d);
        int m = grid.size(), n = grid[0].size();
        int cnt = 0;//好橘子的个数
        int res = 0;//传播的轮次计数
        queue<pair<int, int>> q;
        //将所有烂橘子作为源点进行遍历
        for(int i = 0; i < m; i ++)
            for(int j = 0; j < n; j ++)
                {
                    if(grid[i][j] == 2)
                    {
                        d[i][j] = 0;
                        q.push({i, j});
                    }
                    else if(grid[i][j] == 1) cnt ++;//好橘子个数加一
                }

        //进行遍历
        while(q.size())
        {
            auto t = q.front();
            q.pop();
            int x = t.first, y = t.second;
            int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
            for(int i = 0; i < 4; i ++)//遍历四个方位
            {
                int a = dx[i] + x, b = dy[i] + y;
                if(a >= 0 && a < m && b >= 0 && b < n && grid[a][b] == 1 && d[a][b] == -1)
                {
                    d[a][b] = d[x][y] + 1;
                    res = max(res, d[a][b]);
                    q.push({a, b});
                    cnt --;
                }
            }
        }
        if(cnt > 0) return -1;
        return res;
    }
};