实验08 图存储结构与遍历2022

最新推荐文章于 2024-03-16 22:04:44 发布
最新推荐文章于 2024-03-16 22:04:44 发布
阅读量700 收藏
点赞数
分类专栏： 数据结构实验 文章标签： 算法 深度优先 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62431082/article/details/129093812
版权

A. DS图遍历--深度优先搜索

题目描述

给出一个图的邻接矩阵，对图进行深度优先搜索，从顶点0开始

以下代码框架仅供参考，同学们可在理解的基础上自行设计算法，不强制要求和框架相同

注意：图n个顶点编号从0到n-1

代码框架如下：

输入

第一行输入t，表示有t个测试实例

第二行输入n，表示第1个图有n个结点

第三行起，每行输入邻接矩阵的一行，以此类推输入n行

第i个结点与其他结点如果相连则为1，无连接则为0，数据之间用空格隔开

以此类推输入下一个示例

输出

每行输出一个图的深度优先搜索结果，结点编号之间用空格隔开

输入：

2
4
0 0 1 1
0 0 1 1
1 1 0 1
1 1 1 0
5
0 0 0 1 1
0 0 1 0 0
0 1 0 1 1
1 0 1 0 0
1 0 1 0 0

输出：

0 2 1 3 
0 3 2 1 4

代码：

#include<iostream>
using namespace std;
const int MaxLen = 20;//设置图最多包含20个顶点
class Map {
private:
    bool Visit[MaxLen];//访问标识数组，标识每个顶点是否已经被访问过
    int Maxtrix[MaxLen][MaxLen];//图的邻接矩阵
    int Vexnum;//图的顶点数量
    void DFS(int v);//深度优先内部调用
public:
    void setMatrix(int vnum, int max[MaxLen][MaxLen]);
    void DFSTraverse();//公有函数，被main调用
};
void Map::setMatrix(int vnum, int mx[MaxLen][MaxLen]) {
    int i, j;
    Vexnum = vnum;//设置图的结点数
    for (i = 0; i < MaxLen; i++)//邻接矩阵初始化为0
        for (j = 0; j < MaxLen; j++)
            Maxtrix[i][j] = 0;
    for (i = 0; i < Vexnum; i++)//邻接矩阵初始化
        for (j = 0; j < Vexnum; j++)
            Maxtrix[i][j] = mx[i][j];
}
void Map::DFSTraverse() {//对图G进行深度优先遍历，公有函数
    //代码两行，先把访问标志数组的值全部设为false
    for (int i = 0; i < MaxLen; i++)
        Visit[i] = false;
    //代码2~3行，从0开始，对所有顶点进行检查
    //如果该顶点未访问，则调用DFS函数进行深度优先搜索
    for(int i=0;i<Vexnum;i++)
        if (!Visit[i]) DFS(i);

    cout << endl;
}
void Map::DFS(int v) {//从第v个顶点出发递归地深度优先遍历图G
    int i,w,k;
    Visit[v] = true;
    cout << v << " ";
    int* AdjVex = new int[MaxLen];
    for (i = 0; i < Vexnum; i++) {
        if (Maxtrix[v][i] == 1&&!Visit[i]){
            DFS(i);
        }
        //    AdjVex[k++] = i;
    }
}
int main() {
    int t, n;
    cin >> t;
    while (t--) {
        cin >> n;
        int G[MaxLen][MaxLen];
        for (int i = 0; i < MaxLen; i++)
            for (int j = 0; j < MaxLen; j++)
                G[i][j] = 0;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                cin >> G[i][j];
        Map* map = new Map;
        map->setMatrix(n, G);
        map->DFSTraverse();
    }
}

B. DS图遍历--广度优先搜索

题目描述

给出一个图的邻接矩阵，对图进行深度优先搜索，从顶点0开始

以下代码框架仅供参考，同学们可在理解的基础上自行设计算法，不强制要求和框架相同

注意：图n个顶点编号从0到n-1

代码框架如下：

输入

第一行输入t，表示有t个测试实例

第二行输入n，表示第1个图有n个结点

第三行起，每行输入邻接矩阵的一行，以此类推输入n行

