A-star算法自学

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量794 收藏 1
点赞数
文章标签： 算法 数据结构 路径规划 机器人
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxj_Mq/article/details/130383507
版权

搜索过程

广度优先搜索（BFS）算法与Dijsktra算法的结合，可以得出最短的路径。
将地图信息通过划分为方形或者其他多边形格子的方法进行表示，便于利用二维数组存放地图信息，每个格子有可行和不可行两种状态；每个方格用节点的形式表示（节点可以放置在形状内的任何位置 - 在中心或沿边缘），以便于用于任何形状的格子中的情况。
如上图所示，绿色格子为起点，红色格子为终点，蓝色格子为障碍物
如上图所示，绿色格子为起点，红色格子为终点，蓝色格子为障碍物

评价函数

移动代价
横向/纵向移动代价设为 10
对角线移动代价设为14
主要计算三个值F、G及H
F = G + H
F：从初始块经由n个块后到目标块的最小代价估计
G：表示从起点s到点n的实际成本
G(s) = G(s的父节点) + 10或14(横向移动或者纵向移动)
H：表示从节点n到目标T的估算成本（试探法）
利用曼哈顿方法计算: 计算当前方格n通过横向或者纵向移动到T的节点数 * 10
d = |x1 - x2| + |y1 - y2| * 10
欧式距离计算: 计算n与T的欧式距离

步骤(参考)

设置一个 open list（待检查列表） 及 close list（无需检查列表）

  1. 从起点开始，将其存入open list中，open list中的方格可能是路径会通过的，也可能是路径不会通过的方格。

  2. 寻找起点周围所有可以到达的节点（相邻节点），忽略障碍方格；并将这些相邻节点存入open list中并且这些节点的父节点均为起点。

  3. 从open list中将起点取出，存入 close list中，如下图所示：![[Pasted image 20230426120659.png]]图中绿色方块为起点，其边框为蓝色，表示该方块已存入close list中，并且其周围的8个方块均在open list中，且指针指向中间的绿色方块，表示父节点为绿色方块

  4. 继续遍历open list中的节点，并重复下述过程。

    1. 计算每个节点的F值，选择F值的节点n作为当前处理的节点
    2. 对于当前节点n，与其相邻的所有节点（b，c，d等）如下操作：
      1. 如果节点b是不可到达（unreachable）或者在close list中，则不进行任务操作
      2. 如果节点c不在open list中，则将其加入open list中，并将当前节点n设为c 的父代，计算节点b的F、G、H值
      3. 若节点d在open list中，则检查节点n到节点d的路径是否更优（若该路径的g值更小，则说明其更优）；若该路径更优，则将节点d的父节点（假设为e）设置为当前节点，并重新计算节点e的F、G值
    3. 将节点n存入 close list中
      在这里插入图片描述

  5. 程序运行结束条件（二者满足其一）

    1. 终点在close list中
    2. 无法找到重点，且open list为空

  6. 得到最优路径：从终点开始，每个节点沿着父节点移动，直达到达起点
    在这里插入图片描述

流程图

在这里插入图片描述

代码

A-star.h

#pragma once
#include<vector>
#include<list>

using namespace std;

const int kCost1 = 10; // 横向、纵向移动代价
const int kCost2 = 14; // 对角线移动代价

struct Point
{
	int x, y; // 点坐标，x为横，y为纵坐标
	int F, G, H; // F = G + H
	Point* parent; // 父代坐标
	Point(int _x, int _y) : x(_x), y(_y), F(0), G(0), H(0), parent(nullptr) {} // 初始
};

class Astar
{
public:
	void InitAstar(vector<vector<int>>& _maze);
	list<Point*> GetPath(Point &starPoint, Point &endPoint, bool isIgnoreCorner);
private:
	Point* findPath(Point &startPoint, Point &endPoint, bool isIgnoreCorner);
	vector<Point*> getSurrentPoints(const Point* point, bool isIgnoreCorner) const;
	bool isCanreach(const Point *point, const Point *target, bool isIgnoreCorner) const;  // 判断某点是否可以用于下一步判断
	Point *isInList(const list<Point *> &list, const Point *point) const; // 判断open_list/close_list中是否包含某点
	Point* getLeastFpoint(); // 从open_list中返回F值最小的节点

	// 计算 F G H
	int calG(Point *temp_start, Point *point);
	int calH(Point *point, Point *end);
	int calF(Point *point);

	vector<vector<int>> maze; // 存放地图的二维数组
	list<Point*> openList; // open_list 列表
	list<Point*> closeList; // close_list 列表

};

