图的相关操作(邻接矩阵表示法)

最新推荐文章于 2022-12-10 14:51:15 发布
最新推荐文章于 2022-12-10 14:51:15 发布
阅读量1.2k 收藏 8
点赞数 1
分类专栏： 考研数据结构 文章标签： 数据结构 图论 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43288447/article/details/122269957
版权
本文详细介绍了使用邻接矩阵表示法创建和操作图的各种方法，包括有向图、有向网、无向图和无向网的创建，以及顶点的插入、删除、赋值等操作。同时，提供了深度优先遍历和广度优先遍历的算法实现，帮助读者理解图的基本操作和遍历策略。
摘要由CSDN通过智能技术生成

图的相关操作(邻接矩阵表示法)

文章目录

一：邻接矩阵的结点定义

#define MAX_VERTEX_NUM 20   //定义最大顶点数
#define VertexType int      //定义顶点的数据类型
#define VRType int          //定义顶点之间关系的变量类型
#define InfoTye char        //存储弧或者边的额外信息的指针变量类型
#define INFINITY 100        //定义带权值的图中不可达的无穷
typedef enum {DG,DN,UDG,UDN}GraphKind;      //定义图的类型，0有向图，1有向网，2无向图，3无向网

typedef struct {
    VRType adj;     //顶点之间的关系，如果是无向图，则两定点相邻为1，不想邻为0，若为有向图，则用顶点之间的的权值表示
    InfoTye *info;  //表示边后者弧额外含有的信息指针
}ArcCell;
typedef ArcCell AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];  //表示图的邻接矩阵
typedef struct {
    VertexType vexs[MAX_VERTEX_NUM];    //用来存储顶点的数组
    AdjMatrix arcs;                     //邻接矩阵
    GraphKind kind;                     //图的类型
    int vexnum,arcnum;                  //记录图的定点数和边数
}MGraph;

二：创建矩阵的入口函数

//构造有、无向图，有、无向网的入口函数
int CreatGraph_M(MGraph* G){
    printf("Please select the kind of Graph:");
    scanf("%d",&G->kind);
    switch (G->kind) {
        case DG:
            return CreatDG_M(G);
        case DN:
            return CreatDN_M(G);
        case UDG:
            return CreatUDG_M(G);
        case UDN:
            return CreatUDN_M(G);
        default:break;
    }
}

三：定义顶点v在顶点数组中的位置（下标）

/**
 * 确定顶点v在顶点数组中的位置
 * @param G
 * @param v		顶点数据
 * @return		顶点在顶点数组中的下标
 */
int LocateVex(MGraph G,VertexType v){
    for (int i = 0; i < G.vexs; ++i) {
        if (v == G.vexs[i]){
            return i;
        }
    }
    return -1;
}

四：创建有向图

//创建有向图
int CreatDG_M(MGraph* G){
    //输入图的顶点个数vex，边数arc
    printf("Please input the number of vex and arc:");
    scanf("%d,%d",&(G->vexnum),&(G->arcnum));
    getchar();

    //依次输入顶点数据本身
    printf("Please input the vex:\n");
    for (int i = 0; i < G->vexnum; ++i) {
        scanf("%d",&(G->vexs[i]));
        getchar();
    }

    //初始化二维矩阵数组,全为0
    for (int i = 0; i < G->vexnum; ++i) {
        for (int j = 0; j < G->vexnum; ++j) {
            G->arcs[i][j].adj = 0;
            G->arcs[i][j].info = NULL;  //目前没有指针所指代的内容
        }
    }

    //在二位数组中添加数据
    for (int i = 0; i < G->arcnum; ++i) {
        VertexType v1;  //弧尾
        VertexType v2;  //弧头
        //输入弧尾与弧头
        printf("Please input trail and front:");
        scanf("%d,%d",&v1,&v2);
        //定位
        int trail = LocateVex(*G,v1);   //弧尾
        int front = LocateVex(*G,v2);   //弧头

        //若有顶点不在图中
        if (front==-1||trail == -1){
            printf("No find vertex!!");
            return 0;
        }

        //将正确的弧数据加入到邻接矩阵中
        G->arcs[trail][front].adj = 1;
    }
    return 1;
}

