A*算法

最新推荐文章于 2024-12-06 15:04:14 发布
最新推荐文章于 2024-12-06 15:04:14 发布
阅读量500 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mikon_lee/article/details/8880513
本文探讨了一种基于A*算法的寻路策略，在5*5矩阵迷宫环境中实现从起点到终点的有效路径规划。通过优先级队列、节点状态表示和状态更新机制，展示了算法在复杂路径搜索中的高效性和精确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<stdlib.h>
#include<math.h>
using namespace std;
struct load_list
{
	int x;
	int y;
	load_list(int x,int y)
	{
		this->x=x;
		this->y=y;
	}
	load_list *next;
};
struct mynode
{
	int x;
	int  y;
	double h;
	double g;
	double f;
	int pre_x;
	int pre_y;
	mynode *next;
	mynode(int x,int y)
	{
		this->x=x;
		this->y=y;
	};
	mynode()
	{};
	bool operator==(mynode& other)
	{
		if(x==other.x&&y==other.y)
			return 1;
		else return 0;
	};
	mynode& operator=(mynode &other)
	{

		this->x=other.x;
		this->y=other.y;
		this->h=other.h;
		this->g=other.g;
		this->f=other.f;
		this->pre_x=other.pre_x;
		this->pre_y=other.pre_y;
		this->next=NULL;
		return *this;
	}
};
//--------------------------
//整个图为5*5的矩阵
const int x_len=5;
const int y_len=5;
load_list *load=new load_list(-1,-1);
mynode *open=new mynode;
mynode *Close=new mynode;
mynode *s=new mynode(0,0);
mynode *e=new mynode(4,4);
int can_visit[5][5];
//--------------------------
int len;
bool isvoild(int x,int y)
{
	if(x>=0&&x<x_len&&y>=0&&y<=y_len&&can_visit[x][y]==0)
		return 1;
	else return 0;

}
mynode * IsInOpen(mynode *tmp)
{
	mynode *p=open->next;
	while(p)
	{
		if(*p==*tmp)
			return p;
		else p=p->next;
	}
	return NULL;
}
mynode * IsInClose(mynode *tmp)
{
	mynode *p=Close;
	while(p->next)
	{
		if(*(p->next)==*tmp)
			return p;
		else p=p->next;
	}
	return NULL;
}
void insert_inopen(mynode *t)
{
	mynode *tmp=new mynode;
	*tmp=*t;
	mynode *p=open;
	while(p->next)
	{
		if(p->next->f>tmp->f)
			break;
		else p=p->next;
	}
	tmp->next=p->next;
	p->next=tmp;
}
void insert_inClose(mynode *t)
{
	mynode *tmp=new mynode;
	*tmp=*t;
	if(Close->next==NULL)
		Close->next=tmp;
	else 
	{
		tmp->next=Close->next;
		Close->next=tmp;
	}
}
int print_load(int e_x,int e_y)
{
	//------------------------------------------------------
	//从后往前找到路径，并利用头插法插入到load_list链表中
	int x=e_x,y=e_y;
	load_list *t=new load_list(	e->x,e->y);
	t->next=load->next;
	load->next=t;
	mynode *p=Close->next;
	while(x!=s->x||y!=s->y)
	{
		while(p->x!=x||p->y!=y)
			p=p->next;
		{
			load_list *t=new load_list(	p->x,p->y);
			t->next=load->next;
			load->next=t;
			x=p->pre_x;
			y=p->pre_y;
			p=Close->next;
		}
	}
	t=new load_list(	s->x,s->y);
	t->next=load->next;
	load->next=t;
	//------------------------------------------------------
	//输出路径。。。
	t=load->next;
	while(t)
	{
		printf("%d %d\n",t->x,t->y);
		t=t->next;
	}
	return 0;
}
int main()
{
	open->next=NULL;
	Close->next=NULL;
	load->next=NULL;
	s->h=0;
	s->g=sqrt((abs(s->x-e->x))*(abs(s->x-e->x))+(abs(s->y-e->y))*(abs(s->y-e->y)));
	s->f=s->g+s->h;
	s->next=NULL;
	insert_inopen(s);
	can_visit[1][1]=can_visit[1][3]=can_visit[3][1]=can_visit[3][2]=1;    //设置不能走的点
	while (open->next)
	{
		if(*(open->next)==*e)
		{
			print_load(open->next->pre_x,open->next->pre_y);
			break;
		}
		else 
		{
			//--------------------------------------------------------------------------------
			//	对该点的四个邻点进行匹配
			//--------------------------------------------------------------------------------
			int temp_x=open->next->x;
			int temp_y=open->next->y;
			double temp_g=open->next->g;
			double temp_h=open->next->h;
			mynode *temp=open->next;
			insert_inClose(temp);
			open->next=open->next->next;
			if(isvoild(temp_x-1,temp_y))
			{
				mynode *find;
				mynode *tmp=new mynode;
				tmp->h=temp_h+1;
				tmp->g=sqrt((abs(temp_x-1-e->x))*(abs(temp_x-1-e->x))+(abs(temp_y-e->y))*(abs(temp_y-e->y)));
				tmp->next=NULL;
				tmp->x=temp_x-1;
				tmp->y=temp_y;
				tmp->f=tmp->g+tmp->h;
				tmp->pre_x=temp_x;
				tmp->pre_y=temp_y;
				if((find=IsInOpen(tmp))!=NULL)
				{
					if(find->f>tmp->f)
					{
						find->f=temp->f;
						find->pre_x=tmp->pre_x;
						find->pre_y=tmp->pre_y;
					}
				}
				if((find=IsInClose(tmp))!=NULL&&find->next->f>tmp->f)
				{
					mynode *t=find->next;
					find->next=find->next->next;
					t->pre_x=tmp->pre_x;
					t->pre_y=tmp->pre_y;
					t->f=tmp->f;
					insert_inopen(t);
				}
				if((find=IsInOpen(tmp))==NULL&&(find=IsInClose(tmp))==NULL)
					insert_inopen(tmp);
			}
			if(isvoild(temp_x+1,temp_y))
			{
				mynode *find;
				mynode *tmp=new mynode;
				tmp->h=temp_h+1;
				tmp->g=sqrt((abs(temp_x+1-e->x))*(abs(temp_x+1-e->x))+(abs(temp_y-e->y))*(abs(temp_y-e->y)));
				tmp->next=NULL;
				tmp->x=temp_x+1;
				tmp->y=temp_y;
				tmp->f=tmp->g+tmp->h;
				tmp->pre_x=temp_x;
				tmp->pre_y=temp_y;
				if((find=IsInOpen(tmp))!=NULL)
				{
					if(find->f>tmp->f)
					{
						find->f=temp->f;
						find->pre_x=tmp->pre_x;
						find->pre_y=tmp->pre_y;
					}
				}
				if((find=IsInClose(tmp))!=NULL&&find->next->f>tmp->f)
				{
					mynode *t=find->next;
					find->next=find->next->next;
					t->pre_x=tmp->pre_x;
					t->pre_y=tmp->pre_y;
					t->f=tmp->f;
					insert_inopen(t);
				}
				if((find=IsInOpen(tmp))==NULL&&(find=IsInClose(tmp))==NULL)
					insert_inopen(tmp);
			}
			if(isvoild(temp_x,temp_y-1))
			{
				mynode *find;
				mynode *tmp=new mynode;
				tmp->h=temp_h+1;
				tmp->g=sqrt((abs(temp_x-e->x))*(abs(temp_x-e->x))+(abs(temp_y-1-e->y))*(abs(temp_y-1-e->y)));
				tmp->next=NULL;
				tmp->x=temp_x;
				tmp->y=temp_y-1;
				tmp->f=tmp->g+tmp->h;
				tmp->pre_x=temp_x;
				tmp->pre_y=temp_y;
				if((find=IsInOpen(tmp))!=NULL)
				{
					if(find->f>tmp->f)
					{
						find->f=temp->f;
						find->pre_x=tmp->pre_x;
						find->pre_y=tmp->pre_y;
					}
				}
				if((find=IsInClose(tmp))!=NULL&&find->next->f>tmp->f)
				{
					mynode *t=find->next;
					find->next=find->next->next;
					t->pre_x=tmp->pre_x;
					t->pre_y=tmp->pre_y;
					t->f=tmp->f;
					insert_inopen(t);
				}
				if((find=IsInOpen(tmp))==NULL&&(find=IsInClose(tmp))==NULL)
					insert_inopen(tmp);
			}
			if(isvoild(temp_x,temp_y+1))
			{
				mynode *find;
				mynode *tmp=new mynode;
				tmp->h=temp_h+1;
				tmp->g=sqrt((abs(temp_x-e->x))*(abs(temp_x-e->x))+(abs(temp_y+1-e->y))*(abs(temp_y+1-e->y)));
				tmp->next=NULL;
				tmp->x=temp_x;
				tmp->y=temp_y+1;
				tmp->f=tmp->g+tmp->h;
				tmp->pre_x=temp_x;
				tmp->pre_y=temp_y;
				if((find=IsInOpen(tmp))!=NULL)
				{
					if(find->f>tmp->f)
					{
						find->f=temp->f;
						find->pre_x=tmp->pre_x;
						find->pre_y=tmp->pre_y;
					}
				}
				if((find=IsInClose(tmp))!=NULL&&find->next->f>tmp->f)
				{
					mynode *t=find->next;
					find->next=find->next->next;
					t->pre_x=tmp->pre_x;
					t->pre_y=tmp->pre_y;
					t->f=tmp->f;
					insert_inopen(t);
				}
				if((find=IsInOpen(tmp))==NULL&&(find=IsInClose(tmp))==NULL)
					insert_inopen(tmp);
			}
			//--------------------------------------------------------------------------------
			//	对该点的四个邻点进行匹配
			//--------------------------------------------------------------------------------
		}
	}
}

