【算法】求最短路径算法

最新推荐文章于 2024-04-24 15:47:54 发布
最新推荐文章于 2024-04-24 15:47:54 发布
阅读量4.2k 收藏 21
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011397981/article/details/130453528
版权

文章目录

一、迪杰斯特拉算法

1.1 算法介绍

从某顶点出发，沿图的边到达另一顶点所经过的路径中，各边上权值之和最小的一条路径叫做最短路径。 解决最短路径的问题有以下算法：Dijkstra
算法，Bellman-Ford 算法，Floyd 算法和 SPFA 算法等。

  • 迪杰斯特拉算法（Dijkstra 算法）是典型最短路径算法，用于计算一个节点到其它节点的最短路径，它的主要特点是以起始点为中心向外层层扩展（广度优先搜索思想），直到扩展到终点为止。

  • 该算法的时间复杂度为 O(ElogV)，其中 E 为边数，V 为节点数。

1.2 算法步骤

  1. 设置起始点，并有记录各顶点的数组A、记录各顶点到起始点距离的数组B（起始点到自身的距离记作0）；
  2. 从距离数组中选取最小的值（即当前为最短路径），选好以后，将对应的顶点从数组A中移除，对应记录的距离从数组B中移除；
  3. 比较起始点与各顶点的距离值，更新前驱节点，并保留值较小的一个距离值，从而完成对各顶点到起始点距离的数组B的更新；
  4. 重复执行步骤2、步骤3，直到最短路径顶点为目标顶点时，算法结束。

1.3 应用场景

假设有 7 个村庄（A，B，C，D，E，F，G），各个村庄的距离用边线表示（权） ，比如 A<–>B 距离 5 公里。问：如何计算出 G
村庄到其它各个村庄的最短距离？如果从其它点出发到各个点的最短距离又是多少?（通过迪杰斯特拉算法求最短路径）

示意图：
在这里插入图片描述

代码示例：

public class DijkstraAlgorithmDemo {

    public static void main(String[] args) {
        // 顶点集合。
        char[] vertexes = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};

        // 邻接矩阵，`Integer.MAX_VALUE` 表示不联通。
        final int x = Integer.MAX_VALUE;
        int[][] matrix = {
                {x, 5, 7, x, x, x, 2},
                {5, x, x, 9, x, x, 3},
                {7, x, x, x, 8, x, x},
                {x, 9, x, x, x, 4, x},
                {x, x, 8, x, x, 5, 4},
                {x, x, x, 4, 5, x, 6},
                {2, 3, x, x, 4, 6, x}
        };

        // 创建图。
        Graph graph = new Graph(vertexes, matrix);
        // 查看矩阵创建。
        graph.showGraph();
        // [x, 5, 7, x, x, x, 2]
        // [5, x, x, 9, x, x, 3]
        // [7, x, x, x, 8, x, x]
        // [x, 9, x, x, x, 4, x]
        // [x, x, 8, x, x, 5, 4]
        // [x, x, x, 4, 5, x, 6]
        // [2, 3, x, x, 4, 6, x]

        // 测试迪杰斯特拉算法
        // [6]:"G"（[下标]:对应顶点）。
        int vertexIndex = 6;
        graph.dijkstra(vertexIndex);
        graph.dijkstraResult(vertexes, vertexIndex);
        // 各顶点访问状态 (0:表示已访问 1:表示未访问): 1 1 1 1 1 1 1
        // 前一顶点: 6 6 0 5 6 6 0
        // 各顶点到起始顶点的距离: 2 3 9 10 4 6 0
        // 具体详情如下：<G-A>:(2) <G-B>:(3) <G-C>:(9) <G-D>:(10) <G-E>:(4) <G-F>:(6) <G-G>:(0)
    }
}


/**
 * 图
 */
class Graph {

    /**
     * 顶点数组。
     */
    private final char[] vertexes;

    /**
     * 邻接矩阵。
     */
    private final int[][] matrix;

    /**
     * 已经访问的顶点的集合。
     */
    private VisitedVertex visitedVertex;

