深度优先遍历和广度优先遍历代码实现

最新推荐文章于 2023-09-20 10:29:03 发布
最新推荐文章于 2023-09-20 10:29:03 发布
阅读量2.4k 收藏 32
点赞数 6
分类专栏： 数据结构与算法 文章标签： 数据结构 dfs bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45893475/article/details/117172933
版权
本文详细介绍了图的概念，包括无向图和有向图的表示方法，如邻接矩阵和邻接表。接着，讨论了图的两种遍历算法——深度优先搜索（DFS）和广度优先搜索（BFS），并提供了C++实现。DFS适用于寻找路径，而BFS适用于找到最近的节点。最后，针对图的不连通性给出了遍历整个图的策略。
摘要由CSDN通过智能技术生成

直接跳到 3. 看代码，注释较为详细
理论知识参考
代码参考(写的太好了！)

1. 什么是图

  • 表示 “多对多” 的关系
  • 包含：1. 一组顶点：通常用V(vertex) 表示顶点集合；2. 一组边：通常用E(edge) 表示边的集合。
    • 边是定点对：(v, w)∈E，其中v, w∈V
    • 有向边<v, w> 表示从 v 指向 w 的边（单行边）

表示方法

  1. 邻接矩阵表示法

    在这里插入图片描述

    好处：

    • 直观、简单、好理解
    • 方便检查任意一对的顶点间是否存在边
    • 方便找任一顶点的所有 “邻接点” （有边直接相连的顶点）
    • 方便计算任一顶点的 “度” （从该点发出的边数为 “出度” ，指向该点的边数为 “入度”）
      • 无向图：对应行(或列)非零元素的个数
      • 有向图：对应行非零元素的个数是 “出度” ；对应列非零元素的个数是 “入度”

    缺点：

    • 浪费空间：存稀疏图（点很多而边很少）有大量无效元素。（对稠密图特别是完全图还是很合算的）
    • 浪费时间：统计稀疏图中一共有多少条边

  2. 邻接表

    G[N] 为指针数组，对应矩阵每行一个链表，只存非0元素

    在这里插入图片描述

    特点：

    • 方便找任一顶点的所有 “邻接点”
    • 节约稀疏图的空间
      • 需要N个头指针 + 2E个结点（每个结点至少两个域）
    • 方便计算任一顶点的 “度” ？
      • 对无向图：是的
      • 对有向图：只能计算 “出度” ；需要构造 “逆邻接表”（存指向自己的边）来方便计算 “入度”
    • 不方便检查任意一对顶点间是否存在边

2. 图的遍历

  • 深度优先搜索(Depth First Search，DFS)：一条道走到黑，然后回退！（基于栈）

    // 伪码描述--类似于树的先序遍历
void DFS(vertex V) {
    visited[V] = true;
    for ( V 的每个邻接点 W ) 
        if (!visited[W]) 
            DFS(W);
}

    若有N个顶点、E条边，时间复杂度是：

    • 用邻接表存储图，有O(N+E)
    • 用邻接矩阵存储图，有O(N²)

  • 广度优先搜索(Breadth First Search, BFS)：广泛撒网，共同前行！(基于队列)

    // 伪码描述
void BFS(vertex V) {
    visited[V] = true;
    enqueue(V, Q);
    while (!isEmpty(Q)) {
        V = dequeue(Q);
        for ( V 的每个邻接点 W)
            if (!visited[W]) {
                visited[W] = true;
                enqueue(W, Q);
            }
    }
}

    若有N个顶点、E条边，时间复杂度是：

    • 用邻接表存储图，有O(N+E)
    • 用邻接矩阵存储图，有O(N²)

图不连通怎么办？

每调用一次DFS(V)，就把 V 所在的连通分量遍历一遍。BFS也是一样。

void ListComponents(Graph G) {
    for (each V in G)
        if (!visited[v]) {
            DFS(V);	// or BFS(V);
        }
}

3. 代码实现

3.1 广度优先遍历

邻接矩阵实现：

#include <iostream>
#include <queue>
using namespace std;

