【算法导论】A*算法（A星算法）

最新推荐文章于 2024-06-25 19:52:15 发布
置顶 最新推荐文章于 2024-06-25 19:52:15 发布
阅读量3.6k 收藏 7
点赞数
分类专栏： Data Structure and Algorithm 文章标签： A星算法 算法导论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuangxiaobin/article/details/38755447
版权

前言

这篇blog是由iOS Tutorial Team的成员  Johann Fradj发表的，他目前是一位全职的资深iOS开发工程师。他是Hot Apps Factory的创始人，该公司开发了App Cooker。目前来看，这是一篇例子最简单的A星寻路算法介绍，我只是在原有的基础上做了一下调整，并且在后面带有我写的c++代码。

原文可以查看：http://www.raywenderlich.com/zh-hans/21503/a%E6%98%9F%E5%AF%BB%E8%B7%AF%E7%AE%97%E6%B3%95%E4%BB%8B%E7%BB%8D

Learn how the A* Pathfinding Algorithm Works!

学习A星寻路算法是如何工作的！

你是否在做一款游戏的时候想创造一些怪兽或者游戏主角，让它们移动到特定的位置，避开墙壁和障碍物呢？

如果是的话，请看这篇教程，我们会展示如何使用A星寻路算法来实现它！

在网上已经有很多篇关于A星寻路算法的文章，但是大部分都是提供给已经了解基本原理的高级开发者的。

本篇教程将从最基本的原理讲起。我们会一步步讲解A星寻路算法，并配有很多图解和例子。

不管你使用的是什么编程语言或者操作平台，你会发现本篇教程很有帮助，因为它在非编程语言的层面上解释了算法的原理。

现在找下到达一杯咖啡因饮料和美味的零食的最短路径，开始吧！

探路猫（第一类）

 让我们想象一下，有一款游戏，游戏中一只猫想要找到获取骨头的路线。

“为什么会有一只猫想要骨头？！”你可能会这么想。在本游戏中， 这是一只狡猾的猫，他想捡起骨头给狗，以防止被咬死！:]

现在想像一下下图中的猫想找到到达骨头的最短路径：

This cat just wants someone to throw him a bone!

不幸的是，猫不能直接从它当前的位置走到骨头的位置，因为有面墙挡住了去路，而且它在游戏中不是一只幽灵猫！

游戏中的猫同样懒惰，它总是想找到最短路径，这样当他回家看望它的女朋友时不会太累:-)

但是我们如何编写一个算法计算出猫要选择的那条路径呢？A星算法拯救了我们！ 

简化搜索区域 

寻路的第一步是简化成容易控制的搜索区域。

怎么处理要根据游戏来决定了。例如，我们可以将搜索区域划分成像素点，但是这样的划分粒度对于我们这款基于方块的游戏来说太高了（没必要）。

作为代替，我们使用方块（一个正方形）作为寻路算法的单元。其他的形状类型也是可能的（比如三角形或者六边形），但是正方形是最简单并且最适合我们需求的。

像那样去划分，我们的搜索区域可以简单的用一个地图大小的二维数组去表示。所以如果是25*25方块大小的地图，我们的搜索区域将会是一个有625个正方形的数组。如果我们把地图划分成像素点，搜索区域就是一个有640，000个正方形的数组了（一个方块是32*32像素）！

现在让我们基于目前的区域，把区域划分成多个方块来代表搜索空间（在这个简单的例子中，7*6个方块 = 42 个方块）：

Dividing the maze into a tile-based search area

 Open和Closed列表 

既然我们创建了一个简单的搜索区域，我们来讨论下A星算法的工作原理吧。

除了懒惰之外，我们的猫没有好的记忆力，所以它需要两个列表：

  1. 一个记录下所有被考虑来寻找最短路径的方块（称为open 列表）
  2. 一个记录下不会再被考虑的方块（成为closed列表）

猫首先在closed列表中添加当前位置（我们把这个开始点称为点 “A”）。然后，把所有与它当前位置相邻的可通行小方块添加到open列表中。

下图是猫在某一位置时的情景（绿色代表open列表）:
Adding adjacent tiles from the start position to the open list

现在猫需要判断在这些选项中，哪项才是最短路径，但是它要如何去选择呢？

在A星寻路算法中，通过给每一个方块一个和值，该值被称为路径增量。让我们看下它的工作原理！

