3.2.4--迷宫求解

最新推荐文章于 2024-08-06 12:06:34 发布
最新推荐文章于 2024-08-06 12:06:34 发布
阅读量569 收藏 7
点赞数 7
分类专栏： 数据结构 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52436042/article/details/120103018
版权

一、题目及分析

求迷宫中从入口到出口的所有路径是一个经典的程序设计问题。由于计算机解决迷宫问题时,通常用的是“穷举求解”的方法,即从口出发,顺某方向向前探索,若能走通,则继续往前走;否则沿原入口路退回,换一个方向再继续探索,直至所有可能的通路都探索到为止。为了保证在任何位置上都能沿原路退回,显然需要用一个后进先出的结构来保存从入口到当前位置的路径。因此,在求迷宫通路的算法中应用“栈”。也就是自然而然的事了。
二、思路
请添加图片描述
请添加图片描述

代码：

结构体构造：

typedef struct//坐标
{
	int x;
	int y;
}Coordinate;
typedef struct //栈元素的类型
{
	int stepnumber;//通道块在路径上的序号
	Coordinate seat;//通道块在迷宫中的坐标
	int di;//从此通道块走向下一通道块的方向
}Elem;
typedef struct //栈
{
	Elem* top;
	Elem* base;
	int stacksize;
}Stack;
typedef struct //地图类型
{
	int length;
	int width;
	int mapdic[MAXZISE][MAXZISE];
}Maptype;

栈的常规操作：

int InitStack(Stack* s)//栈初始化
{
	s->base = (Elem*)malloc(STACK_INIT_SIZE * sizeof(Elem));
if(!s->base) return 0;
	s->top = s->base;
	s->stacksize = STACK_INIT_SIZE;
	return 1;
}
int Push(Stack* s, Elem* e)//压栈
{
	if (s->top - s->base >= s->stacksize)
	{
		s->base = (Elem*)realloc(s->base, (STACK_INIT_SIZE + STACKINCREMENT) * sizeof(Elem));
		s->top = s->base + s->stacksize;
		s->stacksize += STACKINCREMENT;
	}
	*s->top = *e;
	s->top++;
	return 1;
}
int Pop(Stack* s, Elem* e)//出栈
{
	if (s->base == s->top)
	{
		cout << "空栈，无法出栈" << endl;
		return 0;
	}
	s->top--;
	*e = *s->top;
	return 1;
}

路径打印：

int MapPath(Maptype map, Coordinate start, Coordinate end)//若迷宫有通路，则打印结果
{
	Stack s;
	Elem e;
	InitStack(&s);
	Coordinate coord = start;
	int stepnum = 1;
	do {
		if (Pass(map, coord))//如果可以通过
		{
			FootPrint(&map, coord);
			e = CreatElem(stepnum, coord, 1);
			Push(&s, &e);
			if (End(coord, end))
			{
				system("CLS");
				PrintMap(&map, ROW, COL);
				return 1;
			}
			else
			{
				coord = NextPod(coord, 1);
				stepnum++;
			}
		}
		else//如果不能通过
		{
			if (!StackEmpty(&s)) {
				Pop(&s, &e);
				while (e.di == 4 && !StackEmpty(&s))
				{
					MarkPrint(&map,e.seat);
					Pop(&s, &e);
				}
				if (e.di < 4) {
					e.di++;
					Push(&s, &e);
					coord = NextPod(e.seat, e.di);
				}
			}
		}
			Sleep(100);
			system("CLS");
			PrintMap(&map, ROW, COL);
	} while (!StackEmpty(&s));
	return 0;
}

总代码：

