LeetCode 994. 腐烂的橘子

题目

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

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。

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

题解

• 数组的广度优先遍历
  将腐烂的橘子装进队列，设置visited
  dist数组用来记录好橘子到腐烂橘子的距离
• 数组广度优先遍历队列存放两个坐标，设visited数组
• 树广度优先遍历队列存放节点
• 考虑问题可以从腐烂的橘子入手，而不是从头到尾遍历矩阵
• 超级源点问题

代码

class Solution {
public:
    static constexpr int dirs[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
    int orangesRotting(vector<vector<int>>& grid) {
        int m=grid.size(),n=grid[0].size();
        vector<vector<int>> dist(m, vector<int>(n));
        vector<vector<int>> visited(m, vector<int>(n));
        queue<pair<int, int>> q;

        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==2){
                    q.emplace(i,j);
                    visited[i][j]=1;
                }
                if(grid[i][j]==0){
                    visited[i][j]=1;
                }
            }
        }

        while(!empty(q)){
            auto [i,j]=q.front();
            q.pop();
            for(int k=0;k<4;k++){
                int ni=i+dirs[k][0];
                int nj=j+dirs[k][1];
                if(ni>=0&&nj>=0&&ni<m&&nj<n&&visited[ni][nj]==0)
                {
                    dist[ni][nj] = dist[i][j] + 1;
                    q.emplace(ni,nj);
                    visited[ni][nj]=1;
                }
            }
        }
        int res=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(visited[i][j]==0){
                    return -1;
                }
                res=max(res,dist[i][j]);
            }
        }        
        return res;
    }
};