End

数据结构与算法-2 最短路径 Dijkstra A*搜索

本文地址

目录

目录

44 | Dijkstra 最短路径算法

如何计算两点之间的最短路径

基础篇的时候，我们学习了图的两种搜索算法，深度优先搜索和广度优先搜索。这两种算法主要是针对无权图的搜索算法。针对有权图，我们该如何计算两点之间的最短路径呢？今天，我就从地图软件的路线规划问题讲起，带你看看常用的最短路径算法 Shortest Path Algorithm。

使用地图软件时，如果想从家开车到公司，你只需要输入起始、结束地址，地图就会给你规划一条最优出行路线。这里的最优，有很多种定义，比如最短距离路线、最少用时路线、最少红绿灯路线等等，这些最优路线是如何计算出来的呢？

建模

解决软件开发中的实际问题，最重要的一点就是建模，也就是将复杂的场景抽象成具体的数据结构。针对这个问题，显然，把地图抽象成图最合适不过了。

我们把每个岔路口看作一个顶点，岔路口与岔路口之间的路看作一条边，路的长度就是边的权重。如果路是单行道，我们就在两个顶点之间画一条有向边；如果路是双行道，我们就在两个顶点之间画两条方向不同的边。这样，整个地图就被抽象成一个有向有权图。

于是，我们要求解的问题就转化为，在一个有向有权图中，求两个顶点间的最短路径。

相关类的定义

有向有权图的邻接表表示

有向有权图 Graph

public class Graph {
  private LinkedList<Edge>[] adj; // 每个顶点都关联一个 LinkedList，里面保存的是，所有以他作为起始顶点的边
  private int v; // 顶点个数

  public Graph(int v) {
    this.v = v;
    this.adj = new LinkedList[v];
    for (int i = 0; i < v; ++i) {
      this.adj[i] = new LinkedList<>();
    }
  }

  // 添加一条边
  public void addEdge(int s, int t, int w) {
    this.adj[s].add(new Edge(s, t, w)); // 编号为 s 的顶点所关联的 LinkedList 中添加一条边
  }
}

边 Edge

class Edge {
    public int sid; // 边的起始顶点编号
    public int tid; // 边的终止顶点编号
    public int w; // 边的权重

    public Edge(int sid, int tid, int w) {
        this.sid = sid;
        this.tid = tid;
        this.w = w;
    }
}

顶点 Vertex

class Vertex {
    public int id; // 顶点对应的编号 id，起始顶点的 id 定义为 0
    public int dist; // 从起始顶点到这个顶点的距离(最终会更新为最短距离)

    public Vertex(int id, int dist) {
        this.id = id;
        this.dist = dist;
    }
}

优先级队列 PriorityQueue

因为 Java 提供的优先级队列没有暴露更新数据的接口，所以我们重新实现了一个。

class PriorityQueue {
    private Vertex[] nodes; // 保存的是顶点，根据 vertex.dist 构建小顶堆
    private int count;

    public PriorityQueue(int v) {
        this.nodes = new Vertex[v + 1];
        this.count = v;
    }

    public Vertex poll() {} // 出队列，并触发堆化
    public void add(Vertex vertex) {} // 入队列，并触发堆化
    public boolean isEmpty() {} // 队列是否为空
    public void update(Vertex vertex) {}  // 新增，更新结点的值，并触发堆化
}

Dijkstra 算法代码

想要解决这个问题，有一个非常经典的算法，单源最短路径算法。

提到最短路径算法，最出名的莫过于 Dijkstra 算法了：

  • Dijkstra 算法有点儿类似 BFS 算法，它每次找到跟起点最近的顶点，往外扩展
  • 在 Dijkstra 算法中，我们用一个优先级队列，来记录已经遍历到的顶点以及这个顶点与起点的路径长度。顶点与起点路径长度越小，就越先被从优先级队列中取出来扩展
