Java 障碍物消除网格中的Leetcode最短路径

我得到更大的输入网格大小的TLE错误。如何改进以解决此问题？ 我在这里使用回溯

给定一个m*n网格，其中每个单元格为0（空）或1（障碍物）。在一个步骤中，您可以从空单元格向上、向下、向左或向右移动

返回从左上角（0，0）到右下角（m-1，n-1）行走的最小步数，前提是您最多可以消除k个障碍物。如果不可能找到这样的步行返回-1。类解决方案{

int min= Integer.MAX_VALUE;

public int shortestPath(int[][] grid, int k) {
    
    
    helper(grid,0,0,0,0,k);
    return min==Integer.MAX_VALUE?-1:min;
    
    
}

void helper(int grid[][],int x, int y, int step, int obstacles,int k){
    if(x<0 || y<0 || x>=grid.length || y>=grid[0].length || obstacles>k || grid[x][y]>1){

        return; 
    }
    
    if(x==grid.length-1 && y==grid[0].length-1){
        min = Math.min(min,step);
        return;
    }
    if(grid[x][y]==1) obstacles++;
    int temp = grid[x][y];
    grid[x][y]=2;
    helper(grid,x+1,y,step+1,obstacles,k);
    helper(grid,x,y+1,step+1,obstacles,k);
    helper(grid,x-1,y,step+1,obstacles,k);
    helper(grid,x,y-1,step+1,obstacles,k);
    grid[x][y]=temp;
}

int min=Integer.MAX\u值；
公共int最短路径（int[][]网格，int k）{
辅助对象（网格，0,0,0,0,k）；
返回最小值==整数。最大值？-1:min；
}
void helper（int grid[]]、int x、int y、int step、int障碍物、int k）{
如果（x=网格[0]。长度| |障碍物>k | |网格[x][y]>1）{
返回；
}
如果（x==grid.length-1&&y==grid[0].length-1）{
最小值=数学最小值（最小值，步长）；
返回；
}
如果（栅格[x][y]==1）障碍物++；
int temp=网格[x][y]；
网格[x][y]=2；
辅助对象（网格，x+1，y，步骤+1，障碍物，k）；
辅助对象（栅格、x、y+1、步骤+1、障碍物、k）；
辅助对象（网格，x-1，y，步骤+1，障碍物，k）；
辅助对象（网格，x，y-1，步骤+1，障碍物，k）；
网格[x][y]=温度；
}

}

有人帮忙吗？

到目前为止看起来还不错！

• 我们可能需要检查访问的

  节点

---

这将使用队列和LinkedList传递：

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

public class Solution {
    static final int[][] directions = new int[][] {{0, 1}, {1, 0}, { -1, 0}, {0, -1}};
    public static final int shortestPath(
        final int[][] grid,
        final int k
    ) {
        final int rowLength = grid.length;
        final int colLength = grid[0].length;
        Queue<int[]> queue = new LinkedList<>();
        boolean[][][] visited = new boolean[rowLength][colLength][k + 1];
        visited[0][0][0] = true;
        queue.offer(new int[] {0, 0, 0});
        int minSteps = 0;

        while (!queue.isEmpty()) {
            final int size = queue.size();

            for (int i = 0; i < size; i++) {
                final int[] info = queue.poll();
                final int row = info[0];
                final int col = info[1];
                final int currObstacble = info[2];

                if (row == rowLength - 1 && col == colLength - 1) {
                    return minSteps;
                }

                for (int[] direction : directions) {
                    final int nextRow = direction[0] + row;
                    final int nextCol = direction[1] + col;
                    int nextObstacle = currObstacble;

                    if (nextRow > -1 && nextRow < rowLength && nextCol > -1 && nextCol < colLength) {
                        if (grid[nextRow][nextCol] == 1) {
                            nextObstacle++;
                        }

                        if (nextObstacle <= k && !visited[nextRow][nextCol][nextObstacle]) {
                            visited[nextRow][nextCol][nextObstacle] = true;
                            queue.offer(new int[] {nextRow, nextCol, nextObstacle});
                        }
                    }
                }
            }

            minSteps++;
        }

        return -1;
    }
}

import java.util.Queue；
导入java.util.LinkedList；
公共类解决方案{
静态最终int[][]方向=新int[][{{0，1}，{1，0}，{-1，0}，{0，-1}；
公共静态final int最短路径(
最终int[][]网格，
最终整数k
) {
最终整数行长度=grid.length；
最终整数长度=网格[0]。长度；
Queue Queue=new LinkedList（）；
boolean[][[]已访问=新的boolean[rowLength][colLength][k+1]；
已访问[0][0][0]=真；
offer（新的int[]{0,0,0}）；
int minSteps=0；
而（！queue.isEmpty（））{
final int size=queue.size（）；
对于（int i=0；i-1&&nextRow-1&&nextCol