leetcode—— 腐烂的橘子

腐烂的橘子

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

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

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

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

示例 1：

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

问题：

java.lang.ArrayIndexOutOfBoundsException: Index 1 out of bounds for length 1
  at line 36, Solution.orangesRotting
  at line 54, __DriverSolution__.__helper__
  at line 84, __Driver__.main

class Solution {
    public int orangesRotting(int[][] grid) {
       // 获取数组的行数和列数
       int rows = grid.length;
       int cols = grid[0].length;
       // 创建一个队列 用于存储橘子的信息
       Queue<int[]> queue = new LinkedList<>();
       // 初始化新鲜橘子的数量 0 
       int count = 0;

       for(int row = 0; row < grid.length; row++){
           for(int col = 0; col < grid[0].length; col++){
               // 若为新鲜橘子 count++
               if(grid[row][col] == 1){
                   count++;
               }else if(grid[row][col] == 2){
                   // 若为腐烂橘子 将其坐标信息入队
                   queue.add(new int[]{row, col});

               }
           }
       }

       // 初始化腐烂的轮数（分钟数）
       int sumMin = 0;

       // 当还有新鲜橘子或者队列不为空时，继续腐烂橘子
       while(count != 0 || ! queue.isEmpty()){
           sumMin ++;   // 每经过一轮循环，分钟数加一
           // 获取队列的长度
           int queLen = queue.size();
           for(int i = 0; i < queLen; i++){
               // 出队一个腐烂橘子的信息 并获取其坐标
               int[] orange = queue.poll();
               int r = orange[0];
               int c = orange[1];

               // 检查该腐烂橘子的上下左右橘子  若为新鲜橘子 对其进行腐烂处理 并入队
               // 上
               if(r-1 > 0 && grid[r-1][c] == 1){
                   // 标记为腐烂并且入队
                   grid[r-1][c] = 2;
                   count--;
                   queue.add(new int[]{grid[r-1][c]});
               }
               // 下
               if(r+1 < rows && grid[r+1][c] == 1){
                   // 标记为腐烂并且入队
                   grid[r+1][c] = 2;
                   count--;
                   queue.add(new int[]{grid[r+1][c]});
                }
                // 左
                if(c-1 > 0 && grid[r][c-1] == 1){
                   // 标记为腐烂并且入队
                   grid[r][c-1] = 2;
                   count--;
                   queue.add(new int[]{grid[r][c-1]});
                 }
                 // 右
                if(c+1 < cols && grid[r][c+1] == 1){
                   // 标记为腐烂并且入队
                   grid[r][c+1] = 2;
                   count--;
                   queue.add(new int[]{grid[r][c+1]});
                }
           }
       }
       // 若遍历完还存在新鲜橘子 返回-1
       if(count > 0){
           return -1;
       }else{
           return sumMin;   // 返回腐烂所有橘子需要的时间
       }
    }
}