Java 迷宫保存路径

前两天写的 迷宫算法是依据bfs算法最后把数组进行修改，最后得出路径看着比较直观。但实际问题往往不需要输出整个数组，而是选择的路径，所以要使用dfs结合队列进行存储路径
代码：

import java.util.LinkedList;
import java.util.Queue;

//定义Postion类主要是为了存储路径
class Postion {
    int x, y;
    public Postion(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
}

public class T1 {
    //因为要使其他静态方法访问变量，所以这里设置为静态变量
    //迷宫地图
    static int[][] maze = { 
        { 0, 1, 0, 0, 0, 0 }, 
        { 0, 0, 0, 1, 0, 0 },
        { 0, 0, 0, 1, 0, 0 },
        { 0, 0, 1, 0, 0, 1 }, 
        { 1, 1, 0, 0, 0, 0 } };
    //方向
    static int[][] step = { { 1, 0 }, { 0, 1 }, { 0, -1 }, { -1, 0 } };
    //dfs所需要的队列
    static Queue<Postion> q = new LinkedList<Postion>();
    //用于存储走过的路径
    static Queue<String> res = new LinkedList<String>();
    //是否走过
    static boolean[][] flags = new boolean[maze.length][maze[0].length];

    public static void main(String[] args) {
        //添加起始点的信息
        q.add(new Postion(0, 0));
        flags[0][0] = true;
        res.add("");
        //开始dfs
        while (!q.isEmpty()) {
            //获取队头信息，而不出队
            int x = q.peek().x;
            int y = q.peek().y;
            //截止条件
            if (x == maze.length - 1 && y == maze[0].length - 1) {
                //注意这里输出的是 res.peek(),res下存储很多条路径,符合条件就会输出当前的路径
                System.out.println(res.peek());
                break;
            } else {
                //四个方向
                for (int i = 0; i < 4; i++) {
                    //判断要访问的点是否符合要求
                    check(x + step[i][0], y + step[i][1]);
                    //符合的情况下，修改变量已经整合到check方法中
                }
            }
            //出队进行下一次循环
            q.poll();
            res.poll();
        }
        
        //以下是进行地图的输出
        String result = res.peek();
        String[] pos = result.split(" ");
        for (String string : pos) {
            String[] nums = string.replace("(", "").replace(")", "").split(",");
            int x = Integer.parseInt(nums[0]);
            int y = Integer.parseInt(nums[1]);
            maze[x][y] = 2;
        }
        for (int i = 0; i < maze.length; i++) {
            for (int j = 0; j < maze[0].length; j++) {
                System.out.print(maze[i][j] + " ");
            }
            System.out.println();
        }

    }

    private static void check(int i, int j) {
        //验证要访问的点：是否越界、是否已经访问，是否是墙壁
        if (i >= 0 && i < maze.length && j >= 0 && j < maze[0].length
                && !flags[i][j] && maze[i][j] == 0) {
            //符合要求，将结点加入队列，修改访问状态
            q.add(new Postion(i, j));
            flags[i][j] = true;
            //这里比较有趣，add了res.peek,所以每次加入的路径包含队头
            //check后会将队头出队，这要保证了不会吧所有的路径都进行保留
            res.add(res.peek() + "(" + i + "," + j + ") ");
        }

    }

}

运行截图：