数据结构与算法之图的进阶（有向图、拓扑排序、加权无向图、最小生成树、加权有向图、最短路径）

最新推荐文章于 2023-08-24 01:50:02 发布
最新推荐文章于 2023-08-24 01:50:02 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 图论 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52448922/article/details/121754510
版权
本文深入探讨了图论在信息技术中的应用，包括有向图的定义、API设计与实现，拓扑排序的概念、检测环的算法以及基于深度优先的顶点排序，加权无向图的表示及其在构建最小生成树中的Prim和Kruskal算法。此外，还讨论了加权有向图的表示以及最短路径问题。通过对这些基本概念和算法的理解，读者可以更好地应对复杂图数据结构的处理挑战。
摘要由CSDN通过智能技术生成

目录

一、有向图

在实际生活中，很多应用相关的图都是有方向性的，最直观的就是网络，可以从A页面通过链接跳转到B页面，那么a和b连接的方向是a->b,但不能说是b->a,此时我们就需要使用有向图来解决这一类问题，它和我们之前学习的无向图，最大的区别就在于连接是具有方向的，在代码的处理上也会有很大的不同。
在这里插入图片描述

1.1 有向图的定义及相关术语

定义：
有向图是一副具有方向性的图，是由一组顶点和一组有方向的边组成的，每条方向的边都连着一对有序的顶点。
出度：
由某个顶点指出的边的个数称为该顶点的出度。
入度：
指向某个顶点的边的个数称为该顶点的入度。
有向路径：
由一系列顶点组成，对于其中的每个顶点都存在一条有向边，从它指向序列中的下一个顶点。
有向环：
一条至少含有一条边，且起点和终点相同的有向路径。
在这里插入图片描述
一副有向图中两个顶点v和w可能存在以下四种关系：

  1. 没有边相连；
  2. 存在从v到w的边v—>w;
  3. 存在从w到v的边w—>v;
  4. 既存在w到v的边，也存在v到w的边，即双向连接；

理解有向图是一件比较简单的，但如果要通过眼睛看出复杂有向图中的路径就不是那么容易了。
在这里插入图片描述

1.2 有向图API设计

类名Digraph
构造方法Digraph(int V)：创建一个包含V个顶点但不包含边的有向图
成员方法1.public int V():获取图中顶点的数量
2.public int E():获取图中边的数量
3.public void addEdge(int v,int w):向有向图中添加一条边 v->w
4.public Queue adj(int v)：获取由v指出的边所连接的所有顶点
5.private Digraph reverse():该图的反向图
成员变量1.private final int V: 记录顶点数量
2.private int E: 记录边数量
3.private Queue[] adj: 邻接表

在api中设计了一个反向图，其因为有向图的实现中，用adj方法获取出来的是由当前顶点v指向的其他顶点，如果能得到其反向图，就可以很容易得到指向v的其他顶点。

1.3 有向图实现

public class Digraph {
    //顶点数目
    private final int V;
    //边的数目
    private int E;
    //邻接表
    private Queue<Integer>[] adj;

    public Digraph(int V){
        //初始化顶点数量
        this.V = V;
        //初始化边的数量
        this.E = 0;
        //初始化邻接表
        this.adj = new Queue[V];
        for (int i = 0; i < adj.length; i++) {
            adj[i] = new Queue<Integer>();
        }
    }

    //获取顶点数目
    public int V(){
        return V;
    }

    //获取边的数目
    public int E(){
        return E;
    }

    //向有向图中添加一条边 v->w
    public void addEdge(int v, int w) {
        //只需要让顶点w出现在顶点v的邻接表中，因为边是有方向的，最终，顶点v的邻接表中存储的相邻顶点的含义是：  v->其他顶点
        adj[v].enqueue(w);
        E++;
    }

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

    //该图的反向图
    private Digraph reverse(){
        //创建有向图对象
        Digraph r = new Digraph(V);

        for (int v = 0;v<V;v++){
            //获取由该顶点v指出的所有边
            for (Integer w : adj[v]) {//原图中表示的是由顶点v->w的边
                r.addEdge(w,v);//w->v
            }
        }
        return r;
    }
}

二、拓扑排序

在现实生活中，我们经常会同一时间接到很多任务去完成，但是这些任务的完成是有先后次序的。以我们学习java学科为例，我们需要学习很多知识，但是这些知识在学习的过程中是需要按照先后次序来完成的。从java基础，到jsp/servlet，到ssm，到springboot等是个循序渐进且有依赖的过程。在学习jsp前要首先掌握java基础和html基础，学习ssm框架前要掌握jsp/servlet之类才行。
在这里插入图片描述
为了简化问题，我们使用整数为顶点编号的标准模型来表示这个案例：
在这里插入图片描述
此时如果某个同学要学习这些课程，就需要指定出一个学习的方案，我们只需要对图中的顶点进行排序，让它转换为一个线性序列，就可以解决问题，这时就需要用到一种叫拓扑排序的算法。

拓扑排序：
给定一副有向图，将所有的顶点排序，使得所有的有向边均从排在前面的元素指向排在后面的元素，此时就可以明确的表示出每个顶点的优先级。下列是一副拓扑排序后的示意图：
在这里插入图片描述

2.1 检测有向图中的环

