Prim和Kruskal求最小生成树

最新推荐文章于 2024-08-23 16:51:26 发布
最新推荐文章于 2024-08-23 16:51:26 发布
阅读量758 收藏
点赞数
分类专栏： 图论－－基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cherish0222/article/details/78429198
版权

前两天TCP/IP协议课上,老师谈到图论中的几个简单算法,发现自己不是很熟练,所以马上挂了一套MST的题目来练练手,题目很简单,但由于课程比较多,所以还有三个题没来得及刷,同时在此%一波典

假设给出了一个图G<V,E>

首先是Prim算法,基于贪心的思想,任选一个点形成一棵树,然后不断的从剩下的点中挑出距离这棵树中任意一个点距离最小的点,不断的重复这个操作,直到n个点都加入到树中形成最小生成树.时间复杂度为O(|V|^2)

点我看Prim详解

关于Kruskal算法,也是基于贪心的思想,同时利用了并查积,先选出一条最小的边,这个边形成一个边的集合,然后再选出一条最小的边,如果这条边的两个点的祖先不是同一个的话,把这条边加入到边的集合中,直到找到n-1条边为止.时间复杂度为O(ElogE).

点我看Kruskal详解


从时间复杂度来看,Prim适用于点比较少的图,Kruskal适合边较少的图.


最小生成树基础题:

HDU-1102 Constructing Roads

/*Prim求最小生成树*/
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e2+10;
int n,q;
int mp[maxn][maxn];
int lowcost[maxn];//表示以i为终点的边的最小权值,当lowcost[i]=0说明以i为终点的边的最小权值=0,也就是表示i点加入了MST
int mst[maxn];//表示对应lowcost[i]的起点,即说明边<mst[i],i>是MST的一条边,当mst[i]=0表示起点i加入MST

int Prim()
{
    //初始化lowcost和mst
    mst[1] = 0;
    lowcost[1] = -1;//先把第一个点加到生成树里面
    for( int i = 2; i<= n; i++)
    {
        lowcost[i] = mp[1][i];//初始化以i为终点的最小权值
        mst[i] = 1;//以哪个点为起点才能得到的最小权值
    }

    int mn,mnid;//当前边的最小权值,加入的点的编号
    int sum = 0;//最小权值和
    for( int i = 2; i <= n; i++)
    {
        mn = inf;
        mnid = 0;
        for( int j = 2; j <= n; j++)
        {
            // printf("j=%d lowcost[j]=%d mn=%d\n",j,lowcost[j],mn);
            if( lowcost[j] < mn && lowcost[j] != -1)//当前权值小且没有加入到树中
            {
                mn = lowcost[j];
                mnid = j;
            }
        }
        sum += mn;
        // printf("sum=%d mnid=%d\n",sum,mnid);
        lowcost[mnid] = -1;
        for( int j = 2; j <= n; j++)
        {
            if( mp[mnid][j] < lowcost[j])
            {
                lowcost[j] = mp[mnid][j];
                mst[j] = mnid;
            }
        }

    }
    return sum;
}

int main()
{
    while( ~scanf("%d",&n))
    {
        for( int i = 1; i <= n; i++)
            for( int j = 1; j <= n; j++)
                scanf("%d",&mp[i][j]);
        scanf("%d",&q);
        while( q--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            mp[u][v] = mp[v][u] = 0;//这是别人已经修好了的路,要用的话就是零消费
        }

        int ans = 0;
        ans = Prim();
        printf("%d\n",ans);
    }

    return 0;
}



HDU-2122 Ice_cream’s world III

/*Prim求最小生成树*/
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e3+10;
const int maxm = 1e4+10;
int n,m;
int mp[maxn][maxn];
int lowcost[maxn];
int mst[maxn];

int Prim()
{
    //初始化
    lowcost[0] = -1;
    mst[0] = 0;
    for( int i = 1; i < n; i++)
    {
        lowcost[i] = mp[0][i];
        mst[i] = 0;
    }

    int mn,id;
    int sum = 0;
    for( int i = 1; i < n; i++)
    {
        mn = inf;
        id = 0;
        for( int j = 1; j < n; j++)
        {
            if( lowcost[j] < mn && lowcost[j] != -1)
            {
                mn = lowcost[j];
                id = j;
            }
        }

        sum += lowcost[id];
        lowcost[id] = -1;
        for( int j = 1; j < n; j++)
        {
            if( mp[id][j] < lowcost[j])
            {
                lowcost[j] = mp[id][j];
                mst[j] = id;
            }
        }
    }

    return sum;
}

