加权有向图与最短路径问题（Dijstra算法，Java实现）

1 加权有向图

加权无向图的边没有方向，一条边会同时出现在该边的两个顶点的邻接表中，为了能够处理含有方向性的图的问题，引入了加权有向图。

1.1 加权有向边的实现

API设计：

类名	DirectedEdge
构造方法	public DirectedEdge(int v, int w, double weight)：通过顶点v、w以及权重weight构造一个边对象
成员方法	1. public double weight()：获取边的权重值 2.public int from()：获取有向边的起点 3.public int to()：获取有向边的终点
成员变量	1.private final int v：起点 2.private final int w：终点 3.private final double weight：当前边的权重

代码：

public class DirectedEdge {
    private final int v;//起点
    private final int w;//终点
    private final double weight;//当前边的权重

    //通过顶点v、w以及权重weight构造一个边对象
    public DirectedEdge(int v, int w, double weight) {
        this.v = v;
        this.w = w;
        this.weight = weight;
    }

    //获取边的权重值
    public double weight(){
        return weight;
    }

    //获取有向边的起点
    public int from(){
        return v;
    }

    //获取有向边的终点
    public int to(){
        return w;
    }
}

1.2 加权有向图的实现

在加权无向图的基础上，把加权无向边替换成加权有向边即是加权有向图。

API设计：

类名	EdgeWeightedDigraph
构造方法	public EdgeWeightedDigraph(int V)：创建一个含有V个顶点的空加权有向图
成员方法	1.public int V()：获取图中顶点的数量 2.public int E()：获取图中边的数量 3.public void addEdge(DirectedEdge e)：向加权有向图中添加一条边e 4.public Deque adj(int v)：获取由顶点v指出的所有边 5.public Deque edges()：获取加权有向图的所有边
成员变量	1.private final int V：记录顶点数量 2.private int E：记录边数量 3.private Deque[] adj：邻接表

代码：

public class EdgeWeightedDigraph {
    //顶点总数
    private final int V;
    //边的总数
    private int E;
    //邻接表
    private Deque<DirectedEdge>[] adj;

    //创建一个含有V个顶点的空加权有向图
    public EdgeWeightedDigraph(int V) {
        //初始化顶点数量
        this.V = V;
        //初始化边的数量
        this.E = 0;
        //初始化邻接表
        this.adj = new Deque[V];
        for (int i = 0; i < adj.length; i++) {
            adj[i] = new LinkedList<>();
        }
    }

    //获取图中顶点的数量
    public int V() {
        return V;
    }

    //获取图中边的数量
    public int E() {
        return E;
    }


    //向加权有向图中添加一条边e
    public void addEdge(DirectedEdge e) {
        //边e是有方向的，所以只需要让e出现在起点的邻接表中即可
        int v = e.from();
        adj[v].offer(e);
        E++;
    }

    //获取由顶点v指出的所有的边
    public Deque<DirectedEdge> adj(int v) {
        return adj[v];
    }

    //获取加权有向图的所有边
    public Deque<DirectedEdge> edges() {
        //遍历图中的每一个顶点，得到该顶点的邻接表，遍历得到每一条边，添加到队列中返回即可
        Deque<DirectedEdge> allEdges = new LinkedList<>();
        for (int v=0; v<V; v++){
            for (DirectedEdge edge : adj[v]) {
                allEdges.offer(edge);
            }
        }
        return allEdges;
    }
}

2 最短路径

加权有向图可以应用到实际生活中的很多场景，例如在地图中，找到顶点a与顶点b之间的路径，这条路径可以是距离最短，或者是时间最短，又或者是费用最小等，如果把距离/时间/费用看作成本，问题就转换为找到a和b之间成本最小的路径，即最短路径问题。

2.1 最短路径定义及性质

1 定义

在一副加权有向图中，从顶点s到顶点t的最短路径是指所有从顶点s到顶点t的路径中总权重最小的那条路径。

2 性质

1. 路径具有方向性；
2. 权重不一定是距离，也可以是时间、费用等内容，最短路径指的是总权重最低；
3. 只考虑连通图。如果s和t不可达，它们之间就不存在最短路径，为了简化问题，这里只考虑连通图；
4. 最短路径不一定唯一。从一个顶点到另一个顶点的最短路径可能有多条，这里只需找出一条即可；

3 最短路径树

1. 给定一幅加权有向图和顶点s，以s为起点的一棵最短路径树是图的一幅子图，它包含起点s以及从s可达的所有顶点；
2. 这棵有向树的根结点为s，树的每条路径都是有向图中的一条最短路径；

2.2 松弛技术

松弛这个词来源于生活：一条橡皮筋沿着两个顶点的某条路径紧紧拉开，如果这两个顶点之间的路径不止一条，还有存在更短的路径，那么把皮筋转移到更短的路径上，皮筋就可以放松了，松弛这种简单的原理刚好可以用来计算最短路径树。

边的松弛：

松弛边v->w意味着检查从s到w的最短路径是否是先从s到v，再从v到w：

1. 如果是，将v-w这条边加入到最短路径树中，并更新edgeTo和distTo中的内容：edgeTo[w] = v->w，distTo[w] = distTo[v] + v->w的权重；
2. 如果不是，忽略v->w；

顶点的松弛：

顶点的松弛是基于边的松弛完成的，只需要把某个顶点指出的所有边松弛，那么该顶点就松弛完毕。例如要松弛顶点v，只需遍历v的邻接表，把每一条边都松弛，那么顶点v就松弛了。

2.3 Dijstra算法思想

算法解析

1. 找出权重最小的顶点；
2. 对于该顶点的邻居，检查是否有前往它们的最短路径，如果有，就更新其权重（松弛）；
3. 重复这个过程，直到对图中的每个顶点都这样做了；

算法实现

1. 成员变量edgeTo存储起点到当前顶点的最短路径的最后一条边，成员变量distTo存储起点到当前顶点的最短路径的总权重；
2. 开始给定图G和起点s，初始化起点s到s的最短路径的总权重distTo[s]=0，起点s到其他顶点的总权重为无穷大；
3. 随着算法的执行，不断使用松弛技术处理图的边和顶点，更新edgeTo和distTo中的数据，最终就得到了最短路径树；

2.4 Dijstra算法具体实现

类名	DijkstraSP
构造方法	public DijkstraSP(EdgeWeightedDigraph G, int s)：根据一幅加权有向图G和顶点s，创建一个计算顶点为s的最短路径树对象
成员方法	1.private void relax(EdgeWeightedDigraph G, int v)：松弛图G中的顶点v 2.public double distTo(int v)：获取从起点s到顶点v的最短路径的总权重 3.public boolean hasPathTo(int v)：判断从起点s到顶点v是否可达 4.public Deque pathTo(int v)：查询从起点s到顶点v的最短路径中所有的边
成员变量	1.private DirectedEdge[] edgeTo：索引代表顶点，值表示从起点s到当前顶点的最短路径上的最后一条边 2.private double[] distTo：索引代表顶点，值为从起点s到当前顶点的最短路径的总权重 3.private indexMinPriorityQueue pq：存放树中顶点与非树中顶点之间的有效横切边

代码：

public class DijkstraSP {
    //索引代表顶点，值表示从顶点s到当前顶点的最短路径上的最后一条边
    private DirectedEdge[] edgeTo;
    //索引代表顶点，值表示从顶点s到当前顶点的最短路径的总权重
    private double[] distTo;
    //存放树中顶点与非树中顶点之间的有效横切边
    private IndexMinPriorityQueue<Double> pq;

    //根据一副加权有向图G和起点s，创建一个计算起点为s的最短路径树对象
    public DijkstraSP(EdgeWeightedDigraph G, int s){
        //初始化edgeTo
        this.edgeTo = new DirectedEdge[G.V()];
        //创建一个和图的顶点数一样大小的double数组，表示权重，并且初始化数组中的内容为无穷大，无穷大即表示不存在这样的边
        this.distTo = new double[G.V()];
        for (int i = 0; i < distTo.length; i++) {
            distTo[i] = Double.POSITIVE_INFINITY;
        }
        //创建一个和图的顶点数一样大小的索引最小优先队列，存储有效横切边
        this.pq = new IndexMinPriorityQueue<>(G.V());
        //默认让顶点s进入树中，但s顶点目前没有与树中其他的顶点相连接，因此初始化distTo[s]=0.0
        distTo[s] = 0.0;
        //使用顶点s和权重0.0初始化pq
        pq.insert(s,0.0);

        //遍历pq
        while(!pq.isEmpty()){
            //松弛图G中的顶点
            relax(G, pq.delMin());
        }
    }

