leetcode 994:腐烂的橘子 java

原创已于 2022-02-17 17:17:04 修改 · 739 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #java #算法

于 2022-02-17 11:12:21 首次发布

数据结构专栏收录该内容

5 篇文章

订阅专栏

本文解析如何使用多源广度优先搜索算法解决LeetCode题目中的橘子腐烂问题。通过逐层遍历并更新矩阵，统计新鲜橘子数量，最终确定需要的时间。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

994. 腐烂的橘子 - 力扣（LeetCode） (leetcode-cn.com)

多源广度优先搜索，初始的所有的腐烂橘子，等价于广度优先搜索的同一层，然后对每一层进行搜索：

class Solution {
    public int orangesRotting(int[][] grid) {
        int[] x = new int[]{-1,1,0,0};
        int[] y = new int[]{0,0,-1,1}; //  当前坐标的上下左右四个方向，例如grid[1][1]的上坐标为1+x[0],1+y[0]
        Queue<int[]> list = new LinkedList<>(); //广度优先搜索所需要的队列
        int m = grid.length;  //矩阵宽
        int n = grid[0].length; //矩阵高
        int cnt = 0;//新鲜橘子的个数
        int res = 0; //广度优先搜索遍历每一层完成所需时间

        //找到初始时所有的腐烂橘子，作为广度优先搜索的一层
        for(int i = 0; i < m; i ++){
            for(int j = 0; j < n; j ++){
                if(grid[i][j]==1){ //统计新鲜橘子个数
                    cnt++;
                }
                if(grid[i][j]==2){
                    list.offer(new int[]{i,j});//将坏橘子入队
                }
            }
        }
        //如果没有好橘子，返回0
        if(cnt==0)
            return 0;
        while(!list.isEmpty()){
            res ++;//每遍历一层，时间加1
            int size = list.size();

            //依次遍历每一层的所有元素
            for(int i = 0; i < size; i ++ ){
            int[] tmp = list.poll();

            //遍历每个元素的上下左右四个坐标
            for(int k = 0; k < 4; k ++){
                //如果当前坐标合法
                if(tmp[0]+x[k]>=0 && tmp[0]+x[k]<m && tmp[1]+y[k] >=0 && tmp[1]+y[k]<n ){
                    if(grid[tmp[0]+x[k]][tmp[1]+y[k]]==1){//如果当前位置是好的橘子
                        grid[tmp[0]+x[k]][tmp[1]+y[k]]=2;//把橘子变坏
                        list.offer(new int[]{tmp[0]+x[k],tmp[1]+y[k]}); //坏橘子入队列
                        cnt--; //好橘子数目减1
                    }
                }
            }
            }
        }
         
        //检查是否有新鲜的橘子
        if(cnt > 0){
            return -1;
         }

        return res-1;//第一层本来就是坏橘子，不需要时间，所以减1
    }
}