// 查找从顶点 s 到顶点 t 的最短路径
public void dijkstra(int s, int t) {
    int[] predecessor = new int[this.v]; // 记录最短路径经过的每个顶点的【前驱顶点】，用来还原最短路径
    Vertex[] vertexes = new Vertex[this.v];
    for (int i = 0; i < this.v; ++i) {
        vertexes[i] = new Vertex(i, Integer.MAX_VALUE); // 初始化顶点
    }
    vertexes[s].dist = 0; // 初始化起点的 dist (距离起点的最短距离)为 0
    boolean[] inqueue = new boolean[this.v]; // 标记顶点是否进入过队列
    inqueue[s] = true;

    PriorityQueue queue = new PriorityQueue(this.v);
    queue.add(vertexes[s]);
    while (!queue.isEmpty()) { // 结束情况一：所有顶点都遍历完了
        // 【核心逻辑】：顶点与起点距离 dist 越小，就越先被从优先级队列中取出来扩展
        Vertex minVertex = queue.poll(); // 取堆中 dist 最小的顶点并删除
        if (minVertex.id == t) break; // 结束情况二：最短路径提前产生了
        // 遍历以顶点 minVertex 为起始顶点的所有【边】，adj[id] 是一个 LinkedList<Edge>
        for (int i = 0; i < adj[minVertex.id].size(); ++i) {
            Edge e = adj[minVertex.id].get(i); // 再次强调，遍历的是边 Edge
            Vertex nextVertex = vertexes[e.tid]; // 取这个边指向的顶点
            //【核心逻辑】：对回溯搜索进行剪枝，只保留起点到某个顶点的最短路径
            if (minVertex.dist + e.w < nextVertex.dist) {
                // 说明经过 min 到达 next 是从起点到达 next 的更短的路径
                // 但不一定是最短的路径，因为后面还可能遍历到更短的路径
                nextVertex.dist = minVertex.dist + e.w; // 更新 dist
                predecessor[nextVertex.id] = minVertex.id; // 更新前驱顶点
                if (inqueue[nextVertex.id] == true) {
                    queue.update(nextVertex); // 更新顶点，会触发堆化
                } else {
                    queue.add(nextVertex); // 加入优先级队列，同样会触发堆化
                    inqueue[nextVertex.id] = true;
                }
            }
        }
    }
    // 打印最短路径
    System.out.print(s);
    print(s, t, predecessor);
}

private void print(int s, int t, int[] predecessor) {
    if (s == t) return;
    print(s, predecessor[t], predecessor);
    System.out.print("->" + t);
}

Dijkstra 算法解释

我们用 vertexes 数组，记录从起始顶点到每个顶点的距离（Vertex.dist）。起初，我们把所有顶点的 dist 都初始化为 Integer.MAX_VALUE。我们把起始顶点的 dist 值初始化为 0，然后将其放到优先级队列中。

  • 我们从优先级队列中取出 dist 最小的顶点 minVertex
  • 然后考察这个顶点可达的所有顶点，即代码中的 nextVertex
    • 如果 minVertex.dist + w 小于 nextVertex 当前的 dist 值
      • 也就是说，存在另一条更短的路径，它可经过 minVertex 到达 nextVertex
      • 那我们就把 nextVertex 的 dist 更新为 minVertex.dist + w
      • 然后，我们把 nextVertex 加入到优先级队列中
    • 否则，说明这个路径肯定不是最短路径，后续就不需要再继续考察。这其实就是一个剪枝操作
  • 重复这个过程，直到找到终止顶点 t 或者队列为空

predecessor 数组的作用是为了还原最短路径，它记录每个顶点的前驱顶点。最后，我们通过递归的方式，将这个路径打印出来。

inqueue 数组是为了避免将一个顶点多次添加到优先级队列中。

算法过程图解

图中状态 (m, n) 中的 m 表示：从起点到达此顶点的最短距离
图中状态 (m, n) 中的 n 表示：从起点到达此顶点的最短路径中，到达此顶点的前驱顶点

