迷宫生成算法prim

㈠ prim算法是什么

prim算法是：图论中的一种算法。

普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。

该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克（英语：Vojtěch Jarník）发现；并在1957年由美国计算机科学家罗伯特·普里姆（英语：Robert C. Prim）独立发现；1959年，艾兹格·迪科斯彻再次发现了该算法。因此，在某些场合，普里姆算法又被称为DJP算法、亚尔尼克算法或普里姆－亚尔尼克算法。

通过邻接矩阵图表示的简易实现中，找到所有最小权边共需O（V）的运行时间。使用简单的二叉堆与邻接表来表示的话，普里姆算法的运行时间则可缩减为O(ElogV)，其中E为连通图的边数，V为顶点数。如果使用较为复杂的斐波那契堆，则可将运行时间进一步缩短为O(E+VlogV)，这在连通图足够密集时（当E满足Ω（VlogV）条件时），可较显着地提高运行速度。

㈡ 迷宫算法复杂度如何计算

迷宫生成可以O(n*m)完成。走迷宫的话可以O(n*m*2)左右。
只要记录走到每一格的最优解就可以了。
最好不要用深度优先搜索。用广度优先的实现方便。

㈢ Prim算法的实现过程

G=（V,E）
①初始化：读入的数据用邻接矩阵x存储，一个一维布尔型数组chosen，记录第i个节点是否已选，初始值除1外全部设为false，记录权值的变量cost赋值为0；
以下②到④循环执行v-1次（每次生成一条边，运行（点的个数减1）次后，生成一棵最小生成树）：
②临时变量p赋值为无限大，用于记录当前最小值；
③二重循环（外循环i，内循环j）扫描邻接矩阵：如果chosen[i]=true（也就是说第i个点已选），那么扫描x[i]，如果not(chosen[j])（也就是说第j个点未选），那么如果x[i,j]<p，那么p赋值为x[i,j],临时变量q赋值为j;
④把cost赋值为cost+o，把chosen[q]赋值为true（也就是说第j个点已选）；
⑤输出cost。

一、以上给出具体的运行过程。这个算法的策略就是贪心，和dijkstra差不多，每次都选择未选的边中权值最小的那一条，直到生成最小生成树。用chosen的目的就是保证生成过程中没有环出现，也就是说保证选择的边不会通向一个已经包含在生成树中的点。
二、这个只输出最小生成树的每条边权值之和，如果要输出整棵最小生成树，加一个[1..n,1..2]的数组，在第④步的时候把每次选的边记录下来就可以了。
三、用小顶堆在第③步优化一下的话就不用每次都扫描那么多边了，只不过建堆维护堆代码写起来很麻烦。
四、prim适合用于比较稠密的网，点数和边数差不多的时候效率很恶心，一般都用kruskal。

㈣ Prim和Dijkstra算法的区别

在图论中，Prim算法是计算最小生成树的算法，而Dijkstra算法是计算最短路径的算法。二者看起来比较类似，因为假设全部顶点的集合是V，已经被挑选出来的点的集合是U，那么二者都是从集合V-U中不断的挑选权值最低的点加入U，那么二者是否等价呢？也就是说是否Dijkstra也可以计算出最小生成树而Prim也可以计算出从第一个顶点v0到其他点的最短路径呢？答案是否定的，否则就不必有两个算法了。
二者的不同之处在于“权值最低”的定义不同，Prim的“权值最低”是相对于U中的任意一点而言的，也就是把U中的点看成一个整体，每次寻找V-U中跟U的距离最小（也就是跟U中任意一点的距离最小）的一点加入U；而Dijkstra的“权值最低”是相对于v0而言的，也就是每次寻找V-U中跟v0的距离最小的一点加入U。
一个可以说明二者不等价的例子是有四个顶点(v0, v1, v2, v3)和四条边且边值定义为(v0, v1)=20, (v0, v2)=10, (v1, v3)=2, (v3, v2)=15的图，用Prim算法得到的最小生成树中v0跟v1是不直接相连的，也就是在最小生成树中v0v1的距离是v0->v2->v3->v1的距离是27，而用Dijkstra算法得到的v0v1的距离是20，也就是二者直接连线的长度。

