数据结构迷宫破解

最新推荐文章于 2023-12-19 09:13:10 发布
最新推荐文章于 2023-12-19 09:13:10 发布
阅读量4k 收藏 2
点赞数
分类专栏： C++程序 文章标签： 数据结构 破解 struct iostream 算法 winapi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/karldoenitz/article/details/8070163
版权 
MazePath.h的代码：
#include "selemtype.h"
#include "sqstack.h"
//#include "linkstack.h"
//迷宫大小
#define N 15
#define M 22
//分割块占总空间比例
#define V 0.4
typedef struct ElemType
{
	int x,y;
	char c;
}ElemType;
typedef struct MazeType
{
	ElemType arr[N][M];	
}MazeType;

Status Pass(MazeType &MyMaze, PosType CurPos);
void FootPrint(MazeType &MyMaze, PosType CurPos);
void MarkPrint(MazeType &MyMaze, PosType CurPos);
PosType NextPos(PosType CurPos, int Dir);

Status MazePath(MazeType &maze, PosType start, PosType end);
sqstack.h的代码：
#include "selemtype.h"
#include "sqstack.h"
//#include "linkstack.h"
//迷宫大小
#define N 15
#define M 22
//分割块占总空间比例
#define V 0.4
typedef struct ElemType
{
	int x,y;
	char c;
}ElemType;
typedef struct MazeType
{
	ElemType arr[N][M];	
}MazeType;

Status Pass(MazeType &MyMaze, PosType CurPos);
void FootPrint(MazeType &MyMaze, PosType CurPos);
void MarkPrint(MazeType &MyMaze, PosType CurPos);
PosType NextPos(PosType CurPos, int Dir);

Status MazePath(MazeType &maze, PosType start, PosType end);

selemtype.h的代码：
#pragma once
#define Status bool
#define TRUE true
#define FALSE false
struct PosType 
{
	int r,c;             //行列 or xy
};

typedef struct
{
	int ord;            //通道块在路径上的序号
	PosType seat;       //通道块在迷宫中的坐标位置
	int di;             //从此通道块走向下一通道块的方向
}SElemType;
extern bool drawflag;   //全局变量外部声明

linkstack.h的源代码：

#include "selemtype.h"
#define MaxSize 1000
typedef struct StackNode
{
	SElemType data;
	struct StackNode *next;
}*Stack;

Status InitStack(Stack &S);
Status DestroyStack(Stack &S);
Status StackEmpty(Stack &S);
Status Push(Stack &S,SElemType &e);
Status Pop(Stack &S,SElemType &e);


sqstack.cpp的源代码：
#include "sqstack.h"

Status InitStack(Stack &S)
{	
	 S.top = 0 ;  
    for( int i = 0 ; i < MaxSize ; i++ )  
    {  
        S.data[i].di = 0 ;  
        S.data[i].ord = 0 ;   
        S.data[i].seat.c = 0;  
        S.data[i].seat.r = 0;  
    }  
    return true;  
};
Status DestroyStack(Stack &S)
{
	S.top = 0 ;  
    return true; 
}
Status StackEmpty(Stack &S)
{ 
    if(S.top == 0)  
        return true;
	else 
		return false;
}
Status Push(Stack &S,SElemType &e)
{  
    if(S.top < MaxSize)  
    {  
          
        S.data[S.top] = e ;  
        S.top++;  
       return true ;  
    } 
	else
       return false;  
}
Status Pop(Stack &S,SElemType &e)
{
    if(S.top > 0)  
    {  
        S.top--;  
        e = S.data[S.top] ;  
        return true ;   
          
    } 
	else
        return false;  
}

linkstack.cpp的源代码：
#include <iostream>
using namespace std;
#include "linkstack.h"

Status InitStack(Stack &S)
{
	return true;
}
Status DestroyStack(Stack &S)
{
	return true;
}
Status StackEmpty(Stack &S)
{
	return true;
}
Status Push(Stack &S,SElemType &e)
{
	return true;
}
Status Pop(Stack &S,SElemType &e)
{
	return true;
}

MazePath.cpp的源代码：

