魔兽世界、仙剑奇侠传这类MMRPG游戏，不知道你有没有玩过？在这些游戏中，有一个非常重要的功能，那就是人物角色自动寻路。当人物处于游戏地图中的某个位置的时候，我们用鼠标点击另外一个相对较远的位置，人物就会自动地绕过障碍物走过去。玩过这么多游戏，不知你是否思考过，这个功能是怎么实现的呢？
算法解析
实际上，这是一个非常典型的搜索问题。人物的起点就是他当下所在的位置，终点就是鼠标点击的位置。我们需要在地图中，找一条从起点到终点的路径。这条路径要绕过地图中所有障碍物，并且看起来要是一种非常聪明的走法。所谓“聪明”，笼统地解释就是，走的路不能太绕。理论上讲，最短路径显然是最聪明的走法，是这个问题的最优解。
不过，在第44节最优出行路线规划问题中，我们也讲过，如果图非常大，那Dijkstra最短路径算法的执行耗时会很多。在真实的软件开发中，我们面对的是超级大的地图和海量的寻路请求，算法的执行效率太低，这显然是无法接受的。
实际上，像出行路线规划、游戏寻路，这些真实软件开发中的问题，一般情况下，我们都不需要非得求最优解（也就是最短路径）。在权衡路线规划质量和执行效率的情况下，我们只需要寻求一个次优解就足够了。那如何快速找出一条接近于最短路线的次优路线呢？
这个快速的路径规划算法，就是我们今天要学习的A*算法。实际上，A*算法是对Dijkstra算法的优化和改造。如何将Dijkstra算法改造成A*算法呢？为了更好地理解接下来要讲的内容，我建议你先温习下第44节中的Dijkstra算法的实现原理。
Dijkstra算法有点儿类似BFS算法，它每次找到跟起点最近的顶点，往外扩展。这种往外扩展的思路，其实有些盲目。为什么这么说呢？我举一个例子来给你解释一下。下面这个图对应一个真实的地图，每个顶点在地图中的位置，我们用一个二维坐标（x，y）来表示，其中，x表示横坐标，y表示纵坐标。
在Dijkstra算法的实现思路中，我们用一个优先级队列，来记录已经遍历到的顶点以及这个顶点与起点的路径长度。顶点与起点路径长度越小，就越先被从优先级队列中取出来扩展，从图中举的例子可以看出，尽管我们找的是从s到t的路线，但是最先被搜索到的顶点依次是1，2，3。通过肉眼来观察，这个搜索方向跟我们期望的路线方向（s到t是从西向东）是反着的，路线搜索的方向明显“跑偏”了。
之所以会“跑偏”，那是因为我们是按照顶点与起点的路径长度的大小，来安排出队列顺序的。与起点越近的顶点，就会越早出队列。我们并没有考虑到这个顶点到终点的距离，所以，在地图中，尽管1，2，3三个顶点离起始顶点最近，但离终点却越来越远。
如果我们综合更多的因素，把这个顶点到终点可能还要走多远，也考虑进去，综合来判断哪个顶点该先出队列，那是不是就可以避免“跑偏”呢？
当我们遍历到某个顶点的时候，从起点走到这个顶点的路径长度是确定的，我们记作g(i)（i表示顶点编号）。但是，从这个顶点到终点的路径长度，我们是未知的。虽然确切的值无法提前知道，但是我们可以用其他估计值来代替。
这里我们可以通过这个顶点跟终点之间的直线距离，也就是欧几里得距离，来近似地估计这个顶点跟终点的路径长度（注意：路径长度跟直线距离是两个概念）。我们把这个距离记作h(i)（i表示这个顶点的编号），专业的叫法是启发函数（heuristic function）。因为欧几里得距离的计算公式，会涉及比较耗时的开根号计算，所以，我们一般通过另外一个更加简单的距离计算公式，那就是曼哈顿距离（Manhattan distance）。曼哈顿距离是两点之间横纵坐标的距离之和。计算的过程只涉及加减法、符号位反转，所以比欧几里得距离更加高效。
int hManhattan(Vertex v1, Vertex v2) { // Vertex表示顶点，后面有定义
return Math.abs(v1.x - v2.x) + Math.abs(v1.y - v2.y);
}
原来只是单纯地通过顶点与起点之间的路径长度g(i)，来判断谁先出队列，现在有了顶点到终点的路径长度估计值，我们通过两者之和f(i)=g(i)+h(i)，来判断哪个顶点该最先出队列。综合两部分，我们就能有效避免刚刚讲的“跑偏”。这里f(i)的专业叫法是估价函数（evaluation function）。
从刚刚的描述，我们可以发现，A*算法就是对Dijkstra算法的简单改造。实际上，代码实现方面，我们也只需要稍微改动几行代码，就能把Dijkstra算法的代码实现，改成A*算法的代码实现。
在A*算法的代码实现中，顶点Vertex类的定义，跟Dijkstra算法中的定义，稍微有点儿区别，多了x，y坐标，以及刚刚提到的f(i)值。图Graph类的定义跟Dijkstra算法中的定义一样。为了避免重复，我这里就没有再贴出来了。
private class Vertex {
public int id; // 顶点编号ID
public int dist; // 从起始顶点，到这个顶点的距离，也就是g(i)
public int f; // 新增：f(i)=g(i)+h(i)
public int x, y; // 新增：顶点在地图中的坐标（x, y）
public Vertex(int id, int x, int y) {
this.id = id;
this.x = x;
this.y = y;
this.f = Integer.MAX_VALUE;
this.dist = Integer.MAX_VALUE;
}
}
// Graph类的成员变量，在构造函数中初始化
Vertex[] vertexes = new Vertex[this.v];
// 新增一个方法，添加顶点的坐标
public void addVetex(int id, int x, int y) {
vertexes[id] = new Vertex(id, x, y)
}
A*算法的代码实现的主要逻辑是下面这段代码。它跟Dijkstra算法的代码实现，主要有3点区别：
-
优先级队列构建的方式不同。A*算法是根据f值（也就是刚刚讲到的f(i)=g(i)+h(i)）来构建优先级队列，而Dijkstra算法是根据dist值（也就是刚刚讲到的g(i)）来构建优先级队列；
-
A*算法在更新顶点dist值的时候，会同步更新f值；
-
循环结束的条件也不一样。Dijkstra算法是在终点出队列的时候才结束，A*算法是一旦遍历到终点就结束。
public void astar(int s, int t) { // 从顶点s到顶点t的路径
int[] predecessor = new int[this.v]; // 用来还原路径
// 按照vertex的f值构建的小顶堆，而不是按照dist
PriorityQueue queue = new PriorityQueue(this.v);
boolean[] inqueue = new boolean[this.v]; // 标记是否进入过队列
vertexes[s].dist = 0;
vertexes[s].f = 0;
queue.add(vertexes[s]);
inqueue[s] = true;
while (!queue.isEmpty()) {
Vertex minVertex = queue.poll(); // 取堆顶元素并删除
for (int i = 0; i < adj[minVertex.id].size(); ++i) {
Edge e = adj[minVertex.id].get(i); // 取出一条minVetex相连的边
Vertex nextVertex = vertexes[e.tid]; // minVertex-->nextVertex
if (minVertex.dist + e.w < nextVertex.dist) { // 更新next的dist,f
nextVertex.dist = minVertex.dist + e.w;
nextVertex.f
= nextVertex.dist+hManhattan(nextVertex, vertexes[t]);
predecessor[nextVertex.id] = minVertex.id;
if (inqueue[nextVertex.id] == true) {
queue.update(nextVertex);
} else {
queue.add(nextVertex);
inqueue[nextVertex.id] = true;
}
}
if (nextVertex.id == t) { // 只要到达t就可以结束while了
queue.clear(); // 清空queue，才能推出while循环
break;
}
}
}
// 输出路径
System.out.print(s);
print(s, t, predecessor); // print函数请参看Dijkstra算法的实现
}
尽管A*算法可以更加快速地找到从起点到终点的路线，但是它并不能像Dijkstra算法那样，找到最短路线。这是为什么呢？
要找出起点s到终点t的最短路径，最简单的方法是，通过回溯穷举所有从s到达t的不同路径，然后对比找出最短的那个。不过很显然，回溯算法的执行效率非常低，是指数级的。
Dijkstra算法在此基础之上，利用动态规划的思想，对回溯搜索进行了剪枝，只保留起点到某个顶点的最短路径，继续往外扩展搜索。动态规划相较于回溯搜索，只是换了一个实现思路，但它实际上也考察到了所有从起点到终点的路线，所以才能得到最优解。
A*算法之所以不能像Dijkstra算法那样，找到最短路径，主要原因是两者的while循环结束条件不一样。刚刚我们讲过，Dijkstra算法是在终点出队列的时候才结束，A*算法是一旦遍历到终点就结束。对于Dijkstra算法来说，当终点出队列的时候，终点的dist值是优先级队列中所有顶点的最小值，即便再运行下去，终点的dist值也不会再被更新了。对于A*算法来说，一旦遍历到终点，我们就结束while循环，这个时候，终点的dist值未必是最小值。
A*算法利用贪心算法的思路，每次都找f值最小的顶点出队列，一旦搜索到终点就不在继续考察其他顶点和路线了。所以，它并没有考察所有的路线，也就不可能找出最短路径了。
搞懂了A*算法，我们再来看下，如何借助A*算法解决今天的游戏寻路问题？
要利用A*算法解决这个问题，我们只需要把地图，抽象成图就可以了。不过，游戏中的地图跟第44节中讲的我们平常用的地图是不一样的。因为游戏中的地图并不像我们现实生活中那样，存在规划非常清晰的道路，更多的是宽阔的荒野、草坪等。所以，我们没法利用44节中讲到的抽象方法，把岔路口抽象成顶点，把道路抽象成边。
实际上，我们可以换一种抽象的思路，把整个地图分割成一个一个的小方块。在某一个方块上的人物，只能往上下左右四个方向的方块上移动。我们可以把每个方块看作一个顶点。两个方块相邻，我们就在它们之间，连两条有向边，并且边的权值都是1。所以，这个问题就转化成了，在一个有向有权图中，找某个顶点到另一个顶点的路径问题。将地图抽象成边权值为1的有向图之后，我们就可以套用A*算法，来实现游戏中人物的自动寻路功能了。
总结引申
我们今天讲的A*算法属于一种启发式搜索算法（Heuristically Search Algorithm）。实际上，启发式搜索算法并不仅仅只有A*算法，还有很多其他算法，比如IDA*算法、蚁群算法、遗传算法、模拟退火算法等。如果感兴趣，你可以自行研究下。
启发式搜索算法利用估价函数，避免“跑偏”，贪心地朝着最有可能到达终点的方向前进。这种算法找出的路线，并不是最短路线。但是，实际的软件开发中的路线规划问题，我们往往并不需要非得找最短路线。所以，鉴于启发式搜索算法能很好地平衡路线质量和执行效率，它在实际的软件开发中的应用更加广泛。实际上，在第44节中，我们讲到的地图App中的出行路线规划问题，也可以利用启发式搜索算法来实现。
课后思考
我们之前讲的“迷宫问题”是否可以借助A*算法来更快速地找到一个走出去的路线呢？如果可以，请具体讲讲该怎么来做；如果不可以，请说说原因。
欢迎留言和我分享，也欢迎点击“请朋友读”，把今天的内容分享给你的好友，和他一起讨论、学习。
精选留言
2019-01-19 20:38:55
我就是这样打算的…
同学说我们学历低只要大专，问我要大家考研究生不？我感觉我不去大公司的话没什么用吧？但一想很多要求本科，自考研究生不知道承认不？尤其公司，再说就算看完都老了吧……意义有多大？
2019-01-19 00:43:46
都说大神级见识很广也多，能给我这个35岁只维护过四五十台linux服务器的运维指条路吗？
现在很迷茫和压力大~~
能力如下：
一.网络：CCNA水平，自过了CCNP忘记了，当过2年网管
二、维护过asp.net电商网站，3年，只有简单的，兼职网管
三、linux运维，只在一家电商做了3年多，会
1.web：nginx、tomcat配置（少用）+php:nignx的rewirte和反代
2.数据库：mysql、mongoDB、redis 配置及主从，不会mycat、Cetus之类
3.反代：会nginx、haproxy简单配置
4.存储：NFS、fastDFS、hadoop简单看了一下
5.版本控制：只会git及搭建gitlab+jenkins（简单的CI/CD）
6.监控：简单配置zabbix+shell脚本
7.虚拟化：kvm安装及配置、docker(k8s还没学)
8.云计算：openstack只会安装做过实验
9.测试：只会ab工具
10.日志：ELK安装配置，还没结合java（在学中）
11.大数据：没使用过（不会flume、storm、spark、flink、kafka）
12.脚本：主要是shell为主、会点python
四、编程能力：自学，没项目经验
1.前端：
1）HTML（HTML5不怎看）
2）css（laiui、学了一下vue）
3) js、jquery框架、ES6简单看了一下
2.PHP：语法简单的thinkphp5框架
3.java：考虑要维护java web在学
只看了java、jsp及servet、spring、springMVC、spring Boot（这个为主）
4.python：考虑运维用到
python：会简单的脚本
django：只会官网简单的
问题是：现在已35岁了，失业，怎办？年龄摆在那里，能力好像不强，学历大专。
能给个建议吗？非常感谢~~
2019-01-18 11:12:42
2020-01-08 15:56:18
2020-09-28 09:04:09
1、写简历，是在审视自己这1年做了什么没，对自己的审视往往很有意思，也会催生自己的危机感
2、出去面试，不要抱着谁虐谁的态度，就是相互交流学习，当然，遇到挑刺的面试官，该虐虐，我觉得单纯就技术这种拼刺刀，能虐绝大部分一面面试官其实表示你的技术水平整体上已经可以了。如果能在案例分析等二面考察中继续脱颖而出，说明哥们你工作经验加技术很可以的。
3、出去面试最大的收获应该是，最后几轮面试，vp或者总监面试，把工作中遇到的一些技术疑惑，技术与业务疑惑，或者技术规划记录下来，这个时候拿出来问，一般固定15~30分钟的面试，你总有机会提出问题的，与高level的人单独交流，收获非常大。
2019-08-20 08:35:52
2019-01-18 09:47:30
2020-11-25 12:59:21
2019-04-07 22:05:45
实际上不管当前点从哪一个点经过，它与终点的曼哈顿距离都是不变的，所以这部分不需要管，具体到不等式里就是左右都有这一项，故可以消去：
if ( minVertex.dist + e.w + nextVertex.g < nextVertex.dist + nextVertex.g )
2020-01-06 08:40:16
2019-01-19 16:06:24
if (nextVertex.id == t) {
queue.clear();
break;
}
2019-08-07 05:43:54
迷宫算法不适合A＊算法，A＊算法的本质是利用了终点的距离这一信息来辅助解决问题。离终点的距离对于能否走出迷宫不是一个有效信息。迷宫问题还是采用经典的遍历算法。
2019-01-18 08:29:37
2020-02-06 09:15:15
* 这是一个非常典型的搜索问题。
* 人物的起点就是他当下所在的位置，终点就是鼠标点击的位置。
* 我们需要在地图中，找一条从起点到终点的路径。
* 这条路径要绕过地图中所有障碍物，并且看起来要是一种非常聪明的走法。所谓“聪明”，笼统地解释就是，走的路不能太绕。理论上讲，最短路径显然是最聪明的走法，是这个问题的最优解。
实际上，像出行路线规划、游戏寻路，这些真实软件开发中的问题，一般情况下都不需要非得求最优解（也就是最短路径）。
在权衡路线规划质量和执行效率的情况下，我们只需要寻求一个次优解就足够了。
如何快速找出一条接近于最短路线的次优路线呢？
A* 算法：A* 算法是对 Dijkstra 算法的优化和改造。最优出行路线规划问题中，如果图非常大，Dijkstra 最短路径算法的执行耗时会很多
Dijkstra 算法有点儿类似 BFS 算法，它每次找到跟起点最近的顶点，往外扩展。这种往外扩展的思路，其实有些盲目。
可以避免“跑偏”吗？
当遍历到某个顶点时，从起点到这个顶点的路径长度是确定的，记作 g(i)（i 表示顶点编号）
* 虽然从这个顶点到终点的路径长度是未知的，但可以用其他估计值来代替。
* 可以通过这个顶点跟终点之间的直线距离(欧几里得距离)，近似估算这个顶点跟终点的路径长度（注意：路径长度跟直线距离是两个概念）
* 把这个距离记作 h(i)（i 表示这个顶点的编号），专业的叫法是启发函数（heuristic function）。
* 因为欧几里得距离的计算公式，会涉及比较耗时的开根号计算，所以一般通过另外一个更加简单的距离计算公式，那就是曼哈顿距离（Manhattan distance）。
* 曼哈顿距离是两点之间横纵坐标的距离之和。计算的过程只涉及加减法、符号位反转，所以比欧几里得距离更加高效。
原来只是单纯地通过顶点与起点之间的路径长度 g(i)，来判断谁先出队列，现在有了顶点到终点的路径长度估计值，通过两者之和 f(i)=g(i)+h(i)，来判断哪个顶点该最先出队列。
综合两部分，就能有效避免“跑偏”。f(i) 的专业叫法是估价函数（evaluation function）
A* 算法就是对 Dijkstra 算法的简单改造
在 A* 算法的代码实现中，顶点 Vertex 类的定义，跟 Dijkstra 算法中的定义，稍微有点儿区别，多了 x，y 坐标，以及刚刚提到的 f(i) 值。图 Graph 类的定义跟 Dijkstra 算法中的定义一样。
A* 算法的代码主要有 3 点区别：
* 优先级队列构建的方式不同，
A* 算法是根据 f 值（ f(i)=g(i)+h(i)）来构建优先级队列，
Dijkstra 算法是根据 dist 值（g(i)）来构建优先级队列；
* A* 算法在更新顶点 dist 值的时候，会同步更新 f 值；
* 循环结束的条件也不一样。Dijkstra 算法是在终点出队列的时候才结束，A* 算法是一旦遍历到终点就结束。
A* 这是为什么不能找到最短路线呢？
要找出起点 s 到终点 t 的最短路径，最简单的方法是，通过回溯穷举所有从 s 到达 t 的不同路径，然后对比找出最短的那个。但回溯算法的执行效率非常低，是指数级的。
Dijkstra 算法在此基础之上，利用动态规划的思想，对回溯搜索进行了剪枝，只保留起点到某个顶点的最短路径，继续往外扩展搜索。动态规划相较于回溯搜索，只是换了一个实现思路，但它实际上也考察到了所有从起点到终点的路线，所以才能得到最优解。
* A* 算法之所以不能像 Dijkstra 算法那样，找到最短路径，主要原因是两者的 while 循环结束条件不一样
* Dijkstra 算法是在终点出队列的时候才结束，A* 算法是一旦遍历到终点就结束
* 对于 Dijkstra 算法，当终点出队列时，终点的 dist 值是优先级队列中所有顶点的最小值，即便再运行下去，终点的 dist 值也不会再被更新了。
* 对于 A* 算法，一旦遍历到终点，我们就结束 while 循环，这个时候，终点的 dist 值未必是最小值。
* A* 算法利用贪心算法的思路，每次都找 f 值最小的顶点出队列，一旦搜索到终点就不在继续考察其他顶点和路线了。
所以，它并没有考察所有的路线，也就不可能找出最短路径了。
2019-03-19 17:31:46
if (minVertex.dist + e.w < nextVertex.dist) { // 更新 next 的 dist,f
nextVertex.dist = minVertex.dist + e.w;
nextVertex.f = nextVertex.dist+hManhattan(nextVertex, vertexes[t]);
predecessor[nextVertex.id] = minVertex.id;
if (inqueue[nextVertex.id] == true) {
queue.update(nextVertex);
} else {
queue.add(nextVertex);
inqueue[nextVertex.id] = true;
}
}
2019-02-13 11:35:48
2019-10-22 18:18:05
2019-01-18 18:45:50
2019-10-15 09:03:59
2019-03-07 08:32:41