展示迷宫算法
public class Maze { private int[][] maze = null;
private int[] xx = { 1, 0, -1, 0 };
private int[] yy = { 0, 1, 0, -1 };
private Queue queue = null; public Maze(int[][] maze) {
this.maze = maze;
queue = new Queue(maze.length * maze.length);
} public void go() {
Point outPt = new Point(maze.length - 1, maze[0].length - 1);
Point curPt = new Point(0, 0);
Node curNode = new Node(curPt, null);
maze[curPt.x][curPt.y] = 2;
queue.entryQ(curNode); while (!queue.isEmpty()) {
curNode = queue.outQ();
for (int i = 0; i < xx.length; ++i) {
Point nextPt = new Point();
nextPt.x = (curNode.point).x + xx[i];
nextPt.y = (curNode.point).y + yy[i];
if (check(nextPt)) {
Node nextNode = new Node(nextPt, curNode);
queue.entryQ(nextNode);
maze[nextPt.x][nextPt.y] = 2;
if (nextPt.equals(outPt)) {
java.util.Stack<Node> stack = new java.util.Stack<Node>();
stack.push(nextNode);
while ((curNode = nextNode.previous) != null) {
nextNode = curNode;
stack.push(curNode);
}
System.out.println("A Path is:");
while (!stack.isEmpty()) {
curNode = stack.pop();
System.out.println(curNode.point);
}
return;
}
}
}
}
System.out.println("Non solution!");
} private boolean check(Point p) {
if (p.x < 0 || p.x >= maze.length || p.y < 0 || p.y >= maze[0].length) {
return false;
}
if (maze[p.x][p.y] != 0) {
return false;
}
return true;
} public static void main(String[] args) {
int[][] maze = {
{ 0, 0, 1, 0, 1, 0, 1, 0, 1, 0 },
{ 0, 0, 1, 1, 1, 0, 0, 0, 1, 0 },
{ 0, 1, 0, 0, 1, 0, 0, 0, 0, 1 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 },
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 1 },
{ 1, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
{ 0, 1, 0, 0, 1, 0, 0, 1, 0, 1 },
{ 1, 0, 1, 0, 1, 1, 0, 1, 0, 0 }
};
new Maze(maze).go();
} private class Queue { Node[] array = null;
int size = 0;
int len = 0;
int head = 0;
int tail = 0; public Queue(int n) {
array = new Node[n + 1];
size = n + 1;
} public boolean entryQ(Node node) {
if (isFull()) {
return false;
}
tail = (tail + 1) % size;
array[tail] = node;
len++;
return true;
} public Node outQ() {
if (isEmpty()) {
return null;
}
head = (head + 1) % size;
len--;
return array[head];
} public boolean isEmpty() {
return (len == 0 || head == tail) ? true : false;
} public boolean isFull() {
return ((tail + 1) % size == head) ? true : false;
}
} private class Node { Point point = null;
Node previous = null; public Node() {
this(null,null);
} public Node(Point point, Node node) {
this.point = point;
this.previous = node;
}
} private class Point { int x = 0;
int y = 0; public Point() {
this(0, 0);
} public Point(int x, int y) {
this.x = x;
this.y = y;
} public boolean equals(Point p) {
return (x == p.x) && (y == p.y);
} @Override
public String toString() {
return "(" + x + "," + y + ")";
}
}
}
B. 迷宫算法里输入了迷宫具体的路径信息之后怎么用键盘输出结果
迷宫算法的输出结果通常是迷宫的路径，可以通过在控制台或命令行界面上输出来展示。如果你想通过键盘输入来控制迷宫算法的执行过程，可以考虑使用以下方法：
在程序中添加键盘输入功能，例如使用Java中的Scanner类或Python中的input函数等，让用户输入迷宫的起点和终点等信息。
在程序中添加控制台输出功能，例如使用Java中的System.out.println方法或Python中的print函数等，让程序在执行过程中输出迷宫的状态和路径信息。
在程序中添加控制台清屏功能，例如使用Java中的Runtime.getRuntime().exec("clear")方法或Python中的os.system("clear")函数等，让程序在每次输出前清空控制台，以便更好地展示迷宫的状态和路径信息。
在程序中添加暂停功能，例如使用Java中的Thread.sleep方法或Python中的time.sleep函数等，在每次输出后暂停一段时间，以便用户观察迷宫的状态和路径信息。
通过以上方法，你可以在控制台上通过键盘输入和输出来展示迷宫算法的执行过程和结果。
C. C++ DFS算法实现走迷宫自动寻路
深度优先搜索（DFS）是一种遍历图或搜索树的算法。它的基本思想是从树或图的根节点开始，尽可能地深入到树的某一分支中。当无法继续向下探索时，回溯并尝试其他分支。DFS算法在图或树的遍历中非常常用，但在迷宫问题中同样适用。
在迷宫问题中，DFS算法用于寻找从起点到终点的路径。通过深度优先搜索，我们可以探索每个可能的路径，直至找到通向目标的路线。
实现此算法的代码展示了手动操控与自动寻路两种模式。手动模式允许用户逐步探索迷宫，而自动模式则自动寻找并显示从起点到终点的路径。
程序的灵活性在于，只需调整迷宫地图的二维数组和相关常量，即可改变地图大小。自动寻路功能同样可用。
理论上，DFS算法在任何大小和复杂度的迷宫中都能有效寻找路径。然而，这种算法采用递归实现，导致空间占用较大。当迷宫地图增大到一定程度，如20*20，可能会触发堆栈溢出异常。因此，程序中提供了18*18和15*15的迷宫地图用于测试。
编译环境为Windows VS2019。该算法的代码包含游戏类（Game.h）和主函数文件（迷宫.cpp），并提供了一定的调试支持。如果您在使用过程中发现任何问题，欢迎指出，感谢您对本项目的贡献。