并查集部分题目

最新推荐文章于 2023-01-14 15:00:24 发布
最新推荐文章于 2023-01-14 15:00:24 发布
阅读量521 收藏
点赞数
分类专栏： 并查集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingkongyidian/article/details/52103901
版权


1 hdu 1232 题目网址

题意：实现任意两个城镇有道路相通，已经修建部分道路，问至少还需修建多少条道路。

思路：连通分量的个数-1

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
const int maxn = 1000 ;
int fa[maxn] , t[maxn] ;

int Find(int x)
{
    while(x != fa[x])
    {
        fa[x] = fa[fa[x]] ;
        x = fa[x] ;
    }
    return x ;
}

void Union(int x , int y)
{
   int fx = Find(x) ;
   int fy = Find(y) ;
   if(fx != fy)
     fa[fy] = fx ;
}

int main()
{
    int N , M , a, b;
    while(scanf("%d" , &N)!= EOF &&N)
    {
        scanf("%d" , &M) ;
        for(int i = 1 ; i <= N ; i ++)
            fa[i] = i ;
        for(int i =0 ; i < M ; i++)
        {
            scanf("%d%d" , &a ,&b) ;
            Union(a ,b) ;
        }
       memset(t , 0 , sizeof(t) ) ;
       for(int i = 1 ; i <= N ; i++)
            t[Find(i)] = 1 ;
       int ans = 0 ;
       for(int i = 1 ; i <= N ; i++)
            if(t[i]) ans++ ;
       printf("%d\n" , ans - 1) ;
    }
    return 0;
}

hdu 1213 题目网址


题意： 有n个人， 每一桌上的人都相互认识（认识关系可传递），至少需要多少桌可使所有人都坐下

思路：求连通分量数

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
const int maxn = 1000 ;
int fa[maxn] , t[maxn] ;

int Find(int x)
{
    while(x != fa[x])
    {
        fa[x] = fa[fa[x]] ;
        x = fa[x] ;
    }
    return x ;
}

void Union(int x , int y)
{
   int fx = Find(x) ;
   int fy = Find(y) ;
   if(fx != fy)
     fa[fy] = fx ;
}

int main()
{
    int T , N , M , a , b;
    scanf("%d" , &T) ;
    for(int i = 1 ; i <= T ; i++)
    {
        scanf("%d%d" , &N, &M) ;
        for(int i = 1 ; i <= N ; i++)
            fa[i] = i ;
        while(M --)
        {
            scanf("%d%d" , &a, &b) ;
            Union(a, b) ;
        }
        memset(t , 0 , sizeof(t)) ;
        for(int i = 1 ; i <= N ; i++)
            t[Find(i)] = 1 ;
        int ans = 0 ;
        for(int i = 1 ; i <= N ; i++)
            if(t[i]) ans ++ ;
        printf("%d\n" ,ans) ;
    }
    return 0 ;
}

hdu 1598 题目链接

