迷宫问题的递归回溯算法java实现

以下是迷宫问题的递归回溯算法的Java实现：

import java.util.*;

public class MazeSolver {
    // 迷宫的地图
    private int[][] maze;
    // 迷宫的行数和列数
    private int rows, cols;
    // 路径栈，用来保存从起点到终点的路径
    private Stack<Point> path;

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

    public void solve() {
        // 从起点开始搜索
        Point start = new Point(0, 0);
        if (search(start)) {
            System.out.println("找到了一条从起点到终点的路径：");
            for (Point p : path) {
                System.out.println("(" + p.x + ", " + p.y + ")");
            }
        } else {
            System.out.println("没有找到从起点到终点的路径！");
        }
    }

    // 搜索从当前位置开始的路径
    private boolean search(Point cur) {
        // 如果当前位置是终点，则搜索成功
        if (cur.x == rows - 1 && cur.y == cols - 1) {
            path.push(cur);
            return true;
        }
        // 如果当前位置不是终点，则尝试向四个方向搜索
        if (maze[cur.x][cur.y] == 0) {  // 如果当前位置是通路
            maze[cur.x][cur.y] = -1;  // 标记为已访问
            path.push(cur);  // 将当前位置加入路径
            // 向右搜索
            if (cur.y < cols - 1 && search(new Point(cur.x, cur.y + 1))) {
                return true;
            }
            // 向下搜索
            if (cur.x < rows - 1 && search(new Point(cur.x + 1, cur.y))) {
                return true;
            }
            // 向左搜索
            if (cur.y > 0 && search(new Point(cur.x, cur.y - 1))) {
                return true;
            }
            // 向上搜索
            if (cur.x > 0 && search(new Point(cur.x - 1, cur.y))) {
                return true;
            }
            path.pop();  // 如果四个方向都搜索失败，则将当前位置从路径中删除
            maze[cur.x][cur.y] = 0;  // 标记为未访问
        }
        return false;
    }

    public static void main(String[] args) {
        int[][] maze = {
            {0, 1, 0, 0, 0},
            {0, 1, 0, 1, 0},
            {0, 0, 0, 0, 0},
            {0, 1, 1, 1, 0},
            {0, 0, 0, 1, 0}
        };
        MazeSolver solver = new MazeSolver(maze);
        solver.solve();
    }
}

class Point {
    public int x;
    public int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

这个程序使用了递归回溯算法来搜索迷宫中从起点到终点的路径。程序首先从起点开始搜索，如果当前位置是终点，则搜索成功；否则，程序尝试向四个方向（右、下、左、上）搜索。如果搜索成功，则返回 true；否则，程序将当前位置从路径中删除，并且将当前位置标记为未访问，然后返回 false。程序最后输出从起点到终点的路径。