这个题目和数据结构---图有关,由于我对图掌握的不是很熟悉,所以写这篇博客来加深自己的理解。
迷宫的随机生成和路径搜索主要和图的遍历有关,一般来说图的遍历主要有两种方式:1、深度优先遍历(DFS)2、广度优先遍历(BFS)
两种遍历方式都很好理解,就说说深度优先遍历:
深度优先遍历,顾名思义,就是尽可能往深处遍历,访问到一个节点时,搜索这个节点没有被访问过的相邻节点,选择一个继续做同样的操作,直到没有邻节点为止再回溯到上一个访问的节点,并选择另外的邻节点。
可以这样描述深度遍历:
(1)访问顶点v;
(2)从v的未被访问的邻接点中选取一个顶点w,重复第一步,如果v没有未访问的邻接点,回溯至上一顶点;
(3)重复上述两步,直至图中所有和v有路径相通的顶点都被访问到。
例如上图,一个可能的遍历顺序就是1-->2-->5-->6-->3-->7-->8-->4-->9-->10。
那么,迷宫的生成和路径搜索与图的遍历有什么关系呢?
假设有如下一个图:
试着对这个图进行深度优先遍历并把遍历的轨迹记录下来,如下图。
遍历顺序依次为 1--->2--->6---->10---->9---->5----->13----->14----->15----->11----->12-----16---->8----->7----->3---->4,
是不是有点迷宫的样子了呢?但是上面这个经过遍历生成的路径图还不能完全算一个迷宫,因为还缺少了“墙”,补上即可成为一个完整的迷宫,如下图:
上图中蓝色的节点为墙,在遍历过程中将点之间的墙“抹掉”--即空白的格子,这样就可形成一个完整的迷宫,如上图。
怎么样,是不是就是一个迷宫了,注意到遍历一次后任意两点之间都可以找到一条路, 所以迷宫的出口和入口只需要从外围的点任选两个即可(如上图中选择的是1旁边的和16旁边的点)。
经过上面的分析,我们就知道该怎么生成一个迷宫了。
1、首先初始化迷宫的雏形,即一个矩形图阵,并为图的每个节点旁边都添加上“墙”,如下图:
2、然后对图中的非“墙”节点进行遍历(深度优先或广度优先都行),为了能够生成随机的迷宫,我们可以在遍历过程过适当的做一些随机的操作(代码中会说明),每次遍历时即打通当前遍历的点与上一个点之间的“墙”
3、遍历完所有的点即可生成一个迷宫,然后再选择出口与入口,一个完整的迷宫就形成了。
至于迷宫的路径搜索,那就完全是图的深度遍历了,大概过程如下。
(1)从迷宫起点节点V开始访问
(2)访问这个节点V,标记为可行的路径;
(3)从v的未被访问的非"墙"邻接点中选取一个顶点w,重复第二步。如果v没有未访问的非"墙"邻接点,把这个节点的可行路径标记移除,回溯至上一节点;
(4)重复上述第(2)、(3)步,直至遍历到迷宫的出口节点。
废话不多说,代码才是正道(以一个二维数组来表示迷宫):
package test;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Stack;
public class Maze {
/**
* 随机生成迷宫
* @param size
* @return
*/
public static Point[][] createMaze(int size){
int realSize = 2 * size + 1;
Point[][] maze = new Point[realSize][realSize];
//初始化迷宫雏形
for(int i = 0; i < realSize; i ++){
for(int j = 0; j < realSize; j ++){
Point p = new Point();
if(i % 2 == 0){
p.value = 1;
}else{
if(j % 2 == 0){
p.value = 1;
} else{
p.value = 0;
}
}
p.x = i;
p.y = j;
maze[i][j] = p;
}
}
// 保存轨迹
List trace = new ArrayList();
Point p = maze[1][1];
List tmpList = new ArrayList();
while(trace.size() < size * size){
tmpList.clear();
// 如果没有访问过,设置为访问过
if(!p.visited){
p.visited = true;
// 加入到轨迹中
trace.add(p);
}
//依次查看上下左右四个方向的节点是否被访问过,如果没有访问过,加入列表中
// 上
if(p.x - 2 > 0) {
Point upPoint = maze[p.x - 2][p.y];
if(!upPoint.visited)
tmpList.add(upPoint);
}
// 下
if(p.x + 2 < realSize){
Point downPoint = maze[p.x + 2][p.y];
if(!downPoint.visited)
tmpList.add(downPoint);
}
// 左
if(p.y - 2 > 0){
Point leftPoint = maze[p.x][p.y - 2];
if(!leftPoint.visited)
tmpList.add(leftPoint);
}
// 右
if(p.y + 2 < realSize){
Point rightPoint = maze[p.x][p.y + 2];
if(!rightPoint.visited)
tmpList.add(rightPoint);
}
// 如果上下左右还有点没有访问
if(tmpList.size() != 0){
// 随机取一个邻点,这样就可以随机生成路径达到随机生成迷宫的目的
Point nextPoint = tmpList.get(new Random().nextInt(tmpList.size()));
// 打通与邻点的“墙”
maze[(p.x + nextPoint.x) / 2][(p.y + nextPoint.y) / 2].value = 0;
// 设置这个邻点为下一个访问点
p = nextPoint;
} else{
// 如果没有邻点,从之前轨迹中的点中随机取一个,也是为了随机生成迷宫
p = trace.get(new Random().nextInt(trace.size()));
}
}
return maze;
}
public static Point[][] search(Point[][] maze, Point enterPoint, Point exitPoint){
int realSize = maze.length;
// 保存轨迹
Stack trace = new Stack();
// 出发点
Point p = enterPoint;
boolean hasFind = false;
do{
// 如果没有访问过,设置为访问过
if(!p.visited){
p.visited = true;
// 设置value为2(表示可行的路径
p.value = 2;
// 如果到了终点,中断
if(p == exitPoint){
hasFind = true;
break;
}
// 加入到轨迹中
trace.push(p);
}
Point nextPoint = null;
//依次查看上下左右四个方向的节点是否可以走
// 上
if(p.x - 1 > 0 && maze[p.x - 1][p.y].value == 0 && !maze[p.x-1][p.y].visited) {
nextPoint = maze[p.x - 1][p.y];
}
// 下
else if(p.x + 1 < realSize && maze[p.x + 1][p.y].value == 0 && !maze[p.x+1][p.y].visited){
nextPoint = maze[p.x + 1][p.y];
}
// 左
else if(p.y - 1 > 0 && maze[p.x][p.y - 1].value == 0 && !maze[p.x][p.y - 1].visited){
nextPoint = maze[p.x][p.y - 1];
}
// 右
else if(p.y + 1 < realSize && maze[p.x][p.y + 1].value == 0 && !maze[p.x][p.y + 1].visited){
nextPoint = maze[p.x][p.y + 1];
}
// 如果上下左右有节点可以走
if(nextPoint != null){
// 设置这个邻点为下一个访问点
p = nextPoint;
} else{
// 如果没有邻点,回退到上一个节点
// 改变value
p.value = 0;
p = trace.pop();
}
} while(!trace.isEmpty());
if(hasFind)
System.out.println("找到路径");
else
System.out.println("没找到路径");
return maze;
}
public static void main(String[] args) {
int size = 5;
int realSize = size * 2 + 1;
// 生成迷宫
Point[][] maze = createMaze(size);
// 指定迷宫出口、入口
// 入口
Point enterPoint = maze[1][0];
// 设置入口的值为0(表示可通)
enterPoint.value = 0;
// 出口
Point exitPoint = maze[realSize - 2][realSize - 1];
// 设置出口的值为0(表示可通)
exitPoint.value = 0;
// 输出迷宫
for(int i = 0; i < realSize; i ++){
for(int j = 0; j < realSize; j ++){
System.out.print(maze[i][j].value + " ");
// 重置每个点的访问性
maze[i][j].visited = false;
}
System.out.println();
}
// 搜索出口
maze = search(maze, enterPoint, exitPoint);
System.out.println();
for(int i = 0; i < realSize; i ++){
for(int j = 0; j < realSize; j ++){
System.out.print(maze[i][j].value + " ");
}
System.out.println();
}
}
static class Point{
public int x;
public int y;
public int value;
boolean visited = false;
}
}