#include<iostream>//ZJJ数据据结构-栈3.2.4
#include  <windows.h>
using namespace std;
#define MAXZISE 100
#define ROW 10//行数
#define COL 10//列数
#define STACK_INIT_SIZE 100//迷宫最大范围
#define STACKINCREMENT 10
typedef struct//坐标
{
	int x;
	int y;
}Coordinate;
typedef struct //栈元素的类型
{
	int stepnumber;//通道块在路径上的序号
	Coordinate seat;//通道块在迷宫中的坐标
	int di;//从此通道块走向下一通道块的方向
}Elem;
typedef struct //栈
{
	Elem* top;
	Elem* base;
	int stacksize;
}Stack;
typedef struct //地图类型
{
	int length;
	int width;
	int mapdic[MAXZISE][MAXZISE];
}Maptype;
int InitStack(Stack* s)//栈初始化
{
	s->base = (Elem*)malloc(STACK_INIT_SIZE * sizeof(Elem));
if(!s->base) return 0;
	s->top = s->base;
	s->stacksize = STACK_INIT_SIZE;
	return 1;
}
int Push(Stack* s, Elem* e)//压栈
{
	if (s->top - s->base >= s->stacksize)
	{
		s->base = (Elem*)realloc(s->base, (STACK_INIT_SIZE + STACKINCREMENT) * sizeof(Elem));
		s->top = s->base + s->stacksize;
		s->stacksize += STACKINCREMENT;
	}
	*s->top = *e;
	s->top++;
	return 1;
}
int Pop(Stack* s, Elem* e)//出栈
{
	if (s->base == s->top)
	{
		cout << "空栈，无法出栈" << endl;
		return 0;
	}
	s->top--;
	*e = *s->top;
	return 1;
}
Elem CreatElem(int stepnumber, Coordinate seat, int di)//构造栈的元素
{
	Elem e;
	e.di = di;
	e.seat = seat;
	e.stepnumber = stepnumber;
	return e;
}
int InitMap(Maptype* map, int a[ROW][COL], int row, int col)//构建迷宫
{
	for (int i = 0;i < row;i++)
	{
		for (int j = 0;j < col;j++)
		{
			map->mapdic[i][j] = a[i][j];//将自己用数字表示的迷宫传入
		}
	}
	map->length = row;
	map->width = col;
	return 1;
}
int Pass(Maptype map, Coordinate coord)//判断是否通过
{
	return map.mapdic[coord.x][coord.y] == 0;
}
int FootPrint(Maptype* map, Coordinate coord)//若通过，标记为O
{
	map->mapdic[coord.x][coord.y] = 'O';
	return 1;
}
int MarkPrint(Maptype* map, Coordinate coord)//若不能通过，标记为X
{
	map->mapdic[coord.x][coord.y] = 'X';
	return 1;
}
int StackEmpty(Stack* s)//判断是否为空栈
{
	return s->base == s->top;
}
int End(Coordinate coord, Coordinate end)//判断当前坐标是否为终点坐标
{
	if (coord.x == end.x && coord.y == end.y)
		return 1;
	else return 0;
}
Coordinate NextPod(Coordinate coord, int di)//下一步的方向
{
	switch (di)
	{
	case 1:
		coord.y++;
		break;
	case 2:
		coord.x++;
		break;
	case 3:
		coord.y--;
		break;
	case 4:
		coord.x--;
		break;
	}
	return coord;
}
int PrintMap(Maptype* map, int row, int col)
{
	for (int i = 0;i < row;i++) {
		for (int j = 0;j < col;j++) {
			switch (map->mapdic[i][j]) {
			case 0:
				cout << ' ';		//未探索 
				break;
			case 1:
				cout << '#';		//迷宫的墙 
				break;
			case 'O':
				cout << 'O';		//通过的路径 
				break;
			case 'X':
				cout << 'X';		//探索后不能通过的路径
			}
		}cout << endl;
	}
	cout << "    " << "start:";
	for (int i = 0;i < row;i++)
	{
		for (int j = 0;j < col;j++)
		{
			if (map->mapdic[i][j] == 'O')
			{
				cout << "(" << i << "," << j << ")" << "->";
			}
		}
	}
	cout << "end" << endl;
	return 1;
}
int MapPath(Maptype map, Coordinate start, Coordinate end)//若迷宫有通路，则打印结果
{
	Stack s;
	Elem e;
	InitStack(&s);
	Coordinate coord = start;
	int stepnum = 1;
	do {
		if (Pass(map, coord))//如果可以通过
		{
			FootPrint(&map, coord);
			e = CreatElem(stepnum, coord, 1);
			Push(&s, &e);
			if (End(coord, end))
			{
				system("CLS");
				PrintMap(&map, ROW, COL);
				return 1;
			}
			else
			{
				coord = NextPod(coord, 1);
				stepnum++;
			}
		}
		else//如果不能通过
		{
			if (!StackEmpty(&s)) {
				Pop(&s, &e);
				while (e.di == 4 && !StackEmpty(&s))
				{
					MarkPrint(&map,e.seat);
					Pop(&s, &e);
				}
				if (e.di < 4) {
					e.di++;
					Push(&s, &e);
					coord = NextPod(e.seat, e.di);
				}
			}
		}
			Sleep(100);
			system("CLS");
			PrintMap(&map, ROW, COL);
	} while (!StackEmpty(&s));
	return 0;
}
int main()
{
	int a[ROW][COL] =
	{ {1,1,1,1,1,1,1,1,1,1} ,
	{1,0,0,1,0,0,0,1,0,1 },
	{1,0,0,1,0,0,0,1,0,1 },
	{1,0,0,0,0,1,1,0,0,1 },
	{1,0,1,1,1,0,0,0,0,1 },
	{1,0,0,0,1,0,0,0,0,1 },
	{1,0,1,0,0,0,1,0,0,1 },
	{1,0,1,1,1,0,1,1,0,1 },
	{1,1,0,0,0,0,0,0,0,1 },
	{1,1,1,1,1,1,1,1,1,1} };
	Maptype map;//构建地图
	Coordinate start, end;//定义初始坐标
	start.x = start.y=1;//定义出口坐标
	end.x = end.y =8;//定义终点坐标
	InitMap(&map, a, ROW, COL);
	if (!MapPath(map, start, end))
	{
		cout << "NO PASS";
	}
	return 0;
}

