A*搜索

最新推荐文章于 2023-02-16 21:53:47 发布
最新推荐文章于 2023-02-16 21:53:47 发布
阅读量496 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shi_zyb/article/details/44812965
版权

又是最重要的32个算法之一。是一种静态路网中求解最短路最有效的直接搜索方法。后面还有更多改进的算法。


和其它的图搜索算法一样，A*潜在地搜索图中一个很大的区域。和Dijkstra一样，A*能用于搜索最短路径。和BFS（Best-First-Search而非Breadth-First-Search）一样，A*能用启发式函数引导它自己。在简单的情况中，它和BFS一样快。1968年发明的A*算法就是把启发式方法（heuristic approaches）如BFS，和常规方法如Dijsktra算法结合在一起的算法。有点不同的是，类似BFS的启发式方法经常给出一个近似解而不是保证最佳解。比较神奇的是，尽管A*基于无法保证最佳解的启发式方法，A*却能保证找到一条最短路径。
成功的秘决在于，它把Dijkstra算法（靠近初始点的结点）和BFS算法（靠近目标点的结点）的信息块结合起来。在讨论A*的标准术语中，g(n)表示从初始结点到任意结点n的代价，h(n)表示从结点n到目标点的启发式评估代价（heuristic estimated cost）。当从初始点向目标点移动时，A*权衡这两者。每次进行主循环时，它检查f(n)最小的结点n，其中f(n) = g(n) + h(n)。


启发式函数h(n)决定了A*算法从任意结点n到目标结点的最小代价评估值。这个函数可以控制A*的行为：

  • 一种极端情况，如果h(n)是0，则只有g(n)起作用，此时A*演变成Dijkstra算法，这保证能找到最短路径。
  • 如果h(n)经常都比从n移动到目标的实际代价小（或者相等），则A*保证能找到一条最短路径。h(n)越小，A*扩展的结点越多，运行就得越慢。
  • 如果h(n)精确地等于从n移动到目标的代价，则A*将会仅仅寻找最佳路径而不扩展别的任何结点，这会运行得非常快。尽管这不可能在所有情况下发生，你仍可以在一些特殊情况下让它们精确地相等（译者：指让h(n)精确地等于实际值）。只要提供完美的信息，A*会运行得很完美，认识这一点很好。
  • 如果h(n)有时比从n移动到目标的实际代价高，则A*不能保证找到一条最短路径，但它运行得更快。
  • 另一种极端情况，如果h(n)比g(n)大很多，则只有h(n)起作用，A*演变成BFS算法。
接下来搞个代码看看，例如游戏寻路A*算法： 

<span style="font-size:18px;">/*
	A star 算法的基础处理
*/
#ifndef _A_STAR_BASE_H_
#define _A_STAR_BASE_H_
#include "windows.h"

typedef struct _APoint{
	int x; // x 坐标
	int y; // y 坐标
	int type; // 类型
	int f; // f = g + h
	int g; 
	int h;
} APoint,*PAPoint;

enum APointType{
	APT_UNKNOWN, // 未知状态
	APT_OPENED, // 开放列表中
	APT_CLOSED, // 关闭列表中
	APT_STARTPOINT, // 起始点
	APT_ENDPOINT // 结束点
};


class CAStarBase{
public:
	CAStarBase();
	~CAStarBase();
private:
	PAPoint m_pAPointArr;
	int m_nAPointArrWidth;
	int m_nAPointArrHeight;

	PAPoint m_pStartPoint,m_pEndPoint,m_pCurPoint;
	char* m_pOldArr;
public:
	BOOL Create(char* pDateArr,int nWidth,int nHeight);
	void SetStartPoint(int x,int y);
	void SetEndPoint(int x,int y);
	void SetOpened(int x,int y);
	void SetClosed(int x,int y);
	void SetCurrent( int x,int y );
	void PrintCharArr();

	PAPoint CalcNextPoint(PAPoint ptCalc); // 应用迭代的办法进行查询
};

#endif
</span>

 
<span style="font-size:18px;">#include "stdafx.h"
#include "AStarBase.h"


