LeetCode-腐烂的橘子（宽度优先搜索）

（一）题目描述

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

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

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

（二） 解题思路

与上一题解题思路一样，首先将所有腐烂橘子横纵坐标加入队列，将橘子腐烂分钟数dist数组元素全部置为MAX_INT，然后对每个腐烂橘子进行广度遍历，比较原位置的dist与现位置dist+1的大小，然后取较小值作为当前坐标的dist，最后遍历dist，取其中的最大值返回。

（三）代码实现

class Solution {
    public int orangesRotting(int[][] grid) {
        int rowLen=grid.length;
        int colLen=grid[0].length;
        int[][] dist=new int[rowLen][colLen];
        int MAX_INT=100000;
//        初始化距离矩阵
        for (int i = 0; i < rowLen; i++) {
            for (int j = 0; j < colLen; j++) {
                dist[i][j]=MAX_INT;
            }
        }

        int[][] directions={{-1,0},{0,1},{1,0},{0,-1}};
        Queue<int[]> queue= new LinkedList<int[]>();
        for (int i = 0; i < rowLen; i++) {
            for (int j = 0; j < colLen; j++) {
                //将所有腐烂橘子加入队列
                if(grid[i][j]==2){
                    queue.offer(new int[]{i,j});
                    dist[i][j]=0;
                }

            }
        }

        //当队列不为null时循环
        while (!(queue.isEmpty())){
            int[] arr=queue.poll();
            int m=arr[0],n=arr[1];
            //遍历每一出队元素的四个方向，并更新对应方向的dist值
            for (int i = 0; i < 4; i++) {
                int newi=m+directions[i][0],newj=n+directions[i][1];
                if(newi>=0&&newi<rowLen&&newj>=0&&newj<colLen){
                    if(grid[newi][newj]==1){
                        if(dist[newi][newj]>dist[m][n]+1) {
                            dist[newi][newj] = dist[m][n] + 1;
                        }
                        //如果当前橘子腐烂了，则将其在grid中的值变为2并加入队列（以便grid中每个值都能被广度遍历）
                        grid[newi][newj]=2;
                        queue.offer(new int[]{newi,newj});
                    }
                }
            }
        }
        //如果grid中有1，则说明单元格中还有新鲜水果不能被腐烂，则返回-1
        for (int i = 0; i < rowLen; i++) {
            for (int j = 0; j <colLen ; j++) {
                if(grid[i][j]==1){
                    return -1;
                }
            }
        }

        int max=0;
        //找dist数组中的最大值
        for (int i = 0; i < rowLen; i++) {
            for (int j = 0; j < colLen; j++) {
                if(dist[i][j]!=MAX_INT){
                    max=dist[i][j]>max?dist[i][j]:max;
                }
            }
        }
        return max;
    }
}