过程解释：

  • while: 开始遍历顶点 0
    • for: 有两条边
      • 顶点 1 到达顶点 0 的距离是 10，记做 (1,10,0)，由于 10 < MAX_VALUE，所以顶点 1 入队列
      • 顶点 4 到达顶点 0 的距离是 15，记做 (4,15,0)，由于 15 < MAX_VALUE，所以顶点 4 入队列
        • 注意，并不是只有距离起点最近的那个顶点才入队列
  • while: 队列中有两个顶点 1 和 4，顶点 1 距离起点的距离最短，所以开始遍历顶点 1
    • for: 有两条边
      • 顶点 2 到达顶点 0 的距离是 10+15，记做 (2,25,1)，由于 25 < MAX_VALUE，所以顶点 2 入队列
      • 顶点 3 到达顶点 0 的距离是 10+2，记做 (3,12,1)，由于 12 < MAX_VALUE，所以顶点 3 入队列
  • while: 队列中有三个顶点 4、2、3，顶点 3 距离起点的距离最短，所以开始遍历顶点 3
    • for: 有两条边
      • 顶点 2 到达顶点 0 的距离是 12+1，由于顶点 2 之前保存的 dist 为 25，且 13 < 25
        • 说明经过顶点 3 到达顶点 2 是从起点到达顶点 2 的更短的路径
        • 更新顶点信息为 (2,13,3)
      • 顶点 5 到达顶点 0 的距离是 12+12，记做 (5,24,3)，由于 24 < MAX_VALUE，所以顶点 5 入队列
  • while: 队列中有三个顶点 4、2、5，顶点 2 距离起点的距离最短，所以开始遍历顶点 2
    • for: 有一条边
      • 顶点 5 到达顶点 0 的距离是 13+5，由于顶点 5 之前保存的 dist 为 24，且 18 < 24
        • 说明经过顶点 2 到达顶点 5 是从起点到达顶点 5 的更短的路径
        • 更新顶点信息为 (5,18,2)
  • while: 队列中有两个顶点 4、5，顶点 5 距离起点的距离最短，所以开始遍历顶点 5
    • 由于顶点 5 就是终点，所以停止遍历，最短路径也产生了

时间复杂度分析

在刚刚的代码实现中，while 循环最多会执行 V 次（V 表示顶点的个数），而内部的 for 循环的执行次数不确定，跟每个顶点的相邻边的个数有关，我们分别记作 E0，E1，E2，……，E(V-1)。如果我们把这 V 个顶点的边都加起来，最大也不会超过图中所有边的个数 E。所以，while 循环 * for 循环内部代码总的执行次数的时间复杂度就是 O(E)（E 表示边的个数）。

for 循环内部的代码涉及三个主要的操作：从优先级队列取数据、往优先级队列中添加数据、更新优先级队列中的数据。我们知道，优先级队列是用堆来实现的，堆中这几个操作的时间复杂度都是 O(logV)（堆中的元素个数不会超过顶点的个数 V）。

所以，综合这两部分，整个代码的时间复杂度就是 O(E*logV)。

如何计算两点之间的最优路径

弄懂了 Dijkstra 算法，我们再来回答之前的问题，如何计算最 优 出行路线？

优化思路

从理论上讲，用 Dijkstra 算法可以计算出两点之间的最短路径。但是，对于一个超级大地图来说，岔路口、道路都非常多，对应到图这种数据结构上来说，就有非常多的顶点和边。如果为了计算两点之间的最短路径，在一个超级大图上动用 Dijkstra 算法，遍历所有的顶点和边，显然会非常耗时。那我们有没有什么优化的方法呢？

做工程不像做理论，一定要给出个最优解。理论上算法再好，如果执行效率太低，也无法应用到实际的工程中。对于软件开发工程师来说，我们经常要根据问题的实际背景，对解决方案权衡取舍。类似出行路线这种工程上的问题，我们没有必要非得求出个绝对最优解。很多时候，为了兼顾执行效率，我们只需要计算出一个可行的次优解就可以了。

解决方案

有了这个原则，你能想出刚刚那个问题的优化方案吗？

虽然地图很大，但是两点之间的最短路径或者说较好的出行路径，只会出现在两点之间和两点附近的区块内。所以我们可以在整个大地图上，划出一个小的区块，这个小区块恰好可以覆盖住两个点，但又不会很大。我们只需要在这个小区块内部运行 Dijkstra 算法，这样就可以避免遍历整个大图，也就大大提高了执行效率。

不过你可能会说了，如果两点距离比较远，从北京某个地点到上海某个地点，那上面的这种处理方法，显然就不工作了，毕竟覆盖北京和上海的区块并不小。

分治思想

对于这样两点之间距离较远的路线规划，我们可以把北京、上海各看作一个顶点，先规划大的出行路线。比如，如何从北京到上海，必须要经过某几个顶点，或者某几条干道，然后再细化每个阶段的小路线。

最少时间和最少红绿灯路径

这样，最短路径问题就解决了。我们再来看另外两个问题，最少时间和最少红绿灯。

前面讲最短路径的时候，每条边的权重是路的长度。在计算最少时间的时候，算法还是不变，我们只需要把边的权重，从路的长度变成经过这段路所需要的时间。不过，这个时间会根据拥堵情况时刻变化。如何计算车通过一段路的时间呢？这是一个蛮有意思的问题，你可以自己思考下。

每经过一条边，就要经过一个红绿灯。关于最少红绿灯的出行方案，实际上，我们只需要把每条边的权值改为 1 即可，算法还是不变，可以继续使用前面讲的 Dijkstra 算法。不过，边的权值为 1，也就相当于无权图了，我们还可以使用之前讲过的广度优先搜索算法。因为我们前面讲过，广度优先搜索算法计算出来的两点之间的路径，就是两点的最短路径。

不过，这里给出的所有方案都非常粗糙，只是为了给你展示，如何结合实际的场景，灵活地应用算法，让算法为我们所用，真实的地图软件的路径规划，要比这个复杂很多。而且，比起 Dijkstra 算法，地图软件用的更多的是类似 A* 的启发式搜索算法，不过也是在 Dijkstra 算法上的优化罢了。

计算得分最高的前 k 个翻译结果

利用 Dijkstra 算法的核心思想，就可以拿来解决下面这个看似完全不相关的问题。这个问题是我之前工作中遇到的真实的问题，为了在较短的篇幅里把问题介绍清楚，我对背景做了一些简化。

我们有一个翻译系统，只能针对单个词来做翻译。如果要翻译一整个句子，我们需要将句子拆成一个一个的单词，再丢给翻译系统。针对每个单词，翻译系统会返回一组可选的翻译列表，并且针对每个翻译打一个分，表示这个翻译的可信程度。

针对每个单词，我们从可选列表中，选择其中一个翻译，组合起来就是整个句子的翻译。每个单词的翻译的得分之和，就是整个句子的翻译得分。随意搭配单词的翻译，会得到一个句子的不同翻译。针对整个句子，我们希望计算出得分最高的前 k 个翻译结果，你会怎么编程来实现呢？

当然，最简单的办法还是借助回溯算法，穷举所有的排列组合情况，然后选出得分最高的前 k 个翻译结果。但是，这样做的时间复杂度会比较高，是 O(m^n)，其中，m 表示平均每个单词的可选翻译个数，n 表示一个句子中包含多少个单词。

解决方案

实际上，这个问题可以借助 Dijkstra 算法的核心思想，非常高效地解决。每个单词的可选翻译是按照分数从大到小排列的，所以 a0-b0-c0 肯定是得分最高组合结果。我们把 a0-b0-c0 及得分作为一个对象，放入到优先级队列中。

我们每次从优先级队列中取出一个得分最高的组合，并基于这个组合进行扩展。扩展的策略是每个单词的翻译分别替换成下一个单词的翻译。比如 a0-b0-c0 扩展后，会得到三个组合，a1-b0-c0、a0-b1-c0、a0-b0-c1。我们把扩展之后的组合，加到优先级队列中。重复这个过程，直到获取到 k 个翻译组合或者队列为空。

时间复杂度

我们来看，这种实现思路的时间复杂度是多少？

假设句子包含 n 个单词，每个单词平均有 m 个可选的翻译，我们求得分最高的前 k 个组合结果。每次一个组合出队列，就对应着一个组合结果，我们希望得到 k 个，那就对应着 k 次出队操作。每次有一个组合出队列，就有 n 个组合入队列。优先级队列中出队和入队操作的时间复杂度都是 O(logX)，X 表示队列中的组合个数。所以，总的时间复杂度就是 O(k*n*logX)。那 X 到底是多少呢？

k 次出入队列，队列中的总数据不会超过 k*n，也就是说，出队、入队操作的时间复杂度是 O(log(k*n))。所以，总的时间复杂度就是 O(k*n*log(k*n))，比之前的指数级时间复杂度降低了很多。

总结引申

今天，我们学习了一种非常重要的图算法，Dijkstra 最短路径算法。实际上，最短路径算法还有很多，比如 Bellford 算法、Floyd 算法等等。如果感兴趣，你可以自己去研究。

关于 Dijkstra 算法，我只讲了原理和代码实现。对于正确性，我没有去证明。之所以这么做，是因为证明过程会涉及比较复杂的数学推导。这个并不是我们的重点，你只要掌握这个算法的思路就可以了。

这些算法实现思路非常经典，掌握了这些思路，我们可以拿来指导、解决其他问题。

49 | A* 启发式搜索算法