第i个结点与其他结点如果相连则为1，无连接则为0，数据之间用空格隔开

以此类推输入下一个示例

输出

每行输出一个图的广度优先搜索结果，结点编号之间用空格隔开

输入：

2
4
0 0 1 1
0 0 1 1
1 1 0 1
1 1 1 0
5
0 0 0 1 1
0 0 1 0 0
0 1 0 1 1
1 0 1 0 0
1 0 1 0 0

输出：

0 2 3 1 
0 3 4 2 1

代码：

#include<iostream>
using namespace std;
#include<queue>
const int MaxLen = 20;//设置图最多包含20个顶点
class Map {
private:
    bool Visit[MaxLen];//访问标识数组，标识每个顶点是否已经被访问过
    int Maxtrix[MaxLen][MaxLen];//图的邻接矩阵
    int Vexnum;//图的顶点数量
    void DFS(int v);//深度优先内部调用
    void BFS(int v);//广度优先遍历
public:
    void setMatrix(int vnum, int max[MaxLen][MaxLen]);
    void DFSTraverse();//公有函数，被main调用
    void BFSTraverse();//公有函数，被main调用
};
void Map::setMatrix(int vnum, int mx[MaxLen][MaxLen]) {
    int i, j;
    Vexnum = vnum;//设置图的结点数
    for (i = 0; i < MaxLen; i++)//邻接矩阵初始化为0
        for (j = 0; j < MaxLen; j++)
            Maxtrix[i][j] = 0;
    for (i = 0; i < Vexnum; i++)//邻接矩阵初始化
        for (j = 0; j < Vexnum; j++)
            Maxtrix[i][j] = mx[i][j];
}
void Map::DFSTraverse() {//对图G进行深度优先遍历，公有函数
    //代码两行，先把访问标志数组的值全部设为false
    for (int i = 0; i < MaxLen; i++)
        Visit[i] = false;
    //代码2~3行，从0开始，对所有顶点进行检查
    //如果该顶点未访问，则调用DFS函数进行深度优先搜索
    for (int i = 0; i < Vexnum; i++)
        if (!Visit[i]) DFS(i);

    cout << endl;
}
void Map::DFS(int v) {//从第v个顶点出发递归地深度优先遍历图G
    int i, w, k;
    Visit[v] = true;
    cout << v << " ";
    int* AdjVex = new int[MaxLen];
    for (i = 0; i < Vexnum; i++) {
        if (Maxtrix[v][i] == 1 && !Visit[i]) {
            DFS(i);
        }
    }
}
void Map::BFSTraverse() {
    BFS(0);
}
void Map::BFS(int v) {
    queue<int>q;
    cout<<v<<" ";
    q.push(v);
    Visit[v]=true;
    while(!q.empty()){
        int i=0,k=0,u=0,w=0;
        w=q.front();
        q.pop();
        int* AdjVex = new int[Vexnum];
        for( i=0;i<Vexnum;i++) AdjVex[i]=-1;
        for(i=0;i<Vexnum;i++)
            if(Maxtrix[w][i]==1) AdjVex[u++]=i;
        for(i=0;i<u;i++){
            k=AdjVex[i];
            if(!Visit[k]){
                Visit[k]=true;
                cout<<k<<" ";
                q.push(k);
            }
        }
    }
    cout << endl;
}
int main() {
    int t, n;
    cin >> t;
    while (t--) {
        cin >> n;
        int G[MaxLen][MaxLen];
        for (int i = 0; i < MaxLen; i++)
            for (int j = 0; j < MaxLen; j++)
                G[i][j] = 0;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                cin >> G[i][j];
        Map* map = new Map;
        map->setMatrix(n, G);
        map->BFSTraverse();
    }
}

C. 图综合练习--构建邻接表

题目描述

已知一有向图，构建该图对应的邻接表。

邻接表包含数组和单链表两种数据结构，其中每个数组元素也是单链表的头结点，数组元素包含两个属性，属性一是顶点编号info，属性二是指针域next指向与它相连的顶点信息。

单链表的每个结点也包含两个属性，属性一是顶点在数组的位置下标，属性二是指针域next指向下一个结点。

输入