CAStarBase::CAStarBase()
{
	m_pAPointArr = NULL;
	m_nAPointArrWidth = 0;
	m_nAPointArrHeight = 0;

	m_pStartPoint = NULL;
	m_pEndPoint = NULL;
	m_pCurPoint = NULL;

}

CAStarBase::~CAStarBase()
{

}

BOOL CAStarBase::Create( char* pDateArr,int nWidth,int nHeight )
{
	if(!pDateArr) return FALSE;
	if(nWidth<1 || nHeight<1) return FALSE;
	m_pAPointArr = new APoint[nWidth*nHeight];
	if(!m_pAPointArr) return FALSE;
	m_pOldArr = pDateArr;
	m_nAPointArrWidth = nWidth;
	m_nAPointArrHeight = nHeight;
	// 初始化数组内容
	for ( int y = 0;y<m_nAPointArrHeight;y++)
	{
		for ( int x=0;x<m_nAPointArrWidth;x++)
		{
			m_pAPointArr[y*m_nAPointArrWidth+x].x = x;
			m_pAPointArr[y*m_nAPointArrWidth+x].y = y;
			m_pAPointArr[y*m_nAPointArrWidth+x].g = 0;
			m_pAPointArr[y*m_nAPointArrWidth+x].f = 0;
			m_pAPointArr[y*m_nAPointArrWidth+x].h = 0;

			if ( pDateArr[y*m_nAPointArrWidth+x] == '0')
			{
				m_pAPointArr[y*m_nAPointArrWidth+x].type = APT_OPENED;
			}else if ( pDateArr[y*m_nAPointArrWidth+x] == '1')
			{
				m_pAPointArr[y*m_nAPointArrWidth+x].type = APT_CLOSED;
			}else if ( pDateArr[y*m_nAPointArrWidth+x] == 'S')
			{
				m_pAPointArr[y*m_nAPointArrWidth+x].type = APT_STARTPOINT;
				m_pStartPoint = m_pAPointArr + y*m_nAPointArrWidth+x;
				m_pCurPoint = m_pStartPoint;
			}else if ( pDateArr[y*m_nAPointArrWidth+x] == 'E')
			{
				m_pAPointArr[y*m_nAPointArrWidth+x].type = APT_ENDPOINT;
				m_pEndPoint = m_pAPointArr + y*m_nAPointArrWidth+x;
			}else{
				m_pAPointArr[y*m_nAPointArrWidth+x].type = APT_UNKNOWN;
			}

		}
	}
	return TRUE;
}

void CAStarBase::SetStartPoint( int x,int y )
{
	if ( m_pStartPoint && m_pAPointArr[y*m_nAPointArrWidth+x].type!=APT_CLOSED )
	{
		m_pStartPoint->type = APT_OPENED;
		// 设置新的值
		m_pStartPoint = m_pAPointArr + y*m_nAPointArrWidth+x;
		m_pStartPoint->type = APT_STARTPOINT;
		m_pCurPoint = m_pStartPoint;
	}
}

void CAStarBase::SetEndPoint( int x,int y )
{
	if ( m_pStartPoint && m_pAPointArr[y*m_nAPointArrWidth+x].type!=APT_CLOSED )
	{
		m_pStartPoint->type = APT_OPENED;
		// 设置新的值
		m_pStartPoint = m_pAPointArr + y*m_nAPointArrWidth+x;
		m_pStartPoint->type = APT_ENDPOINT;
	}
}

void CAStarBase::SetCurrent( int x,int y )
{
//	if ( m_pAPointArr[y*m_nAPointArrWidth+x].type==APT_OPENED )
	{
		m_pCurPoint = m_pAPointArr+y*m_nAPointArrWidth+x;
	}
}

void CAStarBase::SetOpened( int x,int y )
{
	if ( m_pAPointArr[y*m_nAPointArrWidth+x].type!=APT_OPENED )
	{
		m_pAPointArr[y*m_nAPointArrWidth+x].type = APT_OPENED;
	}
}