    /**
     * 初始化构造。
     *
     * @param vertexes 顶点
     * @param matrix   矩阵
     */
    public Graph(char[] vertexes, int[][] matrix) {
        this.vertexes = vertexes;
        this.matrix = matrix;
    }

    /**
     * 展示dijkstra算法结果。
     *
     * @param vertexes    顶点数组
     * @param vertexIndex 顶点下标
     */
    public void dijkstraResult(char[] vertexes, int vertexIndex) {
        visitedVertex.show(vertexes, vertexIndex);
    }

    /**
     * 展示图。
     */
    public void showGraph() {
        for (int[] link : matrix) {
            // 将表示不联通的值替换输出（便于查看）。
            System.out.println(Arrays.toString(link)
                    .replaceAll(Integer.MAX_VALUE + "", "x")
            );
        }
    }

    /**
     * 迪杰斯特拉算法。
     * 目的：根据起始顶点下标找到最短路径。
     *
     * @param index 顶点对应的下标（比如：0对应顶点A，1对应顶点B...）
     */
    public void dijkstra(int index) {
        int vertexNum = this.vertexes.length;
        this.visitedVertex = new VisitedVertex(vertexNum, index);
        // 更新当前顶点到其它周围顶点的距离和前驱顶点。
        update(index);
        for (int i = 1; i < vertexNum; i++) {
            // 选择并返回新的访问顶点。
            index = this.visitedVertex.updateArray();
            // 更新当前顶点到其它顶点的距离和前驱顶点。
            update(index);
        }
    }

    /**
     * 更新下标顶点到周围顶点的距离及前驱顶点。
     *
     * @param index 对应下标
     */
    private void update(int index) {
        // 遍历邻接矩阵。
        int len = this.matrix[index].length;
        long distance = 0;
        for (int j = 0; j < len; j++) {
            // `distance`表示：当前顶点到起始顶点的距离 + 从当前顶点到j顶点距离的和。
            distance = this.visitedVertex.getDistance(index) + this.matrix[index][j];
            // 如果j顶点没有被访问过，且求得的距离小于起始顶点到j顶点的距离，就需要进行更新。
            if (!visitedVertex.in(j) && distance < this.visitedVertex.getDistance(j)) {
                // 更新j顶点前驱顶点。
                this.visitedVertex.updatePre(j, index);
                // 更加起始顶点到j顶点的距离。
                this.visitedVertex.updateDistance(j, distance);
            }
        }
    }
}


/**
 * 已访问的顶点集。
 */
class VisitedVertex {

    /**
     * 记录顶点是否被访问过。
     * 0表示未访问，1表示访问过。
     */
    private final int[] isVisited;

    /**
     * 记录前驱顶点。
     */
    private final int[] preVisited;

    /**
     * 记录到起始顶点距离。
     */
    private final long[] distances;

    /**
     * 使用 `Integer.MAX_VALUE` 表示无穷大，即不可联通。
     */
    private static final int DISCONNECTED = Integer.MAX_VALUE;

    /**
     * 初始化构造。
     *
     * @param vertexNum 顶点个数
     * @param index     顶点对应的下标（比如：0对应顶点A，1对应顶点B...）
     */
    public VisitedVertex(int vertexNum, int index) {
        this.isVisited = new int[vertexNum];
        this.preVisited = new int[vertexNum];
        this.distances = new long[vertexNum];
        // 初始化距离数组数据。
        Arrays.fill(distances, DISCONNECTED);
        // 将起始顶点标记为已访问，并将访问距离设置为0。
        this.isVisited[index] = 1;
        this.distances[index] = 0;
    }

    /**
     * 顶点是否被访问过。
     *
     * @param index 顶点下标
     * @return boolean
     */
    public boolean in(int index) {
        return 1 == this.isVisited[index];
    }

    /**
     * 更新距离。
     *
     * @param index    顶点下标
     * @param distance 距离
     */
    public void updateDistance(int index, long distance) {
        this.distances[index] = distance;
    }

    /**
     * 更新前驱顶点
     *
     * @param pre   前驱顶点下标
     * @param index 当前顶点下标
     */
    public void updatePre(int pre, int index) {
        preVisited[pre] = index;
    }

    /**
     * 得到到起始顶点距离。
     *
     * @param index 顶点下标
     * @return long
     */
    public long getDistance(int index) {
        return this.distances[index];
    }

    /**
     * 继续选择并返回新的访问顶点，比如这里的G 完后，就是 A点作为新的访问顶点（注意不是起始顶点）。
     *
     * @return int
     */
    public int updateArray() {
        long minDis = DISCONNECTED;
        int index = 0;
        for (int i = 0; i < isVisited.length; i++) {
            // 若没有被访问过且有权值，则进行更新。
            if (0 == isVisited[i] && minDis > distances[i]) {
                minDis = distances[i];
                index = i;
            }
        }

        // 设置已访问。
        isVisited[index] = 1;
        return index;
    }

    /**
     * 将各数组数据情况进行输出并显示最终结果。
     *
     * @param vertexes    顶点数组
     * @param vertexIndex 顶点下标
     */
    public void show(char[] vertexes, int vertexIndex) {

        System.out.println("==========================");

        System.out.print("各顶点访问状态 (0:表示已访问 1:表示未访问): ");
        for (int i : isVisited) {
            System.out.print(i + " ");
        }
        System.out.println();

        System.out.print("前一顶点: ");
        for (int i : preVisited) {
            System.out.print(i + " ");
        }
        System.out.println();

        System.out.print("各顶点到起始顶点的距离: ");
        for (long i : distances) {
            System.out.print(i + " ");
        }
        System.out.println();

        System.out.print("具体详情如下：");
        int counter = 0;
        for (long i : distances) {
            if (DISCONNECTED != i) {
                System.out.print("<" + vertexes[vertexIndex] + "-" + vertexes[counter] + ">:(" + i + ") ");
            } else {
                System.out.println("N ");
            }
            counter++;
        }
        System.out.println();
    }
}

二、弗洛伊德算法

2.1 算法介绍

弗洛伊德算法（Floyd 算法）又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与 Dijkstra
算法类似。

  • 与迪杰斯特拉算法对比：

    • 迪杰斯特拉算法通过选定的被访问顶点，求出从起始访问顶点到其它顶点的最短路径；
    • 弗洛伊德算法中每一个顶点都是起始访问点，所以需要将每一个顶点看做被访问顶点，求出从每一个顶点到其它顶点的最短路径。

  • 该算法的时间复杂度为 O(n³)，其中 n 为节点数。

  • 该算法可以处理有向图和无向图，但不能处理负权环，如果存在负权环，则最短路径不存在。

2.2 算法步骤

  1. 初始化距离矩阵：初始化一个 n*n 的矩阵D，其中 D[ i ][ j ] 表示从节点 i 到节点 j 的最短路径长度。如果 i 和 j 之间没有边相连，则 D[ i ][ j ] 为无穷大。
  2. 通过中间点更新距离矩阵：对于每个节点 k，依次更新矩阵D。具体地，对于每对节点 i 和 j，如果从 i 到 j 的路径经过节点 k 可以使得路径长度更短，则更新 D[ i ][ j ] 为 D[ i ][ k ]+D[ k ][ j ] 。
  3. 最终得到的矩阵D即为所有节点对之间的最短路径长度。

2.3 应用场景

假设有 7 个村庄（A，B，C，D，E，F，G），各个村庄的距离用边线表示（权），比如 A<–>B 距离 5
公里。问：如何计算出各村庄到其它各村庄的最短距离？（通过弗洛伊德算法求最短路径）

示意图：
在这里插入图片描述

代码示例：

public class FloydAlgorithmDemo {