路径增量

 我们将会给每个方块一个G+H 和值：

  • G是从开始点A到当前方块的移动量。所以从开始点A到相邻小方块的移动量为1，该值会随着离开始点越来越远而增大。
  • H是从当前方块到目标点（我们把它称为点B，代表骨头！）的移动量估算值。这个常被称为探视，因为我们不确定移动量是多少 – 仅仅是一个估算值。

你也许会对“移动量”感兴趣。在游戏中，这个概念很简单 – 仅仅是方块的数量。

然而，在游戏中你可以对这个值做调整。例如：

  • 如果你允许对角线移动，你可以针对对角线移动把移动量调得大一点。
  • 如果你有不同的地形，你可以将相应的移动量调整得大一点 – 例如针对一块沼泽，水，或者猫女海报:-)

这就是大概的意思 – 现在让我们详细分析下如何计算出G和H值。

关于G值

 G是从开始点A到达当前方块的移动量（在本游戏中是指方块的数目）。

为了计算出G的值，我们需要从它的前继（上一个方块）获取，然后加1。所以，每个方块的G值代表了从点A到该方块所形成路径的总移动量。

例如，下图展示了两条到达不同骨头的路径，每个方块都标有它的G值：
An illustration of the G variable in the A* Pathfinding Algorithm

关于H值

H值是从当前方块到终点的移动量估算值（在本游戏中是指方块的数目）。

移动量估算值离真实值越接近，最终的路径会更加精确。如果估算值停止作用，很可能生成出来的路径不会是最短的（但是它可能是接近的）。这个题目相对复杂，所以我们不会再本教程中讲解，但是我在教程的末尾提供了一个网络链接，对它做了很好的解释。

为了让它更简单，我们将使用“曼哈顿距离方法”（也叫“曼哈顿长”或者“城市街区距离”），它只是计算出距离点B，剩下的水平和垂直的方块数量，略去了障碍物或者不同陆地类型的数量。

例如，下图展示了使用“城市街区距离”，从不同的开始点到终点，去估算H的值（黑色字）：
An illustration of the H variable in the A* pathfinding algorithm with the Manhattan algorithm

A星算法

 既然你知道如何计算每个方块的和值（我们将它称为F，等于G+H),  我们来看下A星算法的原理。

猫会重复以下步骤来找到最短路径：

  1. 将方块添加到open列表中，该列表有最小的和值。且将这个方块称为S吧。
  2. 将S从open列表移除，然后添加S到closed列表中。
  3. 对于与S相邻的每一块可通行的方块T：
    1. 如果T在closed列表中：不管它。
    2. 如果T不在open列表中：添加它然后计算出它的和值。
    3. 如果T已经在open列表中：当我们使用当前生成的路径到达那里时，检查F 和值是否更小。如果是，更新它的和值和它的前继。

如果你对它的工作原理还有点疑惑，不用担心 – 我们会用例子一步步介绍它的原理！:]

猫的路径

让我们看下我们的懒猫到达骨头的行程例子。

在下图中，我根据以下内容，列出了公式F = G + H 中的每项值：

  • F（方块的和值）：左上角
  • G（从A点到方块的移动量）：左下角
  • H（从方块到B点的估算移动量): 右下角

同时，箭头指示了到达相应方块的移动方向。

最后，在每一步中，红色方块表示closed列表，绿色方块表示open列表。

好的，我们开始吧！

第一步

第一步，猫会确定相对于开始位置（点A）的相邻方块，计算出他们的F和值，然后把他们添加到open列表中：
A* Example Part 1

你会看到每个方块都列出了H值（有两个是6，一个是4）。我建议根据“城市街区距离”去计算方块的相关值，确保你理解了它的原理。

同时注意F值（在左上角）是G（左下角）值和H（右下脚）值的和。

第二步

在第二步中，猫选择了F和值最小的方块，把它添加到closed列表中，然后检索它的相邻方块的相关数值。
A* Example Part 2

现在你将看到拥有最小增量的是F值为4的方块。猫尝试添加所有相邻的方块到open列表中（然后计算他们的和值），除了猫自身的方块不能添加以外（因为它已经被添加到了closed列表中）或者它是墙壁方块（因为它不能通行）。