typedef int ElemType;
#define MAXNUM 100
bool visited[MAXNUM];   // 定义visited数组，记录顶点的访问情况
queue<ElemType> q;  // 队列用来记录相邻结点

// ！！！邻接矩阵表示图的广度优先遍历 ！！！

// 邻接矩阵存储表示
struct AMGraph {
    ElemType vertex[MAXNUM];  // 顶点表
    int matrix[MAXNUM][MAXNUM];   // 邻接矩阵
    int vernum, edgenum;     // 当前顶点数和边数
};

// 找到顶点v对应下标
int locateVertex(AMGraph& G, ElemType v) {
    
    for (int i = 0; i < G.vernum; ++i) {
        if (G.vertex[i] == v) {
            return i;
        }
    }
    return -1;
}

// 采用邻接矩阵表示法，构建无向图G
bool createUDG(AMGraph& G) {
    int i, j, k;
    ElemType v1, v2;
    cin >> G.vernum >> G.edgenum;    // 输入总顶点数和边数

    for (i = 0; i < G.vernum; ++i) {
        cin >> G.vertex[i];   // 输入顶点表
    }

    // 初始化邻接矩阵边，0 表示顶点i和j之间无边
    for (i = 0; i < G.vernum; ++i) {
        for (j = 0; j < G.edgenum; ++j) {
            G.matrix[i][j] = 0;   
        }
    }

    // 1 表示两顶点之间有边
    for (k = 0; k < G.edgenum; ++k) {
        cin >> v1 >> v2;
        i = locateVertex(G, v1);   // 找到顶点i的下标
        j = locateVertex(G, v2);   // 找到顶点j的下标

        G.matrix[i][j] = G.matrix[j][i] = 1;    // 即i和j之间有边
    }
    return true;
}

// 用邻接矩阵表示图的广度优先遍历
void BFS_AM(AMGraph& G, ElemType v0) {
    int i, j, v, w;
    i = locateVertex(G, v0);   // 找到v0对应的下标
    cout << v0 << " ";
    visited[i] = 1;     // 标记v0已被访问
    q.push(v0);         // v0入队

    while (!q.empty()) {
        v = q.front();          // 输出队头元素，将要访问邻接点
        i = locateVertex(G, v); // 得到顶点v的下标
        q.pop();                // 将队头元素出队

        for (j = 0; j < G.vernum; ++j) {
            w = G.vertex[j];      // 在j位置上的顶点，先保存下来
            // 如果顶点v和w之间有边且顶点w未被访问
            if (G.matrix[i][j] && !visited[j]) {
                cout << w << " ";   // ！！！遍历 ！！！
                q.push(w);      // 顶点w入队
                visited[j] = 1; // 顶点w已被访问
            }
        }
    }
}

邻接表实现：

#include <iostream>
#include <queue>
using namespace std;

typedef int ElemType;
#define MAXNUM 100
bool visited[MAXNUM];   // 定义visited数组，记录顶点的访问情况
queue<ElemType> q;  // 队列用来记录相邻结点

// ！！！ 用邻接表表示图的广度优先搜索 ！！！
// 邻接表存储表示

// 表结点
struct EdgeNode {
    int locateVer;     // 该边所指向的顶点的位置
    EdgeNode* nextEdge;   // 指向下一条边的指针
    int info;       // 和边有关的信息，如权值
};

// 顶点结点
struct VerNode {
    ElemType data;
    EdgeNode* firstEdge;  // 指向第一条依附在该顶点的边的指针
};

struct ALGraph {
    VerNode vertex[MAXNUM];   // 表头结点表
    int vernum, edgenum;     // 总顶点数和边数
};

// 找到顶点对应的下标
int locateVertex(ALGraph& G, ElemType v) {

    for (int i = 0; i < G.vernum; ++i) {
        if (G.vertex[i].data == v) {
            return i;
        }
    }
    return -1;
}

