课程设计迷宫

① C++课程设计：迷宫问题演示程序

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
#define M 15
#define N 15
int z=0;
struct Point
{
int m_1;
int n_1;
Point_cout();
Point_cout1();
};
Point::Point_cout()
{
return(m_1);
}
Point::Point_cout1()
{
return(n_1);
}
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[2][4][2],int z,int &a,int &b)
{
int m=a;
int n=b;
int i,j,d;
int a_1,b_1;
Element elem;
PLStack S1, S2;
InitStack(S1);
InitStack(S2);
if(z<2)
{
for(int w_1=0;w_1<9;w_1++)
for(int w_2=0;w_2<8;w_2++)
if(maze[w_1][w_2]==2)
maze[w_1][w_2]=0;
maze[start.x][start.y]=2;
//入口点作上标记
elem.x=start.x;
elem.y=start.y;
elem.d=-1;
Push(S1,elem); //开始为-1
//cout<<elem.x<<" "<<elem.y<<" "<<elem.d<<" "; while(!StackEmpty(S1)) //栈不为空 有路径可走
{
Pop(S1,elem);
//cout<<elem.x<<elem.y<<elem.d;
i=elem.x;
j=elem.y;
d=elem.d+1;while(d<4) //试探东南西北各个方向
{
a_1=i+diradd[z][d][0];
b_1=j+diradd[z][d][1];
if(a_1==end.x && b_1==end.y && maze[a_1][b_1]==0) //如果到了出口
{
cout<<"可以到达出口的路径有："<<endl;
//maze[a][b]=2
elem.x=i;
elem.y=j;
elem.d=d;
Push(S1,elem);
elem.x=a_1;
elem.y=b_1;
elem.d=886; //方向输出为-1 判断是否到了出口
Push(S1,elem);
//cout<<"\n0=东 1=南 2=西 3=北 886为则走出迷宫\n\n通路为:(行坐标,列坐标,方向)";
cout<<endl;
while(S1) //逆置序列 并输出迷宫路径序列
{
Pop(S1,elem);
//cout<<"("<<e.x<<","<<e.y<<","<<e.d<<")"<<"-->";
Push(S2,elem);
}
while(S2)
{
Pop(S2,elem);
printf("-->(%d,%d,%d)",elem.x,elem.y,elem.d);
}
cout<<endl;
for(i=0;i<=m+1;i++) //输出迷宫
{
for(j=0;j<=n+1;j++)
cout<<maze[i][j]<<" ";
cout<<endl;
}
++z;
MazePath(start,end,maze,diradd,z,a,b);
}
if(maze[a_1][b_1]==0) //找到可以前进的非出口的点
{
maze[a_1][b_1]=2; //标记走过此点
elem.x=i;
elem.y=j;
elem.d=d;
Push(S1,elem); //当前位置入栈
i=a_1; //下一点转化为当前点
j=b_1;
d=-1;
}
d++;
}
}
//cout<<"("<<elem.x<<","<<elem.y<<","<<elem.d<<")"<<"-->"<<"||";
}
//cout<<"没有找到可以走出此迷宫的路径\n";
}
/*************建立迷宫*******************/
int initmaze(int maze[M][N],int &a,int &b)
{
int i,j;
int m,n; //迷宫行,列
cout<<"请输入迷宫的行数 m=";
cin>>m;
cout<<"请输入迷宫的列数 n=";
cin>>n;
a=m;
b=n;
cout<<"请输入迷宫的各行各列:\n用空格隔开,0代表路,1代表墙:";
cout<<endl;
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
cin>>maze[i][j];
cout<<"你建立的迷宫为:";
cout<<endl;
for(i=0;i<=m+1;i++) //加一圈围墙
{
maze[i][0]=8;
maze[i][n+1]=8;
}
for(j=0;j<=n+1;j++)
{
maze[0][j]=8;
maze[m+1][j]=8;
}
for(i=0;i<=m+1;i++) //输出迷宫
{
for(j=0;j<=n+1;j++)
cout<<maze[i][j]<<" ";
cout<<endl;
}
return 0;
} void main()
{
int a=0;
int b=0;
int sto[M][N]; struct mark start,end; //start,end入口和出口的坐标
int add[2][4][2]={{{0,1},{1,0},{0,-1},{-1,0}},{{1,0},{0,1},{0,-1},{-1,0}}};//行增量和列增量 方向依次为东西南北
cout<<"注:上面的式子一维为2，根据东西南北，共有16种排列，因数量太多，故省略只写顺序依次为东南西北和南东西北";
cout<<endl;
initmaze(sto,a,b);//建立迷宫
cout<<"输入入口的横坐标,纵坐标";
cin>>start.x>>start.y;
cout<<"输入出口的横坐标,纵坐标";
cin>>end.x>>end.y;
MazePath(start,end,sto,add,z,a,b); //find path
//system("PAUSE");
}
// 下面是以9行8列的输入（你可以复制，黏贴就ok 了）0 1 1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 0 1 1 0 1 1 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 1 1 0 1 1 0 0 0 1 1 0 1 1 1 1 0 1 1 0 0 0 0 0 0 1 1 1 0 1 1 1 1 1

