3月打卡活动第4天 LeetCode第994题：腐烂的橘子（简单）

3月打卡第4天 LeetCode第994题：腐烂的橘子（简单）

• 题目：在给定的网格中，每个单元格可以有以下三个值之一：值 0 代表空单元格；值 1 代表新鲜橘子；值 2 代表腐烂的橘子。每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。
  
• 解题思路：先判断新鲜橘子周围是否有橘子，如果没有，则它一定不会坏。但返回-1的情况，我落下了一种，[[2],[2],[1],[0],[1],[1]]，这导致我后面循环的地方出现了死循环。解决这个问题，我偷偷抖了个小机灵，我在循环的地方加了一个判断，如果循环次数过多就返回-1。嘻嘻嘻~~~

class Solution {
    public int orangesRotting(int[][] grid) {
        //数组的大小
        int R = grid[0].length;
        int D = grid.length;
        //是否还有新鲜的橙子，默认没有
        boolean all = false;
        boolean bad = false;
        int time = 0;
        for(int i=0;i<D;i++){
            for(int j=0;j<R;j++){
                if(grid[i][j]==1){
                    //存在新鲜的橙子
                    all = true;
                    //若四周均没有橙子，则永远不会变坏
                    if((i<D-1 && grid[i+1][j]==0)||(i==D-1)){
                        if((j<R-1 && grid[i][j+1]==0)||(j==R-1)){
                            if((i>0 && grid[i-1][j]==0)||(i==0)){
                                if((j>0 && grid[i][j-1]==0)||(j==0)){
                                    return -1;
                                }
                            }
                        }
                    }
                }
                if(grid[i][j]==2){
                    bad = true;
                }
            }
        }
        if(!all)  return time;
        if(!bad)  return -1;
        while(all){
            all = false;
            for(int i=0;i<D;i++){
                for(int j=0;j<R;j++){
                    if(grid[i][j]==1){
                        //存在新鲜的橙子
                        all = true;
                        //若四周存在坏橙子则变坏
                        if((i<D-1 && grid[i+1][j]==2)||
                            (j<R-1 && grid[i][j+1]==2)||
                            (i>0 && grid[i-1][j]==2)||
                            (j>0 && grid[i][j-1]==2)){
                            grid[i][j]=3;
                        }
                    }
                }
            }
            for(int i=0;i<D;i++){
                for(int j=0;j<R;j++){
                    if(grid[i][j]==3){
                        grid[i][j]=2;
                    }
                }
            }
            time++;
            if(time>R*D) return -1;
        }
        return --time;
    }
}

• 题解做法：用了队列的方法，我也不太会。。。

class Solution {
        // dr,dc 配合使用得到 grid[r][c] 上左下右的元素
        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 : all starting cells with rotten oranges
            Queue<Integer> queue = new ArrayDeque();
            Map<Integer, Integer> depth = new HashMap();
            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); //存储橘子变为腐烂时的时间,key为橘子的一维数组下标，value为变腐烂的时间
                    }

            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);
                        // 计次的关键 元素 grid[r][c] 的上左下右元素得腐烂时间应该一致
                        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;

        }
    }
    
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/rotting-oranges/solution/fu-lan-de-ju-zi-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。