算法-11| 最短路径| Dijkstra算法
有向有权图
图的两种搜索算法，深度优先搜索和广度优先搜索。这两种算法主要是针对无权图的搜索算法。
针对有权图，也就是图中的每条边都有一个权重，该如何计算两点之间的最短路径（经过的边的权重和最小）呢？常用的最短路径算法（Shortest Path Algorithm）。
地图软件的最优路线是如何计算出来？底层依赖什么算法？这里的最优，比如最短路线、最少用时路线、最少红绿灯路线等等。
最短路线：解决软件开发中的实际问题最重要的一点就是建模，也就是将复杂的场景抽象成具体的数据结构。
把地图抽象成图，把每个岔路口看作一个顶点，岔路口与岔路口之间的路看作一条边，路的长度就是边的权重。 如果路是单行道，我们就在两个顶点之间画一条有向边；如果路是双行道，我们就在两个顶点之 间画两条方向不同的边。这样，整个地图就被抽象成一个有向有
权图。于是，要求解的问题就转化为，在一个有向有权图中，求两个顶点间的最短路径。
import java.util.LinkedList;
// 有向有权图的邻接表表示
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 implements Comparable<Vertex> {
public int id; // 顶点编号 ID
public int dist; // 从起始顶点到这个顶点的距离
public Vertex(int id, int dist) {
this.id = id;
this.dist = dist;
}
@Override
public int compareTo(Vertex o) { // 按照 dist 从小到大排序
if (o.dist > this.dist) return -1;
else return 1;
}
}
}
Dijkstra 算法
解决这个问题，有一个非常经典的算法，最短路径算法，单源最短路径算 法（一个顶点到一个顶点），最出名的莫过于 Dijkstra 算法。Dijkstra 算法的工作原理如下：
public void dijkstra(int s, int t) { // 从顶点 s 到顶点 t 的最短路径
int[] predecessor = new int[this.v]; // 用来还原最短路径
Vertex[] vertexes = new Vertex[this.v]; // 记录起始顶点到这个顶点的距离
for (int i = 0; i < v; ++i) { // 初始化 dist 为无穷大
vertexes[i] = new Vertex(i, Integer.MAX_VALUE);
}
PriorityQueue<Vertex> queue = new PriorityQueue<>(); // 小顶堆
boolean[] inQueue = new boolean[this.v]; // 标记是否进入过队列
queue.add(vertexes[s]); // 先把起始顶点放到队列中
vertexes[s].dist = 0;
inqueue[s] = true;
while (!queue.isEmpty()) {
Vertex minVertex= queue.poll(); // 取 dist 最小的顶点
if (minVertex.id == t) break; // 最短路径产生了
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
// 找到一条到 nextVertex 更短的路径
if (minVertex.dist + e.w < nextVertex.dist) {
nextVertex.dist = minVertex.dist + e.w; // 更新 dist
predecessor[nextVertex.id] = minVertex.id; // 更新前驱顶点
if (inqueue[nextVertex.id] == false) { // 如果没有在队列中
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);
}
用 vertexes 数组，记录从起始顶点到每个顶点的距离（dist）。起初，我们把所有顶点的 dist 都初始化为无穷大（也就是代码中的 Integer.MAX_VALUE）。我们把起始顶点的 dist 值 初始化为 0，然后将其放到优先级队列中。 我们从优先级队列中取出 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 值 之后，如果这个顶点已经在优先级队列中了，就不要再将它重复添加进去了。
Dijkstra 算法的时间复杂度
在刚刚的代码实现中，最复杂就是 while 循环嵌套 for 循环那部分代码了。while 循环最多会执 行 V 次（V 表示顶点的个数），而内部的 for 循环的执行次数不确定，跟每个顶点的相邻边的 个数有关，分别记作 E0，E1，E2，……，E(V-1)。
如果把这 V 个顶点的边都加起来， 最大也不会超过图中所有边的个数 E（E 表示边的个数）。 for 循环内部的代码涉及从优先级队列取数据、往优先级队列中添加数据、更新优先级队列中的 数据，这样三个主要的操作。
优先级队列是用堆来实现的，堆中的这几个操作，时间 复杂度都是 O(logV)（堆中的元素个数不会超过顶点的个数 V）。 所以，综合这两部分，再利用乘法原则，整个代码的时间复杂度就是 O(E*logV)。
如何计算最优出行路线？
从理论上讲，用 Dijkstra 算法可以计算出两点之间的最短路径。但是对于一 个超级大地图来说，岔路口、道路都非常多，对应到图这种数据结构上来说，就有非常多的顶点 和边。如果为了计算两点之间的最短路径，在一个超级大图上动用 Dijkstra 算法，遍历所有的 顶点和
边，显然会非常耗时。
做工程不像做理论，一定要给出个最优解。理论上算法再好，如果执行效率太低，也无法应用到 实际的工程中。对于软件开发工程师来说，我们经常要根据问题的实际背景，对解决方案权衡取 舍。类似出行路线这种工程上的问题，我们没有必要非得求出个绝对最优解。很
多时候，为了兼 顾执行效率，我们只需要计算出一个可行的次优解就可以了。
优化方案
虽然地图很大，但是两点之间的最短路径或者说较好的出行路径，并不会很“发散”，只会出现在两点之间和两点附近的区块内。所以可以在整个大地图上，划出一个小的区块，这个小区块恰好可以覆盖住两个点，但又不会很大。只需要在这个小区块内部运行 Dijkstra 算
法， 这样就可以避免遍历整个大图，也就大大提高了执行效率。
如果两点距离比较远，从北京海淀区某个地点，到上海黄浦区某个地点，那 上面的这种处理方法，显然就不工作了，毕竟覆盖北京和上海的区块并不小。
对于这样两点之间距离较远的路线规划，可以把北京海淀区或者北京看作一个顶点，把上海黄浦区或者上海看作一个顶点，先规划大的出行路线。比如如何从北京到上海，必须要经过某几个顶点，或者某几条干道，再细化每个阶段的小路线。 这样，最短路径问题就解决了
最少时间和最少红绿灯
最短路径问题时，每条边的权重是路的长度。在计算最少时间的时候，算法还是不变，只需要把边的权重，从路的长度变成经过这段路所需要的时间。不过，这个时间会根据拥堵情况时刻变化。如何计算车通过一段路的时间呢？
每经过一条边，就要经过一个红绿灯。关于最少红绿灯的出行方案，实际上，我们只需要把每条边的权值改为 1 即可，算法还是不变，继续使用Dijkstra算法。不过，边的权值为1，也就相当于无权图了，还可以使用广度优先搜索算法。
广度优先搜索算法计算出来的两点之间的路径，就是两点的最短路径。
真实的地图软件的路径规划，要比这个复杂很多；比起Dijkstra 算法，地图软件用的更多的是类似 A* 的启发式搜索算法，不过也是在 Dijkstra 算法上的优化罢了。
总结
一种非常重要的图算法，Dijkstra 最短路径算法。实际上，最短路径算法还有很多，比如 Bellford 算法、Floyd 算法等等。
Dkijstra 算法不是贪心算法，它是动态规划算法，求得的解全局最优解。
广度优先算法遍历无权图中一点s到另 一点t的路径，就是它的最短路径。
在计算最短时间的出行路线中，如何获得通过某条路的时间呢？这个题目很有意思；
获取通过某条路的时间：通过某条路的时间与①路长度②路况(是否平坦等)③拥堵情况④红 绿灯个数等因素相关。获取这些因素后就可以建立一个回归模型(比如线性回归)来估算时间。
其中①②④因素比较固定，容易获得。③是动态的，但也可以通过
- a.与交通部门合作获得路段 拥堵情况；
- b.联合其他导航软件获得在该路段的在线人数；
- c.通过现在时间段正好在次路段的 其他用户的真实情况等方式估算。