五：创建有向网

/**
 * 创建有向网
 * 有向网与有向图的区别在与有向图中没有权值或者说权值为1
 * 简而言之有向网为带权值的有向图
 * @param G
 * @return
 */
int CreatDN_M(MGraph* G){
   //输入图中顶点个数与边的个数
   printf("Please input the num of vexs and arc:");
   scanf("%d,%d",&(G->vexnum),&(G->arcnum));
   getchar();

   //输入顶点数据
    printf("Please input the data of vex:");
    for (int i = 0; i < G->vexnum; ++i) {
        scanf("%d",&(G->vexs[i]));
        getchar();
    }

    //初始化邻接矩阵为0
    for (int i = 0; i < G->vexnum; ++i) {
        for (int j = 0; j < G->vexnum; ++j) {
            G->arcs[i][j].adj = INFINITY;
            G->arcs[i][j].info = NULL;
        }
    }

    //确定头尾和边上的权值
    for (int i = 0; i < G->arcnum; ++i) {
        VertexType v1,v2;   //v1为尾，v2为头
        VRType m;           //表示当前以v1为尾，v2为头的弧上面的权值

        printf("Please input the trail , head and value:");
        scanf("%d,%d,%d",&v1,&v2,&m);

        int row = LocateVex(*G,v1);     //尾
        int col = LocateVex(*G,v2);     //头

        //判断是否存在
        if (row == -1||col == -1){
            return 0;
        }

        G->arcs[row][col].adj = m;
    }
    return 1;
}

六：创建无向图

int CreatUDG_M(MGraph* G){
    //输入图的顶点个数vex，边数arc
    printf("Please input the number of vex and arc:");
    scanf("%d,%d",&(G->vexnum),&(G->arcnum));
    getchar();

    //依次输入顶点数据本身
    printf("Please input the vex:\n");
    for (int i = 0; i < G->vexnum; ++i) {
        scanf("%d",&(G->vexs[i]));
        getchar();
    }

    //初始化二维矩阵数组,全为0
    for (int i = 0; i < G->vexnum; ++i) {
        for (int j = 0; j < G->vexnum; ++j) {
            G->arcs[i][j].adj = 0;
            G->arcs[i][j].info = NULL;  //目前没有指针所指代的内容
        }
    }

    //在二位数组中添加数据
    for (int i = 0; i < G->arcnum; ++i) {
        //在无向图中没有规定谁是弧头谁是弧尾
        VertexType v1;
        VertexType v2;
        //输入弧尾与弧头
        printf("Please input trail and front:");
        scanf("%d,%d",&v1,&v2);
        //定位
        int trail = LocateVex(*G,v1);
        int front = LocateVex(*G,v2);

        //若有顶点不在图中
        if (front==-1||trail == -1){
            printf("No find vertex!!");
            return 0;
        }

        //将正确的弧数据加入到邻接矩阵中，并且无向图是对称矩阵
        G->arcs[trail][front].adj = 1;
        G->arcs[front][trail].adj = 1;
    }
    return 1;
}

七：创建无向网

int CreatUDN_M(MGraph* G){
    //输入图中顶点个数与边的个数
    printf("Please input the num of vexs and arc:");
    scanf("%d,%d",&(G->vexnum),&(G->arcnum));
    getchar();
    //输入顶点数据
    printf("Please input the data of vex:\n");
    for (int i = 0; i < G->vexnum; ++i) {
        scanf("%d",&(G->vexs[i]));
        getchar();
    }

    //初始化邻接矩阵为0
    for (int i = 0; i < G->vexnum; ++i) {
        for (int j = 0; j < G->vexnum; ++j) {
            G->arcs[i][j].adj = INFINITY;
            G->arcs[i][j].info = NULL;
        }
    }

    //确定头尾和边上的权值
    for (int i = 0; i < G->arcnum; ++i) {
        VertexType v1,v2;   //v1为尾，v2为头
        VRType m;           //表示当前以v1为尾，v2为头的弧上面的权值

        printf("Please input the trail , head and value:");
        scanf("%d,%d,%d",&v1,&v2,&m);

        int row = LocateVex(*G,v1);     //尾
        int col = LocateVex(*G,v2);     //头

        //判断是否存在
        if (row == -1||col == -1){
            return 0;
        }

        G->arcs[row][col].adj = m;
        G->arcs[col][row].adj = m;
    }
    return 1;
}