/*------------------------------------------------
    走迷宫算法v1.0
N            迷宫行数
M            迷宫列数
V            分割块占总空间比例
ElemType     迷宫元素类型
MazeType     迷宫类型

函数MazePath   走迷宫算法
函数Pass       判断当前位置是否可通过
函数FootPrint  留下足迹
函数MarkPrint  留下不能再走的标记
函数NextPos    计算下一位置
-------------------------------------------------*/
#include "MazePath.h"
Status MazePath(MazeType &maze, PosType start, PosType End)
{
	// 算法3.3
	// 若迷宫maze中从入口 start到出口 end的通道，则求得一条存放在栈中
	// （从栈底到栈顶），并返回TRUE；否则返回FALSE	
	Stack stack;   //定义一个栈  
    InitStack(stack);  //初始化该栈  
    int count = 0 ;   //用来记录通道块的序号  
    PosType nextPos = start,curPos = start;  
    SElemType e,pe;  
    pe.di = 0;  
    int di = 0 ;  
    bool judger = true ;  
    bool uu = true;  
    while(true)  
    {  
          
        for(int i = 1 ; i <= 4 ; i++ )  
        {  
                nextPos = NextPos(curPos,i);  
                if(Pass(maze,nextPos))  
                {  
  
                    count++;  
                    e.seat = curPos ;  
                    e.ord = count;  
                    e.di = i ;  
                    FootPrint(maze,curPos);  
                    Push(stack, e);  
                    curPos = nextPos ;  
                    judger = true ;  
                    if(curPos.c==End.c&&curPos.r==End.r)  
                    {  
                        count++;  
                        e.seat = curPos ;  
                        e.ord = count;  
                        e.di = i ;  
                        FootPrint(maze,curPos);  
                        Push(stack, e);  
                        return true ;  
                    }  
                    break;  
                }  
            if(i == 4)  
            {  
                if(judger)  //走投无路时将最后一个通道块压入栈  
                {  
  
                    count++;  
                    e.seat = curPos ;  
                    e.ord = count;  
                    e.di = i ;  
                    FootPrint(maze,curPos);  
                    Push(stack, e);   
                    judger = false;  
                    if(curPos.c==End.c&&curPos.r==End.r)  
                        return true ;  
                }  
                Pop(stack , pe);   //出栈  
                curPos = pe.seat ;  
                MarkPrint(maze , pe.seat);    //标记为走过且不可走  
                if(stack.top == 0)  
                    return false;  
                break;  
            }  
              
        }  
    }  
  
  
	return TRUE;
} // MazePath

Status Pass( MazeType &MyMaze,PosType CurPos) 
{
	if (MyMaze.arr[CurPos.r][CurPos.c].c==' ')
		return 1;     // 如果当前位置是可以通过，返回1
	else return 0;  // 其它情况返回0
}

void FootPrint(MazeType &MyMaze,PosType CurPos) 
{
	//循环是判断全局线程互斥变量的值，等待走步，
	//值为false，迷宫走步，并重新设为true，交给
	//主线程绘制，子线程等待
	while(drawflag)
		;
	drawflag=true;
	MyMaze.arr[CurPos.r][CurPos.c].c='*';
	
}

void MarkPrint(MazeType &MyMaze,PosType CurPos) 
{
	//循环是判断全局线程互斥变量的值，等待走步，
	//值为false，迷宫走步，并重新设为true，交给
	//主线程绘制，子线程等待
	while(drawflag)
		;
	drawflag=true;
	MyMaze.arr[CurPos.r][CurPos.c].c='!';
}

PosType NextPos(PosType CurPos, int Dir) 
{
	PosType ReturnPos; 
	switch (Dir) 
	{
    case 1:
        ReturnPos.r=CurPos.r;
        ReturnPos.c=CurPos.c+1;
        break;
    case 2:
        ReturnPos.r=CurPos.r+1;
        ReturnPos.c=CurPos.c;
        break;
    case 3:
        ReturnPos.r=CurPos.r;
        ReturnPos.c=CurPos.c-1;
        break;
    case 4:
        ReturnPos.r=CurPos.r-1;
        ReturnPos.c=CurPos.c;
        break;
	}
	return ReturnPos;
}