注意被添加到open列表的两个新方块，他们的G值都增加了1，因为他们现在离开始点有2个方块远了。你也许需要再计算下“城市街区距离”以确保你理解了每个新方块的H值。

第三步

再次，我们选择了有最小F和值（5）的方块，继续重复之前的步骤：
A* Example Part 3

现在，只有一个可能的方块被添加到open列表中了，因为已经有一个相邻的方块在close列表中，其他两个是墙壁方块。

第四步

现在我们遇到了一个有趣的情况。正如你之前看到的，有4个方块的F和值都为7 – 我们要怎么做呢？！

有几种解决方法可以使用，但是最简单（快速）的方法是一直跟着最近被添加到open列表中的方块。现在继续沿着最近被添加的方块前进。
A* Example Part 4

这次有两个可通过的相邻方块了，我们还是像之前那样计算他们的和值。

第五步

接着我们选择了最小和值（7）的方块，继续重复之前的步骤：
A* Example Part 5

我们越来越接近终点了！

第六步

你现在训练有素了！我打赌你能够猜出下一步是下面这样子了：
A* Example Part 6

我们差不多到终点了，但是这次你看到有两条到达骨头的最短路径提供给我们选择：
Two shortest paths to the bone

在我们的例子中，有两条最短路径：

  • 1-2-3-4-5-6
  • 1-2-3-4-5-7

It doesn’t really matter which of these we choose, it comes down to the actual implementation in code.

选择哪一条其实没关系，现在到了真正用代码实现的时候了。

第七步

让我们从其中一块方块，再重复一遍步骤吧：
A* Example Part 7

啊哈，骨头在open列表中了！

第八步

现在目标方块在open列表中了，算法会把它添加到closed列表中：
A* Example Part 8

然后，算法要做的所有事情就是返回，计算出最终的路径！
A* Example Part 9

一只有远见的猫

在上面的例子中，我们看到当猫在寻找最短路径时，它经常选择更好的方块（那个在它的未来最短路径上的方块）- 好像它是一只有远见的猫！

但是如果猫是盲目的，并且总是选择第一个添加到它的列表上的方块，会发生什么事情？

下图展示了所有在寻找过程中会被使用到的方块。你会看到猫在尝试更多的方块，但是它仍然找到了最短路径（不是之前的那条，而是另一条等价的）：
What would happen if the cat wasn't so smart...

图中的红色方块不代表最短路径，它们只是代表在某个时候被选择为“S”的方块。

我建议你看着上面的图，并且尝试过一遍步骤。这次无论你看到哪个相邻的方块，都选择“最坏”的方式去走。你会发现最后还是找到了最短路径！

所以你可以看到跟随一个“错误的”方块是没有问题的，你仍然会在多次重复尝试后找到最短路径。

所以在我们的实现中，我们会按照以下的算法添加方块到open列表中：

  • 相邻的方块会返回这些顺序: 上面/左边/下面/右边。
  • 当所有的方块都有相同的和值后，方块会被添加到open列表中（所以第一个被添加的方块是第一个被猫挑选的）。

下面是从原路返回的示意图：
The cat finding the shortest path, even after some wrong turns

最短的路径是从终点开始，一步步返回到起点构成的（例子：在终点我们可以看到箭头指向右边，所以该方块的前继在它的左边）。

总的来说，我们可以用下面的伪代码，合成猫的寻找过程。这是C++写的，但是你可以用任何的语言去实现它。

#include <iostream>
#include <cmath>
using namespace std;

#define WIDTH 7
#define HEIGHT 5


/******************************修改的地方*******************************/
#define NEIGHBOUR 4
/**********************************************************************/


#define table(i,j) *(*(table+i)+j)

int m[NEIGHBOUR]={-1,1,0,0};
int n[NEIGHBOUR]={0,0,-1,1};
//定义每个格子的参数列表
struct param
{
	int f;
	int g;
	int h;
	int dir;//记录方向
	bool state;//记录状态（开列表和闭列表）
};


/************************地图也是要修改的***********************************************/
//初始化地图，坐标（1,2）是起始点，坐标（5,1）是结束点，其他的是墙壁或者障碍
void initMap(int table[][HEIGHT])
{
	table(1,2)=1;
	table(5,1)=2;
	table(1,1)=-1;
	table(3,1)=-1;
	table(3,2)=-1;
	table(3,3)=-1;
	table(3,4)=-1;


}
/****************************************************************************************/


