逃离大迷宫

/*
题目思路：
1. 使用广度优先搜索（BFS）来遍历网格。
2. 维护一个队列用于存储当前的探索位置。
3. 使用一个集合来记录已经访问过的节点，避免重复访问。
4. 每次从队列中取出一个位置，检查它的四个邻接位置是否可以移动，如果可以移动且是目标位置，则返回true。
5. 如果队列为空且未找到目标位置，则返回false。
6. 使用Java Stream API对代码进行简化。
*/

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class SolutionStream {
    private static final int[][] DIRECTIONS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    public boolean isEscapePossible(int[][] blocked, int[] source, int[] target) {
        Set<String> blockedSet = Arrays.stream(blocked)
                                       .map(b -> b[0] + "," + b[1])
                                       .collect(Collectors.toSet());
        
        return bfs(blockedSet, source, target) && bfs(blockedSet, target, source);
    }
    
    private boolean bfs(Set<String> blockedSet, int[] source, int[] target) {
        Set<String> visited = new HashSet<>();
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(source);
        visited.add(source[0] + "," + source[1]);
        
        int maxSteps = blockedSet.size() * blockedSet.size();
        int steps = 0;
        
        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            steps++;
            if (steps > maxSteps) return true;
            for (int[] dir : DIRECTIONS) {
                int x = current[0] + dir[0];
                int y = current[1] + dir[1];
                if (x < 0 || x >= 1000000 || y < 0 || y >= 1000000) continue;
                if (x == target[0] && y == target[1]) return true;
                if (!blockedSet.contains(x + "," + y) && visited.add(x + "," + y)) {
                    queue.offer(new int[]{x, y});
                }
            }
        }
        return false;
    }
}