int main()
{
    int flak = false;
    while( ~scanf("%d%d",&n,&m))
    {
        mem(mp,inf);
        int u,v,x;
        for( int i = 1; i <= m; i++)
        {
            scanf("%d%d%d",&u,&v,&x);
            if( u != v)//存在重边的情况
            {
                mp[u][v] = min(mp[u][v],x);
                mp[v][u] = min(mp[v][u],x);
            }
        }

        int ans = Prim();
        int cnt = 0;
        for( int i = 0; i < n; i++)
            if( lowcost[i] == -1)
                cnt++;
        if( cnt != n)
            puts("impossible");
        else
            printf("%d\n",ans);
        puts("");
    }

    return 0;
}


HDU-1233 还是畅通工程

/*Prim*/
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e2+10;
int n;
int mp[maxn][maxn];
int lowcost[maxn];
int mst[maxn];

int Prim()
{
    lowcost[1] = -1, mst[1] = 0;
    for( int i = 2; i <= n; i++)
        lowcost[i] = mp[1][i], mst[i] = 1;

    int mn, id;
    int sum = 0;
    for( int i = 2; i <= n; i++)
    {
        mn = inf;
        id = 0;
        for( int j = 2; j <= n; j++)
        {
            if( lowcost[j] < mn && lowcost[j] != -1)
            {
                mn = lowcost[j];
                id = j;
            }
        }

        sum += lowcost[id];
        lowcost[id] = -1;
        for( int j = 2; j <= n; j++)
        {
            if( mp[id][j] < lowcost[j])
            {
                lowcost[j] = mp[id][j];
                mst[j] = id;
            }
        }
    }
    return sum;
}

int main()
{
    while( ~scanf("%d",&n) && n)
    {
        mem(mp,inf);
        int m = n*(n-1)/2;
        int u,v,x;
        for( int i = 1; i <= m; i++)
        {
            scanf("%d%d%d",&u,&v,&x);
            mp[u][v] = x;
            mp[v][u] = x;
        }

        int ans = Prim();
        printf("%d\n",ans);
    }

    return 0;
}


HDU-1863 畅通工程

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e2+10;
int n,m;
int mp[maxn][maxn];
int lowcost[maxn];
int mst[maxn];

int Prim()
{
    lowcost[1] = -1;
    mst[1] = 0;
    for( int i = 2; i <= m; i++)
    {
        lowcost[i] = mp[1][i];
        mst[i] = 1;
    }

    int mn,id;
    int sum = 0;
    for( int i = 2; i <= m; i++)
    {
        mn = inf;
        id = 0;
        for( int j = 2; j <= m; j++)
        {
            if( lowcost[j] < mn && lowcost[j] != -1)
            {
                mn = lowcost[j];
                id = j;
            }
        }

        sum += lowcost[id];
        lowcost[id] = -1;
        for( int j = 2; j <= m; j++)
        {
            if( mp[id][j] < lowcost[j])
            {
                lowcost[j] = mp[id][j];
                mst[j] = id;
            }
        }
    }
    return sum;
}

int main()
{
    while( ~scanf("%d%d",&n,&m) && n)
    {
        mem(mp,inf);
        int u,v,x;
        for( int i = 0; i < n; i++)
        {
            scanf("%d%d%d",&u,&v,&x);
            mp[u][v] = min(mp[u][v],x);
            mp[v][u] = min(mp[v][u],x);
        }

        int ans = Prim();
        int cnt = 0;
        for( int i = 1; i <= m; i++)
        {
            if( lowcost[i] == -1)
                cnt++;
        }
        if( cnt != m)
            puts("?");
        else
            printf("%d\n",ans);
    }

    return 0;
}


HDU-1875 畅通工程再续

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 1e20
#define eps 1e-8
const int maxn = 1e2+10;
int n;
double mp[maxn][maxn];
double lc[maxn];
int vis[maxn];
struct Point{
    int x,y;
    Point(){}
    Point( int _x, int _y)
    {
        x = _x, y = _y;
    }
};
Point p[maxn];

int sgn( double x)
{
    if( fabs(x) < eps)
        return 0;
    if( x < 0)
        return -1;
    return 1;
}

int sqr( int x)
{
    return x*x;
}

