A*算法

最新推荐文章于 2022-09-19 20:50:19 发布
最新推荐文章于 2022-09-19 20:50:19 发布
阅读量96 收藏
点赞数
分类专栏： 笔记 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45976950/article/details/108791606
版权

Astar.cpp

#include<math.h>
#include"Astar.h"
#include<iostream>
#include<vector>


static int *maze;	//迷宫对应的二维数组，用一级指针表示
static int cols;	//二维数组对应的列数
static int lines;	//二维数组对应的行数

static list<Point *> openlList;		//开放列表
static list<Point *> closeList;	//关闭列表


/*搜索从起点到终点的最佳路径*/
static Point* findPath(Point *startPoint, Point *endPoint);

/*从开启列表中返回F值最小的节点*/
static Point *getLeastFpoint();

/*获取当前点周围可达的节点*/
static vector<Point *> getSurroundPoints(const Point *point);

/*判断某点是否可以用于下一判断*/
static bool isCanreach(const Point *point, const Point *target);

/*判断开放/关闭列表中是否包含某点*/
static Point *isInList(const list<Point *> &list, const Point *point);

/*计算FGH值*/
static int calcG(Point *temp_start, Point *point);
static int calcH(Point *point, Point *end);
static int calcF(Point *point);


/*分配一个节点（格子）*/
Point* AllocPoint(int x, int y)
{
	Point *temp = new Point;

	memset(temp, 0, sizeof(Point));//初始化清零

	temp->x = x;
	temp->y = y;
	return temp;
}


/*初始化A*搜索的地图*/
void InitAstarMaze(int *_maze, int _lines, int _colums)
{
	maze = _maze;
	lines = _lines;
	cols = _colums;
}

/*通过A*算法寻找路径*/
list<Point *> GetPath(Point *startPoint, Point *endPoint)
{
	Point *result = findPath(startPoint, endPoint);

	list<Point *> path;

	//返回路径，如果没有找到路径，返回空链表
	while (result)
	{
		path.push_front(result);
		result = result->parent;
	}

	return path;
}

/*搜索从起点到终点的最佳路径*/
static Point* findPath(Point *startPoint, Point *endPoint)
{
	openlList.push_back(AllocPoint(startPoint->x,startPoint->y));//置入起点，拷贝开辟一个节点，内外隔离

	while (!openlList.empty())
	{
		//第一步，从开放列表中取最小F的节点
		Point *curPoint = getLeastFpoint();	//找到F值最小的点

		//第二步，把当前节点放到关闭列表中
		openlList.remove(curPoint);
		closeList.push_back(curPoint);

		//第三步，找到当前节点周围可达的节点，并计算F值
		vector<Point *> surroundPoints = getSurroundPoints(curPoint);

		vector<Point *>::const_iterator iter;
		for (iter = surroundPoints.begin(); iter != surroundPoints.end(); iter++)
		{
			Point *target = *iter;

			//对某一个格子，如果它不在开放列表中，加入到开放列表，设置当前格为父节点，计算F G H
			Point *exist = isInList(openlList, target);

			if (!exist)
			{
				target->parent = curPoint;

				target->G = calcG(curPoint, target);
				target->H = calcH(target, endPoint);
				target->F = calcF(target);

				openlList.push_back(target);
			}
			else
			{
				int tempG = calcG(curPoint, target);
				if (tempG < target->G)
				{
					exist->parent = curPoint;
					exist->G = tempG;
					exist->F = calcF(target);
				}

				delete target;
			}
		}//end for
		surroundPoints.clear();

		Point *resPoint = isInList(openlList, endPoint);
		if (resPoint)
		{
			return resPoint;
		}
	}
	return NULL;
}

/*从开启列表中返回F值最小的节点*/
static Point *getLeastFpoint()
{
	if (!openlList.empty())
	{
		Point *resPoint = openlList.front();

		list<Point *>::const_iterator itor;
		for (itor = openlList.begin(); itor != openlList.end(); itor++)
		{
			if ((*itor)->F < resPoint->F)
			{
				resPoint = *itor;
			}
		}
		return resPoint;
	}
	return NULL;
}

