最小生成树模板

最新推荐文章于 2022-08-23 17:03:57 发布
最新推荐文章于 2022-08-23 17:03:57 发布
阅读量1k 收藏
点赞数
分类专栏： 最小生成树 文章标签： 最小生成树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoujiachengdhy/article/details/29910771
版权

1.prim算法

  基本思想：假设G＝(V，E)是连通的，TE是G上最小生成树中边的集合。算法从U＝{u0}（u0∈V）、TE＝{}开始。重复执行下列操作：

   在所有u∈U，v∈V－U的边(u，v)∈E中找一条权值最小的边(u0,v0)并入集合TE中，同时v0并入U，直到V＝U为止。

   此时，TE中必有n-1条边，T=(V，TE)为G的最小生成树。

   Prim算法的核心:始终保持TE中的边集构成一棵生成树。

注意：prim算法适合稠密图，其时间复杂度为O(n^2)，其时间复杂度与边得数目无关，而kruskal算法的时间复杂度为O(eloge)跟边的数目有关，适合稀疏图。

示例如下：

 

（1）图中有6个顶点v1-v6，每条边的边权值都在图上；在进行prim算法时，我先随意选择一个顶点作为起始点，当然我们一般选择v1作为起始点，好，现在我们设U集合为当前所找到最小生成树里面的顶点，TE集合为所找到的边，现在状态如下：

U={v1}； TE={}；

（2）现在查找一个顶点在U集合中，另一个顶点在V-U集合中的最小权值，如下图，在红线相交的线上找最小值。

通过图中我们可以看到边v1-v3的权值最小为1，那么将v3加入到U集合，（v1，v3）加入到TE，状态如下：

U={v1，v3}； TE={（v1，v3）}；

（3）继续寻找，现在状态为U={v1，v3}； TE={（v1，v3）}；在与红线相交的边上查找最小值。

我们可以找到最小的权值为（v3，v6）=4，那么我们将v6加入到U集合，并将最小边加入到TE集合，那么加入后状态如下：

U={v1，v3，v6}； TE={（v1，v3），（v3，v6）}； 如此循环一下直到找到所有顶点为止。


prim算法：

要求节点数量N不超过5000

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#define N 55
#define INF 1<<30
using namespace std;
int n,m,map[N][N];
void input()
{
    int i,j,x,y,p,len;
    cin>>m;
    for(i=1; i<=n; i++)
        for(j=1; j<=n; j++)
            map[i][j] = INF;
    for(i=1; i<=m; i++)
    {
        cin>> x >> y >> len;
        if( map[x][y] > len )
            map[x][y] = map[y][x] = len ;
    }
}
void prim()
{
    int vis[N],dis[N],i;
    for(i=1;i<=n;i++)
    {
        vis[i]=0;
        dis[i]=INF;
    }
    int k;
    int now=1;
    vis[now]=1;
    dis[now]=0;
    for(k=1;k<=n;k++)
    {
        for(i=1;i<=n;i++)
        {
            if(!vis[i]&&map[now][i]!=INF)
            {
                if(dis[i]>map[now][i])dis[i]=map[now][i];
            }
        }
        int min=INF;
        for(i=1;i<=n;i++)
        {
            if(!vis[i]&&dis[i]<min){
                now=i;
                min=dis[i];
            }

        }vis[now]=1;
    }
    int sum=0;
    for(i=1;i<=n;i++)
    {
        sum+=dis[i];
    }
    printf("%d\n",sum);
}
int main()
{
  //  freopen("test.in","r",stdin);
    while( cin>>n && n )
    {
        input();
        prim();
    }
    return 0;
}

应用题目          数据量        耗时       内存

ZOJ1372 

ZOJ1406



另一个算法下次写


ZOJ1406