㈤ “prim” 算法 是谁最先提出在那篇着作里面提出来的对现在有什么意义有什么应用最好详细点。谢谢

Prim算法是图论中求最小生成树的一种算法，最早于1930年由捷克数学家Vojtěch Jarník发现；并在1957年由美国计算机科学家Robert C. Prim独立发现，1959年Edsger Dijkstra再次发现了该算法，参见论文：
R. C. Prim. Shortest Connection Networks And Some Generalizations
JOSEPH B. KRUSKAL, JR. ON THE SHORTEST SPANNING SUBTREE OF A GRAPH AND THE TRAVELING SALESMAN PROBLEM
该算法用于求解图的最小生成树，所有可转换为求图的最小生成树的问题的应用均可以应用Prim算法来解决，他本人的论文里也提及了部分应用。

㈥ Prim算法，求大牛通俗易懂地解释下为什么成立。。。

prim算法就是把点分成两个集合，一个集合里面包含已经加入生成树的点，另一个包含未加入的，然后不断在两个集合之间找最短的边，直到所有的点都加入到生成树中，这时候就构成了最小生成树。

㈦ Prim算法为什么能保证迷宫有唯一通路

为了减少不必要的麻烦，可以不妨设图中所有边的权重都不同，这样最小生成树是唯一的
然后直接用反证法就行了
如果Prim算法得到G，而最小生成树是T
设在生成G的过程中第一次产生的不在T中的边是e，而在G中去掉e得到的两个连通分支记为V1和V2，那么e连接了V1和V2

把e加入T之后会出现环，在这个环里面V1的顶点和V2的顶点至少还被另一条边f连接（否则T本身就不连通了），由Prim算法的贪心策略可知e比f权重低，那么在T里面把f换成e可得一个总权重更小的生成树，与T的最小性矛盾

（因为最小生成树的总权重的边的权重的连续函数，对于有权重重复出现的情况可以利用连续性取极限，这样即使最小生成树不唯一仍然可以保证Prim算法生成的树具有最小权重）

㈧ 什么是Prim算法

Prim算法
Prim算法用于求无向图的最小生成树

设图G =（V，E），其生成树的顶点集合为U。
①、把v0放入U。
②、在所有u∈U，v∈V-U的边(u，v)∈E中找一条最小权值的边，加入生成树。
③、把②找到的边的v加入U集合。如果U集合已有n个元素，则结束，否则继续执行②。
其算法的时间复杂度为O(n^2)

Prim算法实现：
（1）集合：设置一个数组set[i](i=0,1,..,n-1),初始值为 0,代表对应顶点不在集合中（注意：顶点号与下标号差1）
（2）图用邻接阵表示，路径不通用无穷大表示，在计算机中可用一个大整数代替。

参考程序

/* Prim.c

Copyright (c) 2002, 2006 by ctu_85

All Rights Reserved.

*/

/* The impact of the situation of articulation point exists can be omitted in Prim algorithm but not in Kruskal algorithm */

#include "stdio.h"

#define maxver 10

#define maxright 100

int main()