如果学习x课程前必须先学习y课程，学习y课程前必须先学习z课程，学习z课程前必须先学习x课程，那么一定是有问题了，我们就没有办法学习了，因为这三个条件没有办法同时满足。其实这三门课程x、y、z的条件组成了一个环：
在这里插入图片描述
因此，如果我们要使用拓扑排序解决优先级问题，首先得保证图中没有环的存在。

2.1.1 检测有向环的API设计

类名DirectedCycle
构造方法DirectedCycle(Digraph G)：创建一个检测环对象，检测图G中是否有环
成员方法1.private void dfs(Digraph G,int v)：基于深度优先搜索，检测图G中是否有环
2.public boolean hasCycle():判断图中是否有环
成员变量1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索
2.private boolean hasCycle: 记录图中是否有环
3.private boolean[] onStack:索引代表顶点，使用栈的思想，记录当前顶点有没有已经处于正在搜索的有向路径上

2.1.2 检测有向环实现

在API中添加了onStack[] 布尔数组，索引为图的顶点，当我们深度搜索时：

  1. 在如果当前顶点正在搜索，则把对应的onStack数组中的值改为true，标识进栈；
  2. 如果当前顶点搜索完毕，则把对应的onStack数组中的值改为false，标识出栈；
  3. 如果即将要搜索某个顶点，但该顶点已经在栈中，则图中有环；

在这里插入图片描述
在这里插入图片描述

代码：

public class DirectedCycle {
    //索引代表顶点，值表示当前顶点是否已经被搜索
    private boolean[] marked;
    //记录图中是否有环
    private boolean hasCycle;
    //索引代表顶点，使用栈的思想，记录当前顶点有没有已经处于正在搜索的有向路径上
    private boolean[] onStack;

    //创建一个检测环对象，检测图G中是否有环
    public DirectedCycle(Digraph G){
        //初始化marked数组
        this.marked = new boolean[G.V()];
        //初始化hasCycle
        this.hasCycle = false;
        //初始化onStack数组
        this.onStack = new boolean[G.V()];

        //找到图中每一个顶点，让每一个顶点作为入口，调用一次dfs进行搜索；避免非连通图中的有向环
        //被标记为true的顶点就不需要再作为入口进行搜索
        for (int v =0; v<G.V();v++){
            //判断如果当前顶点还没有搜索过，则调用dfs进行搜索
            if (!marked[v]){
                dfs(G,v);
            }
        }
    }

    //基于深度优先搜索，检测图G中是否有环
    private void dfs(Digraph G, int v){
        //把顶点v表示为已搜索
        marked[v] = true;

        //把当前顶点进栈
        onStack[v] = true;

        //进行深度搜索
        for (Integer w : G.adj(v)) {
            //判断如果当前顶点w没有被搜索过，则继续递归调用dfs方法完成深度优先搜索
            if (!marked[w]){
                dfs(G,w);
            }

            //判断当前顶点w是否已经在栈中，如果已经在栈中，证明当前顶点之前处于正在搜索的状态，那么现在又要搜索一次，证明检测到环了
            if (onStack[w]){
                hasCycle = true;
                return;
            }
        }
        //把当前顶点出栈
        onStack[v] = false;
    }

    //判断当前有向图G中是否有环
    public boolean hasCycle(){
        return hasCycle;
    }
}

2.2 基于深度优先的顶点排序

如果要把图中的顶点生成线性序列其实是一件非常简单的事，之前我们学习并使用了多次深度优先搜索，我们会发现其实深度优先搜索有一个特点，那就是在一个连通子图上，每个顶点只会被搜索一次，如果我们能在深度优先搜索的基础上，添加一行代码，只需要将搜索的顶点放入到线性序列的数据结构中，我们就能完成这件事。

2.2.1 顶点排序API设计

类名DepthFirstOrder
构造方法DepthFirstOrder(Digraph G)：创建一个顶点排序对象，生成顶点线性序列；
成员方法1.private void dfs(Digraph G,int v)：基于深度优先搜索，生成顶点线性序列
2.public Stack reversePost():获取顶点线性序列
成员变量1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索
2.private Stack reversePost: 使用栈，存储顶点序列

2.2.2 顶点排序实现

在API的设计中，我们添加了一个栈reversePost用来存储顶点，当我们深度搜索图时，每搜索完毕一个顶点，把该顶点放入到reversePost中，这样就可以实现顶点排序。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
代码：

public class DepthFirstOrder {
    //索引代表顶点，值表示当前顶点是否已经被搜索
    private boolean[] marked;
    //使用栈，存储顶点序列
    private Stack<Integer> reversePost;

    //创建一个检测环对象，检测图G中是否有环
    public DepthFirstOrder(Digraph G){
        //初始化marked数组
        this.marked = new boolean[G.V()];
        //初始化reversePost栈
        this.reversePost = new Stack<Integer>();

        //遍历图中的每一个顶点，让每个顶点作为入口，完成一次深度优先搜索
        for (int v = 0;v<G.V();v++){
            if (!marked[v]){
                dfs(G,v);
            }
        }
    }

    //基于深度优先搜索，把顶点排序
    private void dfs(Digraph G, int v){
        //标记当前v已经被搜索
        marked[v] = true;
        //通过循环深度搜索顶点v
        for (Integer w : G.adj(v)) {
            //如果当前顶点w没有搜索，则递归调用dfs进行搜索
            if (!marked[w]){
                dfs(G,w);
            }
        }
        //让顶点v进栈
        reversePost.push(v);
    }

