A*自动寻路算法初探
本文将用最简洁易懂的语言来阐述A*寻路算法的思路，大牛请绕道。最后会附上C++源码，注释很清晰，很容易看懂。
A*自动寻路算法初探
原来也听狗狗学长讲过一下，但是当时也没怎么听懂，只是在脑海中留下了一点启发式搜索的印象，在做数据结构课程设计之前，突然想到了这个算法，于是就决定好好搞一下这个备受推崇的搜索算法。
其实任何算法，不管多难，只要你愿意花时间深入研究，你都会觉得其实根本没想象中的那么难，如果总是不去学他，那么你将永远觉得他很难。
下面进入正题：
在学习A*算法之前，我们得会最简单的BFS、DFS搜索算法，我觉得从某种意义上来时，A*算法其实就是BFS、DFS的一个变种，一个升级，他就是加入了一个启发式的决策在里面，然而也正是这个启发式的决策，使得这个搜索算法的效率大大提升。
【问题描述】
在一个地图中，有一点A，中间有一道障碍，还有一点B，如下图所示，现在你要从A点出发到达B点，求出这条路径。(绿色的是起点A，红色是终点B，蓝色方块是中间的墙。)
我们首先将搜索区域"格式化"，也就是所谓的建图，你可以用多种数据结构来实现，最简单的莫过于二维数组。
【思路分析】
解决以上提出的问题很容易，方法很多，最简单的莫过于DFS、BFS，但是对于这两种算法来说，时间复杂度太高，几乎遍历了整个地图才找到终点。
【多种算法时间复杂度对比】
首先我们来看一下最简单的两点寻路，中间没有任何障碍的：
首先是A*算法的搜索区域：
下面是最短路Dijkstra的搜索区域:
下面是的双向BFS搜索区域:
我们再来看一下中间有障碍的情况
首先还是A*算法的搜索区域:
下面是Dijkstra的搜索区域:
下面是双向BFS的搜索区域：
由以上各自的搜索树来看，我们可以感受到A*在时间上是三种搜索算法中最优的，其实BFS、DFS的时间复杂度是A*最坏情况下的时间复杂度。
感受到了A*算法的魅力后，我们来看一下算法思想：
【算法思想】
前面说过A*使用了一个启发式搜索，在哪里体现呢？
他的他提思想是这样的，我们在用BFS时，只是没有目标的乱搜一通，而A*则相当于对BFS对列中的元素进行了一个智能的比较，总是选择一个到达目标位置距离最短的路径上可能性最大的点，这样就减少了许多不必要的搜索。
【详细过程】
1，从点A开始，并且把它作为待处理点存入一个“开启列表”。开启列表就像一张购物清单。尽管现在列表里只有一个元素，但以后就会多起来。你的路径可能会通过它包含的方格，也可能不会。基本上，这是一个待检查方格的列表。
2，寻找起点周围所有可到达或者可通过的方格，跳过有墙，水，或其他无法通过地形的方格。也把他们加入开启列表。为所有这些方格保存点A作为“父方格”。当我们想描述路径的时候，父方格的资料是十分重要的。后面会解释它的具体用途。
3，从开启列表中删除点A，把它加入到一个“关闭列表”，列表中保存所有不需要再次检查的方格。在这一点，你应该形成如图的结构。在图中，暗绿色方格是你起始方格的中心。它被用浅蓝色描边，以表示它被加入到关闭列表中了。所有的相邻格现在都在开启列表中，它们被用浅绿色描边。每个方格都有一个灰色指针反指他们的父方格，也就是开始的方格。
[图-2]
接着，我们选择开启列表中的临近方格，大致重复前面的过程，如下。但是，哪个方格是我们要选择的呢？是那个F值最低的。
路径评分
选择路径中经过哪个方格的关键是下面这个等式：F = G + H
这里：
* G = 从起点A，沿着产生的路径，移动到网格上指定方格的移动耗费。
* H = 从网格上那个方格移动到终点B的预估移动耗费。这经常被称为启发式的，可能会让你有点迷惑。这样叫的原因是因为它只是个猜测。我们没办法事先知道路径的长度，因为路上可能存在各种障碍(墙，水，等等)。虽然本文只提供了一种计算H的方法，但是你可以在网上找到很多其他的方法。
我们的路径是通过反复遍历开启列表并且选择具有最低F值的方格来生成的。文章将对这个过程做更详细的描述。首先，我们更深入的看看如何计算这个方程。
正如上面所说，G表示沿路径从起点到当前点的移动耗费。在这个例子里，我们令水平或者垂直移动的耗费为，对角线方向耗费为。我们取这些值是因为沿对角线的距离是沿水平或垂直移动耗费的的根号（别怕），或者约.414倍。为了简化，我们用和近似。比例基本正确，同时我们避免了求根运算和小数。这不是只因为我们怕麻烦或者不喜欢数学。使用这样的整数对计算机来说也更快捷。你不就就会发现，如果你不使用这些简化方法，寻路会变得很慢。
既然我们在计算沿特定路径通往某个方格的G值，求值的方法就是取它父节点的G值，然后依照它相对父节点是对角线方向或者直角方向(非对角线)，分别增加和。例子中这个方法的需求会变得更多，因为我们从起点方格以外获取了不止一个方格。
H值可以用不同的方法估算。我们这里使用的方法被称为曼哈顿方法，它计算从当前格到目的格之间水平和垂直的方格的数量总和，忽略对角线方向，然后把结果乘以10。这被称为曼哈顿方法是因为它看起来像计算城市中从一个地方到另外一个地方的街区数，在那里你不能沿对角线方向穿过街区。很重要的一点，我们忽略了一切障碍物。这是对剩余距离的一个估算，而非实际值，这也是这一方法被称为启发式的原因。想知道更多？你可以在这里找到方程和额外的注解。
F的值是G和H的和。第一步搜索的结果可以在下面的图表中看到。F,G和H的评分被写在每个方格里。正如在紧挨起始格右侧的方格所表示的，F被打印在左上角，G在左下角，H则在右下角。
[图-3]
现在我们来看看这些方格。写字母的方格里，G = 10。这是因为它只在水平方向偏离起始格一个格距。紧邻起始格的上方，下方和左边的方格的G值都等于。对角线方向的G值是。
H值通过求解到红色目标格的曼哈顿距离得到，其中只在水平和垂直方向移动，并且忽略中间的墙。用这种方法，起点右侧紧邻的方格离红色方格有格距离，H值就是。这块方格上方的方格有格距离(记住，只能在水平和垂直方向移动)，H值是。你大致应该知道如何计算其他方格的H值了～。每个格子的F值，还是简单的由G和H相加得到
继续搜索
为了继续搜索，我们简单的从开启列表中选择F值最低的方格。然后，对选中的方格做如下处理：
4，把它从开启列表中删除，然后添加到关闭列表中。
5，检查所有相邻格子。跳过那些已经在关闭列表中的或者不可通过的(有墙，水的地形，或者其他无法通过的地形)，把他们添加进开启列表，如果他们还不在里面的话。把选中的方格作为新的方格的父节点。
6，如果某个相邻格已经在开启列表里了，检查现在的这条路径是否更好。换句话说，检查如果我们用新的路径到达它的话，G值是否会更低一些。如果不是，那就什么都不做。
另一方面，如果新的G值更低，那就把相邻方格的父节点改为目前选中的方格（在上面的图表中，把箭头的方向改为指向这个方格）。最后，重新计算F和G的值。如果这看起来不够清晰，你可以看下面的图示。
好了，让我们看看它是怎么运作的。我们最初的格方格中，在起点被切换到关闭列表中后，还剩格留在开启列表中。这里面，F值最低的那个是起始格右侧紧邻的格子，它的F值是。因此我们选择这一格作为下一个要处理的方格。在紧随的图中，它被用蓝色突出显示。
[图-4]
首先，我们把它从开启列表中取出，放入关闭列表(这就是他被蓝色突出显示的原因)。然后我们检查相邻的格子。哦，右侧的格子是墙，所以我们略过。左侧的格子是起始格。它在关闭列表里，所以我们也跳过它。
其他格已经在开启列表里了，于是我们检查G值来判定，如果通过这一格到达那里，路径是否更好。我们来看选中格子下面的方格。它的G值是。如果我们从当前格移动到那里，G值就会等于(到达当前格的G值是，移动到上面的格子将使得G值增加)。因为G值大于，所以这不是更好的路径。如果你看图，就能理解。与其通过先水平移动一格，再垂直移动一格，还不如直接沿对角线方向移动一格来得简单。
当我们对已经存在于开启列表中的个临近格重复这一过程的时候，我们发现没有一条路径可以通过使用当前格子得到改善，所以我们不做任何改变。既然我们已经检查过了所有邻近格，那么就可以移动到下一格了。
于是我们检索开启列表，现在里面只有7格了，我们仍然选择其中F值最低的。有趣的是，这次，有两个格子的数值都是。我们如何选择？这并不麻烦。从速度上考虑，选择最后添加进列表的格子会更快捷。这种导致了寻路过程中，在靠近目标的时候，优先使用新找到的格子的偏好。但这无关紧要。（对相同数值的不同对待，导致不同版本的A*算法找到等长的不同路径）那我们就选择起始格右下方的格子，如图：
[图-5]
这次，当我们检查相邻格的时候，发现右侧是墙，于是略过。上面一格也被略过。我们也略过了墙下面的格子。为什么呢？因为你不能在不穿越墙角的情况下直接到达那个格子。你的确需要先往下走然后到达那一格，按部就班的走过那个拐角。(注解：穿越拐角的规则是可选的。它取决于你的节点是如何放置的。)
这样一来，就剩下了其他格。当前格下面的另外两个格子目前不在开启列表中，于是我们添加他们，并且把当前格指定为他们的父节点。其余格，两个已经在关闭列表中（起始格，和当前格上方的格子，在表格中蓝色高亮显示),于是我们略过它们。最后一格，在当前格的左侧，将被检查通过这条路径，G值是否更低。不必担心，我们已经准备好检查开启列表中的下一格了。
我们重复这个过程，直到目标格被添加进关闭列表(注解)，就如在下面的图中所看到的。
[图-6]
注意，起始格下方格子的父节点已经和前面不同的。之前它的G值是，并且指向右上方的格子。现在它的G值是，指向它上方的格子。这在寻路过程中的某处发生，当应用新路径时，G值经过检查变得低了－于是父节点被重新指定，G和F值被重新计算。尽管这一变化在这个例子中并不重要，在很多场合，这种变化会导致寻路结果的巨大变化。
那么，我们怎么确定这条路径呢？很简单，从红色的目标格开始，按箭头的方向朝父节点移动。这最终会引导你回到起始格，这就是你的路径！看起来应该像图中那样。从起始格A移动到目标格B只是简单的从每个格子（节点）的中点沿路径移动到下一个，直到你到达目标点。就这么简单。
[图-7]
A*算法总结
好，现在你已经看完了整个说明，让我们把每一步的操作写在一起：
1，把起始格添加到开启列表。
2，重复如下的工作：
a) 寻找开启列表中F值最低的格子。我们称它为当前格。
b) 把它切换到关闭列表。
c) 对相邻的格中的每一个？
* 如果它不可通过或者已经在关闭列表中，略过它。反之如下。
* 如果它不在开启列表中，把它添加进去。把当前格作为这一格的父节点。记录这一格的F,G,和H值。
* 如果它已经在开启列表中，用G值为参考检查新的路径是否更好。更低的G值意味着更好的路径。如果是这样，就把这一格的父节点改成当前格，并且重新计算这一格的G和F值。如果你保持你的开启列表按F值排序，改变之后你可能需要重新对开启列表排序。
d) 停止，当你
* 把目标格添加进了关闭列表(注解)，这时候路径被找到，或者
* 没有找到目标格，开启列表已经空了。这时候，路径不存在。
3.保存路径。从目标格开始，沿着每一格的父节点移动直到回到起始格。这就是你的路径。
(注解:在这篇文章的较早版本中，建议的做法是当目标格（或节点）被加入到开启列表，而不是关闭列表的时候停止寻路。这么做会更迅速，而且几乎总是能找到最短的路径，但不是绝对的。当从倒数第二个节点到最后一个（目标节点）之间的移动耗费悬殊很大时－例如刚好有一条河穿越两个节点中间，这时候旧的做法和新的做法就会有显著不同。)
附上我的代码:
#include <set> #include <map> #include <list> #include<ctime> #include <queue> #include <stack> #include <cmath> #include<cstdio> #include <vector> #include <string> #include <cstdio> #include<cassert> #include <cstdlib> #include <cstring> #include <iostream> #include<windows.h> #include <algorithm> using namespace std; const int MAXINT = 88888; //随便取个数,大于地图上任意两点间的距离 int Map_w, Map_h; //地图的宽,高 int title_num ( int x, int y ) { return Map_w * x + y; //由坐标转化为地图块号 } int title_y ( int n ) { return n % Map_w; //由块号转化为x,y坐标 } int title_x ( int n ) { return n / Map_w; } struct treenode { int h; //节点所在的高度，表示从起始点到该节点所有的步数 int title; //该节点的位置(块数) treenode*father; //该节点的上一步 }; struct linknode //链表队列 { treenode*node; int f; linknode*next; }; //定义两个队列 linknode*open_queue; // 保存没有处理的行走方法的节点 linknode*close_queue; // 保存已经处理过的节点 (搜索完后释放) unsigned int*Map; //地图数据 unsigned int*dis_Map; //保存搜索路径时,中间目标的最优解 int sx, sy, ex, ey; //地点,终点坐标 /**************************************END define***************************************/ void initial() // 初始化队列 { open_queue = new linknode(); open_queue->node = NULL; open_queue->f = -1; open_queue->next = new linknode(); open_queue->next->node = NULL; open_queue->next->next = NULL; open_queue->next->f = MAXINT; close_queue = new linknode(); close_queue->f = -1; close_queue->next = NULL; close_queue->node = NULL; } void Push_queue ( treenode*node, int m ) //待处理节点入队列, 依*对目的地估价距离插入排序 { linknode*p, *priot; p = open_queue; while ( m > p->f ) { priot = p; p = p->next; assert ( p ); } linknode*q = new linknode(); q->next = p; priot->next = q; q->node = node; q->f = m; } treenode*Pop_queue() // 将离目的地估计最近的方案出队列 { linknode*p = open_queue->next; open_queue->next = open_queue->next->next; p->next = close_queue->next; close_queue->next = p; return p->node; } void pop_stack() // 释放栈顶节点 { linknode*p = close_queue->next; close_queue->next = close_queue->next->next; assert ( p ); delete p->node; delete p; } void empty() //释放申请过的所有节点 { linknode*p; while ( open_queue ) //当队列不为空 { p = open_queue; delete p->node; open_queue = open_queue->next; delete p; } while ( close_queue ) { p = close_queue; delete p->node; close_queue = close_queue->next; delete p; } } int testing ( int x, int y ) //估价函数,估价 x,y 到目的地的距离,估计值必须保证比实际值小 { return abs ( ex - x ) + abs ( ey - y ); } int trytest ( int x, int y, treenode* priot ) //尝试下一步移动到 x,y 可行否 { treenode*p; int h; if ( 0 == Map[title_num ( x, y )] ) return 1; //将地图按照顺序给每个方格编号 h = priot->h + 1; if ( h >= dis_Map[title_num ( x, y )] ) return 1; // 如果曾经有更好的方案移动到 (x,y) 失败 dis_Map[title_num ( x, y )] = h; // 记录这次到 (x,y) 的距离为历史最佳距离 // 将这步方案记入待处理队列 p = new treenode(); p->father = priot; p->h = priot->h + 1; p->title = title_num ( x, y ); Push_queue ( p, p->h + testing ( x, y ) ); return 0; } int* A_star() //路径寻找主函数 { treenode*root = root = new treenode(); int i; int*paths; memset ( dis_Map, 0xff, Map_h * Map_w * sizeof ( *dis_Map ) ); //填充dis_Map为0XFF，表示各点未曾经过 initial(); //初始化队列 root->title = title_num ( sx, sy ); //将起点的坐标转化为地图块号 root->h = 0; //起点到起点的距离为0 root->father = NULL; //起点的初始化 Push_queue ( root, testing ( sx, sy ) ); //将起点入队 while( true ) { int x, y, child; root = Pop_queue(); // 将离目的地估计最近的方案出队列 if ( NULL == root ) return NULL; //结束条件之一 x = title_x ( root->title ); //将地图转化为x,y坐标 y = title_y ( root->title ); if ( x == ex && y == ey ) break;; // 达到目的地成功返回 child = 1; //由该点扩展出来的子节点 child &= trytest ( x, y - 1, root ); //尝试4个方向 child &= trytest ( x, y + 1, root ); //尝试下一步移动到 x,y 可行否 child &= trytest ( x - 1, y, root ); child &= trytest ( x + 1, y, root ); if ( child != 0 ) pop_stack(); // 如果四个方向均不能移动,释放这个死节点 } paths = new int[root->h + 2]; assert ( paths ); //如果它的条件返回错误，则终止程序执行 for ( i = 0; root; ++i ) //将所有由该点派生出来的子节点的father指针指向该点 { paths[i] = root->title; root = root->father; } paths[i] = -1; empty(); //已得出路径，现在可以释放所有节点内存 return paths; //返回路径数组的首地址 } void showMap(); //显示地图 void showpath ( int *paths ) // 回溯树，将求出的最佳路径保存在 path[] 中(从终点沿着父节点回溯到起点) { int i; if ( paths == NULL ) return; for ( i = 0; paths[i] > 0; ++i ) { cout << "(" << title_x ( paths[i] ) << "," << title_y ( paths[i] ) << ")" << " "; } cout << endl; getchar();getchar(); for ( i = 0; paths[i] > 0; ++i ) { assert ( paths[i] ); Map[paths[i]] = '*'; system ( "cls" ); showMap(); } } void setMap() //申请dis_Map的大小 { dis_Map = new unsigned int[Map_w * Map_h * sizeof ( dis_Map )]; assert ( dis_Map ); //判断是否申请内存成功 } void showMap() //显示地图 { int i, j; assert ( Map ); for ( i = 0; i < Map_h; ++i ) { for ( j = 0; j < Map_w; ++j ) { if ( i == 0 || j == 0 || i == Map_h - 1 || j == Map_w - 1 ) { cout << "■"; continue; } if ( i == sx && j == sy ) { cout << "Ｅ"; continue; } if ( i == ex && j == ey ) { cout << "Ｓ"; continue; } if ( Map[Map_w * i + j] == '*' ) { cout << "＊"; continue; } if ( Map[Map_w * i + j] ) cout << "□"; else cout << "■"; } cout << endl; } Sleep ( 800 ); } void Maps() //生成地图 { int in1; int in2; cout << "请输入随机地图的宽度:"; cin >> in1; Map_w = in1 + 2; //将地图围起来 cout << "请输入随机地图的高度:"; cin >> in2; Map_h = in2 + 2; cout << endl; cout << "请输入地图的入口坐标x[" << 1 << "," << in1 << "]" << ",y[" << 1 << "," << in2 << "]\nx="; cin >> ey; while ( ey < 1 || ey > in1 ) { cin.clear(); //清空输入缓存区 while ( cin.get() != '\n' ) continue; cout << "输入错误,请重新输入\nx="; cin >> ey; } cout << "y="; cin >> ex; while ( ex < 1 || ex > in2 ) { cin.clear(); while ( cin.get() != '\n' ) continue; cout << "输入错误,请重新输入\ny="; cin >> ex; } cout << endl; cout << "请输入地图的出口坐标x[" << 1 << "," << in1 << "]" << ",y[" << 1 << "," << in2 << "]\nx="; cin >> sy; while ( sy < 1 || sy > in1 ) { cin.clear(); while ( cin.get() != '\n' ) continue; cout << "输入错误,请重新输入\nx="; cin >> sy; } cout << "y="; cin >> sx; while ( sx < 1 || sx > in2 ) { cin.clear(); while ( cin.get() != '\n' ) continue; cout << "输入错误,请重新输入\ny="; cin >> sx; } cout << endl; Map = new unsigned int[ ( Map_w + 1 ) *Map_h]; //按照输入大小申请内存空间(线性结构) int i = 0, j = 0, direc = 2; int ran; for ( i = 0; i < Map_h; i++ ) for ( j = 0; j < Map_w; j++ ) Map[Map_w * i + j] = 1; //初始化地图 srand ( time ( 0 ) ); //按照时间生成随机数 i = j = 0; while ( true ) { if ( i >= Map_h - 1 && j >= Map_w - 1 ) break; //地图已经全部赋值 ran = ( int ) rand() % 4; if ( ran < 1 ) { if ( direc != 1 && i < Map_h - 1 ) { i++; direc = 3; } } else if ( ran < 2 ) { if ( direc != 2 && j > 0 ) { j--; direc = 0; } } else if ( ran < 3 ) { if ( direc != 3 && i > 0 ) { i--; direc = 1; } } else { if ( direc != 0 && j < Map_w - 1 ) { j++; direc = 2; } } } for ( i = 0; i < Map_h; i++ ) for ( j = 0; j < Map_w; j++ ) if ( Map[Map_w * i + j] == 1 ) { ran = ( int ) rand() % 10; //按照40%的比例来给地图添加障碍物 if ( ran < 3 ) Map[Map_w * i + j] = 0; } Map[title_num ( sx, sy )] = 1; Map[title_num ( ex, ey )] = 1; for ( i = 0; i < Map_h; ++i ) //将地图边界围起来 { for ( j = 0; j < Map_w; ++j ) { if ( i == 0 || j == 0 ) Map[title_num ( i, j )] = 0; if ( i == Map_h - 1 || j == Map_w - 1 ) Map[title_num ( i, j )] = 0; } } } int main() { system("color 1a"); system("mode con cols=75 lines=30"); char str[] = "\n\n\t你好,欢迎进入<A_star智能寻路系统>*_*\n\n\t\t\tCHANGING THE WORLD BY PROGRAMING ~_~ "; char tmp[30] = {0}; int len = strlen(str); for(int i = 0; i < len; ) { memset(tmp,0,30); if(str[i] >= 0x80) { strncpy(tmp,&(str[i]),2); i+=2; } else { strncpy(tmp,&(str[i]),1); i+=1; } printf("%s",tmp); Sleep(150); //输出字符速度（微秒） } printf("\n"); system("cls"); while ( true ) { int*paths; Maps(); //建立地图 setMap(); //存储地图节点的F(n)解 system ( "cls" ); showMap(); getchar(); getchar(); // system ( "PAUSE" ); paths = A_star(); if ( paths == NULL ) { system ( "cls" ); cout << " \\\|/// \n"; cout << " \\ - - // \n"; cout << " ( @ @ ) \n"; cout << " ┏━━━━━━━oOOo-(_)-oOOo━━━━━━━┓ \n"; cout << " ┃ ┃ \n"; cout << " ┃ ┃ \n"; cout << " ┃ 没有出路 ┃ \n"; cout << " ┃ ┃ \n"; cout << " ┃ ┃ \n"; cout << " ┃ ┃ \n"; cout << " ┃ ┃ \n"; cout << " ┃ ┃ \n"; cout << " ┃ ┃ \n"; cout << " ┃ ┃ \n"; cout << " ┃ Oooo ┃ \n"; cout << " ┗━━━━━━━ oooO━-( )━━━━━━━┛ \n"; cout << " ( ) ) / \n"; cout << " \ ( (_/ \n"; cout << " \_) \n"; } showpath ( paths ); // 回溯树，将求出的最佳路径保存在 path[] 中(从终点沿着父节点回溯到起点) if ( dis_Map ) delete[]dis_Map; //释放内存 if ( paths ) delete[]paths; //释放路径数组的内存 if ( Map ) delete[]Map; //释放地图数组的内存 cout << "搜索完成"<<endl; getchar(); // system ( "PAUSE" ); system ( "cls" ); cout << "再来一次(Y/N)?"; char anyt; cin >> anyt; if ( anyt == 'n' || anyt == 'N' ) break; } getchar(); // system ( "PAUSE" ); return 0; }
【参考资料】
[1] 算法导论（原书第 3 版） Thomas H. Cormen Charles E.LeisersonTonaldL.Rivest(spfa算法)
[2] 数据结构（第 3 版）刘振鹏 石强 编著
[3] 算法竞赛入门经典刘汝佳
[4] 以下是参考了网络博客的地址
[5] http://www.cnblogs.com/kanego/archive/2011/08/30/2159070.html
[6] http://www.cppblog.com/mythit/archive/2009/04/19/80492.aspx
[7] http://hi.baidu.com/fdwm_lx/item/f5ed5a48cd0baae31281dafe
[8] http://blog.csdn.net/b2b160/article/details/4057781
[9] mhtml:http://dev.gameres.com/Program/Abstract/Arithmetic/AmitAStar.mht#_Toc16918094
浙公网安备 33010602011771号