#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<stdio.h>/*
1 means it is blocked.
0 means it is available/ you can go.
E means the Exit point.
* means the start point.*/
typedef struct{
int x,y,last
}ST
char in[15][15]int vis[15][15]={0}
const int dx[]={0,0,1,-1},
dy[]={1,-1,0,0}
ST st[300]int fr,re
#define ok(_) ((_)>=0&&(_)<11)
#define canto(_,__) (ok(st[_].x+dx[__])&&ok(st[_].y+dy[__]))
#define V(_) (vis[st[_].x][st[_].y])
#define Vd(_,__) (vis[st[_].x+dx[__]][st[_].y+dy[__]])
#define Md(_,__) (in [st[_].x+dx[__]][st[_].y+dy[__]])
int go(int x,int y){
fr=0re=1
st[0].x=x
st[0].y=y
V(0)=1
int i
while(fr<re){
for(i=0i<4i++)
if(canto(fr,i)&&!Vd(fr,i)&&Md(fr,i)!='1'){
st[re].x=st[fr].x+dx[i]
st[re].y=st[fr].y+dy[i]
st[re].last=fr
Vd(fr,i)=1
if(Md(fr,i)=='E')return re
re++}
fr++
}
return 0
}
void solve(void){
int i,j,p=-1
for(i=0i<11i++)
for(j=0j<11j++)
if(in[i][j]=='*')
if(p==-1)p=go(i,j)
else {
printf("Too Many Start Point!")//这是废话，可删
return }
if(p==-1)printf("No Start Point!")//同上
else if(p==0)printf("Cant Go To End!")//同上
else {
for(i=0i<11i++)
printf("%s\n",in[i])//输出原迷宫
printf("\n")
while(st[p].last!=0){
p=st[p].last
if(p==0)break
in[st[p].x][st[p].y]='x'}//用x替换路径
for(i=0i<11i++)
printf("%s\n",in[i])//输出
}
return
}
int main(int ac,char **ar){
FILE *inp=NULL
int i
if(ac==1)return 0
inp=fopen(ar[1],"r")
if(inp==NULL)return 0
for(i=0i<11i++)
fscanf(inp,"%s",in[i])
solve()
return 0
}
/*BY TXJ*/
#include<stdio.h>#include<stdlib.h>
#include<time.h>
#define stack_init_size 200
#define stack_increment 10
#define OVERFLOW 0
#define OK 1
#define ERROE 0
#define TRUE 1
#define FALSE 0
typedef int Status
typedef struct{
int x
int y
}PosType
typedef struct {
int ord// 通道块在路径上的"序号"
PosType seat//通道块在迷宫中的"坐标位置"
int di //从此通道块走向下一通道块的"方向"
}SElemType
typedef struct{
SElemType *base
SElemType *top
int stacksize
}SqStack
int mg[20][20]
/*随机生成迷宫的函数
/*为了能够让尽量能通过，将能通过的块和不能通过的块数量比大致为2:1*/
void Random(){
int i,j,k
srand(time(NULL))
mg[1][0]=mg[1][1]=mg[18][19]=0//将入口、出口设置为"0"即可通过
for(j=0j<20j++)
mg[0][j]=mg[19][j]=1 /*设置迷宫外围"不可走"，保证只有一个出口和入口*/
for(i=2i<19i++)
mg[i][0]=mg[i-1][19]=1 /*设置迷宫外围"不可走"，保证只有一个出口和入口*/
for(i=1i<19i++)
for(j=1j<19j++){
k=rand()%3//随机生成0、1、2三个数
if(k)
mg[i][j]=0
else{
if((i==1&&j==1)||(i==18&&j==18)) /*因为距入口或出口一步的路是必经之路，故设该通道块为"0"加大迷宫能通行的概率*/
mg[i][j]=0
else
mg[i][j]=1
}
}
}
//构造一个空栈
Status InitStack(SqStack &s){
s.base =(SElemType *)malloc(stack_init_size * sizeof(SElemType))
if(!s.base) return OVERFLOW
s.top=s.base
s.stacksize=stack_init_size
return OK
}
//当前块可否通过
Status Pass(PosType e){
if (mg[e.x][e.y]==0) //0时可以通过
return OK // 如果当前位置是可以通过，返回1
return OVERFLOW// 其它情况返回0
}
//留下通过的足迹
Status FootPrint(PosType e){
mg[e.x][e.y]=7
return OK
}
//压入栈
Status Push(SqStack &s,SElemType e){
if(s.top-s.base>=s.stacksize){
s.base=(SElemType *)realloc(s.base,(s.stacksize+stack_increment) *sizeof(SElemType))
if(!s.base)exit(OVERFLOW)
s.top=s.base+s.stacksize
s.stacksize+=stack_increment
}
*s.top++=e
return OK
}
//出栈
Status Pop(SqStack &s,SElemType &e){
if(s.top==s.base)
return ERROE
e=*--s.top
return OK
}
//下一步
PosType NextPos(PosType &e,int dir){
PosType E
switch(dir){
case 1:E.x=e.x //向下
E.y=e.y+1
break
case 2:E.x=e.x+1//向右
E.y=e.y
break
case 3:E.x=e.x //向上
E.y=e.y-1
break
case 4:E.x=e.x-1//向左
E.y=e.y
break
}
return E
}
//是否空栈
Status StackEmpty(SqStack s){
if (s.top==s.base)
return OK
return OVERFLOW
}
//留下不能通过的足迹
Status MarkPrint(PosType e){
mg[e.x][e.y]=3
return OK
}
//迷宫函数
// 若迷宫maze中从入口 start到出口 end的通道，则求得一条存放在栈中
// （从栈底到栈顶），并返回TRUE；否则返回FALSE
Status MazePath(int mg,PosType start,PosType end,SqStack &s){
PosType curpos
InitStack(s)
SElemType e
int curstep
curpos=start// 设定"当前位置"为"入口位置"
curstep=1 // 探索第一步
do{
if(Pass(curpos)){ // 当前位置可通过，即是未曾走到过的通道块
FootPrint(curpos)// 留下足迹
e.di =1
e.ord = curstep
e.seat= curpos
Push(s,e)// 加入路径
if(curpos.x==end.x&&curpos.y==end.y){
printf("\n\n0∩_∩0 能到达终点!")
return TRUE
}
curpos=NextPos(curpos,1)// 下一位置是当前位置的东邻
curstep++ // 探索下一步
}
else{ // 当前位置不能通过
if(!StackEmpty(s)){
Pop(s,e)
while(e.di==4&&!StackEmpty(s)){
MarkPrint(e.seat)
Pop(s,e)
}
if(e.di<4){
e.di++
Push(s,e)// 留下不能通过的标记，并退回一步
curpos=NextPos(e.seat,e.di)/* 当前位置设为新方向的相邻块*/
}//if
}//if
}//else
}while(!StackEmpty(s))
printf("\n\n囧 ! 不能到达终点!")
return FALSE
}
//打印迷宫
void PrintMaze(){
int i,j
printf("运行路径:\n\n")
for(i=0i<20i++){
for(j=0j<20j++){
if(mg[i][j]==0)printf(" ")
else if(mg[i][j]==1) printf("■") //迷宫的"墙"
else if(mg[i][j]==3) printf("◇") //不通的路
else if(mg[i][j]==7)printf("○") //通过的路径
}
printf("\n")
}
printf("\n")
}
void main(){
SqStack S
PosType start,end
start.x=1start.y=0//起点坐标
end.x=18end.y=19//终点坐标
printf("\n==================迷宫游戏==================")
printf("\n说明:■不能走的区域\t◇走不通的区域")
printf("\n'空格'代表未到过的区域")
printf("\n ○代表能通过的路径，指向终点")
printf("\n============================================")
Random()
printf("\n\nTest 1:")
MazePath(mg[20][20],start,end,S)
PrintMaze()
system("pause")
Random()
printf("\nTest 2:")
MazePath(mg[20][20],start,end,S)
PrintMaze()
system("pause")
Random()
printf("\nTest 3:")
MazePath(mg[20][20],start,end,S)
PrintMaze()
printf("\n==========程序退出，感谢使用!==========\n")
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）