八：获取第n个顶点的值

/**
 * 返回第n个结点的值
 * @param G
 * @param order
 * @return
 */
VertexType GetVexValue_M(MGraph G,int order){
    if (order>=1 && order<=G.vexnum){   //图中的结点是从1开始的
        return G.vexs[order-1];         //在数组中需要进行减一操作
    }
    return -1;
}

九：对顶点v进行赋值

/**
 * 对顶点v进行赋值操作
 * @param G
 * @param v 顶点值为v
 * @param value     待赋的值
 * @return
 */
int PutVex_M(MGraph* G,VertexType v,VertexType value){
    //遍历图中存储节点的数组
    for (int i = 0; i < G->vexnum; ++i) {
        if (G->vexs[i] = v){
            G->vexs[i] = value;
            return 1;
        }
    }
    return 0;
}

十：将顶点v插入到图中（但是没有插入弧或边）

/**
 * 将顶点v插入到图中
 * @param G
 * @param v
 * @return
 */
int InsertVex_M(MGraph* G,VertexType v){
    //判断顶点的数量是否已经到达最大值
    if (G->vexnum >= MAX_VERTEX_NUM){
        return 0;
    }

    //判断是图还是网
    int sign;
    if (G->kind%2 == 1){
        sign = INFINITY;    //网
    } else{
        sign = 0;
    }

    //将顶点v加入到顶点数组中
    G->vexnum++;
    G->vexs[G->vexnum-1] = v;

    //给邻接矩阵加一行和一列
    for (int i = 0; i < G->vexnum; ++i) {
        G->arcs[G->vexnum-1][i].adj = sign;
        G->arcs[i][G->vexnum-1].adj = sign;
    }
    return 1;
}

十一：删除顶点v

/**
 * 删除顶点v
 * 思路：
 *      删除顶点主要有三部分操作
 *          操作顶点数组，当删除完顶点之后要将后面顶点前移一位
 *          操作邻接矩阵，对应行和列上的数据要清除并将后续行列的数据前移
 *          修改顶点数和边数
 *              注意区分有向图和无向图边数的修改
 * @param G
 * @param v
 * @return
 */
int DeleteVex_M(MGraph* G,VertexType v){
    int index = LocateVex(*G,v);
    if (index == -1){
        return 0;       //待删顶点不在图中
    }
    //删除顶点
    for (int i = index; i <G->vexnum-1 ; ++i) {
        G->vexs[i] = G->vexs[i+1];
    }
    //顶点数组的最后一位置为0
    G->vexs[G->vexnum-1] = 0;
    //统计与待删除结点相接的边数
    int rowcount = 0;
    int colcount = 0;
    int sign;
    if (G->kind%2 == 1){
        sign = INFINITY;    //网
    } else{
        sign = 0;
    }

    for (int i = 0; i < G->vexnum; ++i) {
        if (G->arcs[index][i].adj != sign){
            rowcount++;
        }
    }
    for (int i = 0; i < G->vexnum; ++i) {
        if (G->arcs[i][index].adj != sign){
            colcount++;
        }
    }
    int adjsnum;
    if (G->kind == 0 || G->kind){   //如果是有向图或者是有向网
        adjsnum = rowcount+colcount;
    } else if (G->kind == 2 || G->kind == 3){   //因为无向图或者无向网的邻接矩阵是对称的，所以需要除2
        adjsnum = (rowcount+colcount)/2;
    }

    //处理行
    for (int j = index; j < G->vexnum-1; ++j) {
        for (int i = 0; i < G->vexnum; ++i) {
            G->arcs[j][i] = G->arcs[j+1][i];
        }
    }

    //处理列
    for (int i = index; i < G->vexnum-1 ; ++i) {
        for (int j = 0; j < G->vexnum; ++j) {
            G->arcs[j][i] = G->arcs[j][i+1];
        }
    }

    //顶点数减一，边数减少
    G->vexnum--;
    G->arcnum = G->arcnum - adjsnum;
    return 1;
}

