Question

我想编写2D阵列迷宫求解器，我明白了。但是，当2d数组映射具有2个或更多解决方案时，我的代码不起作用。

public class Mapsolver {

    private int tried = 2;
    private int path = 3;
    private int maze[][];

    public Mapsolver(int maze[][], int destinationcolumn, int destinationrow, int locationcolumn, int locationrow) {
        this.maze = maze;
        traverse(locationrow, locationcolumn, destinationrow, destinationcolumn);
    }

    public boolean valid(int row, int column) {
        boolean result = false;

        if (row >= 0 && row < maze.length && column >= 0 && column < maze[row].length) {
            if (maze[row][column] == 1) {
                result = true;
            }
        }
        return result;
    }

    public boolean traverse(int row, int column, int destrow, int destcolumn) {
        boolean done = false;
        if (valid(row, column)) {
            maze[row][column] = tried;

            if (row == destrow && column == destcolumn)
                done = true;

            else {
                done = traverse(row + 1, column, destrow, destcolumn);
                if (!done)
                    done = traverse(row, column + 1, destrow, destcolumn);
                if (!done)
                    done = traverse(row - 1, column, destrow, destcolumn);
                if (!done)
                    done = traverse(row, column - 1, destrow, destcolumn);
            }
            if (done) {
                maze[row][column] = path;
            }
        }
        return done;
    }

    public String toString() {
        String result = "\n";
        for (int row = 0; row < maze.length; row++) {
            for (int column = 0; column < maze[row].length; column++)
                result += maze[row][column] + "";
            result += "\n";
        }
        return result;
    }

}

如果我们有一个解决方案，那绝对是正确的。但是，如果我们有2个或更多的解决方案，则它标志着所有可能的解决方法。但是，我不想在打印时看到所有解决方案。正确的输出将是这些解决方案之一。

Answer 1

您用来解决迷宫的算法是DFS algorithm，并且提供的解决方案不一定是到达目的地的最短路径。

递归的结束条件可确保您只会收到一个解决方案。您认为多个解决方案实际上是一个解决方案，如以下印刷示例所示，基于您的代码（10 * 10网格，xx是墙，目标位于（6）（3），每个迷宫单元格封装在“ |”中，访问过的单元格是-）：

另一个例子：

还有一个：

解决方案中的编号步骤表明DFS算法为到达目的地提供了非常长且曲折的路径。

最重要的是-您得到的解决方案比您想象的要长得多。

Answer 2

您可以为每个访问的顶点存储指向父顶点的指针，并且一旦到达目标顶点，就停止搜索并将（反向）路径打印回到起始顶点。但是在所谓的“完美”迷宫中，除了生成树之外，在任何两个顶点之间始终只有一条路径。

我的2D迷宫求解器无法进行多项选择

2 个答案: