单源最短路径

前言

给定一个带权有向图G=（V,E），其中每条边的权是一个实数。另外，还给定V中的一个顶点，称为源。现在要计算从源到其他所有各顶点的最短路径长度。这里的长度就是指路上各边权之和。这个问题通常称为单源最短路径问题。

求取单源最短路径一般有两种算法，Bellman ford算法以及Dijkstra算法。Bellman ford算法可适应有负权重的图，而Dijkstra算法则只能用于正权重无环图。

环路

如上图，一条最短路径是不可能包含环路的。环路包含两种情况，一种是负环路，如上图最下边的路径，它的最短路径为无限小，因为s、e、f、g的环路中，可以无限循环e、f，那么权重值可以无限降低。

最短路径也不可能包含正环路的，比如s、c、d、g的路径，不可能重复c、d，因为这样会增加路径的距离，完全可以减去正环路。

所以，最小路径中是不包含环路的。

松驰操作

求取单源最短路径需要用到松驰技术。对于每个节点来说，我们维持一个属性 v.d ，用来记录从源节点s到结点v的最短路径权重的上界。在算法开始时，使用如下方式进行初始化。

public void init_single_source(MatrixGraph graph, Vertex s){
    List list = graph.mList;
    for (Vertex vertex : list) {
        vertex.d = Integer.MAX_VALUE;
        vertex.pre = null;
    }
    s.d = 0;
}

设置源节点s.d等于0，其它节点v.d为无穷大，任意节点的前驱节点为空。

public void relax(Vertex u, Vertex v, int w){
    if (v.d > u.d + w) {
        v.d = u.d + w;
        v.pre = u;
    }
}

松驰操作，就是比较当前节点和前驱节点。如果前驱节点 d 加上边的权重值少于本节点的 d 值，则更新本节点 d 值。

Bellman ford算法

首先指出，图的任意一条最短路径既不能包含负权回路，也不会包含正权回路，因此它最多包含|v|-1条边。

其次，从源点s可达的所有顶点如果 存在最短路径，则这些最短路径构成一个以s为根的最短路径树。Bellman-Ford算法的迭代松弛操作，实际上就是按每个点实际的最短路径（虽然我们还不知道，但它一定存在）的层次，逐层生成这棵最短路径树的过程。

注意，每一次遍历，都可以从前一次遍历的基础上，找到此次遍历的部分点的单源最短路径。如：这是第i次遍历，那么，通过数学归纳法，若前面单源最短路径层次为1~（i-1）的点全部已经得到，而单源最短路径层次为i的点，必定可由单源最短路径层次为i-1的点集得到，从而在下一次遍历中充当前一次的点集，如此往复迭代，[v]-1次后，若无负权回路，则我们已经达到了所需的目的--得到每个点的单源最短路径。（注意：这棵树的每一次更新，可以将其中的某一个子树接到另一个点下）

最后，我们在第[v]次更新中若没有新的松弛，则输出结果，若依然存在松弛，则输出 false 表示无解。

public boolean bellman_ford(){
    MatrixGraph graph = initDigraph();
    Vertex s = graph.mList.get(0);
    init_single_source(graph, s);
    List list = graph.mList;
    MatrixEdge[][] edges = graph.mEdges;
    List edgeList = new ArrayList<>();
    int arrayLength = graph.maxLength;
    MatrixEdge edge = null;
    for (int i = 0; i < arrayLength; i++) {
        for (int j = 0; j < arrayLength; j++) {
            edge = edges[i][j];
            if (edge != null) {
                edgeList.add(edge);
            }
        }
    }
    //每条边都要循环 list .size()-1 次，才能计算出正确答案。
    //因为s到最远的端点最多要经过 list .size()-1 条边，如果松驰次数少了
    //某个前顶点的d值之前改变后，就不会得到反馈。
    for (int i = 1; i < list.size(); i++) {
        for (int j = 0; j < edgeList.size(); j++) {
            edge = edgeList.get(j);
            relax(edge.v1, edge.v2, edge.weight);
        }
    }
    //第i个点经过i-1次数松驰就能得到最短距离
    //最远的点经过 edgeList.size()-1 次松驰也会得到最短距离。
    //所以，再次遍历，如果还存在能松驰的情况，那一定是有环路，这样的情况不存在最短距离。
    for (int i = 0; i < edgeList.size(); i++) {
        edge = edgeList.get(i);
        if (edge.v2.d > edge.v1.d + edge.weight) {
            return false;
        }
    }
    for (Vertex vertex : list) {
        System.out.println(vertex);
    }
    return true;
}

