hot100-腐烂的橘子

思路

每个腐烂橘子向四周感染一次，直到没有新鲜橘子所需的最少时间。其中一定设计图的遍历，那么是DFS还是BFS？因为要求一层层感染完的最少时间，所以用BFS。即把腐烂橘子放入队列，每次感染一波出队，再把新感染的入队，直到所有腐烂橘子都向四周感染过一次。

为了判断是否有橘子永远不会被感染，还要记录一开始的新鲜橘子数。

代码

• 遍历所有橘子，腐烂入队，新鲜的让新鲜橘子数+1
• BFS框架

class Solution {
public: 
    int orangesRotting(vector<vector<int>>& grid) {
        int fresh=0;// 有多少个新鲜橘子——最后判断是否有橘子永远不会腐烂
        int times=0;
        queue<pair<int,int>> q;
        int m=grid.size();
        int n=grid[0].size();
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==2){
                    q.push({i,j});
                }else if(grid[i][j]==1){
                    fresh++;
                }
            }
        }
        vector<vector<int>> dirs = {{-1,0},{1,0},{0,-1},{0,1}};
        while(!q.empty()){
            int num = q.size();
            bool rotten=false;//这一层有橘子被腐烂了才能让时间++
            for(int i=0;i<num;i++){
                auto x = q.front();
                q.pop();
                for(auto dir : dirs){
                    int i=x.first + dir[0];
                    int j=x.second + dir[1];
                    if(i>=0&&i<m&&j>=0&&j<n&&grid[i][j]==1){
                        fresh--;
                        rotten = true;
                        grid[i][j]=2;
                        q.push({i,j});
                    }
                }
            }
            if(rotten==true)times++;
        }

        return fresh==0 ? times : -1;

    }
};