搜索算法可视化对比

用 A* 搜索算法实现寻路功能

魔兽世界、仙剑奇侠传这类 MMRPG 游戏，有一个非常重要的功能，那就是人物角色自动寻路。当人物处于游戏地图中的某个位置的时候，我们用鼠标点击另外一个相对较远的位置，人物就会自动地绕过障碍物走过去。这个功能是怎么实现的呢？

实际上，这是一个非常典型的搜索问题。人物的起点就是他当下所在的位置，终点就是鼠标点击的位置。我们需要在地图中，找一条从起点到终点的路径。这条路径要绕过地图中所有障碍物，并且看起来要是一种非常聪明的走法。所谓“聪明”，笼统地解释就是，走的路不能太绕。理论上讲，最短路径显然是最聪明的走法，是这个问题的最优解。

不过，如果图非常大，那 Dijkstra 最短路径算法的执行耗时会很多。在真实的软件开发中，我们面对的是超级大的地图和海量的寻路请求，算法的执行效率太低，这显然是无法接受的。

实际上，像出行路线规划、游戏寻路，这些真实软件开发中的问题，一般情况下，我们都不需要非得求最优解。在权衡路线规划质量和执行效率的情况下，我们只需要寻求一个次优解就足够了。那如何快速找出一条接近于最短路线的次优路线呢？

Dijkstra 算法存在跑偏的问题

这个快速的路径规划算法，就是我们今天要学习的 A* 算法。实际上，A* 算法是对 Dijkstra 算法的优化和改造。

Dijkstra 算法有点儿类似 BFS 算法，它每次找到跟起点最近的顶点，往外扩展。这种往外扩展的思路，其实有些盲目。为什么这么说呢？我举一个例子来给你解释一下。下面这个图对应一个真实的地图，每个顶点在地图中的位置，我们用一个二维坐标（x，y）来表示，其中，x 表示横坐标，y 表示纵坐标。

在 Dijkstra 算法的实现思路中，我们用一个优先级队列，来记录已经遍历到的顶点以及这个顶点与起点的路径长度。顶点与起点路径长度越小，就越先被从优先级队列中取出来扩展，从图中举的例子可以看出，尽管我们找的是从 s 到 t 的路线，但是最先被搜索到的顶点依次是 1，2，3。通过肉眼来观察，这个搜索方向跟我们期望的路线方向是反着的，路线搜索的方向明显“跑偏”了。

之所以会“跑偏”，那是因为

  • 我们是按照顶点与起点的路径长度的大小，来安排出队列顺序的，与起点越近的顶点，就会越早出队列
  • 我们并没有考虑这个顶点到终点的距离，所以，在地图中，尽管 1，2，3 三个顶点离起始顶点最近，但离终点却越来越远

如何避免跑偏问题

如果我们综合更多的因素，把这个顶点到终点可能还要走多远也考虑进去，综合来判断哪个顶点该先出队列，那是不是就可以避免“跑偏”呢？

当我们遍历到某个顶点的时候，从起点走到这个顶点的路径长度是确定的，我们记作 g(i)（i 表示顶点编号）。但是，从这个顶点到终点的路径长度，我们是未知的。虽然确切的值无法提前知道，但是我们可以用其他估计值来代替。

这里我们可以通过这个顶点跟终点之间的直线距离，也就是欧几里得距离，来近似地估计这个顶点跟终点的路径长度。我们把这个距离记作 h(i)（i 表示这个顶点的编号），专业的叫法是启发函数（heuristic function）。

因为欧几里得距离的计算公式会涉及比较耗时的开根号计算，所以，我们一般通过另外一个更加简单的距离计算公式，那就是曼哈顿距离（Manhattan distance）。曼哈顿距离是两点之间横纵坐标的距离之和。计算的过程只涉及加减法、符号位反转，所以比欧几里得距离更加高效。

