一个关於迷宫算法的JAVA程序

一个关於迷宫算法的JAVA程序
以下是一个关于迷宫算法的JAVA程序的示例，代码注释中解释了程序的工作原理和算法实现细节。

```java
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
public class MazeSolver
private int[][] maze;
private int[][] solution;
private int size;
public MazeSolver(int[][] maze)
this.maze = maze;
this.size = maze.length;
this.solution = new int[size][size];
}
//迷宫的通路为0，墙壁为1，已走过的路径为2
//使用深度优先算法找到从起点到终点的路径
public boolean solveMaz
boolean[][] visited = new boolean[size][size];
return solveMazeHelper(0, 0, visited);
}
private boolean solveMazeHelper(int x, int y, boolean[][] visited)
//检测是否到达终点
if (x == size - 1 && y == size - 1)
solution[x][y] = 1;
return true;
}
//检查当前位置是否可行
if (isSafe(x, y, visited))
//标记当前位置为已访问
visited[x][y] = true;
//标记当前位置为路径的一部分
solution[x][y] = 1;
//递归探索当前位置的相邻位置
if (solveMazeHelper(x + 1, y, visited)) // 向右移动
return true;
if (solveMazeHelper(x, y + 1, visited)) // 向下移动return true;
if (solveMazeHelper(x - 1, y, visited)) // 向左移动return true;
if (solveMazeHelper(x, y - 1, visited)) // 向上移动return true;
//如果没有找到路径，取消当前位置的标记
solution[x][y] = 0;
}
return false;
}
private boolean isSafe(int x, int y, boolean[][] visited) //检查坐标是否在合法范围内，且该位置没有被访问过
return x >= 0 && y >= 0 && x < size && y < size &&
maze[x][y] == 0 && !visited[x][y];
}
//使用BFS算法找到从起点到终点的最短路径
public List<Integer> findShortestPat
boolean[][] visited = new boolean[size][size];
int[][] distance = new int[size][size];
int[][] parent = new int[size][size];
//初始化距离和父节点数组
for (int i = 0; i < size; i++)
for (int j = 0; j < size; j++)
distance[i][j] = Integer.MAX_VALUE; // 初始距离为无穷大
parent[i][j] = -1; // 初始父节点为无效值
}
}
//使用BFS算法来设置距离和父节点数组
Deque<int[]> queue = new ArrayDeque<>(;
queue.offer(new int[]{0, 0}); // 起点入队列
visited[0][0] = true;
distance[0][0] = 0;
int[][] directions = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; // 右下左上
while (!queue.isEmpty()
int[] current = queue.poll(;
int x = current[0];
int y = current[1];
for (int[] direction : directions)
int newX = x + direction[0];
int newY = y + direction[1];
if (isSafe(newX, newY, visited))
visited[newX][newY] = true;
queue.offer(new int[]{newX, newY});
distance[newX][newY] = distance[x][y] + 1; // 更新距离parent[newX][newY] = x * size + y; // 更新父节点
}
}
}
//从终点回溯到起点，构造最短路径
List<Integer> shortestPath = new ArrayList<>(;
int currentX = size - 1;
int currentY = size - 1;
while (parent[currentX][currentY] != -1)
shortestPath.add(0, currentX * size + currentY); // 将当前节点添加到路径首部
int parentX = parent[currentX][currentY] / size;
int parentY = parent[currentX][currentY] % size;
currentX = parentX;
currentY = parentY;
}
shortestPath.add(0, 0); // 添加起点到路径首部
return shortestPath;
}
public void printSolutio
for (int[] row : solution)
for (int cell : row)
System.out.print(cell + " ");
}
System.out.println(;
}
}
public static void main(String[] args)
int[][] maze =
{0,1,1,1,1},
{0,0,1,0,1},
{1,0,0,0,0},
{1,1,0,1,1},
{1,1,0,0,0}
};
MazeSolver solver = new MazeSolver(maze);
solver.solveMaze(;
System.out.println("Solution:");
solver.printSolution(;
List<Integer> shortestPath = solver.findShortestPath(;
System.out.println("Shortest Path:" + shortestPath);
}
```
此程序实现了解决迷宫问题的两种算法：深度优先和广度优先。

其中，深度优先算法通过递归实现，而广度优先算法使用BFS算法。

程序先创建了一个`MazeSolver`类，构造函数接受一个二维数组作为
输入迷宫，其中0表示通路，1表示墙壁。

然后，程序实现了
`solveMaze`方法，该方法使用深度优先算法找到从迷宫起点到终点的路径。

`solveMazeHelper`方法是实际的递归帮助程序，探索当前位置的相邻位置是否可行，并继续递归探索下一个位置，直到找到终点或者没有路径可行。

`isSafe`方法用于检查当前位置是否在合法范围内，并且该位置未被访问。

`findShortestPath`方法使用广度优先算法（BFS）找到从起点到终点的最短路径。

它使用一个队列来追踪要探索的位置，并使用一个距离数组和一个父节点数组来记录到达每个位置所需的最短距离和路径。

最后，程序在`main`方法中创建一个迷宫实例，解决迷宫并打印解决方案和最短路径。