994. 腐烂的橘子 --力扣 --JAVA

简介: 在给定的 m x n 网格 grid 中,每个单元格可以有以下三个值之一:值 0 代表空单元格;值 1 代表新鲜橘子;值 2 代表腐烂的橘子。每分钟,腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能,返回 -1 。

题目

在给定的 m x n 网格 grid 中,每个单元格可以有以下三个值之一:

    • 0 代表空单元格;
    • 1 代表新鲜橘子;
    • 2 代表腐烂的橘子。

    每分钟,腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

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

    解题思路

      1. 三层循环,最外层判断执行次数即分钟,初始腐烂标志为2,每次加1,作为下一次腐烂标志;
      2. 里面双层循环,当有腐烂的橘子是将周围新鲜橘子腐烂修改当前位置为腐烂标志加1,参加下一次判断;
      3. 当无法腐烂新鲜橘子时跳出循环,遍历是否还存在新鲜橘子,存在则返回-1,不存在则返回腐烂标志 - 2;

      代码展示

      class Solution {
          public int orangesRotting(int[][] grid) {
              int n = grid.length;
              int m = grid[0].length;
              int start = 2;
              boolean status = false;
              while (true) {
                  for (int i = 0; i < n; i++) {
                      for (int j = 0; j < m; j++) {
                          if (grid[i][j] == start) {
                              grid[i][j] = start + 1;
                              if(i > 0 && grid[i - 1][j] == 1){
                                  grid[i - 1][j] = start + 1;
                                  status = true;
                              }
                              if(j > 0 && grid[i][j - 1] == 1){
                                  grid[i][j - 1] = start + 1;
                                  status = true;
                              }
                              if(i < n - 1 && grid[i + 1][j] == 1){
                                  grid[i + 1][j] = start + 1;
                                  status = true;
                              }
                              if(j < m - 1 && grid[i][j + 1] == 1){
                                  grid[i][j + 1] = start + 1;
                                  status = true;
                              }
                          }
                      }
                  }
                  if(!status){
                      break;
                  }
                  start++;
                  status = false;
              }
              for (int[] ints : grid) {
                  for (int j = 0; j < m; j++) {
                      if (ints[j] == 1) {
                          return -1;
                      }
                  }
              }
              return start - 2;
          }
      }

      image.gif

       

      目录
      相关文章
      |
      9月前
      |
      分布式计算 算法 Go
      【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)
      本文讲解了两道经典的图论问题:**岛屿数量(LeetCode 200)** 和 **腐烂的橘子(LeetCode 994)**,分别通过 DFS/BFS 实现。在“岛屿数量”中,利用深度或广度优先搜索遍历二维网格,标记连通陆地并计数;“腐烂的橘子”则采用多源 BFS,模拟腐烂传播过程,计算最短时间。两者均需掌握访问标记技巧,是学习网格搜索算法的绝佳实践。
      404 1
      |
      9月前
      |
      Go
      【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)
      本篇博客详细解析了三道经典的动态规划问题:198. 打家劫舍(线性状态转移)、279. 完全平方数与322. 零钱兑换(完全背包问题)。通过 Go 语言实现,帮助读者掌握动态规划的核心思想及其实战技巧。从状态定义到转移方程,逐步剖析每道题的解法,并总结其异同点,助力解决更复杂的 DP 问题。适合初学者深入理解动态规划的应用场景和优化方法。
      289 0
      |
      算法 Java
      LeetCode经典算法题:矩阵中省份数量经典题目+三角形最大周长java多种解法详解
      LeetCode经典算法题:矩阵中省份数量经典题目+三角形最大周长java多种解法详解
      209 6
      |
      算法 Java
      LeetCode(一)Java
      LeetCode(一)Java
      192 0
      |
      存储 算法 Java
      LeetCode经典算法题:打家劫舍java详解
      LeetCode经典算法题:打家劫舍java详解
      230 2
      |
      人工智能 算法 Java
      LeetCode经典算法题:井字游戏+优势洗牌+Dota2参议院java解法
      LeetCode经典算法题:井字游戏+优势洗牌+Dota2参议院java解法
      215 1
      |
      存储 算法 Java
      LeetCode经典算法题:预测赢家+香槟塔java解法
      LeetCode经典算法题:预测赢家+香槟塔java解法
      246 1
      |
      算法 Java
      [Java·算法·简单] LeetCode 283. 移动零
      [Java·算法·简单] LeetCode 283. 移动零
      178 2
      |
      存储 算法 Java
      LeetCode经典算法题:二叉树遍历(递归遍历+迭代遍历+层序遍历)以及线索二叉树java详解
      LeetCode经典算法题:二叉树遍历(递归遍历+迭代遍历+层序遍历)以及线索二叉树java详解
      316 0
      |
      算法 Java
      LeetCode初级算法题:环形链表+排列硬币+合并两个有序数组java解法
      LeetCode初级算法题:环形链表+排列硬币+合并两个有序数组java解法
      219 0