和上题一样，初始化不要忘了，1y

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define N 30
#define INF 1<<30
int n,m;
int map[N][N];
void prim()
{
    int vis[N],dis[N],i;
    for(i=1;i<=n;i++)
    {
        vis[i]=0;
        dis[i]=INF;
    }
    int k;
    int now=1;
    vis[now]=1;
    dis[now]=0;
    for(k=1;k<=n;k++)
    {
        for(i=1;i<=n;i++)
        {
            if(!vis[i]&&map[now][i]!=INF)
            {
             //   printf("   %d %d %d\n",now,i,map[now][i]);
                if(dis[i]>map[now][i])dis[i]=map[now][i];
            }
        }
        int min=INF;
        for(i=1;i<=n;i++)
        {
            if(!vis[i]&&dis[i]<min){
                now=i;
                min=dis[i];
            }

        }vis[now]=1;
    }
    int sum=0;
    for(i=1;i<=n;i++)
    {
        sum+=dis[i];
      //  printf("%d %d\n",i,dis[i]);
    }
    printf("%d\n",sum);
}
int main()
{
    //freopen("test.in","r",stdin);
    char ch1[2],ch2[2];
    int d,p1,p2,i,j;
    while(cin>>n&&n)
    {
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)map[i][j]=INF;//这里的初始化不要忘记
        }
        for(i=1;i<=n-1;i++)
        {
            cin>>ch1;
            cin>>m;
            p1=ch1[0]-'A'+1;
            for(j=1;j<=m;j++)
            {
                cin>>ch2>>d;
                p2=ch2[0]-'A'+1;
                map[p1][p2]=d;
                map[p2][p1]=d;
           //     printf("%d %d\n",p1,p2);
            }

        }
        prim();
    }
    return 0;
}

POJ2485 最小生成树的最长边是所有生成树中最短的

纯套模板

关于最小生成树的最长边为所求的证明

因为题目要求没两个点间必须存在通路。
故满足条件的任意方案为一生成树（spanning tree)
1.先证最小生成树T的最长边（u，v）小于等于任一生成树T的最长边
反证：假设不满足上述命题，即：存在一个生成树T'，其最长边小于(u,v)
则有T'的任一边 <= T’最长边 < (u,v)，
因为T'是生成树，则其上u,v两点间必存在唯一通路P;
由于u,v位于(u,v)所通过的某割的两边，P上必有一边(x,y)通过割且(x,y)<(u,v)
在T上去掉(u,v)加上(x,y)形成T''可证T‘’仍然是生成树且所有边权值和小于T的权值和。与T是最小生成树矛盾。得证
2.再证存在一个可达的方案，其最长边等于(u,v)，即1中的下限是紧确的。
 显然，只要选取最小生成树为所选方案即可得

综上所述，最小生成树的最长边即为题目所述任一生成树的最长边的最小值

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#define N 550
#define INF 1<<30
using namespace std;
int n,m,map[N][N];
void input()
{
    int i,j,p,len;
    scanf("%d",&n);
    for(i=1; i<=n; i++)
        for(j=1; j<=n; j++)
            map[i][j] = INF;
    for(i=1; i<=n; i++)
    {
        for(j=1; j<=n; j++){
            scanf("%d",&len);
            if( len< map[i][j] )
                map[i][j] = map[j][i] = len ;
        }
    }
}
void prim()
{
    int vis[N],dis[N],i;
    for(i=1;i<=n;i++)
    {
        vis[i]=0;
        dis[i]=INF;
    }
    int k;
    int now=1;
    vis[now]=1;
    dis[now]=0;
    for(k=1;k<=n;k++)
    {
        for(i=1;i<=n;i++)
        {
            if(!vis[i]&&map[now][i]!=INF)
            {
                if(dis[i]>map[now][i])dis[i]=map[now][i];
            }
        }
        int min=INF;
        for(i=1;i<=n;i++)
        {
            if(!vis[i]&&dis[i]<min){
                now=i;
                min=dis[i];
            }

        }vis[now]=1;
    }
    int ma=0;
    for(i=1;i<=n;i++)
    {
        ma=ma>dis[i]?ma:dis[i];
    }
    printf("%d\n",ma);
}
int main()
{
  //  freopen("test.in","r",stdin);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        input();
        prim();
    }
    return 0;
}


Kruskal算法

算法简单描述

1).记Graph中有v个顶点，e个边

