力扣 6081. 到达角落需要移除障碍物的最小数目

最新推荐文章于 2025-11-24 01:23:29 发布

原创最新推荐文章于 2025-11-24 01:23:29 发布 · 298 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #职场和发展

BFS 专栏收录该内容

13 篇文章

订阅专栏

该博客介绍了一种使用广度优先搜索（BFS）算法来解决从二维矩阵的左上角到右下角，求解最小障碍物移除数目的问题。在BFS过程中，通过维护一个距离矩阵记录从起点到各点的最小花费，并优先考虑非障碍路径以减少重复搜索。代码示例展示了如何实现这一算法，最终返回目标位置的最小障碍物移除数。

题目来源：https://leetcode.cn/problems/minimum-obstacle-removal-to-reach-corner/

大致题意：
给一个 m*n 的二维矩阵，由 0 和 1 组成，其中 1 表示障碍，求从左上角到右下角需要移除障碍物的最小数目

思路

这道题类似求左上角到右下角的最短路径，其中经过障碍需要的代价为 1

于是可以使用 bfs 求左上角到右下角的最短路径

bfs

设一个 m*n 的距离矩阵，表示左上角到每个位置的最小花费

bfs 搜索时，若当前位置到达相邻位置的花费小于相邻位置目前的最小花费，那么可以更新相邻位置的花费，并将相邻位置添加到 bfs 队列中

可以注意到，如果一个位置有多条路径可以到达，那么每次新的更小的路径到达该位置后，都会将该位置放入 bfs 队列，也就表示之前从该位置进行的 bfs 搜索是白费功夫

所以在搜索时，可以优先搜索当前路径花费更小的路径，这样可以减少重复搜索的次数

每次在将一个新位置加入队列时，若新位置为障碍（也就是当前位置到新位置会使花费 + 1），那么就将新位置放入队列尾；若新位置不是障碍，则将新位置放入队列头
这样在 bfs 搜索时，会优先搜索没有障碍的路径，花费更小

代码：

public int minimumObstacles(int[][] grid) {
        Deque<int[]> queue = new ArrayDeque<>();
        queue.offer(new int[]{0, 0, 0});
        int m = grid.length;
        int n = grid[0].length;
        int[][] dis = new int[m][n];
        for (int i = 0; i < m; i++) {
            Arrays.fill(dis[i], Integer.MAX_VALUE);
        }
        int[] directions = new int[]{1, 0, -1, 0, 1};
        dis[0][0] = 0;
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            // 遍历四个方向
            for (int i = 0; i < 4; i++) {
                int nx = cur[0] + directions[i];
                int ny = cur[1] + directions[i + 1];
                if (!(nx >= 0 && nx < m && ny >= 0 && ny < n)) {
                    continue;
                }
                // 若当前位置到达新位置的花费更小，则更新新位置花费，并将新位置放入队列
                if (cur[2] + grid[nx][ny] < dis[nx][ny]) {
                    dis[nx][ny] = cur[2] + grid[nx][ny];
                    // 优先搜索没有障碍的路径
                    if (grid[nx][ny] == 0) {
                        queue.offerFirst(new int[]{nx, ny, dis[nx][ny]});
                    } else {
                        queue.offerLast(new int[]{nx, ny, dis[nx][ny]});
                    }
                }
            }
        }
        return dis[m - 1][n - 1];
    }