② c语言课程设计一个迷宫

让人完全帮你写一个这基本没机会，
迷宫的随机生成要注意调整随机变量的值，不断测试，尽量得出一个比较可行迷宫生成器。
提醒你一下就是 自动运行探索那里，如果要用递归的话，写一个函数，判断该店是否可行，如果可行，就调用该函数探索周围的点，地图可以看做一个二维数组,0，1判断是否可行，
这里给你一个伪代码例子
//1表示可行，0表示不可行
search_map（a[][MAX],point_x,point_y）
{
if（a[point_x][point_y]==0&&数组未越界)
{
search_map(a,point_x+1,point_y);
search_map(a,point_x-1,point_y);
search_map(a,point_x,point_y+1);
search_map(a,point_x,point_y-1);
}
}
调用这个函数的时候在主函数调用search_map（a,入口_x，入口_y)即可，这样可以查到所有可以达到的范围，最后可以抽取一条或数条可行路径。

③ 数据结构课程设计的迷宫问题~~~~急！！！

看下我的程序,,要不是你要的.

#include <iostream>
#include <iomanip>
using namespace std;
#define M 20
#define N 20
struct move{int dx,dy;};
move mazemove[8];
char ma[M][N];
int False=0;

void maze()
{int i,j,num;
for(i=1;i<M-1;i++)
{for(j=1;j<N-1;j++)
{num=(800*(i+j)+1500)%327;
if((num<156)&&(i!=M||j!=N))
ma[i][j]='1';
else
ma[i][j]='0';
}
}
ma[1][1]='0';
ma[M-2][N-2]='0';
for(i=0;i<M;i++)
{for(j=0;j<N;j++)
cout<<setw(3)<<ma[i][j];
cout<<endl;
}
}

void inimove()
{mazemove[0].dx=0;mazemove[0].dy=1;
mazemove[1].dx=1;mazemove[1].dy=1;
mazemove[2].dx=1;mazemove[2].dy=0;
mazemove[3].dx=1;mazemove[3].dy=-1;
mazemove[4].dx=0;mazemove[4].dy=-1;
mazemove[5].dx=-1;mazemove[5].dy=-1;
mazemove[6].dx=-1;mazemove[6].dy=0;
mazemove[7].dx=-1;mazemove[7].dy=1;
}

void outpath()
{int i,j,x,y,k;
i=1;j=1;k=0;
while((i!=(M-2))||(j!=(N-2)))
{for(k=0;k<8;k++)
{x=i+mazemove[k].dx;
y=j+mazemove[k].dy;
if(ma[x][y]=='0'){k=0;break;}
}
if(k!=8)
{if(ma[i][j]=='8')ma[i][j]='2';
if(ma[i][j]=='0')ma[i][j]='>';
i=x;j=y;
}
else
{for(k=0;k<8;k++)
{x=i+mazemove[k].dx;
y=j+mazemove[k].dy;
if(ma[x][y]=='8')break;
}
ma[i][j]='2';
i=x;j=y;
}
if((i==1)&&(j==1))
{False=0;
break;
}
else False=1;
}

}