2).新建图Graphnew，Graphnew中拥有原图中相同的e个顶点，但没有边

3).将原图Graph中所有e个边按权值从小到大排序

4).循环：从权值最小的边开始遍历每条边 直至图Graph中所有的节点都在同一个连通分量中

                if 这条边连接的两个节点于图Graphnew中不在同一个连通分量中

                                         添加这条边到图Graphnew中

 

图例描述：

首先第一步，我们有一张图Graph，有若干点和边 

 

将所有的边的长度排序，用排序的结果作为我们选择边的依据。这里再次体现了贪心算法的思想。资源排序，对局部最优的资源进行选择，排序完成后，我们率先选择了边AD。这样我们的图就变成了右图

 

 

 

在剩下的变中寻找。我们找到了CE。这里边的权重也是5

依次类推我们找到了6,7,7，即DF，AB，BE。

下面继续选择， BC或者EF尽管现在长度为8的边是最小的未选择的边。但是现在他们已经连通了（对于BC可以通过CE,EB来连接，类似的EF可以通过EB,BA,AD,DF来接连）。所以不需要选择他们。类似的BD也已经连通了（这里上图的连通线用红色表示了）。

最后就剩下EG和FG了。当然我们选择了EG。最后成功的图就是右：

 

kruskal模板：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
#define N 50005
int n,m,pre[N];
map<string,int>id;
struct ss
{
    int x,y,len;
}node[N];
bool cmp(ss a,ss b)
{
    return a.len<b.len;
}
void input()
{
    int k=1;
    string s1,s2;
    char s11[10],s22[10];
    id.clear();
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++){
            scanf("%s%s%d",s11,s22,&node[i].len);
            s1=s11;
            s2=s22;
            if(!id[s1])id[s1]=k++;
            if(!id[s2])id[s2]=k++;
            node[i].x=id[s1];
            node[i].y=id[s2];
    }
    sort(node,node+m,cmp);
    //for(int i=0;i<m;i++)printf("%d %d %d\n",node[i].x,node[i].y,node[i].len);
}
int find(int x)
{
    if(x!=pre[x])pre[x]=find(pre[x]);
    return pre[x];
}
int kruskal(int t)
{
    int a,b,cnt=0,sum=0;;
    for(int i=1;i<=n;i++)pre[i]=i;
    for(int i=t;i<m;i++)
    {
        a=find(node[i].x);
        b=find(node[i].y);
        if(a!=b)
        {
            pre[b]=a;
            cnt++;
            sum+=node[i].len;
            if(cnt==n-1)
            {
                return sum;
            }
        }
    }
    return -1;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        input();
        printf("%d\n",kruskal(0));
    }

    return 0;
}
应用题目                      数据量                                                    耗时                      内存

模板            10w/mb                             O(mlogm)             O(n)

ZOJ3036稀疏图         50000个节点，2000条边                         120ms               1184k



POJ3522 差值最小生成树 枚举+kruskal

这道题的题意很明了。求最大边与最小边差值最小的生成树

首先，把所有的生成树都求出来是不可能的，所以，必须用别的方法。

在学习次小生成树的过程中，知道了一个最小生成树的性质， 一个图的最小生成树不一定是唯一的，但是组成这些最小生成树的各个边的权值一定都是一一对应相同的。不会出现这种一个树上有两个边权值a+b等于另外一颗树上两个边c+d，然后这两个树都是最小生成树的情况。  

对于本题来讲，上面那个性质就说明了一个图的最小生成树上的最小边的权值和最大边的权值是固定不变的。那么当使用克鲁斯卡尔算法时，第一次加入的必然是边权最小的边，由于克鲁斯卡尔算法的正确性已经得到验证过，那么此边的权值必然就是最小生成树的最小边权值了，当最小边的权值固定时，最小生成树的最大边的权值也“命中注定”是固定的，在最小边权值固定的情况下，其他的生成树的最大边必然也是大于等于最小生成树的最大边，否则就不满足我们上文提到的性质，这就是“当生成树的最小边确定时，最小生成树的最大边的权值是所有生成树中最小的”。从而，我们得到了一个本题的解法。  枚举最小边，然后求最小生成树，更新最优解。