    //获取顶点线性序列
    public Stack<Integer>  reversePost(){
        return reversePost;
    }
}

2.3 拓扑排序实现

前面已经实现了环的检测以及顶点排序，那么拓扑排序就很简单了，基于一幅图，先检测有没有环，如果没有环，则调用顶点排序即可。
API设计：

类名TopoLogical
构造方法TopoLogical(Digraph G)：构造拓扑排序对象
成员方法1.public boolean isCycle()：判断图G是否有环
2.public Stack order():获取拓扑排序的所有顶点
成员变量1.private Stack order: 顶点的拓扑排序

代码：

public class TopoLogical {
    //顶点的拓扑排序
    private Stack<Integer> order;

    //构造拓扑排序对象
    public TopoLogical(Digraph G) {
        //创建一个检测有向环的对象
        DirectedCycle cycle = new DirectedCycle(G);
        //判断G图中有没有环，如果没有环，则进行顶点排序：创建一个顶点排序对象
        if (!cycle.hasCycle()){
            DepthFirstOrder depthFirstOrder = new DepthFirstOrder(G);
            order = depthFirstOrder.reversePost();
        }
    }

    //判断图G是否有环
    private boolean isCycle(){
        return order==null;
    }

    //获取拓扑排序的所有顶点
    public Stack<Integer>  order(){
        return order;
    }
}
//测试类
public class TopoLogicalTest {
    public static void main(String[] args) {
        //准备有向图
        Digraph digraph = new Digraph(6);
        digraph.addEdge(0,2);
        digraph.addEdge(0,3);
        digraph.addEdge(2,4);
        digraph.addEdge(3,4);
        digraph.addEdge(4,5);
        digraph.addEdge(1,3);

        //通过TopoLogical对象堆有向图中的顶点进行排序
        TopoLogical topoLogical = new TopoLogical(digraph);

        //获取顶点的线性序列进行打印
        Stack<Integer> order = topoLogical.order();
        //进行字符串拼接
        StringBuilder sb = new StringBuilder();
        for (Integer w : order) {
        	//为了最后不出现横杠和箭头，用字符串拼接
        	//System.out.println(w+"->");
            sb.append(w+"->");//优化代码
        }
        String str = sb.toString();
        //标记最后的横杠和箭头
        int index = str.lastIndexOf("->");
        //截取最后横杠和箭头  0到index,最后输出即可
        str = str.substring(0,index);
        System.out.println(str);
    }
}

三、加权无向图

加权无向图是一种为每条边关联一个权重值或是成本的图模型。这种图能够自然地表示许多应用。在一副航空图中，边表示航线，权值则可以表示距离或是费用。在一副电路图中，边表示导线，权值则可能表示导线的长度即成本，或是信号通过这条先所需的时间。此时我们很容易就能想到，最小成本的问题，例如，从西安飞纽约，怎样飞才能使时间成本最低或者是金钱成本最低？

在下图中，从顶点 0 到顶点 4 有三条路径，分别为0-2-3-4,0-2-4,0-5-3-4,那我们如果要通过那条路径到达 4 顶点最好呢？此时就要考虑，那条路径的成本最低。
在这里插入图片描述

3.1 加权无向图边的表示

加权无向图中的边我们就不能简单的使用v-w两个顶点表示了，而必须要给边关联一个权重值，因此我们可以使用对象来描述一条边。
API设计：

类名Edge implements Comparable
构造方法Edge(int v,int w,double weight)：通过顶点v和w，以及权重weight值构造一个边对象
成员方法1.public double weight():获取边的权重值
2.public int either():获取边上的一个点
3.public int other(int vertex)):获取边上除了顶点vertex外的另外一个顶点
4.public int compareTo(Edge that)：比较当前边和参数that边的权重，如果当前边权重大，返回1 ，如果一样大，返回 0 ，如果当前权重小，返回 -1
成员变量1.private final int v：顶点一
2.private final int w：顶点二
3.private final double weight：当前边的权重

代码：

public class Edge implements Comparable<Edge> {
    private final int v;//顶点一
    private final int w;//顶点二
    private final double weight;//当前边的权重

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

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

    //获取边上的一个点
    public int either(){
        return v;
    }

    //获取边上除了顶点vertex外的另外一个顶点
    public int other(int vertex){
        if (vertex==v){
            return w;
        }else{
            return v;
        }
    }

    @Override
    public int compareTo(Edge that) {
        //使用一个遍历记录比较的结果
        int cmp;

        if (this.weight()>that.weight()){
            //如果当前边的权重值大，则让cmp=1；
            cmp = 1;
        }else if (this.weight()<that.weight()){
            //如果当前边的权重值小，则让cmp=-1；
            cmp=-1;
        }else{
            //如果当前边的权重值和that边的权重值一样大，则让cmp=0
            cmp = 0;
        }
        return cmp;
    }
}

3.2 加权无向图的实现

之前我们已经完成了无向图，在无向图的基础上，我们只需要把边的表示切换成Edge对象即可。
API设计：

类名EdgeWeightedGraph
构造方法EdgeWeightedGraph(int V)：创建一个含有V个顶点的空加权无向图
成员方法1.public int V():获取图中顶点的数量
2.public int E():获取图中边的数量
3.public void addEdge(Edge 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: 邻接表

代码：

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

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

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

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

    //向加权无向图中添加一条边e
    public void addEdge(Edge e) {
        //需要让边e同时出现在e这个边的两个顶点的邻接表中
        int v = e.either();
        int w = e.other(v);

        adj[v].enqueue(e);
        adj[w].enqueue(e);

        //边的数量+1
        E++;
    }

    //获取和顶点v关联的所有边
    public Queue<Edge> adj(int v) {
        return adj[v];
    }

    //获取加权无向图的所有边
    public Queue<Edge> edges() {

        //创建一个队列对象，存储所有的边
        Queue<Edge> allEdges = new Queue<>();

        //遍历图中的每一个顶点，找到该顶点的邻接表，邻接表中存储了该顶点关联的每一条边

        //因为这是无向图，所以同一条边同时出现在了它关联的两个顶点的邻接表中，需要让一条边只记录一次；
        for(int v =0;v<V;v++){
            //遍历v顶点的邻接表，找到每一条和v关联的边
            for (Edge e : adj(v)) {

                if (e.other(v)<v){
                    allEdges.enqueue(e);
                }

            }
        }
        return allEdges;
    }
}

四、最小生成树

之前学习的加权图，我们发现它的边关联了一个权重，那么我们就可以根据这个权重解决最小成本问题，但如何才能找到最小成本对应的顶点和边呢？最小生成树相关算法可以解决。
在这里插入图片描述

4.1 最小生成树定义及相关约定

定义：
图的生成树是它的一棵含有其所有顶点的无环连通子图，一副加权无向图的最小生成树它的一棵权值 (树中所有边的权重之和) 最小的生成树
在这里插入图片描述
约定：
只考虑连通图。最小生成树的定义说明它只能存在于连通图中，如果图不是连通的，那么分别计算每个连通图子图的最小生成树，合并到一起称为最小生成森林。
在这里插入图片描述
所有边的权重都各不相同。如果不同的边权重可以相同，那么一副图的最小生成树就可能不唯一了，虽然我们的算法可以处理这种情况，但为了好理解，我们约定所有边的权重都各不相同。

4.2 最小生成树原理

4.2.1 树的性质

  1. 用一条边接树中的任意两个顶点都会产生一个新的环；
    在这里插入图片描述
  2. 从树中删除任意一条边，将会得到两棵独立的树；
    在这里插入图片描述

4.2.2 切分定理

要从一副连通图中找出该图的最小生成树，需要通过切分定理完成。
切分：
将图的所有顶点按照某些规则分为两个非空且没有交集的集合。
横切边：
连接两个属于不同集合的顶点的边称之为横切边。
例如我们将图中的顶点切分为两个集合，灰色顶点属于一个集合，白色顶点属于另外一个集合，那么效果如下：
在这里插入图片描述
切分定理：
在一副加权图中，给定任意的切分，它的横切边中的权重最小者必然属于图中的最小生成树。
在这里插入图片描述

注意: 一次切分产生的多个横切边中，权重最小的边不一定是所有横切边中唯一属于图的最小生成树的边。
在这里插入图片描述

4.3 贪心算法

贪心算法是计算图的最小生成树的基础算法，它的基本原理就是切分定理，使用切分定理找到最小生成树的一条边，不断的重复直到找到最小生成树的所有边。如果图有V个顶点，那么需要找到V-1条边，就可以表示该图的最小生成树。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

计算图的最小生成树的算法有很多种，但这些算法都可以看做是贪心算法的一种特殊情况，这些算法的不同之处在于保存切分和判定权重最小的横切边的方式。

4.4 Prim算法

我们学习第一种计算最小生成树的方法叫Prim算法，它的每一步都会为一棵生成中的树添加一条边。一开始这棵树只有一个顶点，然后会向它添加V-1条边，每次总是将下一条连接树中的顶点与不在树中的顶点且权重最小的边加入到树中。
Prim算法的切分规则：
把最小生成树中的顶点看做是一个集合，把不在最小生成树中的顶点看做是另外一个集合。
在这里插入图片描述

4.4.1 Prim算法API设计

类名PrimMST
构造方法PrimMST(EdgeWeightedGraph G)：根据一副加权无向图，创建最小生成树计算对象；
成员方法1.private void visit(EdgeWeightedGraph G, int v)：将顶点v添加到最小生成树中，并且更新数据
2.public Queue edges():获取最小生成树的所有边
成员变量1.private Edge[] edgeTo: 索引代表顶点，值表示当前顶点和最小生成树之间的最短边
2.private double[] distTo: 索引代表顶点，值表示当前顶点和最小生成树之间的最短边的权重
3.private boolean[] marked:索引代表顶点，如果当前顶点已经在树中，则值为true，否则为false
4.private IndexMinPriorityQueue pq:存放树中顶点与非树中顶点之间的有效横切边

4.4.2 Prim算法的实现原理

Prim算法始终将图中的顶点切分成两个集合，最小生成树顶点和非最小生成树顶点，通过不断的重复做某些操作，可以逐渐将非最小生成树中的顶点加入到最小生成树中，直到所有的顶点都加入到最小生成树中。