int main()
{int i,j;
maze();
inimove();
outpath();
cout<<endl;
if(False==0)
cout<<"无法走出该迷宫!"<<endl;
else
{cout<<"走出迷宫的路径(用‘>’符号表示)为:"<<endl;
ma[M-2][N-2]='>';
for(i=0;i<M;i++)
{for(j=0;j<N;j++)
{ {if(ma[i][j]=='2')ma[i][j]='>';
if(ma[i][j]=='0')ma[i][j]=' ';
if(ma[i][j]=='1')ma[i][j]='*';
}
cout<<setw(3)<<ma[i][j];
}
cout<<endl;
}
}
return 0;
}

④ 数据结构 c语言 课程设计 小鼠走迷宫问题

|”1、可以用“*”来代表老鼠，“|”来代表墙，空格来代表路。每走一步用system("cls")刷新一次屏幕。
2、墙不可穿过代表，墙与周围的格子没有边。
3、规定一个时间t，若在t步之内没有走到粮仓，则输出无解。
4、这个简单，无非就是修改条件，从而修改整个图。
5、所用路径可以用深搜（回朔）来解决，最短路就用广搜来解决。最短路也可以用Dijstra算法、floyd算法等，但广搜是最简单的。
具体的程序你自己实现吧，如果写不出来，就去请教一下你们学校的ACMer，他们应该会比较熟悉。加油吧。

⑤ c语言的课程设计：迷宫问题。

参考一下这个