A-star.cpp

#include "A-star.h"

void Astar::InitAstar(vector<vector<int>>& _maze)
{
	maze = _maze;
}

list<Point*> Astar::GetPath(Point& starPoint, Point& endPoint, bool isIgnoreCorner)
{
	Point* res = findPath(starPoint, endPoint, isIgnoreCorner);
	list<Point*> path;
	// 返回路径
	while (res)
	{
		path.push_back(res);
		res = res->parent;
	}

	// 情况open list和close list
	openList.clear();
	closeList.clear();

	return path;
}

Point* Astar::findPath(Point& startPoint, Point& endPoint, bool isIgnoreCorner)
{
	openList.push_back(new Point(startPoint.x, startPoint.y)); // open_list中存入七点，并开辟一个新的下一个节点
	while (!openList.empty())
	{
		auto curPoint = getLeastFpoint(); // 找到最小F值的节点
		openList.remove(curPoint); // 从open list中将当前节点移出
		closeList.push_back(curPoint); // 将当前节点存入close list中
		// 1.找到当前节点相邻的可以通过的格子
		auto surroundPoints = getSurrentPoints(curPoint, isIgnoreCorner);
		for (auto& target : surroundPoints)
		{
			// 2. 对某一个格子进行判断， 若其不在open list中，则加入到open list中， 并设其为父节点 计算其 F G H值
			if (!isInList(openList, target))
			{
				target->parent = curPoint;
				target->G = calG(curPoint, target);
				target->H = calH(target, &endPoint);
				target->F = calF(target);

				openList.push_back(target);
			}
			// 3. 若其在open list中，则计算其G值并 与当前节点进行比较，若其G值大，则不进行任何操作， 否则设置它的父节点为当前节点，并更新G F 
			else
			{
				int tempG = calG(curPoint, target);
				if (tempG < target->G)
				{
					target->parent = curPoint;
					target->G = tempG;
					target->F = calF(target);
				}
			}
			Point* resPoint = isInList(openList, &endPoint);
			if (resPoint)
				return resPoint;
		}
	}
	return nullptr;
}

vector<Point*> Astar::getSurrentPoints(const Point* point, bool isIgnoreCorner) const
{
	vector<Point*> surroundPoints;
	for (int x = point->x - 1; x <= point->x + 1; ++x)
		for (int y = point->y - 1; y <= point->y; ++y)
			if (isCanreach(point, new Point(x, y), isIgnoreCorner))
				surroundPoints.push_back(new Point(x, y));
	return surroundPoints;
}

bool Astar::isCanreach(const Point* point, const Point* target, bool isIgnoreCorner) const
{
	/*if (target->x < 0 || target->x > maze.size() - 1 || target->y < 0 || target->y > maze[0].size() - 1 || maze[target->x][target->y] == 1 || target->x == point->x && target->y == point->y || isInList(closeList, target))
		return false;*/
	if (target->x<0 || target->x>maze.size() - 1
		|| target->y<0 || target->y>maze[0].size() - 1
		|| maze[target->x][target->y] == 1
		|| target->x == point->x && target->y == point->y
		|| isInList(closeList, target)) //如果点与当前节点重合、超出地图、是障碍物、或者在关闭列表中，返回false
		return false;
	else
	{
		 只有对角线才能进行搜索
		//if (abs(point->x - target->x) + abs(point->y - target->y) == 1)
		//	return true;
		//else
		//{
		//	// 对角线需要判断是否会遇到障碍
		//	if (maze[point->x][target->y] == 0 && maze[target->x][point->y] == 0)
		//		return true;
		//	else
		//		return isIgnoreCorner;
		//}
		return true;
	}
}

// 判断某个节点是否在列表中
Point* Astar::isInList(const list<Point*>& list, const Point* point) const
{
	for (auto p : list)
		if (p->x == point->x && p->y == point->y)
			return p;
	return nullptr;
}

Point* Astar::getLeastFpoint()
{
	if (!openList.empty())
	{
		auto resPoint = openList.front();
		for (auto& point : openList)
		{
			if (point->F < resPoint->F)
			{
				resPoint = point;
			}
		}
		return resPoint;
	}
	return nullptr;
}

int Astar::calG(Point* temp_start, Point* point)
{
	int extraG = (abs(point->x - temp_start->x) + abs(point->y - temp_start->y)) == 1 ? kCost1 : kCost2;
	int parentG = point->parent == nullptr ? 0 : point->parent->G; // 如果为初始点， 则其父节点为空
	return parentG + extraG;
}