bool createALG(ALGraph& G) {
    int i, j, k;
    ElemType v1, v2;
    cin >> G.vernum >> G.edgenum;    // 输入总顶点数和总边数

    for (i = 0; i < G.vernum; ++i) {
        cin >> G.vertex[i].data;  // 输入顶点值
        G.vertex[i].firstEdge = nullptr;   // 初始化每个表头结点的指针域
    }

    // 输入各边，构造邻接表
    for (k = 0; k < G.edgenum; ++k) {
        cin >> v1 >> v2;            // 输入一条边的两侧顶点
        i = locateVertex(G, v1);   // 找到顶点i的下标
        j = locateVertex(G, v2);   // 找到顶点j的下标

        // 操作表结点
        EdgeNode* p1 = new EdgeNode;  // 创建一个边结点
        p1->locateVer = j;         // 邻接点域为j
        p1->nextEdge = G.vertex[i].firstEdge;
        G.vertex[i].firstEdge = p1;

        // 因为一条边对应两个顶点，直接生成另一对称的新的表结点
        EdgeNode* p2 = new EdgeNode;
        p2->locateVer = i;
        p2->nextEdge = G.vertex[j].firstEdge;
        G.vertex[j].firstEdge = p1;
    }
    return true;
}

// 采用邻接表表示图的广度优先遍历----操作与邻接矩阵表示类似
void BFS_AL(ALGraph& G, ElemType v0) {
    int i, j, v;
    EdgeNode* p = nullptr;
    cout << v0 << " ";

    i = locateVertex(G, v0);
    visited[i] = 1;
    q.push(v0);

    while (!q.empty()) {
        v = q.front();      // 输出队列中的第一个顶点
        i = locateVertex(G, v); // 计算其下标
        q.pop();        // 顶点v出队

        // 遍历顶点v的邻接点
        for (p = G.vertex[i].firstEdge; p; p = p->nextEdge) {
            j = p->locateVer;   // 记录该顶点下标
            // 如果顶点p未被访问
            if (!visited[j]) {
                cout << G.vertex[j].data << " ";    // 访问顶点p
                visited[j] = 1;                     // 标记p已被访问
                q.push(G.vertex[j].data);           // 将顶点p入队
            }
        }
    }
}

3.2 深度优先遍历

邻接矩阵实现

#include <iostream>
#include <queue>
using namespace std;

typedef int ElemType;
#define MAXNUM 100
bool visited[MAXNUM];   // 定义visited数组，记录顶点的访问情况
queue<ElemType> q;  // 队列用来记录相邻结点

// ！！！邻接矩阵表示图的深度优先遍历 ！！！

// 邻接矩阵存储表示
struct AMGraph {
    ElemType vertex[MAXNUM];  // 顶点表
    int matrix[MAXNUM][MAXNUM];   // 邻接矩阵
    int vernum, edgenum;     // 当前顶点数和边数
};

// 找到顶点v对应下标
int locateVertex(AMGraph& G, ElemType v) {

    for (int i = 0; i < G.vernum; ++i) {
        if (G.vertex[i] == v) {
            return i;
        }
    }
    return -1;
}

// 采用邻接矩阵表示法，构建无向图G
bool createUDG(AMGraph& G) {
    int i, j, k;
    ElemType v1, v2;
    cin >> G.vernum >> G.edgenum;    // 输入总顶点数和边数

    for (i = 0; i < G.vernum; ++i) {
        cin >> G.vertex[i];   // 输入顶点表
    }

    // 初始化邻接矩阵边，0 表示顶点i和j之间无边
    for (i = 0; i < G.vernum; ++i) {
        for (j = 0; j < G.edgenum; ++j) {
            G.matrix[i][j] = 0;
        }
    }

    // 1 表示两顶点之间有边
    for (k = 0; k < G.edgenum; ++k) {
        cin >> v1 >> v2;
        i = locateVertex(G, v1);   // 找到顶点i的下标
        j = locateVertex(G, v2);   // 找到顶点j的下标

        G.matrix[i][j] = G.matrix[j][i] = 1;    // 即i和j之间有边
    }
    return true;
}

void DFS_AM(AMGraph& G, int i) {
    int j;
    cout << G.vertex[i] << " "; // 输出顶点
    visited[i] = 1;             // 标记为已访问
    for (j = 0; j < G.vernum; ++j) {   
        // 如果两顶点之间有边且该顶点还未被访问，则递归调用DFS
        if (G.matrix[i][j] && !visited[j]) {    
            DFS_AM(G, j);
        }
    }
}

邻接表实现：

#include <iostream>
#include <queue>
using namespace std;

typedef int ElemType;
#define MAXNUM 100
bool visited[MAXNUM];   // 定义visited数组，记录顶点的访问情况
queue<ElemType> q;  // 队列用来记录相邻结点

// ！！！ 用邻接表表示图的深度优先搜索 ！！！
// 邻接表存储表示

// 表结点
struct EdgeNode {
    int locateVer;     // 该边所指向的顶点的位置
    EdgeNode* nextEdge;   // 指向下一条边的指针
    int info;       // 和边有关的信息，如权值
};

// 顶点结点
struct VerNode {
    ElemType data;
    EdgeNode* firstEdge;  // 指向第一条依附在该顶点的边的指针
};

struct ALGraph {
    VerNode vertex[MAXNUM];   // 表头结点表
    int vernum, edgenum;     // 总顶点数和边数
};

// 找到顶点对应的下标
int locateVertex(ALGraph& G, ElemType v) {

    for (int i = 0; i < G.vernum; ++i) {
        if (G.vertex[i].data == v) {
            return i;
        }
    }
    return -1;
}

bool createALG(ALGraph& G) {
    int i, j, k;
    ElemType v1, v2;
    cin >> G.vernum >> G.edgenum;    // 输入总顶点数和总边数

    for (i = 0; i < G.vernum; ++i) {
        cin >> G.vertex[i].data;  // 输入顶点值
        G.vertex[i].firstEdge = nullptr;   // 初始化每个表头结点的指针域
    }

    // 输入各边，构造邻接表
    for (k = 0; k < G.edgenum; ++k) {
        cin >> v1 >> v2;    // 输入一条边的两侧顶点
        i = locateVertex(G, v1);   // 找到顶点i的下标
        j = locateVertex(G, v2);   // 找到顶点j的下标

        // 操作表结点
        EdgeNode* p1 = new EdgeNode;  // 创建一个边结点
        p1->locateVer = j;         // 邻接点域为j
        p1->nextEdge = G.vertex[i].firstEdge;
        G.vertex[i].firstEdge = p1;

        // 因为一条边对应两个顶点，直接生成另一对称的新的表结点
        EdgeNode* p2 = new EdgeNode;
        p2->locateVer = i;
        p2->nextEdge = G.vertex[j].firstEdge;
        G.vertex[j].firstEdge = p1;
    }
    return true;
}

