LeetCode #1293. 网格中的最短路径_leetcode n*m 最短路径障碍-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_33193309/article/details/118028719

这是一道困难级别的编程题，题目要求在含有障碍物的网格中寻找从左上角到右下角的最短路径，允许最多消除一定数量的障碍物。你需要计算通过最短路径所需的步数，若无法找到则返回-1。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1293. 网格中的最短路径

难度困难123收藏分享切换为英文接收动态反馈

给你一个 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)

示例 2：

输入：
grid = 
[[0,1,1],
 [1,1,1],
 [1,0,0]], 
k = 1
输出：-1
解释：
我们至少需要消除两个障碍才能找到这样的路径。

提示：

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

走到一个障碍物有去除和不去除两种状态，可以用个三维数组判断是否去除了

class Solution {
public:
    struct node{
        int x,y,cnt,len;
    };
    int vis[42][42][2002] = {0};
    int fz[4][2] = {1,0,0,1,-1,0,0,-1};
    bool pd(int x,int y,int n,int m){
        if(x >= 0 && x < n && y >= 0 && y < m) return true;
        return false;
    }
    int shortestPath(vector<vector<int>>& grid, int k) {
        int n = grid.size(),m = grid[0].size();
        if(k >= m + n - 3) return m + n - 2; 
        queue<node> que;
        que.push({0,0,k,0});
        while(que.size() != 0){
            node no = que.front();
            que.pop();
            int x = no.x,y = no.y,cnt = no.cnt,len = no.len;
            if(x == n - 1 && y == m - 1 && cnt >= 0) return len;
            if(vis[x][y][cnt]) continue;
            vis[x][y][cnt] = 1;
            for(int i = 0;i < 4;i++){
                int xx = x + fz[i][0];
                int yy = y + fz[i][1];
                if(!pd(xx,yy,n,m)) continue;
                if(grid[xx][yy] == 0 && vis[xx][yy][cnt] == 0){
                    que.push({xx,yy,cnt,len + 1});
                }
                else if(grid[xx][yy] == 1 && vis[xx][yy][cnt] == 0 && cnt > 0){
                    que.push({xx,yy,cnt - 1,len + 1});
                }
            }
        }
        return -1;
    }
};