/*4.3.3源程序*/
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#define N 20/*迷宫的大小，可改变*/
int oldmap[N][N];/*递归用的数组,用全局变量节约时间*/
int yes=0;/*yes是判断是否找到路的标志,1找到，0没找到*/
int way[100][2],wayn=0;/*way数组是显示路线用的,wayn是统计走了几个格子*/
void Init(void);/*图形初始化*/
void Close(void);/*图形关闭*/
void DrawPeople(int *x,int *y,int n);/*画人工探索物图*/
void PeopleFind(int (*x)[N]);/*人工探索*/
void WayCopy(int (*x)[N],int (*y)[N]);/*为了8个方向的递归，把旧迷宫图拷贝给新数组*/
int FindWay(int (*x)[N],int i,int j);/*自动探索函数*/
void MapRand(int (*x)[N]);/*随机生成迷宫函数*/
void PrMap(int (*x)[N]);/*输出迷宫图函数*/
void Result(void);/*输出结果处理*/
void Find(void);/*成功处理*/
void NotFind(void);/*失败处理*/
void main(void)/*主函数*/
{
int map[N][N]; /*迷宫数组*/
char ch;
clrscr();
printf("\n Please select hand(1) else auto\n");/*选择探索方式*/
scanf("%c",&ch);
Init(); /*初始化*/
MapRand(map);/*生成迷宫*/
PrMap(map);/*显示迷宫图*/
if(ch=='1')
PeopleFind(map);/*人工探索*/
else
FindWay(map,1,1);/*系统自动从下标1,1的地方开始探索*/
Result();/*输出结果*/
Close();
}
void Init(void)/*图形初始化*/
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\\tc");
}
void DrawPeople(int *x,int *y,int n)/*画人工控制图*/
{/*如果将以下两句注释掉，则显示人工走过的路径，*/
setfillstyle(SOLID_FILL,WHITE); /*设置白色实体填充样式*/
bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6);
/*恢复原通路*/
switch(n)/*判断x,y的变化，8个方向的变化*/
{
case 1: (*x)--;break; /*上*/
case 2: (*x)--;(*y)++;break ;/*右上*/
case 3: (*y)++;break; /*右*/
case 4: (*x)++;(*y)++;break; /*右下*/
case 5: (*x)++;break; /*下*/
case 6: (*x)++;(*y)--;break; /*左下*/
case 7: (*y)--;break; /*左*/
case 8: (*x)--;(*y)--;break; /*左上*/
}
setfillstyle(SOLID_FILL,RED);/*新位置显示探索物*/
bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6);
}
void PeopleFind(int (*map)[N])/*人工手动查找*/
{
int x,y;
char c=0;/*接收按键的变量*/
x=y=1;/*人工查找的初始位置*/
setcolor(11);
line(500,200,550,200);
outtextxy(570,197,"d");
line(500,200,450,200);
outtextxy(430,197,"a");
line(500,200,500,150);
outtextxy(497,130,"w");
line(500,200,500,250);
outtextxy(497,270,"x");
line(500,200,450,150);
outtextxy(445,130,"q");
line(500,200,550,150);
outtextxy(550,130,"e");
line(500,200,450,250);
outtextxy(445,270,"z");
line(500,200,550,250);
outtextxy(550,270,"c");/*以上是画8个方向的控制介绍*/
setcolor(YELLOW);
outtextxy(420,290,"Press 'Enter' to end");/*压回车键结束*/
setfillstyle(SOLID_FILL,RED);
bar(100+y*15-6,50+x*15-6,100+y*15+6,50+x*15+6);/*入口位置显示*/
while(c!=13)/*如果按下的不是回车键*/
{
c=getch();/*接收字符后开始各个方向的探索*/
if(c=='w'&&map[x-1][y]!=1)
DrawPeople(&x,&y,1);/*上*/
else
if(c=='e'&&map[x-1][y+1]!=1)
DrawPeople(&x,&y,2);/*右上*/
else
if(c=='d'&&map[x][y+1]!=1)
DrawPeople(&x,&y,3);/*右*/
else
if(c=='c'&&map[x+1][y+1]!=1)
DrawPeople(&x,&y,4);/*右下*/
else
if(c=='x'&&map[x+1][y]!=1)
DrawPeople(&x,&y,5);/*下*/
else
if(c=='z'&&map[x+1][y-1]!=1)
DrawPeople(&x,&y,6); /*左下*/
else
if(c=='a'&&map[x][y-1]!=1)
DrawPeople(&x,&y,7); /*左*/
else if(c=='q'&&map[x-1][y-1]!=1)
DrawPeople(&x,&y,8); /*左上*/
}
setfillstyle(SOLID_FILL,WHITE); /*消去红色探索物，恢复原迷宫图*/
bar(100+y*15-6,50+x*15-6,100+y*15+6,50+x*15+6);
if(x==N-2&&y==N-2)/*人工控制找成功的话*/
yes=1; /*如果成功标志为1*/
}
void WayCopy(int (*oldmap)[N],int (*map)[N])/*拷贝迷宫数组 */
{
int i,j;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
oldmap[i][j]=map[i][j];
}
int FindWay(int (*map)[N],int i,int j)/*递归找路*/
{
if(i==N-2&&j==N-2)/*走到出口*/
{
yes=1;/*标志为1,表示成功*/
return;
}
map[i][j]=1;/*走过的地方变为1*/
WayCopy(oldmap,map); /*拷贝迷宫图*/
if(oldmap[i+1][j+1]==0&&!yes)/*判断右下方是否可走*/
{
FindWay(oldmap,i+1,j+1);
if(yes)/*如果到达出口了，再把值赋给显示路线的way数组,也正是这个原因,所以具体路线是从最后开始保存*/
{
way[wayn][0]=i;
way[wayn++][1]=j;
return;
}
}
WayCopy(oldmap,map);
if(oldmap[i+1][j]==0&&!yes)/*判断下方是否可以走,如果标志yes已经是1也不用找下去了*/
{
FindWay(oldmap,i+1,j);
if(yes)
{
way[wayn][0]=i;
way[wayn++][1]=j;
return;
}
}
WayCopy(oldmap,map);
if(oldmap[i][j+1]==0&&!yes)/*判断右方是否可以走*/
{
FindWay(oldmap,i,j+1);
if(yes)
{
way[wayn][0]=i;
way[wayn++][1]=j;
return;
}
}
WayCopy(oldmap,map);
if(oldmap[i-1][j]==0&&!yes)/*判断上方是否可以走*/
{
FindWay(oldmap,i-1,j);
if(yes)
{
way[wayn][0]=i;
way[wayn++][1]=j;
return;
}
}
WayCopy(oldmap,map);
if(oldmap[i-1][j+1]==0&&!yes)/*判断右上方是否可以走*/
{
FindWay(oldmap,i-1,j+1);
if(yes)
{
way[wayn][0]=i;
way[wayn++][1]=j;
return;
}
}
WayCopy(oldmap,map);
if(oldmap[i+1][j-1]==0&&!yes)/*判断左下方是否可以走*/
{
FindWay(oldmap,i+1,j-1);
if(yes)
{
way[wayn][0]=i;
way[wayn++][1]=j;
return;
}
}
WayCopy(oldmap,map);
if(oldmap[i][j-1]==0&&!yes)/*判断左方是否可以走*/
{
FindWay(oldmap,i,j-1);
if(yes)
{
way[wayn][0]=i;
way[wayn++][1]=j;
return;
}
}
WayCopy(oldmap,map);
if(oldmap[i-1][j-1]==0&&!yes)/*判断左上方是否可以走*/
{
FindWay(oldmap,i-1,j-1);
if(yes)
{
way[wayn][0]=i;
way[wayn++][1]=j;
return;
}
}
return;
}
void MapRand(int (*map)[N])/*开始的随机迷宫图*/
{
int i,j;
cleardevice();/*清屏*/
randomize(); /*随机数发生器*/
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
if(i==0||i==N-1||j==0||j==N-1)/*最外面一圈为墙壁*/
map[i][j]=1;
else
if(i==1&&j==1||i==N-2&&j==N-2)/*出发点与终点表示为可走的*/
map[i][j]=0;
else
map[i][j]=random(2);/*其它的随机生成0或1*/
}
}
}
void PrMap(int (*map)[N])/*输出迷宫图*/
{
int i,j;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
if(map[i][j]==0)
{
setfillstyle(SOLID_FILL,WHITE);/*白色为可走的路*/
bar(100+j*15-6,50+i*15-6,100+j*15+6,50+i*15+6);
}
else
{
setfillstyle(SOLID_FILL,BLUE);/*蓝色为墙壁*/
bar(100+j*15-6,50+i*15-6,100+j*15+6,50+i*15+6);
}
}
void Find(void)/*找到通路*/
{
int i;
setfillstyle(SOLID_FILL,RED);/*红色输出走的具体路线*/
wayn--;
for(i=wayn;i>=0;i--)
{
bar(100+way[i][1]*15-6,50+way[i][0]*15-6,100+
way[i][1]*15+6,50+way[i][0]*15+6);
sleep(1);/*控制显示时间*/
}
bar(100+(N-2)*15-6,50+(N-2)*15-6,100+
(N-2)*15+6,50+(N-2)*15+6); /*在目标点标红色*/
setcolor(GREEN);
settextstyle(0,0,2);/*设置字体大小*/
outtextxy(130,400,"Find a way!");
}
void NotFind(void)/*没找到通路*/
{
setcolor(GREEN);
settextstyle(0,0,2);/*设置字体大小*/
outtextxy(130,400,"Not find a way!");
}
void Result(void)/*结果处理*/
{
if(yes)/*如果找到*/
Find();
else/*没找到路*/
NotFind();
getch();
}
void Close(void)/*图形关闭*/
{
closegraph();
}