第1行输入整数t，表示有t个图

第2行输入n和k，表示该图有n个顶点和k条弧。

第3行输入n个顶点。

第4行起输入k条弧的起点和终点，连续输入k行

以此类推输入下一个图

输出

输出每个图的邻接表，每行输出格式：数组下标 顶点编号-连接顶点下标-......-^，数组下标从0开始。

具体格式请参考样例数据，每行最后加入“^”表示NULL。

1
5 7
A B C D E
A B
A D
A E
B D
C B
C E
E D

输出：

0 A-1-3-4-^
1 B-3-^
2 C-1-4-^
3 D-^
4 E-3-^

代码：

#include<iostream>
using namespace std;
const int MAXVERTEXNUM=20;
struct ArcNode{      // 边（弧）节点
    int AdjVex;    // 顶点
    int  Weight;    // 边（弧）的权值
    ArcNode *NextArc;    // 指向下一条边(弧)指针
};
struct VexNode {    // 顶点
    char Data;    // 顶点
    ArcNode *firstArc;    // 指向第一条边(弧)指针
};
class Graph{            // 定义图（采用邻接链表）
    int  VertexNum;            // 顶点数
    bool visited[MAXVERTEXNUM];    //访问标记
    VexNode *AdjList;            // 邻接表头指针
public:
    Graph();
    void InsertLinkList(char x, char y);
    int GetVexNodeNo(char c);
    void print();
};
Graph::Graph()    {    // 创建图（采用邻接表）
    int  i, ArcNum;    char x, y;
    cin >> VertexNum;            // 输入顶点数目
    cin >> ArcNum;            // 输入边（弧）数
    AdjList = new VexNode[VertexNum];// 申请n个头结点
    for (i=0; i<VertexNum; i++) {
        cin >> AdjList[i].Data;    // 输入顶点（字符）
        AdjList[i].firstArc = NULL;}    // 置头顶点的第一条边指针为空
    for (i=0; i<ArcNum; i++) {
        cin >> x>> y;        // 输入顶点1（或弧尾）、输入顶点2（或弧头）
        InsertLinkList(x, y);    // 在x的单链表中，插入y结点
        //InsertLinkList(y, x);     // 插入x结点（如果是有向图，不做）
    }
}
void Graph::InsertLinkList(char x, char y)    {
    int i,j;    ArcNode *p, *q;
    i = GetVexNodeNo(x);        // 找到顶点x对应的单链表头结点
    j= GetVexNodeNo(y);
    q = new ArcNode;            // 申请一个新结点
    q->AdjVex = j;            // 边的另一个顶点（弧头）为y
    q->NextArc = NULL;
    if ((AdjList[i].firstArc==NULL)||(AdjList[i].firstArc->AdjVex>j)){
        q->NextArc = AdjList[i].firstArc;    // 有序插入结点
        AdjList[i].firstArc = q;}
    else {    p = AdjList[i].firstArc;
        while((p->NextArc)&&(p->NextArc->AdjVex<j))p=p->NextArc;
        q->NextArc = p->NextArc;    //有序插入结点
        p->NextArc = q;
    }}

int Graph::GetVexNodeNo(char c) {
    int j;
    for (j=0; j<VertexNum; j++)
        if (AdjList[j].Data == c) break;
    return(j);

}
void Graph::print(){
    for(int i=0;i<VertexNum;i++){
        cout<<i<<" "<<AdjList[i].Data<<"-";
        ArcNode *p=new ArcNode;
        p=AdjList[i].firstArc;
        while(p){
            cout<<p->AdjVex<<"-";
            p=p->NextArc;
        }
        cout<<"^"<<endl;
    }
}
int main(){
    int t;
    cin>>t;
    while(t--){
        Graph graph;
        graph.print();
    }
}

D. DS图—图的邻接矩阵存储及度计算

题目描述

假设图用邻接矩阵存储。输入图的顶点信息和边信息，完成邻接矩阵的设置，并计算各顶点的入度、出度和度，并输出图中的孤立点（度为0的顶点）

--程序要求--

若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio

程序中若include多过一个头文件，不看代码，作0分处理

不允许使用第三方对象或函数实现本题的要求