    public static void main(String[] args) {
        // 顶点集合。
        char[] vertexes = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        
        // 邻接矩阵，`Integer.MAX_VALUE` 表示不联通。
        final int x = Integer.MAX_VALUE;
        long[][] matrix = {
                {0, 5, 7, x, x, x, 2},
                {5, 0, x, 9, x, x, 3},
                {7, x, 0, x, 8, x, x},
                {x, 9, x, 0, x, 4, x},
                {x, x, 8, x, 0, 5, 4},
                {x, x, x, 4, 5, 0, 6},
                {2, 3, x, x, 4, 6, 0}
        };
        
        // 创建图。
        Graph graph = new Graph(vertexes.length, vertexes, matrix);
        // 测试弗洛伊德算法。
        graph.floyd();
        graph.show();
        // <A-A>的最短路径是0; <A-B>的最短路径是5; <A-C>的最短路径是7; <A-D>的最短路径是12; <A-E>的最短路径是6; <A-F>的最短路径是8; <A-G>的最短路径是2; 
        // <B-A>的最短路径是5; <B-B>的最短路径是0; <B-C>的最短路径是12; <B-D>的最短路径是9; <B-E>的最短路径是7; <B-F>的最短路径是9; <B-G>的最短路径是3; 
        // <C-A>的最短路径是7; <C-B>的最短路径是12; <C-C>的最短路径是0; <C-D>的最短路径是17; <C-E>的最短路径是8; <C-F>的最短路径是13; <C-G>的最短路径是9; 
        // <D-A>的最短路径是12; <D-B>的最短路径是9; <D-C>的最短路径是17; <D-D>的最短路径是0; <D-E>的最短路径是9; <D-F>的最短路径是4; <D-G>的最短路径是10; 
        // <E-A>的最短路径是6; <E-B>的最短路径是7; <E-C>的最短路径是8; <E-D>的最短路径是9; <E-E>的最短路径是0; <E-F>的最短路径是5; <E-G>的最短路径是4; 
        // <F-A>的最短路径是8; <F-B>的最短路径是9; <F-C>的最短路径是13; <F-D>的最短路径是4; <F-E>的最短路径是5; <F-F>的最短路径是0; <F-G>的最短路径是6; 
        // <G-A>的最短路径是2; <G-B>的最短路径是3; <G-C>的最短路径是9; <G-D>的最短路径是10; <G-E>的最短路径是4; <G-F>的最短路径是6; <G-G>的最短路径是0; 
    }
}

/**
 * 图。
 */
class Graph {

    /**
     * 顶点数组。
     */
    private final char[] vertexes;

    /**
     * 记录各个顶点到其它顶点的距离。
     */
    private final long[][] distances;

    /**
     * 到达目标顶点的前驱顶点。
     */
    private final int[][] preVisited;

    /**
     * 初始化构造。
     *
     * @param size      数组大小
     * @param vertexes  顶点集合
     * @param distances 距离
     */
    public Graph(int size, char[] vertexes, long[][] distances) {
        this.vertexes = vertexes;
        this.distances = distances;
        this.preVisited = new int[size][size];
        for (int i = 0; i < size; i++) {
            // 对前驱节点数组进行初始化（存放前驱顶点下标）。
            Arrays.fill(preVisited[i], i);
        }
    }

    /**
     * 展示前驱关系及距离信息。
     */
    public void show() {
        int length = this.distances.length;
        for (int k = 0; k < length; k++) {
            for (int i = 0; i < length; i++) {
                System.out.print("<" + this.vertexes[k] + "-" + this.vertexes[i] + ">的最短路径是" + distances[k][i] + "; ");
            }
            System.out.println();
        }
    }

