检查网格中是否存在有效路径

/*
 * 思路：
 * 使用流式处理（Stream）可以简化一些操作，但核心思路与基本的DFS一致。
 * 我们依然从起点开始，根据街道类型决定下一步移动的方向，并检查是否到达终点。
 */
import java.util.*;
import java.util.stream.*;
public class SolutionStream {
    private int[][] directions = {
        {}, // placeholder for index 0
        {0, -1, 0, 1}, // type 1: left-right
        {-1, 0, 1, 0}, // type 2: up-down
        {0, -1, 1, 0}, // type 3: left-down
        {0, 1, 1, 0}, // type 4: right-down
        {0, -1, -1, 0}, // type 5: left-up
        {0, 1, -1, 0}  // type 6: right-up
    };
    private boolean[][] visited;
    public boolean hasValidPath(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        visited = new boolean[m][n];
        return dfs(grid, 0, 0);
    }
    private boolean dfs(int[][] grid, int x, int y) {
        int m = grid.length;
        int n = grid[0].length;
        if (x == m - 1 && y == n - 1) return true;
        visited[x][y] = true;
        int type = grid[x][y];
        return IntStream.range(0, directions[type].length / 2)
            .mapToObj(i -> new int[] {x + directions[type][i * 2], y + directions[type][i * 2 + 1]})
            .filter(pos -> pos[0] >= 0 && pos[0] < m && pos[1] >= 0 && pos[1] < n && !visited[pos[0]][pos[1]])
            .anyMatch(pos -> isValidMove(type, grid[pos[0]][pos[1]], directions[type][0], directions[type][1]) && dfs(grid, pos[0], pos[1]));
    }
    private boolean isValidMove(int type, int nextType, int dx, int dy) {
        return IntStream.range(0, directions[nextType].length / 2)
            .anyMatch(i -> directions[nextType][i * 2] == -dx && directions[nextType][i * 2 + 1] == -dy);
    }
}