void DFS_AL(ALGraph& G, int i) {
    int j;
    cout << G.vertex[i].data << " ";    // 访问该顶点
    visited[i] = 1;         // 标记为以访问
    // 是否可以不用申请一个空间？    
    // EdgeNode* p = new EdgeNode;     
    // p = G.vertex[i].firstEdge;
    EdgeNode* p = G.vertex[i].firstEdge;

    while (p) {
        j = p->locateVer;       // 该顶点的下标
        if (!visited[j]) {
            DFS_AL(G, j);
        }
        p = p->nextEdge;
    }
}
ClimberCoding
关注
  • 6
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
两种常见的遍历方法是深度优先遍历（Depth-First Search, DFS）和广度优先遍历（Breadth-First Search, BFS）。在JavaScript中，我们可以使用递归或非递归的方法来实现这两种遍历。 1. **深度优先遍历**： 深度...
图的广度优先算法全部代码，使用邻接矩阵，包括FirstNeighbor函数以及NextNeighbor函数的实现
强仔的博客
05-26 1253
话不多说，直接上代码，注意代码中顶点的序号是从1开始，但是存放顶点的数组序号是从0开始，所以在代码中需要实现一个函数该函数来通过顶点找到对应的下标，辅助队列使用的是带头结点的链式队列。下图来自王道考研视频，验证中也是从顶点1开始遍历，当然可以自己指定顶点进行验证。注意，边数以及顶点数也可以自己输入，我这里是直接进行赋值了，最后进行验证。
leetcode-广度优先遍历/图
MaYingColdPlay的博客
09-14 947
目录 ​​​​​​​279 完全平方数 127 单词接龙 以前的 现在的 ​ 注意： 单词接龙2 以前的 现在的 走迷宫 岛屿数量 深度优先搜索 广度优先搜索 并查集 岛屿数量2 ​ 并查集 5544. 执行操作后字典序最小的字符串 5548.最小体力消耗路径 回溯 bfs 并查集模版 力扣​​​​​​​ 407 接雨水2 并查集 路径压缩和按rank合并 547 省份数量 并查集模版 本题题解 743 网络延迟时间 Dijk...
【算法】广度优先遍历 (BFS)
代码星辰的博客
01-11 9758
本文介绍了 BFS 的概述、代码实现以及应用。
C语言：广度优先遍历算法
零小唬的博客
10-09 2538
广度优先遍历算法
【C语言】图的深度优先遍历&广度优先遍历(算法，代码一步到位)
Jaye513的博客
12-10 3774
图的两种遍历，你一定要学会
Java实现二叉树的深度优先遍历和广度优先遍历算法示例
08-27
本文详细介绍了Java实现二叉树的深度优先遍历和广度优先遍历算法，通过实例代码展示了深度优先遍历和广度优先遍历的实现过程，并对二叉树的定义、深度优先遍历与广度优先遍历算法原理与相关操作实现技巧进行了详细...
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
在计算机科学中，图是一种数据结构，用于表示对象之间的关系，可以用来建模现实世界中的各种复杂系统。...通过阅读和分析这些代码，可以更深入地理解非递归算法在深度优先遍历和广度优先遍历中的具体实现。
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
10-14
无向图建立、深度优先遍历和广度优先遍历实现算法 本文将详细介绍无向图的建立、深度优先遍历和广度优先遍历的实现算法。这些算法是数据结构中非常重要的内容，掌握它们对后续学习和应用非常重要。 一、无向图的...
C/C++实现图的深度优先遍历和广度优先遍历
最新发布
12-26
C/C++实现图的深度优先遍历和广度优先遍历
【数据结构】图的广度优先遍历
每天进步一点丶的博客
03-20 1409
文章目录1.算法思想2.定义结构体3.函数实现4.测试结果5.完整代码 1.算法思想 广度优先遍历，类似于树的层次遍历，又是熟悉的队列实现。首先将第一个顶点添加到队列中，然后讲该顶点的所有邻接顶点都加入队列中，再将该顶点输出。如此重复直到遍历完整个图。 2.定义结构体 typedef struct { char vertex[VERTEXNUM]; int edge[VERTEXNUM][VERTEXNUM]; int n,e; } MGraph; 3.函数实现 Q:队列，用于存
深度遍历(DFS)与广度遍历(BFS) (C语言实现)
zhangsir199的专栏
05-17 5208
 参考严版数据结构，纯属练习，不当之处还请多多指教： 体会：1.深度遍历：从第一个节点开始一直往下走，碰到多个邻接点的时候，打印第一个，其他存入栈，如此循环            直到某个节点没有邻接点，倒退。当然存入栈跟倒退的动作都是递归来实现，不用操心。 2.广度遍历：同样从第一个节点开始，访问第一个节点并将该节点入队。访问所有与第一个节点直连的所有节点， 
