迷路的机器人

/*
题目思路：
使用深度优先搜索（DFS）来寻找从左上角到右下角的路径。首先，我们需要检查当前网格是否有效（即在边界内并且不是障碍物）。
然后我们尝试向下或向右移动。如果我们找到了一个有效的路径，我们返回这条路径。
如果当前路径不通，则回溯并尝试另一条路径。
使用Java Stream的递归特性和Optional类来处理路径查找和回溯。
*/
import java.util.*;
import java.util.stream.*;

public class RobotPathStream {
    public List<int[]> findPath(int[][] grid) {
        return findPath(grid, 0, 0).orElse(new ArrayList<>());
    }

    private Optional<List<int[]>> findPath(int[][] grid, int row, int col) {
        // 检查边界和障碍物
        if (row < 0 || col < 0 || row >= grid.length || col >= grid[0].length || grid[row][col] == 1) {
            return Optional.empty();
        }
        List<int[]> path = new ArrayList<>();
        path.add(new int[]{row, col});
        // 如果到达右下角，返回路径
        if (row == grid.length - 1 && col == grid[0].length - 1) {
            return Optional.of(path);
        }
        // 标记当前路径
        grid[row][col] = 1;
        // 尝试向下或向右移动
        Optional<List<int[]>> downPath = findPath(grid, row + 1, col);
        Optional<List<int[]>> rightPath = findPath(grid, row, col + 1);
        // 合并路径
        Optional<List<int[]>> resultPath = Stream.of(downPath, rightPath)
                .filter(Optional::isPresent)
                .map(Optional::get)
                .findFirst();
        // 回溯
        grid[row][col] = 0;
        if (resultPath.isPresent()) {
            path.addAll(resultPath.get());
            return Optional.of(path);
        }
        return Optional.empty();
    }

    public static void main(String[] args) {
        RobotPathStream rps = new RobotPathStream();
        int[][] grid = {
            {0, 0, 0},
            {0, 1, 0},
            {0, 0, 0}
        };
        List<int[]> path = rps.findPath(grid);
        path.forEach(p -> System.out.println(Arrays.toString(p)));
    }
}