LeetCode：1293. Shortest Path in a Grid with Obstacles Elimination - Python

1293. 网格中的最短路径

问题描述：

给你一个 m * n 的网格，其中每个单元格不是0（空）就是1（障碍物）。每一步，您都可以在空白单元格中上、下、左、右移动。
如果您 最多 可以消除k个障碍物，请找出从左上角 (0, 0) 到右下角 (m-1, n-1) 的最短路径，并返回通过该路径所需的步数。如果找不到这样的路径，则返回 -1。

示例 1：

输入：
grid = [[0,0,0], [1,1,0], [0,0,0], [0,1,1], [0,0,0]],
k = 1
输出：6
解释：不消除任何障碍的最短路径是 10。消除位置 (3,2) 处的障碍后，最短路径是 6 。该路径是 (0,0) -> (0,1) -> (0,2) -> (1,2) -> (2,2) -> (3,2) -> (4,2).

提示：

• grid.length == m
• grid[0].length == n
• 1 <= m, n <= 40
• 1 <= k <= m*n
• grid[i][j] == 0 or 1
• grid[0][0] == grid[m-1][n-1] == 0

问题分析：

看问题不难发现，这个就是迷宫问题的变种，应该是早期Google的一个面试题。题目也给了提示广度优先搜索🔍。

注意的两个点：

• 要求的是最短的距离
• 拆墙不能超过k堵

现在看下解题思路，广度优先搜索，具体思路如下：
（1）和求解迷宫最短路径问题一样，一层一层的搜索，每一层使用队列（也就栈）来保存。
（2）但是，和迷宫问题不同的是，在每一层搜索的时候要考虑拆墙问题，所以可以引入一个“标志位 : k_”，作为从这个方格（点）出发还可以拆几堵墙，当然最开始是k堵墙了。
（3）下面，可以结合下图进行理解，一层一层的搜索入队：

• 1、当，当前方格内没有墙，且之前没有访问过，则入队，否则舍弃。
• 2、当，当前方格有墙，且还可以拆墙，且没有访问过，则入队，否则舍弃。
• 3、判断是否访问过的条件包含两个：一是当前方格的位置信息，而是当前方格出发还可以拆多少堵墙的信息，也就是标志位信息 : k_。

（4）最后，找到出口，则返回步数即可。

Python3实现：

class Solution:
    def shortestPath(self, grid, k):
        """
        :type grid: List[List[int]]
        :type k: int
        :rtype: int
        """
        queue = []
        step = 0
        n, m = len(grid), len(grid[0])

        if n == m and n == 1:
            return 0

        visited = set()
        queue.append((0, 0, k))
        visited.add((0, 0, k))

        # 如果 k 大于矩阵的从左上角到右下角的最小距离，那就直接返回最近距离即可
        if k > (len(grid) - 1 + len(grid[0]) - 1):
            return len(grid) - 1 + len(grid[0]) - 1

        directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]  # 可走的四个方向
        while queue:
            curqueue = []  # 当前正在构建的新队列
            step += 1
            for x, y, k_ in queue:
                for dx, dy in directions:
                    nx, ny = x + dx, y + dy
                    if (nx, ny) == (n - 1, m - 1):  # 找到出口
                        return step
                    if 0 <= nx < n and 0 <= ny < m:  # 判断是不是越界

                        if grid[nx][ny] == 0 and (nx, ny, k_) not in visited:  # 不是墙，且之前没有访问过，添加
                            visited.add((nx, ny, k_))
                            curqueue.append((nx, ny, k_))

                        elif grid[nx][ny] == 1 and k_ > 0 and (nx, ny, k_ - 1) not in visited:  # 是墙但是，还可以拆墙并且之前没有访问过 添加
                            visited.add((nx, ny, k_ - 1))
                            curqueue.append((nx, ny, k_ - 1))
            queue = curqueue[:]  # 更新队列
        return -1


if __name__ == '__main__':
    solu = Solution()
    grid = [
        [0, 0, 0],
        [1, 1, 0],
        [0, 0, 0],
        [0, 1, 1],
        [0, 0, 0]]
    k = 1
    print(solu.shortestPath(grid, k))

声明： 总结学习，有问题或不当之处，可以批评指正哦，谢谢。

题目链接: https://leetcode-cn.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/
参考链接: https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/discuss/457493/python-stack-breadth-first-search