994. 腐烂的橘子

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

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

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

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

 思路：先将刚开始的怀橘子入队列，利用这些怀橘子来带出一批新的怀橘子，

if(grid.empty())return 0;

        int row = grid.size();

        int col = grid[0].size();

        queue<Node> bad;

        for(int i = 0; i < row; i++)

            for(int j = 0; j < col; j++)

                if(grid[i][j] == 2)

                    bad.push(Node(i,j));    // 将所有怀橘子入队列

如果条件满足那么每分钟都会有怀橘子腐烂新橘子，如果有新的怀橘子加入，那么step才能加加

int step = 0;

        while(!bad.empty())

        {

            bool flag = 0;      //设置标志位，每一轮是否有橘子发生腐烂

            int size = bad.size();

            while(size--)

            {

                Node cur = bad.front();     // 对当前队列中所有坏橘子周围好橘子进行一次感染

                bad.pop();

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

                {

                    int newX = cur.x + nextP[i][0];        //对新位置元素的更新判断

                    int newY = cur.y + nextP[i][1];

                    if(newX<0||newX>=row||

                       newY<0||newY>=col)

                       continue;

                    if(grid[newX][newY]==1)

                    {

                        grid[newX][newY]=2;        

                        bad.push(Node(newX, newY));

                        flag=1;

                    }

                }

            }

            if(flag)

                step++; // 每执行一轮大循环，时间++

        }

最后BFS执行完之后，说明所有可以被腐烂的都完成了，再去遍历grid,如何还有
值为1的，说明没有办法完全腐烂，返回-1,如果没有，则返回step

        for(int i = 0; i < row; i++)    // 检测是否有橘子还是好的

            for(int j = 0; j < col; j++)

                if(grid[i][j] == 1)

                    return -1;

        return step;

源码：

int nextP[4][2] = {{0,-1},{0,1},{1,0},{-1,0}};
struct Node
{
    int x;
    int y;
    Node(int a, int b)
    {
        x = a;
        y = b;
    }
};
class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        if(grid.empty())return 0;
        int row = grid.size();
        int col = grid[0].size();
        queue<Node> bad;
        for(int i = 0; i < row; i++)
            for(int j = 0; j < col; j++)
                if(grid[i][j] == 2)
                    bad.push(Node(i,j));    // 将所有怀橘子入队列
        int step = 0;
        while(!bad.empty())
        {
            bool flag = 0;      //设置标志位，每一轮是否有橘子发生腐烂
            int size = bad.size();
            while(size--)
            {
                Node cur = bad.front();     // 对当前队列中所有坏橘子周围好橘子进行一次感染
                bad.pop();
                for(int i = 0; i < 4; i++)
                {
                    int newX = cur.x + nextP[i][0];
                    int newY = cur.y + nextP[i][1];
                    if(newX<0||newX>=row||
                       newY<0||newY>=col)
                       continue;
                    if(grid[newX][newY]==1)
                    {
                        grid[newX][newY]=2;
                        bad.push(Node(newX, newY));
                        flag=1;
                    }
                }
            }
            if(flag)
                step++; // 每执行一轮大循环，时间++
        }
        for(int i = 0; i < row; i++)    // 检测是否有橘子还是好的
            for(int j = 0; j < col; j++)
                if(grid[i][j] == 1)
                    return -1;
        return step;
    }
};

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/rotting-oranges
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。