输入

测试次数T，每组测试数据格式如下：

图类型 顶点数 （D—有向图，U—无向图）

顶点信息

边数

每行一条边（顶点1 顶点2）或弧（弧尾 弧头）信息

输出

每组测试数据输出如下信息（具体输出格式见样例）：

图的邻接矩阵

按顶点信息输出各顶点的度（无向图）或各顶点的出度 入度 度（有向图）。孤立点的度信息不输出。

图的孤立点。若没有孤立点，不输出任何信息。

输入：

2
D 5
V1 V2 V3 V4 V5
7
V1 V2
V1 V4
V2 V3
V3 V1
V3 V5
V4 V3
V4 V5
U 5
A B C D E
5
A B
A C
B D
D C
A D

输出:

0 1 0 1 0
0 0 1 0 0
1 0 0 0 1
0 0 1 0 1
0 0 0 0 0
V1: 2 1 3
V2: 1 1 2
V3: 2 2 4
V4: 2 1 3
V5: 0 2 2
0 1 1 1 0
1 0 0 1 0
1 0 0 1 0
1 1 1 0 0
0 0 0 0 0
A: 3
B: 2
C: 2
D: 3
E

代码：

#include<iostream>
using namespace std;
#define MAXVERTEXNUM    100    // 最大顶点数
struct connect{
    char* x;
    char* y;
};
class Graph{
    int  VertexNum;        // 顶点数
    char type;//图类型
    char* Vertex[MAXVERTEXNUM];// 顶点数据
    int information;//顶点信息
    int  AdjMatrix[MAXVERTEXNUM][MAXVERTEXNUM];
    int* degree;//无向图顶点的度
    int* outdegree;
    int* indegree;
    connect *con;
    // 邻接矩阵
    void youxian();
    void wuxian();
    void printyouxian();
    void printwuxian();
public:
    Graph();
    void printAdjMatrix();
    void print();
};
Graph::Graph()    // 生成图
{
    cin>>type>>VertexNum;
    outdegree=new int[VertexNum];
    indegree=new int[VertexNum];
    degree=new int[VertexNum];
    for(int i=0;i<VertexNum;i++){
        Vertex[i]=new char[3];
        cin>>Vertex[i];
        for(int j=0;j<VertexNum;j++)
            AdjMatrix[i][j]=0;
    }
    cin>>information;
    con=new connect[information];
    for(int i=0;i<information;i++){
        con[i].x=new char [3];
        con[i].y=new char [3];
        cin>>con[i].x>>con[i].y;
    }
    if(type=='D')youxian();
    else wuxian();
}
void Graph::printAdjMatrix() {
    for(int i=0;i<VertexNum;i++){
        for(int j=0;j<VertexNum-1;j++)
            cout<<AdjMatrix[i][j]<<" ";
        cout<<AdjMatrix[i][VertexNum-1]<<endl;
    }
}
void Graph::youxian() {
    if(Vertex[0][1]!='\0'){
        for(int i=0;i<information;i++)
            AdjMatrix[con[i].x[1]-'1'][con[i].y[1]-'1']=1;
    }
    else{
        for(int i=0;i<information;i++)
            AdjMatrix[con[i].x[0]-'0'][con[i].y[0]-'0']=1;
    }
    for(int i=0;i<VertexNum;i++){
        int count1=0,count2=0;
        for(int j=0;j<VertexNum;j++){
            if(AdjMatrix[i][j]==1) count1++;
            if(AdjMatrix[j][i]==1) count2++;
        }
        outdegree[i]=count1;
        indegree[i]=count2;
    }
}
void Graph::wuxian() {
    for(int i=0;i<VertexNum;i++) degree[i]=0;
    for(int i=0;i<information;i++){
        AdjMatrix[con[i].x[0]-'A'][con[i].y[0]-'A']=1;
        AdjMatrix[con[i].y[0]-'A'][con[i].x[0]-'A']=1;
    }
    for(int i=0;i<VertexNum;i++)
        for(int j=0;j<VertexNum;j++)
            if(AdjMatrix[i][j]==1) degree[i]++;
}
void Graph::print() {
    if(type=='D') printyouxian();
    else printwuxian();
}
void Graph::printyouxian() {
    for(int i=0;i<VertexNum;i++)
        if(outdegree[i]==0&&indegree[i]==0)
            cout<<Vertex[i]<<endl;
        else
            cout<<Vertex[i]<<": "<<outdegree[i]<<" "<<indegree[i]<<" "<<outdegree[i]+indegree[i]<<endl;
}
void Graph::printwuxian() {
    for(int i=0;i<VertexNum;i++)
        if(degree[i]==0)
            cout<<Vertex[i]<<endl;
        else
            cout<<Vertex[i]<<": "<<degree[i]<<endl;
}
int main(){
    int t;
    cin>>t;
    while(t--){
        Graph graph;
        graph.printAdjMatrix();
        graph.print();
    }
}