{

int G[maxver][maxver],in[maxver]=,path[maxver][2];

int i,j,k,min=maxright;

int v1,v2,num,temp,status=0,start=0;

restart:

printf("Please enter the number of vertex(s) in the graph:\n");

scanf("%d",&num);

if(num>maxver||num<0)

{

printf("Error!Please reinput!\n");

goto restart;

}

for(j=0;j<num;j++)

for(k=0;k<num;k++)

{

if(j==k)

G[j][k]=maxright;

else

if(j<k)

{

re:

printf("Please input the right between vertex %d and vertex %d,if no edge exists please input -1:\n",j+1,k+1);

scanf("%d",&temp);

if(temp>=maxright||temp<-1)

{

printf("Invalid input!\n");

goto re;

}

if(temp==-1)

temp=maxright;

G[j][k]=G[k][j]=temp;

}

}

for(j=0;j<num;j++)

{

status=0;

for(k=0;k<num;k++)

if(G[j][k]<maxright)

{

status=1;

break;

}

if(status==0)

break;

}

do

{

printf("Please enter the vertex where Prim algorithm starts:");

scanf("%d",&start);

}while(start<0||start>num);

in[start-1]=1;

for(i=0;i<num-1&&status;i++)

{

for(j=0;j<num;j++)

for(k=0;k<num;k++)

if(G[j][k]<min&&in[j]&&(!in[k]))

{

v1=j;

v2=k;

min=G[j][k];

}

if(!in[v2])

{

path[i][0]=v1;

path[i][1]=v2;

in[v1]=1;

in[v2]=1;

min=maxright;

}

}

if(!status)

printf("We cannot deal with it because the graph is not connected!\n");

else

{

for(i=0;i<num-1;i++)

printf("Path %d:vertex %d to vertex %d\n",i+1,path[i][0]+1,path[i][1]+1);

}

return 1;

}

Prim算法。

设图G =（V，E），其生成树的顶点集合为U。

①、把v0放入U。

②、在所有u∈U，v∈V-U的边(u，v)∈E中找一条最小权值的边，加入生成树。

③、把②找到的边的v加入U集合。如果U集合已有n个元素，则结束，否则继续执行②。

其算法的时间复杂度为O(n^2)

参考程序

//Prim 算法 读入顶点数(n)、边数(m)，边的起始点和权值 用邻接矩阵储存

//例如

//7 12 (7个顶点12条边)

//1 2 2

//1 4 1

//1 3 4

//2 4 3

//2 5 10

//3 4 2

//4 5 7

//3 6 5

//4 6 8

//4 7 4

//5 7 6

//6 7 1

#include <stdio.h>

#include <string.h>

int main()

{

int m , n;

int a[201][201] , mark[201] , pre[201] , dist[201];

int s , t , w;

int i , j , k , min , tot;

freopen("Prim.txt" , "r" , stdin);

//读入数据

memset(a , 0 , sizeof(a));

scanf("%d %d" , &n , &m);

for (i = 0; i < m; i ++)

{

scanf("%d %d %d" , &s , &t , &w);

a[s][t] = w; a[t][s] = w;

}

//赋初值

memset(mark , 0 , sizeof(mark));

memset(pre , 0 , sizeof(pre));

memset(dist , 9999 , sizeof(dist));

dist[1] = 0;

//Prim

for (i = 1; i <= n; i ++)

{

min = 9999; k = 0;

for (j = 1; j <= n; j ++)

if ((mark[j] == 0) && (dist[j] < min)) {min = dist[j]; k = j;}

if (k == 0) break;

mark[k] = 1;

for (j = 1; j <= n; j ++)

if ((mark[j] == 0) && (a[k][j] < dist[j]) && (a[k][j] > 0))

{

dist[j] = a[k][j];

pre[j] = k;

}

}

tot = 0;

for (i = 1; i <= n; i ++) tot += dist[i];

printf("%d\n" , tot);

return 0;

}

㈨ 数据结构迷宫算法求解

注释非常详细，希望对你有所帮助。
#include<stdio.h>
#include<stdlib.h>
#define M 15
#define N 15
struct mark //定义迷宫内点的坐标类型
{
int x;
int y;
};

struct Element //"恋"栈元素，嘿嘿。。
{
int x,y; //x行,y列
int d; //d下一步的方向
};

typedef struct LStack //链栈
{
Element elem;
struct LStack *next;
}*PLStack;

/*************栈函数****************/

int InitStack(PLStack &S)//构造空栈
{
S=NULL;
return 1;
}

int StackEmpty(PLStack S)//判断栈是否为空
{
if(S==NULL)
return 1;
else
return 0;
}

int Push(PLStack &S, Element e)//压入新数据元素
{
PLStack p;
p=(PLStack)malloc(sizeof(LStack));
p->elem=e;
p->next=S;
S=p;
return 1;
}

