数据结构与算法--最短路径之Dijkstra算法
加权图中，我们很可能关心这样一个问题：从一个顶点到另一个顶点成本最小的路径。比如从成都到北京，途中还有好多城市，如何规划路线，能使总路程最小；或者我们看重的是路费，那么如何选择经过的城市可以使得总路费降到最低？
首先路径是有向的，最短路径需要考虑到各条边的方向。
权值不一定就是指距离，还可以是费用等等...
最短路径的定义：在一幅有向加权图中，从顶点s到顶点t的最短路径是所有从s到t的路径中权值最小者。
为此，我们先要定义有向边以及有向图。
加权有向图的实现
首先是有向边。
package Chap7;
public class DiEdge {
private int from;
private int to;
private double weight;
public DiEdge(int from, int to, double weight) {
this.from = from;
this.to = to;
this.weight = weight;
}
public int from() {
return from;
}
public int to() {
return to;
}
public double weight() {
return weight;
}
@Override
public String toString() {
return "(" +
from +
"->" + to +
" " + weight +
')';
}
}
比起无向边Edge类，更简单些，因为两个顶点有明显的先后顺序。
然后是加权有向图。
package Chap7;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class EdgeWeightedDiGraph<Item> {
private int vertexNum;
private int edgeNum;
// 邻接表
private List<List<DiEdge>> adj;
// 顶点信息
private List<Item> vertexInfo;
public EdgeWeightedDiGraph(List<Item> vertexInfo) {
this.vertexInfo = vertexInfo;
this.vertexNum = vertexInfo.size();
adj = new ArrayList<>();
for (int i = 0; i < vertexNum; i++) {
adj.add(new LinkedList<>());
}
}
public EdgeWeightedDiGraph(List<Item> vertexInfo, int[][] edges, double[] weight) {
this(vertexInfo);
for (int i = 0; i < edges.length; i++) {
DiEdge edge = new DiEdge(edges[i][0], edges[i][1], weight[i]);
addDiEdge(edge);
}
}
public EdgeWeightedDiGraph(int vertexNum) {
this.vertexNum = vertexNum;
adj = new ArrayList<>();
for (int i = 0; i < vertexNum; i++) {
adj.add(new LinkedList<>());
}
}
public EdgeWeightedDiGraph(int vertexNum, int[][] edges, double[] weight) {
this(vertexNum);
for (int i = 0; i < edges.length; i++) {
DiEdge edge = new DiEdge(edges[i][0], edges[i][1], weight[i]);
addDiEdge(edge);
}
}
public void addDiEdge(DiEdge edge) {
adj.get(edge.from()).add(edge);
edgeNum++;
}
// 返回与某个顶点依附的所有边
public Iterable<DiEdge> adj(int v) {
return adj.get(v);
}
public List<DiEdge> edges() {
List<DiEdge> edges = new LinkedList<>();
for (int i = 0; i < vertexNum; i++) {
for (DiEdge e : adj(i)) {
edges.add(e);
}
}
return edges;
}
public int vertexNum() {
return vertexNum;
}
public int edgeNum() {
return edgeNum;
}
public Item getVertexInfo(int i) {
return vertexInfo.get(i);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(vertexNum).append("个顶点, ").append(edgeNum).append("条边。\n");
for (int i = 0; i < vertexNum; i++) {
sb.append(i).append(": ").append(adj.get(i)).append("\n");
}
return sb.toString();
}
public static void main(String[] args) {
List<String> vertexInfo = List.of("v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
int[][] edges = {{4, 5}, {5, 4}, {4, 7}, {5, 7}, {7, 5}, {5, 1}, {0, 4}, {0, 2},
{7, 3}, {1, 3}, {2, 7}, {6, 2}, {3, 6}, {6, 0}, {6, 4}};
double[] weight = {0.35, 0.35, 0.37, 0.28, 0.28, 0.32, 0.38, 0.26, 0.39, 0.29,
0.34, 0.40, 0.52, 0.58, 0.93};
EdgeWeightedDiGraph<String> graph = new EdgeWeightedDiGraph<>(vertexInfo, edges, weight);
System.out.println("该图的邻接表为\n"+graph);
System.out.println("该图的所有边："+ graph.edges());
}
}实现和加权无向图差不多，就改了addEdge和adj方法。addEdge由于边有向，不会对称地存储边；adj方法不像无向图那样邻接表中有重复的边，有向图中邻接表中的边都是唯一的，所以全部加入即可。
最短路径的数据结构
1、最短路径树中的边
和深度优先、广度优先搜索一样，我们将用到一个edgeTo[]表示一个树形结构，edgeTo[v]表示树中连接顶点v和其父结点的边（也就是起点s到v的路径上最后一条边）。
2、起点到各个顶点的最短距离
和Prim算法类似，需要一个distTo[]。Prim算法中它存放的是：到某个顶点权值最小的那条边。而最短路径中，distTo[v]存放的是：从起点s开始到某顶点v的最短路径长度。我们约定到起点s的最短路径长度为0，即distTo[s] = 0；同时约定从起点s到不可达的顶点的距离均为正无穷。
最短路径算法的基础基于一个被称为松弛的简单操作。放松一条边v -> w意味着检查s到w的最短路径是否是 先从s到v，再从v到w。如果是就更新相关数据结构的内容；如果不是，不作更改。用代码可以表示为
// v -> w, v和w是边edge的两个顶点
// distTo[v] ：s到v的最短距离；distTo[w]：s到w的最短距离
if (distTo[v] + edge.weight() < distTo[w]) {
distTo[w] = distTo[v] + e.weight();
edgeTo[w] = edge;
}再用一幅图加深理解。
先看左边两个图：s到v的最短距离是3.1，s到w的最短距离是3.3。当在顶点v时，检查它的邻接点w，边v -> w的权值是1.3，从s到w的当然不能先从s到v，再从v到w，因为这俩加起来都4.4，比原来s到w的方案还要费劲，所以不会更改distTo[w]和edgeTo[w]。此时我们说v -> w这条边失效并忽略它。
再看右边两个图：原先s到w的方案距离为7.2，现在我们换条路走，从s先到v，再从v到w，只有4.4！这是条到w更近的路。所以更新，distTo[w]改成4.4，到s到w的最后一条边edgeTo[w]也改成了v- > w这条边。此时就称边v -> w放松成功（可以想象成一根紧绷的橡皮筋，它的长度比较长；橡皮筋放松后，长度变短。）
对顶点的放松就是：放松由该顶点引出的所有边。
在实现之前，对于最短路径算法我们需要了解得更多，来看几个命题。
当且仅当对于从v -> w的任意一条边，都有dist[w] <= distTo[v] + edge.weight()，那么s到w的路径都是最短路径。
Dijkstra算法能解决边权值非负的加权有向图的单点最短路径问题，换句话说，当遇到有负权值的边，或者想通过一次运算就找到任意顶点到任意顶点的最短路径，Dijkstra就不适用了。
如果v是从起点s可达的，那么边v -> w只会被放松一次，放松v时，必有dist[w] <= distTo[v] + edge.weight()，该等式在算法整个流程都成立，所以distTo[w]只能减小。而distTo[v]不会改变，因为每次都选择distTo[]最小的顶点，之后的放松操作不可能使得任何distTo[]的值小于dist[v]。也就是说，每次选择distTo[]最小的顶点，它的值不会小于那些已经放松过的顶点的最短路径值distTo[v]，也不会大于任意未被放松过的顶点。所有从s可达的顶点都会按照distTo[]里最短路径的权值来依次放松。
最短路径算法也可以处理无向图，用有向图的数据类型，只是对应于无向图，每条边都会创建两条方向不同的有向边。例如，无向图中的边3-0，使用有向图创建3 -> 0和0 -> 3两条边，然后调用最短路径算法即可。
Dijkstra算法的实现
package Chap7;
import java.util.*;
public class Dijkstra {
private DiEdge[] edgeTo;
private double[] distTo;
private Map<Integer, Double> minDist;
public Dijkstra(EdgeWeightedDiGraph<?> graph, int s) {
edgeTo = new DiEdge[graph.vertexNum()];
distTo = new double[graph.vertexNum()];
minDist = new HashMap<>();
for (int i = 0; i < graph.vertexNum(); i++) {
distTo[i] = Double.POSITIVE_INFINITY; // 1.0 / 0.0为INFINITY
}
// 到起点距离为0
distTo[s] = 0.0;
relax(graph, s);
while (!minDist.isEmpty()) {
relax(graph, delMin());
}
}
private int delMin() {
Set<Map.Entry<Integer, Double>> entries = minDist.entrySet();
Map.Entry<Integer, Double> min = entries.stream().min(Comparator.comparing(Map.Entry::getValue)).get();
int key = min.getKey();
minDist.remove(key);
return key;
}
private void relax(EdgeWeightedDiGraph<?> graph, int v) {
for (DiEdge edge : graph.adj(v)) {
int w = edge.to();
if (distTo[v] + edge.weight() < distTo[w]) {
distTo[w] = distTo[v] + edge.weight();
edgeTo[w] = edge;
if (minDist.containsKey(w)) {
minDist.replace(w, distTo[w]);
System.out.println(w);
} else {
minDist.put(w, distTo[w]);
}
}
}
}
public double distTo(int v) {
return distTo[v];
}
public boolean hasPathTo(int v) {
return distTo[v] != Double.POSITIVE_INFINITY;
}
public Iterable<DiEdge> pathTo(int v) {
if (hasPathTo(v)) {
LinkedList<DiEdge> path = new LinkedList<>();
for (DiEdge edge = edgeTo[v]; edge != null; edge = edgeTo[edge.from()]) {
path.push(edge);
}
return path;
}
return null;
}
public static void main(String[] args) {
List<String> vertexInfo = List.of("v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
int[][] edges = {{4, 5}, {5, 4}, {4, 7}, {5, 7}, {7, 5}, {5, 1}, {0, 4}, {0, 2},
{7, 3}, {1, 3}, {2, 7}, {6, 2}, {3, 6}, {6, 0}, {6, 4}};
double[] weight = {0.35, 0.35, 0.37, 0.28, 0.28, 0.32, 0.38, 0.26, 0.39, 0.29,
0.34, 0.40, 0.52, 0.58, 0.93};
EdgeWeightedDiGraph<String> graph = new EdgeWeightedDiGraph<String>(vertexInfo, edges, weight);
Dijkstra dijkstra = new Dijkstra(graph, 0);
for (int i = 0; i < graph.vertexNum(); i++) {
System.out.print("0 to " + i + ": ");
System.out.print("(" + dijkstra.distTo(i) + ") ");
System.out.println(dijkstra.pathTo(i));
}
}
}
/* Outputs
0 to 0: (0.0) []
0 to 1: (1.05) [(0->4 0.38), (4->5 0.35), (5->1 0.32)]
0 to 2: (0.26) [(0->2 0.26)]
0 to 3: (0.9900000000000001) [(0->2 0.26), (2->7 0.34), (7->3 0.39)]
0 to 4: (0.38) [(0->4 0.38)]
0 to 5: (0.73) [(0->4 0.38), (4->5 0.35)]
0 to 6: (1.5100000000000002) [(0->2 0.26), (2->7 0.34), (7->3 0.39), (3->6 0.52)]
0 to 7: (0.6000000000000001) [(0->2 0.26), (2->7 0.34)]
*/和Prim算法的即时版本的几乎一样！两种算法都是添加边的方式来构造一棵树：Prim算法每次添加的是离整棵树（各个顶点）最近的树外的顶点；Dijkstra算法每次添加的是离起点最近的树外顶点。
Dijkstra不需要marked[]来记录被访问过的顶点了，因为每条边v -> w只会被放松一次，每个顶点也只会放松一次。放松后的顶点的最短路径长度一定满足dist[w] <= distTo[v] + edge.weight()，当想重复放松某个顶点时，会因为无法通过以下条件而被跳过。
if (distTo[v] + edge.weight() < distTo[w]) { }我们还是来跟着图走一遍。
放松顶点0，2、4被加入Map，distTo[2]为0 -> 2的权值，distTo[4]为0 -> 4的权值。
按权值放松顶点2，0 -> 2添加到树中。7被加入Map。distTo[7]为0 -> 2 -> 7的权值和。
放松顶点4，0 -> 4被加入到树中。5加到Map。dsitTo[5]为0 -> 4 -> 5的权值和。0 -> 4 -> 7没有0 ->2 -> 7路径短所以不更新distTo[7]。
放松顶点7，2- > 7加入到树中。3加入到Map。distTo[3]为0 -> 2 -> 3 -> 7的权值和，0 -> 2 -> 7 -> 5的权值和没有0 -> 4 -> 5的权值和小，所有不更新distTo[5]
放松顶点5， 4 ->5加入到树中，1加入到Map，distTo[1]为0 -> 4 -> 5 -> 1的权值和。0 -> 4 -> 5 -> 7的权值和没有0 -> 2 -> 7的权值和小，所以不更新distTo[7]
放松顶点3，7 -> 3加入到树中。6加入到Map。distTo[6]为0 -> 2 -> 7 -> 3 -> 6的权值和。
放松顶点1，5 -> 1加入到树。0 -> 4 -> 5 ->1 -> 3的权值和由于没有0 -> 2 -> 7 -> 3 的权值和小，所以不更新distTo[3]。
放松顶点6， 3 -> 6加入到树中。至此所有顶点都已放松一次，算法结束。
by @sunhaiyu
2017.9.23