十二：深度优先遍历

/**
 * 寻找第一个与下标为index的顶点相邻的顶点的下标
 * @param G
 * @param index
 * @return  相邻顶点在数组中的下标
 */
int FirstAdjVex(MGraph G,int index){
    int sign;
    if (G.kind%2 == 1){ //表示网，有权值
        sign = INFINITY;
    } else{
        sign = 0;
    }
    for (int i = 0; i < G.vexnum; ++i) {
        if (sign!=G.arcs[index][i].adj){
            return i;
        }
    }
    return -1;
}

/**
 *
 * @param G
 * @param indexV    访问顶点的下标
 * @param indexW    相对顶点的下标
 * @return
 */
int NextAdjVex(MGraph G,int indexV,int indexW){
    int sign;
    if (G.kind%2 == 1){
        sign = INFINITY;
    } else{
        sign = 0;
    }
    for (int i = indexW+1; i <G.vexnum ; ++i) {
        if (G.arcs[indexV][i].adj != sign){
            return i;
        }
    }
    return -1;
}

void visitVex(MGraph G,int index){
    printf("%d\t",G.vexs[index]);
}
//全局变量
bool visited[MAX_VERTEX_NUM];       //访问标志数组
/**
 * 深度优先遍历思想为：
 *      从图中的某起始顶点v开始，访问与v相邻但是并未被访问的下一顶点w1，在访问与w1相邻但是未被访问的顶点
 *      w2。。。。重复上述过程，当不能够将继续向下访问的时候，则依次回退到最近被访问的顶点，若它还有邻接
 *      顶点没有被访问，则从该顶点开始继续上述搜索。直到图中的所有顶点都被访问
 * 显然这是一个递归的过程，那么在遍历过程中要容易辨别定点是否被访问，则需要设置一个全局变量标志数组visited，
 * 来表示该顶点是否已经被访问。
 *
 * @param G
 */
void DFSTraverse(MGraph G){
    //首先初始化访问表示数组
    for (int i = 0; i < G.vexnum; ++i) {
        visited[i] = false;     //初始为false，表示没有被访问
    }

    for (int i = 0; i < G.vexnum; ++i) {
        if (!visited[i]){   //如果尚未被访问
            DFS(G,i);
        }
    }
}
/**
 * 深度优先遍历核心算法
 * @param G
 * @param v     //顶点在数组中的下标
 */
void DFS(MGraph G,int v){
    //访问当前顶点
    visited[v] = true;
    visitVex(G,v);
    int w;
    for (w = FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w)) {       //这边需要想明白
        if (!visited[w]){
            DFS(G,w);
        }
    }
}

十三：广度优先遍历

/**
 * 寻找第一个与下标为index的顶点相邻的顶点的下标
 * @param G
 * @param index
 * @return  相邻顶点在数组中的下标
 */
int FirstAdjVex(MGraph G,int index){
    int sign;
    if (G.kind%2 == 1){ //表示网，有权值
        sign = INFINITY;
    } else{
        sign = 0;
    }
    for (int i = 0; i < G.vexnum; ++i) {
        if (sign!=G.arcs[index][i].adj){
            return i;
        }
    }
    return -1;
}

/**
 *
 * @param G
 * @param indexV    访问顶点的下标
 * @param indexW    相对顶点的下标
 * @return
 */
int NextAdjVex(MGraph G,int indexV,int indexW){
    int sign;
    if (G.kind%2 == 1){
        sign = INFINITY;
    } else{
        sign = 0;
    }
    for (int i = indexW+1; i <G.vexnum ; ++i) {
        if (G.arcs[indexV][i].adj != sign){
            return i;
        }
    }
    return -1;
}