double dist( Point a, Point b)
{
    return sqrt(1.0*(sqr(a.x-b.x)+sqr(a.y-b.y)));
}

double Prim()
{
    mem(vis,0);
    vis[1] = 1;
    for( int i = 2; i <= n; i++)
        lc[i] = mp[1][i];

    double mn;
    int id;
    double sum = 0;
    for( int i = 2; i <= n; i++)
    {
        mn = inf;
        id = 0;
        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] && lc[j] < mn)
            {
                mn = lc[j];
                id = j;
            }
        }
        sum += mn;
        vis[id] = 1;
        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] && mp[id][j] < lc[j])
                lc[j] = mp[id][j];
        }
    }
    return sum;
}

int main()
{
    int T;
    scanf("%d",&T);
    while( T--)
    {
        scanf("%d",&n);
        for( int i = 1; i <= n; i++)
            scanf("%d%d",&p[i].x,&p[i].y);

        for( int i = 1; i <= n; i++)
        {
            for( int j = 1; j <= n; j++)
            {
                mp[i][j] = inf;
                double dis = dist(p[i],p[j]);
                if( sgn(dis-10.0) >= 0 && sgn(dis-1000.0) <= 0)
                    mp[i][j] = dis;
            }
        }
        double ans = Prim();
        if( ans >= inf)
            puts("oh!");
        else
            printf("%.1f\n",ans*100);
    }

    return 0;
}


HDU-3371 Connect the Cities

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 5e2+10;
int n,m,k;
int mp[maxn][maxn];
int con[maxn];
int lc[maxn];
bool vis[maxn];
int ans;

void Prim()
{
    mem(vis,0);
    vis[1] = 1;
    for( int i = 2; i <= n; i++)
        lc[i] = mp[1][i];

    int pos = 1;
    ans = 0;
    for( int i = 2; i <= n; i++)
    {
        int mn = inf;
        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] &&  lc[j] < mn)
            {
                mn = lc[j];
                pos = j;
            }
        }

        ans += mn;
        if( mn == inf)
            return;
        vis[pos] = 1;

        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] && mp[pos][j] < lc[j])
                lc[j] = mp[pos][j];
        }
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while( T--)
    {
        mem(mp,inf);
        scanf("%d%d%d",&n,&m,&k);
        int u,v,x;
        for( int i = 0; i < m; i++)
        {
            scanf("%d%d%d",&u,&v,&x);
            mp[u][v] = min(mp[u][v],x);
            mp[v][u] = min(mp[v][u],x);
        }

        while( k--)
        {
            int t;
            scanf("%d",&t);
            for( int i = 0; i < t; i++)
                scanf("%d",&con[i]);
            for( int i = 0; i < t; i++)
                for( int j = i+1; j < t; j++)
                    mp[con[i]][con[j]] = mp[con[j]][con[i]] = 0;
        }

        Prim();
        if( ans > inf)
            puts("-1");
        else
            printf("%d\n",ans);
    }


    return 0;
}


HDU-1301 Jungle Roads

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e2+10;
int n;
int mp[maxn][maxn];
int lc[maxn];
bool vis[maxn];
int ans;

void Prim()
{
    mem(vis,0);
    vis[1] = 1;
    for( int i = 2; i <= n; i++)
        lc[i] = mp[1][i];

    int pos = 1;
    ans = 0;
    for( int i = 2; i <= n; i++)
    {
        int mn = inf;
        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] &&  lc[j] < mn)
            {
                mn = lc[j];
                pos = j;
            }
        }

        ans += mn;
        if( mn == inf)
            return;
        vis[pos] = 1;

        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] && mp[pos][j] < lc[j])
                lc[j] = mp[pos][j];
        }
    }
}

int main()
{
    while( ~scanf("%d",&n) && n)
    {
        mem(mp,inf);
        for( int i = 1; i < n; i++)
        {
            getchar();
            char ch;
            int u,v,x;
            scanf("%c",&ch);
            u = ch-'A'+1;
            int t;
            scanf("%d",&t);
            for( int i = 0; i < t; i++)
            {
                getchar();
                scanf("%c%d",&ch,&x);
                v = ch-'A'+1;
                mp[u][v] = min(mp[u][v],x);
                mp[v][u] = min(mp[v][u],x);
            }
        }
        // for( int i = 1; i <= n; i++)
        // {
        //     for( int j = 1; j <= n; j++)
        //     {
        //         if( mp[i][j] == inf)
        //             printf(" -1");
        //         else
        //             printf("%3d",mp[i][j]);
        //     }
        //     puts("");
        // }
        Prim();
        printf("%d\n",ans);
    }

    return 0;
}


