随机迷宫生成算法（并查集+生成树）

最近整合之前学习的opengl知识，和两个朋友(fluyy,Evergreen)一起制作了一个3D的迷宫游戏。我们先是自己设计了九个关卡，而为了增加游戏重复性，在关卡的最后，我设计了一个随机生成的迷宫。今天在这里总结一下其中的算法。

在实现这个功能之前，我在网上找了一下这方面的相关算法。找到的算法很多都是 DFS,,,这个算法，实现起来简单，但是效率较低，而当迷宫大起来的时候容易导致堆栈溢出。 于是我打算从生成树的思路来做，—先将地图初始化为完全无法行走的形式。

确定起点和终点，—将地图的每个空格设置为一个顶点，每个顶点的父顶点设置为自己，顶点之间的墙设置为一条边。

— 实现步骤：

— ①随机选择一条边，判断边连接的顶点，是否在同一子树中，如果是则执行③，如果不是则执行②。

— ②连通这两个顶点，并把他们任意一个添加到另一个所在的子树中。

— ③判断起点和终点是否在同一子树中，如果不是则执行①，如果是则退出。

— 在执行判断两顶点是否在一个子树中，以及合并两个顶点的时候，想要实现高效率的话，使用线性表肯定是不行的，所以这里需要使用 UFS(Union_Find_Set) 并查集 。

—

— 并查集 是一种树型的数据结构，用于处理一些不相交集合（ Disjoint Sets） 的合并及查询问题。常常在使用中以森林来表示。

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define MAXSIZE 1638400
int rank[MAXSIZE];
int parent[MAXSIZE];
const int wid=500;
void Init()
{
     memset(rank, 0, sizeof(rank));
     for(int i=0; i < MAXSIZE; ++i )
         parent[i] = i;
}

int FindSet(int x)
{
    if( x != parent[x] )
         parent[x] = FindSet(parent[x]);
     return parent[x];
}

void UnionSet(int root1, int root2)
{
     int x = FindSet(root1), y = FindSet(root2);
     if( x == y ) return ;
     if( rank[x] > rank[y] ) parent[y] = x;
     else{
         parent[x] = y;
         if( rank[x] == rank[y] ) ++rank[y];
     }
}
int postolist(int x,int y)
{
    return x*wid+y;
}
int main()
{
    int n,x,y,i,j,d,xt1,yt1,xt2,yt2;

    char dun[500][500];
    int dir[4][2]={
                {0,1},{1,0},{-1,0},{0,-1}};
    Init();
    for (i=0; i

以下是 网上找的一个DFS代码

#include 
#include 
#include 
#include 
using namespace std;
#define MAZE_MAX 1000
char map[MAZE_MAX+2][MAZE_MAX+2];
const int x = 500, y = 500;
int z1, z2;

void printMaze();
void makeMaze();
int searchPath(int, int);
int main()
{
 for(int i=0; i<=x*2+2; ++i)
  for(int j=0; j<=y*2+2; ++j)
   map[i][j] = 1;

 makeMaze();
 cout << "Tanky Woo" << endl;
 printMaze();
}

void printMaze()
{
    for(z2=1; z2<=y*2+1; z2++)
    {
        for(z1=1;z1<=x*2+1;z1++)
            fputs(map[z2][z1]==0?"¡¡":"¨€",stdout);
        putchar(10);
    }
 cout << endl;
}

void makeMaze()
{
 for(z1=0, z2=2*y+2; z1<=2*x+2; ++z1)
 {
  map[z1][0] = 0;
  map[z1][z2] = 0;
 }
 for(z1=0, z2=2*x+2; z1<=2*y+2; ++z1)
 {
  map[0][z1] = 0;
  map[z2][z1] = 0;
 }
 map[2][1] = 0;
 map[2*x][2*y+1] = 0;

 srand((unsigned)time(NULL));
 searchPath(rand()%x+1, rand()%y+1);
}

int searchPath(int x, int y)
{
 static int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
 int zx = x*2;
 int zy = y*2;
 int next, turn, i;
 map[zx][zy] = 0;
 turn = rand()%2 ? 1 : 3;
 for(i=0, next=rand()%4; i<4; ++i, next=(next+turn)%4)
  if(map[zx+2*dir[next][0]][zy+2*dir[next][1]] == 1)
  {
   map[zx+dir[next][0]][zy+dir[next][1]] = 0;
   searchPath(x+dir[next][0], y+dir[next][1]);
  }
 return 0;
}