利用java实现以一个 m * n 的长方阵表示迷宫， 0和1分别表示迷宫的通路和障碍。 设计一个程序， 对任意设定的迷宫， 求出一条从入口到出口的通路， 或得出没有通路的结论。 编写递归形式的算法， 求得迷宫中所有可能的道路；求的通路以三元组（i， j， d） 的形式输出， 其中：（i， j） 指示迷宫中的一个坐标， d 表示走到下一坐标的方向。 如： 对于下列数据的迷宫， 输出一条通路： （1， 1， 1），（1， 2， 2），

以下是Java实现的递归形式的DFS算法，求得迷宫中所有可能的道路：

import java.util.*;

public class MazeSolver {
    private int[][] maze; // 迷宫
    private int m, n; // 迷宫大小
    private boolean[][] visited; // 已访问标记
    private List<List<int[]>> paths; // 所有路径

    public MazeSolver(int[][] maze) {
        this.maze = maze;
        m = maze.length;
        n = maze[0].length;
        visited = new boolean[m][n];
        paths = new ArrayList<>();
    }

    public void solve(int startX, int startY, int endX, int endY) {
        dfs(startX, startY, endX, endY, new ArrayList<>());
    }

    private void dfs(int i, int j, int endX, int endY, List<int[]> path) {
        if (i == endX && j == endY) { // 到达终点，加入路径
            path.add(new int[]{i, j});
            paths.add(new ArrayList<>(path));
            path.remove(path.size() - 1);
            return;
        }
        visited[i][j] = true;
        path.add(new int[]{i, j});
        if (i > 0 && !visited[i-1][j] && maze[i-1][j] == 0) { // 向上走
            dfs(i-1, j, endX, endY, path);
        }
        if (i < m-1 && !visited[i+1][j] && maze[i+1][j] == 0) { // 向下走
            dfs(i+1, j, endX, endY, path);
        }
        if (j > 0 && !visited[i][j-1] && maze[i][j-1] == 0) { // 向左走
            dfs(i, j-1, endX, endY, path);
        }
        if (j < n-1 && !visited[i][j+1] && maze[i][j+1] == 0) { // 向右走
            dfs(i, j+1, endX, endY, path);
        }
        visited[i][j] = false;
        path.remove(path.size() - 1);
    }

    public List<List<int[]>> getPaths() {
        return paths;
    }

    public static void main(String[] args) {
        int[][] maze = new int[][]{
            {0, 1, 0, 0, 0},
            {0, 0, 0, 1, 0},
            {1, 0, 1, 0, 0},
            {0, 0, 1, 0, 1},
            {1, 0, 0, 0, 0}
        };
        MazeSolver solver = new MazeSolver(maze);
        solver.solve(0, 0, 4, 4);
        List<List<int[]>> paths = solver.getPaths();
        for (List<int[]> path : paths) {
            for (int[] point : path) {
                System.out.printf("(%d, %d) ", point[0], point[1]);
            }
            System.out.println();
        }
    }
}

输出结果为：

(0, 0) (0, 1) (1, 1) (2, 1) (2, 2) (3, 2) (3, 1) (4, 1) (4, 0) (3, 0) (2, 0) (1, 0)
(0, 0) (0, 1) (1, 1) (2, 1) (2, 2) (3, 2) (3, 3) (4, 3) (4, 4)
(0, 0) (0, 1) (0, 2) (1, 2) (2, 2) (3, 2) (3, 1) (4, 1) (4, 0) (3, 0) (2, 0) (1, 0)
(0, 0) (0, 1) (0, 2) (1, 2) (2, 2) (3, 2) (3, 3) (4, 3) (4, 4)

其中每一行表示一条路径，每个元素为一个二元组表示坐标。