知识点二十四：最短路径——Dijkstra 算法

前言

像 Google 地图、百度地图、高德地图这样的地图软件，你只需要输入起始、结束地址，地图就会给你规划一条最优出行路线。这里说的最优路线，有很多种定义，比如最短路线、最少用时路线、最少红绿灯路线等等。那么，这些地图软件的最优路线是如何计算出来的吗？底层依赖了什么算法呢？

图的最短路径问题

关于图上的搜索算法，深度优先搜索和广度优先搜索这两种算法主要是针对无权图的搜索算法。而针对有权图，也就是当图中的每条边都有一个权重时，我们该如何计算图上两个顶点之间的最短路径（经过的边的权重和最小）呢？

例如刚刚提到的地图软件中的路线规划问题，这里头最优问题包含三个：最短路线、最少用时和最少红绿灯。我们先解决最简单的，求最短路线。解决软件开发中的实际问题，最重要的一点就是建模，也就是将复杂的场景抽象成具体的数据结构。我们之前也提到过，图这种数据结构的表达能力很强，显然，把地图抽象成图最合适不过了。我们把每个岔路口看作一个顶点，岔路口与岔路口之间的路看作一条边，路的长度就是边的权重。如果路是单行道，我们就在两个顶点之间画一条有向边；如果路是双行道，我们就在两个顶点之间画两条方向不同的边。这样，整个地图就被抽象成一个有向有权图。具体的代码实现如下：

public class Graph { // 有向有权图的邻接表存储方法
  private LinkedList<Edge> adj[]; // 邻接表
  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));
  }

  private 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;
    }
  }
  // 下面这个类是为了dijkstra实现中，顶点的定义
  private class Vertex {
    public int id; // 顶点编号ID
    public int dist; // 从起始顶点到这个顶点的距离
    public Vertex(int id, int dist) {
      this.id = id;
      this.dist = dist;
    }
  }
}

于是，我们要求解的最短路线问题就转化为，在一个有向有权图中，求两个顶点间的最短路径。想要解决这个问题，就要用到图上的一种非常经典的算法：最短路径算法，更加准确地说，是单源最短路径算法（即从一个顶点到另一个顶点）。

Dijkstra 算法

提到最短路径算法，最出名的莫过于 Dijkstra 算法了。这个算法的原理解释起来稍微有点儿复杂，单纯的文字描述可能不是很好懂。所以，我们结合具体的代码来理解。

// 因为Java提供的优先级队列，没有暴露更新数据的接口，所以我们需要重新实现一个
private class PriorityQueue { // 根据vertex.dist构建小顶堆
  private Vertex[] nodes;
  private int count;
  public PriorityQueue(int v) {
    this.nodes = new Vertex[v+1];
    this.count = v;
  }
  public Vertex poll() 
  public void add(Vertex vertex) 
  // 更新结点的值，并且从下往上堆化，重新符合堆的定义。时间复杂度O(logn)。
  public void update(Vertex vertex) 
  public boolean isEmpty() 
}

public void dijkstra(int s, int t) { // 求从顶点s到顶点t的最短路径
  int[] predecessor = new int[this.v]; // predecessor 数组记录每个顶点的前驱顶点，用来还原最短路径
  Vertex[] vertexes = new Vertex[this.v]; // vertexes 数组记录从起始顶点到每个顶点的距离（dist）
  for (int i = 0; i < this.v; ++i) {
    vertexes[i] = new Vertex(i, Integer.MAX_VALUE);
  }
  PriorityQueue queue = new PriorityQueue(this.v);// 小顶堆
  boolean[] inqueue = new boolean[this.v]; // 标记是否进入过队列，避免将一个顶点多次添加到优先级队列中
  vertexes[s].dist = 0; // 把起始顶点 s 的 dist 值初始化为 0
  queue.add(vertexes[s]); // 将起始顶点 s 添加到优先级队列中
  inqueue[s] = true;
  while (!queue.isEmpty()) { // 循环直到队列为空
    Vertex minVertex= queue.poll(); // 取堆顶元素并删除
    if (minVertex.id == t) break; // 找到终止顶点 t，最短路径产生了
    for (int i = 0; i < adj[minVertex.id].size(); ++i) {
      Edge e = adj[minVertex.id].get(i); // 取出一条与 minVetex相连的边 e
      Vertex nextVertex = vertexes[e.tid]; // 取出的有向边为：minVertex-->nextVertex
      // nextVertex.dist 记录了从起始顶点到这条取出的边 e的终止顶点（e.tid）的距离
      if (minVertex.dist + e.w < nextVertex.dist) { 
        nextVertex.dist = minVertex.dist + e.w; // 若存在更短的路径，则更新nextVertex.dist
        predecessor[nextVertex.id] = minVertex.id; // 记录nextVertex的前驱顶点
        if (inqueue[nextVertex.id] == true) { // 如果这个顶点已经在优先级队列中了，就不要再将它重复添加进去了。
          queue.update(nextVertex); // 直接更新队列中该顶点的dist值即可
        } else {
          queue.add(nextVertex);
          inqueue[nextVertex.id] = true; // 新的顶点进入队列后，要在 inqueue数组中标记
        }
      }
    }
  }
  // 输出最短路径
  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);
}

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

