经典迷宫算法

最经典的走迷宫最短路径算法(深度优先搜索BFS的典型实例) 迷宫的最短路径 问题描述 给定一个大小为N×M的迷宫。迷宫由通道和墙壁组成,每一步可以向邻接的上下左右四个的通道移动。请求出从起点到终点所需的最小步数。请注意,本题假定从起点一定可以移动到终点。(N,M≤100) (’#’, ‘.’ , ‘S’, 'G’分别表示墙壁、通道、起点和终点) 样例输入: 10 10 #S######.# ......#..# .#.##.##.# .#........ ##.##.#### ....#....# .#######.# ....#..... .####.###. . 阅读详情
/********************************************************************
经典迷宫算法
迷宫值的含义:
1---表示可以占据
0---障碍物
2---已走过该位置

	------------------------------------------->y
	|               寻路顺序图
	|		 	   |
	|			   |3:x-1
	|			   |
	|	4:y-1 <--------------------->2:y+1
	|			   |
	|			   | 1:x+1
	|			   |
	|
	x

寻找到一个位置后按照方向1,2,3,4的顺序进行探索。
********************************************************************/
#include <iostream>
#include "string.h"
using namespace std;
#define MAZESIZE 50
/*表示位置的结构体*/
typedef struct {
	int x, y, dir;//dir - 表示此位置下一步将要探索的方向
}pos;
/*栈信息存储,此栈为增地址*/
typedef struct {
	pos** base;//栈中存放的是pos位置的指针,栈底
	pos** top;//栈顶指向栈顶元素的下一个位置
	int size;//栈的容量
}stack;

/*栈初始化函数*/
void Init(stack* s, int size)
{
	if (size <= 0)return;
	else
	{
		s->base = (pos**)malloc(size*sizeof(pos*));
		if (s->base == NULL)
		{
			cout << "Init stack failed!" << endl;
			exit(-1);
		}
		s->size = size;
		s->top = s->base;
		cout << "分配了" << size << "*" << sizeof(pos*) << "字节空间" << endl;
	}
}
/*判断栈是否为空*/
bool IsEmpty(stack* s)
{
	if (s == NULL || s->base == s->top)return true;
	else
	{
		return false;
	}
}
/*元素入栈*/
void push(stack* s, pos* position)
{
	//如果栈满再扩充10个元素的空间
	if (s->top-s->base==s->size)
	{
		//分配十个指向pos的指针数组
		s->base = (pos**)realloc(s->base, (s->size + 10) + sizeof(pos*));
		if (s->base == NULL)
		{
			cout << "push failed " << endl;
			exit(-1);
		}
		s->top = s->base + s->size;
		s->size += 10;
		cout << "重新分配了" << s->size + 10 << "*" << sizeof(pos*) << "字节空间" << endl;
	}
	*s->top = position;
	s->top++;
	cout << "位置[" << position ->x<<","<<position->y<< "]入栈" << endl;
}
/*元素出栈*/
void pop(stack* s)
{
	if (IsEmpty(s) == true)
	{
		cout << "empty stack! " << endl;
	}
	else
	{
		cout << "位置[" << (*(s->top-1))->x << "," << (*(s->top-1))->y << "]出栈" << endl;
		s->top--;
		delete *(s->top);//某元素出栈,则要释放内存空间
	}
	
}
int getStep(stack*s)
{
	return (s->top - s->base);
}
pos* getStackTopPos(stack*s)
{
	cout << "获取栈顶位置[" << (*(s->top - 1))->x << "," << (*(s->top - 1))->y << "]" << endl;
	return *(s->top - 1);
}
/*判断当前位置是否可以占据*/
bool IsPassPos(pos* position, int maze[][8])
{
	if (maze[position->x][position->y] != 0 && maze[position->x][position->y] != 2)
	{
		return true;
	}
	else
	{
		return false;
	}
}
/*根据当前位置寻找下一个位置*/
int findNextPos(pos* curpos,int maze[][8])
{
	if (curpos == NULL)
	{
		cout << "pos error" << endl;
		exit(-1);
	}
	else
	{
		//根据当前位置欲探索的方向,代表方向的数字值是一直增加的,
		//一旦找出一个可行的方向立即返回
		for (int i = curpos->dir; i < 5; i++)
		{
			switch (i)
			{
			case 1:
				if (curpos->x + 1 < 8 && maze[curpos->x + 1][curpos->y] != 0 && maze[curpos->x + 1][curpos->y] != 2)
				{
					return 1;
				}
			case 2:
				if (curpos->y + 1 < 8 && maze[curpos->x][curpos->y + 1] != 0 && maze[curpos->x][curpos->y + 1] != 2)
				{
					return 2;
				}
			case 3:
				if (curpos->x - 1 >= 0 && maze[curpos->x - 1][curpos->y] != 0 && maze[curpos->x - 1][curpos->y] != 2)
				{
					return 3;
				}
			case 4:
				if (curpos->y - 1 >= 0 && maze[curpos->x][curpos->y - 1] != 0 && maze[curpos->x][curpos->y - 1] != 2)
				{
					return 4;
				}
			default:
				continue;
			}
		}
		
		
		
		
	}
	return 0;//表示没有下一个位置
}
/*核心寻路算法*/
bool searchPath(pos* curpos, pos* end, stack*s, int maze[][8])
{
	if (curpos->dir<5 && curpos->dir>0)//判断当前方向是否合法
	{
		cout << "寻路方向-->" << curpos->dir << endl;
		push(s, curpos);//当前位置入栈
		maze[curpos->x][curpos->y] = 2;//当前位置留下足迹
		if (curpos->x == end->x && curpos->y == end->y)//此位置是终点
		{
			cout << "find path step:"<< endl;
			//打印路径
			for (pos **p = s->base; p != s->top-1; ++p)
			{
				cout << "[" << (*p)->x << "," << (*p)->y << "]" << "->";
			}
			cout << "[" << (*(s->top - 1))->x << "," << (*(s->top - 1))->y << "]" << endl;
			return true;
		}
		//获取下一个位置
		else
		{
			int dir=findNextPos(curpos, maze);//获取下一个可以探索的方向
			pos *next=new pos;//为下一个位置分配存储空间。
			switch (dir)
			{
			case 0: //说明没有下一个位置
					maze[curpos->x][curpos->y] = 1;//清除足迹	
					pop(s);//当前位置退栈 
					memcpy(next, getStackTopPos(s),sizeof(pos));			
					next->dir += 1;//方向加一
					//cout << "[" << next->x << "," << next->y << "," << next->dir << "]" << endl;
					pop(s);//栈顶元素再退栈 
					break;
			case 1: next->x = curpos->x + 1;
				    next->y = curpos->y;
					next->dir = 1;
					break;
			case 2: next->x = curpos->x;
					next->y = curpos->y + 1;
					next->dir = 1;
					break;
			case 3: next->x = curpos->x - 1;
					next->y = curpos->y;
					next->dir = 1;
					break;
			case 4:	next->x = curpos->x;
					next->y = curpos->y - 1;
					next->dir = 1;
					break;
			default:
				break;
			}
			searchPath(next, end, s, maze);
		}
	}
	else //没有下一个位置,curpos->dir > 5,表示当前位置不合法
	{

		pos *next=new pos;	
		memcpy(next, getStackTopPos(s), sizeof(pos));
		next->dir += 1;//方向加一
		pop(s);//当前位置退栈
		searchPath(next, end, s, maze);
	}
}
int main(int argc,char* argv[])
{
	/*迷宫数据*/
	int maze[8][8] =
	{
		{ 0, 0, 0, 0, 0, 0, 0, 0 },
		{ 0, 0, 1, 0, 0, 1, 0, 0 },
		{ 0, 0, 1, 1, 1, 0, 1, 0 },
		{ 0, 0, 1, 0, 1, 0, 0, 0 },
		{ 0, 0, 0, 1, 1, 0, 1, 0 },
		{ 0, 0, 0, 1, 0, 0, 1, 0 },
		{ 0, 0, 0, 1, 1, 1, 1, 0 },
		{ 0, 0, 0, 0, 1, 0, 0, 0 }
	};
	stack *s=new stack();//存储栈信息,只有一个实例
	pos* start = new pos();//起点
	start->x = 1;
	start->y = 2;
	start->dir = 1;
	pos* end = new pos();//终点
	end->x = 4;
	end->y = 6;	
	end->dir = 0;
	cout << "起点位置:[" << start->x << "," << start->y << "]" << endl;
	cout << "终点位置:[" << end->x << "," << end->y << "]" << endl;
	Init(s, MAZESIZE);//初始化栈
	searchPath(start, end, s, maze);//寻路
	delete s;
	delete start;
	delete end;
}	 

 

BFS解迷宫问题(经典BFS算法) 【问题描述】 下图给出了一个迷宫的平面图,其中标记为 1 的为障碍,标记为 0 的为可 以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角,出口为右下角,在迷宫中,只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫,从入口开始,可以按DRRURRDDDR 的顺序通过迷宫, 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、... 阅读详情

相关推荐

经典迷宫问题(C++)简单DFS算法

经典迷宫问题(C++) *给出一个起点S 输入地图 ‘.’ 代表可以走 ‘ ’代表墙壁不能走 ‘T’代表终点 question:判断是否能够能从到达终点 (不要求最短路径) thinking and methods :单独考虑一个点,从上下左右四个方向进行探索,如果满足条件(不是墙壁&&未超界&&未被探索过),向这个方向探索(递归),直到满足条件或者无路可走return 进行回溯 好好理解dfs(x,y)回溯之后的下一步:vis[tx][ty]=0 “还原现场”;

m0_48300684的博客 3563

C语言零基础项目:迷宫游戏!详细思路+源码分享

每天一个C语言小项目,提升你的编程能力!

致力于C语言C++知识分享! 1万+

【经典算法】老鼠走迷宫问题

老鼠走迷宫问题及其多个变种 说明 老鼠走迷宫问题的递归实现,是对递归思想的一种应用。 问题描述 给定一个二维数组,数组中2表示墙壁,0表示通路,由此数组可展示为一个迷宫图。给定入口位置和出口位置,判断之间是否存在通路并显示出走出迷宫的道路。 /*************************************************************************...

煮酒论英雄 9613

数据结构与算法之走迷宫

数据结构与算法 Java实现走迷宫

liuffei的专栏 5280

经典算法五--老鼠走迷宫

说明: 老鼠走迷宫是递回求解的基本题型,我们在二维阵列中使用2表示迷宫墙壁,使用1表示老鼠行走的路径,试以程式求出由入口至出口的路径。 代码:

qq_46000102的博客 1089

强化学习算法案例——一个经典的走迷宫任务。

作者:禅与计算机程序设计艺术 1.简介 在强化学习(Reinforcement Learning, RL)中,有一个经典的任务——走迷宫,其原理简单易懂,但它的实际意义却深远,它让计算机学习如何通过策略网络(policy network),以最佳的方式解决复杂的任务。本文将介绍如何用强化学习解决这个经典

AI天才研究院 3221

迷宫算法(DFS)

1.如果采用堆栈进行迷宫探测,则称之为深度优先搜索(DFS),它和递归的探测思路是基本一致的,可以看成是递归方式的非递归版本; 2.采用队列进行迷宫探测,则是广度优先搜索(BFS),广度优先搜索法利用队列的特点,一层层向外扩展查找可走的方块,直到找到出口为止,最先找到的这个答案就必然是最短的。 如果打比喻来说,DFS更适合模拟机器人走迷宫的方式,看到一个方向是通的,就一直走下去,遇到死胡同就退回;BFS则好比一个人站在迷宫入口处,拿出一堆小探测器,每个小探测器帮他搜索一个可能的路径去寻找,第一个找到出口的

m0_53157173的博客 1万+

C语言大作业简单迷宫程序

这是我们C语言课程的大作业,个人所写,适合初学者了解C语言. 使用dev c++编译通过,可以运行. 使用方式:按键盘方向键,移动,找出迷宫出口.

经典算法-----迷宫问题(栈的应用)

今天学习一种算法问题,也就是我们常见的迷宫问题,本期我们通过前面学习过的数据结构---栈来去完美的解决这个问题,下面看问题!

m0_73633088的博客 1万+

易语言最短路径走迷宫,BFS(宽度优先搜索) 易语言纯源码实现 简单搜索算法

易语言最短路径走迷宫,BFS(宽度优先搜索) 易语言纯源码实现 简单搜索算法 。@qwb492859377。

易语言COM对象操作XML模块

易语言COM对象操作XML模块源码,COM对象操作XML模块,test,取根节点名,取父节点名,导入,导入XML,取子节点数,取节点名,枚举子节点名,枚举属性名值,删除节点,删除属性,导出到文件,取XML源码,取XML文本,取XML路径,插入节点,插入属性,置节点值,置节点名,取节点值,取

经典算法50例 老鼠走迷宫1,2

本文来源和参考于经典算法50例。只不过把c换成java来实现。 老鼠走迷官(一) 说明 老鼠走迷宫是递回求解的基本题型,我们在二维阵列中使用2表示迷宫墙壁,使用1来表示老鼠的行走路径,试以程式求出由入口至出口的路径。 解法 老鼠的走法有上、左、下、右四个方向,在每前进一格之后就选一个方向前进,无法前进时退回选择下一个可前进方向,如此在阵列中依序测试四个方向,直到走到出口为止,这是递回的基本题,请直...

小jinx的博客 4880

数据埋点系列 3|数据质量保证:验证、清洗与管理

数据质量管理是一个持续的过程,需要技术和组织文化的共同支持。通过本文,我们深入探讨了数据质量保证的各个方面,从基本的验证和清洗技术,到高级的监控和自动化策略。主动的而非被动的自动化的而非手动的持续的而非一次性的全面的而非局部的随着数据在决策中的作用越来越重要,确保数据质量将成为每个数据驱动型组织的核心竞争力。通过实施本文中讨论的策略和技术,你将能够建立一个强大的数据质量保证体系,为你的组织带来更可靠、更有价值的数据洞察。

一个8年大数据开发工程师的碎碎念 1464

C#实现4种经典迷宫生成算法和迷宫寻路算法(一)

4种经典的迷宫生成算法是: (1)使用并查集算法生成 (2)使用深度优先算法生成 (3)使用随机算法生成 (4)使用递归切割算法 而迷宫寻路使用A*算法。 我把所有迷宫生成定义成一个虚类,每一种生成算法是继承虚类的一个实现。当然,寻路算法也在虚类中,因为无论迷宫如何生成,寻路算法都是一样的。为了阅读的流畅性,在下面的代码中,暂不包含寻路算法。 /// &lt;summary&gt;...

lweiyue的专栏 4556

揭秘个人开发者接支付宝的‘野路子’:不用企业资质,用Python模拟扫码转账与回调监听

本文探讨了个人开发者如何通过Python模拟支付宝扫码转账与回调监听的技术实现,解析了支付宝URL协议格式,并设计了本地化的支付状态监听方案。文章强调该方法仅用于技术研究,实际应用需遵守支付宝官方接口和金融合规要求。

weixin_30736301的博客 409

机器视觉中的特征提取【0】:什么是特征提取,特征提取有什么作用?

1.什么是特征提取? 特征提取的英文叫做feature extractor,它是将一些原始的输入的数据维度减少或者将原始的特征进行重新组合以便于后续的使用。简单来说有两个作用:减少数据维度,整理已有的数据特征。 这里我给一个例子来解释特征提取的第二个作用。那就是我们很熟悉的奖学金评定,我们知道学生的文化课成绩,道德分数,以及各种其他竞赛的成绩。摆在奖学金评定委员会面前的任务就是如何知道一个学生是否...

月下花弄影 5万+

经典bfs算法 蓝桥杯 学霸的迷宫

经典bfs算法 试题 算法提高 学霸的迷宫 资源限制 时间限制:1.0s 内存限制:256.0MB 问题描述   学霸抢走了大家的作业,班长为了帮同学们找回作业,决定去找学霸决斗。但学霸为了不要别人打扰,住在一个城堡里,城堡外面是一个二维的格子迷宫,要进城堡必须得先通过迷宫。因为班长还有妹子要陪,磨刀不误砍柴功,他为了节约时间,从线人那里搞到了迷宫的地图,准备提前计算最短的路线。可是他现在正向...

weixin_44371476的博客 567

Cadence Allegro 17.4学习记录开始01-原理图Capture CIS 17.4

Orcad的学习记录

qq_31444421的博客 1万+

经典Q-learning代码-迷宫:迷宫寻路算法的MATLAB实现

经典Q-learning代码-迷宫:迷宫寻路算法的MATLAB实现 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在人工智能领域中,强化学习是一种重要的机器学习方法,而Q-learning算法则是强化学习中的经典算法之一。今天,我们要推荐的这个开源项目——经典Q-learning代码-迷宫,就是一套基于Q-learning算法的MATLAB代码实现,它旨在解决一个迷宫...

gitblog_06731的博客 1064

pytorch中的wheel文件

whl 文件是 Python 的一个软件包分发格式,用于在 Python 中安装软件包。它是 Python Wheel 的缩写,也被称为 wheel 文件。这种文件格式旨在简化 Python 软件包的安装和分发。对于 PyTorch 而言,它提供了预编译的 .whl 文件,您可以通过 pip 安装这些文件来快速方便地安装 PyTorch。这些 .whl 文件是已经编译好的二进制分发文件,可以直接安装在您的 Python 环境中,而无需再进行编译。

bj_zhb的博客 3129

多路输出电源的交叉调整率:从理论到无源优化实践

本文深入探讨了多路输出电源中的交叉调整率问题,分析了其物理根源及无源优化方法。通过漏感与耦合的理论分析,结合加权反馈、电感耦合等五种无源优化技术,帮助工程师有效解决交叉调整率挑战。文章还以TDK-Lambda CUT75系列为例,展示了优化技术的实际应用与效果。

weixin_26886855的博客 282

洛谷—P1605 迷宫(经典DFS算法)

对于 100% 的数据,1≤N,M≤5,1≤T≤10,1≤SX,FX≤n,1≤SY,FY≤m。

2301_79724394的博客 417

从零开始开发AI Agent:基于大模型的智能体实战指南

### 摘要 本文介绍了AI Agent的开发全流程,从基础概念到实际部署,涵盖大模型集成、工具调用和记忆系统构建等核心技术。通过电商客服案例展示实战应用,并提供调试优化与部署方案,最后展望了AI Agent的未来发展方向,帮助开发者快速掌握智能体开发技能。

ghs_gss的博客 4869

经典游戏算法之走迷宫

问题描述:使用二维数组构建迷宫,用2代表墙壁,1代表行走路径,0表示可走路径,找出从起点到终点的路径。 函数说明: bool visit_maze(int maze[][SIZE],int ,int ); 遍历迷宫的主要函数,传入代表迷宫的数组及起始位置,函数将从起始位置开始遍历相邻位置以发现可行路径。 具体步骤为,将当前位置置1表示走过该位置,然后依序遍历位置(如:右上左下)递归调用该函数,若到达终点则返回真,否则将当前位置置回0并返回假。 bool judge_arrived(int maze

#include <iostream> 1222

用 ADT 连接 SAP S/4HANA Public Cloud 开发租户的完整落地指南

摘要:在SAP S/4HANA公有云中进行ABAP开发时,必须使用Development Tenant(客户端080)而非Customizing Tenant(客户端100)连接ADT工具。开发用户需具备SAP_BR_DEVELOPER角色且写权限不受限,开发对象应创建在结构包的子包中。连接前需确认正确的ABAP服务URL(通常为Launchpad URL去掉"/ui"),并通过运行控制台程序验证全链路功能。典型开发场景如通过BAdI实现业务校验时,需遵循Clean Core原则在指定包

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 343

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

毕业设计 基于Unity3D的迷宫类游戏设计 回溯算法以及八皇后等经典算法

游戏的娱乐性在于游戏的迷宫探索,3D游戏不同于2D,游戏的过程中,不能采用上帝视角观看游戏的迷宫,需要人工挨个探索,增加了游戏的难度。迷宫类的游戏,是一款关于回溯算法以及八皇后等经典算法的一个算法类游戏,也加入了3D游戏的概念和建模概念,游戏中的人物都是通过建模生成的角色,迷宫也是建模后的迷宫,是一款经典的3D游戏引擎开发。点击空格按钮,可以重置迷宫布局。游戏建模设计:游戏的建模设计,是游戏的核心,首先要对游戏中的人物,游戏迷宫中的相应的树木,景色等进行建模,创建一个丰富的游戏迷宫,并进行游戏。

QQ_188083800的博客 888

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

上一篇: shell 流程控制参数
下一篇: 八皇后问题 的92种结果
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值