//200K	94MS
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#define N 110
#define INF 0x7fffffff
using namespace std;
struct ss
{
    int x,y;
    int len;
} city[N*N/2];
int n,m,pre[N];
int cmp(ss a,ss b)
{
    return a.len<b.len;
}
void input()
{
    int i,x,y,len;
    for(i=0; i<m; i++)scanf("%d%d%d",&city[i].x,&city[i].y,&city[i].len);
    sort(city,city+m,cmp);
//	printf("---------------------\n");
//	for(i=0;i<m;i++)printf("%d %d %d\n",city[i].x,city[i].y,city[i].len);
}
int find( int x )
{
    if(x!=pre[x])pre[x]=find(pre[x]);
    return pre[x];
}
int kruskal(int t)
{
    int i,a,b,cnt=0;;
    for(i=1; i<=n; i++)pre[i] = i;
//	printf("---\n");
    for(i=t; i<m; i++)
    {
        a = find(city[i].x);
        b = find(city[i].y);
        if( a!= b)
        {
            pre[b]=a;
            cnt++;
            //     printf("** %d %d %d\n",city[i].x,city[i].y,city[i].len);
            if(cnt==n-1)
            {
                //       printf("%d\n",city[i].len-city[t].len);
                return city[i].len-city[t].len;
            }
        }

    }
    return -1;
}
int main()
{
    while(scanf("%d%d",&n,&m)&&(n+m))
    {
        input();
        int i;
        int ans=INF;
        for(i=0; i<m; i++)
        {
            int t=kruskal(i);
            if(t!=-1&&t<ans)ans=t;
        }
        if(ans!=INF)printf("%d\n",ans);
        else printf("-1\n");

    }
    return 0;
}

湖南师范大学第五届大学生计算机程序设计竞赛--G--修路11464--最小生成树的kruskal算法

题目链接：http://acm.hunnu.edu.cn/online/?action=problem&type=show&id=11464&courseid=132

修路
Time Limit: 2000ms, Special Time Limit:5000ms, Memory Limit:32768KB
 
Problem 11464 : No special judgement
Problem description
  在X国家，有n个城市，只有在城市才有加油站，现在国王决定修一些道路来使这n个城市链接起来，使得任意二个城市可以互相到达。由于经济危机，现在国王只有y元用来修路。由于只有在城市里才有加油站，所以当一条道路太长的时候，车辆由于油量不够，不同在这两个城市间互相到达。所以国王要求每条道路不能太长，即使得修的道路中最长的道路最短。现在问你最长的道路的长度。
Input
  包含多组数据，每组数据第一行为一个数n m 和y，表示n个城市和m条可以修的道路，y元的修路费2<=n<=10000 1<=m<=100000,1<=y<=100000。
接下来m行每行有四个整数u v c d 表示该道路链接城市u和v 修路的费用为c长度为d。
1<=u,v<=n   1<=d<=100000  1<=c<=10
Output
  对于每组数据，输出一个整数，表示修路中的最长的道路的长度，如果修的道路不能任意二个城市可以互相到达 则输出 -1。
Sample Input
3 2 10
1 2 2 1
1 3 2 5

3 3 10
1 2 5 2 
2 1 6 1 
1 3 5 1

3 2 100
1 2 1 1
1 2 2 2
Sample Output
5
2
-1

思路：题意为在满足费用y的情况下，将所有的城市连起来，并且使选择的所有道路中，最长的那一条最短，故可以枚举最长道路的长度，然后检验在这种长度内的道路能否符合国王的要求，找到一个最小值即为答案，其中枚举过程采用二分优化，检验过程用并查集，代码如下~。

代码如下：

参考:http://blog.csdn.net/angel_e/article/details/29576035