int Pop(PLStack &S,Element &e) //栈顶元素出栈
{
PLStack p;
if(!StackEmpty(S))
{
e=S->elem;
p=S;
S=S->next;
free(p);
return 1;
}
else
return 0;
}

/***************求迷宫路径函数***********************/
void MazePath(struct mark start,struct mark end,int maze[M][N],int diradd[4][2])
{
int i,j,d;int a,b;
Element elem,e;
PLStack S1, S2;
InitStack(S1);
InitStack(S2);
maze[start.x][start.y]=2; //入口点作上标记
elem.x=start.x;
elem.y=start.y;
elem.d=-1; //开始为-1
Push(S1,elem);
while(!StackEmpty(S1)) //栈不为空 有路径可走
{
Pop(S1,elem);
i=elem.x;
j=elem.y;
d=elem.d+1; //下一个方向
while(d<4) //试探东南西北各个方向
{
a=i+diradd[d][0];
b=j+diradd[d][1];
if(a==end.x && b==end.y && maze[a][b]==0) //如果到了出口
{
elem.x=i;
elem.y=j;
elem.d=d;
Push(S1,elem);
elem.x=a;
elem.y=b;
elem.d=886; //方向输出为-1 判断是否到了出口
Push(S1,elem);
printf("\n0=东 1=南 2=西 3=北 886为则走出迷宫\n\n通路为:(行坐标,列坐标,方向)\n");
while(S1) //逆置序列 并输出迷宫路径序列
{
Pop(S1,e);
Push(S2,e);
}
while(S2)
{
Pop(S2,e);
printf("-->(%d,%d,%d)",e.x,e.y,e.d);
}
return; //跳出两层循环，本来用break,但发现出错，exit又会结束程序，选用return还是不错滴
}
if(maze[a][b]==0) //找到可以前进的非出口的点
{
maze[a][b]=2; //标记走过此点
elem.x=i;
elem.y=j;
elem.d=d;
Push(S1,elem); //当前位置入栈
i=a; //下一点转化为当前点
j=b;
d=-1;
}
d++;
}
}
printf("没有找到可以走出此迷宫的路径\n");
}

/*************建立迷宫*******************/
void initmaze(int maze[M][N])
{
int i,j;
int m,n; //迷宫行,列 [/M]

printf("请输入迷宫的行数 m=");
scanf("%d",&m);
printf("请输入迷宫的列数 n=");
scanf("%d",&n);
printf("\n请输入迷宫的各行各列:\n用空格隔开,0代表路,1代表墙\n",m,n);
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
scanf("%d",&maze[i][j]);
printf("你建立的迷宫为(最外圈为墙)...\n");
for(i=0;i<=m+1;i++) //加一圈围墙
{
maze[i][0]=1;
maze[i][n+1]=1;
}
for(j=0;j<=n+1;j++)
{
maze[0][j]=1;
maze[m+1][j]=1;
}
for(i=0;i<=m+1;i++) //输出迷宫
{
for(j=0;j<=n+1;j++)
printf("%d ",maze[i][j]);
printf("\n");
}
}

