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

以下是基于递归和回溯法的Java代码实现：

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

public class MazeSolver {

    private int[][] maze;
    private int rows;
    private int cols;
    private List<int[]> path;
    private List<List<int[]>> allPaths;

    public MazeSolver(int[][] maze) {
        this.maze = maze;
        this.rows = maze.length;
        this.cols = maze[0].length;
        this.path = new ArrayList<>();
        this.allPaths = new ArrayList<>();
    }

    public List<int[]> solve(int startRow, int startCol, int endRow, int endCol) {
        if (startRow < 0 || startRow >= rows || startCol < 0 || startCol >= cols || maze[startRow][startCol] == 1) {
            return null; // 起点非法或为障碍，无法走通
        }
        if (startRow == endRow && startCol == endCol) {
            List<int[]> result = new ArrayList<>();
            result.addAll(path);
            result.add(new int[]{endRow, endCol, -1}); // -1 表示到达终点
            allPaths.add(result); // 找到一条通路
            return result;
        }
        path.add(new int[]{startRow, startCol, -1}); // -1 表示方向未确定
        maze[startRow][startCol] = 1; // 标记为已经走过
        // 尝试向四个方向走
        List<int[]> nextPaths = new ArrayList<>();
        nextPaths.add(solve(startRow + 1, startCol, endRow, endCol)); // 向下走
        nextPaths.add(solve(startRow, startCol + 1, endRow, endCol)); // 向右走
        nextPaths.add(solve(startRow - 1, startCol, endRow, endCol)); // 向上走
        nextPaths.add(solve(startRow, startCol - 1, endRow, endCol)); // 向左走
        // 如果四个方向都无法走通，则回溯
        if (nextPaths.stream().allMatch(p -> p == null)) {
            path.remove(path.size() - 1); // 移除当前坐标
            maze[startRow][startCol] = 0; // 标记为未走过
            return null;
        }
        return path;
    }

    public List<List<int[]>> solveAll(int startRow, int startCol, int endRow, int endCol) {
        solve(startRow, startCol, endRow, endCol); // 先求出一条通路
        while (allPaths.get(allPaths.size() - 1).get(allPaths.get(allPaths.size() - 1).size() - 1)[2] != -1) {
            // 如果最后一条路径的最后一个元素不是终点，则继续求下一条路径
            path.clear(); // 清空当前路径
            solve(startRow, startCol, endRow, endCol);
        }
        return allPaths;
    }

    public static void main(String[] args) {
        int[][] maze = {
                {0, 0, 1, 0},
                {1, 0, 0, 0},
                {0, 0, 1, 0},
                {1, 1, 0, 0}
        };
        MazeSolver solver = new MazeSolver(maze);
        List<int[]> path = solver.solve(0, 0, 3, 3);
        if (path == null) {
            System.out.println("无法走通");
        } else {
            for (int[] p : path) {
                System.out.printf("(%d, %d, %d) ", p[0], p[1], p[2]);
            }
            System.out.println();
        }
        List<List<int[]>> allPaths = solver.solveAll(0, 0, 3, 3);
        for (List<int[]> p : allPaths) {
            for (int[] q : p) {
                System.out.printf("(%d, %d, %d) ", q[0], q[1], q[2]);
            }
            System.out.println();
        }
    }
}

上述代码中，`maze` 是一个二维数组，表示迷宫；`path` 是一个列表，存储当前的路径；`allPaths` 是一个列表，存储所有的路径。`solve` 方法是递归求解从起点到终点的一条路径，`solveAll` 方法则是求解所有路径。

在 `solve` 方法中，我们首先判断起点是否合法，如果是障碍则无法走通；如果已经到达终点，则添加到路径列表中，并将路径列表添加到所有路径列表中；否则，将当前坐标添加到路径列表中，并标记为已经走过。然后尝试向四个方向走，如果有一条方向可以走通，则递归求解该方向；如果四个方向都无法走通，则回溯，将当前坐标从路径列表中移除，并标记为未走过。最后返回路径列表。

在 `solveAll` 方法中，我们先求出一条通路，然后判断是否到达终点。如果没有到达终点，则继续求解下一条路径，直到最后一条路径的最后一个元素为终点为止。

在输出路径时，我们将每个坐标以三元组的形式输出，其中第三个元素表示走到下一坐标的方向，如果是终点则为 -1。