kuangbin 并查集

最新推荐文章于 2024-05-19 20:16:34 发布
最新推荐文章于 2024-05-19 20:16:34 发布
阅读量66 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/smallhester/p/10316036.html
版权

 

A ： Wireless Network  POJ - 2236 

题意：并查集，可以有查询和修复操作

题解：并查集

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
#define N 1110
int d;
bool use[N];
 
struct node
{
    int pre;
    int x, y;
}p[N];
 
int find(int x)
{
    return x == p[x].pre ? x : find(p[x].pre);
}
 
void join(const node p1, const node p2)
{
    int root1, root2;
    root1 = find(p1.pre);
    root2 = find(p2.pre);
    if(root1 != root2)
        if((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y) <= d * d)
            p[root2].pre = root1;
}
 
int main()
{
    //freopen("Input.txt", "r", stdin);
    int num;
    char ope;
    int ok;
    int from, to;
    scanf("%d%d", &num, &d);
    for(int i = 1; i <= num; ++i)
        p[i].pre = i;
    memset(use, false, sizeof(use));
    for(int i = 1; i <= num; ++i)
        scanf("%d%d", &p[i].x, &p[i].y);
    while(scanf("\n%c", &ope) != EOF)
    {
        if(ope == 'O')
        {
            scanf("%d", &ok);
            use[ok] = true;
            for(int i = 1; i <= num; ++i)
                if(use[i] && i != ok)
                    join(p[i], p[ok]);
        }
        else
        {
            scanf("%d%d", &from, &to);
            if(find(from) == find(to))
                printf("SUCCESS\n");
            else
                printf("FAIL\n");
        }
    }
    return 0;
}
View Code

 

 

 

B：The Suspects POJ - 1611 

题意：0节点为携带病毒人，有一些团队，一个人可以在多个团队，一个团队一个有病毒，其余都感染，问一共几人感染病毒

题解：寻找0号根结点对应的sum值

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn =  1e5+5;
const int  mod = 1e9+7;

int father[maxn],sum[maxn];
void init(int n)
{
    for(int i=0;i<n;i++)
    {
        father[i] = i;
        sum[i] = 1;
    }
}
int find(int x)
{
    if(father[x] == x)
        return x;
    else
        return father[x] = find(father[x]);
}
void combine(int x,int y)
{
    int xx = find(x);
    int yy = find(y);
    if(xx != yy) {
        father[xx] = yy;
        sum[yy] += sum[xx];
    }
}
int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        init(n);
        if(n == 0 && m == 0)
            break;
        for(int i=0;i<m;i++)
        {
            int x;
            scanf("%d",&x);
            int one,two;
            scanf("%d",&one);
            for(int j=1;j<x;j++)
            {
                scanf("%d",&two);
                combine(one,two);
            }
        }
        printf("%d\n",sum[find(0)]);
    }
}
View Code

 

 

 

C：How Many Tables  hdu-1213

题意：认识的人可以坐在一张桌子，也可以间接认识，问需要几张桌子

思路：并查集之后找有几个集

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<map>
#include<cstdlib>
#include <vector>
#include<queue>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e3+5;

int father[maxn];
void init(int n)
{
    for(int i=1;i<=n;i++)
        father[i] = i;
}
int find(int x)
{
    if(father[x] == x)
        return x;
    else
        return father[x] = find(father[x]);
}
void combine(int x,int y)
{
    x = find(x);
    y = find(y);
    if(x != y)
        father[x] = y;
}
int main()
{
   int t;
   scanf("%d",&t);
   while(t--)
   {
       int n,m;
       scanf("%d %d", &n,&m);
       init(n);
       for(int i=0;i<m;i++)
       {
           int a,b;
           scanf("%d%d",&a,&b);
           combine(a,b);
       }
       int res = 0;
       for(int i=1;i<=n;i++)
           if(i == find(i))
               res++;
       printf("%d\n",res);
   }
}
View Code

 

D：How Many Answers Are Wrong  hdu-3038

题意：现在有n个数（你并不知道这n个数是什么），m次查询，每次查询给出u，v，w。表示从第u个数到第v个数的和为w。
　　　问，在这些查询中，有多少个是错误的（即有冲突）。

思路：带权并查集

