网格中的最短路径

import java.util.*;
import java.util.stream.IntStream;

/**
 * This method uses Java Streams to help with the BFS approach to find the shortest path in a grid with obstacles.
 * It leverages streams for initializing and processing parts of the grid.
 */
public class Solution {
    public int shortestPath(int[][] grid, int k) {
        int m = grid.length;
        int n = grid[0].length;
        int[][][] visited = new int[m][n][k + 1];
        IntStream.range(0, m).forEach(i -> IntStream.range(0, n).forEach(j -> Arrays.fill(visited[i][j], Integer.MAX_VALUE)));
        int[] dirs = {0, 1, 0, -1, 0};
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{0, 0, 0, 0});
        visited[0][0][0] = 0;

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int x = cur[0], y = cur[1], steps = cur[2], obstacles = cur[3];

            if (x == m - 1 && y == n - 1) {
                return steps;
            }

            for (int i = 0; i < 4; i++) {
                int nx = x + dirs[i];
                int ny = y + dirs[i + 1];

                if (nx >= 0 && ny >= 0 && nx < m && ny < n) {
                    int newObstacles = obstacles + grid[nx][ny];

                    if (newObstacles <= k && steps + 1 < visited[nx][ny][newObstacles]) {
                        visited[nx][ny][newObstacles] = steps + 1;
                        queue.offer(new int[]{nx, ny, steps + 1, newObstacles});
                    }
                }
            }
        }

        return -1;
    }
}