    //松弛图G中的顶点v
    private void relax(EdgeWeightedDigraph G, int v){
        //松弛顶点v就是松弛顶点v邻接表中的每一条边，遍历邻接表
        for (DirectedEdge edge : G.adj(v)) {
            //获取到该边的终点w
            int w = edge.to();
            //通过松弛技术，判断从起点s到顶点w的最短路径是否需要先从顶点s到顶点v再由顶点v到顶点w
            if (distTo(v) + edge.weight() < distTo(w)){
                distTo[w] = distTo[v] + edge.weight();
                edgeTo[w] = edge;

                //如果顶点w已经存在于索引最小优先队列pq中，则重置顶点w的权重
                if (pq.contains(w)){
                    pq.changeItem(w, distTo(w));
                }else{
                    //如果顶点w没有出现在优先队列pq中，则把顶点w及其权重加入到pq中
                    pq.insert(w, distTo(w));
                }
            }
        }
    }

    //获取从顶点s到顶点v的最短路径的总权重
    public double distTo(int v){
        return distTo[v];
    }

    //判断从顶点s到顶点v是否可达
    public boolean hasPathTo(int v){
        return distTo[v]<Double.POSITIVE_INFINITY;
    }

    //查询从起点s到顶点v的最短路径中所有的边
    public Deque<DirectedEdge> pathTo(int v){
        //如果顶点s到v不可达，则返回null
        if (!hasPathTo(v)){
            return null;
        }
        //创建队列保存最短路径的边
        Deque<DirectedEdge> allEdges = new LinkedList<>();
        //从顶点v开始，逆向寻找，一直找到顶点s为止，而起点s为最短路径树的根结点，所以edgeTo[s]=null
        while (true){
            DirectedEdge e = edgeTo[v];
            if (e==null){
                break;
            }
            allEdges.offer(e);
            v = e.from();
        }
        return allEdges;
    }
}

public class Test {
    public static void main(String[] args) {
        EdgeWeightedDigraph g = new EdgeWeightedDigraph(8);
        DirectedEdge e1 = new DirectedEdge(4,5,0.35); DirectedEdge e2 = new DirectedEdge(4,7,0.37);
        DirectedEdge e3 = new DirectedEdge(5,7,0.28); DirectedEdge e4 = new DirectedEdge(5,4,0.35);
        DirectedEdge e5 = new DirectedEdge(7,5,0.28); DirectedEdge e6 = new DirectedEdge(5,1,0.32);
        DirectedEdge e7 = new DirectedEdge(0,4,0.38); DirectedEdge e8 = new DirectedEdge(0,2,0.26);
        DirectedEdge e9 = new DirectedEdge(7,3,0.39); DirectedEdge e10 = new DirectedEdge(1,3,0.29);
        DirectedEdge e11 = new DirectedEdge(2,7,0.34); DirectedEdge e12 = new DirectedEdge(6,2,0.40);
        DirectedEdge e13 = new DirectedEdge(3,6,0.52); DirectedEdge e14 = new DirectedEdge(6,0,0.58);
        DirectedEdge e15 = new DirectedEdge(6,4,0.93);

        g.addEdge(e1);g.addEdge(e2);g.addEdge(e3);g.addEdge(e4);
        g.addEdge(e5);g.addEdge(e6);g.addEdge(e7);g.addEdge(e8);
        g.addEdge(e9);g.addEdge(e10);g.addEdge(e11);g.addEdge(e12);
        g.addEdge(e13);g.addEdge(e14);g.addEdge(e15);

        //根据图g和顶点0，构建PrimMST对象
        DijkstraSP dsp = new DijkstraSP(g, 0);
        //获取起点0到顶点6的最短路径
        Deque<DirectedEdge> edges = dsp.pathTo(6);
        //打印输出
        for (DirectedEdge edge : edges) {
            System.out.println(edge.from() + "->" + edge.to() + ":" + edge.weight());
        }
    }
}

3->6:0.52
7->3:0.39
2->7:0.34
0->2:0.26

注：

类IndexMinPriority可在索引最小优先队列的实现_sc179的博客-CSDN博客中找到