/*获取当前点周围可达的节点*/
static vector<Point *> getSurroundPoints(const Point *point)
{
	vector<Point *> surroundPoints;

	for (int x = point->x - 1; x < point->x + 1; x++)
	{
		for (int y = point->y - 1; y < point->y + 1; y++)
		{
			Point *temp = AllocPoint(x, y);
			if (isCanreach(point, temp))
			{
				surroundPoints.push_back(temp);
			}
			else
			{
				delete temp;
			}
		}
	}
	return surroundPoints;
}

/*判断某点是否可以用于下一判断*/
static bool isCanreach(const Point *point, const Point *target)
{
	if (target->x<0 || target->x>(lines - 1)		//行不能越界
		|| target->y<0 || target->y>(cols - 1)		//列不能越界
		|| maze[target->x*cols + target->y] == 1	//判断当前格子是否为障碍
		|| maze[target->x*cols + target->y] == 2	//判断当前格子是否为障碍
		|| (target->x == point->x &&target->y == point->y)	//不能跟当前点重叠
		|| isInList(closeList, target))	//判断是否在封闭列表里面
	{
		return false;
	}

	if ((abs(point->x - target->x) + abs(point->y - target->y)) == 1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

/*判断开放/关闭列表中是否包含某点*/
static Point *isInList(const std::list<Point *> &list, const Point *point)
{
	//判断某个节点是否在列表中，这里不能比较指针，因为每次加入列表是新开辟的节点，只能比较坐标
	std::list<Point *>::const_iterator itor;
	for (itor = list.begin(); itor != list.end(); itor++)
	{
		if ((*itor)->x == point->x && (*itor)->y == point->y)
		{
			return *itor;
		}
	}
	return NULL;
}

/*计算FGH值*/
static int calcG(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 == NULL ? NULL : point->parent->G);

	return parentG + extraG;
}
static int calcH(Point *point, Point *end)
{
	//用简单的欧几里得距离计算H
	return (int)sqrt((double)(end->x - point->x)*(double)(end->x - point->x) + (double)(end->y - point->y)*(double)(end->y - point->y))*kCost1;
}
static int calcF(Point *point)
{
	return point->G + point->H;
}

/*清理资源，结束后必须调用*/
void ClearAstarMaze()
{
	maze = NULL;
	lines = 0;
	cols = 0;

	list<Point *>::iterator itor;

	//清除openList 中的元素
	for (itor = openlList.begin(); itor != openlList.end();)
	{
		delete *itor;
		itor = openlList.erase(itor);//获取下一个节点
	}

	//清理closeList 中的元素
	for (itor = closeList.begin(); itor != closeList.end();)
	{
		delete *itor;
		itor = closeList.erase(itor);//获取下一个节点
	}
}

Astar.h

#pragma once

#include<list>

using namespace std;

const int kCost1 = 10;//直移一格消耗
const int kCost2 = 12;//斜移一格消耗

typedef struct _Point
{
	int x, y;		//点坐标
	int F, G, H;	//F=G+H
	struct _Point *parent;	//parent的坐标
}Point;


/*分配一个节点*/
Point* AllocPoint(int x, int y);

/*初始化地图*/
void InitAstarMaze(int *_maze, int _lines, int _colums);

/*通过A*算法寻找路径*/
list<Point *> GetPath(Point *startPoint, Point *endPoint);

/*清理资源，结束后必须调用*/
void ClearAstarMaze();

main.cpp

#include"Astar.h"
#include<iostream>
#include<list>
#include<Windows.h>

using namespace std;

//定义地图数组
int map[13][13] =
{
	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
	{0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,},
	{0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,},
	{0, 1, 0, 1, 0, 1, 2, 1, 0, 1, 0, 1, 0,},
	{0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,},
	{0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0,},
	{0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0,},
	{2, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 2,},
	{0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0,},
	{0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,},
	{0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,},
	{0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,},
	{0, 0, 0, 0, 0, 1, 3, 1, 0, 0, 0, 0, 0,},
};


void AStarTest()
{
	InitAstarMaze(&map[0][0], 13, 13);

	//设置起始和结束点
	Point* start = AllocPoint(12, 4);
	Point* end = AllocPoint(0, 0);

	//A*算法找寻路径
	list<Point *> path = GetPath(start, end);

	cout << "寻路结果：" << endl;

	list<Point *>::const_iterator iter;
	for (iter = path.begin(); iter != path.end(); iter++)
	{
		Point *cur = *iter;
		cout << '(' << cur->x << ',' << cur->y << ')' << endl;

		Sleep(800);
	}

	ClearAstarMaze();
}


int main()
{
	AStarTest();

	system("pause");
	return 0;
}
nI丶唯一
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
路径规划 | 详解混合A*算法Hybrid A*(附ROS C++/Python/Matlab仿真)
FRIGIDWINTER的博客
04-29 7621
Hybrid A*算法通过结合连续状态空间搜索、运动约束考虑和轨迹优化等技术，弥补了普通A*算法在高维连续空间和的不足，提高了路径规划的效率和鲁棒性，广泛应用于车规级路径规划。本文详细图解Hybrid A*算法的原理——启发式、维诺耗散项、节点扩展法则等，并给出ROS C++、python、matlab三种语言的仿真实现加深理解
A*算法自学心得
XiangEZ的博客
04-30 2505
这里写自定义目录标题1.1 概述1.2 算法类比1.3 新增算法与优缺点对比1.4 BFS算法问题的出现 1.1 概述 这是一个寻径算法 相信同学们都玩过某种游戏LOL人在塔在！！！ ，在你用鼠标点击地面的某个地方的时候，你所操控的人物会十分智能地寻找一条最短的路前进到你所指定的位置，不论范围大小，这种算法都很快。 1.2 算法类比 看完这样一个功能，似乎实现起来很简单 似乎我们也可以...
A*算法（C++实现）
A_L_A_N
08-03 3万+
简易地图 如图所示简易地图, 其中绿色方块的是起点 (用 A 表示), 中间蓝色的是障碍物, 红色的方块 (用 B 表示) 是目的地. 为了可以用一个二维数组来表示地图, 我们将地图划分成一个个的小方块. 二维数组在游戏中的应用是很多的, 比如贪吃蛇和俄罗斯方块基本原理就是移动方块而已. 而大型游戏的地图, 则是将各种"地貌"铺在这样的小方块上. 寻路步骤 1. 从起点A开始, 把它作...
A*算法（超级详细讲解，附有举例的详细手写步骤）
热门推荐
dujuancao11的博客
11-17 12万+
背景：项目需要接触此算法，以下是一些自学成果，如有不足之处，欢迎指出，必虚心接受。做了一份PPT来汇报，此处直接使用自己PPT的截图。部分图片来源网络，如有侵权立马删除，以下博文仅作为学习笔记。 目录 A*寻路算法 A*算法解决什么问题 A*算法的基本原理 A*算法的详细原理 A*算法的详细原理之定义 ​A*算法的详细原理之初始设定 ​A*算法的详细原理之寻路原理 A*算法的详细原理之结束条件 A*算法的寻路详细步骤 A*算法的举例说明 A*算法的伪代码 A*算法的定义伪....
【人工智能实验】A*算法求解8数码问题
weixin_43442778的博客
03-21 10万+
1、画出A*算法求解N数码问题的流程图。根据A*算法的实验原理，；这样估价函数f(n)在g(n)一定的情况下，会或多或少的受距离估计值h(n)的制约，节点距目标点近，h值小，f值相对就小，能保证最短路的搜索向终点的方向进行,因此f是根据需要找到一条最小代价路径的观点来估算节点的。设计A*算法的流程图如图4.1.1所示，按照流程图编写伪代码，进而编写完整的程序。其中OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。
A*算法图解
weixin_43757333的博客
04-26 2万+
A*（A-star）算法是一种静态网路中求解最短路径最有效的直接搜索算法。在电子游戏中最主要的应用是寻找地图上两点间的最佳路线。在机器人领域中，A*算法常用于移动机器人路径规划。 为了便于理解，本文将以正方形网格地图为例进行讲解。如图，蓝色格子是障碍物，灰色格子是可通过区域，绿色格子是起点（S），红色格子是终点（D）。我们要做的是找到一条从起点到终点的最佳路线。 为了顺利地解决问题，我们先要设定一些约束条件： 1.从一个格子可以朝周围 8 个方向移动。其中朝上、下、左、右移动的成本为 1，朝.
详细介绍用MATLAB实现基于A*算法的路径规划（附完整的代码，代码逐行进行解释）（一）--------A*算法简介和环境的创建
慕羽★的博客
10-01 6万+
   本系列文章主要介绍基于A*算法的路径规划的实现，并使用MATLAB进行仿真演示。    一、 A*算法简介       A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。      公式表示为： f(n)=g(n)+h(n),其中， f(n) 是从初始状态经由状态n到目标状态的代价估计，g(n) 是在状态空间中从初始状态到状态n的实际代价，h(n) 是从状态n到目标状态的最佳路径的估计代价。
A算法与A*算法
weixin_45102820的博客
09-19 7848
对于A算法，他是使用了一个评价函数f(n)=g(n)+h(n)，g(n)表示从起点到当前点的代价，h(n)表示预估代价，就是从当前点到终点的代价，每次选取当前f(n)最小的进行扩展。在平常的搜索算法中，BFS和DFS算是盲目搜索，BFS搜索从a到b的最短路径，会从自己各个方向依次扩展，效率低下，因此出现了启发式搜索，A算法和A*算法。(n)，对h(n)进行了限制，是优化版的A算法。算法则是对A算法进行了优化，让h(n)≤h。
【路径规划】全局路径规划算法——A*算法（含python实现 | c++实现）
weixin_42301220的博客
06-06 3万+
A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。广泛应用于室内机器人路径搜索、游戏动画路径搜索等A*算法结合了贪心算法（深度优先）和Dijkstra算法（广度优先），是一种启发式搜索算法。它使用一个路径优劣评价公式为： f(n)=g(n)+h(n) f(n)=g(n)+h(n) f(n)=g(n)+h(n)A*算法需要维护两个状态表，分别称为表和表。表由待考察的节点组成， 表由已经考察过的节点组成。如图，假设我们需要从点到目标点，这两点之间有一堵墙。
A*算法 matlab版
11-21
A*算法，动态路径规划算法的一种，程序直接放到matlab即可运行。
A*算法Matlab 代码
05-05
A* 算法是一种在图形搜索中广泛使用的启发式搜索策略，它的主要目标是找到从起点到终点的最短路径。在这个特定的上下文中，我们讨论的是在Matlab环境中实现A*算法来解决路径规划问题。A*算法结合了Dijkstra算法的最...
A*算法Matlab实例实现
05-07
A*(A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。 本实例主要针对自动驾驶技术当中A*算法的应用现象，...
A*算法的讲解PPT（A算法）
最新发布
05-30
A*算法是一种在图形搜索问题中寻找最优路径的启发式搜索算法，由Peter Hart、Nils Nilsson和Bertram Raphael在1968年提出。它的主要目标是在有限的计算时间内找到从起点到终点的最短路径，特别适用于静态路网中的...
A*算法学习（python代码实现）
05-17
A*算法是一种在图形搜索中用于寻找从起点到终点最短路径的有效算法，它结合了Dijkstra算法的全局最优性和Greedy最佳优先搜索算法的效率。A*算法的核心在于引入了启发式函数，使得搜索更加高效，能够在大量可能的路径...
数据结构c++代码实现
qq_45976950的博客
09-25 2974
顺序表 #include<iostream> #include<string> using namespace std; //#define MAX_SIZE 100 // //typedef struct //{ // int *elems; //顺序表的基地址 // int length; //长度 // int size; //总空间大小 //}SqList; template <typename T> class SqList { public:
五大核心算法
qq_45976950的博客
09-25 2805
动态规划算法 #include<iostream> using namespace std; /*递归实现机器人台阶走法统计 参数： n - 台阶个数 返回：上台阶总的走法 f(n) = f(n-1) + f(n-2); */ //分治算法 int WalkCount1(int n) { if (n < 0) return 0; if (n == 1) return 1; //一级台阶，一种走法 else if (n == 2) return 2; //二级台阶，两种
C++学习笔记：利用虚函数面积计算
qq_45976950的博客
02-10 528
抽象基类 Shape.h #pragma once class Shape { public: virtual void shapeName()const = 0; //定义两个纯虚函数 virtual void printArea()const = 0; //输出面积 }; 圆形 Circle.h #pragma once #include "Shape.h" #include&l...
C++：函数对象-内建函数
qq_45976950的博客
04-29 484
逻辑仿函数 #include<iostream> #include<functional> #include<vector> #include<algorithm> using namespace std; //逻辑非 logical_not void test01() { vector<bool>v; v.push_bac...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值