第 9 天_广度优先搜索 / 深度优先搜索

简介: 第 9 天_广度优先搜索 / 深度优先搜索

542. 01 矩阵

给定一个由 01 组成的矩阵 mat ,请输出一个大小相同的矩阵,其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。

两个相邻元素间的距离为 1

示例 1:

输入:mat = [[0,0,0],[0,1,0],[0,0,0]]
输出:[[0,0,0],[0,1,0],[0,0,0]]

示例 2:



输入:mat = [[0,0,0],[0,1,0],[1,1,1]]
输出:[[0,0,0],[0,1,0],[1,2,1]]

提示:

  • m == mat.length
  • n == mat[i].length
  • 1 <= m, n <= 104
  • 1 <= m * n <= 104
  • mat[i][j] is either 0 or 1.
  • mat 中至少有一个 0

题解
能力不足,请看题解

https://leetcode-cn.com/problems/01-matrix/solution/

994. 腐烂的橘子

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

  • 0 代表空单元格;
  • 1 代表新鲜橘子;
  • 2 代表腐烂的橘子。
    每分钟,任何与腐烂的橘子(在 4 个正方向上)相邻的新鲜橘子都会腐烂。

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

示例 1:



输入:[[2,1,1],[1,1,0],[0,1,1]]
输出:4

示例 2:

输入:[[2,1,1],[0,1,1],[1,0,1]]
输出:-1
解释:左下角的橘子(第 2 行, 第 0 列)永远不会腐烂,因为腐烂只会发生在 4 个正向上。

示例 3:

输入:[[0,2]]
输出:0
解释:因为 0 分钟时已经没有新鲜橘子了,所以答案就是 0 。

提示:

1 <= grid.length <= 10

1 <= grid[0].length <= 10

grid[i][j] 仅为 0、1 或 2

来源:力扣(LeetCode)

链接:https://leetcode-cn.com/problems/rotting-oranges

著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

题解

能力有限,请看

理清思路:为什么用 BFS,以及如何写 BFS 代码(Java/Python)

class Solution {
   public int orangesRotting(int[][] grid) {
        int M = grid.length;
        int N = grid[0].length;
        Queue<int[]> queue = new LinkedList<>();
        int[][] dir = { {-1,0},{1,0},{0,-1},{0,1} };//四个方向移动
        int count = 0; // count 表示新鲜橘子的数量
        for (int r = 0; r < M; r++) {
            for (int c = 0; c < N; c++) {
                if (grid[r][c] == 1) {
                    count++;
                } else if (grid[r][c] == 2) {
                    queue.add(new int[]{r, c});//腐烂的入队
                }
            }
        }
        int round = 0; // round 表示分钟数
        while (count > 0 && !queue.isEmpty()) {//注意条件 count不能少,否则会多计算
            round++;
            int n = queue.size();
            for(int i = 0; i < n; i++) {
                int[] tmp = queue.poll();
                for(int k = 0; k < 4; k++) {
                    int cr = tmp[0] + dir[k][0];
                    int cc = tmp[1] + dir[k][1];
                    if(cr >= 0 && cr < M && cc >= 0 && cc < N && grid[cr][cc] == 1) {
                        grid[cr][cc] = 2;//开始腐烂
                        count--;
                        queue.add(new int[]{cr, cc});//添加新元素
                    }
                }
            }
        }
        if (count > 0) {
            return -1;
        } else {
            return round;
        }
    }
}

相关文章
|
算法
第 7 天_广度优先搜索 / 深度优先搜索【算法入门】
第 7 天_广度优先搜索 / 深度优先搜索【算法入门】
116 0
|
算法
深度优先搜索
深度优先搜索
|
算法
【算法】通过递归和非递归实现树的前中后序以及广度优先搜索和深度优先搜索
【算法】通过递归和非递归实现树的前中后序以及广度优先搜索和深度优先搜索
125 0
|
算法
第 8 天_广度优先搜索 / 深度优先搜索【算法入门】
第 8 天_广度优先搜索 / 深度优先搜索【算法入门】
130 0
深度优先遍历与广度优先遍历
深度优先遍历与广度优先遍历
128 0
|
算法 定位技术
算法 | 广度优先遍历BFS
算法 | 广度优先遍历BFS
97 0
|
存储 JavaScript 算法
广度优先搜索的理解与实现
广度优先搜索的理解与实现
广度优先搜索的理解与实现
|
算法 前端开发 JavaScript
深度优先搜索的理解与实现
深度优先搜索的理解与实现
深度优先搜索的理解与实现
|
算法 PHP
广度优先搜索(BFS)
广度优先搜索(BFS)
144 0
广度优先搜索(BFS)