【Leetcode】1293. Shortest Path in a Grid with Obstacles Elimination

题目地址：

https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/

给定一个$m$行$n$列二维$0-1$矩阵，$0$代表空地，$1$代表障碍物，要求从$(0,0)$出发，走到$(m-1,n-1)$这个位置，允许最多移除$k$个障碍物，求最短路长度。每一步可以上下左右走一步。题目保证出发点和终点都是空地。

思路是BFS。将已经移除了多少个障碍物加进状态，然后做隐式图搜索即可。代码如下：

import java.util.LinkedList;
import java.util.Queue;

public class Solution {
    
    
    public int shortestPath(int[][] grid, int k) {
    
    
        if (grid.length <= 1 && grid[0].length <= 1) {
    
    
            return 0;
        }
        
        // 前两个数代表坐标，最后一个数代表已经移除了多少个障碍物
        int[] start = {
    
    0, 0, 0};
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(start);
        boolean[][][] visited = new boolean[grid.length][grid[0].length][k + 1];
        visited[0][0][0] = true;
        
        int[] d = {
    
    1, 0, -1, 0, 1};
        
        int res = 0;
        while (!queue.isEmpty()) {
    
    
            res++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
    
    
                int[] cur = queue.poll();
                for (int j = 0; j < 4; j++) {
    
    
                    int nextX = cur[0] + d[j], nextY = cur[1] + d[j + 1];
                    if (inBound(nextX, nextY, grid)) {
    
    
                        int obs = cur[2] + grid[nextX][nextY];
                        int[] next = {
    
    nextX, nextY, obs};
                        if (obs <= k && !visited[nextX][nextY][obs]) {
    
    
                            if (nextX == grid.length - 1 && nextY == grid[0].length - 1) {
    
    
                                return res;
                            }
                            
                            queue.offer(next);
                            visited[nextX][nextY][obs] = true;
                        }
                    }
                }
            }
        }
        
        return -1;
    }
    
    private boolean inBound(int x, int y, int[][] grid) {
    
    
        return 0 <= x && x < grid.length && 0 <= y && y < grid[0].length;
    }
}

时空复杂度$O(kmn)$。