LeetCode994.腐烂的橘子-编程知识

看完题我觉得这不是和上一道岛屿的题一样简单嘛，然后写了将近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的周围都是空，则这个位置用不腐烂，返回-1for(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，返回永不腐烂，返回-1statuCode = -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，用不腐烂，则返回-1statuCode =-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。