接下来，每次我们从优先级队列中取出 dist 最小的顶点 minVertex，然后考察这个顶点可达的所有顶点（代码中的 nextVertex）。如果 minVertex 的 dist 值加上 minVertex 与 nextVertex 之间边的权重 w 小于 nextVertex 当前的 dist 值，也就是说，存在另一条更短的路径，它经过 minVertex 到达 nextVertex。那我们就把 nextVertex 的 dist 更新为 minVertex 的 dist 值加上 w，然后把 nextVertex 加入到优先级队列中。重复这个过程，直到找到终止顶点 t 或者队列为空。

以上就是 Dijkstra 算法的核心逻辑。除此之外，代码中还有两个额外的变量，predecessor 数组和 inqueue 数组。predecessor 数组的作用是为了还原最短路径，它记录每个顶点的前驱顶点。最后，我们通过递归的方式，将这个路径打印出来。inqueue 数组是为了避免将一个顶点多次添加到优先级队列中，每当更新了某个顶点的 dist 值之后，如果这个顶点已经在优先级队列中了，就不要再将它重复添加进去了，直接更新队列中该顶点的dist值即可。

现在我们来看下，Dijkstra 算法的时间复杂度是多少？

在刚刚的代码实现中，最复杂就是 while 循环嵌套 for 循环那部分代码了。while 循环最多会执行 V 次（V 表示顶点的个数），而内部的 for 循环的执行次数不确定，跟每个顶点的相邻边的个数有关，我们把它们分别记作 E0，E1，E2，……，E(V-1)。如果把这 V 个顶点的边都加起来，最大也不会超过图中所有边的个数 E（E 表示边的个数）。也就是说，while循环最多遍历图上的所有 V 个顶点，针对每个顶点的for循环执行次数跟该顶点的相邻边的个数有关，全部顶点的相邻边加起来不超过图上所有边数 E，因此这部分嵌套循环代码的执行次数最多不超过 E。此外，for 循环内部的代码涉及从优先级队列取数据、往优先级队列中添加数据、更新优先级队列中的数据这样三个主要的操作。我们知道，优先级队列是用堆来实现的，堆中的元素个数不会超过顶点的个数 V，所以堆中的这几个操作，时间复杂度都是 O(logV)。综合这两部分，再利用乘法原则，整个代码的时间复杂度就是 O(E*logV)。

地图软件是如何计算出最优出行路线的？

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

实际上，做工程不像做理论，一定要给出个最优解。理论上算法再好，如果执行效率太低，也无法应用到实际的工程中。因此，实际的工程项目中，软件开发工程师经常要根据问题的实际背景，对解决方案权衡取舍。类似出行路线这种工程上的问题，我们没有必要非得求出个绝对最优解。很多时候，为了兼顾执行效率，我们只需要计算出一个可行的次优解就可以了。虽然地图很大，但是两点之间的最短路径或者说较好的出行路径，并不会很“发散”，只会出现在两点之间和两点附近的区块内。所以我们可以在整个大地图上，划定一个小的区块，这个小区块恰好可以覆盖住两个点，但又不会很大。我们只需要在这个小区块内部运行 Dijkstra 算法，这样就可以避免遍历整个大图，也就大大提高了执行效率。

不过，如果两点距离比较远，比如，从北京海淀区某个地点，到上海黄浦区某个地点，那上面的这种处理方法显然就不工作了，毕竟覆盖北京和上海的区块并不小。对于这种两点之间距离较远的路线规划，我们可以把北京海淀区或者北京看作一个顶点，把上海黄浦区或者上海看作一个顶点，先规划大的出行路线。比如，如何从北京到上海，必须要经过某几个顶点，或者某几条干道，然后再细化每个阶段的小路线。

我们再来看另外两个问题，如何求最少用时路线和最少红绿灯的路线。