我们在设计API的时候，使用最小索引优先队列存放树中顶点与非树中顶点的有效横切边，那么它是如何表示的呢？我们可以让最小索引优先队列的索引值表示图的顶点，让最小索引优先队列中的值表示从其他某个顶点到当前顶点的边权重。
在这里插入图片描述
初始化状态，先默认 0 是最小生成树中的唯一顶点，其他的顶点都不在最小生成树中，此时横切边就是顶点 0 的邻接表中0-2,0-4,0-6,0-7这四条边，我们只需要将索引优先队列的 2 、 4 、 6 、 7 索引处分别存储这些边的权重值就可以表示了。

现在只需要从这四条横切边中找出权重最小的边，然后把对应的顶点加进来即可。所以找到0-7这条横切边的权重最小，因此把0-7这条边添加进来，此时 0 和 7 属于最小生成树的顶点，其他的不属于，现在顶点 7 的邻接表中的边也成为了横切边，这时需要做两个操作：

  1. 0-7这条边已经不是横切边了，需要让它失效：
    只需要调用最小索引优先队列的delMin()方法即可完成；
  2. 2 和 4 顶点各有两条连接指向最小生成树，需要只保留一条：
    4-7的权重小于0-4的权重，所以保留4-7，调用索引优先队列的change(4,0.37)即可，
    0-2的权重小于2-7的权重，所以保留0-2，不需要做额外操作。
    在这里插入图片描述

我们不断重复上面的动作，就可以把所有的顶点添加到最小生成树中。

4.4.3 代码

public class PrimMST {
    //索引代表顶点，值表示当前顶点和最小生成树之间的最短边
    private Edge[] edgeTo;
    //索引代表顶点，值表示当前顶点和最小生成树之间的最短边的权重
    private double[] distTo;
    //索引代表顶点，如果当前顶点已经在树中，则值为true，否则为false
    private boolean[] marked;
    //存放树中顶点与非树中顶点之间的有效横切边
    private IndexMinPriorityQueue<Double> pq;

    //根据一副加权无向图，创建最小生成树计算对象
    public PrimMST(EdgeWeightedGraph G) {
       //初始化edgeTo
        this.edgeTo = new Edge[G.V()];
        //初始化distTo
        this.distTo = new double[G.V()];
        for (int i = 0; i < distTo.length; i++) {
            distTo[i] = Double.POSITIVE_INFINITY;
        }
        //初始化marked
        this.marked = new boolean[G.V()];
        //初始化pq
        pq = new IndexMinPriorityQueue<Double>(G.V());

        //默认让顶点0进入到树中，但是树中只有一个顶点0，因此，0顶点默认没有和其他的顶点相连，所以让distTo对应位置处的值存储0.0
        distTo[0] = 0.0;
        pq.insert(0,0.0);

        //遍历索引最小优先队列，拿到最小和N切边对应的顶点，把该顶点加入到最小生成树中
        while (!pq.isEmpty()){
            visit(G,pq.delMin());
        }
    }

    //将顶点v添加到最小生成树中，并且更新数据
    private void visit(EdgeWeightedGraph G, int v) {
        //把顶点v添加到最小生成树中
        marked[v] = true;
        //更新数据
        for (Edge e : G.adj(v)) {
            //获取e边的另外一个顶点(当前顶点是v)
            int w = e.other(v);
            //判断另外一个顶点是不是已经在树中，如果在树中，则不做任何处理，如果不再树中，更新数据
            if (marked[w]){
                continue;
            }


            //判断边e的权重是否小于从w顶点到树中已经存在的最小边的权重；
            if (e.weight()<distTo[w]){
                //更新数据
                edgeTo[w] = e;

                distTo[w] = e.weight();

                if (pq.contains(w)){
                    pq.changeItem(w,e.weight());
                }else{
                    pq.insert(w,e.weight());
                }
            }
        }
    }

    //获取最小生成树的所有边
    public Queue<Edge> edges() {
        //创建队列对象
        Queue<Edge> allEdges = new Queue<>();
        //遍历edgeTo数组，拿到每一条边，如果不为null，则添加到队列中
        for (int i = 0; i < edgeTo.length; i++) {
            if (edgeTo[i]!=null){
                allEdges.enqueue(edgeTo[i]);
            }
        }
        return allEdges;
    }
}

4.5 kruskal算法

kruskal算法是计算一副加权无向图的最小生成树的另外一种算法，它的主要思想是按照边的权重 (从小到大) 处理它们，将边加入最小生成树中，加入的边不会与已经加入最小生成树的边构成环，直到树中含有V-1条边为止。
kruskal算法和prim算法的区别：
Prim算法是一条边一条边的构造最小生成树，每一步都为一棵树添加一条边。kruskal算法构造最小生成树的时候也是一条边一条边地构造，但它的切分规则是不一样的。它每一次寻找的边会连接一片森林中的两棵树。如果一副加权无向图由V个顶点组成，初始化情况下每个顶点都构成一棵独立的树，则V个顶点对应V棵树，组成一片森林， kruskal算法每一次处理都会将两棵树合并为一棵树，直到整个森林中只剩一棵树为止。
在这里插入图片描述

4.5.1 kruskal算法API设计