算法数据结构——图的遍历之广度优先搜索算法（Breadth First Search）
白话机器学习
06-06 8750
广度优先搜索算法（Breadth First Search）：简称为 BFS，又译作宽度优先搜索 / 横向优先搜索。是一种用于遍历或搜索树或图的算法。该算法从根节点开始，沿着树的宽度遍历树或图的节点。如果所有节点均被访问，则算法中止。广度优先遍历类似于树的层次遍历过程。呈现出一层一层向外扩张的特点。先看到的节点先访问，后看到的节点后访问。遍历到的节点顺序符合「先进先出」的特点，所以广度优先搜索可以通过「队列」来实现。
数据结构——广度优先遍历（BFS）无向连通图
qq_51231048的博客
10-30 2219
以下是数据结构中关于广度优先遍历无向连通图的操作（编程风格参考严蔚敏版数据结构）。其实深度优先遍历就是二叉树的层次遍历的推广。代码是参考严蔚敏版《数据结构》写的，因为书上只写核心代码不是完整的源程序，以上代码能调是通过是自己对书本代码进行补充才能跑起来，水平有限可能有错，敬请批评指正。
广度优先遍历
weixin_44979432的博客
03-31 201
【代码】广度优先遍历。
C语言实现图的广度优先搜索遍历和深度优先搜索遍历
我一定要早睡
08-14 1290
在这里广度优先遍历没有使用队列而是使用了数组代替了队列，如果使用队列可以使用顺序队列，然后使用入队和出队的代码，在这里数组其实作用差不太多。测试可以按照上一个运行的测试样例对照。
数据结构与算法之广度优先遍历
weixin_47225948的博客
09-20 3814
广度优先遍历（Breadth-First Search，BFS）是一种遍历或搜索数据结构（如树或图）的算法。它从根节点开始，依次遍历同一级别的所有节点，然后再逐级遍历下一级别的节点，直到遍历完整个结构。BFS使用队列（queue）来实现遍历过程。从根节点开始，将根节点入队，然后进入循环。循环中取出队列首部节点，访问它的所有邻居节点并将其入队，然后重复上述步骤，直到队列为空。BFS的时间复杂度为O(N)，其中N代表节点个数。因为它需要遍历整个结构中的每个节点一次。
数据结构——详解图的深度优先遍历和广度优先遍历及代码实现
诶你爱我吗的博客
12-30 1万+
图的深度优先遍历和广度优先遍历： 从本质上来说都是用来访问图中的所有结点的，只是两种访问的方式不同，深度优先遍历用的是堆栈，先进的后出，而广度优先遍历用的是队列的思想。 1.图的深度优先遍历 1.1基本思想： ⑴ 访问顶点v； ⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历； ⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。 例如我们需要用深度优先遍历下面这个图...
C语言实现图的深度优先遍历和广度优先遍历
热门推荐
BEICHENx1的博客
11-28 1万+
图的深度优先遍历和广度优先遍历图的遍历深度优先遍历广度优先遍历 图的遍历 从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中所有顶点，使每个顶点仅被访问一次，这个过程称为图的遍历 图的遍历方法有两种，一种叫深度优先遍历（DFS），另一种叫广度优先遍历（BFS）。 深度优先遍历 深度优先遍历的过程是从图中的某个初始点v出发，首先访问初始点v，然后选择一个与顶点v相邻且没被...
图的深度优先遍历和广度优先遍历代码实现
05-03
以下是图的深度优先遍历和广度优先遍历的代码实现，以邻接表形式存储图： ```python # 图的深度优先遍历 def DFS(graph, start): visited = set() # 记录已经访问过的节点 stack = [start] # 用栈来实现深度优先遍历 while stack: node = stack.pop() if node not in visited: visited.add(node) print(node) # 将所有未访问的邻居节点入栈，实现深度优先遍历 stack.extend([n for n in graph[node] if n not in visited]) # 图的广度优先遍历 def BFS(graph, start): visited = set() # 记录已经访问过的节点 queue = [start] # 用队列来实现广度优先遍历 while queue: node = queue.pop(0) if node not in visited: visited.add(node) print(node) # 将所有未访问的邻居节点入队列，实现广度优先遍历 queue.extend([n for n in graph[node] if n not in visited]) ``` 其中，`graph` 表示邻接表形式存储的图，`start` 表示起始节点。在遍历时，用 `visited` 集合记录已经访问过的节点，防止重复访问。在深度优先遍历中，用栈来实现，每次取出栈顶元素并访问，再将其所有未访问的邻居节点入栈。在广度优先遍历中，用队列来实现，每次取出队首元素并访问，再将其所有未访问的邻居节点入队列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ClimberCoding

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值