后面的不会了，摆

要被ddl噶辣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图综合练习--构建邻接表
luoyeliufeng的博客
12-20 2558
图综合练习–构建邻接表 题目描述 已知一有向图，构建该图对应的邻接表。 邻接表包含数组和单链表两种数据结构，其中每个数组元素也是单链表的头结点，数组元素包含两个属性，属性一是顶点编号info，属性二是指针域next指向与它相连的顶点信息。 单链表的每个结点也包含两个属性，属性一是顶点在数组的位置下标，属性二是指针域next指向下一个结点。 输入 第1行输入整数t，表示有t个图 第2行输入n和k，表...
数据结构实验代码图的两种遍历.rar
最新发布
05-01
广度优先搜索（BFS）则从起始节点开始，一层一层地遍历图的所有节点。首先访问起始节点，然后访问与其相邻的未访问节点，再接着访问这些相邻节点的未访问邻居，以此类推。BFS通常使用队列来辅助实现，可以找到最短...
C语言 图的建立（邻接矩阵与邻接表）
m0_73070900的博客
05-25 5131
5Cinfty。
数据结构-树系列之基础（一）
B君的军火库
05-27 362
数据结构系列正式进入树的专题！鼓掌~ 毫不夸张的说，树乃是数据结构中最重要的一环，太多的地方需要用到树，前面的链表与数组仅仅是一种线性的存储结构，而树则立体了起来。那么，什么是树呢？ 文章目录树的基础概念什么是树节点的度节点关系节点层次树的深度二叉树二叉树定义二叉树描述多叉树二叉树特点二叉树性质满二叉树（完美二叉树）二叉树的存储结构数组存储结构链表存储结构重难点：二叉树遍历前序遍历中序遍历后序遍历...
邻接矩阵存储图 C++题解
xxy20110830的博客
03-16 268
内存限制： 128 MiB 时间限制： 1000 ms 标准输入输出 题目类型： 传统 评测方式： 文本比较。
数据结构实验报告-图的遍历.doc
07-11
数据结构实验报告主要关注的是图的遍历方法，包括深度优先遍历（DFS）和广度优先遍历（BFS）。图是一种非线性的数据结构，由顶点和边组成，用于表示对象之间的关系。实验的目标是理解和掌握图的逻辑结构（如邻接矩阵...
实验报告：图的存储结构和遍历.doc
10-10
图的存储结构和遍历 一、图的存储结构 图的存储结构是指将图结构存储在计算机中的方法。常见的图存储结构有两种：邻接矩阵存储法和邻接表存储法。 1. 邻接矩阵存储法 邻接矩阵存储法是将图的节点之间的关系存储...
数据结构实验图的储存与遍历.doc
09-28
在本实验中，重点在于理解并实现图这种非线性数据结构的存储和遍历方法。图是由顶点（或节点）和边构成的数据结构，用于表示对象之间的关系。以下是关于实验涉及的知识点的详细解释： 1. **邻接矩阵**：这是一种二...
数据结构实验 - 图的储存与遍历.doc
11-26
数据结构实验 - 图的存储与遍历是计算机科学中一项重要的实践任务，它涉及到图论的基本概念和算法。在这个实验中，目标是理解和掌握图这种非线性数据结构的两种常见存储方法：邻接矩阵和邻接表，以及在这些存储方式...
DS|图（存储与遍历）
2203_75720729的博客
01-06 888
数据结构学习记录
【数据结构OJ】A:图综合练习--构建邻接表
weixin_73824936的博客
11-23 458
邻接表包含数组和单链表两种数据结构，其中每个数组元素也是单链表的头结点，数组元素包含两个属性，属性一是顶点编号info，属性二是指针域next指向与它相连的顶点信息。单链表的每个结点也包含两个属性，属性一是顶点在数组的位置下标，属性二是指针域next指向下一个结点。输出每个图的邻接表，每行输出格式：数组下标 顶点编号-连接顶点下标-……第2行输入n和k，表示该图有n个顶点和k条弧。第4行起输入k条弧的起点和终点，连续输入k行。已知一有向图，构建该图对应的邻接表。第1行输入整数t，表示有t个图。
关系网络 时间限制：1秒 内存限制：128M
xiong_er0512的博客
10-29 159
有n个人，他们的编号为1~n，其中有一些人相互认识，现在x想要认识y，可以通过他所认识的人来认识更多的人（如果a认识b，b认识c，那么a可以通过b来认识c），求出x最少需要通过多少人才能认识y。接下来n行是一个nxn的邻接矩阵，a[i][j]=1表示i认识j，a[i][j]=0表示不认识。保证i=j时，a[i][j]=0,并且a[i][j]=a[j][i]一行一个整数，表示x认识y最少需要通过的人数。数据保证x一定能认识y。第一行3个整数n、x、y,2<=n<=100。
邻接表和逆邻接表
m0_54234010的博客
01-02 9763
邻接表与逆邻接表
【数据结构】图综合练习--构建邻接表
笔记
11-08 1666
有了下标之后，我们来实现插入的操作，这里要注意是有顺序的插入，如果头节点为空或者当前需要插入的下标小于头节点的下标，那么插入到头节点的后面，如果不是，那么乖乖循环去找恰当的位置插入。邻接表包含数组和单链表两种数据结构，其中每个数组元素也是单链表的头结点，数组元素包含两个属性，属性一是顶点编号info，属性二是指针域next指向与它相连的顶点信息。输出每个图的邻接表，每行输出格式：数组下标 顶点编号-连接顶点下标-......-^，数组下标从0开始。需要两个结构体，一个是顶点，一个是连接的点。
百 花 数橘结构 9
Qa666qa的博客
11-12 424
数据滴作业
DS图-拓扑排序
夜阑優琿
01-02 390
题目 问题 C: DS图-拓扑排序 时间限制: 1 Sec 内存限制: 128 MB 提交: 202 解决: 63 [提交][状态][讨论版] 题目描述 已知有向图，求它的求拓扑有序序列。 拓扑排序算法：给出有向图邻接矩阵 1.逐列扫描矩阵，找出所有入度为0的顶点入队列（栈）。 2.队列（栈）不空，输出队头（栈顶)元素v，出队（出栈），将v的所有邻接点入度减-。度为0，入队（栈）。 重复步骤2，直到队空（栈空）。 输入 第一行：测试次数t，表示有t个有向图。 每组测试数据格式如下: 第一行
数据结构（廿三） -- C语言版 -- 图 - 图的存储结构 -- 邻接表、逆邻接表
热门推荐
青椒*^_^*凤爪爪的博客
08-15 1万+
在图中任何两个顶点之间都可能存在联系，所以图的存储结构应该需要根据具体问题的要求来进行设计。从图的逻辑结构定义来看，图中任何一个顶点都可以看成是第一个顶点。常用的存储结构有邻接矩阵、邻接表（逆邻接表）、十字链表、邻接多重表、 边集数组。那么本博文将带你就 “邻接表（逆邻接表）” 来窥探一二。。。
图综合练习--构建邻接表：快速使用vector
m0_61960885的博客
10-31 464
vector > 变量名(大小n,vector)vector 变量名字（大小）.pop_back(这里不需要传入参数)——删除队尾元素。vector的下标可以是字符、字符串等，不局限于int。.push_back（需要添加的数据）——在队尾追加。使用：类似于数组——变量名[数据位置].clear()——清空vector。相当于一个二维数组，变量【】【】vector 的嵌套。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值