LeetCode 994-腐烂的橘子

994. 腐烂的橘子 

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

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

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

这题是BFS，逐层腐化，需要注意的一个点是，记录时间，也就是BFS的层数，可以在每一轮BFS之前先记录队列中节点数，然后遍历完后时间++，考虑到又可能无法完全腐化，需要加入一个count记录新鲜水果数量，腐化后--，若最后count!=0,则返回-1代表无法完全腐化

import java.util.Deque;
import java.util.LinkedList;

/*
 * @lc app=leetcode.cn id=994 lang=java
 *
 * [994] 腐烂的橘子
 */

// @lc code=start
class Solution {
    public int orangesRotting(int[][] grid) {
        int n=grid.length,m=grid[0].length;
        int count=0;
        Deque<int[]>queue=new LinkedList<>();
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(grid[i][j]==2){
                    queue.offer(new int[]{i,j});
                }
                if(grid[i][j]==1){
                    count++;
                }
            }
        }
        int []moveX=new int[]{0,0,1,-1};
        int []moveY=new int[]{1,-1,0,0};
        int minute=0;
        for(;count>0&&!queue.isEmpty();minute++){
            int num=queue.size();
            for(int i=0;i<num;i++){
                int[]idx=queue.poll();
                int x=idx[0];
                int y=idx[1];
                for(int j=0;j<4;j++){
                    int newX=x+moveX[j];
                    int newY=y+moveY[j];
                    if(newX>=0&&newY>=0&&newX<n&&newY<m&&grid[newX][newY]==1){
                        grid[newX][newY]=2;
                        count--;
                        queue.offer(new int[]{newX,newY});
                    }
                }
            }
        }
        return count==0?minute:-1;
    }
}
// @lc code=end

超过100%，爽！