力扣每日一题-994

题目

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

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

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

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

示例1：

输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4

示例 2：

输入：grid = [[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。

示例 3：

输入：grid = [[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

思路

是一个层次遍历的问题，要求最短时间，考虑用dfs(深度优先遍历)，根据不同的状态，修改腐烂后的状态

解题方法

由于我们如果直接对原图（二维数组）进行遍历，会发现还未腐烂的提前腐烂。于是我们需要对原数组进行新建和修改，对其-2，使得-2为空，-1为未腐烂，0为腐烂。建立的新表,用t来表示当前要腐烂的橘子，t为次数；用f来进行判断遍历的结束，最后再判断是否有为腐烂的橘子

代码

class Solution {
    public int orangesRotting(int[][] grid) {
        int m=grid.length;
        int n=grid[0].length;
        int ans;
        int time[][]=new int[m][n];
        int t=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                time[i][j]=grid[i][j]-2;
            }
        }
        while(true){
            boolean f=false;
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                    if(time[i][j]==t){
                        if(i-1>=0&&time[i-1][j]==-1){
                            time[i-1][j]=t+1;
                            f=true;
                        }
                        if(i+1<m&&time[i+1][j]==-1){
                            time[i+1][j]=t+1;
                            f=true;
                        }
                        if(j-1>=0&&time[i][j-1]==-1){
                            time[i][j-1]=t+1;
                            f=true;
                        }
                        if(j+1<n&&time[i][j+1]==-1){
                            time[i][j+1]=t+1;
                            f=true;
                        }

                    }
                }
            }
            if(!f)
            break;
            t++;
        }
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(time[i][j]==-1){
                    return -1;
                }
            }
        }
        return t;
    }
}