看完题我觉得这不是和上一道岛屿的题一样简单嘛，然后写了将近2个小时才写出来，我的思路就是，用check()先对grid检查一下，是否有以下情况：

（如果有1的周围都是空，则这个位置用不腐烂，返回-1； 如果全是1，返回永不腐烂，返回-1；如果没有2，永不腐烂，则返回-1），

定义一个hasFresh（）方法看grid中是不是还有fresh的橘子1，然后在orangesRotting()方法算minute。

就是在while（hasFresh())中对grid全部扫描一遍，如果有2，就把它放进栈中，扫描完了就把这些2的坐标拿出来，然后把2的周围的1变成2调用turnRot()，这算是变腐烂了1次，minute++，然后又是while去检查是否还有fresh，如果还有就继续腐烂，最后直到没有了fresh就跳出循环返回minute。

但是如果是一列2，2，1，0，1，1就出现死循环了，因为第一个1腐烂后无法去腐烂后面但是又始终hasFresh，

于是我加了一个visit布尔数组，如果发现了一个2并且它没有visit才把它放进栈，然后visit改为true表示已经用它腐烂过周围了不能再次腐烂周围了，下次扫面到这个2就不会放进栈了，那么上面的情况就当第一个1变成2并且visit后就没有可以放进栈的2了，所以扫描一遍后stack还是empty，所以当扫描一遍后stack还是empty的话直接返回-1，

以下是我的代码：

class Solution {
    public int orangesRotting(int[][] grid) {
       int m = grid.length;
       int n = grid[0].length;
       int minute =0;
       boolean[][] visit = new boolean[m][n];
       if(check(grid) == -1)return -1;
       while(hasFresh(grid)){
           Stack<Integer[]> stack = new Stack<>(); 
           for(int i =0;i<m;i++){
           for(int j=0;j<n;j++){
              if(grid[i][j] == 2 && visit[i][j] == false){
                  visit[i][j] = true;
                  Integer[] index = new Integer[]{i,j};
                  stack.push(index);
              }
           }
         }
         if(stack.isEmpty()){
             return -1;
         }
          while(!stack.isEmpty()){
            Integer[] a = stack.pop();
            grid = turnRot(grid, a[0], a[1]);
        }
        minute++;
       }

       return minute;
      

    }

    public int[][] turnRot(int[][] grid, int i, int j){
        if(i-1>=0 && grid[i-1][j]==1)grid[i-1][j] = 2;
        if(i+1<grid.length && grid[i+1][j]==1)grid[i+1][j] = 2;
        if(j-1>=0 && grid[i][j-1]==1)grid[i][j-1] = 2;
        if(j+1<grid[0].length && grid[i][j+1]==1)grid[i][j+1] = 2;
        return grid;
    }

    public boolean hasFresh(int[][] grid){
        int m = grid.length;
       int n = grid[0].length;
       for(int i =0;i<m;i++){
           for(int j=0;j<n;j++){
              if(grid[i][j] == 1)return true;
           }
       }
       return false;
    }

    public int check(int[][] grid){
        int m = grid.length;
       int n = grid[0].length;
       
       //如果有1的周围都是空，则这个位置用不腐烂，返回-1
       for(int i =0;i<m;i++){
           for(int j=0;j<n;j++){
              if((grid[i][j] == 1)){
                   if(i-1>=0 && grid[i-1][j]!=0)continue;
                   if(i+1<grid.length && grid[i+1][j]!=0)continue;
                   if(j-1>=0 && grid[i][j-1]!=0)continue;
                   if(j+1<grid[0].length && grid[i][j+1]!=0)continue;
                   return -1;
              }
           }
       }
 
       if(statuCode == 0)return 0;
        //如果全是1，返回永不腐烂，返回-1
        statuCode = -1;
       for(int i =0;i<m;i++){
           for(int j=0;j<n;j++){
              if(grid[i][j] != 1){
                  statuCode =1;
              }
           }
       }
       if(statuCode == -1)return -1;
        //如果没有2，用不腐烂，则返回-1
        statuCode =-1;
      for(int i =0;i<m;i++){
           for(int j=0;j<n;j++){
              if(grid[i][j] == 2){
                  statuCode=1;
              }
           }
       }
       if(statuCode == -1)return -1;

       return 1;
    }

}