//初始化列表，所有的格子都开放
void initList(struct param list[][HEIGHT])
{
	for(int i=0;i<WIDTH;i++)
	{
		for(int j=0;j<HEIGHT;j++)
		{
			//全部开放
			list[i][j].state=1;
			//方向初始化
			list[i][j].dir=-1;
			list[i][j].h=10*(abs(i-5)+abs(j-2));
			list[i][j].g=0x7ffffff;
		}
	}
	//起始点到自己的距离是0
	list[1][2].g=0;

}
void search(int table[][HEIGHT],struct param list[][HEIGHT],int i,int j)
{
	int tempi,tempj;
	//初始化min为无穷
	int min=0x7ffffff,minIndex;

	list[i][j].state=0;

	for(int k=0;k<NEIGHBOUR;k++)
	{
		tempi=i+m[k];
		tempj=j+n[k];
		//处理边界问题，障碍问题，以及闭列表的问题
		if(tempi>=0&&tempi<WIDTH&&tempj>=0&&tempj<HEIGHT&&table[tempi][tempj]!=-1&&list[tempi][tempj].state==1&&table[i][tempj]!=-1&&table[tempi][j]!=-1)
		{
			if(table[tempi][tempj]==2)
			{
				list[i][j].dir=k;
				return;
			}
			else
			{
/***************************************距离修改***************************************/
				//对角上的距离是1.4倍,判断是否会引起G值下降
					if(list[i][j].g+10<list[tempi][tempj].g)
						list[tempi][tempj].g=list[i][j].g+10;
					else
						list[tempi][tempj].state=0;

/**************************************************************************************/

				list[tempi][tempj].f=list[tempi][tempj].g+list[tempi][tempj].h;

				if(list[tempi][tempj].f<min)
				{
					min=list[tempi][tempj].f;
					minIndex=k;
				}
			}
			
		}		
	}
	list[i][j].dir=minIndex;
	search(table,list,i+m[minIndex],j+n[minIndex]);
}
//输出结果
void display(struct param list[][HEIGHT],int i,int j)
{
	int tempi,tempj;
	if(list[i][j].dir<0)
		return;
	tempi=i+m[list[i][j].dir];
	tempj=j+n[list[i][j].dir];
	cout<<tempi+1<<","<<tempj+1<<endl;
	display(list,tempi,tempj);
}
int main()
{

	int table[WIDTH][HEIGHT]={0};
	struct param list[WIDTH][HEIGHT];
	initMap(table);
	initList(list);
	search(table,list,1,2);
	display(list,1,2);
	
/*********************************增加了一部分，可有可无***********************/	
	//图示输出
	int i,j;
	for(j=HEIGHT-1;j>=0;j--)
	
	{
		for(i=0;i<WIDTH;i++)
			
			
		{	if (table[i][j]==-1)
			cout<<"*  ";
		    else if (list[i][j].dir>=0)			
				cout<<"+  ";
			else cout<<"-  ";
		}
		cout<<endl;
	}
/****************************************************************************/

	while(1);
    return 0;
}



方块连接（第二类）

现在，我们换个例子。我们上面的例子中，猫只能在水平和垂直方向上移动。现在，我们有下图所示的地图，不同的是，我们允许方块在八个方向上进行连线。



代码如下 

#include <iostream>
#include <cmath>
using namespace std;

#define WIDTH 7
#define HEIGHT 5


/******************************修改的地方*******************************/
#define NEIGHBOUR 8
/**********************************************************************/


#define table(i,j) *(*(table+i)+j)

int m[NEIGHBOUR]={-1,1,0,0,-1,-1,1,1};
int n[NEIGHBOUR]={0,0,-1,1,-1,1,-1,1};
//定义每个格子的参数列表
struct param
{
	int f;
	int g;
	int h;
	int dir;//记录方向
	bool state;//记录状态（开列表和闭列表）
};


/************************地图也是要修改的***********************************************/
//初始化地图，坐标（1,2）是起始点，坐标（5,1）是结束点，其他的是墙壁或者障碍
void initMap(int table[][HEIGHT])
{
	table(1,2)=1;
	table(5,2)=2;
	table(3,1)=-1;
	table(3,2)=-1;
	table(3,3)=-1;


}
/****************************************************************************************/