注意cmp中的cost的排序 用cost为权重做最小生成树

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#define N 10010
#define M 100010
using namespace std;
struct ss
{
    int x,y;
    int len;
    int c;
} city[M];
int n,m,y,pre[N];
int cmp(ss a,ss b)
{
    return a.c<b.c;
}
void input()
{
    int i,x,y,len;
    for(i=0; i<m; i++)scanf("%d%d%d%d",&city[i].x,&city[i].y,&city[i].c,&city[i].len);
    sort(city,city+m,cmp);
}
int find( int x )
{
    if(x!=pre[x])pre[x]=find(pre[x]);
    return pre[x];
}
int kruskal(int len)
{
    int i,a,b,cnt=0;
    int cost=0;
    for(i=1; i<=n; i++)pre[i] = i;
    for(i=0; i<m; i++)
    {
        if(city[i].len>len)continue;
        a = find(city[i].x);
        b = find(city[i].y);
        if( a!= b)
        {
            pre[b]=a;
            cnt++;
            cost+=city[i].c;
            if(cost>y)break;
            if(cnt==n-1)
            {
                return city[i].len;
            }
        }
    }
    return 0;
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&y))
    {
        input();
        int i;
        int ans=-1;
        int l=1,r=1,mid;
        for(i=0;i<m;i++)r=r>city[i].len?r:city[i].len;
        if(!kruskal(r)){
            printf("-1\n");
            continue;
        }
        while(l<r)
        {
            mid=(l+r)/2;
            if(kruskal(mid))r=mid;
            else l=mid+1;
        }
        printf("%d\n",l);
    }
    return 0;
}








