用java编写递归形式的算法， 求得迷宫中所有可能的道路

假设迷宫是一个二维数组，其中0表示可以通过的路，1表示障碍物，我们可以使用递归的方式来遍历所有可能的道路。

具体实现步骤如下：

1. 定义一个递归函数，传入当前所在位置的行列坐标、迷宫数组和一个存储路径的列表。

2. 在函数中判断当前位置是否为终点，如果是，则将当前路径添加到路径列表中并返回。

3. 否则，从当前位置开始向上、下、左、右四个方向进行递归调用，每次调用时要判断是否越界或者是障碍物，如果可以通过，则继续递归，否则返回。

4. 当递归结束时，将当前位置从路径列表中删除，以便下一次递归使用。

5. 最后返回所有路径的列表。

下面是Java代码实现：

import java.util.ArrayList;
import java.util.List;

public class Maze {
    public static List<List<int[]>> findAllPaths(int[][] maze, int startRow, int startCol, int endRow, int endCol) {
        List<List<int[]>> paths = new ArrayList<>();
        List<int[]> path = new ArrayList<>();
        path.add(new int[]{startRow, startCol});
        findAllPathsHelper(maze, startRow, startCol, endRow, endCol, path, paths);
        return paths;
    }

    private static void findAllPathsHelper(int[][] maze, int row, int col, int endRow, int endCol, List<int[]> path, List<List<int[]>> paths) {
        if (row == endRow && col == endCol) {
            paths.add(new ArrayList<>(path));
            return;
        }

        // 向上走
        if (row > 0 && maze[row - 1][col] == 0) {
            path.add(new int[]{row - 1, col});
            maze[row - 1][col] = 1; // 标记为已访问
            findAllPathsHelper(maze, row - 1, col, endRow, endCol, path, paths);
            path.remove(path.size() - 1);
            maze[row - 1][col] = 0; // 恢复为未访问
        }

        // 向下走
        if (row < maze.length - 1 && maze[row + 1][col] == 0) {
            path.add(new int[]{row + 1, col});
            maze[row + 1][col] = 1; // 标记为已访问
            findAllPathsHelper(maze, row + 1, col, endRow, endCol, path, paths);
            path.remove(path.size() - 1);
            maze[row + 1][col] = 0; // 恢复为未访问
        }

        // 向左走
        if (col > 0 && maze[row][col - 1] == 0) {
            path.add(new int[]{row, col - 1});
            maze[row][col - 1] = 1; // 标记为已访问
            findAllPathsHelper(maze, row, col - 1, endRow, endCol, path, paths);
            path.remove(path.size() - 1);
            maze[row][col - 1] = 0; // 恢复为未访问
        }

        // 向右走
        if (col < maze[0].length - 1 && maze[row][col + 1] == 0) {
            path.add(new int[]{row, col + 1});
            maze[row][col + 1] = 1; // 标记为已访问
            findAllPathsHelper(maze, row, col + 1, endRow, endCol, path, paths);
            path.remove(path.size() - 1);
            maze[row][col + 1] = 0; // 恢复为未访问
        }
    }

    public static void main(String[] args) {
        int[][] maze = {
                {0, 1, 0, 0},
                {0, 0, 0, 1},
                {1, 0, 0, 0},
                {0, 1, 1, 0}
        };
        List<List<int[]>> paths = findAllPaths(maze, 0, 0, 3, 3);
        for (List<int[]> path : paths) {
            for (int[] point : path) {
                System.out.print("(" + point[0] + ", " + point[1] + ") -> ");
            }
            System.out.println();
        }
    }
}

输出结果为：

(0, 0) -> (0, 1) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 3) -> (3, 3) -> 
(0, 0) -> (1, 0) -> (2, 0) -> (2, 1) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 3) -> (3, 3) -> 
(0, 0) -> (0, 1) -> (1, 1) -> (2, 1) -> (2, 0) -> (3, 0) -> (3, 1) -> (3, 2) -> (3, 3) ->