HDU-1162 Eddy's picture

/*Kruskal*/
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 1e20;
const int maxn = 1e2+10;
const int maxm = 1e4+10;
int n;
struct Point{
    double x,y;
};
Point p[maxn];
struct Edge{
    int a,b;
    double dis;
    Edge(){}
    Edge( int _a, int _b, double _dis)
    {
        a = _a, b = _b, dis = _dis;
    }
};
Edge e[maxm];
int sz;//边的条数
double ans;
int pre[maxn];

void Init()
{
    for( int i = 0; i < n; i++)
        pre[i] = i;
}

double sqr( double x)
{
    return x*x;
}

double dist( Point p0, Point p1)
{
    return sqrt(sqr(p0.x-p1.x)+sqr(p0.y-p1.y));
}

bool cmp( Edge e0, Edge e1)
{
    return e0.dis < e1.dis;
}

int Find( int x)
{
    if( x == pre[x])
        return x;
    return pre[x] = Find(pre[x]);
}

void Union( int x, int y)
{
    int px = Find(x);
    int py = Find(y);
    if( px != py)
        pre[px] = py;
}

void Kruskal()
{
    sort(e,e+sz,cmp);
    int edge = 0;
    for( int i = 0; i < sz && edge != n-1; i++)
    {
        if( Find(e[i].a) != Find(e[i].b))
        {
            Union(e[i].a,e[i].b);
            ans += e[i].dis;
            edge++;
        }
    }
}

int main()
{
    while( ~scanf("%d",&n))
    {
        for( int i = 0; i < n; i++)
            scanf("%lf%lf",&p[i].x,&p[i].y);
        sz = 0;
        for( int i = 0; i < n; i++)
        {
            for( int j = i+1; j < n; j++)
            {
                double dis = dist(p[i],p[j]);
                e[sz++] = Edge(i,j,dis);
            }
        }

        Init();
        ans = 0;
        Kruskal();
        printf("%.2f\n",ans);
    }

    return 0;
}