//初始化列表，所有的格子都开放
void initList(struct param list[][HEIGHT])
{
	for(int i=0;i<WIDTH;i++)
	{
		for(int j=0;j<HEIGHT;j++)
		{
			//全部开放
			list[i][j].state=1;
			//方向初始化
			list[i][j].dir=-1;
			list[i][j].h=10*(abs(i-5)+abs(j-2));
			list[i][j].g=0x7ffffff;
		}
	}
	//起始点到自己的距离是0
	list[1][2].g=0;

}
void search(int table[][HEIGHT],struct param list[][HEIGHT],int i,int j)
{
	int tempi,tempj;
	//初始化min为无穷
	int min=0x7ffffff,minIndex;

	list[i][j].state=0;

	for(int k=0;k<NEIGHBOUR;k++)
	{
		tempi=i+m[k];
		tempj=j+n[k];
		//处理边界问题，障碍问题，以及闭列表的问题
		if(tempi>=0&&tempi<WIDTH&&tempj>=0&&tempj<HEIGHT&&table[tempi][tempj]!=-1&&list[tempi][tempj].state==1)
		{
			if(table[tempi][tempj]==2)
			{
				list[i][j].dir=k;
				return;
			}
			else
			{
/***************************************距离修改***************************************/
				//对角上的距离是1.4倍,判断是否会引起G值下降
				if(k<4)
				{
					if(list[i][j].g+10<list[tempi][tempj].g)
						list[tempi][tempj].g=list[i][j].g+10;
					else
						list[tempi][tempj].state=0;
				}
				else
				{
					if(list[i][j].g+14<list[tempi][tempj].g)
						list[tempi][tempj].g=list[i][j].g+14;

					else
						list[tempi][tempj].state=0;
				}
/**************************************************************************************/

				list[tempi][tempj].f=list[tempi][tempj].g+list[tempi][tempj].h;

				if(list[tempi][tempj].f<min)
				{
					min=list[tempi][tempj].f;
					minIndex=k;
				}
			}
			
		}		
	}
	list[i][j].dir=minIndex;
	search(table,list,i+m[minIndex],j+n[minIndex]);
}
//输出结果
void display(struct param list[][HEIGHT],int i,int j)
{
	int tempi,tempj;
	if(list[i][j].dir<0)
		return;
	tempi=i+m[list[i][j].dir];
	tempj=j+n[list[i][j].dir];
	cout<<tempi+1<<","<<tempj+1<<endl;
	display(list,tempi,tempj);
}
int main()
{

	int table[WIDTH][HEIGHT]={0};
	struct param list[WIDTH][HEIGHT];
	initMap(table);
	initList(list);
	search(table,list,1,2);
	display(list,1,2);
	
/*********************************增加了一部分，可有可无***********************/	
	//图示输出
	int i,j;
	for(j=HEIGHT-1;j>=0;j--)
	
	{
		for(i=0;i<WIDTH;i++)
			
			
		{	if (table[i][j]==-1)
			cout<<"*  ";
		    else if (list[i][j].dir>=0)			
				cout<<"+  ";
			else cout<<"-  ";
		}
		cout<<endl;
	}
/****************************************************************************/

	while(1);
    return 0;
}
路径以及演示：+号表示路径，*号表示障碍，-号表示空白处。


方块连接（第三类）

现在我们假设不可以掠过障碍物进行连线，例如下图中，不能从左上角移动到右下角，因为右上角是障碍物。代码如下。（和第二种唯一的不同在于第76行代码） 


#include <iostream>
#include <cmath>
using namespace std;

#define WIDTH 7
#define HEIGHT 5


/******************************修改的地方*******************************/
#define NEIGHBOUR 8
/**********************************************************************/


#define table(i,j) *(*(table+i)+j)

int m[NEIGHBOUR]={-1,1,0,0,-1,-1,1,1};
int n[NEIGHBOUR]={0,0,-1,1,-1,1,-1,1};
//定义每个格子的参数列表
struct param
{
	int f;
	int g;
	int h;
	int dir;//记录方向
	bool state;//记录状态（开列表和闭列表）
};


/************************地图也是要修改的***********************************************/
//初始化地图，坐标（1,2）是起始点，坐标（5,1）是结束点，其他的是墙壁或者障碍
void initMap(int table[][HEIGHT])
{
	table(1,2)=1;
	table(5,2)=2;
	table(3,1)=-1;
	table(3,2)=-1;
	table(3,3)=-1;


}
/****************************************************************************************/