    /**
     * 弗洛伊德算法。
     */
    public void floyd() {
        // 距离变量。
        long dist = 0;
        int dLen = this.distances.length;
        // 三层 `for`。
        // k 就是中间顶点的下标。
        for (int k = 0; k < dLen; k++) {
            // i 作为起始顶点。
            for (int i = 0; i < dLen; i++) {
                // j 作为目标顶点。
                for (int j = 0; j < dLen; j++) {
                    // 求出从 i 顶点出发，经过 k 中间顶点，到达 j 顶点距离。
                    dist = distances[i][k] + distances[k][j];
                    // 如果`算法得到的距离`小于`当前距离表中已有的距离`则进行更新。
                    if (dist < distances[i][j]) {
                        // 更新距离。
                        distances[i][j] = dist;
                        // 更新前驱顶点。
                        preVisited[i][j] = preVisited[k][j];
                    }
                }
            }
        }
    }
}
逆流°只是风景-bjhxcc
关注
  • 0
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++用Dijkstra(迪杰斯特拉)算法求最短路径
01-20
算法介绍 迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有向图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。 算法思想 按路径长度递增次序产生算法： 　把顶点集合V分成两组： 　　（1）S：已求出的顶点的集合（初始时只含有源点V0） 　　（2）V-S=T：尚未确定的顶点集合 　　将T中顶点按递增的次序加入到S中，保证： 　　（1）从源点V0到S中其他各顶点的长度都不
关于最短路径几种算法的总结
Armstrong的博客
02-22 4465
一、Dijkstra 算法 迪杰斯特拉算法，可以解决无负权值的单源最短路径问题。 基本思路是对图 G(V, E) 设置集合 S ，存放已被访问的顶点，然后每次从集合 V - S 中选择与起点 s 的最短距离最小的一个顶点（记为 u ），访问并加入集合 S。之后，令顶点 u 为中介点，优化起点 s 与所有从 u 能到达的顶点 v 之间的最短距离。这样操作 n 次（ n 为顶点个数），直到集合 S...
详解图的最短路径算法（BFS、Dijkstra、Floyd）（附上图解步骤）
叶小树咯
03-23 3462
详解图的最短路算法、针对BFS、Dijkstra、Floyd算法写出详细的图解、解题步骤
数据结构学习记录——图-最短路径问题（无权图单源最短路径算法、有权图单源最短路径算法、多源最短路径算法、Dijkstra（迪杰斯特拉）算法、Floyd算法）
li13437542099的博客
06-04 3016
在算法的每一步，我们将一个顶点加入集合S，该顶点是在当前阶段中距离源点s的最短路径长度最小的顶点。Floyd算法也是逐步地求出最短距离的，通过遍历所有可能的中间节点k，并不断尝试更新D[i][j]的值，Floyd算法逐步优化路径长度，最终找到图中所有节点对之间的最短路径。现在，我们引入一个中间节点k，想要通过节点k来尝试找到更短的路径，即尝试在节点i和节点j之间建立一条路径，其中包括节点k。在每一步中，选择的顶点v是当前阶段中距离源点s最近的顶点，而且该距离是经过已确定最短路径顶点集合S的路径长度。
【算法】最短路径——弗洛伊德 (Floyd) 算法
代码星辰的博客
11-16 2708
本文介绍了弗洛伊德 (Floyd) 算法的相关知识。
最短路径的四种算法
我の名字
07-30 1万+
最短路径四种算法 1 2 3 4 Floyd Dijkstra Bellman-Ford 队列优化的Bellman-Ford 一，只有四行的算法——Floyd-Warshall 假设求顶点ViViVi到VjVjVj的最短路径。弗洛伊德算法依次找从ViViVi到VjVjVj，中间经过结点序号不大于000的最短路径，不大于111的最短路径，…直到中间顶点序号不大于n−1n-1n−1...
图的五种最短路径算法
热门推荐
qq_35710556的博客
03-17 7万+
本文总结了图的几种最短路径算法的实现：深度或广度优先搜索算法，费罗伊德算法，迪杰斯特拉算法，Bellman-Ford 算法。1）深度或广度优先搜索算法（解决单源最短路径）从起点开始访问所有深度遍历路径或广度优先路径，则到达终点节点的路径有多条，取其中路径权值最短的一条则为最短路径。下面是核心代码：void dfs(int cur,int dst){ if(minpath&lt;dst) r...
算法之几个常见的经典最短路径算法
weixin_51948450的博客
03-07 1万+
包括的经典的Dijkstra算法，Floyd算法和Bellman-Ford 算法
最短路径算法
qq_39749300的博客
10-03 6526
前言 本篇文章我将向大家介绍求解最短路径的三种经典算法——Dijkstra 算法，Bellman-Ford 算法以及 Floyd-Warshall 算法。 Dijkstra 算法 最短路径 最短路径问题是图论研究领域中的一个经典算法问题，旨在寻找图中两节点之间的最短路径。 譬如上图为一个无向有权图，节点 0 到节点 3 的最短路径为 ： 0 -> 2 -> 1 -> 3 其路径长度为：5。 研究最短路径算法具有哪些意义呢？或者说最短路径算法可以解决哪些问题？ 我们知道，在生活中，地铁
图算法——求最短路径（Dijkstra算法）
在夜里行走的博客
11-22 6万+
图解Dijkstra算法，让你了解Dijkstra算法的每一步是怎么进行的
蚁群算法求最短路径，matlab程序
02-21
蚁群算法求最短路径，matlab程序
最短路径算法dijkstra的matlab实现_dijkstra_最短路径算法_
10-04
最短路径算法dijkstra的matlab实现
C# floyd算法 求最短路径
04-09
C# floyd算法 求最短路径 C# floyd算法 求最短路径 C# floyd算法 求最短路径
【路径规划】基于遗传算法求最短路径matlab源码.md
08-05
【路径规划】基于遗传算法求最短路径matlab源码.md
python Dijkstra算法实现最短路径问题的方法
09-18
主要介绍了python Dijkstra算法实现最短路径问题的方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
算法训练营day21
wugong_true的博客
04-23 366
接下来，根据计数count与最大计数maxCount的比较，更新众数的结果数组resList和最大计数maxCount。如果count大于maxCount，则清空resList并将当前节点值添加进去，并更新maxCount为count；接着，根据resList中的众数，创建一个整型数组res，并将其返回作为结果。然后，通过与前一个节点的值进行比较，判断当前节点值出现的次数。如果当前节点与前一个节点的值不同，说明出现了一个新的值，将计数count重置为1；，计算相邻两个元素的差值，并将较小的差值更新到。
视频质量评价 BRISQUE算法详细介绍
小金牛来了
04-21 84
视频质量评价 BRISQUE算法详细介绍
【算法基础】第五章：动态规划
最新发布
m0_65787507的博客
04-24 505
DP：【1】状态表示：需要几个维度来表示状态（1）集合（所有选法，带有约束条件）（2）属性（最大值、最小值、数量）【2】状态计算：如何算出每一步的状态，对应集合的划分（不重+不漏）**DP的优化：**对代码/计算方程做变形。
力扣HOT100 - 543. 二叉树的直径
qq_61504864的博客
04-23 212
【代码】力扣HOT100 - 543. 二叉树的直径。
迪杰斯特算法求最短路径
10-09
迪杰斯特拉算法（Dijkstra's algorithm）是一种用于求解带权重图的最短路径问题的算法。它将图中的节点分为两个集合：已确定最短路径的节点集合和未确定最短路径的节点集合。算法的基本思想是从起始节点开始，依次选择与当前节点距离最短的未确定节点，并更新其最短路径及距离。重复这个过程，直到所有节点都被确定。 下面是迪杰斯特拉算法的基本步骤： 1. 创建一个集合用于存放已确定最短路径的节点，初始时只包含起始节点，以及一个集合用于存放未确定最短路径的节点，初始时包含所有其他节点。 2. 初始化起始节点的最短路径为0，其余节点的最短路径为无穷大。 3. 从未确定集合中选择一个节点，找到与其距离最短的节点，并将其加入已确定集合。 4. 更新与新加入节点相邻的节点的最短路径，如果通过新加入节点的路径长度比原来的最短路径短，则更新最短路径。 5. 重复步骤3和步骤4，直到所有节点都被确定。 通过以上步骤，可以得到起始节点到其他所有节点的最短路径。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值