1. 用c语言编个走迷宫程序，要求：1：迷宫的规模和地图由程序随机自动生成。入口和出口由用户指定。
程序目的：
输入一个任意大小的迷宫，用栈求出一条走出迷宫的路径，并
显示在屏幕上。
程序实现：
可以实现载入迷宫和保存迷宫，附带文件中有4个测试迷宫路径的
文件test1~4.dd。请将这些文件拷贝到TC当前目录下，或者在载
入时写明完全路径。由于屏幕大小的限制，当用户自己输入迷宫
时一定要注意：迷宫大小是有限制的，不小于4*3,不大于30*20。
否则会出现错误信息。输入开始时全是墙，用上下左右键移动，
用Del键删除墙，形成通路，用Enter键添加墙。输入结束时可以
将迷宫保存下来，以dd为扩展名。输入完毕时用F9键来得到结果，
找到路径时，屏幕下方会出现Path found，否则出现Path not found。
程序经Turbo C 2.0编译调试成功。运行时不用添加任何运行库。
不可以在VC上编译。
下载DOS版和windows版的迷宫游戏全部代码
用户名：migong
----------------------------------------------------------------------------------
/**//*
MazePath Demo BY Turbo C 2.0
Copyright(c) RoverUnion. All right reserved.
Filename: Maze.c
Author Dongchengyu.
Ver 1.10
*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <conio.h>
#include <dos.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define F9 0x43
#define Esc 0x1b
#define Del 0x53
#define Home 0x47
#define End 0x4f
#define Space 0x20
#define Up 0x48
#define Down 0x50
#define Left 0x4b
#define Right 0x4d
#define Enter 0x0d
#define F2 0x3c
#define F3 0x3d
#define STACK_INIT_SIZE 200
#define STACKINCREMENT 10
typedef int Boolean;
typedef int Status;
typedef struct {
int x;
int y;
} PosType;
typedef struct {
int ord;
PosType seat;
int di;
} SElemType;
typedef struct {
int td;
int foot;
int mark;
} MazeType;
typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
} Stack;
int Maze[20][30];
MazeType maze[20][30];
PosType StartPlace;
PosType EndPlace;
int count;
int m,n;
Boolean b_start=FALSE,b_end=FALSE;
void CreatMaze(void);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
void Error(char *message);
Status InitStack(Stack *s);
Status DestroyStack(Stack *s);
Status ClearStack(Stack *s);
Boolean StackEmpty(Stack *s);
int StackLength(Stack *s);
Status Push(Stack *s,SElemType e);
SElemType Pop(Stack *s,SElemType e);
Status GetTop(Stack *s,SElemType *e);
Status StackTraverse(Stack *s,Status (* visit)(SElemType *se));
Boolean Pass(PosType curpos);
void MarkPrint(PosType seat);
void FootPrint(PosType curpos);
PosType NextPos(PosType seat,int di);
Status MazePath(PosType start,PosType end);
void CreatMaze(void)
/**//* Form the maze. */
{
void Error(char *message);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
int i,j;
int x,y;
char c;
char savename[12],loadname[12];
Boolean flag=FALSE,load=FALSE;
clrscr();
printf("Menu:\n\n");
printf("1.Load Mazefile:(*.dd)\n\n");
printf("2.Input Maze:\n\n");
printf("Input your choice: ");
do
{
c=getch();
switch(c)
{
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''); break;
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''); break;
case Esc: sleep(1); exit(1);
default: break;
}
}
while(c!=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''&&c!=''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''') ;
if(c==''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''')
{
printf("\n\nLoadName: ");
scanf("%s",loadname);
if(LoadMaze(loadname))
{
sleep(1); load=TRUE;
}
else { gotoxy(1,9); printf("Load fail! "); }
}
if(!load)
{
printf("\nInput the maze''''''''''''''''''''''''''''''''s size:\n");
printf("\nInput Length :\n");
scanf("%d",&m);
printf("\nInput Width :\n");
scanf("%d",&n);
if(m<4||n<4) Error("Input");
if(m>30||n>20) Error("Maze too large");
for(i=0;i<30;i++)
for(j=0;j<20;j++)
Maze[j][i]=2;
StartPlace.x=0;
StartPlace.y=0;
EndPlace.x=0;
EndPlace.y=0;
clrscr();
printf("\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf(" #");
Maze[i-1][j-1]=0;
}
printf("\n");
}
}
gotoxy(65,5);
printf("''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''':Wall");
gotoxy(65,7);
printf("Start:Home");
gotoxy(65,9);
printf("End:End");
gotoxy(65,11);
printf("Delete Wall:Del");
gotoxy(65,13);
printf("Enter Wall:Enter");
gotoxy(65,15);
printf("Save Maze:F2");
gotoxy(65,17);
printf("Complete:F9");
gotoxy(65,19);
printf("Exit:Esc");
gotoxy(4,3);
x=4;y=3;
do
{
c=getch();
switch(c)
{
case Up: if(y>3) { y--; gotoxy(x,y); }
break;
case Down: if(y<n) { y++; gotoxy(x,y); }
break;
case Left: if(x>4) { x-=2; gotoxy(x,y); }
break;
case Right: if(x<2*m-2) { x+=2; gotoxy(x,y); }
break;
case Del: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) b_start=FALSE;
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) b_end=FALSE;
putch('''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=1; gotoxy(x,y);
break;
case Enter: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) break;
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) break;
putch(''''''''''''''''''''''''''''''''#''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=0; gotoxy(x,y);
break;
case Home: if(Maze[y-2][x/2-1]&&!b_start)
{
StartPlace.x=x/2-1;
StartPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
gotoxy(x,y);
b_start=TRUE;
}
break;
case End: if(Maze[y-2][x/2-1]&&!b_end)
{
EndPlace.x=x/2-1;
EndPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
gotoxy(x,y);
b_end=TRUE;
}
break;
case Esc: gotoxy(2,22); printf("exit"); sleep(1); exit(1);
case F9: if(b_start&&b_end) flag=TRUE; break;
case F2: gotoxy(2,22);
printf("Savename:");
scanf("%s",savename);
gotoxy(2,22);
if(SaveMaze(savename)) printf("Save OK! ");
else printf("Save fail! ");
sleep(1);
gotoxy(2,22);
printf(" ");
gotoxy(x,y);
break;
default: break;
}
}
while(!flag);
for(i=0;i<30;i++)
for(j=0;j<20;j++)
{
maze[j][i].td=Maze[j][i];
maze[j][i].mark=0;
maze[j][i].foot=0;
}
}
Status LoadMaze(char *file)
/**//* The maze has been loaded. */
{
FILE *fp;
char *buffer;
char ch;
int i=0,j,k;
Boolean len=FALSE,wid=FALSE;
if((fp=fopen(file,"r"))==NULL)
return ERROR;
buffer=(char *)malloc(600*sizeof(char));
ch=fgetc(fp);
while(ch!=EOF)
{
buffer[i]=ch;
i++;
ch=fgetc(fp);
}
m=30;n=20;
for(i=0;i<600;i++)
{
j=i/30; k=i%30;
if(buffer[i]==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!len){ m=i; len=TRUE; }
if(k==0&&buffer[i]==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!wid){ n=j; wid=TRUE; }
switch(buffer[i])
{
case ''''''''''''''''''''''''''''''''0'''''''''''''''''''''''''''''''': Maze[j][k]=0; break;
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': Maze[j][k]=1; break;
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': Maze[j][k]=2; break;
case ''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''': Maze[j][k]=1;
StartPlace.x=k;
StartPlace.y=j;
b_start=TRUE;
break;
case ''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''': Maze[j][k]=1;
EndPlace.x=k;
EndPlace.y=j;
b_end=TRUE;
break;
default : break;
}
}
fclose(fp);
clrscr();
for(i=0;i<30;i++)
for(j=0;j<20;j++)
{
maze[j][i].td=Maze[j][i];
maze[j][i].foot=0;
maze[j][i].mark=0;
if(Maze[j][i]==0)
{
gotoxy(2*i+2,j+2);
putch(''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''');
}
}
gotoxy(2*StartPlace.x+2,StartPlace.y+2);
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
gotoxy(2*EndPlace.x+2,EndPlace.y+2);
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
return OK;
}
Status SaveMaze(char *filename)
/**//* The maze has been saved. */
{
FILE *fp;
char *buffer;
int i,j,k;
fp=fopen(filename,"wb");
buffer=(char *)malloc(600*sizeof(char));
for(i=0;i<600;i++)
{
j=i/30; k=i%30;
switch(Maze[j][k])
{
case 0: buffer[i]=''''''''''''''''''''''''''''''''0''''''''''''''''''''''''''''''''; break;
case 1: buffer[i]=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''; break;
case 2: buffer[i]=''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''; break;
default : Error("Write"); break;
}
if(k==StartPlace.x&&j==StartPlace.y) buffer[i]=''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''';
if(k==EndPlace.x&&j==EndPlace.y) buffer[i]=''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''';
}
fwrite(buffer,600,1,fp);
free(buffer);
fclose(fp);
return OK;
}
void Error(char *message)
{
clrscr();
fprintf(stderr,"Error:%s\n",message);
exit(1);
} /**//* Error */
Status InitStack(Stack *s)
/**//* The stack s has been created and is initialized to be empty. */
{
s->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!s->base) Error("Overflow");
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
return OK;
} /**//* InitStack */
Status DestroyStack(Stack *s)
/**//* The stack s has been destroyed. */
{
s->top=NULL;
s->stacksize=0;
free(s->base);
s->base=NULL;
return OK;
} /**//* DestroyStack */
Status ClearStack(Stack *s)
/**//* The stack has been clear to be maximum. */
{
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
return OK;
} /**//* ClearStack */
Boolean StackEmpty(Stack *s)
/**//* Check if the stack s is empty. */
{
if(s->top==s->base) return TRUE;
else return FALSE;
} /**//* StackEmpty */
int StackLength(Stack *s)
/**//* Gain the length of the stack s. */
{
if(s->top>s->base) return (int)(s->top-s->base);
else return 0;
} /**//* StackLength */
Status Push(Stack *s,SElemType e)
/**//* The element e has been pushed into the stack s. */
{
if(s->top-s->base>=s->stacksize)
{
s->base=(SElemType *)realloc(s->base,
(s->stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!s->base) Error("Overflow");
s->top=s->base+s->stacksize;
s->stacksize+=STACKINCREMENT;
}
*s->top++=e;
return OK;
} /**//* Push */
SElemType Pop(Stack *s,SElemType e)
/**//* The element e has been removed from the stack s. */
{
if(s->top==s->base) Error("Pop");
e=*--s->top;
return e;
} /**//* Pop */
Status GetTop(Stack *s,SElemType *e)
/**//* The element e has got to the top of the stack s.*/
{
if(s->top==s->base) Error("GetTop");
*e=*(s->top-1);
return OK;
} /**//* GetTop */
/**//* Traverse the stack s using ''''''''''''''''''''''''''''''''visiting'''''''''''''''''''''''''''''''' function. */
/**//* Status StackTraverse(Stack *s,Status (* visit)(SElemType *se))
{
SElemType p;
int result;
if(s->top==s->base) return ERROR;
p=s->base;
while(!(p==s->top))
{
result=(*visit)(p);
p++;
}
return OK;
} */
Boolean Pass(PosType curpos)
/**//* Check if the current position can be passed. */
{
if(maze[curpos.x][curpos.y].td==1&&
maze[curpos.x][curpos.y].foot==0&&maze[curpos.x][curpos.y].mark==0)
return TRUE;
else return FALSE;
} /**//* Pass */
void MarkPrint(PosType seat)
/**//* Mark the position seat. */
{
maze[seat.x][seat.y].mark=-1;
/**//* Marking ''''''''''''''''''''''''''''''''-1'''''''''''''''''''''''''''''''' symbolize the current position cannot be put. */
} /**//* MarkPrint */
void FootPrint(PosType curpos)
/**//* The foot of the curpos of the maze has been set ''''''''''''''''''''''''''''''''true''''''''''''''''''''''''''''''''. */
{
maze[curpos.x][curpos.y].foot=1;
} /**//* FootPrint */
PosType NextPos(PosType seat,int di)
{
switch(di)
{
case 1: seat.y++; return seat; /**//* Eastward */
case 2: seat.x++; return seat; /**//* Southward */
case 3: seat.y--; return seat; /**//* Westward */
case 4: seat.x--; return seat; /**//* Northward */
default: seat.x=0; seat.y=0; return seat;
}
} /**//* NextPos */
/**//* The key to the program. */
/**//* Pre: The maze array & the startplace & the endplace.
Post: Find the one traverse of the maze and perform the mazepath.
Uses: The ADT stack class.
*/
Status MazePath(PosType start,PosType end)
{
PosType curpos;
int curstep;
SElemType e;
Stack *s,stack;
stack.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!stack.base) Error("Overflow");
stack.top=stack.base;
stack.stacksize=STACK_INIT_SIZE;
s=&stack;
curpos=start;
curstep=1;
do
{
if(Pass(curpos))
{
FootPrint(curpos);
e.ord=curstep; e.seat=curpos; e.di=1;
gotoxy((curpos.y+1)*2,curpos.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /**//* pospone time. */
Push(s,e);
if(curpos.x==end.x&&curpos.y==end.y) /**//* Proceed recursively. */
{
DestroyStack(s);
return TRUE;
}
curpos=NextPos(curpos,1); /**//* Try next position. */
curstep++;
}
else
{
if(!StackEmpty(s))
{
e=Pop(s,e); /**//* Removed e from s. */
while(e.di==4&&!StackEmpty(s)) /**//* Four directions have been checked
and s is not empty. */
{
MarkPrint(e.seat);
gotoxy((e.seat.y+1)*2,e.seat.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /**//* Pospone time. */
gotoxy((e.seat.y+1)*2,e.seat.x+2);
putch('''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''');
e=Pop(s,e); /**//* Remove e from s. */
curstep--;
}
if(e.di<4) /**//* The current position hasnot been checked. */
{
e.di++;
Push(s,e); /**//* Insert e into s. */
curpos=NextPos(e.seat,e.di); /**//* Try next position. */
}
}
}
}
while(!StackEmpty(s));
DestroyStack(s);
return FALSE;
} /**//* MazePath */
void main()
{
PosType start,end;
CreatMaze();
start.x=StartPlace.y;
start.y=StartPlace.x;
end.x=EndPlace.y;
end.y=EndPlace.x;
if(MazePath(start,end))
{
gotoxy(2,22);
printf("Path found\n");
}
else
{
gotoxy(2,22);
printf("Path not found\n");
}
getch();
clrscr();
}
2. 用C++实现寻找迷宫里最短路线
你找 QQ为85141512 的QQ空间里有 ，那个是我的
我是公司的网，上不了QQ抱歉。
有什么疑问发到网络我的消息里
都是数据结构的问题
我找到了，贴过来:
#include<iostream.h>
#include <stdlib.h>
#include<iomanip.h>
#define STACK_INIT_SIZE 100 //初始栈大小
#define STACKINCREAMENT 10 //添加栈的长度
#define SIZE_OF_MAPH 20 //迷宫高度
#define SIZE_OF_MAPW 20 //迷宫长度
////////////////////////////////////////////////////////////////////////////////
// 结构体名称：MazeCell
// 功能：用来描述迷宫组成单元的信息
// 成员：Pass: 当Pass为1时，表示导通块；为0则表示障碍块；
// Footprint: 当 Footprint为1时，表示留下足迹，反之，表示未经此地。
////////////////////////////////////////////////////////////////////////////////
typedef struct
{
int Pass;
bool Footprint;
}MazeCell;
////////////////////////////////////////////////////////////////////////////////
// 结构体名称：SElemType
// 功能： 此为栈的元素，用来表示当前位置，（栈用来描述当前路径）
// 成员： ord: 通道块的序号
// x : 当前位置的横坐标
// y : 当前位置的纵坐标
// di : 搜索方向 1向东，2向南，3向西，4向北
////////////////////////////////////////////////////////////////////////////////
typedef struct
{
int ord;
int x;
int y;
int di;
}SElemType;
////////////////////////////////////////////////////////////////////////////////
// 结构体名称： SqTack
// 功能： 此为栈，用来记录当前路径
// 成员： *base 栈底指针，指向起点
// *top 栈顶指针，指向路径的末点
// stacksize 栈的容量
////////////////////////////////////////////////////////////////////////////////
typedef struct
{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;
////////////////////////////////////////////////////////////////////////////////
// 结构体名称： Seat
// 功能： 用来记录迷宫坐标，此结构体为中间变量，纯粹为方便编程而建立
// 成员： x: 用来记录横坐标
// y: 用来记录纵坐标
////////////////////////////////////////////////////////////////////////////////
typedef struct
{
int x;
int y;
}Seat;
////////////////////////////////////////////////////////////////////////////////
// 函数名称： InitStack
// 功能： 此函数用于初始化一个栈，即在类存中找一块大小为STACK_INIT_SIZE个栈
// 元素的空间,将其首址赋给栈底指针，此时栈顶指针与栈底指针重合。栈的容
// 量为 STACK_INIT_SIZE。操作成功则函数返回1，若类存空间不足，函数返回
// 0，表示初始化失败。
// 函数参数： SqStack &S
// 函数返回值类型： bool
////////////////////////////////////////////////////////////////////////////////
bool InitStack(SqStack &S)
{
S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)
{
return 0;
}
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// 函数名称： BuideMaze
// 功能： 此函数的功能是用于根据用户要求建立一个迷宫地图，将用户输入的整形数组
// 形状给迷宫数组
//
// 函数参数： MazeCell Map[SIZE_OF_MAP][SIZE_OF_MAP]
// Seat &start 起点坐标
// Seat &end 终点坐标
// 函数返回值类型： bool 建立成功则返回1，反之返回0。
////////////////////////////////////////////////////////////////////////////////
void BuideMaze(MazeCell Map[SIZE_OF_MAPH][SIZE_OF_MAPW],int ma[SIZE_OF_MAPH][SIZE_OF_MAPW])
{
for(int i=0;i<SIZE_OF_MAPH;i++)
{
for(int j=0;j<SIZE_OF_MAPW;j++)
{
Map[i][j].Pass=ma[i][j];
Map[i][j].Footprint=0;
}
}
}
////////////////////////////////////////////////////////////////////////////////
// 函数名称： Pass
// 功能： 此函数用于判断当前点是否可通，如果可通则返回1，反之返回0。
// 所谓可通是指当前位置为导通块并且当前位置没有留下脚印。
// 函数参数： Seat curpos 当前块的坐标
// MazeCell Map[SIZE_OF_MAP][SIZE_OF_MAP] 迷宫地图
// 函数返回值类型： bool 若当前块可通则返回1，反之则返回0。
////////////////////////////////////////////////////////////////////////////////
bool Pass(Seat curpos,MazeCell Map[SIZE_OF_MAPH][SIZE_OF_MAPW])
{
if(Map[curpos.x][curpos.y].Pass==0)
{
return 0;
}
else if(Map[curpos.x][curpos.y].Footprint==1)
{
return 0;
}
else
{
return 1;
}
}
////////////////////////////////////////////////////////////////////////////////
// 函数名称： FootPrint
// 功能： 此函数用于在当前路径下留下脚印。
// 函数参数： Seat curpos 当前坐标
// MazeCell Map[SIZE_OF_MAP][SIZE_OF_MAP] 迷宫地图
// 函数返回值类型： 无
////////////////////////////////////////////////////////////////////////////////
void FootPrint(Seat curpos,MazeCell Map[SIZE_OF_MAPH][SIZE_OF_MAPW])
{
Map[curpos.x][curpos.y].Footprint=1;
}
bool Push(SqStack &S,SElemType e)//栈插入函数
{
if(S.top-S.base>=S.stacksize)
{
S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREAMENT)*sizeof(SElemType));
if(!S.base)
{
return 0;
}
S.top=S.base+S.stacksize;
S.stacksize=S.stacksize+STACKINCREAMENT;
}
*S.top++=e;
return 1;
}
bool Pop(SqStack &S,SElemType &e)//栈取出最上面的元素，将值给e
{
if(S.base==S.top)return false;
S.top--;
e=*S.top;
return true;
}
////////////////////////////////////////////////////////////////////////////////
// 函数名称： NextPos
// 功能： 此函数用于将坐标为x,y位置的di方向位置切换为当前位置。
// 函数参数： Seat curpos 当前坐标
// int di 方向
// int x,y 坐标
// 函数返回值类型： 无
////////////////////////////////////////////////////////////////////////////////
void NextPos(int x,int y,Seat &curpos,int di)
{
if(di==1)
{
curpos.y=y+1;
curpos.x=x;
}
else if(di==2)
{
curpos.x=x+1;
curpos.y=y;
}
else if(di==3)
{
curpos.y=y-1;
curpos.x=x;
}
else if(di==4)
{
curpos.x=x-1;
curpos.y=y;
}
}
///////////////////////////////////////////////////////////////////////////
// 函数名称： PutIn
// 功能： 向数组里输入元素
// 函数参数： int map[] 将得到的数组给map
// int Wei 迷宫的长度
// int Hig 迷宫的高度
// 函数返回值类型： 无
///////////////////////////////////////////////////////////////////////////
void PutIn(int map[],int &Wei,int &Hig)
{
int w,h;
cout<<"如果您想输入的迷宫大于所规定的大小，您只需修改SIZE_OF_MAPH和SIZE_OF_MAP"<<endl;
cout<<"请输入迷宫的长度(长度小于等于"<<SIZE_OF_MAPW-2<<")：";
cin>>w;
cout<<"请输入迷宫的高度(高度小于等于"<<SIZE_OF_MAPW-2<<")：";
cin>>h;
cout<<"1表示导通块；0表示障碍块"<<endl;
Wei=w;
Hig=h;
for(int i=0;i<SIZE_OF_MAPH;i++)
for(int j=0;j<SIZE_OF_MAPW;j++)
*(map+i*SIZE_OF_MAPW+j)=0;
for(int is=1;is<h+1;is++)
{
cout<<"请输入第"<<is<<"行:";
for(int js=1;js<w+1;js++)
{
int point;
cin>>point;
*(map+is*SIZE_OF_MAPW+js)=point;
}
cout<<endl;
}
}
///////////////////////////////////////////////////////////////////////////
// 函数名称： Display
// 功能： 用于显示栈中所有元素
// 函数参数： 无
// 函数返回值类型： 无
///////////////////////////////////////////////////////////////////////////
void Display(SqStack S)
{
int i=1;
SElemType *p;
p=S.base;
cout<<"从base到top:"<<endl;
cout<<"di搜索方向:di=1向东，di=2向南，di=3向西，di=4向北"<<endl;
while(p!=S.top) //从base到top打印元素
{
cout<<"第"<<i<<"步: ";
cout<<"("<<(*p).y;
cout<<","<<(*p).x;
cout<<","<<(*p).di<<")"<<endl;
p++;
i++;
}
}
void DisplayMaze(int ma[SIZE_OF_MAPH][SIZE_OF_MAPW],int w,int h)
{
cout<<"迷宫为(1代表可以通过；0代表不可以通过): "<<endl;
for(int i=0;i<h+2;i++)
{
for(int j=0;j<w+2;j++)
{
cout<<ma[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
}
///////////////////////////////////////////////////////////////////////////
// 函数名称： MazePath
// 功能： 组织所有子函数，求解迷宫
// 函数参数： 无
// 函数返回值类型： int 迷宫有解则返回1，反之则返回0；
////////////////////////////////////////////////////////////////////////////
int MazePath(MazeCell Map[SIZE_OF_MAPH][SIZE_OF_MAPW],Seat start,Seat end)
{
SElemType e;
SqStack S; //定义一个栈
InitStack(S); //初始化栈
Seat curpos; //定义当前位置
int curstep; //计步器
curstep=1; //计步器计1
curpos.x=start.x; //
curpos.y=start.y; //当前位置设为起点
cout<<"起点是:"<<start.y<<" "<<start.x<<endl;
cout<<"终点是:"<<end.y<<" "<<end.x<<endl;
///////////////////////////////////////////////////////////////////////////
//
// 下面的循环是求解迷宫的核心程序
////////////////////////////////////////////////////////////////////////////
do
{
if(Pass(curpos,Map)) //如果当前块可通，则进行如下操作
{
FootPrint(curpos,Map); //留下脚印
e.ord=curstep; //记下计步器
e.x=curpos.x; //记下行数
e.y=curpos.y; //记下列数
e.di=1; //设一个方向为东方
Push(S,e); //压栈操作，将当前位置纳入当前路径
if(curpos.x==end.x&&curpos.y==end.y) //如果当前块为终点，进行如下操作
{ //
cout<<"ok!"; //
Display(S); //调用显示栈的子程序显示结果
return 1; //函数返回1
} //
else //如果当前位置不是终点，进行如下操作
{ //
NextPos(curpos.x,curpos.y,curpos,1); //切换东方向的位置为当前位置
curstep++; //计步器自增1
}
}//if
else
{
if(S.base!=S.top) //如果当前块不通，且栈不为空（说明还有解）
{
Pop(S,e); //将栈顶元素弹出进行观察
while(e.di==4&&(S.top-S.base)) //如果栈顶元素四方均不通
{
Pop(S,e); //弹出下一个栈顶元素进行观察
}//while
if(e.di<4) //如果栈顶元素还有其他方向没有走过
{ //
e.di++; //切换下一个方向为当前方向
Push(S,e); //压入栈
NextPos(e.x,e.y,curpos,e.di); //切换下一个方向位置为当前位置
}//if
}//if
}//else
}while(S.base!=S.top); //只要栈不空则说明有解，重复循环
cout<<"没找到路径"<<endl;
}
////////////////////////////////////////////////////////////////////////////////
// 函数名称： main
// 功能： 组织所有子函数，求解迷宫
// 函数参数： 无
// 函数返回值类型： bool 迷宫有解则返回1，反之则返回0；
//
////////////////////////////////////////////////////////////////////////////////
void main()
{
MazeCell Map[SIZE_OF_MAPH][SIZE_OF_MAPW]; //定义一个迷宫数组
/*int migong[SIZE_OF_MAPH][SIZE_OF_MAPW]= {
{ 0,0,0,0,0,0,0,0,0,0},
{ 0,1,1,0,0,0,0,0,0,0}, //1
{ 0,0,1,1,1,0,1,1,1,0}, //2
{ 0,0,1,0,1,1,1,0,1,0}, //3
{ 0,0,1,0,0,0,0,0,1,0}, //4
{ 0,0,1,0,1,1,1,0,0,0}, //5
{ 0,0,1,1,1,0,1,1,1,0}, //6
{ 0,0,0,0,0,0,0,0,0,0},
}; //以数组表示的迷宫*/
int w,h;
int migong[SIZE_OF_MAPH][SIZE_OF_MAPW];
PutIn(migong[0],w,h);
BuideMaze(Map,migong); //调用建立迷宫的子函数
DisplayMaze(migong,w,h); //显示迷宫的形状
Seat start,end; //定义当前位置，起点位置，终点位置的结构体
/*start.x=1; //起点
start.y=1; //
end.x=2; //终点
end.y=2; //*/
cout<<"起点横坐标:";
cin>>start.y;
cout<<"起点纵坐标:";
cin>>start.x;
cout<<"终点横坐标:";
cin>>end.y;
cout<<"终点纵坐标:";
cin>>end.x;
MazePath(Map,start,end);
}
程序大部分分成函数了，你只要把函数的功能弄清楚了，就差不多了
祝你成功！我当时弄了3天才写出来的
3. 求个c++源码 走迷宫 程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓
输入地图时：1代表不可通行，0代表可通行，自动增加边框（墙壁），且左上角左边一格为入口，右下角右边一格为出口
编译通过，代码如下：
#include<stdio.h>
#include<stdlib.h>
#defineN50
int**maze;
introw;
intcol;
intstack[50];//存放路径的栈
voidCreateMaze()//用于动态创建迷宫
{
inti,j;
printf("请输入迷宫的行数：");
scanf("%d",&row);
printf("请输入迷宫的列数：");
scanf("%d",&col);
if(row<=0||col<=0)
{
printf("输入的行数或列数不符合规则！ ");
exit(1);
}
//利用指针的指针动态创建二维数组
maze=(int**)malloc((row+2)*sizeof(int*));
for(i=0;i<row+2;i++)
{
maze[i]=(int*)malloc((col+2)*sizeof(int));
}
//加边墙
for(i=0;i<row+2;i++)
{
maze[i][0]=1;
maze[i][col+1]=1;
}
for(i=0;i<col+2;i++)
{
if(i==1)
{
maze[0][i]=0;
}
elsemaze[0][i]=1;
if(i==col)
{
maze[row+1][col]=0;
}
elsemaze[row+1][i]=1;
}
for(i=1;i<=row;i++)
{
for(j=1;j<=col;j++)
{
printf("请输入第%d行的第%d个数: ",i,j);
scanf("%d",&maze[i][j]);
}
}
//输入下一个当前加边墙的迷宫，以验证输入是否正确
printf("输入完毕！当前加边墙的迷宫为： ");
for(i=0;i<row+2;i++)
{
for(j=0;j<col+2;j++)
{
printf("%d ",maze[i][j]);
}
printf(" ");
}
}
voidShowMaze()//输出迷宫
{
inti,j;
for(i=1;i<=row;i++)
{
for(j=1;j<=col;j++)
{
printf("%d ",maze[i][j]);
}
printf(" ");
}
}
//释放迷宫数组
voidDestroyMaze()
{
inti;
for(i=0;i<row+2;i++)
free(maze[i]);
free(maze);
}
//用DFS方法来实现回溯，找到迷宫的一条解路径
intFindPath()
{
inti,j,k,count,x,y,direction;
count=0;
x=1,y=1;
direction=0;
j=0,k=0;
for(i=0;i<N;i++)
{
stack[i]=0;
}
i=0;
while(1)
{
count=0;//用count判断是否有路可走
{
if(x==1&&y==1)
maze[x][y]=2;
if(maze[x][y+1]==0)//东
{
count++;
maze[x][y+1]=2;
y=y+1;
stack[i]=-1;
i++;
if(x==row&&y==col)
return1;
}
elseif(maze[x+1][y]==0)//南
{
if(maze[x+1][y]==0)
count++;
{
maze[x+1][y]=2;
x=x+1;
stack[i]=-2;
i++;
if(x==row&&y==col)
return1;
}
}
elseif(maze[x][y-1]==0)//西
{
count++;
if(maze[x][y-1]==0)
{
maze[x][y-1]=2;
y=y-1;
stack[i]=-3;
i++;
if(x==row&&y==col)
return1;
}
}
elseif(maze[x-1][y]==0)//北
{
count++;
if(maze[x-1][y]==0)
{
maze[x-1][y]=2;
x=x-1;
stack[i]=-4;
i++;
if(x==row&&y==col)
return1;
}
}
}
if(count==0)
{
if(i<0)
return0;
direction=stack[i--];
switch(direction)
{
case-1:y=y-1;break;
case-2:x=x-1;break;
case-3:y=y+1;break;
case-4:x=x+1;break;
default:break;
}
}
}
}
intmain()
{
CreateMaze();
if(FindPath())
{
printf("已经找到了一条路径，如下: ");
ShowMaze();
}
else
{
printf("没有合适的路径走出当前迷宫！ ");
}
DestroyMaze();
}
4. 用C语言编写一个迷宫程序 很急很急 （1）利用上下左右方向键控制光标在屏幕上一个20*20的区域内移动，通过
在不在，可以帮你临时写代码，就是怎么发送给你？还有保存DC中的位图到文件 要用到savebitmaptofile,它的头文件找不到，所以一般我制作位图时，显示到屏幕上，然后截屏保存的。（其实截屏就只要两个函数就可以完成了的）至于显示到屏幕上，就得到所有地图文件后才能做到了。
5. c语言编写迷宫游戏如何调用多个迷宫地图，是调用文件吗，怎么调用了
如果要方便更改的话，我觉得可以用txt
如果要不让别人更改的话，可以在程序中定义好
txt可以用fopen,fscanf,fclose等函数，具体用法可以看网络
6. 求个迷宫游戏源代码，要带解释的，希望带上如何执行，怎样用java来实现
你有个100分的悬赏我会考虑下。。。
而且你说的这个，真的不会太难。。。
7. 怎么制作迷宫图
方案一：主路扭曲型
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、最后，给地图加上出口和入口，地图就做完啦！
总结一下，这种方案比前两种多了小型地块，这一点比较适合设计玩家的阶段性反馈。同时地图的分岔路明显减少，玩家在这种方案下的选择次数会明显降低。另外，由于这个方案的步骤相对多且独立，所以对于设计者来讲会比较容易控制地图的结构。
8. 求助用C或者C++语言实现一个迷宫小游戏代码
#include<bits/stdc++.h>
#include<windows.h>
#include<conio.h>
using namespace std;
int main()
{
int i123;
cout<<" ."<<endl;
cout<<" . ."<<endl;
cout<<" . . ."<<endl;
cout<<" . ."<<endl;
cout<<" ."<<endl;
cout<<" T M";
for(i123=500;i123<=1000;i123+=100){
Beep(i123,1000);
}
system("cls");
char a[50][50]={"##############################",
"#o # ## # ### ####",
"# ###### # # # # # ### ####",
"# # ## # # #### # ### ##",
"# # ## ### # # ## ####",
"##### # # ##### ## ####",
"# # ##### # # # # # #",
"# # # ## # #### ## # # ####",
"# # # ## ## # # ####",
"# # # ####### ## ###### # ##",
"# # ## # ## ###### ### #",
"# ###### # ##### # # #",
"# # # ##### ### # ",
"# ######## ##### # ### ### # #",
"# # ## ##### ### ###",
"##### # ## # ######## # #",
"# # ## ## ### # #",
"# # ### ###### ####### #",
"# # ### ## # #",
"##############################"
};
int i,i1,x=1,y=1,n=12,m=29;
char ch;
for(i=0;i<=19;i++){
puts(a[i]);
}
while(x!=n||y!=m){
ch=getch();
if(ch==115||ch==25){
if(a[x+1][y]!=35){
a[x][y]=32;
x++;
a[x][y]=111;
}
}
if(ch==119||ch==24){
if(a[x-1][y]!=35){
a[x][y]=32;
x--;
a[x][y]=111;
}
}
if(ch==97||ch==27){
if(a[x][y-1]!=35){
a[x][y]=32;
y--;
a[x][y]=111;
}
}
if(ch==100||ch==26){
if(a[x][y+1]!=35){
a[x][y]=32;
y++;
a[x][y]=111;
}
}
system("cls");
for(i=0;i<=19;i++){
puts(a[i]);
}
}
for(i1=500;i1<=1000;i1=i1+100){
Beep(i1,1000);
}
cout<<endl<<"你赢了！！！祝贺你！！！";
system("pause");
}
