[LeetCode—002][Java]腐烂的橘子

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

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

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

示例图：

示例1：

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

示例 2：

输入：[[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。

示例 3：

输入：[[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

方法：

public int orangesRotting(int[][] grid) {
	    	//数组元素的值视为橘子的腐烂指数，max在这里当做橘子最大的腐烂值
	    	int max = 0;
	    	
	    	int count = 0;
	    	
	    	//如果数组为0，就不用找了
	        if (grid.length == 0) {
	        	return -1;
	        }
	        
	        //第一次遍历检查橘子的腐烂值
	        for (int i = 0; i < grid.length; i++) {
	        	for (int j = 0; j < grid[0].length; j++) {
	        		//看看有没有新鲜的橘子
	        		if (grid[i][j] == 1) {
	        			count++;
	            	}
	        		//看看有没有腐烂的橘子,max <= 2
	        		max = Math.max(grid[i][j], max);
	        	}
	        }
	        if(count == 0) {
	        	//没有新鲜的橘子，返回0
	        	return 0;
	        }else if(max != 2) {
	        	//没有腐烂的橘子无法传染,返回-1
	        	return -1;
	        }
	        
	        //第二次遍历找出腐烂的橘子
	        for (int i = 0; i < grid.length; i++) {
	            for (int j = 0; j < grid[0].length; j++) {
	            	//找出腐烂的橘子
	                if (grid[i][j] == 2) {      
	                	//烂橘子开始传染，调用传染方法s
	                    dps(i, j, 2,grid);                       
	                }
	                
	            }
	        }
	        
	        //第三次遍历，找出腐烂指数最高的橘子
	        for (int i = 0; i < grid.length; i++) {
	            for (int j = 0; j < grid[0].length; j++) {
	            	
	            	//判断是否有新鲜的橘子
	            	if (grid[i][j] == 1) {
	            		return -1;
	            	}
	            	//找到腐烂指数最大的橘子,max>2
	                max = Math.max(grid[i][j], max);
	            }
	        }
	        //减去一开始的腐烂值2，得到腐烂次数，也就等于传播次数
	        return max -2;
	    }

传染方法：

//传染方法
	    public void dps(int i, int j, int val,int[][] grid) {
	    	
	    	//列数
	    	int r = grid.length;
	    	//行数
	    	int l = grid[0].length;
	    	
	        grid[i][j] = val;
	        
	        //传染是向上下左右个方向同时发生的
	        
	        //向上判断
	        //先判断是否为空，再判断当前列向上一个元素是好橘子或是一个腐烂的更晚的橘子
	        if (i > 0 && (grid[i - 1][j] == 1 || grid[i - 1][j] - grid[i][j] > 1)) {
	        	//该位置的值+1，相当于腐烂指数+1，递归判断
	            dps(i - 1, j, val+1,grid);
	        }
	        
	        //向下判断
	        //先判断是否为空，再判断当前行向下一个元素是好橘子或是一个腐烂的更晚的橘子
	        if (i < r - 1 && (grid[i + 1][j] == 1 || grid[i + 1][j] - grid[i][j] > 1)) {
	        	dps(i + 1, j, val+1,grid);
	        }
	        
	        //向左判断
	        //先判断是否为空，再判断当前行向左一个元素是好橘子或是一个腐烂的更晚的橘子
	        if (j > 0 && (grid[i][j - 1] == 1 || grid[i][j - 1] - grid[i][j] > 1)) {
	            dps(i, j - 1, val+1,grid);
	        }
	        
	        //向右判断
	        //先判断是否为空，再判断当前行向右一个元素是好橘子或是一个腐烂的更晚的橘子
	        if (j < l - 1 && (grid[i][j + 1] == 1 || grid[i][j + 1] - grid[i][j] > 1)) {
	            dps(i, j + 1, val+1,grid);
	        }
	    }

程序mian方法（测试代码）：

public static void main(String[] args) {
		int grid[][] = {{2,1,1},{0,0,1},{1,1,1}};
		CowCoder02 cCoder = new CowCoder02();
		//打印传染前的数组
		System.out.println(Arrays.deepToString(grid));
		System.out.println("传染次数:"+cCoder.orangesRotting(grid));
		//打印传染后的数组
		System.out.println(Arrays.deepToString(grid));
	}

运行结果：