⑥ VC++课程设计，迷宫游戏，高手进

想要复制粘贴根本不可能，哥们你也太不厚道了，至少留个邮箱也成啊内，弄得发都不知道容往哪里去发。
你直接去网站上看即可，大体的设计程序就是那样的，对赫夫曼编码稍作修改即可，我们做过相关的程序，也是根据上面的和教材的提示改编而成的。
http://wenku..com/view/c6d33cd276a20029bd642d57.html
希望对你有帮助，给分~ ~

⑦ C迷宫课设纠错~麻烦了~给你最高分，就到

#include<iostream>
#include<cassert>
#include<ctime>
#include<windows.h>
using namespace std;
const int MAXINT = 88888; //随便取个数,大于地图上任意两点间的距离
int map_w, map_h; //地图的宽,高
inline int title_num(int x,int y){return map_w*x+y;} //由坐标转化为地图块号
inline int title_y(int n){return n%map_w;}//由块号转化为x,y坐标
inline int title_x(int n){return n/map_w;}
class treenode
{
public:
int h; //节点所在的高度，表示从起始点到该节点所有的步数
int title; //该节点的位置(块数)
treenode*father; //该节点的上一步
};

class linknode //链表结点
{
public:
treenode*node;
int f;
linknode*next;
};

linknode*open_queue; // 保存没有处理的行走方法的节点
linknode*close_queue; // 保存已经处理过的节点 (搜索完后释放)