main.cpp的源代码：
#include <iostream>  
using namespace std;  
#include "graphics.h"  
#include <time.h>  
#include "mazepath.h"  
/*------------------------------------------------ 
    走迷宫游戏v1.0 
屏幕大小：   640*480 
Width        每个小方块宽度 
Space        每个小方块间隔 
Step         每块占据象素 
 
drawflag     线程互斥全局变量，为true画图， 
             为false走迷宫 
threadflag   判断线程是否结束的全局变量，为false 
             线程结束，程序结束 
maze;        迷宫全局对象 
start,end    迷宫起终点全局变量 
 
 
函数InitMaze        初始化迷宫 
函数RandmMaze       随机生成迷宫 
函数DrawMaze        绘制迷宫 
函数ThreadMazePath  子线程函数，调用走迷宫函数修 
                    改迷宫对象数据 
    算法设计思想 
数据结构：     迷宫每个元素由位置坐标x,y和是否可走 
               的状态c构成，x、y代表画块的左上角坐 
               标，c为#是障碍，为空格是空位，为！ 
               是已走过且不能再走，为*是走过且还有 
               选择； 
基本操作：     栈的初始化、销毁、入栈、出栈等; 
绘制迷宫操作： 在主线程中绘制，根据元素值c选择不同 
               颜色绘制，根据元素值x、y，确定绘制 
               位置； 
走迷宫操作：   在子线程中计算迷宫对象走动的每一步， 
               修改迷宫对象的值，但不绘制迷宫，通 
               过修改互斥变量drawflag的值，在两个 
               线程中交替进行绘制和走步。                 
-------------------------------------------------*/  
#define Width 24  
#define Space 2  
#define Step  (Width + Space)  
  
bool drawflag=true;  
MazeType maze;  
PosType start,End;  
bool threadflag=true;  
  
void InitMaze(MazeType &maze)  
{  
    //初始化迷宫,将二维数组的每个元素计算出屏幕坐标  
    int i,j;  
    for(i=0;i<N;i++)  
        for(j=0;j<M;j++)  
        {  
            maze.arr[i][j].x=30+j*Step;  
            maze.arr[i][j].y=30+i*Step;  
        }  
}  
void RandmMaze(MazeType &maze,PosType start,PosType end)  
{  
    //随机生成迷宫，在二维数组内除起终点外其余位置随  
    //机生成障碍，障碍数量按比例V计算  
    int i,j,k,num;  
    //边界和空位初始化  
    for(i=0;i<N;i++)  
    {  
        maze.arr[i][0].c='#';  
        maze.arr[i][M-1].c='#';       
  
        if(i!=0&&i!=N-1)  
        {  
            for(j=1;j<M-1;j++)  
            {  
                maze.arr[i][j].c=' ';  
            }  
        }  
    }  
    for(i=1;i<M-1;i++)  
    {  
        maze.arr[0][i].c='#';  
        maze.arr[N-1][i].c='#';  
    }  
  
    //按分割块占总空间比例随机生成迷宫  
    num=(N-2)*(M-2)*V;   //计算需要的分割块数量  
  
    maze.arr[start.r][start.c].c='#'; //为了随机生成分割块不占用起始和终止位置  
    maze.arr[end.r][end.c].c='#';  
  
    k=num;   
    while(k>1)  
    {  
        i=rand()%(N-2)+1;j=rand()%(M-2)+1;  
        if(maze.arr[i][j].c==' ')  
            maze.arr[i][j].c='#';  
        k--;  
    }  
    maze.arr[start.r][start.c].c=' ';  
    maze.arr[end.r][end.c].c=' ';     
  
}  
void DrawMaze(MazeType &maze)  
{  
    //绘制迷宫，按不同状态绘制不同颜色方块  
    int i,j;  
          
    for(i=0;i<N;i++)  
    {  
        for(j=0;j<M;j++)  
        {  
            switch(maze.arr[i][j].c)  
            {  
            case '#':   //障碍块  
                setfillstyle(SOLID_FILL,LIGHTBLUE);  
                break;  
            case '!':   //已走过且无路可走的块  
                setfillstyle(SOLID_FILL,LIGHTRED);  
                break;  
            case '*':   //走过的块  
                setfillstyle(SOLID_FILL,LIGHTGREEN);  
                break;  
            case ' ':   //空闲块  
                setfillstyle(SOLID_FILL,BLACK);  
                break;  
            }  
            bar(maze.arr[i][j].x,maze.arr[i][j].y,maze.arr[i][j].x+Width,maze.arr[i][j].y+Width);  
        }  
        //cout<<endl;  
    }  
  
}  
  