类名KruskalMST
构造方法KruskalMST(EdgeWeightedGraph G)：根据一副加权无向图，创建最小生成树计算对象；
成员方法1.public Queue edges():获取最小生成树的所有边
成员变量1.private Queue mst：保存最小生成树的所有边
2.private UF_Tree_Weighted uf: 索引代表顶点，使用uf.connect(v,w)可以判断顶点v和顶点w是否在同一颗树中，使用uf.union(v,w)可以把顶点v所在的树和顶点w所在的树合并
3.private MinPriorityQueue pq: 存储图中所有的边，使用最小优先队列，对边按照权重进行排序

4.5.2 kruskal算法的实现原理

在设计API的时候，使用了一个MinPriorityQueue pq存储图中所有的边，每次使用pq.delMin()取出权重最小的边，并得到该边关联的两个顶点v和w，通过uf.connect(v,w)判断v和w是否已经连通，如果连通，则证明这两个顶点在同一棵树中，那么就不能再把这条边添加到最小生成树中，因为在一棵树的任意两个顶点上添加一条边，都会形成环，而最小生成树不能有环的存在，如果不连通，则通过uf.connect(v,w)把顶点v所在的树和顶点w所在的树合并成一棵树，并把这条边加入到mst队列中，这样如果把所有的边处理完，最终mst中存储的就是最小生树的所有边。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.5.3 代码

public class KruskalMST {
    //保存最小生成树的所有边
    private Queue<Edge> mst;
    //索引代表顶点，使用uf.connect(v,w)可以判断顶点v和顶点w是否在同一颗树中，使用uf.union(v,w)可以把顶点v所在的树和顶点w所在的树合并
    private UF_Tree_Weighted uf;
    //存储图中所有的边，使用最小优先队列，对边按照权重进行排序
    private MinPriorityQueue<Edge> pq;

    //根据一副加权无向图，创建最小生成树计算对象
    public KruskalMST(EdgeWeightedGraph G) {
        //初始化mst
        this.mst = new Queue<Edge>();
        //初始化uf
        this.uf = new UF_Tree_Weighted(G.V());
        //初始化pq
        this.pq = new MinPriorityQueue<>(G.E()+1);
        //把图中所有的边存储到pq中
        for (Edge e : G.edges()) {
            pq.insert(e);
        }

        //遍历pq队列，拿到最小权重的边，进行处理
        while(!pq.isEmpty() && mst.size()<G.V()-1){
            //找到权重最小的边
            Edge e = pq.delMin();
            //找到该边的两个顶点
            int v = e.either();
            int w = e.other(v);

            //判断这两个顶点是否已经在同一颗树中，如果在同一颗树中，则不对该边做处理，如果不在一棵树中，则让这两个顶点属于的两棵树合并成一棵树
            if (uf.connected(v,w)){
                continue;
            }

            uf.union(v,w);

            //让边e进入到mst队列中
            mst.enqueue(e);
        }
    }

    //获取最小生成树的所有边
    public Queue<Edge> edges() {
        return mst;
    }
}

五、加权有向图

之前学习的加权无向图中，边是没有方向的，并且同一条边会同时出现在该边的两个顶点的邻接表中，为了能够处理含有方向性的图的问题，我们需要实现以下加权有向图。

5.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：当前边的权重

代码：

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;
    }
}

5.2 加权有向图的实现

之前我们已经完成了有向图，在有向图的基础上，我们只需要把边的表示切换成DirectedEdge对象即可。
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: 邻接表

代码：

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

    //创建一个含有V个顶点的空加权有向图
    public EdgeWeightedDigraph(int V) {
        //初始化顶点数量
        this.V = V;
        //初始化边的数量
        this.E = 0;
        //初始化邻接表
        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) {
        //边e是有方向的，所以只需要让e出现在起点的邻接表中即可
        int v = e.from();
        adj[v].enqueue(e);
        E++;
    }

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

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

六、最短路径

有了加权有向图之后，我们立刻就能联想到实际生活中的使用场景，例如在一副地图中，找到顶点a与地点b之间的路径，这条路径可以是距离最短，也可以是时间最短，也可以是费用最小等，如果我们把 距离/时间/费用看做是成本，那么就需要找到地点a和地点b之间成本最小的路径，也就是我们接下来要解决的最短路径问题。

6.1 最短路径定义及性质

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

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

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

6.2 最短路径树API设计

计算最短路径树的经典算法是dijstra算法，为了实现它，先设计如下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:存放树中顶点与非树中顶点之间的有效横切边

6.3 松弛技术

松弛这个词来源于生活：一条橡皮筋沿着两个顶点的某条路径紧紧展开，如果这两个顶点之间的路径不止一条，还有存在更短的路径，那么把皮筋转移到更短的路径上，皮筋就可以放松了。
在这里插入图片描述
松弛这种简单的原理刚好可以用来计算最短路径树。
在我们的API中，需要用到两个成员变量edgeTo和distTo，分别存储边和权重。一开始给定一幅图G和顶点s，我们只知道图的边以及这些边的权重，其他的一无所知，此时初始化顶点s到顶点s的最短路径的总权重disto[s]=0；顶点s到其他顶点的总权重默认为无穷大，随着算法的执行，不断的使用松弛技术处理图的边和顶点，并按一定的条件更新edgeTo和distTo中的数据，最终就可以得到最短路劲树。