mikon_lee
关注
路径规划——A*算法
weixin_51995147的博客
08-05 1711
为了解决Dijkstra算法效率低的问题，A Star 算法作为一种启发式算法被提出。该算法在广度优先的基础上加入了一个估价函数。如BFS和常规方法如Dijsktra算法结合在一起的算法，有点不同的是，类似BFS的启发式经常给出一个近似解而不是保证最佳解，A Star是路径搜索中最受欢迎的选择，它相当灵活，并且能用于多种多样的情理之中，A Star 潜在的搜索一个很大的区域，A Star算法能用于搜索最短路径，A Star 能用启发式函数引发它自己，在简单的情况中，它和BFS一样快。
浅谈A*算法
BlueCarrot的博客
11-01 1275
A*算法 推荐知乎上的一篇文章《路径规划之 A* 算法》，写得很好，图文并茂。 最优路径规划 最优路径规划问题，即依据某个或某些优化准则（如工作代价最小、行走路径最短、行走时间最短等），在工作空间中找到一个从起始状态到目标状态且能避开障碍物的最优路径。 也就是说需要注意以下三个问题： 明确起始位置和终点 避开障碍物 尽可能做到路径上的优化 路径规划的应用场景十分丰富，如游戏中NPC的位置移动、百度地图导航、无人驾驶汽车等。 目前路径规划算法分： 我们先从
OSG 自定义数据类型 关键帧动画
weixin_34296641的博客
06-08 143
OSG 自定义数据类型 关键帧动画 转自：http://blog.youkuaiyun.com/zhuyingqingfen/article/details/12651017 /* 1.创建一个AnimManager一般继承于osg::NodeCallback 2.在AnimManager中创建一个采样器sampler（例如Vec3LinearSampler，有各种sammpler） 3....
A* 算法 是什么？
keyboard专栏
12-06 2310
A*（A-star）算法是一种启发式搜索算法，用于在图或网格中找到从起点到目标的最短路径。它被广泛用于路径规划问题，例如导航、游戏开发中的角色移动，以及机器人路径规划。1. A算法的基本概念。
【人工智能实验】A*算法求解8数码问题
热门推荐
weixin_43442778的博客
03-21 12万+
1、画出A*算法求解N数码问题的流程图。根据A*算法的实验原理，；这样估价函数f(n)在g(n)一定的情况下，会或多或少的受距离估计值h(n)的制约，节点距目标点近，h值小，f值相对就小，能保证最短路的搜索向终点的方向进行,因此f是根据需要找到一条最小代价路径的观点来估算节点的。设计A*算法的流程图如图4.1.1所示，按照流程图编写伪代码，进而编写完整的程序。其中OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。
A*算法及其变种
qq_43353179的博客
03-17 1889
本文详细介绍A*算法及其大部分变种算法．
A*算法自学心得
XiangEZ的博客
04-30 2673
这里写自定义目录标题1.1 概述1.2 算法类比1.3 新增算法与优缺点对比1.4 BFS算法问题的出现 1.1 概述 这是一个寻径算法 相信同学们都玩过某种游戏LOL人在塔在！！！ ，在你用鼠标点击地面的某个地方的时候，你所操控的人物会十分智能地寻找一条最短的路前进到你所指定的位置，不论范围大小，这种算法都很快。 1.2 算法类比 看完这样一个功能，似乎实现起来很简单 似乎我们也可以...
【路径规划】A*算法方法改进思路简析
m0_56662453的博客
08-20 3万+
对A*算法进行基本功能实现，以分析其优缺点，并在此基础上进行改进。改进的内容为，将针对特定地图的相关特点，设计合理的预估函数，设置了包含代价函数和启发函数的权重函数，其次，将传统的8方向搜索降为5个方向，舍弃无用的方向，然后在此基础上，对开放列表的数据结构进行堆优化，并且采用双向A*算法进一步提高计算速度，并针对实际机器人运动过程中的路径不平滑问题采用贝塞尔曲线进行平滑化处理。
A*算法原理概述
小狐狸
05-06 2万+
这里是目录路径规划A*算法原理路线规划理论概述Dijkstra算法最佳优先搜索算法A*算法理论概述 路径规划A*算法原理 路线规划理论概述 移动一个物体直观上很容易的，但是物品的路线规划是复杂的。如下图3-1所示，物体最初位于地图的底端，并尝试向顶部移动。物在扫描的区域中，没有任何东西显示物体不能向上移动，因此它持续向上移动。在靠近顶部时，它探测到一个障碍物然后改变移动方向。然后它沿着U形障碍物找...
A*算法的讲解PPT（A算法）
05-30
A*算法是一种在图形搜索问题中寻找最优路径的启发式搜索算法，由Peter Hart、Nils Nilsson和Bertram Raphael在1968年提出。它的主要目标是在有限的计算时间内找到从起点到终点的最短路径，特别适用于静态路网中的...
A*算法Matlab实例实现
05-07
A*(A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。 本实例主要针对自动驾驶技术当中A*算法的应用现象，...
A*算法Matlab 代码
05-05
A* 算法是一种在图形搜索中广泛使用的启发式搜索策略，它的主要目标是找到从起点到终点的最短路径。在这个特定的上下文中，我们讨论的是在Matlab环境中实现A*算法来解决路径规划问题。A*算法结合了Dijkstra算法的最...
C语言实现：使用A*算法来解决15数码问题
03-26
A*算法是一种预测算法，主要用于寻路等，根据当前状态和目标状态之间的差异，预测到达目标需要多少开销，根据这个开销来判断下一次选择以那个状态开始。这个开销在八数码问题中可以以路程为标准。
基于方向约束的A*算法
01-13
实际机器人路径规划问题经常需要考虑路径的转弯约束以及路径起始/目标角要求,为此提出一种基于方向约束的A*算法.新算法区分同一路径点处不同方向的各条路径,通过定向扩展机制来满足路径方向约束,并采用节点合并策略...
【数据库技术】SQL语言基础操作示例：创建学生表、插入与查询数据入门教程
08-22
内容概要：本文档提供了一个简单的SQL语言示例，旨在帮助初学者快速掌握SQL的基本操作。示例的功能是创建一个学生表并插入数据，然后查询所有学生信息。首先，通过`CREATE TABLE`语句创建一个名为Students的表，定义了表的结构，包括id（自动递增主键）、name（非空字符串）、age（整数）和grade（字符串）四个字段。接着，利用`INSERT INTO`语句向表中插入了三条学生记录。最后，使用`SELECT * FROM`语句查询并显示了表中的所有数据。文中还简要介绍了运行这些SQL语句的方法，包括打开MySQL客户端、连接到指定数据库以及执行代码的具体步骤。 适合人群：对SQL语言感兴趣的初学者，尤其是刚开始接触数据库操作的新手。 使用场景及目标：①学习如何在SQL中创建表，定义表结构；②掌握向表中插入数据的方法；③学会使用查询语句从表中检索数据。 其他说明：此示例基于MySQL数据库，但大部分SQL语法具有通用性，适用于其他关系型数据库系统。建议读者按照文中提供的步骤，在自己的环境中实际操作，以便更好地理解和掌握SQL的基本概念和操作。
python38-pytz-2019.3-3.module_el8.5.0+742+dbad1979.tar.gz
最新发布
08-22
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
2024 年大模型面试必备宝典：全方位知识梳理与高效应试指南
08-22
资源下载链接为： https://pan.quark.cn/s/262584c7179b 在大模型蓬勃发展的当下，无论是校招还是社招，大模型相关岗位竞争愈发激烈，面试难度也不断攀升。为助力大家成功应对大模型面试，特推出《2024 大模型面试全攻略》 。 这本攻略全面且系统，从基础理论到进阶应用，从模型微调技巧到前沿技术探索，涵盖了大模型面试的各个关键领域。它不仅梳理了主流开源模型体系的特点与应用场景，如 GPT 系列、BERT、XLNet 等；还深入剖析了模型训练过程中的关键环节，像预训练与微调的流程及要点。 在面试题方面，无论是基础的 “目前主流的开源模型体系有哪些”“大模型 LLM 的架构介绍”，还是进阶的 “如何让大模型处理更长的文本”“如何缓解 LLMs 复读机问题”，亦或是微调相关的 “如果想要在某个模型基础上做全参数微调，究竟需要多少显存” 等高频问题，都能在其中找到详细解答。 此外，针对 LangChain、参数高效微调（PEFT）等热门技术，攻略也提供了丰富的面试问答与深度解析，帮助读者精准把握面试要点，提升面试成功率 。无论是初涉大模型领域的新手，还是寻求突破的资深从业者，《2024 大模型面试全攻略》都将是你求职路上的得力助手，助你在大模型面试中脱颖而出 。
python3-zxcvbn-4.4.28-2.el8.tar.gz
08-22
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
A*算法C语言源代码详解
Dijkstra算法是A*算法的一个特例，当h(n)为0时，A*算法就是Dijkstra算法。RRT算法则是一种用于解决高维空间运动规划问题的算法，特别是在机器人路径规划领域有着广泛的应用。这表明该压缩包可能是一个综合性的路径...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值