DWORD WINAPI ThreadMazePath(LPVOID plParameter)  
{  
    //子线程函数，调用走迷宫函数修改迷宫对象数据  
    //迷宫无解再生成新迷宫，直到有解  
    int k=1;  
    srand(time(0));  
    RandmMaze(maze,start,End); //随机生成迷宫  
  
    while(!MazePath(maze,start,End))  
    {         
        cout<<"第"<<k<<"个迷宫无解！"<<endl;  
          
        getchar();  
        InitMaze(maze);  
        RandmMaze(maze,start,End);k++;        
    }  
    cout<<"第"<<k<<"个迷宫有解！"<<endl;  
      
    setfillstyle(SOLID_FILL,BLACK);  
    bar(100,450,500,480);  
    setcolor(YELLOW);  
    SetFont(16,16,0,0,0,FALSE,FALSE,FALSE,"宋体"); //文字设为宋体  
    outtextxy(100,450,"此迷宫有通路!");  
  
    threadflag=false;  //线程结束标记  
    return 0;  
}  
void main()  
{  
    //初始化图形界面  
    initgraph(640,480);  
    //清屏  
    cleardevice();  
  
    //默认全局变量为true  
    drawflag=true;     
    threadflag=true;  
  
      
    InitMaze(maze);     //初始化迷宫对象  
      
    start.r=start.c=1;  //初始化起终点  
    End.r=N-2;End.c=M-2;  
  
    //创建走迷宫数据计算子线程  
    HANDLE hThread1=CreateThread(NULL,  
        0,ThreadMazePath,NULL,0,NULL);  
  
    while(threadflag)   //子线程未结束  
    {  
        Sleep(100);  
        if(drawflag)     //线程互斥变量为真，画图，否则等待迷宫走完一步  
        {  
            DrawMaze(maze);   
            drawflag=false;  //画完一步，置为假，迷宫数据计算子线程走下一步  
        }  
    }  
  
    //结束前任意键暂停  
    getchar();  
    //关闭图形界面  
    closegraph();  
  
}