void visitVex(MGraph G,int index){
    printf("%d\t",G.vexs[index]);
}


//全局变量
bool visited[MAX_VERTEX_NUM];       //访问标志数组

/**
 * 广度优先遍历
 * @param G
 */
void BFSTraverse(MGraph G){
    //初始化标记数组
    for (int i = 0; i < G.vexnum; ++i) {
        visited[i] = false;
    }

    int queue[20];      //用来模仿队列
    int rear = 0;
    int top = 0;

    for (int v = 0; v < G.vexnum; ++v) {
        if (!visited[v]){
            visited[v] = true;
            visitVex(G,v);  //访问
            queue[rear] = G.vexs[v];    //将顶点加入到队列中
            rear = (rear+1)%20;
            while (rear-top != 0){      //当队列不为空时
                int u = queue[top];
                top = (top+1)%20;   //出队列一个顶点
                u = LocateVex(G,u); //获取顶点在数组中的下标
                for (int w = FirstAdjVex(G,u); w >=0 ; w = NextAdjVex(G,u,w)) {
                    if (!visited[w]){
                        visited[w] = true;
                        visitVex(G,w);
                        queue[rear] = G.vexs[w];
                        rear = (rear+1)%20;
                    }
                }
            }

        }
    }
}

图示

在这里插入图片描述

