看完题我觉得这不是和上一道岛屿的题一样简单嘛，然后写了将近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。