int Astar::calH(Point* point, Point* end)
{
	// 根据曼哈顿算法进行计算
	return (abs(point->x - end->x) + abs(point->y - end->y)) * kCost1;

	//return sqrt((double)(end->x - point->x) * (double)(end->x - point->x) + (double)(end->y - point->y) * (double)(end->y - point->y)) * kCost1;
}

int Astar::calF(Point* point)
{
	return point->G + point->H;
}

main.cpp

#include<iostream>
#include "A-star.h"
#include "A-star2.h"

bool InPath(const int &row, const int &col, const list<Point *> &path)
{
	for (const auto& p : path)
	{
		if (row == p->x || col == p->y)
		{
			return true;
		}
	}
	return false;
}

int main()
{
	// 初始化地图，用二维矩阵代表地图，1表示障碍物，0表示可通
	vector<std::vector<int>> map = { {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
									   {1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1},
									   {1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1},
									   {1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1},
									   {1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1},
									   {1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1},
									   {1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1},
									   {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1} };

	Astar astar;
	astar.InitAstar(map);

	// 设置起点和目标点
	Point start(1, 1);
	Point end(6, 10);

	// 寻找路径
	list<Point*> path = astar.GetPath(start, end, false);

	// 打印路径
	for (auto& p : path)
	{
		cout << "(" << p->x << ", " << p->y << ")";
	}
	cout << endl;

	for (int row = 0; row < map.size(); ++row) {
		for (int col = 0; col < map[0].size(); ++col) {
			if (InPath(row, col, path)) {
				if (map[row][col] != 0) {
					cout << "e ";
				}
				else {
					cout << "* ";
				}
			}
			else {
				cout << map[row][col] << " ";
			}
		}
		cout << endl;
	}

}

参考链接：
https://www.gamedev.net/reference/articles/article2003.asp
https://blog.csdn.net/A_L_A_N/article/details/81392212
https://zhuanlan.zhihu.com/p/590786438

Xxwl.
关注
大厂速成算法笔记，Github上已收获近60K+star！力压LeetCode只为面试
2401_83916283的博客
04-20 944
(img-leHoUQwX-1713626768728)](img-JygCsEgq-1713626768729)]讲真，刷算法要是没有套路章法，连笔试都过不去，关于 Linux shell 你必须知道的。团灭LeetCode股票买卖问题。团灭LeetCode打家劫舍问题。回溯算法团灭子集、排列、组合问题。如何同时寻找缺失和重复的元素。如何在无限序列中随机抽取元素。Union-Find算法详解。Union-Find算法应用。如何计算完全二叉树的节点数。如何去除有序数组的重复元素。
A_star算法C++程序
楼下滴小丑
10-15 515
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 ...
图论经典A-Star(A*) Algorithm最短路径，networkx，Python（1）
Zhang Phil
04-16 1306
运行代码，跑几轮，看看程序选的路线如何。此时查找open_list中所有节点的具有最小F值的节点 V' （此处是 V' 撇，不是 V，表示V选好后，进行第二轮选点的那个节点），V' 选出来后，再次把 V' 所有相邻的节点加入到open_list中，同时把 V' 从open_list中删掉，并把V' 加入到close_list中去。逆向的从终点开始，找出终点保存的父节点指向谁，然后逆向，然后再找到终点的父节点的父节点......，一路逆行查找，直到查找到父节点为出发点为止，即为A*选出来的路径。
A-Star算法探索和实现（五）
我与岁月的森林的博客
01-30 898
本篇内容围绕A*（A星或A-Star）算法中的权值计算和路径查找方式的改进进行探索和实现
Matlab 数值计算----二分法求非线性方程组
汉南最後の読書人
04-09 8368
bisect.m函数（二分法的实现算法） function[x_star,index,it]=bisect(fun,a,b) %求解非线性计算方程的二分法，其中，fun(x)为需要求根的函数; %a,b为初始区间的端点; %ep为精度，当(b-a)/2<ep时，算法能终止计算， %缺省值为1e-5; %当x_star迭代成功时，输出方程的根 %当x_start迭代失败时，输出两端点的值； %in
star算法
chencunheng的专栏
04-25 528
A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。 公式表示为： f(n)=g(n)+h(n), 其中f(n) 是节点n从初始点到目标点的估价函数， g(n) 是在状态空间中从初始节点到n节点的实际代价， h(n)是从n到目标节点最佳路径的估计代价。 保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取： 估价值h(n)实际值, 搜索的...
探索未来对话的奥秘：安静的思考者 - Quiet-STaR
gitblog_00024的博客
05-30 722
探索未来对话的奥秘：安静的思考者 - Quiet-STaR quiet-star项目地址:https://gitcode.com/gh_mirrors/qu/quiet-star 在当今人工智能的快速发展中，语言模型已成为我们与机器交流的核心桥梁。今天，我们要向大家隆重推介一个令人兴奋的开源项目——Quiet-STaR，它不仅是一个技术上的创新之作，更是对传统语言处理模式的一次重大突破。通过阅读...
大话数据结构--算法概述
ehehhahs的博客
04-21 996
至此，文章终于到了尾声。技术能力：先写岗位所需能力，再写加分能力，不要写无关能力；项目经历：只写明星项目，描述遵循 STAR 法则；简历印象：简历遵循三大原则：清晰，简短，必要，要有的放矢，不要海投；以及最后为大家准备的福利时间：简历模板+Java面试题+热门技术系列教程视频《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！讲解视频，并且会持续更新！**如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）至此，文章终于到了尾声。
swift-algorithm-club-cn:swift-algorithm-club的翻译。使用Swift学习算法和数据结构
05-28
当然也欢迎加:star:，:star-struck::star-struck::star-struck::face_with_raised_eyebrow::zany_face:。 以下是原项目的README.markdown翻译(:hourglass_not_done:表示还未翻译) 欢迎来到Swift算法俱乐部！ 在这里...
刷leetcode不用stl-Algorithms-in-4-Steps:四步算法
06-30
还是自学算法竞赛； 或者单纯的课外拓展； 不管你算法能力如何，这个仓库里总有适合你的算法学习内容！ 如果对你有所帮助，请 star:sparkles: 支持一下 出乎意料进了GitHub Trending，这是对我很大的鼓励！ Let`s ...
【Godot4自学手册】源代码，第十四节完善敌人功能-追击、攻击
02-20
A*（A-star）算法是一种常用的寻路方法，它可以在导航网格上快速计算出最短路径。 9. **反馈系统**：为了增强游戏体验，敌人追击和攻击时应有视觉和听觉反馈。这可能包括动画、音效以及特效，它们都需要通过Godot的...
Unity游戏开发客户端面经——算法（初级）
热门推荐
Sea3752的博客
10-27 1万+
Unity游戏开发客户端面经之算法篇
A Star算法总结与实现（附Demo)
qq_29261149的博客
08-03 2925
关于A Star Algorithm A star算法最早可追溯到1968年，在IEEE Transactions on Systems Science and Cybernetics中的一篇A Formal Basis for the Heuristic Determination of Minimum Cost Paths，是把启发式方法（heuristic approaches）如BFS，和常规方法如Dijsktra算法结合在一起的算法。有点不同的是，类似BFS的启发式方法经常给出一个近似解而不是保证
34. 在排序数组中查找元素的第一个和最后一个位置
weixin_61695887的博客
10-12 491
请你找出给定目标值在数组中的开始位置和结束位置。给你一个按照非递减顺序排列的整数数组。你必须设计并实现时间复杂度为。如果数组中不存在目标值。
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 796
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 131
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 353
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
【优选算法】（第四十二篇）
weixin_73861555的博客
10-15 771
输⼊：beginWord="hit",endWord="cog",wordList=["hot","dot","dog","lot","log","cog"]输出：5。输⼊：beginWord="hit",endWord="cog",wordList=["hot","dot","dog","lot","log"]输出：0。解释：⼀个最短转换序列是"hit"->"hot"->"dot"->"dog"->"cog",返回它的⻓度5。解释：endWord"cog"不在字典中，所以⽆法进⾏转换。
【鸟类识别系统】Python+卷积神经网络算法+人工智能+深度学习+ResNet50算法+计算机课设项目
子午的博客
10-12 858
鸟类识别系统。本系统采用Python作为主要开发语言，通过使用加利福利亚大学开源的200种鸟类图像作为数据集。使用TensorFlow搭建ResNet50卷积神经网络算法模型，然后进行模型的迭代训练，得到一个识别精度较高的模型，然后在保存为本地的H5格式文件。在使用Django开发Web网页端操作界面，实现用户上传一张鸟类图像，识别其名称。本项目通过人工智能技术实现对鸟类图像的自动识别，满足用户在日常生活中快速、准确地识别鸟类的需求。
matlab实现a-star算法
11-17
A-star算法是一种常用的图搜索算法，可以用于解决路径规划等问题。在Matlab中实现A-star算法主要包括以下几个步骤： 1. 定义地图和节点：首先需要定义地图，包括障碍物的位置和起点终点等信息。然后，将地图抽象成...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Xxwl.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值