用Java打印递归迷宫解决方案的循环

所以我一直在研究以下问题：

我埋了我的蓝宝石，然后开始走路。我总是走在一条小路上 沿着罗盘方向（北、南、东、西）的直线。当我 停下来，我转了90度，继续走。我可能有 走过我的路，但我不记得了。下面是米数 我向各个方向旅行。我现在迷路了，必须放弃这一切 在我寻找出路时录制。我把这张纸条放在一张纸下面 在我的最终位置摇滚。也许某个幸运的冒险家会破译 我的笔记和我的步骤，以赚取财富。不幸地 没有在废墟中发现这张纸条的记录。相反 你必须写一个程序来寻找宝藏。输入第一个 行包含两个整数X Y，表示行数和行数 废墟中的柱子。最多20行50列。下一个X 线条显示空间的栅格地图。句号“.”是一个空正方形。A. 散列“#”是一个大圆石，表示一个不能进入的正方形。 下一行有一个整数N，即直线路径的计数 走。最多20条路径。最后一行包含N个整数 以空格分隔，显示连续路径长度。。5 10

#### ........# .#...##.# ...#....# ####8 2 4 2 2 5 2 1输出您的程序必须打印相同的地图，带有蓝宝石和最终目标的位置 标记的消息（F）的位置。此外，标记每个转折点 带有连续的小写字母（如果更多地使用同一点 不止一次，为下一轮打印信件。）只有一封 遵循列表中路径长度的路线

#### b、 e.a..f# .#...##.# c、 d#S.Fg# # 我已经做了一个递归的方法，从迷宫的每个开放位置开始检查每个方向，直到找到解决方案，但是问题的输出需要是带转弯的迷宫

问题是，当我使用递归解决方案并编辑实际的char[][]映射时，它永远不知道哪个路径将导致实际的完成，因此它将创建如下输出：

d、 …d

cbabc

d、 …d

但我希望它只显示一条路径，如下所示：

……d

…abc

以下是我不完整的解决方案：

import java.util.Scanner;

public class SapphireSearch {

    private static int rs; // Row Size
    private static int cs; // Column Size

    private static int sr; // Save row (saves solution row)
    private static int sc; // Save col (saves solution col)
    private static Direction sd; // Save direction (saves solution dir)

    private static char[][] map; // the maze to traverse

    private static int n; // number of turns

    private static int[] go; // length of the turns

    public static void main(String[] args) {
        getInput();
        for (int r = 0; r < rs; r++)
            for (int c = 0; c < cs; c++)
                for (Direction d : Direction.values())
                    solve(sr = r, sc = c, sd = d, 0, false);
    }

    public static void solve(int r, int c, Direction d, int start,
            boolean printing) {
        if (isSolid(r, c))
            return;
        if (printing) {
            if (start == 0)
                map[r][c] = 'S';
            else
                map[r][c] = (char) (start - 1 + 'a');
            if (start == n) {
                map[r][c] = 'F';
                return;
            }
        }
        if (start == n - 1 && !printing) {
            solve(sr, sc, sd, 0, true);
            printArray(map);
            System.exit(0);
        }
        int count = 0;
        while (start < go.length && count < go[start]) {
            count++;
            r += d.dr;
            c += d.dc;
            if (isSolid(r, c))
                return;
        }
        for (Direction t : d.turn())
            solve(r, c, t, start + 1, printing);
    }

    public static boolean isSolid(int r, int c) {
        return map[r][c] == '#';
    }

    public static void printArray(char[][] o) {
        for (int r = 0; r < o.length; r++) {
            for (int c = 0; c < o[r].length; c++)
                System.out.print(o[r][c]);
            System.out.println();
        }
    }

    private static void getInput() {
        Scanner s = new Scanner(System.in);
        rs = s.nextInt();
        cs = s.nextInt();
        s.nextLine(); // clear buffer
        map = new char[rs][cs];
        for (int r = 0; r < rs; r++) {
            int c = 0;
            char[] f = s.nextLine().trim().toCharArray();
            for (char t : f)
                map[r][c++] = t;
        }
        n = s.nextInt();
        go = new int[n];
        for (int i = 0; i < n; i++)
            go[i] = s.nextInt();
    }
}

enum Direction {
    // deltaR, deltaC
    up(-1, 0), down(1, 0), left(0, -1), right(0, 1);

    public int dr;
    public int dc;

    private Direction(int dr, int dc) {
        this.dr = dr;
        this.dc = dc;
    }

    public Direction[] turn() {
        Direction[] out = new Direction[2];
        switch (this) {
        case up:
        case down:
            out[0] = left;
            out[1] = right;
            break;
        case left:
        case right:
            out[0] = up;
            out[1] = down;
        }
        return out;
    }
}

import java.util.Scanner；
公共级蓝宝石研究{
私有静态int rs；//行大小
私有静态int cs；//列大小
私有静态int sr；//保存行（保存解决方案行）
私有静态int sc；//保存列（保存解决方案列）
私有静态方向sd；//保存方向（保存解决方案目录）
私有静态字符[][]映射；//要遍历的迷宫
私有静态int n；//圈数
私有静态int[]go；//转弯长度
公共静态void main（字符串[]args）{
getInput（）；
对于（int r=0；r

---

问题是：在我的递归求解算法的基础上，打印解决方案路径的最佳方式是什么（它不会打印出它尝试采用的所有路径）？

在进行递归搜索时，您需要建立轮次列表（为了简单起见，我只是在这里列出了方向，但您也可以存储一个带有坐标的对象）

如果路径为（N，E，N，W，S），则在退出时保存该路径

要做到这一点，请保留部分列表