我这个算法写的太屎了，尤其是check方法全靠一种一种情况排除，还是看看官方题解吧，写到这里的时候，我想去看看check方法能不能优化一下，把有些情况放一起check，比如那个全是1就不用判断了，因为它包含在没有2的情况里面，但是你猜怎么了？

我发现有了visit数组后，check中的所有情况都不用check，因为他们都是使得stack为空，直接返回-1了，我只能说牛逼。所以可以删掉check方法，改成代码如下：

class Solution {
    public int orangesRotting(int[][] grid) {
       int m = grid.length;
       int n = grid[0].length;
       int minute =0;
       boolean[][] visit = new boolean[m][n];
      
       while(hasFresh(grid)){
           Stack<Integer[]> stack = new Stack<>(); 
           for(int i =0;i<m;i++){
           for(int j=0;j<n;j++){
              if(grid[i][j] == 2 && visit[i][j] == false){
                  visit[i][j] = true;
                  Integer[] index = new Integer[]{i,j};
                  stack.push(index);
              }
           }
         }
         if(stack.isEmpty()){
             return -1;
         }
          while(!stack.isEmpty()){
            Integer[] a = stack.pop();
            grid = turnRot(grid, a[0], a[1]);
        }
        minute++;
       }

       return minute;
      

    }

    public int[][] turnRot(int[][] grid, int i, int j){
        if(i-1>=0 && grid[i-1][j]==1)grid[i-1][j] = 2;
        if(i+1<grid.length && grid[i+1][j]==1)grid[i+1][j] = 2;
        if(j-1>=0 && grid[i][j-1]==1)grid[i][j-1] = 2;
        if(j+1<grid[0].length && grid[i][j+1]==1)grid[i][j+1] = 2;
        return grid;
    }

    public boolean hasFresh(int[][] grid){
        int m = grid.length;
       int n = grid[0].length;
       for(int i =0;i<m;i++){
           for(int j=0;j<n;j++){
              if(grid[i][j] == 1)return true;
           }
       }
       return false;
    }

}

看看官方题解的做法吧，题解用的叫多源广度优先搜索，和上一道题岛屿的数量的解法差不多，先上代码：

class Solution {
    int[] dr = new int[]{-1, 0, 1, 0};
    int[] dc = new int[]{0, -1, 0, 1};

    public int orangesRotting(int[][] grid) {
        int R = grid.length, C = grid[0].length;
        Queue<Integer> queue = new ArrayDeque<Integer>();
        Map<Integer, Integer> depth = new HashMap<Integer, Integer>();
        for (int r = 0; r < R; ++r) {
            for (int c = 0; c < C; ++c) {
                if (grid[r][c] == 2) {
                    int code = r * C + c;
                    queue.add(code);
                    depth.put(code, 0);
                }
            }
        }
        int ans = 0;
        while (!queue.isEmpty()) {
            int code = queue.remove();
            int r = code / C, c = code % C;
            for (int k = 0; k < 4; ++k) {
                int nr = r + dr[k];
                int nc = c + dc[k];
                if (0 <= nr && nr < R && 0 <= nc && nc < C && grid[nr][nc] == 1) {
                    grid[nr][nc] = 2;
                    int ncode = nr * C + nc;
                    queue.add(ncode);
                    depth.put(ncode, depth.get(code) + 1);
                    ans = depth.get(ncode);
                }
            }
        }
        for (int[] row: grid) {
            for (int v: row) {
                if (v == 1) {
                    return -1;
                }
            }
        }
        return ans;
    }
}

它每个元素用序号（行号*每行的个数+列好）来表示，用一个队列来装一层的2的序号，然后用一个Map<Integer, Integer> depth表示每个节点的深度，key是序号，value是腐烂时间，他的腐烂时间其实就是父节点的腐烂时间+1，然后遍历完一次就把队列里的2取出来反向解出行号和列号，然后把周围腐烂，把周围的序号放进队列，把所有时间，也就是父节点时间+1放入map，然后取出时间，因为每次所放入的时间都是上一次的时间+1，所以最后一次的时间就是最大时间，所以最后返回ans是没有问题的，在返回之前先检查一遍，如果还有没腐烂的橘子1就返回-1。