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

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

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

提示：

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

题解1 多源广度优先搜索

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        int fresh = 0;
        int ret = 0;
        deque<pair<int, int>> q;
        // 每个新鲜橘子被腐烂的最短时间
        // 本身就腐烂的是0，没腐烂的是初始值-1
        int dis[10][10];
        memset(dis, -1, sizeof(dis));
        int dir_x[4]={0, 1, 0, -1};
        int dir_y[4]={1, 0, -1, 0};
        // 先查有没有腐烂的橘子
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == 2){
                    q.push_back(make_pair(i, j));
                    dis[i][j] = 0;
                }
                else if(grid[i][j] == 1)
                    fresh ++;
            }
        }

        // 没有新鲜橘子
        if(! fresh)
            return 0;
        else{
            while(q.size()){
                auto x = q.front();
                q.pop_front();
                for(int i = 0; i < 4; i++){
                    int tmpx = x.first + dir_x[i];
                    int tmpy = x.second + dir_y[i];
                    // ~(0) = 1
                    // 意思是碰到本来就烂的橘子先跳过？
                    if(tmpx < 0 || tmpy < 0 || tmpx >= m || tmpy >= n || !grid[tmpx][tmpy] || ~dis[tmpx][tmpy])
                    continue;
                    // 保证一层一层扩，不会多加
                    dis[tmpx][tmpy] = dis[x.first][x.second]+1;
                    q.push_back(make_pair(tmpx,tmpy));
                    if(grid[tmpx][tmpy] == 1){
                        fresh --;
                        ret = dis[tmpx][tmpy];
                        if(! fresh)
                            break;
                    }
                }
            }
        }
        return fresh ? -1 : ret; 
    }   
};

另一种写法

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        int fresh = 0;
        int ret = 0;
        deque<pair<int, int>> q;

        int dir_x[4]={0, 1, 0, -1};
        int dir_y[4]={1, 0, -1, 0};
        
        // 先查有没有腐烂的橘子
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == 2){
                    q.push_back(make_pair(i, j));
                }
                else if(grid[i][j] == 1)
                    fresh ++;
            }
        }

        // 没有新鲜橘子
        if(! fresh)
            return 0;
        else{
            while(fresh && q.size()){
                int t = q.size();
                ret ++;

                while(t --){

                    auto x = q.front();
                    q.pop_front();

                    for(int i = 0; i < 4; i++){

                        int tmpx = x.first + dir_x[i];
                        int tmpy = x.second + dir_y[i];

                        if(tmpx < 0 || tmpy < 0 || tmpx >= m || tmpy >= n || !grid[tmpx][tmpy])
                            continue;
                        
                        if(grid[tmpx][tmpy] == 1){
                            fresh --;
                            grid[tmpx][tmpy] = 2;
                            q.push_back(make_pair(tmpx,tmpy));
                            if(! fresh)
                                break;
                        }
                    }
                }
            }
        }
        return fresh ? -1 : ret; 
    }   
};