题意：XX星有许多城市，城市之间通过一种奇怪的高速公路SARS(Super Air Roam Structure---超级空中漫游结构）进行交流，每条SARS都对行驶在上面的Flycar限制了固定的Speed，同时XX星人对 Flycar的“舒适度”有特殊要求，即乘坐过程中最高速度与最低速度的差越小乘坐越舒服 ,(理解为SARS的限速要求，flycar必须瞬间提速/降速，痛苦呀 ),
但XX星人对时间却没那么多要求。要你找出一条城市间的最舒适的路径。(SARS是双向的）。

思路：贪心+并查集，对所有道路按照速度进行排序，不断添加道路，当a , b连通时，取道路速度差的最小值。

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
#define Min(a,b) ( (a) < (b) ? (a) : (b) )
const int maxn = 1005 , inf = 1e9;
int fa[205] , n , MIN;

struct Edge
{
    int s , t ;
    int speed ;
};

bool cmp(Edge a , Edge b)
{
    return a.speed < b.speed ;
}

Edge e[maxn] ;

void init(int n)
{
    for(int i =1 ; i <= n ; i ++)
       fa[i] = i ;
}

int Find(int a)
{
   while(a != fa[a])
   {
       fa[a] = fa[fa[a]] ;
       a = fa[a] ;
   }
   return a ;
}

void Union(int x ,int y)
{
    int fx = Find(x) ;
    int fy = Find(y) ;
    if(fx != fy)
        fa[fy] = fx  ;
}

int main()
{
   int m , a ,b ,q ;
   while(scanf("%d%d" , &n ,&m) != EOF)
   {
       for(int i = 0 ; i < m ; i++)
          scanf("%d%d%d" , &e[i].s , &e[i].t , &e[i].speed) ;
       sort(e , e + m , cmp) ;
       scanf("%d" , &q) ;
       while(q--)
       {

           scanf("%d%d" , &a, &b) ;
           MIN = inf ;
           for(int i = 0; i < m ; i ++)
           {
               init(n) ;
               for(int j = i ; j < m ; j ++)
              {
                 Union(e[j].s , e[j].t) ;
                 if(Find(a) == Find(b))
                {
                   MIN = Min(MIN , e[j].speed - e[i].speed) ;
                   break ;
                }
             }
           }
           if(MIN == inf)
             printf("-1\n" ) ;
           else
             printf("%d\n" , MIN) ;
       }
   }
    return 0;
}

hdu1856 题目链接

题意：求最大的连通分量的大小

#include<stdio.h>
#define N 10000000
int pre[N],num[N];
int find(int x){
	int r=x,k=x,j;
	while(pre[r]!=r)
		r=pre[r];           
    while(k!=r){ 
		j=pre[k];             
		pre[k]=r;           
        k=j;                  
    }    
	return r;
}
int join(int x,int y){
	int fx,fy;
	fx=find(x);
	fy=find(y);
	if(fx!=fy){
		pre[fx]=fy;
		num[fy]+=num[fx];
	}
	return 0;
}
int main(){
	int n,x,y,i,j;
	while(scanf("%d",&n)!=EOF){
		for(i=1;i<=N;i++){
			pre[i]=i;
			num[i]=1;
		}
		while(n--){
			scanf("%d%d",&x,&y); 
			join(x,y);
		}
		int max=1;
		for(j=1;j<=N;j++){
			if(num[j]>max)
				max=num[j];
		}
		printf("%d\n",max);
	}
	return 0;
}

hdu1272 题目链接

题意： 任意两个节若满足有且仅有一条道路相通，则输出“Yes”，否则输出“No”

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
const int maxn = 100005 ;
int edgenum = 0;
int f[maxn] , vis[maxn] ;

void Init()
{
    for(int i = 1 ; i <= 100000 ; i ++)
        f[i] = i ;
}

int Find(int x)
{
    while(x != f[x])
    {
        f[x] ==f[f[x]] ;
        x = f[x] ;
    }
    return x ;
}

void Union(int x , int y)
{
    int fx = Find(x) ;
    int fy = Find(y) ;
    if(fx != fy)
    {
        f[fy] = fx ;
        edgenum ++ ;
    }

}

int main()
{
    //freopen("a.txt" , "r" , stdin) ;
    int ok , x , y  , n = 0 , m = 1000000;
    while(scanf("%d%d" , &x , &y) != EOF )
    {
        memset(vis , 0 , sizeof(vis) ) ;
        edgenum = 0 ;
        n = 0 ;
       if( x == -1 && y == -1) break ;
       if (x == 0 && y == 0 )
       {
           printf("Yes\n") ; continue ;
       }
       Init() ;
       Union(x , y) ;
       vis[x] = 1 , vis[y] = 1 ;
       ok = 1 ;
       while(scanf("%d%d" , &x ,&y)!= EOF )
       {
           if(x == 0 && y == 0) break ;
           if(Find(x) == Find(y))
            { ok = 0 ;Union(x ,y ) ;}
           else Union(x ,y ) ;
           vis[x] = 1 , vis[y] = 1 ;
       }
       int vnum = 0 ;
       for(int i = 1 ; i <= 100000 ; i ++)
       {
           if(vis[i]) vnum ++ ;
       }
       if(vnum != edgenum + 1) ok = 0 ;
       if(ok )  printf("Yes\n") ;
       else  printf("No\n") ;
    }
    return 0;
}
hdu 5606 链接

题意：n个节点n - 1条边，每条边的权值为0或1，求所有节点i（1 <= i <= n）离节点i最近的节点的数目，并对它们异或操作后输出

思路：求所有连通分量的大小，并对他们进行异或操作

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
const int maxn = 100005;
int fa[maxn] , ans[maxn] ;

void Init()
{
    for(int i = 1 ; i <= 100000 ; i ++)
    {
        fa[i] = i ;
        ans[i] = 1 ;
    }
}

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

int Union(int x , int y)
{
   int fx = Find(x) ;
   int fy = Find(y) ;
   if(fx != fy)
   {
       fa[fy] = fx ;
       ans[fx] += ans[fy] ;
       //ans[fy] = ans[fx] ;
   }
   return 0 ;
}

int Xor( int a , int b)
{
     return (!a && b) || (a && !b) ;
}

int main()
{
    //freopen("a.txt" , "r" , stdin) ;
    int t , n , u , v , w ;
    scanf("%d" , &t) ;
    while(t --)
    {
        scanf("%d" , &n) ;
        Init() ;
        for(int i = 1 ; i <= n -1 ; i ++)
        {
            scanf("%d%d%d" , &u , &v , &w) ;
            if(w == 0) Union(u , v) ; //权值为0时，为一个连通分量
        }

        for(int i = 1 ; i <= n ; i ++) //更新所有的连通分量大小
        {
            int k = Find(i) ; 
            ans[i] = ans[k] ;
        }
        int Ans = ans[1];
        for(int i = 2 ; i <= n ; i ++)
        {
            Ans = Ans ^ ans[i] ;
        }
        printf("%d\n" , Ans) ;
    }
    return 0;
}

hdu1198 稍微复杂的连通分量表示 链接

题意：有11种不同形状的管道，一块田用这11种不同形状的管道覆盖，问这块田中有多少连通分量

思路：本题难点是如何表示连通分量，集合的合并操作怎么表示

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
const int maxn = 1000 ;

int type[11][4] =
{
   {1 , 0 , 1 , 0} ,
   {0 , 1 , 1 , 0} ,
   {1 , 0 , 0 , 1} ,
   {0 , 1 , 0 , 1} ,
   {0 , 0 , 1 , 1} ,
   {1 , 1 , 0 , 0} ,
   {1 , 1 , 1 , 0} ,
   {1 , 0 , 1 , 1} ,
   {1 , 1 , 0 , 1} ,
   {0 , 1 , 1 , 1} ,
   {1 , 1 , 1 , 1}
} ;

char Farm[maxn][maxn] ;
int fa[maxn*maxn + 10] ;
int cnt , m , n ;

void Init(int n)
{
    for(int i = 1 ; i <=n ; i ++)
        fa[i] = i ;
    cnt = n ;
}

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

void Union(int ax , int ay , int bx , int by , int dir)
{
    if(ax > m || bx > m ) return ;
    if(ay > n || by > n ) return ;
    int a = Farm[ax][ay] - 'A' ;
    int b = Farm[bx][by] - 'A' ;
    bool flag = false ;
    if(dir == 0)
    {
        if(type[a][1] && type[b][0]) flag = true ;
    }
    else
    {
        if(type[a][3] && type[b][2]) flag = true ;
    }
    if(flag )
    {
        int fx = Find( (ax - 1) * n + ay) ;
        int fy = Find( (bx - 1) * n + by) ;
        if(fx != fy)
        {
            fa[fx] = fy ;
            -- cnt ;
        }
    }
}

int main()
{
    //freopen("a.txt" , "r" , stdin) ;
    while(scanf("%d%d" , &m , &n) != EOF)
    {
        if(n <0 || m < 0) break ;
        Init(n * m) ;
        for(int i = 1 ; i <= m ; i ++)
            scanf("%s" , Farm[i] + 1) ;
        for(int i = 1 ; i <= m ; i ++)
        {
            for(int j = 1 ; j <= n ; j ++)
            {
                Union(i , j , i + 1 , j , 1) ;
                Union(i , j , i , j + 1 , 0) ;
            }
        }
        printf("%d\n" , cnt) ;
    }
    return 0 ;
}

hdu2473 链接

并查集的删除操作

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <set>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
using namespace std;
const int maxn = 1100006 ;
int fa[maxn] , id[maxn] ;
set<int> S ;

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

void Union(int x ,int y)
{
   int fx = Find(id[x]) ;
   int fy = Find(id[y]) ;
   if(fx != fy)
       fa[fx] = fy ;
}

int main()
{

    //freopen("a.txt", "r" , stdin) ;
    int n , m , kase = 0 , x , y , cnt  ;
    char s[10] ;
    while(scanf("%d%d" , &n , &m) != EOF)
    {  S.clear() ;
        if(n == 0 && m == 0) break ;
        cnt = n ;
        for(int i = 0 ; i < maxn ; i ++)
            fa[i] = i ;
        for(int i = 0 ; i < n ; i ++)
            id[i] = i ;
        for(int i = 1 ; i <= m ; i ++)
        {
            scanf("%s" , s) ;
            if(s[0] == 'M')
            {
                scanf("%d%d" , &x , &y ) ;
                Union(x , y) ;
            }
            if(s[0] == 'S')
            {
                scanf("%d" , &x) ;
                id[x] = cnt ++ ;
                //fa[id[x]]=id[x];
            }
        }
        for(int i = 0 ; i < n ; i ++)
        {
            S.insert(Find(id[i])) ;
            //printf("%d " , Find(id[i])) ;
        }
        //printf("\n") ;
        printf("Case #%d: %d\n" , ++kase , S.size()) ;

    }
    return 0;
}


xingkongyidian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode并查集相关经典题目(思路、分析、代码)
Ding 的博客
05-22 5576
leetcode并查集相关经典题目(思路、分析、代码) 关于并查集的一些基础知识以及应用，可以看我之前的一篇文章：一文搞定并查集 看完那篇文章基本可以完全掌握并查集 文章目录leetcode并查集相关经典题目(思路、分析、代码)[547. 朋友圈](https://leetcode-cn.com/problems/friend-circles/)[1319. 连通网络的操作次数](https://leetcode-cn.com/problems/number-of-operations-to-make-ne
SQL查询习题集
12-21
Access数据库中的SQL习题集通常会涵盖这些主题，并通过实际的案例和练习来加深理解。每个习题可能包含题目描述、预期结果、解答步骤以及提示，帮助学习者逐步提升SQL技能。通过解决这些习题，用户可以更好地掌握如何...
（qqqqc）自用模板
qqqqc16的博客
07-23 331
代码】jianglycodeforces模板。
并查集的合并和查找
ssigin的博客
04-06 323
主要操作 1.合并集合 合并两个集合 2.查找集合 查找两个元素是否在一个集合中 朴素查找 int finds(int x) { while(x != f[x]) x = f[x]; return x; } //举列 /* 4 != f[4] /f[4] = 2继续查找 2 != f[2] /f[2] = 1 1 = f[1] /此时退出循环中 */ //从中可以看出当 当这些点合并出一个长长的链条状时，如果你从最后一个元素开始查找，会从最后一个 //找
并查集
天行健，君子以自强不息
02-13 267
并查集的定义： int fa[N]; fa[i]=i表示i的父节点为i 并查集的操作 初始化： FOR(i,0,N) fa[i]=i; 查找： int findFather(int x) { while(x!=fa[x]){ x=fa[x]; } return x; }合并： void Union(int a,int b) { int
图-并查集
一个无聊的程序猿
01-25 1520
并查集 文章目录并查集1.定义2.意义3.root函数4.merge函数（union） 1.定义 什么是并查集？ 集：集合。 并：合并的意思，把集合合并在一起。 查：查询，查询某个集合。 并查集是一种树型的数据结构，判断一个森林中有几颗树，一个节点是否属于某棵树等。 森林？树？它们是什么。 试想一下，有nnn个图，它们彼此没有任何关系。每一个图就是一个单独的树，这nnn个树组成了一片树林。 2.意义 某天，AAA和BBB遇到了一起，他们同姓，于是他们猜想他们是否是亲戚？ 如果要验证他们的猜想，那就要去翻
c++并查集（详细总结）
YSJ367635984的博客
02-01 6111
老话重谈，先看定义 并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。常常在使用中以森林来表示。 首先得明白一些概念： 什么是树，什么是森林（由树组成的叫森林hh），什么是集合 这些问题是其他范畴的知识，就不过多累赘了，不了解的同学建议提前了解先。 下面我们切入重点 1、并查集 首先，我个人认为并查集在逻辑上是一个森林，该森林内由一棵或多棵数组成，如下举个例子 这三棵树可以组成一个森林，而这个森林可以叫并查集，每棵树可以称为并查集分量，这是逻辑上的理解
并查集（java）
iGxy0929的博客
01-14 1462
并查集是一种用于管理元素所属集合的数据结构，实现为一个森林，其中每棵树表示一个集合，树中的节点表示对应集合中的元素。
并查集——团伙(洛谷 P1892)
青春无问西东 岁月自成芳华
10-04 1518
最基础的并查集是给出关系直接合并，这道题呢稍微多了一些条件，就是敌人的敌人也是自己的朋友，所以在合并的时候多了几步操作。
超级简单并查集详解
Superb_day
08-05 9575
一、概述 并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。 其实说白了大部分还是用于寻找两个点是否联通，求最小生成树。 二、分析 1、背景阐明 首先我们需要先阐明一个简单的道理，假如从A城能到B城，从B城能到C城，那么自然A城和C城联通。并查集便是基于这个理论。...
简洁而优美的结构 - 并查集 | 一文吃透 “带权并查集” 不同应用场景 | “手撕” 蓝桥杯A组J题 - 推导部分和
Dream_Y.ocean的博客
12-14 3548
⭐以上就是朴素版的并查集的实现啦并查集是被很多人公认的最简洁而优雅的数据结构之一，建议同学们反复阅读掌从而握它呀~⭐以上就是带权并查集的全部内容了：若权值体现在集合上，一般开一个size数组来统计集合的大小若权值体现在边上，可表示当前节点到父节点的距离等意思而具体需要使用哪种并查集，维护哪些信息，就需要视具体题意来决定但是，如果遇到需要同时维护size和dist的情况，我们该怎么办呢？👉而以下所提及的方法就可以很好解决上述问题啦~综上，我们基本了解了算法基础中的“并查集&带权并查集”🍭。
src.rar_ Binary search java_KMP_PKU_java pku_并查集算法
09-23
标题中的“src.rar_ Binary search java_KMP_PKU_java pku_并查集算法”揭示了这个压缩包的内容，它包含了一些与计算机科学和编程相关的Java实现，特别是针对PKU（北京大学）的数据结构和算法题目。这个压缩包的核心...
ACM 程序设计：并查集-p1.pdf
06-17
并查集是一种在图论和数据结构中用于处理不相交集合合并的算法，它能够高效地解决诸如“两个人是否是亲戚”这类问题。在ACM（国际大学生程序设计竞赛）中，这样的算法是非常重要的，因为它能有效地处理大规模的数据...
浙大计算机机试ACM算法精华 并查集搜索等均涵盖
04-26
1. **并查集（Disjoint Set）**： 并查集是一种数据结构，用于处理不相交集合的操作，如合并和查找。它在解决“连接”和“查询”问题时特别有效，例如判断两个元素是否属于同一个集合。在ACM竞赛中，常用于处理树形...
阿里巴巴笔试题目合集
11-23
3. **数学逻辑**：部分题目可能需要应聘者具备一定的数学思维和逻辑推理能力，例如概率问题、组合优化、图论模型等。这些题目旨在测试你的逻辑思维和解决问题的能力。 4. **产品理解**：阿里巴巴作为电子商务和...
05创建公务卡扣减明细表_CASH_USE_MINUSAMT_DETAIL_20240708-刘君.sql
最新发布
07-19
05创建公务卡扣减明细表_CASH_USE_MINUSAMT_DETAIL_20240708-刘君.sql
【BP回归预测】龙格库塔算法优化BP神经网络RUN-BP光伏数据预测（多输入单输出）【含Matlab源码 5171期】.zip
07-19
CSDN海神之光上传的全部代码均可运行，亲测可用，直接换数据就行，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化BP神经网络分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化BP 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化BP 4.4.3 灰狼算法GWO/狼群算法WPA优化BP 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化BP 4.4.5 萤火虫算法FA/差分算法DE优化BP 4.4.6 其他优化算法优化BP
在UCA上结合DOA估计算法和自适应波束形成matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【信号分解】基于海鸥优化算法SOA-CEEMDAN实现信号去躁附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
并查集解决亲戚关系查询问题
ACM程序设计中的并查集（DisjointSets）是一种常用的数据结构，主要用于处理集合分割和合并的问题，尤其适用于表示具有亲戚关系的个体。在这个特定的问题场景中，我们需要设计一个算法来快速判断多个人之间的亲戚...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值