啥也不会的研究牲
关注
专栏目录
图的邻接矩阵表示法&邻接表表示法
大力海棠的博客
06-25 9272
图表示是一种多对多的关系的数据结构。因为线性表表示的是一种一对一的关系的数据结构，树表示的是一种一对多的数据结构，所以图把线性表和树都包含在内。图由一个非空的有限顶点集合和一个有限边集合组成。当我们描述图的时候，一定要包含以下两个元素：1、一组顶点：例如用Vertex表示顶点的集合。2、一组边：用Edge表示边的集合，一条边是一组顶点对。      •无向边 ：（i，j）∈Edge，i，j∈Ver...
数据结构 图 邻接矩阵表示法
oowadanoko的博客
01-29 1825
图 邻接矩阵表示法 基本结构： enum GraphKind { DG, DN, UDG, UDN }; template<typename VRType, typename InfoType> struct ArcCell { VRType adj; InfoType* info; }; template<typename VRType, typename InfoType> using AdjMatrix = ArcCell<VRType, InfoType>
数据结构--图的邻接矩阵表示法
07-17
图的邻接矩阵表示法 深度优先搜索遍历 折半查找 数组模式
图的邻接矩阵表示法
winbobob的专栏
07-23 3431
图邻接矩阵表示 1．图的邻接矩阵表示法 　 在图的邻接矩阵表示法中： 　 ① 用邻接矩阵表示顶点间的相邻关系 　 ② 用一个顺序表来存储顶点信息 2．图的邻接矩阵(Adacency Matrix) 　 设G=(V，E)是具有n个顶点的图，则G的邻接矩阵是具有如下性质的n阶方阵： 【例】下图中无向图G 5 和有向图G 6 的邻接矩阵分别为A l 和A 2 。 3．网络的邻
图的邻接矩阵表示方法
weixin_30449239的博客
10-24 175
1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<time.h> 4 #define OK 1 5 #define NO 0 6 #define TRUE 1 7 #define FALSE 0 8 #define ERROR -1 9 #define ...
数据结构-图的邻接矩阵表示法
最新发布
12-13
数据结构-图的邻接矩阵表示法
数据结构（C语言版）——邻接矩阵表示法创建无向网
m0_67929407的博客
11-26 4269
邻接矩阵表示法创建无向网的算法
图的邻接矩阵表示法（Java）
qq_40100414的博客
06-18 2238
基础知识理解 （本人口语化解释，专业解释请自行查阅文献，本人是通过**屈婉玲、耿素云、张立昂编著《离散数学》（第五版）**入门图论，这本书是入门计算机专业不可多得的好书） **图（Graph）：** 描述一组对象（元素）的结构（由**二元组**或**三元组**进行定义）。 **顶点（Vertex）：** 图中的每一个对象（元素）被称为顶点。 **边（Edge）：** 用于两个顶点之间的关系。（弧（Arc）：有方向的边；弧尾（Tail）：初始点；**弧头（Head）：**终端点） **二元组(V,E)：.
数据结构——图的邻接矩阵表示法
minyuanxiani的专栏
09-04 860
#include using namespace std; #define MAX_VERTEX_NUM 10 //最大顶点个数 typedef char VERTYPE; typedef struct { VERTYPE vexs[MAX_VERTEX_NUM]; //顶点向量 int arcs[M
数据结构 图的邻接矩阵表示法
alex1997222的博客
11-02 1260
对于图来说，邻接矩阵是不错的一种图存储结构，但是我们也发现，对于边数相对顶点较少的图，这种结构是存在对存储空间的极大浪费的。因此我们考虑另外一种存储结构方式：邻接表，即数组与链表相结合的存储方法。 邻接表的处理方法是这样的。 1、图中顶点用一个一维数组存储，另外，对于顶点数组中，每个数据元素还需要存储指向第一个邻接点的指针，以便于查找该顶点的边信息。 2、图中每个顶点vi的所有邻
图的表示法--邻接矩阵
meng110389的博客
10-14 967
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
图的表示邻接矩阵
Viator
04-16 5217
邻接矩阵(adjacency matrix)是图的最基本的实现方式，使用方阵A[n][n]表示有n个顶点构成的图，其中每个单元，各自负责描述一对顶点之间可能存在的邻接关系。 对于无权图，存在(不存在)从顶点u到v的边，当且仅当A[u][v]=1(0)。下图没无向图和有向图的邻接矩阵的实例。 这一方式如果推广至带权的网络，各邻接矩阵可以从布尔型改为整型或者浮点型，记录所对应边的权重。对于不存...
图 邻接矩阵表示法 代码实现 java
xmind
06-13 439
  package abc.Dijkstra.pack3; public class MGraph { int vertexNum; int [][] adjMatrix; MGraph(int vertexNum) { this.vertexNum = vertexNum; adjMatrix = new int[vertexNum][vertexNu...
图的邻接矩阵表示及其基本操作
热门推荐
hellolde的博客
08-21 1万+
图的邻接矩阵表示及其基本操作 文章目录图的邻接矩阵表示及其基本操作1.邻接矩阵 1.邻接矩阵 表示图的一种简单方式是使用二维数组，称为邻接矩阵表示法。图中的每条边(v, w)，设置A[v][w]=1；若不存在边(v, w)，则A[v][w] = 0；如果边上带权值，那么可以设置A[v][w]等于该权值，同时使用一个很大或者很小的权值来表示不存在的边。如图，展示了无向图、有向图、有向网和它们的邻接矩阵。 邻接矩阵是一种顺序结构，从邻接矩阵的行数或者列数可知图的顶点数。无向图的邻接矩阵总是对称的，但有向图的邻
数据结构之图的邻接矩阵表示法和邻接表表示法
Richard_666的博客
01-25 983
 
与图相关的一些矩阵
November、Chopin
12-10 2287
邻接矩阵(Adjacency matrix) 度矩阵(Degree matrix) 关联矩阵(Incidence matrix) 拉普拉斯矩阵 常规拉普拉斯矩阵 拉普拉斯矩阵标准化
图的基本操作_邻接矩阵
hang981601026的博客
10-18 888
一、创建     规范方式 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define INIFINITE 32768 #define FALSE 0 #define TRUE 1 typedef int Vertex; typedef int Boolean; typedef char VertexType; typedef int ...
邻接矩阵表示法：无向图特性和应用
邻接矩阵表示法是数据结构中用于表示图的一种重要工具，特别是针对无向图和有向图的存储和操作。以下是一些关键特点： 1. **无向图与有向图的区别**：无向图的邻接矩阵是对称的，这意味着如果顶点v和w之间有一条边...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值