从第u个数到第v个数的和其实可以理解为，第u-1个数到v个数之间的和。那么，就可以把和当成一种关系，利用带权并查集来维护这种关系。u-1节点为根，v的权值为第u-1个数到v个数之间的和。这里需要理解一下的是，在Find函数和unite（合并）函数里面，有两个关系域的转移方程（暂且这么叫他吧）
①p[x].relation+=p[tmp].relation
②p[root2].relation=p[x].relation+relation-p[y].relation

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<map>
#include<cstdlib>
#include <vector>
#include<queue>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 2e5+5;
struct node
{
    int father;
    int w;
};
node p[maxn];
int n,m,ans;
void init()
{
    ans = 0;
    for(int i=1;i<=n;i++)
    {
        p[i].father = i;
        p[i].w = 0;
    }
}

int find(int x)
{
    if(x == p[x].father)
        return x;
   int tmp = p[x].father;
   p[x].father = find(tmp);
   p[x].w += p[tmp].w;
   return p[x].father;
}

void combine(int x,int y,int w)
{
    int x1 = find(x);
    int y1 = find(y);
    if(x1 != y1)
    {
        p[y1].father = x1;
        p[y1].w = p[x].w + w -p[y].w;
    }
    else
    {
        if(p[y].w - p[x].w != w)
            ans ++;
    }
}

int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        int u,v,w;
        init();
        for(int i=0;i<m;i++)
        {
            scanf("%d %d %d",&u,&v,&w);
            u -= 1;
            combine(u,v,w);
        }
        printf("%d\n",ans);
    }
}
View Code

 

E - 食物链 POJ - 1182

题意：A吃B，B吃C，C吃A，给出一些话，问有几句假话

题解：可开3倍数组，也可以用结构体，关系域用向量加减操作

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<map>
#include<cstdlib>
#include<vector>
#include<string>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
const double PI = acos(-1.0);
const int maxn =  5e4+10;
const int mod = 1e9+7;

struct node
{
    int pre;
    int relation;  //0:与根节点同类 1:被根节点吃 2:吃根节点
}p[maxn];

int find(int x)
{
    int temp;
    if(x == p[x].pre)
        return x;
    temp = p[x].pre;
    p[x].pre = find(temp);
    p[x].relation = (p[x].relation + p[temp].relation) % 3;
    return p[x].pre;
}
int main()
{
    int n,k;
    int ope,a,b;
    int root1,root2;
    int sum = 0;
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++)
    {
        p[i].pre = i;
        p[i].relation = 0;
    }
    while(k--)
    {
        scanf("%d%d%d",&ope,&a,&b);
        if(max(a,b) > n)
        {
            sum++;
            continue;
        }
        if(ope == 2 && a == b)
        {
            sum++;
            continue;
        }
        root1 = find(a);
        root2 = find(b);
        if(root1 != root2)
        {
            p[root2].pre = root1;
            p[root2].relation = (3+(ope - 1) + p[a].relation - p[b].relation) % 3;
        }
        else
        {
            if(ope == 1 &&p[a].relation != p[b].relation)
            {
                sum++;
                continue;
            }
            if(ope == 2 &&((3 - p[a].relation + p[b].relation) % 3 != ope -1))
            {
                sum++;
                continue;
            }
        }
    }
    printf("%d\n",sum);
}
View Code

 

F - True Liars POJ - 1417 

题目大意：给你p1个好人和p2个坏人，编号为1-p1+p2，然后给你n中操作

                  x1 x2 no：x1说x2不是好人

                  x1 x2 yes：x1说x2是好人

                  在这里好人说的总是对的，坏人说的总是坏的，然后问你最后能不能唯一确定哪些是好人，并输出不能就输出no