表示通过的路径，‘X’ 表示探索过但是不通的路径
下方坐标表示为（行，列）
运行结果：请添加图片描述
这个代码还算是比较有难度的了，算是我写数据结构到现在最难的了，看一遍真没啥感觉，得好好理解。
有无欠缺的，欢迎指正。

ZJJ啥都学不会
关注
专栏目录
05-C. DS堆栈--迷宫求解
bianchengfive的博客
10-13 949
05-栈与队列- 题目描述 给出一个N*N的迷宫矩阵示意图，从起点[0,0]出发，寻找路径到达终点[N-1, N-1] 要求使用堆栈对象来实现，具体算法参考课本3.2.4节51页 输入 第一行输入t，表示有t个迷宫 第二行输入n，表示第一个迷宫有n行n列 第三行起，输入迷宫每一行的每个方格的状态，0表示可通过，1表示不可通过 输入n行 以此类推输入下一个迷宫 输出 逐个输出迷宫的路径 如果迷宫不存在路径，则输出no path并回车 如果迷宫存在路径，将路径中每个方格的x和y坐标输出，
python迷宫小游戏代码_课内资源 - 基于python实现的迷宫游戏
weixin_39935388的博客
11-24 1427
一、项目概述与编译环境本次大作业选题为题目2，即小兔子找胡萝卜的迷宫问题，最终完成开发的游戏名为Caveman and Treasure（穴居人寻宝），游戏整体界面如下：该项目在windows下编译通过，所需环境为python3，编写GUI所用的库为pygame，在运行作业前，需要配置依赖项，即在main.py的路径下打开cmd，并运行：pip install–r requirement.txt配...
迷宫求解问题
10-07
1.本演示程序中，首先实现一个以链表做存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i，j，d）的形式输出，其中：（i，j）指示迷宫中的一个坐标的方向。 2.演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令；相应的输入数据（滤去输入数据中的非法字符）和运算结果显示在其后。 3.程序执行的命令包括： （1）构造链表；（2）输入数据；（3）数据处理；（4）结束 4.测试数据
3.2.4 迷宫求解
SJMP
11-06 891
/* func3-1.c algo3-5.c、algo3-9.c和algo3-11.c要调用的函数、结构和全局变量 */  typedef struct  {    int x; /* 行值 */    int y; /* 列值 */  }PosType; /* 迷宫坐标位置类型 */  #define MAXLENGTH 25 /* 设迷宫的最大行列为25 */  typedef
【数据结构与算法】迷宫求解------回溯法
最新发布
qq_74047911的博客
08-06 546
当我们想要找到迷宫的出口,那我们在计算机中,然后操作,可以将每个位置都人栈,然后进行上下左右的路的判断,能否通过,若是死路,就将这个点出栈,回退到刚刚的栈,再判断其他的道路.在同行同列且相邻且在二维数组范围内,值为1就是通道就可以下一步.就当前入口点入栈,然后做标记改为2,就是我们走过的地方.就出栈,进行判断上一个路口,是否可以其他的下一步.地图的结构就是一个二维数组,初始化就是进行赋值.只有我们的栈不为空或者找不到出口,那么就一直找.初始化栈就可以进入到我们的迷宫判断了.能下一步就做标记,入栈.
迷宫求解
snow_5288的博客
12-04 6903
话不多说，直接贴代码： （一）运行迷宫：0表示通路，1表示墙，红色的0表示入口，绿色的一行表示出口 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 0 1
迷宫求解！
weixin_34129280的博客
05-31 735
迷宫求解主要是将迷宫转换为由‘0’和‘1’组成的矩阵‘0’表示此处是路‘1’表示此处是墙然后从起点开始寻找直到终点，并将路径用‘*’表示首先构建组成迷宫的每个单元如下 然后就可以构建迷宫了 然后是测试类 运行结果如下 ...
第3章栈和队列第7讲-队列的应用-求解迷宫问题.pptx
05-24
3.2.4 用队列求解迷宫问题 在迷宫问题中，我们需要使用队列来记录走过的方块。该队列的结构如下： typedef struct { int i,j;// 方块的位置 int pre// 本路径中上一方块在队列中的下标 } Box;// 方块类型 ...
c语言数据结构迷宫求解
11-29
c语言数据结构迷宫求解 严蔚敏版 使用栈和结构体
3-3 C. DS堆栈--迷宫求解
2301_79713191的博客
01-21 1939
DS堆栈--迷宫求解 给出一个N*N的迷宫矩阵示意图，从起点[0,0]出发，寻找路径到达终点[N-1, N-1] 要求使用堆栈对象来实现，具体算法参考课本3.2.4节51页
迷宫求解程序
05-24
用mfc编的迷宫程序是,上机交作业不可多得的好东东
1.编写网络爬虫程序，实现支持断点续传的网络文件下载功能。 https://mirrors.tuna.tsinghua.edu.cn/apache/spark/spark-3.2.4/spark-3.2.4-bin-hadoop2.7.tgz
05-19
好的，以下是一个 Python 3 编写的支持断点续传的网络文件下载程序： ```python import requests import os url = "https://mirrors.tuna.tsinghua.edu.cn/apache/spark/spark-3.2.4/spark-3.2.4-bin-hadoop2.7.tgz" filename = "spark-3.2.4-bin-hadoop2.7.tgz" # 检查文件是否已经下载过 if os.path.exists(filename): filesize = os.path.getsize(filename) else: filesize = 0 # 设置 HTTP 请求头，指定下载的文件范围 headers = {"Range": "bytes={}-".format(filesize)} # 发送 HTTP 请求，获取响应 res = requests.get(url, headers=headers, stream=True) # 打开文件，准备写入数据 with open(filename, "ab") as f: # 写入数据 for chunk in res.iter_content(chunk_size=1024): if chunk: f.write(chunk) # 打印下载完成信息 print("Download finished!") ``` 运行程序时，会检查文件是否已经下载过，如果已经下载过就记录文件大小，然后设置 HTTP 请求头，指定下载的文件范围。发送 HTTP 请求，获取响应，打开文件，准备写入数据，然后写入数据。如果下载中断，下次运行程序时会从上次下载的位置继续下载，直到下载完成。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ZJJ啥都学不会

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值