边的松弛：
放松边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这条边。
在这里插入图片描述

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

如果把起点设置为顶点 0 ，那么找出起点 0 到顶点 6 的最短路径0->2->7>3->6的过程如下:
在这里插入图片描述

6.4 Dijstra算法实现

Disjstra算法的实现和Prim算法很类似，构造最短路径树的每一步都是向这棵树中添加一条新的边，而这条新的边是有效横切边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()];
        //初始化distTo
        this.distTo = new double[G.V()];
        for (int i = 0; i < distTo.length; i++) {
            distTo[i] = Double.POSITIVE_INFINITY;
        }
        //初始化pq
        this.pq = new IndexMinPriorityQueue<>(G.V());

        //找到图G中以顶点s为起点的最短路径树

        //默认让顶点s进入到最短路径树中
        distTo[s] = 0.0;
        pq.insert(s,0.0);

        //遍历pq

        while(!pq.isEmpty()){
            relax(G,pq.delMin());
        }
    }

    //松弛图G中的顶点v
    private void relax(EdgeWeightedDigraph G, int 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;

                //判断pq中是否已经存在顶点w，如果存在，则更新权重，如果不存在，则直接添加
                if (pq.contains(w)){
                    pq.changeItem(w,distTo(w));
                }else{
                    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<DirectedEdge> allEdges = new Queue<>();

        while (true){
            DirectedEdge e = edgeTo[v];
            if (e==null){
                break;
            }

            allEdges.enqueue(e);

            v = e.from();
        }
        return allEdges;
    }
}
@阿清
关注
专栏目录
第十三章：数据结构-图的进阶(拓扑排序,最小生成树,加权无/有向图,Prim+kruskal算法)
Mr.Ding的博客
02-27 961
在实际生活中，很多应用相关的图都是有方向性的，最直观的就是网络，可以从A页面通过链接跳转到B页面，那么a和b连接的方向是a->b,但不能说是b->a,此时我们就需要使用有向图来解决这一类问题，它和我们之前学习的无向图，最大的区别就在于连接是具有方向的，在代码的处理上也会有很大的不同。
图的基本算法——BFS、DFS、拓扑排序、强连通分支、最小生成树算法
wawawakaokao的博客
04-10 2166
图 图的基本算法 图的表示 邻接矩阵 邻接表 BFS搜索 在给定图G=(V,E)G=(V,E)G=(V,E)和一个特定的源顶点s的情况下，广度优先搜索系统的探索G中的边，以期“发现”可从s到达的所有顶点，并计算s到所有这些可达顶点之间的距离（即最少的边数）。该搜索算法同时还能生成一颗根为s、且包括所有s的可达顶点的广度优先树。 广度优先搜索产生的广度优先树可能会有所不同，但由算法计算出来的距离d都是一样的。 时间复杂度 O(V+E)O(V+E)O(V+E) 对于图，广度优先搜索可以得到从已知源顶点到每
【图结构专题】有向图
热门推荐
惜暮
03-19 2万+
有向图 一. 有向图的相关术语 在有向图中，边是单向的：每条边连接的两个顶点都是一个有序对，它们的邻接性是单向的。我们开发过程中碰到的很多场景都是有向图：比如任务調度的依赖关系，社交网络的任务关系等等都是天然的有向图。 以下概念都是针对有向图的： （1）==有向图==：一幅有向图是由一组顶点和一组有方向的边组成的，每条有方向的边都连接着有序的一对顶点。 （2）==顶点的出度==：该顶...
【图的介绍】
qq_39826006的博客
08-19 608
​ 图是一种比较复杂的数据结构，在线性表中数据元素之间仅有线性关系，每个元素只有一个直接前驱和直接后继（元素之间只存在一对一关系），在树形结构中元素之间有着明显的层次关系，每一层的元素只能和下层的多个元素有关系（元素之间存在一对多关系），而在图形结构中，任意两个结点之间都可能有关系（元素之间存在多对多关系）。**顶点：**图中的数据元素被称为顶点，一般使用V表示图的顶点的有穷非空集合。
数据结构与算法学习---数据结构篇（图b）（默然回首，夯实基础）
weixin_43185348的博客
05-27 691
一、有向图 在实际生活中，很多应用相关的图都是有方向性的，最直观的就是网络，可以从A页面通过链接跳转到B页面，那么a和b连接的方向是a->b,但不能说是b->a,此时我们就需要使用有向图来解决这一类问题，它和我们之前学习的无向图，最大的区别就在于连接是具有方向的，在代码的处理上也会有很大的不同。 1.1 有向图的定义及相关术语 定义： 有向图是一副具有方向性的图，是由一组顶点和一组有方向的边组成的，每条方向的边都连着一对有序的顶点。 出度： 由某个顶点指出的边的个数称为该顶点的出度。 入度：
数据结构学习之：图
shun12580的博客
07-25 187
定义： 堆是一种比较特殊的数据结构，可以被看做一棵树的数组对象，具有以下的性质： 堆中某个节点的值总是不大于或不小于其父节点的值； 堆总是一棵完全二叉树。 将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。 特点： 堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。 (ki <= k2i,ki &...
数据结构--图的学习（基础概念）
最新发布
m0_61402375的博客
08-24 1932
学习图的相关概念
详解图的应用（最小生成树拓扑排序关键路径最短路径）共26页
10-31
在有向或无向图中，如果每条边都代表一定的成本或距离，那么寻找连接所有节点的最小总成本的树就是最小生成树。Kruskal算法和Prim算法是最常用的两种求解最小生成树的方法。Kruskal算法基于并查集，按照边的权重从小...
详解图的应用（最小生成树、拓扑排序、关键路径、最短路径）
09-03
接下来，拓扑排序是针对有向无环图（DAG）的一种排序方法，它可以将图中的所有顶点排成一个线性序列，使得对于每条有向边 (u, v)，顶点 u 都在这个序列中出现在顶点 v 之前。拓扑排序在项目管理、任务调度等领域非常...
图的算法详解：拓扑排序与最小生成树
最小生成树是指在带权重的无向图中找到一棵包含所有顶点的树，使得树的总权重最小。常见的算法有Prim算法和Kruskal算法。 拓扑排序是对有向无环图（DAG）进行线性排序的一种方法，使得对于每一条有向边,v>，u都在v...
数据结构——图
荔枝当大佬的博客
03-08 1747
在这篇文章中，荔枝主要记录了自己学习图的笔记，只能说是大致了解，还是得去做几道题目巩固一下，先将这个阶段的学习笔记记录下来哈哈哈。今朝已然成为过去，明日依然向往未来！
数据结构与算法学习系列-5-常见的数据结构-图
热爱编程，享受开发Coding的乐趣，一个开发爱好者的博客
01-24 667
常见的数据结构-图
数据结构学习笔记（6）——图
晃在云淡风轻
04-05 1247
图的存储结构 图的顺序存储结构——邻接矩阵 typedef struct { int no; //顶点编号，表示它的位置 char info; //顶点的其他辅助信息，没有的话可以删除 }VertexType; //顶点 typedef struct{ int edges[maxSize][maxSize]; //顶点之间的相邻关系（无权值：1表示相通，0表示不相通）（有权值：∞表示不相通，其它为权值） int vexnum, arcnum; //总顶点数和
数据结构，图（用图教你秒懂图的知识）
qq_46104786的博客
11-21 6575
数据结构学习，图（基础篇） 前言： 前面我们把树的知识全部学完了，今天我们学习图，如果不算算法，图是是我们最后一种要学的“数据结构”，图是一种非线性数据结构，它比树状结构更复杂，前面我们学习的知识都是一对一或者一对多的关系，今天要学的是多对多的关系，通常用于表示网状结构的数据。其实我们前面学过的都阔以看作特殊的图，图在很多邻域都用的到，博主之前学网络的时候广域网就是网状，就是表示不止一条通道。 每日一遍，注意休息 1.图的定义 无论多么复杂的图都是由顶点和边构成的，采用形式化的定义，图G（Graph）由两
[XJTUSE]数据结构学习—— 4.1 图的基本概念与实现
weixin_47692652的博客
02-10 946
[XJTUSE]数据结构学习—— 4.1 图的基本概念与实现
数据结构学习笔记（第六章 图）
阿七的博客
07-08 917
图的定义这里不多加描述了，下面给出几种图的图像。 这是有向图，无向图和有向完全图。简单图：1.不存在重复边2.不存在顶点到自身的边多重图: 某两个顶点间的边数大于一条，又允许顶点通过一条边与自身关联。完全图：任意两个顶点间都有边关于其他基本概念可看下面这个博主写的超级详细数据结构：图(Graph)【详解】_UniqueUnit的博客-CSDN博客_数据结构图用一个一维数组存储顶点的信息，用一个二维数组存储边的关系（即顶点间的邻接关系），这个二维数组成为邻接矩阵。 注：无向图的邻接矩阵是对称矩阵，邻接矩
6.1图的定义、无向图、有向图、连通图、强连通图、带权图
qq_26553393的博客
01-19 2万+
1. 知识总览 2. 图的定义 3. 图逻辑结构的应用 4. 无向图、有向图 5. 简单图、多重图 6. 顶点的度、入度、出度 7. 连通图、强连通图 8. 研究图的局部–子图 9. 连通分量 10. 强连通分量 11. 生成树 12. 生成森林 13 边的权、带权图/网 14. 几种特殊形态的图 15. 知识回顾 1. 知识总览 2. 图的定义 3. 图逻辑结构的应用 4. 无向图、有向图 5. 简单图、多重图 6. 顶点的度、入度、出度 7. 连通图、强连通图 8. 研究图...
Networkx学习1 - 无向图&有向图&加权图
小熵的专栏
08-02 1万+
Python中的Networkx能够方便地创建社会网络，语义网络等网络结构，并进行各种分析，记录下学习的过程，方便自己的记忆。 1. 安装 在windows中安装的python3.9以及pycharm2020社区版，配置python环境变量 安装networkx，直接pip install nexworkx即可，在pycharm中创建python项目，Venv中再次导入一下networkx。 2. 无向图 创建无向图nx.Graph() 无向图中两点间最多只有一条边。 import ne.
【九度OJ】1008【加权无向图最短路径】
ALiTuTu的专栏
08-08 4258
在网上查了一下，无向图最短路解法DFS和Dijkstra多一些，一般不用BFS
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值