题目思路：开始看到这题很好想到的就是用并查集，如果是yes的话说明他们同类，no的话说明不是同类，但这样只能分出几个大集合来，每个集合又分成两个小集合表示两种类型的个数，而我们要求的是在所有大集合中选出一个小集合然后加起来看能不能组 合成p1，并且要唯一，这里我们可以想到用背包来做，dp[i][j]表示前i个大集合好人为j个的方案数，第i种状态只能是有第i-1种状态而来，我们用w0[i],w1[i]表示第i个集合两个小集合的个数 ，所以dp[i][j]可以由dp[i-1][j-w0[]i]和dp[i-1][j-w1[i]]得来，这样我们只需判断dp[cnt][p1]是否等于1，这题还有麻烦的就是输出好人的编号，这里我们可以利用边的权值，w0存的全是权值为0的w1存的全是权值为1的，然后最后只需判断下第i个集合是由w0还是w1组合而来，这里可以利用dp[i-1][p1-w0[i]]的值来判断，如果等于1则表示是由w0组合否则就是w1，这个不难理，dp[i-1][p1-w0[i]]==1可以得到dp[i][p1]==1,应为这里已经表示答案唯一，所以只有一种情况！

 

此题题意题解转载自：   https://blog.csdn.net/qq_34731703/article/details/54603652

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn =  1e3+5;
const ll mod = 1e9+7;

int pre[maxn],rk[maxn],p[maxn],vis[maxn];
int w0[maxn],w1[maxn],dp[maxn][maxn];
int n,p1,p2;
void init()
{
    for(int i=1;i<=p1+p2;i++)
    {
        pre[i] = i;
        rk[i] = 0;
        vis[i] = 0;
        w0[i] = w1[i] = 0;
    }
    memset(dp,0,sizeof dp);
}
int find(int x)
{
    if(x != pre[x])
    {
        int temp = pre[x];
        pre[x] = find(pre[x]);
        rk[x] = rk[x] ^ rk[temp];
    }
    return pre[x];
}
void combine(int x,int y,int k)
{
    int xx = find(x);
    int yy = find(y);
    if(xx != yy)
    {
        pre[xx] = yy;
        rk[xx] = rk[x] ^ rk[y] ^ k;
    }
}
int main()
{
    while(scanf("%d %d %d",&n,&p1,&p2) && (n + p1 + p2))
    {
        init();
        for(int i=0;i<n;i++)
        {
            int a,b;
            char str[10];
            scanf("%d %d %s",&a,&b,str);
            if(str[0] == 'y')
                combine(a,b,0);
            else
                combine(a,b,1);
        }
        int cnt = 1;
        for(int i=1;i<=p1+p2;i++)
        {
            if(!vis[i])
            {
                int fa = find(i);
                for(int j=i;j<=p1+p2;j++)
                {
                    if(find(j) == fa && !vis[j])
                    {
                        vis[j] = 1;
                        if(rk[j] == 0)
                            w0[cnt]++;
                        else
                            w1[cnt]++;
                    }
                }
                p[cnt] = fa;
                cnt++;
            }
        }
        dp[0][0] = 1;
        for(int i=1;i<cnt;i++)
        {
            int minn = min(w0[i],w1[i]);
            for(int j=p1;j>=minn;j--)
            {
                if(dp[i-1][j-w0[i]])
                    dp[i][j] += dp[i-1][j-w0[i]];
                if(dp[i-1][j-w1[i]])
                    dp[i][j] += dp[i-1][j-w1[i]];
            }
        }

        if(dp[cnt-1][p1] != 1)
        {
            puts("no");
            continue;
        }
        int ans[maxn];
        int num = 0;
        int good = p1;
        for(int i=cnt-1;i>=1;i--)
        {
            if(dp[i-1][good-w0[i]] == 1)
            {
                for(int j=1;j<=p1+p2;j++)
                    if(find(j) == p[i] && rk[j] == 0)
                        ans[num++]=j;
                good -= w0[i];
            }
            else
            {
                for(int j=1;j<=p1+p2;j++)
                    if(find(j) == p[i] && rk[j] == 1)
                        ans[num++] = j;
                good -= w1[i];
            }
        }
        sort(ans,ans + num);
        for(int i=0;i<num;i++)
            printf("%d\n",ans[i]);
        puts("end");
    }
    return 0;
}
View Code

 

G - Supermarket POJ - 1456 

题意：超市里有n个产品要卖，每个产品都有一个截至时间d（从开始卖时算起），只有在这个截至时间之前才能卖出并且获得率润dy。

