994. 腐烂的橘子

问题描述

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

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

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

分析

多源bfs，while中用一层for循环控制多个源头同时bfs，这样一来while当层就等价于多个源头同时消耗时间。

代码

class Solution {
public:
    typedef pair<int, int> PII;
    int dx[4] = {-1, 0, 1, 0};
    int dy[4] = {0, 1, 0, -1};
    int fresh = 0;
    queue<PII> q;
    const static int N = 13;
    int st[N][N]; // 2是新鲜橘子，1是走过或者腐烂的橘子
    int xx = 0;
    int yy = 0;
    int res = 0;
    void bfs() {
        while(!q.empty() && fresh) {
            int n = q.size(); // n个源头同时扩散
            for (int x = 0; x < n; x++) {
                PII t = q.front();
                q.pop();
                for (int i = 0; i < 4; i++) { // 4个方向，若有新腐烂，放到下一次扩散，而不是跟当前的n个一起扩散
                    int a = t.first+dx[i]; int b = t.second+dy[i];
                    if (a < 0 || a > xx || b < 0 || b > yy) {
                        continue;
                    } else if (st[a][b] == 1) {
                        continue;
                    }
                    if (st[a][b] == 2) {
                        q.push(make_pair(a, b));
                        fresh--;
                    }
                    st[a][b] = 1;
                }
            }
            res++;
        }
    }
    int orangesRotting(vector<vector<int>>& grid) {
        xx = grid.size(); yy = grid[0].size();
        for (int i = 0; i < xx; i++) {
            for (int j = 0; j < yy; j++) {
                if (grid[i][j] == 1) {fresh++; st[i][j] = 2;}
                if (grid[i][j] == 2) {
                    q.push(make_pair(i, j));
                    st[i][j] = 1;
                }
            }
        }
        bfs();
        if (fresh == 0) {
            return res;
        } else {
            return -1;
        }
    }
};