Vmorish
关注
专栏目录
最小生成树(Prim、Kruskal)算法，秒懂！
bigsai
09-30 4万+
前言 在数据结构与算法的图论中，(生成)最小生成树算法是一种常用并且和生活贴切比较近的一种算法。但是可能很多人对概念不是很清楚，什么是最小生成树? 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。 通俗易懂的讲就是最小生成树包含原图的所有节点而只用最少的边和最小的权值距离。因为n个节点最少需要n-1个边联通，而距离就需要采取某种策略选择恰当的边。 学习最
Prim算法与Kruskal算法求最小生成树
07-10
Prim算法与Kruskal算法 求最小生成树 源代码 实验报告 完整
AcWing 859. Kruskal算法求最小生成树
Allen的博客
02-05 201
给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。 求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。 给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合，n=|V|，m=|E|。 由V中的全部n个顶点和E中n-1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无向图G的最小生成树。 输入格...
最小生成树 —— Kruskal 克鲁斯卡尔算法
最新发布
qq_64485082的博客
08-23 3116
算法是一种用来在加权连通图中寻找最小生成树的算法，其操作对象是。1. 从加权图中的找出；初始时，所有边都不属于最小生成树，最小生成树为。2. 从不属于最小生成树的边中，判断最小边及其连接的两个顶点加入到最小生成树。a)若不形成环路，则将此最小边及其连接的顶点并入最小生成树；b)若形成环路，则永远不再看此边，然后从剩下的且不属于最小生成树的边中，寻找权值最小的边。3. 重复上述步骤，直至所有顶点均连接在一起，并没有形成环路时，最小生成树就找到了。
图详解第三篇：最小生成树（Kruskal算法+Prim算法）
热门推荐
m0_70980326的博客
10-13 1万+
最小生成树：Kruskal算法+Prim算法
用Prim和Kruskal算法实现图的最小生成树
liangwgl的博客
11-30 1182
1.最小生成树的概念    最小生成树   由一个网络生成的各边的权数总和最小的生成树，记为MST(Minimum Cost Spanning Tree)。 MST性质   设N=(V,{E})是一个连通的网络，U是V的真子集，若边(u,v)[uÎU,vÎV-U]是E中所有一个端点在U内，一个端点不在U内的边中权值最小的一条边(轻边)，则一定存在G的一棵生成树包括此边。
大话数据结构-普里姆算法（Prim）和克鲁斯卡尔算法（Kruskal）
村长Korbin
03-02 6890
最小生成树的定义，普里姆算法（Prim）和克鲁斯卡尔（Kruskal），以及各种存储结构下的最小生成树的代码实现。
Prim与Kruskal算法的最小生成树matlab实现
05-26
在通信网理论作业3-最小生成树这个项目中，你可能会学习如何用MATLAB编写代码，实现Prim和Kruskal算法，并对给定的网络图数据进行最小生成树的构造。这将涉及到数据结构的设计、图的遍历以及最小生成树的验证等编程...
Prim和Kruskal算法求最小生成树
m0_58228798的博客
11-08 806
两种算法求最小生成树都是基于贪心算法完成的Prim算法是通过选择节点来构建最小生成树的Kruskal算法是通过选择边来构建最小生成树的Kruskal适合于稀疏图Prim适合于稠密图。
cpp-图论算法最小生成树Prim算法和Kruskal算法C实现
08-16
本文将详细介绍两种经典算法来解决最小生成树问题：Prim算法和Kruskal算法，并以C语言实现为例进行讲解。 ### Prim算法 Prim算法是一种贪心算法，其基本思想是从一个初始节点开始，逐步添加最短的边，直到连接到...
Kruskal算法 最小生成树
03-08
克鲁斯卡尔算法的基本思想是以边为主导地位，始终选择当前可用（所选的边不能构成回路）的最小权植边。所以Kruskal算法的第一步是给所有的边按照从小到大的顺序排序。这一步可以直接使用库函数qsort或者sort。接下来从小到大依次考察每一条边（u，v）。 具体实现过程如下： <1>　设一个有n个顶点的连通网络为G（V,E），最初先构造一个只有n个顶点，没有边的非连通图T={V,空}，图中每个顶点自成一格连通分量。 <2>　在Ｅ中选择一条具有最小权植的边时，若该边的两个顶点落在不同的连通分量上，则将此边加入到Ｔ中；否则，即这条边的两个顶点落到同一连通分量 上，则将此边舍去（此后永不选用这条边），重新选择一条权植最小的边。 <3>　如此重复下去，直到所有顶点在同一连通分量上为止。
kruskal算法求最小生成树
09-29
深度遍历图并用kruskal算法求最小生成树
kruskal求最小生成树
12-02
通过矩阵输入权值情况，求最小生成树，并按顺序输出每一条路
最小生成树（Prim，Kruskal）
Stormjing的博客
11-16 332
1. 图的基本概念： 连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。 强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。 连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通网。 生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个...
最小生成树的Prim算法以及Kruskal算法（C语言）
派拉斯兔子的博客
08-06 1242
一、生成树 连通图的生成树是包含图中全部顶点的一个极小连通子图。 边尽可能的少，但要保持连通 若图中顶点数为n，则它的生成树含有 n-1 条边。对生成树而言，若砍去它的一条边，则会变成非连通图，若加上一条边则会形成一个回路。 （一）最小生成树（最小代价树） 对于⼀个带权连通⽆向图G = (V, E)，⽣成树不同，每棵树的权（即树中所有边上的权值之和）也可能不同。设R为G的所有⽣成树的集合，若T为R中边的权值之和最⼩的⽣成树，则T称为G的最⼩⽣成树（Minimum-Spanning-Tree，MST）
Kruskal 算法 求最小生成树
ACM,再见！
04-10 1366
Kruskal算法基于贪心的思想，对于图G={V,E}先gouzha
Kruskal 算法求最小生成树
花开无言
06-18 382
#include #include /* for INT_MAX */ #include #include using namespace std; #include /** 并查集. */ typedef struct ufs_t { int *p; /** 树的双亲表示法*/ int size; /** 大小. */ } ufs_t; /** * @brief 创建
prim和kruskal算法最小生成树
05-22
Prim算法和Kruskal算法都是用来求解带权无向图的最小生成树的算法。 Prim算法的思想是从一个顶点开始，每次找到一条与当前集合中的点相连的最小权值边所连接的顶点，将其加入到集合中。不断重复此过程，直到所有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值