• 求最少用时路线
  前面讲最短路径的时候，每条边的权重是路的长度。在计算最少时间的时候，算法还是不变，我们只需要把边的权重，从路的长度变成经过这段路所需要的时间。不过，如何获得通过某条路的时间呢？一般来说，通过某条路的时间与 ①路长度 ②路况(是否平坦等) ③拥堵情况 ④红绿灯个数 ⑤道路限速等因素有关。获取这些因素后就可以建立一个回归模型(比如线性回归)来估算所需要的时间。其中①②④⑤因素比较固定，容易获得，而③是动态的，但也可以通过以下几种方式估算。
  ⑴ 与交通部门合作获得路段拥堵情况；
  ⑵ 联合其他导航软件获得在该路段的在线人数；
  ⑶ 通过现在时间段正好在此路段的其他用户的真实情况估算
• 求最少红绿灯的路线
  每经过一条边，就相当于要经过一个红绿灯，从一条道路进入另一条道路。关于最少红绿灯的出行方案，实际上，我们只需要把每条边的权值改为 1 即可，算法还是不变，可以继续使用前面讲的 Dijkstra 算法。不过，边的权值为 1，也就相当于无权图了，我们还可以使用之前讲过的广度优先搜索算法。因为广度优先搜索算法计算出来的两点之间的路径，就是两点的最短路径。

不过，这里给出的所有方案都非常粗糙，真实的地图软件的路径规划，要比这个复杂很多。而且，比起 Dijkstra 算法，地图软件用的更多的是类似 A* 的启发式搜索算法，不过，它其实也是在 Dijkstra 算法上的优化罢了。

Dijkstra 算法的其它应用

Dijkstra 最短路径算法是一种非常重要的图算法，这个算法的核心思想，可以拿来指导、解决其他问题，比如下面这个看似完全不相关的问题。

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

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

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

实际上，这个问题可以借助 Dijkstra 算法的核心思想，非常高效地解决。每个单词的可选翻译列表是按照分数从大到小排列的，所以 a₀​b₀​c₀​ 肯定是得分最高的组合结果。我们把 a₀​b₀​c₀​​ 及其得分作为一个对象，放入到优先级队列中。接下来，我们每次从优先级队列中取出一个得分最高的翻译组合，并基于这个组合进行扩展，扩展的策略是将这个翻译组合中的每个单词的翻译分别替换成该单词的可选翻译列表中的下一个翻译。比如 a₀​b₀​c₀​ 扩展后，会得到三个新的翻译组合，a₁​b₀​c₀​、a₀​b₁​c₀​、a₀​b₀​c₁​。我们把扩展之后的组合，加到优先级队列中。重复这个过程，直到获取到 k 个翻译组合或者队列为空。具体的过程如下图所示。

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

假设句子包含 n 个单词，每个单词平均有 m 个可选的翻译，我们要求得分最高的前 k 个翻译组合结果。每当有一个组合出队列，就对应着得到一个翻译结果，我们希望得到 k 个，那就对应着 k 次出队操作。每次有一个组合出队列，就有 n 个组合入队列，因为组合中 n 个单词都要分别替换成下一个翻译结果，因此，一个组合有 n 种替换结果。优先级队列中出队和入队操作的时间复杂度都是 O(logX)，X 表示队列中的组合个数。所以，总的时间复杂度就是 O(k * n * logX)。那 X 到底是多少呢？k 次出入队列操作，队列中的总组合个数不会超过 k * n，也就是说，出队、入队操作的时间复杂度是 O(log(k * n))。所以，总的时间复杂度就是 O(k *n *log(k *n))，比回溯算法的指数级时间复杂度降低了很多。

小结

一、图的最短路径问题
1.关于图上的搜索算法，深度优先搜索和广度优先搜索这两种算法主要是针对无权图的搜索算法。而针对有权图，也就是当图中的每条边都有一个权重时，图上两个顶点之间的最短路径，是指经过的边的权重之和最小。
2.图的表达能力强，类似求最短路线的问题都可以转化为：在一个有向有权图中，求两个顶点间的最短路径。
3.要解决这类图上两个顶点间的最短路径问题，有个非常经典的算法，叫最短路径算法，更准确的地说，是单源最短路径算法（一个顶点到一个顶点）。
4.常见的最短路径算法：Dijkstra算法，Bellford算法，Floyd算法等

二、Dijkstra算法
1.概念：计算图上一个顶点到其他顶点的最短路径，是一种单源最短路径算法。
2.时间复杂度：O(E*log V)，E表示边的个数，V表示顶点的个数。
3.Dijkstra实际上可以看作动态规划，求得的解是全局最优解。

参考

《数据结构与算法之美》
王争
前Google工程师

GeeksforGeeks上对Dijkstra算法的介绍：https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/

Dijkstra算法对应的 LeetCode 习题：https://leetcode.com/problems/network-delay-time/