为什么一定要松驰 V-1 次，因为一个顶点到另一个顶点最多需要经过 V-1 条边。而且，我们在做松驰操作的时候，选取的第一条边未必就经过初始顶点，每次松驰所有边之后，顶点的d值均有可能减少，所以要松驰这么多次，以便得到最后正确答案。另外本算法的复杂度是 VE

Dijkstra算法

Dijkstra算法在运行过程中维持的关键信息是一组结点集合q，且q是最小优先队列，图中的所有结点均被保存在q中，不停地从q中取出第一个节点，也是d值最小的节点，将与d节点有边相连的节点进行松驰操作。

因为Dijkstra算法总是选择图中d值最小的点进行松驰，使用的是贪心策略。因为最短路径也一定是各条子路径都是最短的，所以此算法是有效的。

代码如下：

public void dijkstra(){
    MatrixGraph graph = initDigraph();
    Vertex s = graph.mList.get(0);
    init_single_source(graph, s);
    Vertex[] datas = new Vertex[graph.mList.size()];
    for (int i = 0; i < graph.mList.size(); i++) {
        datas[i] = graph.mList.get(i);
    }
    MinPriorityQueue queue = new MinPriorityQueue(datas);
    Vertex u = null;
    MatrixEdge edge = null;
    while (queue.size() > 0) {
        u = (Vertex) queue.heapExtractMin();
        int index = graph.mList.indexOf(u);
        for (int i = 0; i < VERTEX_NUM; i++) {
            edge = graph.mEdges[index][i];
            if (edge != null) {
                relax(edge.v1, edge.v2, edge.weight);
                //上一步进行了松驰操作，所以此处需要重新检测最小优先队列的属性
                //以维持queue仍是最小优先队列
                //此算法的关键就是正确设计最小优先队列
                queue.checkMinHeap();
            }
        }
    }
  for (Vertex vertex : graph.mList) {
      System.out.println(vertex);
  }
}

最小优先队列使用最小堆技术，代码详见本人github

如果不用最小堆，还有另一种实现：

/**
 * dijkstra算法的另一种实现
 * 核心原理都是顶点分成两部分，一部分是已经查验过的，一部分是未查验过的
 * 已检查的顶点集合已得到的最小距离，它们必然是其它顶点最短距离的一个环节
 * 每次在未查验顶点集合中，选取d值最小顶点，松驰d相关的所有边
 */
public void dijkstra2(){
    MatrixGraph graph = initDigraph();
    Vertex s = graph.mList.get(0);
    init_single_source(graph, s);
    List notCheckList = new ArrayList<>();
    notCheckList.addAll(graph.mList);
    List checkList = new ArrayList<>();
    Vertex u = null;
    MatrixEdge edge = null;
    while (notCheckList.size() > 0) {
        //找出最小的d值所在顶点
        int small = 0;
        for (int i = 0; i < notCheckList.size(); i++) {
            if (notCheckList.get(i).d < notCheckList.get(small).d) {
                small = i;
            }
        }
        u = notCheckList.get(small);
        int index = graph.mList.indexOf(u);
        for (int i = 0; i < VERTEX_NUM; i++) {
            edge = graph.mEdges[index][i];
            if (edge != null) {
                relax(edge.v1, edge.v2, edge.weight);
            }
        }
        notCheckList.remove(u);
        checkList.add(u);
    }
    for (Vertex vertex : graph.mList) {
        System.out.println(vertex);
    }
}

这两种写法其实背后的原理一样。