自行车炫技赛场

/*
思路：
1. 通过流式处理和广度优先搜索结合来解决问题。
2. 使用Queue来处理每个位置的速度变化，并使用流来筛选和排序结果。
*/
import java.util.*;
import java.util.stream.Collectors;
public class BikeRaceStream {
    public List<int[]> findPositions(int[] position, int[][] terrain, int[][] obstacle) {
        int n = terrain.length;
        int m = terrain[0].length;
        List<int[]> result = new ArrayList<>();
        boolean[][] visited = new boolean[n][m];
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{position[0], position[1], 1}); // {row, col, speed}
        int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int row = current[0];
            int col = current[1];
            int speed = current[2];
            Arrays.stream(directions).forEach(dir -> {
                int newRow = row + dir[0];
                int newCol = col + dir[1];
                if (newRow >= 0 && newRow < n && newCol >= 0 && newCol < m && !visited[newRow][newCol]) {
                    int newSpeed = speed + terrain[row][col] - terrain[newRow][newCol] - obstacle[newRow][newCol];
                    if (newSpeed == 1) {
                        result.add(new int[]{newRow, newCol});
                        visited[newRow][newCol] = true;
                        queue.offer(new int[]{newRow, newCol, newSpeed});
                    }
                }
            });
        }
        return result.stream().sorted((a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]).collect(Collectors.toList());
    }
    public static void main(String[] args) {
        BikeRaceStream bikeRace = new BikeRaceStream();
        int[] position = {1, 1};
        int[][] terrain = {{5, 0}, {0, 6}};
        int[][] obstacle = {{0, 6}, {7, 0}};
        List<int[]> result = bikeRace.findPositions(position, terrain, obstacle);
        result.forEach(pos -> System.out.println(Arrays.toString(pos)));
    }
}