#include <iostream>
#include <conio.h>
#include <windows.h>
#include <time.h>
using namespace std
#define Height 25//高度，必须为奇数
#define Width 25 //宽度，必须为奇数
#define Wall 1//用1表示墙
#define Road 0//用0表示路
#define Start 2
#define End 3
#define up 72
#define down 80
#define left 75
#define right 78
#define flag 5
int map[Height+2][Width+2]
int x=2,y=1//玩家当前位置，刚开液埋缺始在入口处
class Migong
{
public:
void gotoxy(int x,int y) //移动坐标的函数声明
void shengcheng(int x,int y) //随机生成迷宫的函数声明
void display(int x,int y) //显示迷宫的函数声明
void chushi()//初始化迷宫的函数声液碰明
}
class Wanjia:public Migong //玩家类由迷宫类派生来
{
public:
void gonglue(int x,int y)
void shang(int x,int y)
void xia(int x,int y)
void zuo(int x,int y)
void you(int x,int y)
void game()//游戏运行包括移动的函数声明
}
void Migong::gotoxy(int x,int y) //移动坐标 这是使光标 到（x，y）这个位置的闹辩函数.调用 COORD 需要#include.
{
COORD coord
coord.X=x
coord.Y=y
SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord )
}
void Migong::shengcheng(int x,int y) //随机生成迷宫
{
int c[4][2]={0,1,1,0,0,-1,-1,0}//四个方向//数组c 0 1 向右
// 1 0 向下
// -1 0 向上
// 0 -1 向左
int i,j,t
//将方向打乱
for(i=0i<4i++)
{
j=rand()%4 //随机生成j
t=c[i][0]c[i][0]=c[j][0]c[j][0]=t //将c[i][0]和c[j][0]交换
t=c[i][1]c[i][1]=c[j][1]c[j][1]=t //类似上
}
map[x][y]=Road //当前位置设为路
for(i=0i<4i++) //沿四个方向设置
if(map[x+2*c[i][0]][y+2*c[i][1]]==Wall)//沿c[i][0]、c[i][1]方向前2步如果是墙
{
map[x+c[i][0]][y+c[i][1]]=Road //让该方向前一步设为路
shengcheng(x+2*c[i][0],y+2*c[i][1]) //在该方向前两步继续生成地图因为这里是递归函数，当执行到最后一点发现都不能走的时候，
//会返回到上一个函数，也就是上一个点，再次判断是否可以产生地图 ，知道地图上所有点被遍历完。
}
}
void Migong::display(int x,int y) //显示迷宫
{
gotoxy(2*y-2,x-1)
switch(map[x][y])
{
case Start:
cout<<"入"break//显示入口
case End:
cout<<"出"break//显示出口
case Wall:
cout<<"■"break//显示墙
case Road:
cout<<" "break//显示路
case up:
cout<<"↑"break //在攻略中的标记 下同
case down:
cout<<"↓"break
case left:
cout<<"←"break
case right:
cout<<"→"break
case flag:
cout<<" "break //标记，防止攻略遍历时候无线循环
}
}
void Migong::chushi()
{
int i,j
srand((unsigned)time(NULL))//初始化随机种子
for(i=0i<=Height+1i++)
for(j=0j<=Width+1j++)
if(i==0||i==Height+1||j==0||j==Width+1) //初始化迷宫 默认四周是路
map[i][j]=Road
else map[i][j]=Wall
shengcheng(2*(rand()%(Height/2)+1),2*(rand()%(Width/2)+1))//从随机一个点开始生成迷宫，该点行列都为偶数
for(i=0i<=Height+1i++) //边界处理 把最开始默认为路的堵上,以免跑出迷宫
{
map[i][0]=Wall
map[i][Width+1]=Wall
}
for(j=0j<=Width+1j++) //边界处理
{
map[0][j]=Wall
map[Height+1][j]=Wall
}
map[2][1]=Start//给定入口
map[Height-1][Width]=End//给定出口
for(i=1i<=Heighti++)//i初始为1,结束为height,以免画出外围
for(j=1j<=Widthj++) //画出迷宫 同上
display(i,j)
}
void Wanjia::game()
{
int x=2,y=1//玩家当前位置，刚开始在入口处
int c//用来接收按键
while(1)
{
gotoxy(2*y-2,x-1)
cout<<"☆"//画出玩家当前位置
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(30,24) //到达此坐标
cout<<"到达终点，按任意键结束"
getch()
break
c=getch()
}
if(c!=-32)
{
c=getch()
switch(c)
{
case 72: //向上走
if(map[x-1][y]!=Wall)
{
display(x,y)
x--
}
break
case 80: //向下走
if(map[x+1][y]!=Wall)
{
display(x,y)
x++
}
break
case 75: //向左走
if(map[x][y-1]!=Wall)
{
display(x,y)
y--
}
break
case 77: //向右走
if(map[x][y+1]!=Wall)
{
display(x,y)
y++
}
break
case 112://按下P
gonglue(2,1)break //如果按下P执行攻略函数
}
}
}
}
void Wanjia::shang(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20) //到达此坐标
cout<<"到达终点，按任意键结束"
getch()
exit(0)
}
if(map[x-1][y]!=Wall&&map[x-1][y]!=up&&map[x-1][y]!=down&&map[x-1][y]!=left&&map[x-1][y]!=right&&map[x-1][y]!=flag)
{ //当移动后的下一个位置没有被走过且不是墙
map[x][y]=up
display(x,y)
x--
gonglue(x,y) //递归，攻略下一个点
}
}
void Wanjia::xia(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20) //到达此坐标
cout<<"到达终点，按任意键结束"
getch()
exit(0)
}
if(map[x+1][y]!=Wall&&map[x+1][y]!=up&&map[x+1][y]!=down&&map[x+1][y]!=left&&map[x+1][y]!=right&&map[x+1][y]!=flag) //当移动后的下一个位置没有被走过且不是墙
{
map[x][y]=down
display(x,y)
x++
gonglue(x,y) //递归，攻略下一个点
}
}
void Wanjia::zuo(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20) //到达此坐标
cout<<"到达终点，按任意键结束"
getch()
exit(0)
}
if(map[x][y-1]!=Wall&&map[x][y-1]!=up&&map[x][y-1]!=down&&map[x][y-1]!=left&&map[x][y-1]!=right&&map[x][y-1]!=flag) //当移动后的下一个位置没有被走过且不是墙
{
map[x][y]=left
display(x,y)
y--
gonglue(x,y)//递归，攻略下一个点
}
}
void Wanjia::you(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20) //到达此坐标
cout<<"到达终点，按任意键结束"
getch()
exit(0)
}
if(map[x][y+1]!=Wall&&map[x][y+1]!=up&&map[x][y+1]!=down&&map[x][y+1]!=left&&map[x][y+1]!=right&&map[x][y+1]!=flag) //当移动后的下一个位置没有被走过且不是墙
{
map[x][y]=right
display(x,y)
y++
gonglue(x,y)//递归，攻略下一个点
}
}
void Wanjia::gonglue (int x,int y)
{
gotoxy(2*y-2,x-1)
cout<<"☆"//画出玩家当前位置
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20) //到达此坐标
cout<<"到达终点，按任意键结束"
getch()
exit(0)
}
shang(x,y)//上下左右
xia(x,y)
zuo(x,y)
you(x,y)
map[x][y]=flag//当上下左右都无法走的时候，即为死路，因为递归函数开始向后，所以讲死路点值置为flag，变成无形之墙。
display(x,y)
}
int main()
{
cout<<" 移动迷宫 "<<endl
cout<<"--------------------"<<endl
cout<<"欢迎来到移动迷宫游戏"<<endl
cout<<"--------------------"<<endl
cout<<"游戏说明：给定一出口和入口"<<endl
cout<<"玩家控制一个五角星（☆）从入口走到出口"<<endl
cout<<"系统会记录你所走的步数"<<endl
cout<<"按回车进入游戏"
cout<<"(按下P键可以获得攻略。)"
getch()
system("cls") //清屏函数 ，清除开始界面
Wanjia w1
w1.chushi()
w1.game()//开始游戏
//w1.gonglue(2,1) //功略显示
getch()
return 0
}
————————————————
版权声明：本文为CSDN博主「失落之风」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41572774/java/article/details/84035598
喜欢的源码拿走，把小赞赞留下
#include "stdafx.h"
#include <stack>
using namespace std
const int rows = 8,cols = 8
HINSTANCE hInst
HBITMAP ball
HDC hdc,mdc,bufdc
HWND hWnd
DWORD tPre,tNow
char *str
int nowPos,prePos
bool find
stack<int>path
int mapIndex[rows*cols] = { 0,2,0,0,0,0,0,0, //材1
0,1,0,1,1,1,1,0, //材2
0,1,0,1,0,1,1,0, //材3
0,1,0,0,0,1,1,0, //材4
0,1,1,1,1,1,1,0, //材5
0,1,0,0,0,0,1,0, //材6
0,0,1,1,1,1,1,0, //材7
0,0,0,0,0,0,3,0 }//材8
int record[rows*cols]
ATOM MyRegisterClass(HINSTANCE hInstance)
BOOL InitInstance(HINSTANCE, int)
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM)
void MyPaint(HDC hdc)
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
渣或 LPSTR lpCmdLine,
如磨伍 游吵int nCmdShow)
{
MSG msg
MyRegisterClass(hInstance)
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE
}
while( msg.message!=WM_QUIT )
{
if( PeekMessage( &msg, NULL, 0,0 ,PM_REMOVE) )
{
TranslateMessage( &msg )
DispatchMessage( &msg )
}
else
{
tNow = GetTickCount()
if(tNow-tPre >= 100)
MyPaint(hdc)
}
}
return msg.wParam
}
//****注册窗口*************************
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX wcex
wcex.cbSize = sizeof(WNDCLASSEX)
wcex.style = CS_HREDRAW | CS_VREDRAW
wcex.lpfnWndProc = (WNDPROC)WndProc
wcex.cbClsExtra = 0
wcex.cbWndExtra = 0
wcex.hInstance = hInstance
wcex.hIcon = NULL
wcex.hCursor = NULL
wcex.hCursor = LoadCursor(NULL, IDC_ARROW)
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1)
wcex.lpszMenuName = NULL
wcex.lpszClassName = "canvas"
wcex.hIconSm = NULL
return RegisterClassEx(&wcex)
}
//****初始化*************************************
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HBITMAP bmp
hInst = hInstance
hWnd = CreateWindow("canvas", "迷宫" , WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL)
if (!hWnd)
{
return FALSE
}
MoveWindow(hWnd,10,10,430,450,true)
ShowWindow(hWnd, nCmdShow)
UpdateWindow(hWnd)
hdc = GetDC(hWnd)
mdc = CreateCompatibleDC(hdc)
bufdc = CreateCompatibleDC(hdc)
bmp = CreateCompatibleBitmap(hdc,cols*50,rows*50)
SelectObject(mdc,bmp)
HBITMAP tile
int rowNum,colNum
int i,x,y
tile = (HBITMAP)LoadImage(NULL,"tile.bmp",IMAGE_BITMAP,50,50,LR_LOADFROMFILE)
ball = (HBITMAP)LoadImage(NULL,"ball.bmp",IMAGE_BITMAP,50,50,LR_LOADFROMFILE)
for (i=0i<rows*colsi++)
{
record[i] = mapIndex[i]
rowNum = i / cols
colNum = i % cols
x = colNum * 50
y = rowNum * 50
SelectObject(bufdc,tile)
if(!mapIndex[i])
BitBlt(mdc,x,y,50,50,bufdc,0,0,SRCCOPY)
else
{
if(mapIndex[i] == 2)
{
nowPos = i
path.push(i)
record[i] = 0
}
BitBlt(mdc,x,y,50,50,bufdc,0,0,WHITENESS)
}
}
prePos = cols * rows + 1
MyPaint(hdc)
return TRUE
}
//****核心代码*********************************
void MyPaint(HDC hdc)
{
int rowNum,colNum
int x,y
int up,down,left,right
rowNum = prePos / cols
colNum = prePos % cols
x = colNum * 50
y = rowNum * 50
SelectObject(bufdc,ball)
BitBlt(mdc,x,y,50,50,bufdc,0,0, WHITENESS)
rowNum = nowPos / cols
colNum = nowPos % cols
x = colNum * 50
y = rowNum * 50
SelectObject(bufdc,ball)
BitBlt(mdc,x,y,50,50,bufdc,0,0, SRCCOPY)
if(!find)
{
str = "迷宫入口"
up = nowPos - cols
down = nowPos + cols
left = nowPos - 1
right = nowPos + 1
if(up>=0 &&record[up])
{
path.push(up)
record[up] = 0
prePos = nowPos
nowPos = up
if(mapIndex[nowPos] == 3)
find = true
}
else if(down<=cols*rows-1 &&record[down])
{
path.push(down)
record[down] = 0
prePos = nowPos
nowPos = down
if(mapIndex[nowPos] == 3)
find = true
}
else if(left>=rowNum*cols &&record[left])
{
path.push(left)
record[left] = 0
prePos = nowPos
nowPos = left
if(mapIndex[nowPos] == 3)
find = true
}
else if(right<=(rowNum+1)*cols-1 &&record[right])
{
path.push(right)
record[right] = 0
prePos = nowPos
nowPos = right
if(mapIndex[nowPos] == 3)
find = true
}
else
{
if(path.size() <= 1) //
str = "xxxxx"
else
{
path.pop()
prePos = nowPos
nowPos = path.top()
}
}
}
else
{
str = "找到出口"
}
TextOut(mdc,0,0,str,strlen(str))
BitBlt(hdc,10,10,cols*50,rows*50,mdc,0,0,SRCCOPY)
tPre = GetTickCount()
}
//****消息函数***********************************
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_KEYDOWN:
if(wParam==VK_ESCAPE)
PostQuitMessage(0)
break
case WM_DESTROY:
DeleteDC(mdc)
DeleteDC(bufdc)
DeleteObject(ball)
ReleaseDC(hWnd,hdc)
PostQuitMessage(0)
break
default:
return DefWindowProc(hWnd, message, wParam, lParam)
}
return 0
}
// 可以运行 请采纳
有不懂的可以联系我
这个可是标准c++的 这是结果
这是源代码
这里给你提供2个程序1.用栈实现迷宫问题求解
2.老鼠走迷宫程序实例
1.用栈实现迷宫问题求解
源程序：
//base.h
#include
#include
#include
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status
//stack.h
#include "base.h"
#define INIT_SIZE 100 //存储空间初始分配量
#define INCREMENT 10 //存储空间念袭分配增量
typedef struct{ //迷宫中r行c列的位置
int r
int c
}PostType
typedef struct{
int ord //当前位置在路径上的序号
PostType seat//当前坐标
int di //往下一坐标的方向
}SElemType //栈元素类型
typedef struct{
SElemType* base//栈基址,构造前销毁后为空
SElemType* top//栈顶
int stackSize //栈容量
}Stack//栈类型
Status InitStack(Stack &S){ //构造空栈s
S.base=(SElemType*)malloc(INIT_SIZE *sizeof(SElemType))
if(!S.base)
exit(OVERFLOW)//存储分配失败
S.top=S.base
S.stackSize=INIT_SIZE
return OK
}//InitStack
Status StackEmpty(Stack S){
//若s为空返回TRUE,否则返回FALSE
if(S.top==S.base)
return TRUE
return FALSE
}//StackEmpty
Status Push(Stack &S,SElemType e){
//插入元素e为新的栈顶元素
if(S.top-S.base >=S.stackSize){//栈满，加空间
S.base=(SElemType *)realloc(S.base,(S.stackSize+INCREMENT)*sizeof(SElemType))
if(!S.base)
exit(OVERFLOW) //存储分配失败
S.top=S.base+S.stackSize
S.stackSize+=INCREMENT
}
*S.top++=e
return OK
}/敬明/push
Status Pop(Stack &S,SElemType &e){//若栈不空删除栈//顶元素用e返回并返回OK，否则返回ERROR
if(S.top==S.base)
return ERROR
e=*--S.top
return OK
}//Pop
Status DestroyStack(Stack &S){//销毁栈S,
free(S.base)
S.top=S.base
return OK
}//DestroyStack
//maze.cpp
#include "stack.h"
#define MAXLEN 10//迷宫包括外墙仔稿兄最大行列数目
typedef struct{
int r
int c
char adr[MAXLEN][MAXLEN]//可取’ ’’*’ ’@’ ’#’
}MazeType //迷宫类型
Status InitMaze(MazeType &maze){
//初始化迷宫若成功返回TRUE,否则返回FALSE
int m,n,i,j
printf("Enter row and column numbers: ")
scanf("%d%d",&maze.r,&maze.c)//迷宫行和列数
for(i=0i<=maze.c+1i++){//迷宫行外墙
maze.adr[0][i]=’#’
maze.adr[maze.r+1][i]=’#’
}//for
for(i=0i<=maze.r+1i++){//迷宫列外墙
maze.adr[i][0]=’#’
maze.adr[i][maze.c+1]=’#’
}
for(i=1i<=maze.ri++)
for(j=1j<=maze.cj++)
maze.adr[i][j]=’ ’//初始化迷宫
printf("Enter block’s coordinate((-1,-1) to end): ")
scanf("%d%d",&m,&n)//接收障碍的坐标
while(m!=-1){
if(m>maze.r || n>maze.c)//越界
exit(ERROR)
maze.adr[m][n]=’#’//迷宫障碍用’#’标记
printf("Enter block’s coordinate((-1,-1) to end): ")
scanf("%d%d",&m,&n)
}//while
return OK
}//InitMaze
Status Pass(MazeType maze,PostType curpos){
//当前位置可通则返回TURE,否则返回FALSE
if(maze.adr[curpos.r][curpos.c]==’ ’)//可通
return TRUE
else
return FALSE
}//Pass
Status FootPrint(MazeType &maze,PostType curpos){
//若走过并且可通返回TRUE,否则返回FALSE
//在返回之前销毁栈S
maze.adr[curpos.r][curpos.c]=’*’//"*"表示可通
return OK
}//FootPrint
PostType NextPos(PostType &curpos,int i){
//指示并返回下一位置的坐标
PostType cpos
cpos=curpos
switch(i){//1.2.3.4分别表示东,南,西,北方向
case 1 : cpos.c+=1break
case 2 : cpos.r+=1break
case 3 : cpos.c-=1break
case 4 : cpos.r-=1break
default: exit(ERROR)
}
return cpos
}//Nextpos
Status MarkPrint(MazeType &maze,PostType curpos){
//曾走过但不是通路标记并返回OK
maze.adr[curpos.r][curpos.c]=’@’//"@"表示曾走过但不通
return OK
}//MarkPrint
Status MazePath(MazeType &maze,PostType start,PostType end){
//若迷宫maze存在从入口start到end的通道则求得一条存放在栈中
//并返回TRUE,否则返回FALSE
Stack S
PostType curpos
int curstep//当前序号,1.2.3.4分别表示东,南,西,北方向
SElemType e
InitStack(S)
curpos=start//设置"当前位置"为"入口位置"
curstep=1 //探索第一步
do{
if(Pass(maze,curpos)){//当前位置可以通过,
//即是未曾走到过的通道
FootPrint(maze,curpos)//留下足迹
e.ord=curstep
e.seat=curpos
e.di=1
Push(S,e) //加入路径
if(curpos.r==end.r&&curpos.c==end.c)
if(!DestroyStack(S))//销毁失败
exit(OVERFLOW)
else
return TRUE//到达出口
else{
curpos=NextPos(curpos,1)
//下一位置是当前位置的东邻
curstep++ //探索下一步
}//else
}//if
else{//当前位置不通
if(!StackEmpty(S)){
Pop(S,e)
while(e.di==4
&&!StackEmpty(S)){
MarkPrint(maze,e.seat)
Pop(S,e)
//留下不能通过的标记,并退一步
}//while
if(e.di <4){
e.di++//换下一个方向探索
Push(S,e)
curpos=NextPos(e.seat,e.di)//设定当前位置是该
//新方向上的相邻
}//if
}//if
}//else
}while(!StackEmpty(S))
if(!DestroyStack(S))//销毁失败
exit(OVERFLOW)
else
return FALSE
}//MazePath
void PrintMaze(MazeType &maze){
//将标记路径信息的迷宫输出到终端(包括外墙)
int i,j
printf("\nShow maze path(*---pathway):\n\n")
printf(" ")
for(i=0i<=maze.r+1i++)//打印列数名
printf("%4d",i)
printf("\n\n")
for(i=0i<=maze.r+1i++){
printf("%2d",i)//打印行名
for(j=0j<=maze.c+1j++)
printf("%4c",maze.adr[i][j])//输出迷宫//当前位置的标记
printf("\n\n")
}
}//PrintMaze
void main(){ //主函数
MazeType maze
PostType start,end
char cmd
do{
printf("-------FOUND A MAZEPATH--------\n")
if(!InitMaze(maze)){ //初始化并创建迷宫
printf("\nInitialization errors!!!\n")
exit(OVERFLOW)//初始化错误
}
do{ //输入迷宫入口坐标
printf("\nEnter entrance coordinate of the maze: ")
scanf("%d%d",&start.r,&start.c)
if(start.r>maze.r || start.c>maze.c){
printf("\nBeyond the maze!!!\n")
continue
}
}while(start.r>maze.r || start.c>maze.c)
do{ //输入迷宫出口坐标
printf("\nEnter exit coordinate of the maze: ")
scanf("%d%d",&end.r,&end.c)
if(end.r>maze.r || end.c>maze.c){
printf("\nBeyond the maze!!!\n")
continue
}
}while(end.r>maze.r || end.c>maze.c)
if(!MazePath(maze,start,end))//迷宫求解
printf("\nNo path from entrance to exit!\n")
else
PrintMaze(maze)//打印路径
printf("\nContinue?(y/n): ")
scanf("%s",&cmd)
}while(cmd==’y’ || cmd==’Y’)
}//main
2.老鼠走迷宫程序实例
#include "stdafx.h"
#include "iostream.h"
#include "string.h"
#include "stdio.h"
double dMeans=0,dWalkLen=10000//dMeans表示走出迷宫的方法，dWalkLen表示当前走出迷宫最少步数
char Maze[10][52]={
{"###################################################"},
{"% ## #### ### ### # ####"},
{"# ## # ### ### ###### ### ############ # ##"},
{"# ## ## ### ## ## # # ## # # ####"},
{"# ## ## ## ### # # ######### # # # ##"},
{"# # # # ## ########## #### ## ##"},
{"# ## ### ## ## ### #### ##### # ######### #"},
{"# # # ## ## # ## #### # # ######"},
{"#### ## ########## # ### ####@"},
{"###################################################"},
} //迷宫
int MazeFlag[10][51] //迷宫的标志：0表示未走过，i(i=1,2,3,4)表示已经走过了,i表示方向。
int MazeMin[10][51] //路径最小的迷宫的标志
void Walk(int nx,int ny)//走迷宫的函数，nx是列，ny是行
void PrintOut()//打印路径及迷宫的函数，同时比较获取路径较短的行走方法
int Judge(int nx,int ny,int i)//判断在第nx列ny行向第i个方向走是否可以,可以返回1否则返回0。
//i=1表示向右，2表示向下，3表示向左，4表示向上
/*---------------------------------------------------------------------------------------------
//行走迷宫函数： void Walk (int nx,int ny)
//功能：判断是否已经走出迷宫，如果走出则打印路径，如果没有则开始逐个方向判断是否可以行走，
// 如果都不能行走，或已经返回。则退出该位置，即将该位置的标志写为0表明未走过。
//无返回值，形参nx为当前位置的列，ny为当前位置的行。
---------------------------------------------------------------------------------------------*/
void Walk(int nx,int ny)
{
if (Maze[nx][ny]=='@')//判断是否走出迷宫，@是迷宫出口标志
PrintOut() //走出则打印出迷宫及行走路径
else //未走出迷宫
{
for (int i=1i<=4i++)//四个方向逐个行走，i=1向右 2向下 3向左 4向上
{
if (Judge(nx,ny,i)) //如果列为nx行为ny的位置向i方向是否可以行走
{
MazeFlag[nx][ny]=i//将标志位置i表明该位置向i方向可行走
if (i==1) //分散处理，根据不同的i来确定下一步的位置，以便行走。
Walk(nx,ny+1)
else if (i==2)
Walk(nx+1,ny)
else if (i==3)
Walk(nx,ny-1)
else if (i==4)
Walk(nx-1,ny)
}
}
MazeFlag[nx][ny]=0//如果4个方向都走不通，或者回朔则清空该点标志位，置为0表明未走过。
}
}
/*---------------------------------------------------------------------------------------------
//打印函数：void PrintOut()
//功能：打印第dMeans种方法的在迷宫中的行走路径,以及通过比较找出目前行走步数最少的行走方法。
//无返回值，无形参。dMeans表示当前行走方法的种类。dCount是用来计算此种方法用了多少步。
---------------------------------------------------------------------------------------------*/
void PrintOut()
{
int nx,ny
double dCount=0
dMeans++
cout<<"The "<<dMeans<<" ways is: "<<endl
for (nx=0nx<10nx++)
{
for (ny=0ny<51ny++)
{
if (Maze[nx][ny]=='#')//＃表示墙
cout<<"#"
else if (MazeFlag[nx][ny]==0)//不是墙但未走过的地方用空格表示
cout<<" "
else //不是墙且走过的地方用*表示
{
cout<<"."
dCount++ //走一步总步数加1
}
}
cout<<endl
}
cout<<"This way used "<<dCount<<" steps"<<endl
if (dCount<dWalkLen)//如果此种方法的步数比以前方法中最少步数还要少，
{ //则将此种方法列为当前最少行走步数
for (nx=0nx<10nx++)
for(ny=0ny<51ny++)
MazeMin[nx][ny]=MazeFlag[nx][ny]
dWalkLen=dCount
}
}
/*--------------------------------------------------------------------------------------------
//判断函数：int Judge(int nx,int ny,int i)
//功能：判断当前位置(nx为列ny为行)向第i方向行走是否可以
//返回值int型 返回1表明可以，0表示不可以
--------------------------------------------------------------------------------------------*/
int Judge(int nx,int ny,int i)
{
if (i==1)//判断向右可否行走
{
if (ny<50&&(Maze[nx][ny+1]==' '||Maze[nx][ny+1]=='@')&&MazeFlag[nx][ny+1]==0)
return 1
else
return 0
}
else if (i==2)//判断向下可否行走
{
if (nx<9&&(Maze[nx+1][ny]==' '||Maze[nx+1][ny]=='@')&&MazeFlag[nx+1][ny]==0)
return 1
else
return 0
}
else if (i==3)//判断向左可否行走
{
if (ny>0&&(Maze[nx][ny-1]==' '||Maze[nx][ny-1]=='@')&&MazeFlag[nx][ny-1]==0)
return 1
else
return 0
}
else if (i==4)//判断向上可否行走
{
if (nx>0&&(Maze[nx-1][ny]==' '||Maze[nx-1][ny]=='@')&&MazeFlag[nx-1][ny]==0)
return 1
else
return 0
}
else
return 0
}
int main(int argc, char* argv[])
{
int nx,ny,ni,nj
cout<<"迷宫游戏: "<<endl
for (ni=0ni<10ni++)//输出迷宫形状，并且找到迷宫的入口，同时将迷宫标志初始化
{
for(nj=0nj<51nj++)
{
cout<<Maze[ni][nj]
MazeFlag[ni][nj]=0//将迷宫标志初始化为0表示未走过
if (Maze[ni][nj]=='%')
{
nx=ni//迷宫入口列坐标
ny=nj//迷宫入口行坐标
}
}
cout<<endl
}
cout<<endl<<"入口坐标:"<<endl<<"nx= "<<nx<<" "<<"ny= "<<ny<<endl
Walk(nx,ny)//调用行走迷宫函数，从入口处开始行走
cout<<endl<<"The MinLen way is: "<<endl
for (nx=0nx<10nx++)//输出最短路径
{
for (ny=0ny<51ny++)
{
if (Maze[nx][ny]=='#')
cout<<"#"
else if (MazeMin[nx][ny]==0)
cout<<" "
else
{
cout<<"."
}
}
cout<<endl
}
cout<<"This Way used "<<dWalkLen<<" steps"<<endl//输出最短路径总行走步数
return 0
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）