int hManhattan(Vertex v1, Vertex v2) {
  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* 算法代码实现

其实 A* 算法就是对 Dijkstra 算法的简单改造。

class Vertex {
    public int id;
    public int dist; // 从起始顶点，到这个顶点的距离，也就是 g(i)
    public int f; // 新增：f(i) = g(i) + h(i)
    public int x, y; // 新增：顶点在地图中的坐标
    // ...
}

public void astar(int s, int t) {
    int[] predecessor = new int[this.v];
    // 核心区别：按照顶点的 f 值构建的小顶堆，而不是按照 dist
    PriorityQueue queue = new PriorityQueue(this.v);
    boolean[] inqueue = new boolean[this.v];
    vertexes[s].dist = 0;
    vertexes[s].f = 0; // 初始化 f
    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);
            Vertex nextVertex = vertexes[e.tid];
            if (minVertex.dist + e.w < nextVertex.dist) { // 更新条件仍然和 dijkstra 算法一致
                nextVertex.dist = minVertex.dist + e.w;
                nextVertex.f = nextVertex.dist + hManhattan(nextVertex, vertexes[t]);  // 更新 f
                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);
}

跟 Dijkstra 算法的代码实现主要有 3 点区别：

  • 优先级队列构建的方式不同：A* 算法是根据 f 值来构建优先级队列，而 Dijkstra 算法是根据 dist 值来构建优先级队列
  • A* 算法在更新顶点 dist 值的时候，会同步更新 f 值
  • 循环结束的条件也不一样：Dijkstra 算法是在终点出队列的时候才结束，A* 算法是一旦遍历到终点就结束

A* 算法找到的不是最短路径

尽管 A* 算法可以更加快速地找到从起点到终点的路线，但是它并不能像 Dijkstra 算法那样，找到最短路线。这是为什么呢？

要找出起点 s 到终点 t 的最短路径，最简单的方法是，通过回溯穷举所有从 s 到达 t 的不同路径，然后对比找出最短的那个。不过很显然，回溯算法的执行效率非常低，是指数级的。

Dijkstra 算法在此基础之上，利用动态规划的思想，对回溯搜索进行了剪枝，只保留起点到某个顶点的最短路径，继续往外扩展搜索。动态规划相较于回溯搜索，只是换了一个实现思路，但它实际上也考察到了所有从起点到终点的路线，所以才能得到最优解。

A* 算法之所以不能像 Dijkstra 算法那样能找到最短路径，主要原因是两者的 while 循环结束条件不一样

  • Dijkstra 算法是在终点出队列的时候才结束
    • 当终点出队列的时候，终点的 dist 值是优先级队列中所有顶点的最小值
    • 即便再运行下去，终点的 dist 值也不会再被更新了
  • A* 算法是一旦遍历到终点就结束
    • A* 算法利用贪心算法的思路，每次都找 f 值最小的顶点出队列，一旦搜索到终点就不在继续考察其他顶点和路线了
    • 它并没有考察所有的路线，也就不可能找出最短路径了

借助 A* 算法解决游戏寻路问题

搞懂了 A* 算法，我们再来看下，如何借助 A* 算法解决今天的游戏寻路问题？

要利用 A* 算法解决这个问题，我们只需要把地图，抽象成图就可以了。不过，游戏中的地图跟我们平常用的地图是不一样的，因为游戏中的地图并不像我们现实生活中那样，存在规划非常清晰的道路，更多的是宽阔的荒野、草坪等。所以，我们没法把岔路口抽象成顶点，把道路抽象成边。

实际上，我们可以换一种抽象的思路，把整个地图分割成一个一个的小方块。在某一个方块上的人物，只能往上下左右四个方向的方块上移动。我们可以把每个方块看作一个顶点。两个方块相邻，我们就在它们之间连两条有向边，并且边的权值都是 1。所以，这个问题就转化成了，在一个有向有权图中，找某个顶点到另一个顶点的路径问题。将地图抽象成边权值为 1 的有向图之后，我们就可以套用 A* 算法，来实现游戏中人物的自动寻路功能了。

总结引申

我们今天讲的 A* 算法属于一种启发式搜索算法（Heuristically Search Algorithm）。实际上，启发式搜索算法并不仅仅只有 A* 算法，还有很多其他算法，比如 IDA* 算法、蚁群算法、遗传算法、模拟退火算法等。如果感兴趣，你可以自行研究下。

启发式搜索算法利用估价函数避免“跑偏”，贪心地朝着最有可能到达终点的方向前进。这种算法找出的路线，并不是最短路线。但是，实际的软件开发中的路线规划问题，我们往往并不需要非得找最短路线。所以，鉴于启发式搜索算法能很好地平衡路线质量和执行效率，它在实际的软件开发中的应用更加广泛。

2017-12-14

posted @ 2017-12-14 11:42  白乾涛  阅读(11908)  评论(1)  编辑  收藏  举报