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");
}
