LeetCode 994. 腐烂的橘子

题目链接

994. 腐烂的橘子

题目分析

这个题好像没有什么偷鸡的方法，只能一步一步去模拟橘子腐烂的过程。我们首先要先统计好的橘子的个数，因为我们接下来要用这个判断模拟过程是否结束。
因为一开始grid中腐烂的橘子为2，为了区分每一个时刻腐烂的橘子的不同，我们利用一个lastBad变量来记录下这个橘子变烂的过程，初始值为2.
然后我们需要利用一个bfs思想，去寻找是否有当前当前腐烂程度==lastBad的橘子，如果有的话就让其上、下、左、右那些好的橘子变成lastBad+1。
直到所有好的橘子都腐烂，即good == 0 或者是一轮bfs后 good的数量没有变都需要退出循环。
最后我们判断一下good是否为0，如果为0就返回分钟数，否则就返回-1代表不能腐烂。

代码实现

class Solution {
    public int orangesRotting(int[][] grid) {
        int res = 0;
        int good = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[i].length; j++){
                if(grid[i][j] == 1){
                    good++;
                }
            }
        }
        int lastBad = 2;
        while(good > 0){
            int pre = good;
            for(int i = 0; i < grid.length; i++){
                for(int j = 0; j < grid[i].length; j++){
                    if(grid[i][j] == lastBad){
                        if(i - 1 >= 0 && grid[i-1][j] == 1){
                            grid[i-1][j] = lastBad+1;
                            good--;
                        }
                        if(j - 1 >= 0 && grid[i][j-1] == 1){
                            grid[i][j-1] = lastBad+1;
                            good--;
                        }
                        if(i + 1 < grid.length && grid[i+1][j] == 1){
                            grid[i+1][j] = lastBad+1;
                            good--;
                        }
                        if(j + 1 < grid[i].length && grid[i][j+1] == 1){
                            grid[i][j+1] = lastBad+1;
                            good--;
                        }
                    }
                }
            }
            res++;
            lastBad++;
            if(pre == good){
                break;
            }
        }
        return good == 0? res : -1;
    }
}

总结

做这种题，一定要胆大心细~

更新

2020年10月10日
今天又回来做这个题目了，隔着3个月没做，这个题还是想了一下才能动手哈。其实就是一个简单的bfs问题，每一轮bfs就是时间加1的情况，要注意最后可能会出现🍊没办法全部被感染的情况，所以还得判断下是否所有好的🍊都被infected了~~

实现代码

class Solution {
    public int orangesRotting(int[][] grid) {
        int res = 0;
        int oranges = 0;
        Queue<int[]> queue = new LinkedList<>();
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[i].length; j++){
                if(grid[i][j] == 2){
                    queue.add(new int[]{i,j});
                }else if(grid[i][j] == 1){
                    oranges++;
                }
            }
        }
        if(oranges == 0){
            return res;
        }
        int[][] direction = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        while(!queue.isEmpty() && oranges != 0){
            int length = queue.size();
            for(int i = 0; i < length; i++){
                int[] cur = queue.poll();
                for(int j = 0; j < direction.length; j++){
                    int x = cur[0] + direction[j][0];
                    int y = cur[1] + direction[j][1];
                    if(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] != 1){
                        continue;
                    }
                    grid[x][y] = 2;
                    queue.offer(new int[]{x, y});
                    oranges--;
                }
            }
            res++;
        }
        return oranges == 0? res : -1;
    }
}