第 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 天_广度优先搜索 / 深度优先搜索【算法入门】
126 0
|
算法
深度优先搜索
深度优先搜索
|
存储 前端开发 算法
深度优先搜索(DFS)和广度优先搜索(BFS)
深度优先搜索(DFS)和广度优先搜索(BFS)
139 0
|
算法
第 8 天_广度优先搜索 / 深度优先搜索【算法入门】
第 8 天_广度优先搜索 / 深度优先搜索【算法入门】
132 0
|
算法 C++
BFS从0到1
BFS从0到1
114 0
|
算法 定位技术
算法 | 广度优先遍历BFS
算法 | 广度优先遍历BFS
103 0
|
机器学习/深度学习 人工智能 定位技术
BFS题单总结
BFS题单总结
92 0
|
算法 PHP
广度优先搜索(BFS)
广度优先搜索(BFS)
151 0
广度优先搜索(BFS)
|
存储 JavaScript 算法
广度优先搜索的理解与实现
广度优先搜索的理解与实现
广度优先搜索的理解与实现
|
算法 前端开发 JavaScript
深度优先搜索的理解与实现
深度优先搜索的理解与实现
深度优先搜索的理解与实现