Kylehz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
最 小生成树.zip
06-10
Kruskal（克鲁斯卡尔算法）算法介绍： 设G=（V，E）是无向带权连通图，V={1，2，…，n}；设最小生成树T=（V，TE），该树的初始状态为只有n个顶点而无边的非连通图T=（V，{}），Kruskal算法将这n个顶点看成是n个孤立...
【模板】最小生成树（C++）
m0_74036684的博客
01-09 649
最小生成树的模板题 说明了最小生成树的概念，以及prim算法的两种实现方式
图(四)：最小生成树
cjx2774952383的博客
08-23 148
图(四)：生成树
最小生成树——模板
fuhaitao9999的博客
08-11 161
题目 模版题很简单； 一共有n个城市（从1开始编号），有m条路线，求出一条能连通n个城市的最小路线； 分析 首先需要找到一条能连通所有城市的路线； 其次要保证这条路径的路程最短； 算法简介 常用两种算法： Kruskal 时间复杂度为eloge e为总共的边数。 1.先将各个边的权值从小到大排序； 2.按从小到大的顺序依次将边连接的点加入到一个集合中，并利用并查集确定一个祖先节点，使其中的...
最小生成树详解（模板 + 例题）
zgdlxs的博客
02-10 5782
1.什么是最小生成树 一个图中可能存在多条相连的边,我们一定可以从一个图中挑出一些边生成一棵树。这仅仅是生成一棵树,还未满足最小,当图中每条边都存在权重时,这时候我们从图中生成一棵树(n - 1 条边)时,生成这棵树的总代价就是每条边的权重相加之和。 一个有N个点的图，边一定是大于等于N-1条的。图的最小生成树，就是在这些边中选择N-1条出来，连接所有的N个点。这N-1条边的边权之和是所有方案中最小的。 2.最小生成树的应用 要在n个城市之间铺设光缆，主要目标是要使这 n 个城市的任意两个...
最小生成树的常用算法模板
m0_51551385的博客
05-15 223
1、所有最小生成树算法 最小生成树问题一般都使用无向图，基本不会遇到有向图的问题。 2、朴素版 Prim 算法 稠密图就用Prim算法。
最小生成树.zip
最新发布
04-25
算法是解决特定问题或执行特定任务的一系列步骤或规则的有序集合。在计算机科学中，算法通常用来指导计算机执行特定的任务或解决问题。良好设计的算法能够有效地解决问题，并且在给定的输入下能够产生正确的输出。...
图及其最小生成树的可视化生成
11-23
用pygame实现带权图及其最小生成树的可视化,其中生成最小生成树用的是prim算法，使用的语言是python3.7，当时写的时候还没有养成良好的编程习惯，所以全篇无注释，命名也不规范，逻辑也有些混乱，现在是2020年，我...
最小生成树.pdf
08-01
最小生成树.pdf
最小生成树.c
06-16
最小生成树.c
POJ1258 最小生成树基础模板题通俗详细版（prim解法）
uyret的博客
03-09 1712
既然是基础题，就顺带详细一些讲一下算法吧 题目意思：就是输入一个N,代表有N个点，然后给你一个N*N的数组，假定数组为map[N][N]数组中的每个数map[i][j]代表从i到j所需要的时间,问题是从0走到N最快需要用多长时间 咋一看这样的题目用搜索应该也是可以的，不过我没试，后续试一下可以的话就把搜索的步骤也放上来。 首先，来看一下Prim算法 prim算法简单来说就是一个动态的更新路径的方法，举个栗子： 假如我们有 A B C D 四个点，点和点之间有的相连有的不相连，现在...
最小生成树详解(模板 + 例题)
热门推荐
潘小蓝的博客
10-15 11万+
作为一个伪ACMer,先来首广为人知的打油诗: 模拟只会猜题意，贪心只能过样例，数学上来先打表，规律一般是DP，组合数学碰运气，计算几何瞎暴力，图论一顿套模板，数论只会GCD,递归递推伤不起，搜索茫然TLE，分治做得像枚举，暴力枚举数第一，数据结构干瞪眼，怒刷水题找信心。 文章目录1、什么是树2、最小生成树3、最小生成树的应用4、实现最小生成树的两种算法4.1 prim (普里姆算法)4.2 kruskal (克鲁斯卡尔算法)5、总结 1、什么是树 如果一个无向连通图不包含回路(连通图中不存在环),.
图表算法—最小生成树
01-31 445
1. 什么是最小生成树(Minimum Spanning Trees) 　　对于一个无向图，如果它的所有边都带有一定的数值（即带权），则会变成下面的样子 　　 　　假设这些点都是城市，每个城市之间的连线代表城市间的道路，线上的数字代表着道路的长短。当然，修越长的道路就需要越多的资源。 　　那么如果要用最少的资源把所有城市都联系起来（即任意城市A能沿着道路抵达任意城市B），我们应该...
最小生成树模板（prim+kruskal）
smilng的博客
08-01 1011
1.prim算法（稠密图适用–O(n^2)） #include<iostream> #include<cstring> #include<algorithm> using namespace std; #define inf 0x3f3f3f3f #define N 505 int n,m; int mp[N][N]; int dis[N],vis[N]; in...
最小生成树prime算法模板
weixin_30279671的博客
08-16 117
#include<stdio.h> #include<string.h> using namespace std; int map[505][505]; int v, e; int prime() { bool vis[505]; int dist[505]; int i,j,sum=0; for(i=1;i<=v;i++) { ...
最小生成树-Kruskal算法（模板）
algzjh的博客
08-25 4693
Kruskal基本算法：每次选取最短的边，看该边相连的两点是否在同一集合内，若在，则跳过，若不在，就把两个点合并，判断与合并都用并查集实现。 Kruskal的复杂度是O（ElogE），适合稀疏图。 /* Kruskal算法求MST */ #include #include #include #include #include using namespace std; con
【Kruskal最小生成树】算法模板+例题
It's the Climb
04-20 7653
Kruskal最小生成树生成树 已知连通图G ，图上有N个顶点。生成树是指图G的一个极小（边最少）连通子图，生成树上有n个顶点、n-1条边，且任意两点之间都是连通的。 最小生成树 已知带权连通图G，图中有n个顶点，每条边都有权值。我们要从图中抽出一棵生成树，使得树上所有边权之和最小，这棵生成树就叫做 最小生成树。 常见变形应用： 1.要求找最大边权是最小的的生成树（多读几遍）：直接找最小生成树即可...
cpl在最小生成树中
08-27
在最小生成树问题中，我们需要找到一棵连接所有顶点的树，且总权重最小。CPL算法通过以下步骤来求解最小生成树： 1. 创建一个空的生成树，用来存储最终的结果。 2. 定义约束函数，用来确定生成树中的边是否满足约束...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值