void main()
{
int sto[M][N];
struct mark start,end; //start,end入口和出口的坐标
int add[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//行增量和列增量 方向依次为东西南北 [/M]

initmaze(sto);//建立迷宫

printf("输入入口的横坐标,纵坐标[逗号隔开]\n");
scanf("%d,%d",&start.x,&start.y);
printf("输入出口的横坐标,纵坐标[逗号隔开]\n");
scanf("%d,%d",&end.x,&end.y);

MazePath(start,end,sto,add); //find path
system("PAUSE");
}
测试数据，算法复杂度你就自己来写吧，如果你连这都不自己做，那你一定是在应付作业。劝你还是自己运行测试一下吧，免得答辩时老师问你，什么都不知道，那你就悲剧了。祝你好运！！

㈩ 怎么制作迷宫图

方案一：主路扭曲型

1、首先，按照下图的间隔规则来生成基础的大地图，1为陆地，0为水域。

2、然后，选择一个靠近边缘的1作为起点，在它的周围随机找另一个黄色的1（这里的“周围”指的是上下左右4个方向，斜边不算）。找到就把他们联通，即把两个1之间的0变成陆地，这里用红色来表示。

3、把上一步“终”的格子作为新的一个“起”格子，不停循环第二步的过程，直到找不到周围有黄色的1。

4、这时候，原路往回走（即不停去找前一个格子），直到找到一个格子，这个格子周围有黄色的1，那么从这个格子开始重复前两个步骤。

5、接下来就是不停重复上面的步骤，找到就联通，找不到就往回走。

6、填充完整个地图之后，迷宫就算是制作完成了，根据需求加上终点即可。

总结一下，这种方案生成的迷宫会有一条明显的主路，即一条特别长、贯穿大部分区域的路线，同时，迷宫的路线一般比较扭曲。

方案二：自然分岔型

这个方案的雏形来自于随机prim算法，具体步骤如下：

1、跟方案一一样，生成一个基础地图。格子先用黄色1和灰色0来表示，暂时不区分水陆。

2、随机取一个地图边缘的黄色1，把它标记为红色1，即变成陆地。然后把它旁边的灰色0标记成蓝色0，表示“待定”。（注意的是，大地图四周的灰色0固定不变，作为地图边缘而存在）

3、敲黑板了！！这里是重点！！！

随机选一个蓝色的0（这一步很重要，会使这个方案明显区别于上一个方案），然后看红色1隔着这个蓝色0对面的格子，是否是黄色的1：

如果是，则把对面的黄色1标记成红色1，即变成陆地，然后把蓝色0变成红色的0，即也变成陆地；

如果不是，就把这个蓝色的0变成灰色的0。

最后，把新创建的红色1周围的灰色0，标记成蓝色0。

4、继续重复上面的步骤

5、对比上图和下图，这里取一个蓝色0生成一个红色1之后，新生成的红色1旁边，有两个蓝色0的两边都是红色1了，那么就根据第三步的规则，在稍后取到这些蓝色0时，就会把他们变成灰色0。

6、继续重复上述步骤，直到整个地图没有蓝色0了，地图就生成完毕。

总结一下，对比方案一，这套方案不会出现明显的主路，迷宫相对比较自然，但迷宫的分岔路会比较多，所以迷宫可能会更复杂，即玩家需要做选择的次数可能比较多。

方案三：块状分割型

上述两个方案有个共同的特点，就是道路永远都是1个格子宽，如果游戏需要给地图创造一些小型地块或者更宽的道路，需要在迷宫生成之后再用各种分布的规则来丰富迷宫。

而第三个方案则以小型地块作为出发点来设计迷宫，这套方案的雏形来自于国外大神Bob Nystrom，有兴趣的可以去查看他个人主页。

1、首先，在大地图（还是之前那个大地图）上生成若干小型地形，保证边长是奇数且不重合就好（示意图全部使用了正方形，实际上可以做成长方形让地图更加自然）。注意顶点要在黄色1格子上即可，这里我用橙色1来表示这些小型地块。

2、然后，根据之前方案一的迷宫生成方案，在非小型地块的区域里，用迷宫来填充。这一步完成之后，迷宫和小型地形是分隔开来的。

3、在橙色1的小型地形周围，随机取点以连接黄色1，连接点的数量可以根据需要来确定，建议是不要吝啬连接点的个数，因为这种地图之下，分岔路远比前两种方案要少。

4、接下来是简化地图，目的是去掉一些死胡同，因为这种方案的核心在于小型地块，没有必要让玩家在迷宫的路上绕。方法是把一些3边都是灰色0的黄色1去掉即可，具体数量也根据游戏需求来制定，我这里只去掉了一部分。

5、最后，给地图加上出口和入口，地图就做完啦！

总结一下，这种方案比前两种多了小型地块，这一点比较适合设计玩家的阶段性反馈。同时地图的分岔路明显减少，玩家在这种方案下的选择次数会明显降低。另外，由于这个方案的步骤相对多且独立，所以对于设计者来讲会比较容易控制地图的结构。