题解：先将产品按照价格从高到低排序，之后用并查集来寻找还有的时间

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn =  1e4+5;
const ll mod = 1e9+7;
struct node
{
    int p,d;
}a[maxn];
int pre[maxn];
bool cmp(node a,node b)
{
    return a.p > b.p;
}
int find(int x)
{
    if(pre[x] == -1)
        return x;
    else
        return pre[x] = find(pre[x]);
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        memset(pre,-1,sizeof pre);
        for (int i = 0; i < n; i++)
            scanf("%d %d",&a[i].p,&a[i].d);
        sort(a,a+n,cmp);
        int ans = 0;
        for(int i=0;i<n;i++)
        {
            int t = find(a[i].d);
           // cout<<t<<endl;
            if(t)
            {
                ans += a[i].p;
                pre[t] = t-1;
                //cout<<"pre[t]"<<t-1<<endl;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}
View Code

 

 M - 小希的迷宫 HDU - 1272 

题意：给一张地图，要求任意的两个房间之间只有一条路，是的输出Yes，不是的输出No

思路：使用并查集，当发现两个房间的根节点不一样的话就将两个房间连接起来，如果两个房间的根节点是一样的话，说明成环了，就不是。同时，也有可能不是联通的，需要验证，就是只有一个根节点在所有的点中，还有一个特判，直接输入0 0 的话输出的是Yes

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<sstream>
#include<cmath>
#include<stack>
#include<cstdlib>
#include <vector>
#include <set>
#include<queue>
#include<map>
using namespace std;

#define ll long long
#define llu unsigned long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
const int maxn =  1e5+5;
const ll mod = 1e9+7;
const double eps = 1e-8;

int pre[maxn];
int vis[maxn];

void init()
{
    for(int i=1;i<maxn;i++)
        pre[i] = i;
    memset(vis,0,sizeof vis);
}
int find(int x)
{
    if(x == pre[x])
        return x;
    else
        return pre[x] = find(pre[x]);
}

void combine(int x,int y)
{
    int fx = find(x);
    int fy = find(y);
    if(fx != fy)
        pre[fy] = fx;
}
bool same(int x,int y)
{
    int fx = find(x);
    int fy = find(y);
    return fx == fy;
}
int main()
{
    int a,b;
    while(scanf("%d%d",&a,&b))
    {
        init();
        vis[a] = vis[b] = 1;
        if(a == -1 && b == -1)
            break;
        if(a==0 && b==0)
        {
            puts("Yes");
            continue;
        }
        combine(a,b);
        int x,y;
        int flag = 0;
        while(scanf("%d%d",&x,&y))
        {
            if(x==0 && y==0)
            {
                int ans = 0;
                for(int i=1;i<maxn;i++)
                    if(vis[i] && pre[i]==i) {
                        ans++;
                        //cout<<i<<endl;
                    }
                if(flag == 0 && ans == 1)
                    puts("Yes");
                else
                    puts("No");
                break;
            }
            vis[x] = vis[y] = 1;
            if(!same(x,y))
                combine(x,y);
            else
                flag = 1;
        }
    }
}
View Code

 

转载于:https://www.cnblogs.com/smallhester/p/10316036.html

weixin_30687811
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
kuangbin 模板
09-08
kuangbin 模板
kuangbin并查集题解分析
wjmwsgj的博客
01-16 492
先分析一下这套题吧，其中A,B,C,G,L,M,N，(ps，刚刚看到szt大佬说了做题顺序，那么就按照他说的来就好了)是简单题都是并查集的简单应用，大家可以先写这几道题，其中L，G都挺有意思的 ，大家，大家要多想一下，接下来在我看来都是难题了，剩下的题还牵扯到带权的并查集的应用，这个东西需要用到向量的思想，szt大佬会给大家讲，他这个很强，剩下的题目的做题顺序我推荐的是：D,J,H,E,K,F。简
kuangbin专题五并查集总结
qq_34921856的博客
01-26 368
之前只知道简单并查集，做了才学会了带权并查集。感觉很开心。。 D - How Many Answers Are Wrong 带权并查集的模板题，不过这题也有需要注意的地方。 1，sum[A]的意义是从A到rootA(rootA 2，由上一点也可以得出，如果想求从A到B的sum，那么需要把A–。 代码如下: #include #include #include using namesp
kuangbin并查集分析
Haipai1998的博客
11-14 415
1.Wireless Network 题意：输入N(电脑数量),d（电脑修复后可联系的范围）； 输入N台电脑的坐标，输入0&id代表修复编号为id的电脑，输入S X Y代表询问X,Y是否能 直接联系/间接联系 思路：对于可联系的所有ID，均放到一个集合，想到并查集的作用，把具有相同性质（一定关联性）的东西放在一棵树上，并可以进行查询。 2.The Suspects 题意：输入n（学
kuangbin 专题五: 并查集
weixin_45867800的博客
04-20 330
1. Wireless Network /* 这道算是并查集的模板题了，主要需要弄清楚的是连接的条件。在这连接的条件是连个点之间的距离要小于等于d（即题目给定的距离），与此同时还要判断你要连接的电脑是否已经被修理过了，因为只有被修好的电脑才能充当中转站。 最终本题的思路就是，先接受输入的点的坐标，然后接受若干个操作，当操作为O时，枚举所有点与当前点之间的关系（包括距离和是否被修复）符合条件就把两点连接。如果是S操作，那就判断两点是否连接，连接就输出SUCCESS否则输出FAIL。 */ #include&l
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . ....
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
kuangbin的ACM模板动态规划计算几何：线与线求交，线与面求交，求凸包，半平面求交等若干图论问题：最小生成树 最短路 强连通分量、桥和割点 等
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
09-19
kuangbin巨巨 ACM模板~ 有需要的朋友可以下载了~
Day31 代码随想录打卡|二叉树篇---二叉树的递归遍历
最新发布
m0_48909584的博客
05-19 432
因此我们递归函数的参数和返回值肯定是节点和返回结果的数组，终止条件是当遍历的节点为空，即遍历完时，单层遍历根据不同的遍历方式不同而确定。二叉树的前序遍历是中左右的顺序；中序遍历是左中右的顺序；后序遍历是左右中的顺序。利用递归写出二叉树的遍历时，我们一定要明确几个点，一是。利用递归的方式写出二叉树的前、中、后序遍历。
（二刷）代码随想录第8天|344.反转字符串● 541. 反转字符串II
lilith_2001的博客
05-16 486
给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组。如果剩余字符少于 k 个，则将剩余字符全部反转。输入: s = "abcdefg", k = 2。、使用 O(1) 的额外空间解决这一问题。不要给另外的数组分配额外的空间，你必须。输出: "bacdfeg"
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环）
<font color="Pink">Tisfy的博客</font>
05-18 856
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环） 给你两个下标从 0 开始的整数数组 nums 和 divisors 。 divisors[i] 的 可整除性得分 等于满足 nums[j] 能被 divisors[i] 整除的下标 j 的数量。 返回 可整除性得分 最大的整数 divisors[i] 。如果有多个整数具有最大得分，则返回数值最小的一个。
leetcode 1319.连通网络的操作次数
m0_73917165的博客
05-13 244
第三个问题，我们需要着重注意一下细节，首先，我们需要知道一个连通块最少需要多少条线，其实就是上面的知识点，n个顶点的话n-1个就够了，就能至少形成一个连通块。这样的话，我们其实就是重新统计了一遍每个连通块所用的条数，然后相加到sum中，判断总条数-sum，就是我们能够最大限度用的线了。如果说，我们剩下的线足够我们连通这几个连通块，那么就取能够连通这几个连通块的最小条数，而不取剩下的条数；也就是说，这个例子里面，有两个连通块。最后，我们需要判断连通这些点的最小线数，然后判断一下题目中给我们的线够不够用。
算法设计与分析——（各种解决问题的方法）之分治算法、动态规划算法
2302_76516899的博客
05-14 1046
算法设计与分析——（各种解决问题的方法）之分治算法、动态规划算法
算法程序设计之 回溯法
牛牛博士博客
05-18 820
算法程序设计之 回溯法
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 248
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
LeetCode 235. 二叉搜索树的最近公共祖先
2301_80211119的博客
05-16 686
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
【二叉树算法题记录】从中序与后序遍历序列构造二叉树，从前序与中序遍历序列构造二叉树
weixin_43627638的博客
05-15 379
这样我们就能确定整棵树的根节点在。
并查集板子llkkyyy
08-19
- *1* *2* [「kuangbin带你飞」专题五并查集专题题解](https://blog.csdn.net/weixin_51216553/article/details/121643742)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值