void CAStarBase::SetClosed( int x,int y )
{
	if ( m_pAPointArr[y*m_nAPointArrWidth+x].type!=APT_CLOSED )
	{
		m_pAPointArr[y*m_nAPointArrWidth+x].type = APT_CLOSED;
	}
}

void CAStarBase::PrintCharArr()
{
	if ( m_pOldArr )
	{
		for ( int y=0; y<m_nAPointArrHeight;y++)
		{
			for ( int x=0;x<m_nAPointArrWidth;x++)
			{
				printf("%c ",m_pOldArr[x+m_nAPointArrWidth*y]);
			}
			printf("\r\n");
		}
		printf("\r\n");
	}
}

PAPoint CAStarBase::CalcNextPoint( PAPoint ptCalc )
{
	if ( ptCalc == NULL )
	{
		ptCalc = m_pStartPoint;
	}
	int x = ptCalc->x;
	int y = ptCalc->y;
	int dx = m_pEndPoint->x;
	int dy = m_pEndPoint->y;
	int xmin = x,ymin = y,vmin = 0; // 最优步骤的坐标和值
	// 判断是否已经到了最终的位置
	if ( (x==dx && abs(y-dy)==1) || (y==dy && abs(x-dx)==1) )
	{
		return m_pEndPoint;
	}
	// 上
	if ( m_pAPointArr[(x+0)+m_nAPointArrWidth*(y-1)].type == APT_OPENED && y>0)
	{
		m_pAPointArr[(x+0)+m_nAPointArrWidth*(y-1)].g = 10;
		m_pAPointArr[(x+0)+m_nAPointArrWidth*(y-1)].h = 
			10*(abs(x - dx) + abs(y-1 - dy));
		m_pAPointArr[(x+0)+m_nAPointArrWidth*(y-1)].f = 
			m_pAPointArr[(x+0)+m_nAPointArrWidth*(y-1)].g + m_pAPointArr[(x+0)+m_nAPointArrWidth*(y-1)].h;
		if ( vmin==0 )
		{
			xmin = x;
			ymin = y-1;
			vmin = m_pAPointArr[(x+0)+m_nAPointArrWidth*(y-1)].f;
		}else{
			if ( vmin > m_pAPointArr[(x+0)+m_nAPointArrWidth*(y-1)].f )
			{
				xmin = x;
				ymin = y-1;
				vmin = m_pAPointArr[(x+0)+m_nAPointArrWidth*(y-1)].f;
			}
		}
	}
	// 下
	if ( m_pAPointArr[(x+0)+m_nAPointArrWidth*(y+1)].type == APT_OPENED && y<m_nAPointArrHeight)
	{
		m_pAPointArr[(x+0)+m_nAPointArrWidth*(y+1)].g = 10;
		m_pAPointArr[(x+0)+m_nAPointArrWidth*(y+1)].h = 
			10*(abs(x - dx) + abs(y+1 - dy));
		m_pAPointArr[(x+0)+m_nAPointArrWidth*(y+1)].f = 
			m_pAPointArr[(x+0)+m_nAPointArrWidth*(y+1)].g + m_pAPointArr[(x+0)+m_nAPointArrWidth*(y+1)].h;
		if ( vmin==0 )
		{
			xmin = x;
			ymin = y+1;
			vmin = m_pAPointArr[(x+0)+m_nAPointArrWidth*(y+1)].f;
		}else{
			if ( vmin > m_pAPointArr[(x+0)+m_nAPointArrWidth*(y+1)].f )
			{
				xmin = x;
				ymin = y+1;
				vmin = m_pAPointArr[(x+0)+m_nAPointArrWidth*(y+1)].f;
			}
		}
	}
	// 左
	if ( m_pAPointArr[(x-1)+m_nAPointArrWidth*y].type == APT_OPENED && x>0)
	{
		m_pAPointArr[(x-1)+m_nAPointArrWidth*y].g = 10;
		m_pAPointArr[(x-1)+m_nAPointArrWidth*y].h = 
			10*(abs(x-1 - dx) + abs(y - dy));
		m_pAPointArr[(x-1)+m_nAPointArrWidth*y].f = 
			m_pAPointArr[(x-1)+m_nAPointArrWidth*y].g + m_pAPointArr[(x-1)+m_nAPointArrWidth*y].h;
		if ( vmin==0 )
		{
			xmin = x-1;
			ymin = y;
			vmin = m_pAPointArr[(x-1)+m_nAPointArrWidth*y].f;
		}else{
			if ( vmin > m_pAPointArr[(x-1)+m_nAPointArrWidth*y].f )
			{
				xmin = x-1;
				ymin = y;
				vmin = m_pAPointArr[(x-1)+m_nAPointArrWidth*y].f;
			}
		}
	}
	// 右
	if ( m_pAPointArr[(x+1)+m_nAPointArrWidth*y].type == APT_OPENED && x<m_nAPointArrWidth)
	{
		m_pAPointArr[(x+1)+m_nAPointArrWidth*y].g = 10;
		m_pAPointArr[(x+1)+m_nAPointArrWidth*y].h = 
			10*(abs(x+1 - dx) + abs(y - dy));
		m_pAPointArr[(x+1)+m_nAPointArrWidth*y].f = 
			m_pAPointArr[(x+1)+m_nAPointArrWidth*y].g + m_pAPointArr[(x+1)+m_nAPointArrWidth*y].h;
		if ( vmin==0 )
		{
			xmin = x+1;
			ymin = y;
			vmin = m_pAPointArr[(x+1)+m_nAPointArrWidth*y].f;
		}else{
			if ( vmin > m_pAPointArr[(x+1)+m_nAPointArrWidth*y].f )
			{
				xmin = x+1;
				ymin = y;
				vmin = m_pAPointArr[(x+1)+m_nAPointArrWidth*y].f;
			}
		}
	}

	// 如果有最优点则迭代，则否就返回NULL
	if ( vmin )
	{
		SetCurrent(xmin,ymin);
		SetClosed(xmin,ymin);
		*(m_pOldArr+xmin+m_nAPointArrWidth*ymin) = '-';
		PrintCharArr();
		PAPoint pApoint = CalcNextPoint(m_pCurPoint);
		if ( pApoint == NULL )
		{
			SetCurrent(x,y);
			SetClosed(xmin,ymin);
			*(m_pOldArr+xmin+m_nAPointArrWidth*ymin) = '0';
			return CalcNextPoint(m_pCurPoint);
		}
		return pApoint;
	}else{
		return NULL;
	}

}
</span>