KarlDoenitz
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构：迷宫
mxc111213_的博客
01-22 2322
迷宫问题。假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为（1，1），出口坐标为（m，n），试设计并验证以下算法：找出一条从入口通往出口的路径，或报告一个“无法通过”的信息。 (1) 用C语言实现顺序存储结构上队列的基本操作，然后利用该队列的基本操作找出迷宫的一条最短路径。 (2) 设计一个二维数组MAZE[m+2][n+2]表示迷宫，数组元素为0表示该位置可以通过，数组元素为1表示该位置不可以通行。MAZE[1][1]、MAZE[m][n]分别为迷宫的入口和出口。 (3) 输入迷宫的大小m行和n列
C语言实现数据结构迷宫实验
01-01
本文实例为大家分享了C语言实现简单的数据结构迷宫实验，供大家参考，具体内容如下 分析：迷宫实验主要有两部分操作，其一是对迷宫的生成，其二是寻路使用栈的操作。 步骤： 一、.h文件 1、首先是迷宫的生成，可以...
数据结构例题--迷宫
chihiro1122的博客
11-09 4150
迷宫oj题的思路代码实现
数据结构——迷宫问题
weixin_45823684的博客
01-13 9941
一.题意说明 求迷宫问题（见实验4-17）的所有路径。分别使用栈、队列、递归算法等实现（至少三种方法）。要求迷宫地图大小可自定义，障碍物可随机生成。 题意分析：用二维数组定义迷宫大小，确定迷宫方向。迷宫通路为1，不通为0，随机分配0和1，构造迷宫。分别用栈、队列、递归方法求解迷宫路径。采用链表存储迷宫内数据。 二.算法设计与分析 首先确定迷宫的大小，用二维数组构造迷宫，并且规定方向0—3代表上下左右。Path方法存放路径。随机使用0和1填充迷宫，0为不可通过点，1为可通过点。记录好起点和终点。1.栈
数据结构：栈与队列之迷宫（详解）
study_jiang_up的博客
11-18 3622
迷宫对于数据结构的萌新来说，是比较困难的。所以需要多理解栈和队列的思想，在看这个之前，可以先做做栈和队列其他题目，比如转进制转化等问题，再回来写迷宫问题会更好理解。
数据结构-迷宫
m0_62999250的博客
03-29 209
规定：方向的一致性，按照:东南西北四个方向来选择路径。
数据结构 迷宫算法
12-20
用栈来求解迷宫的数据结构实验。求解迷宫的代码来自书上，迷宫只能在源代码上修改。
数据结构实验迷宫问题实验报告
11-18
数据结构实验迷宫问题实验报告
迷宫_数据结构迷宫问题实验_
10-02
C语言数据结构迷宫问题思路：首先，迷宫如何用计算机语言表示？一般用二维数组。0表示墙，1表示路。其次，其次就是如何从迷宫中走出来了。结合堆栈，进行搜索。你可以尝试着对问题进行分层，然后逐步细化来解决。...
数据结构课设：迷宫问题（c语言版）
qq_45804132的博客
05-07 1万+
迷宫求解问题 题目描述 用一个m×n的矩阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对给定的迷宫，求出找到的第一条从入口到出口的通路，或得到没有通路的结论。 我们指定: 迷宫的入口为矩阵的左上角（1,1），迷宫的出口为右下角（m,n）; 路径的探索顺序依次为"东南西北"（即：右下左上）。 输入 第一行输入两个整数，空格间隔，分别表示矩阵的行数m和列数n； 接下来的连续m...
迷宫数据结构
04-13
里面有详细的描述。按照严惠敏书上里的算法写的。<br>不懂的人都能看懂这个算法。
数据结构--迷宫问题
qq_52496013的博客
04-13 4032
项目场景： 以一个MxN的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，判断有无通路。如果有通路，求出一条从入口到出口的通路 问题描述 在输出栈s中所有迷宫路径时会出现输出将终点坐标输出为起点坐标 void print_Path(Seqstack* s) //输出栈中所有迷宫路线 { int i = 0; printf("迷宫路线为：\n"); for (i=0; i <s->top; i++) { p...
【数据结构】迷宫问题实现(包含界面)
ybny0421的博客
02-28 2187
数据结构 迷宫实现
数据结构(7)—栈的应用之迷宫求解
热门推荐
小白的专栏
02-21 1万+
参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社 本文中的代码可从这里下载：https://github.com/qingyujean/data-structure 1.问题描述： 采用“穷举求解”方法，从入口出发，顺某一方向向前探索，若能走通，则继续往前走；否则沿原路返回，换一个方向再继续探索。为了保证在任何位置上都能沿原路返回，显然需要用一个后进先出的栈结构来保存从入口到...
迷宫问题数据结构
12-19 1173
在A*算法中，我们使用一个f(n)函数来估计从起点到节点n的代价，这个函数通常由两部分组成：g(n)表示从起点到节点n的实际代价，h(n)表示从节点n到目标的估计代价。分支定界是指在搜索过程中，将一些不可能存在解的分支提前剪除，从而减少搜索的路径。最后，解决迷宫问题还涉及到一些启发式搜索技术，比如在A*算法中的h(n)函数，可以提供一些关于目标位置的估计信息，从而引导搜索方向。在迷宫问题中，我们可以将迷宫的每个节点看作一个状态，将每个节点到出口的距离看作目标函数，然后使用模拟退火算法来寻找最优路径。
【数据结构与算法】关于迷宫问题
weixin_68160004的博客
06-11 1073
关于迷宫创建以及寻路的几种不同方式
数据结构——迷宫问题（顺序栈、C++）
m0_53468233的博客
08-01 8692
顺序栈求解随机生成迷宫的通路（C++)
数据结构--迷宫求解
m0_62476845的博客
04-02 3653
迷宫求解--C语言太多了不会？跟着我的代码敲，熟能生巧，一个一个模块去做，分治法大事化小。看着代码自己打一遍，能运行就是成功。
【数据结构 迷宫问题求解】栈的应用|c语言|迷宫问题
m0_61139217的博客
05-05 7248
【数据结构 迷宫问题求解】栈的应用|c语言|迷宫问题
数据结构迷宫问题python
最新发布
04-02
数据结构迷宫问题是一个经典的算法问题，主要是通过使用适当的数据结构和算法来解决迷宫中的路径搜索问题。在Python中，可以使用多种数据结构和算法来解决迷宫问题。 一种常见的解决方法是使用深度优先搜索（DFS）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值