//初始化列表，所有的格子都开放
void initList(struct param list[][HEIGHT])
{
	for(int i=0;i<WIDTH;i++)
	{
		for(int j=0;j<HEIGHT;j++)
		{
			//全部开放
			list[i][j].state=1;
			//方向初始化
			list[i][j].dir=-1;
			list[i][j].h=10*(abs(i-5)+abs(j-2));
			list[i][j].g=0x7ffffff;
		}
	}
	//起始点到自己的距离是0
	list[1][2].g=0;

}
void search(int table[][HEIGHT],struct param list[][HEIGHT],int i,int j)
{
	int tempi,tempj;
	//初始化min为无穷
	int min=0x7ffffff,minIndex;

	list[i][j].state=0;

	for(int k=0;k<NEIGHBOUR;k++)
	{
		tempi=i+m[k];
		tempj=j+n[k];
		//处理边界问题，障碍问题，以及闭列表的问题
		if(tempi>=0&&tempi<WIDTH&&tempj>=0&&tempj<HEIGHT&&table[tempi][tempj]!=-1&&list[tempi][tempj].state==1&&table[i][tempj]!=-1&&table[tempi][j]!=-1)
		{
			if(table[tempi][tempj]==2)
			{
				list[i][j].dir=k;
				return;
			}
			else
			{
/***************************************距离修改***************************************/
				//对角上的距离是1.4倍,判断是否会引起G值下降
				if(k<4)
				{
					if(list[i][j].g+10<list[tempi][tempj].g)
						list[tempi][tempj].g=list[i][j].g+10;
					else
						list[tempi][tempj].state=0;
				}
				else
				{
					if(list[i][j].g+14<list[tempi][tempj].g)
						list[tempi][tempj].g=list[i][j].g+14;

					else
						list[tempi][tempj].state=0;
				}
/**************************************************************************************/

				list[tempi][tempj].f=list[tempi][tempj].g+list[tempi][tempj].h;

				if(list[tempi][tempj].f<min)
				{
					min=list[tempi][tempj].f;
					minIndex=k;
				}
			}
			
		}		
	}
	list[i][j].dir=minIndex;
	search(table,list,i+m[minIndex],j+n[minIndex]);
}
//输出结果
void display(struct param list[][HEIGHT],int i,int j)
{
	int tempi,tempj;
	if(list[i][j].dir<0)
		return;
	tempi=i+m[list[i][j].dir];
	tempj=j+n[list[i][j].dir];
	cout<<tempi+1<<","<<tempj+1<<endl;
	display(list,tempi,tempj);
}
int main()
{

	int table[WIDTH][HEIGHT]={0};
	struct param list[WIDTH][HEIGHT];
	initMap(table);
	initList(list);
	search(table,list,1,2);
	display(list,1,2);
	
/*********************************增加了一部分，可有可无***********************/	
	//图示输出
	int i,j;
	for(j=HEIGHT-1;j>=0;j--)
	
	{
		for(i=0;i<WIDTH;i++)
			
			
		{	if (table[i][j]==-1)
			cout<<"*  ";
		    else if (list[i][j].dir>=0)			
				cout<<"+  ";
			else cout<<"-  ";
		}
		cout<<endl;
	}
/****************************************************************************/

	while(1);
    return 0;
}
路径以及演示：+号表示路径，*号表示障碍，-号表示空白处。