看看上面的代码，算法的伪程序如下：

　　A_Star_Search()
　　{
　　　　Open = [起始节点];
　　　　Closed = [];
　　　　while ( Open表非空 )
　　　　{
　　　　　　从Open中取得一个节点X, 并从OPEN表中删除.
　　　　　　if (X是目标节点)
　　　　　　{
　　　　　　　　求得路径PATH;
　　　　　　　　返回路径PATH;
　　　　　　}
　　　　　　for (每一个X的子节点Y)
　　　　　　{
　　　　　　　　if( Y不在OPEN表和CLOSE表中 )
　　　　　　　　{
　　　　　　　　　　求Y的估价值;
　　　　　　　　　　并将Y插入OPEN表中;　//还没有排序
　　　　　　　　}
　　　　　　　　else if( Y在OPEN表中 )
　　　　　　　　{
　　　　　　　　　　if( Y的估价值小于OPEN表的估价值 )
　　　　　　　　　　　　更新OPEN表中的估价值;
　　　　　　　　}
　　　　　　　　else //Y在CLOSE表中
　　　　　　　　{
　　　　　　　　　　if( Y的估价值小于CLOSE表的估价值 )
　　　　　　　　　　{
　　　　　　　　　　　　更新CLOSE表中的估价值;
　　　　　　　　　　　　从CLOSE表中移出节点, 并放入OPEN表中;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　将X节点插入CLOSE表中;
　　　　　　　　按照估价值将OPEN表中的节点排序;
　　　　　　}　//end for
　　　　}　//end while
　　}　//end func


上下左右注释后面的if代码片，就是估值过程。

A*算法也有变种，Beam Search（集束搜索）就是其中一种，只是BS中的open集有大小限制，不像A*保存所有需要检查的节点。

集束搜索BeamSearch
Taylar_where的博客
05-23 970
在开始写关于集束搜索的文章之前，我发现我对很多相关的算法都不是很熟悉，这严重影响到了我对集束搜索的理解，为了能让自己更好的理解集束搜索，我又回顾了一些基础。 我的回顾之旅: BFS算法中，我总结了两篇二叉树的BFS搜索和无向图的BFS搜索，在理解BFS搜索算法的过程中又额外涉及到了通过树的中序和先序遍历生成二叉树和存储无向图的邻接矩阵和邻接链表这两个知识点，有兴趣的朋友可以查看我的文集“算法之...
A*搜索算法概述
热门推荐
奇舞周刊
11-25 1万+
编者按：本文作者奇舞团前端开发工程师魏川凯。A*搜索算法（A-star search algorithm）是一种常见且应用广泛的图搜索和寻径算法。A*搜索算法是通过使用启...
【AI】The A* Search 搜索算法
weixin_43098506的博客
10-16 824
A*搜索算法 最短路径 城市距离最优解
集束搜索算法 beam search
a3923022的博客
03-10 308
类似于贪心算法,局部最优解,只不过有三个带宽增加概率 https://blog.csdn.net/pipisorry/article/details/78404964 https://blog.csdn.net/xljiulong/article/details/51554780 类似于 Viterbi-Algorithm算法 转载于:https://www.cn...
a*的含义及应用实例
最新发布
weixin_42607969的博客
02-16 1032
a*是一种常用的路径搜索算法，通常用于计算机科学中的人工智能、游戏开发、机器人学和其他相关领域。 在路径搜索中，a算法被用来寻找从起点到终点的最短路径。它通过对估计从当前节点到目标节点的距离进行评估，选择在估计成本最小的方向上继续搜索，以尽可能快地找到最短路径。a算法在不断探索的同时，还会尝试优化它的路径选择，从而找到最短路径。 应用实例包括但不限于：游戏中的人物寻路、机器人的路径规划、GPS导航...
浅析A*算法在搜索最短路径的应用
10-21
人工智能大作业，关于A*算法在搜索路径的应用，C++代码，STL的优先队列
A星搜索算法教程确定目标最短路径的A*搜索算法教程
01-03
A星(A*)搜索算法是一种广泛应用在图形搜索、游戏开发、路径规划等领域的高效寻路算法。它是Dijkstra算法的一种扩展，引入了启发式信息来提高搜索效率，同时保证找到的路径是最优的。本教程将深入讲解A*算法的核心...
A*搜索和迭代A*搜索
05-11
A*搜索算法是一种广泛应用在路径规划、游戏AI、图形学等领域中的启发式搜索算法。它在Dijkstra算法的基础上，引入了评估函数以提高搜索效率，同时保持了找到最优解的特性。A*搜索的核心思想是结合了实际路径代价（g...
AStar_java:A *搜索算法
05-02
A* 搜索算法（AStar）是一种在图形中寻找从起始节点到目标节点最短路径的启发式搜索算法。这个算法结合了Dijkstra算法的全局最优性和贪婪最佳优先搜索的效率，通过引入启发式函数来估计从当前节点到目标节点的剩余...
tsgraph:TypeScript中的A *搜索算法实现
03-07
在编程领域，A*（A-star）搜索算法是一种广泛应用的路径寻找算法，尤其在游戏开发、图形渲染和导航系统中。本篇将详细探讨如何在TypeScript环境中实现A*搜索算法，并以`tsgraph`为例进行阐述。`tsgraph`是一个专门...
Go实现A *搜索算法-Golang开发
05-26
Go的go-astar A *寻路实现A *寻路算法是一种寻路算法，以其性能和准确性着称，通常用于游戏开发中。 它可以用来为Go的任何A-star A *寻路实现找到短路径。A *寻路算法是一种寻路算法，以其性能和准确性着称，通常...
迷宫问题的A*算法(python实现)
07-05
附件中A_star.py为算法实现，有两个txt文件作为测试样例，mediumMaze是一个封闭的迷宫，openmaze是一个开放的迷宫
搜索算法—A*
a0021001的博客
07-21 234
这东西，简直是被神化了一样。我从蓝书上查找了一些资料，以我的水平确实难以看懂他的表达。于是借助百度，发现大多数博客都在转载一篇似乎是翻译自国外的文章。写的很详细，但我在第一次阅读的时候并没有看懂，并且感觉专业性较高。比如其中又是OpenList又是CloseList的，初看确实有些头晕眼花。 那么，在这里重新整理一下我理解A*的过程。 概念理论 这个算法似乎被广泛应用于游戏开发的寻...
A*算法 详解与例题
HeartFireY的博客
05-25 6343
A*搜索(A\* Search Algorithm)，是一种在图形平面上，对于有多个节点的路径求出最低通过成本的算法。它属于图的遍历和最佳有限搜索算法，同时也是BFS算法的改进之一。
一、A*搜索算法
dinongxu8804的博客
12-23 1343
经典算法研究系列：一、A*搜索算法 作者：July、二零一一年一月----------------------------------博主说明：1、本经典算法研究系列，此系列文章写的不够好之处，还望见谅。2、本经典算法研究系列，系我参考资料，一篇一篇原创所作，转载必须注明作者本人July及出处。3、本经典算法研究系列...
A*搜索算法(附带可运行源码)
jinvasshole
02-28 201
最近有空，用Java写了个A*搜索，并使用swing做为显示。 关于算法知识，可以在这里查到(http://en.wikipedia.org/wiki/A*_search_algorithm)，其它网站也有很多介绍。我就不说了。本文主要提供源码下载和一些测试数据。 硬件：ThinkpadX200 7457CH1 CPU : Intel(R) Core(TM)2 Duo CPU P8600...
寻路算法A*, JPS（跳点搜索）的一些杂谈
weixin_30741653的博客
09-15 1514
A*是一个比较经典的启发式寻路算法。是基于dijkstra算法，但是加入了启发函数，使路径搜索效率更高。实现起来很简单。不过要做到通用性高，比如支持各种不同类型的地图，甚至不仅仅是地图，而是个图结构如解决拼图游戏N-puzzle会用到的，就需要多花点心思。用C++实现的话，可以使用模板来适应不同的需要。也可以使用类继承。 template <typename NodeType, t...
寻路A*算法 （下）
大白专栏
08-10 6437
这样还剩下 5 个相邻的方格。当前方格下面的 2 个方格还没有加入 open list ，所以把它们加入，同时把当前方格设为他们的父亲。在剩下的 3 个方格中，有 2 个已经在 close list 中 ( 一个是起点，一个是当前方格上面的方格，外框被加亮的 ) ，我们忽略它们。最后一个方格，也就是当前方格左边的方格，我们检查经由当前方格到达那里是否具有更小的 G 值。没有。因此我们准备从 ope
A*搜索算法
长生但酒狂的博客
11-28 1万+
作为程序员的我们可能经常会听到 A*搜索算法这个的词，听起来非常高大上，腻害，但是具体是什么呢？ 引用 Wiki 上的说法就是： A* 搜索算法（A* search algorithm）是一种在图形平面上，有多个节点的路径，求出最低通过成本的算法。常用于游戏中的NPC的移动计算，或网络游戏的BOT的移动计算上。 该算法综合了最良优先搜索和Dijkstra算法的优点：在进行启发式搜索提高算法效率的同...
A*搜索算法详解与实现
A 星算法是一种经典的路径搜索算法，用于寻找两点之间的最短路径，特别适合在复杂的图形或地图环境中寻找最优解决方案。它结合了Dijkstra算法（优先级队列原理）和启发式函数，能够在处理有障碍物的环境时提供更高效...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值