题994、腐烂的橘子

一、题目¹

二、思路

代码的思路就是从每一个腐烂的苹果开始，向四周扩散，每分钟扩散一周，直到将能够感染的苹果都感染完，计算一共用来多长时间，如果已经没有好苹果了，这就是总用时，如果仍然存在完好的苹果则不能将所有的苹果感染，返回-1。

还有一种思路，我没有成功实现，但是应该可以实现，就是从每一个完好的苹果出发，去查找距离他最近的腐烂的苹果的距离，然后所有完好苹果距离的最大值就是总用时。

三、代码

import java.util.ArrayList;
import java.util.List;

public class T0994 {

    public T0994(){

//        int[][] gird = {{2,1,1},{1,1,0},{0,1,1}};
//        int[][] gird = {{2,1,1},{0,1,1},{1,0,1}};
//        int[][] gird = {{0,2}};
//        int[][] gird = {{0}};
        int[][] gird = {{0, 0, 0 }, {0, 1, 2}, { 2, 2, 2}};
        System.out.println( orangesRotting(gird) );
    }

    public int orangesRotting(int[][] grid) {

        //判断是否已经将可以感染的苹果都感染完
        boolean stop = false;

        //计算进行了几轮感染
        int count = 0;

        //暂时存储查询到的还未感染别的苹果的腐烂苹果
        List<int[]> stoke = new ArrayList<>();

        //存储当前已经感染过别的苹果的腐烂的苹果，避免重复
        int[][] map = new int[grid.length][grid[0].length];

        //一直循环，直到把所有能够感染的苹果都给感染完
        while ( !stop ){
            stop = true;

            //循环查询所有还未感染过别的苹果的腐烂苹果
            for ( int i = 0; i < grid.length; i++ ){
                for ( int j = 0; j < grid[i].length; j++ ){

                    //如果还未感染过别的苹果就将其存储在stock内
                    if (grid[i][j]==2 && map[i][j] != 1){
                        stoke.add( new int[]{i,j} );
                        map[i][j] = 1;
                    //如果还存在尚未感染的苹果就证明可能还需要继续进行循环
                    }else if ( grid[i][j] == 1 ){
                        stop = false;
                    }
                }
            }

            //将次数加一
            count++;

            //如果stock为空，证明已经没有可以去感染别的苹果的腐烂苹果了，结束循环
            if ( stoke.isEmpty() )
                break;

            //将上面查询到的腐烂苹果周围的苹果感染
            for (int[] i :stoke){

//                System.out.print(i[0] + "\t " + i[1] + "\t  ||");

                //上面
                if ( i[0] < grid.length-1 )
                    grid[i[0]+1][i[1]] = grid[i[0]+1][i[1]] == 0 ? 0 : 2;

                //下面
                if ( i[0] > 0 )
                    grid[i[0]-1][i[1]] = grid[i[0]-1][i[1]] == 0 ? 0 : 2;

                //左侧
                if ( i[1] < grid[0].length-1 )
                    grid[i[0]][i[1]+1] = grid[i[0]][i[1]+1] == 0 ? 0 : 2;

                //右侧
                if ( i[1] > 0 )
                    grid[i[0]][i[1]-1] = grid[i[0]][i[1]-1] == 0 ? 0 : 2;
            }

//            System.out.println( stoke );

            //清空stock进行下一轮循环
            stoke.clear();
        }


        //如果将所有能感染的苹果都感染过了
        //但是仍然存在尚未感染的苹果，证明不能把所有的苹果都感染，返回-1
        //否则返回count-1，因为计数的时候多算了一次，要减去
        if ( stop ){
            return count-1;
        }else
            return -1;
    }

    public static void main(String[] args) {
        T0994 t0994 = new T0994();
    }
}