...编写,用栈来实现,因为是数据结构课程设计所以只要现成代码,越快越好...
发布网友
发布时间：2024-10-16 17:17
共3个回答
热心网友
时间：2024-10-16 17:21
#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=0;i<rows*cols;i++)
{
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++的 这是结果
这是源代码
热心网友
时间：2024-10-16 17:18
#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=0;i<4;i++)
{
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=0;i<4;i++) //沿四个方向设置
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=0;i<=Height+1;i++)
for(j=0;j<=Width+1;j++)
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=0;i<=Height+1;i++) //边界处理 把最开始默认为路的堵上,以免跑出迷宫
{
map[i][0]=Wall;
map[i][Width+1]=Wall;
}
for(j=0;j<=Width+1;j++) //边界处理
{
map[0][j]=Wall;
map[Height+1][j]=Wall;
}
map[2][1]=Start; //给定入口
map[Height-1][Width]=End; //给定出口
for(i=1;i<=Height;i++) //i初始为1,结束为height,以免画出外围
for(j=1;j<=Width;j++) //画出迷宫 同上
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
对不起，本人能力有限，希望大家能支持
热心网友
时间：2024-10-16 17:19
编译的代码如下：
＃包括
＃包括
＃N 50
数组的迷宫;
诠释行;
整数关口;
int的堆栈[50] ;/ /堆栈
无效CreateMaze存储路径（）/ /动态创建的迷宫
{
INT I，J;
printf的（“请输入的迷宫的行数：”）; <BR / scanf函数（“％d”，＆行）;
printf的（“请输入迷宫的列数：”）;
scanf的（“％d”，＆COL）
（行<= 0 | | COL <= 0）
{
printf的（“请输入行或列的数量是不符合规则的！ \ n“）;
出口（1）;
}
/ /动态地创建一个二维数组的指针的指针
迷宫=（INT *）malloc的（（2行）*表示sizeof（int *））;
为（i = 0;我行+2，我+ +）
{
迷宫[ ] =（*）malloc的（（山坳+2）*表示sizeof（int））;
}
/ /添加侧壁
（i = 0;我行+2;我+ +）
{
迷宫[I] [0] = 1;
迷宫[I] [COL +1] = 1;
} <BR / （i = 0; <山坳+2;我+ +）
{
（== 1）
{
迷宫[0] [] = 0;
}
其他迷宫[0] [I] = 1;
（== COL）
{
迷宫[行+1] [COL ] = 0;
}
其他迷宫行+1]在[i] = 1;
}
（i = 1; <=行; + +）
{
为（J = 1; <=山坳; + +）
{
printf（“请输入第％d行％d号：\ n“，I，J）;
scanf的（”％d“，＆迷宫[I] [J]）;
}
} BR />
/ /输入电流和侧壁的迷宫，以验证输入的是正确
printf的（“请输入完毕！电流和侧壁的迷宫：\ n”）; />（i = 0;我行+2，我+ +）
{
为（J = 0，J <山坳+2; J + +）
{ />输出（“％d”，迷宫[I] [J]）;
}
printf的（“\ n”）;
}
}
BR />的无效ShowMaze（）/ /输出迷宫
{
INT I，J;
（i = 1; <=行，我+ +）
{ BR />（J = 1; <=山坳; + +）
{
printf的（“％d”，迷宫[I] [J]）;
}
printf（“请\ n”）;
}
}
/ /释放的迷宫阵列
无效DestroyMaze（）
{
>;
为（i = 0;我行+2，我+ +）
（迷宫[I]）;
免费（迷宫）;
}
/ /的DFS方法来实现回溯找到迷宫路径的解决方案
FindPath（）
{
INT I，J，K ，计数，X，Y，方向;
计数= 0;
X = 1，Y = 1;
方向= 0;
J = 0，K表= 0;
为（i = 0; <N; + +）
{
堆栈[I] = 0;
}
i = 0;
（1）
{
计数= 0 ;/ /计算，以确定是否有很长的路要走
{
（X =
迷宫= 1 && Y == 1）[X] [Y] = 2;
（迷宫[X] [Y +1] == 0）/ /东
{
计数+ +;
迷宫[X] [Y +1] = 2;
Y = Y +1;
栈[我] = -1;
i + +;
（X =行&& Y == COL）
返回1;
}
其他（迷宫[+1] [Y] == 0）/ /南
{
（迷宫[+1] [Y] == 0）
计数+ +;
{
迷宫[X + 1] [Y] = 2;
X = X +1;
栈[I] = -2;
我+ +;
（X =行&&? == COL）返回1
}
}
其他（迷宫[X] [Y-1] == 0）/ /西
{ BR />数+ +;
（迷宫[X] [Y-1] == 0）
{
迷宫[X] [Y-1] = 2;
> Y = Y-1;
栈[I] = -3;
+ +;
（X =行&& Y == COL）
返回1;
}
}
其他（迷宫[-1] [Y] == 0）/ /北
{
数+ +;
如果（迷宫〔x-1] [Y] == 0）
{
迷宫〔x-1] [] = 2;
= x-1的;
栈[我] = -4;
+ +;
（X =行&& Y == COL）返回1
}
} BR />}
（数== 0）
{
（<0）
返回0;
方向=堆栈[ - ]; BR />开关（方向）
{
情况下，-1：Y = Y-1;突破;
情况下，-2：X = X-1;突破;
情况下 - 3：Y = Y +1;突破;
情况下-4：X = X +1;突破;
默认值：打破;
}
}
} BR />}
廉政的main（）
{
CreateMaze（）;
（FindPath（））
{ BR /> printf的（“已找到了一条路径，如下所示：\ n”）;
ShowMaze（）;
}
其他
{
printf的（“不在正确的道路上走出迷宫！\ n“）;
}}
DestroyMaze（）;
//没啥区别 把printf改成cout scanf改成cin