unsigned int*map; //地图数据
unsigned int*dis_map; //保存搜索路径时,中间目标地最优解

int startx,starty,endx,endy; //地点,终点坐标

void initial() // 初始化队列
{
open_queue=new linknode();
open_queue->node=NULL;
open_queue->f=-1;
open_queue->next=new linknode();
open_queue->next->node=NULL;
open_queue->next->next=NULL;
open_queue->next->f=MAXINT;
close_queue=new linknode();
close_queue->f=-1;
close_queue->next=NULL;
close_queue->node=NULL;
}

void entrance(treenode*node, int m) // 待处理节点入队列, 依*对目的地估价距离插入排序
{
linknode*p,*priot;
p=open_queue;

while(m>p->f)
{
priot=p;
p=p->next;
assert(p);
}

linknode*q=new linknode();
q->next=p;
priot->next=q;
q->node=node;
q->f=m;
}

treenode*receive() // 将离目的地估计最近的方案出队列
{
linknode*p=open_queue->next;
open_queue->next=open_queue->next->next;
p->next=close_queue->next;
close_queue->next=p;
return p->node;
}

void pop_stack() // 释放栈顶节点
{
linknode*p=close_queue->next;
close_queue->next=close_queue->next->next;
assert(p);
delete p->node;
delete p;
}

void empty() // 释放申请过的所有节点
{
linknode*p;

while(open_queue)
{
p=open_queue;
delete p->node;
open_queue=open_queue->next;
delete p;
}

while(close_queue)
{
p=close_queue;
delete p->node;
close_queue=close_queue->next;
delete p;
}
}

int testing(int x,int y) // 估价函数,估价 x,y 到目的地的距离,估计值必须保证比实际值小
{
return abs(endx-x)+abs(endy-y);
}

int trytest(int x,int y,treenode* priot) //尝试下一步移动到 x,y 可行否
{
treenode*p;
int h;
if(0==map[title_num(x,y)])return 1;
h=priot->h+1;
if(h>=dis_map[title_num(x,y)])return 1; // 如果曾经有更好的方案移动到 (x,y) 失败
dis_map[title_num(x,y)]=h; // 记录这次到 (x,y) 的距离为历史最佳距离
// 将这步方案记入待处理队列

p=new treenode();
p->father=priot;
p->h=priot->h+1;
p->title=title_num(x,y);
entrance(p, p->h+testing(x,y));
return 0;
}

int* lookup() // 路径寻找主函数
{
treenode*root=root=new treenode();
int i;
int*paths;

memset(dis_map,0xff,map_h*map_w*sizeof(*dis_map));//填充dis_map为0XFF，表示各点未曾经过
initial();

root->title=title_num(startx,starty);
root->h=0;
root->father=NULL;
entrance(root,testing(startx,starty));

for(;;)
{
int x,y,child;
root=receive();
if(NULL==root)return NULL;

x=title_x(root->title );
y=title_y(root->title );

if(x==endx&&y==endy)break;;// 达到目的地成功返回

child=1;
child&=trytest(x,y-1,root); //尝试4个方向
child&=trytest(x,y+1,root);
child&=trytest(x-1,y,root);
child&=trytest(x+1,y,root);
if(child!=0)pop_stack();// 如果四个方向均不能移动,释放这个死节点
}
paths=new int[root->h+2];
assert(paths);
for(i=0;root;++i)
{
paths[i]=root->title;
root=root->father;
}

paths[i]=-1;
empty();
return paths;
}
void showmap();//显示地图
void showpath(int *paths) // 回溯树，将求出的最佳路径保存在 path[] 中
{
int i;

if(paths==NULL)
return;

for(i=0; paths[i]>0; ++i)
{
cout << "("
<< title_x(paths[i])
<< ","
<< title_y(paths[i])
<< ")" << " ";
}

cout<<endl;
for(i=0; paths[i]>0; ++i)
{
assert(paths[i]);
map[paths[i]]='*';
system("cls");
showmap();
}
}

