数据结构 -- 加权有向图

一、概述

加权有向图是在有向图的基础上，边的赋予权重信息的。

二、实现

2.1 加权有向图的边

2.1.1 API设计

类名	DirectedEdge
构造方法	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：当前边的权重

2.1.2 实现

/**
 * 加权有向图边的表示
 * @date 2021/7/16 21:17
 */
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;
    }
}

2.2 加权有向图

2.2.1 API设计

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

2.2.2 实现

/**
 * 加权有向图
 * @date 2021/7/19 16:43
 */
public class EdgeWeightedDigraph {
    // 记录顶点数量
    private final int V;
    // 记录边的数量
    private int E;
    // 邻接表
    private Queue[] adj;

    // 创建一个包含V个顶点的空加权有向图
    public EdgeWeightedDigraph(int V) {
        this.V = V;
        // 初始化邻接表
        this.adj = new Queue[V];
        // 初始化邻接表中的空队列
        for (int i = 0; i < adj.length; i++) {
            adj[i] = new Queue<DirectedEdge>();
        }
    }

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

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

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

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

    // 获取加权有向图的所有边
    public Queue<DirectedEdge> edges(){
        // 创建一个队列，存储所有的边
        Queue<DirectedEdge> allEdge = new Queue<>();
        // 遍历顶点，拿到每个顶点的邻接表
        for (int v = 0; v < this.V; v++) {
            // 遍历邻接表，拿到邻接表中的每条边存储到队列中
            for (DirectedEdge e : adj(v)) {
                allEdge.enqueue(e);
            }
        }
        return allEdge;
    }
}

2.2.3 测试

/**
 * 测试加权有向图
 * @date 2021/7/19 17:55
 */
public class EdgeWeightedDigraphTest {
    public static void main(String[] args) {
        EdgeWeightedDigraph edgeWeightedDigraph = new EdgeWeightedDigraph(5);
        // 创建边
        DirectedEdge edge01 = new DirectedEdge(0, 1, 2);
        DirectedEdge edge04 = new DirectedEdge(0, 4, 2);
        DirectedEdge edge14 = new DirectedEdge(1, 4, 2);
        DirectedEdge edge13 = new DirectedEdge(1, 3, 2);
        DirectedEdge edge12 = new DirectedEdge(1, 2, 2);
        DirectedEdge edge34 = new DirectedEdge(3, 4, 2);
        DirectedEdge edge32 = new DirectedEdge(3, 2, 2);
        // 添加边
        edgeWeightedDigraph.addEdge(edge01);
        edgeWeightedDigraph.addEdge(edge04);
        edgeWeightedDigraph.addEdge(edge14);
        edgeWeightedDigraph.addEdge(edge13);
        edgeWeightedDigraph.addEdge(edge12);
        edgeWeightedDigraph.addEdge(edge34);
        edgeWeightedDigraph.addEdge(edge32);
        // 获取由0指出的所有边
        for (DirectedEdge directedEdge : edgeWeightedDigraph.adj(0)) {
            System.out.println(directedEdge.from()+"->"+directedEdge.to());
        }
    }
}

三、最短路径

3.1 概述

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

四、Dijkstra算法

4.1 最短路径树

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

4.2 松弛技术

4.2.1 边的松弛

放松边v->w意味着检查从s到w的最短路径是否先从s到v，然后再从v到w？如果是，则v-w这条边需要加入到最短路径树中，更新edgeTo和distTo中的容：edgeTo[w]=表示v->w这条边的DirectedEdge对象，distTo[w]=distTo[v]+v->w这条边的权重；如果不是，则忽略v->w这条边。

4.2.2 顶点的松弛

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

4.3 API设计

类名	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 Queue pathTo(int v):查询从起点s到顶点v的最短路径中所有的边
成员变量	1.private DirectedEdge[] edgeTo: 索引代表顶点，值表示从顶点s到当前顶点的最短路径上的最后一条边 2.private double[] distTo: 索引代表顶点，值从顶点s到当前顶点的最短路径的总权重 3.private IndexMinPriorityQueue pq:存放树中顶点与非树中顶点之间的有效横切边

4.4 实现

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

    // 根据一副加权有向图G和顶点s，创建一个计算顶点为s的最短路径树对象
    public DijkstraSP(EdgeWeightedDigraph G, int s) {
        // 创建一个和图的顶点数一样大小的DirectedEdge数组，表示边
        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);
        // 遍历有效边队列
        while (!pq.isEmpty()) {
            // 松弛图G中的顶点
            relax(G, pq.delMin());
        }
    }

    // 松弛图G中的顶点v
    private void relax(EdgeWeightedDigraph G, int v) {
        // 松弛顶点v就是松弛顶点v邻接表中的每一条边，遍历邻接表
        for (DirectedEdge e : G.adj(v)) {
            // 获取边e的终点
            int w = e.to();
            // 起点s到顶点w的权重是否大于起点s到顶点v的权重+边e的权重，如果大于，则修改s->w的路径：edgeTo[w]=e,并修改distTo[v]=distTo[v]+e.weight()，如果不大于，则忽略
            if (distTo(w) > distTo(v) + e.weight()) {
                distTo[w] = distTo[v] + e.weight();
                edgeTo[w] = e;
                // 如果顶点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 Queue<DirectedEdge> pathTo(int v) {
        // 如果顶点s到v不可达,则返回Null
        if (!hasPathTo(v)) {
            return null;
        }
        // 创建队列Queue保存最短路径的边
        Queue<DirectedEdge> edges = new Queue<>();
        // 从顶点v开始，逆向寻找，一直找到顶点s为止，而起点s为最短路径树的根节点，所以edgeTo[s]=null
        DirectedEdge e = null;
        while (true) {
            e = edgeTo[v];
            if (e == null) {
                break;
            }
            edges.enqueue(e);
            v = e.from();
        }
        return edges;
    }
}

4.5 测试

/**
 * 测试Dijkstra算法
 * @date 2021/7/19 19:25
 */
public class DijkstraSPTest {
    public static void main(String[] args) {
        EdgeWeightedDigraph edgeWeightedDigraph = new EdgeWeightedDigraph(5);
        // 创建边
        DirectedEdge edge01 = new DirectedEdge(0, 1, 2);
        DirectedEdge edge04 = new DirectedEdge(0, 4, 2);
        DirectedEdge edge14 = new DirectedEdge(1, 4, 2);
        DirectedEdge edge13 = new DirectedEdge(1, 3, 2);
        DirectedEdge edge12 = new DirectedEdge(1, 2, 2);
        DirectedEdge edge34 = new DirectedEdge(3, 4, 2);
        DirectedEdge edge32 = new DirectedEdge(3, 2, 2);
        // 添加边
        edgeWeightedDigraph.addEdge(edge01);
        edgeWeightedDigraph.addEdge(edge04);
        edgeWeightedDigraph.addEdge(edge14);
        edgeWeightedDigraph.addEdge(edge13);
        edgeWeightedDigraph.addEdge(edge12);
        edgeWeightedDigraph.addEdge(edge34);
        edgeWeightedDigraph.addEdge(edge32);
        // 根据图和顶点0，构建DijkstraSP对象
        DijkstraSP dijkstraSP = new DijkstraSP(edgeWeightedDigraph, 0);
        // 获取起点0到顶点6的最短路径
        Queue<DirectedEdge> edges = dijkstraSP.pathTo(3);
        // 打印输出
        for (DirectedEdge edge : edges) {
            System.out.println(edge.from()+"->"+edge.to()+": "+edge.weight());
        }
    }
}