[Leetcode]994.腐烂的橘子(广度优先搜索)

994.腐烂的橘子

难度 : 中等
在给定的网格中，每个单元格可以有以下三个值之一：
值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。
返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。



由题目我们可以知道烂橘子会蔓延，并且是像自己的上下左右四个方向蔓延，蔓延过程中会将新鲜的橘子变为腐烂的橘子。通过这一点我们可以看出这个过程很类似于广度优先搜索，最后是让我们返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数，如果不可能，返回 -1。所以这个问题我们利用广度优先搜索来解决这个问题。其次还要知道广度优先搜索是通过队列来实现的。

具体实现和解释看下面代码和注释。

class Solution {
    public int orangesRotting(int[][] grid) {
       int[][] arr = {{-1,0},{1,0},{0,-1},{0,1}};  //方向矩阵
        int row = grid.length;
        int col = grid[0].length;
        Queue<int[]> q = new LinkedBlockingQueue<>();
        //找出所有坏橘子
        for(int i = 0;i < row; i++){
            for(int j = 0;j < col; j++){
                if(grid[i][j] == 2)
                    q.add(new int[]{i,j});
            }
        }
        int minute = 0;
        while(!q.isEmpty()){
            boolean flag = false; //用来标记最后有没有新鲜橘子腐烂
            //获取坏橘子数
            int size = q.size();
            for(int i = size;i > 0; i--){
                int[] orange = q.poll();
                int r = orange[0], c = orange[1];
                //调用方向矩阵来走上下左右的过程
                for(int j = 0;j < 4; j++){
                    int nr = r + arr[j][0];
                    int nc = c + arr[j][1];
                    //如果是新鲜橘子变坏入队
                    if(0 <= nr && nr < row && 0 <= nc && nc < col && grid[nr][nc] == 1){
                            flag = true;
                            grid[nr][nc] = 2;
                            q.add(new int[]{nr,nc});
                    }
                }
            }
            if(flag == true)
                minute++;
        }
        //判断剩下的橘子是否还有还有坏橘子
        for(int i = 0;i < row; i++){
            for(int j = 0;j < col; j++){
                if(grid[i][j] == 1)
                    return -1;
            }
        }
        return minute;
    }
}

运行结果(挑战全力扣最慢) :

如果有写的不对的或者还可以优化的，还请多多指出。