void setmap() //申请dis_map的大小
{
dis_map=new unsigned int[map_w*map_h*sizeof(dis_map)];
assert(dis_map);
}

void showmap() //显示地图
{
int i,j;
assert(map);
for(i=0;i<map_h;++i)
{
for(j=0;j<map_w;++j)
{
if(i==0||j==0||i==map_h-1||j==map_w-1)
{
cout<<"■";
continue;
}
if(i==startx&&j==starty)
{
cout<<"E";
continue;
}
if(i==endx&&j==endy)
{
cout<<"S";
continue;
}
if(map[map_w*i+j]=='*')
{
cout<<"＊";
continue;
}
if(map[map_w*i+j])cout<<"□";
else cout<<"■";

}
cout<<endl;
}
Sleep(800);
}
void maps() //生成地图
{
int in1;
int in2;
cout<<"请输入随机地图的宽度:";
cin>>in1;
map_w=in1+2;
cout<<"请输入随机地图的高度:";
cin>>in2;
map_h=in2+2;
cout<<endl;
cout<<"请输入地图的入口坐标x["<<1<<","<<in1<<"]"<<",y["<<1<<","<<in2<<"]\nx=";
cin>>endy;
while(endy<1||endy>in1)
{
cin.clear();
while(cin.get()!='\n')continue;
cout<<"输入错误,请重新输入\nx=";
cin>>endy;
}
cout<<"y=";
cin>>endx;
while(endx<1||endx>in2)
{
cin.clear();
while(cin.get()!='\n')continue;
cout<<"输入错误,请重新输入\ny=";
cin>>endx;
}
cout<<endl;
cout<<"请输入地图的出口坐标x["<<1<<","<<in1<<"]"<<",y["<<1<<","<<in2<<"]\nx=";
cin>>starty;
while(starty<1||starty>in1)
{
cin.clear();
while(cin.get()!='\n')continue;
cout<<"输入错误,请重新输入\nx=";
cin>>starty;
}
cout<<"y=";
cin>>startx;
while(startx<1||startx>in2)
{
cin.clear();
while(cin.get()!='\n')continue;
cout<<"输入错误,请重新输入\ny=";
cin>>startx;
}
cout<<endl;
map=new unsigned int[(map_w+1)*map_h];
int i=0,j=0,direc=2;
int ran;
for(i=0;i<map_h;i++)
for(j=0;j<map_w;j++)
map[map_w*i+j]=1; //初始化地图
srand(time(0));
i=j=0;
while(1){
if(i>=map_h-1&&j>=map_w-1)break;
ran=(int)rand()%4;
if(ran<1){
if(direc!=1&&i<map_h-1){
i++;
direc=3;
}
}
else if(ran<2){
if(direc!=2&&j>0){
j--;
direc=0;
}
}
else if(ran<3){
if(direc!=3&&i>0){
i--;
direc=1;
}
}
else {
if(direc!=0&&j<map_w-1){
j++;
direc=2;
}
}
}
for(i=0;i<map_h;i++)
for(j=0;j<map_w;j++)
if(map[map_w*i+j]==1){
ran=(int)rand()%10;
if(ran<3)map[map_w*i+j]=0;
}
map[title_num(startx,starty)]=1;
map[title_num(endx,endy)]=1;
for(i=0;i<map_h;++i)
{
for(j=0;j<map_w;++j)
{
if(i==0||j==0)map[title_num(i,j)]=0;
if(i==map_h-1||j==map_w-1)map[title_num(i,j)]=0;
}
}
}
int main()
{
while(1)
{
char anyt;
int*paths;
maps();
setmap();
system("cls");
showmap();
system("PAUSE");
paths=lookup();
if(paths==NULL)
{
system("cls");

cout<<" \\\|/// \n";
cout<<" \\ - - // \n";
cout<<" ( @ @ ) \n";
cout<<" ┏━━━━━━━oOOo-(_)-oOOo━━━━━━━┓ \n";
cout<<" ┃ ┃ \n";
cout<<" ┃ ┃ \n";
cout<<" ┃ 没有出路 ┃ \n";
cout<<" ┃ ┃ \n";
cout<<" ┃ ┃ \n";
cout<<" ┃ ┃ \n";
cout<<" ┃ ┃ \n";
cout<<" ┃ ┃ \n";
cout<<" ┃ ┃ \n";
cout<<" ┃ ┃ \n";
cout<<" ┃ Oooo ┃ \n";
cout<<" ┗━━━━━━━ oooO━-( )━━━━━━━┛ \n";
cout<<" ( ) ) / \n";
cout<<" \ ( (_/ \n";
cout<<" \_) \n";
}
showpath(paths);
if(dis_map)delete [] dis_map;
if(paths)delete [] paths;
if(map)delete [] map;
cout<<"搜索完成";
system("PAUSE");
system("cls");
cout<<"再来一次(Y/N)?";
cin>>anyt;
if(anyt=='n'||anyt=='N')break;
}
system("PAUSE");
return 0;
}