艾尔伦
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
a-star-on-quadtree:四叉树上的A *算法（带有实时演示）
05-19
四叉树上的A * 四叉树上的A *算法
【WHUT】*实验报告*《人工智能概论》课内实验：A*算法仿真实验
07-11
**A*算法详解** A*算法是一种启发式搜索算法，广泛应用于路径规划、游戏AI、图形处理等领域。它结合了Dijkstra算法的最优性保证和Greedy算法的搜索效率，通过一个评估函数来指导搜索方向，减少无效的探索。评估函数...
A星寻路算法介绍
燕窝
03-18 2625
这篇文章还可以在这里找到 英语 Tweet 这篇blog是由iOS Tutorial Team的成员  Johann Fradj发表的，他目前是一位全职的资深iOS开发工程师。他是Hot Apps Factory的创始人，该公司开发了App Cooker。   学习A星寻路算法是如何工作的！ 你是否在做一款游戏的时候想创造一些怪兽或者游戏主
A*算法
最新发布
m0_52796585的博客
06-25 864
A * 搜索算法（英文：A*search algorithm，A * 读作 A-star），简称 A * 算法，是一种在图形平面上，对于有多个节点的路径求出最低通过成本的算法。它属于图遍历（英文：Graph traversal）和最佳优先搜索算法（英文：Best-first search），亦是BFS的改进。
Silverlight.XNA(C#)跨平台3D游戏研发手记：(二)四叉树遍历与人工智能A*算法在SLG移动路径范围测算中的应用...
weixin_34007886的博客
09-21 154
    除战斗范围设定外，说到SLG中最有趣而经典的算法莫过于角色可移动范围的测算与寻路。当前成熟的SLG商业游戏中，以《火焰纹章》、《高级大战争》等系列新作为代表，它们在传统的基础上将可移动范围进行了拓展，组合上攻击范围并配合移动指向路径箭头，使得整场战局每个“棋子”的操控感受和趣味性都无与伦比。 SLG角色移动从程序设计的角度可大致分为3个步骤： 1）呈现可移动路径范围 2）确定移动...
【A星算法】--第四篇（A星算法）
Jim_Wu的博客
11-30 1867
本篇主要介绍A星算法的过程： * 把起始节点加进openList * while openList 不为空 { * 当前节点 = openList 中成本最低的节点 * if（当前节点 = 目标节点）{ * 路径完成 * }else{ * 把当前节点移入closeedList * 检...
算法导论(part2)
09-09
它深入浅出地介绍了大量的算法及相关的数据结构，以及用于解决一些复杂计算问题的高级策略(如动态规划、贪心算法、平摊分析等)，重点在于算法的分析和设计。对于每一个专题，作者都试图提供目前最新的研究成果及样例...
[麻省理工学院-算法导论](英文版).chm
04-03
注：下载后，评价时给5星，还你11分 Table of Contents Introduction to Algorithms, Second Edition Preface Part I - Foundations Chapter 1 - The Role of Algorithms in Computing Chapter 2 - ...
算法导论(part1)
09-09
它深入浅出地介绍了大量的算法及相关的数据结构，以及用于解决一些复杂计算问题的高级策略(如动态规划、贪心算法、平摊分析等)，重点在于算法的分析和设计。对于每一个专题，作者都试图提供目前最新的研究成果及样例...
A星算法与蚁群算法解决车间调度问题-人工智能大作业完整源码、测试数据与实验报告.rar
01-16
在这个名为"A星算法与蚁群算法解决车间调度问题-人工智能大作业完整源码、测试数据与实验报告"的压缩包中，包含了一项基于人工智能的课程设计，主要探讨了两种优化算法在解决复杂车间调度问题上的应用：A*算法和蚁群...
A星寻路实例
03-24
A星寻路最经典的的实例.E易语言例子!A星寻路最经典的的实例.E易语言例子!
A星算法源代码
03-12
A星算法的DLL,A星算法的DLL,A星算法的DLL,A星算法的DLL,A星算法的DLL,A星算法的DLL,
易语言 A星 A星寻路
10-14
易语言 A星 A星寻路
A星寻路，寻路系统
12-28
采用A星寻路，让任务自动采取路径寻路到敌人身边，以最近路径
A*寻路算法 教程(一) （转）
05-26
NULL 博文链接：https://xldbk.iteye.com/blog/504452
A星寻路算法
weixin_43735634的博客
01-02 4618
通过该节点访问其上右下左的四个点，并判断这些点是否能够加入开放表（坐标超出网格范围，节点在关闭表，节点是障碍点。最后判断坐标点是否在开放表，不在开放表的点构建节点并加入开放表，这里默认两点间的代价为1；A星算法结合了广度优先搜索（BFS）和最佳优先搜索（Best-First Search）的特点，通过使用启发式函数评估节点的重要性，优先选择最有希望达到目标节点的节点进行扩展，从而有效地缩小搜索范围。public int CompareTo(AstarNode other) //排序方式。
算法：A星寻路（含实例）
weixin_52596036的博客
01-05 2225
a星寻路是寻路算法中比较常用的一种，核心是启发式寻路算法（曼哈顿方法），实际开发中常用于计算最优路径，自动寻路等......
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值