⑧ 迷宫课程设计

#include<stdio.h> struct PosType //迷宫坐标位置类型 { int x; int y; }; #define MAXLENGTH 25 //设迷宫的最大行列为25 typedef int MazeType[MAXLENGTH][MAXLENGTH];//[行][列] struct PosType end; //迷宫终点位置 MazeType m; //迷宫数组 int x,y; //迷宫行数，列数 void Print(int x,int y) { int i,j; for(i = 0;i<x;i++) { for(j=0;j<y;j++) printf("%3d",m[i][j]); printf("\n"); } printf("\n"); } void Try(struct PosType cur,int curstep) { int i;//由当前位置，当前步骤curstep试探下一点 struct PosType next;//下一个位置 struct PosType direc[4] = {{0,1},{1,0},{0,-1},{-1,0}};//{行增量}，{列增量} for(i=0;i<=3;i++) { next.x = cur.x + direc[i].x; next.y = cur.y + direc[i].y; if(m[next.x][next.y]==-1)//是通路 { m[next.x][next.y]=++curstep; if(next.x!=end.x || next.y!=end.y)//没到终点 Try(next,curstep);//试探下一点（递归调用） else Print(x,y);//输出结果 m[next.x][next.y]=-1;//恢复为通路，试探下一条路 curstep--; } } } void main() { struct PosType begin; int i,j,x1,y1; printf("请输入迷宫的行数，列数（包括外墙):"); scanf("%d,%d",&x,&y); for(i = 0;i<x;i++)//定义周边值为0（同墙) { m[0][i] = 0; //行周边 m[x-1][i] = 0; } for(j=1;j<y-1;j++) { m[j][0]=0;//列周边 m[j][y-1]=0; } for(i=1;i<x-1;i++) for(j=1;j<y-1;j++) m[i][j]=-1;//定义通道初值为-1 printf("请输入迷宫内墙单元数："); scanf("%d",&j); if(j) printf("请依次输入迷宫内墙每个单元的行数，列数：\n"); for(i=1;i<=j;i++) { scanf("%d,%d",&x1,&y1); m[x1][y1]=0; } printf("迷宫结构如下:\n"); Print(x,y); printf("请输入起点的行数，列数:"); scanf("%d,%d",&begin.x,&begin.y); printf("请输入终点的行数，列数"); scanf("%d,%d",&end.x,&end.y); m[begin.x][begin.y]=1; Try(begin,1); }