并查集

合集 - 刷题集(97)

1.妖梦拼木棒2023-05-23 2.[USACO1.2]回文平方数 Palindromic Squares2023-05-24 3.[COCI2012-2013#1] LJUBOMORA2023-05-25 4.火柴棒等式2023-05-25 5.Kieszonkowe2023-05-25 6.[COCI2014-2015#5] TRAKTOR2023-05-26 7.硬币翻转2023-05-26 8.[蓝桥杯 2020 省 AB1] 走方格2023-05-26 9.P2097 资料分发2023-05-26 10.[AHOI2005]约数研究2023-05-26 11.[NOIP2004 普及组] 火星人2023-05-26 12.我焯,原神(这真是个题)2023-05-26 13.滑雪 OJ36512023-05-24 14.CV的人有福啦!YTU贪心训练2(部分注释)2023-05-27 15.砝码称重2023-05-27 16.警钟长鸣-----找零钱2023-05-28 17.[USACO09OCT]Barn Echoes G2023-05-28 18.【CSGRound2】光骓者的荣耀2023-05-29 19.初见蓝桥杯2023-05-30 20.[蓝桥杯 2022 省 B] 扫雷2023-05-31 21.开餐馆2023-05-31 22.P9241 [蓝桥杯 2023 省 B] 飞机降落2023-06-01 23.P7083 [NWRRC2013] Energy Tycoon2023-06-03 24.高精度2023-06-04 25.P7954 [COCI2014-2015#6] PAPRIKA2023-06-04 26.(输出路径搜索)[USACO06OCT] Cows on Skates G2023-06-04 27.畜栏保留问题2023-06-04 28.(贪心+搜索+剪枝)P8801 [蓝桥杯 2022 国 B] 最大数字2023-06-05 29.蓝桥杯入门----普及-2023-06-06 30.[NOIP2016 提高组] 玩具谜题2023-06-06 31.[NOIP2002 提高组] 字串变换(无向图查重)2023-06-06 32.[NOIP2000 提高组] 单词接龙2023-06-07 33.POJ 硬币2023-06-07 34.动态规划学习 1(最长上升子序列问题)2023-06-07 35.动态规划学习 2(背包问题及其变形)2023-06-08 36. 切割回文2023-06-10 37.[NOIP2001 提高组] 数的划分(剪枝)2023-06-10 38.字符串转换数字,sscanf和sprintf大法2023-06-10 39.[CTSC1997] 选课(树状DP)2023-06-10 40. k 倍区间(同余定理,组合数)2023-06-11 41.[蓝桥杯 2018 省 AB] 全球变暖2023-06-11 42.马的遍历(对bfs的更深一层探讨)2023-06-11 43.找零钱2023-06-11 44.Pasha Maximizes2023-06-12 45.Newspaper Headline2023-06-12 46.Balanced Ternary String2023-06-13 47.(数论)素数,质数2023-06-13 48.(数论) 约数2023-06-13 49.Helping the Nature2023-06-14 50.(博弈论)Even Number Addicts2023-06-14 51.Present2023-06-15 52.Mr. Kitayuta's Colorful Graph(二维并查集,弱化版)2023-06-16 53.Edgy Trees(dfs,并查集,快速幂,树形结构,红黑树)2023-06-16

54.并查集2023-05-24

55.再谈前缀和,差分,离散化2023-06-16 56.Best Cow Fences(前缀和+特殊二分)2023-06-17 57.二分2023-06-17 58.同类型,类背包动态规划,选地dp2023-06-17 59.Primes on Interval(欧拉筛+二分+滑动窗口)2023-06-18 60.字符串(KMP , Trie树 , STL)2023-06-18 61.Codeforces1 #879 div.22023-06-19 62.Add Modulo 10(数论,思维,数学,规律)2023-06-20 63.期末考试YTU4035: Shmily(数学,等差数列)2023-06-20 64.[POI2006] OKR-Periods of Words2023-06-21 65.Getting Zero(Bfs)2023-06-21 66.快速幂2023-06-21 67.Dreaming of Freedom(数论,贪心)2023-06-23 68.Scoring Subsequences2023-06-24 69.Dolce Vita2023-06-29 70.Cake Assembly Line2023-06-29 71.Constructive Problem2023-06-30 72.Forever Winter2023-06-30 73.Maximum Sum(前缀和)2023-07-10 74.Contrast Value(数学规律)2023-07-10 75.Lamps(STL+双端队列)2023-07-10 76.Long Long2023-07-11 77.Sum in Binary Tree2023-07-11 78.Apple Tree(树状搜索,树形DP)2023-07-11 79.Strong Password(贪心思想)2023-07-12 80.Come Together2023-07-12 81.Notepad2023-07-13 82.Hamiltonian Wall2023-07-13 83.7.17作业2023-07-16 84.逛画展(双指针)2023-07-19 85.#8852023-07-20 86.树状数组2023-07-20 87.Subsequence Addition2023-07-22 88.7.22作业2023-07-22 89.Diverse Substrings2023-07-24 90.Tracking Segments(二分,区间前缀)2023-07-27 91.最大食物链计数2023-07-27 92.线段树12023-07-22 93.[TJOI2007] 线段(状态机)2023-07-29 94.#8782023-07-30 95.测试12023-07-30 96.李白打酒2023-07-30 97.砍竹子2023-07-30

6-1 并查集
///find函数可能有点难理解,自己尝试画下图随便理解好吧
///M是合并,Q是询问是否在一个树中
#include<bits/stdc++.h>
using namespace std;
const int N=10010;
int n,m;
int q[N];
int find(int x)
{
    if(q[x]!=x) q[x]=find(q[x]));///如果x不是树的头结点,向上循环查找到头结点为止.
    ///可以自己画图理解一下;
    return q[x];
}
int  main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        q[i]=i;
    while(m--)
    {
        char op[2];
        int a,b;
        scanf("%s%d%d",&op,&a,&b);
        if(op[0]=='M') q[find(a)]=find(b);
        else
        {
            if(find(a)==find(b))
                cout<<"YES"<<endl;
            else
                cout<<"NO"<<endl;
        }
    }
    return 0;
}
6-2 查并集,但是可能输出长度
#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int n,m;
int p[N],size[N];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        p[i]=i;
        size[i]=1;
    }
    while(m--)
    {
        ///C为合并,Q1为 检查是否在同一区间,Q2检查长度;
        char op[2];
        scanf("%s",&op);
        int a,b;
        if(op[0]=='C')
        {
            cin>>a>>b;
            if(find(a)==find(b)) continue;///特判
            size[find(b)]+=size[find(a)];
            p[find(a)]=find(b);
        }
        else if(op[1]=='1')
        {
            cin>>a>>b;
            if(find(a)==find(b))
                cout<<"YES"<<endl;
            else
                cout<<"No"<<endl;
        }
        else if(op[1]=='2')
        {
            cin>>a;
            cout<<size[find(a)]<<endl;
        }
    }
}
6-3 食物链
https://www.luogu.com.cn/problem/P2024
///这题是真难,看视频加理解一共花了俩小时
#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int n,m,res=0;
int p[N],d[N];
int find(int x)
{
    if(p[x]!=x)///与以往不同,这里的d数组刚开始的作用是,x节点与父节点的距离,经过find函数递归之后
                    ///d数组变成了,x节点到头节点的距离,这样就可以来判断是不是同一类和接下来做题了
    {
        int t=find(p[x]);
        d[x]+=d[p[x]];///因为要用到p[x],所以先储存;
        p[x]=t;
    }
    return p[x];
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        p[i]=i;
    while(m--)
    {
        int a,b,c;
        cin>>c>>a>>b;
        if(a>n||b>n) res++;
        else
        {
            if(c==1)
            {
                int pa=find (a),pb=find(b);
                if(pa==pb&&(d[a]-d[b])%3) res++;///3个一循环;如果A和B是同类,而且他俩已经在合并过了,那么两者的距离相减,如果余三不得0那么就是错的;
                else
                {
                    p[pa]=pb;
                    d[pa]=d[b]-d[a];
                }
            }
            else
            {
                int pa=find(a),pb=find(b);
                if(pa==pb&&(d[a]-d[b]-1)%3) res++;
                else if(pa!=pb)
                {
                    p[pa]=pb;
                    d[pa]=d[b]+1-d[a];
                }
            }
        }
    }
    cout<<res;
    return 0;
}
6-4 自动程序检测装置
https://www.luogu.com.cn/problem/P1955
///这个题是我得知有查并集这个算法的起初
///查并集+离散化,题目i和j都开到10的九次方了,不用离散化等着爆吧
///本题思路
#include<bits/stdc++.h>
using namespace std;
const int N=400010;
int t,n;
int a[2*N],p[N],d[2*N],b[N],c[N];
int find(int x)///典
{
    if(p[x]!=x)
        p[x]=find(p[x]);
    return p[x];
}
int main()
{
    cin>>t;
    while(t--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>a[2*i-1]>>a[2*i]>>c[i];
            d[2*i-1]=a[2*i-1],d[2*i]=a[2*i];
        }
    sort(d+1,d+2*n+1);
    int h=0;
    b[0]=-1;
    for(int i=1;i<=2*n;i++)
        if(b[h]!=d[i]) b[++h]=d[i];///离散化完成,用了两次这个离散化模板了,感觉yxc老师的那个离散化模板用不了一点
    for(int i=1;i<=h;i++)
        p[i]=i;///更新爹节点
    for(int i=1;i<=n;i++)
    {
        if(c[i]==0)
            continue;
        int x=lower_bound(b+1,b+h+1,a[2*i-1])-b;
        int y=lower_bound(b+1,b+h+1,a[2*i])-b;
        if(find(x)==find(y)) continue;
        else
            p[find(x)]=find(y);///将所有相等的元素,放进树里面;接下来的就是狠狠的查找有没有内鬼
    }
    bool f=false;
    for(int i=1;i<=n;i++)
    {
        if(c[i]==1)
            continue;
        int x=lower_bound(b+1,b+h+1,a[2*i-1])-b;
        int y=lower_bound(b+1,b+h+1,a[2*i])-b;
        if(find(x)==find(y))///查找内鬼,如果有人在相等的树里面,就是内鬼!
        {
            cout<<"NO"<<endl;
            f=true;
            break;
        }
    }
    if(!f)
        cout<<"YES"<<endl;
}
    return 0;
}
6-6 A-bugs
http://bailian.openjudge.cn/practice/2492/
    ///此题考察并查集的应用,考察的是加权并查集,类似于食物链,需要考虑两者之间存在距离关系


///大题思路:每当输出两个数字是,代表这两个数字之间肯定是异性关系(如果两者满足距离为奇数)
///每当新的数加入到另一个树上时,如果符合条件,那么就意味这两者的距离之差至少为1,并且都是奇数,再向下拓展一位,也就是距离为偶数的,就是同性
///可以用da-db%2来判断,如果两者在一个树上并且满足这个条件,这两个人就是同性!

#include<bits/stdc++.h>
using namespace std;
const int N=10010;
int n,m,t;
int p[N],d[N];
int find(int x)
{
    if(x!=p[x])
    {
        int t=find(p[x]);
        d[x]+=d[p[x]];
        p[x]=t;
    }
    return p[x];
}
int main()
{
    cin>>t;
    int res=1;
    while(t--)
    {
        cin>>n>>m;
        for(int i=1;i<=n;i++)
            p[i]=i;
        memset(d,0,sizeof d);
        bool f=false;
        while(m--)
        {
            int a,b;
            cin>>a>>b;
            int pa=find(a),pb=find(b);
            if(pa==pb&&(d[a]-d[b])%2==0)
                f=true;
            else
            {
                p[pa]=p[b];
                d[pa]=d[b]+1-d[a];
            }
        }
        if(f)
        {
            printf("Scenario #%d:\n",res++);
            cout<<"Suspicious bugs found!"<<endl;
        }
        else
        {
            printf("Scenario #%d:\n",res++);
            cout<<"No suspicious bugs found!"<<endl;
        }
        cout<<endl;
    }
    return 0;
}

//https://www.luogu.com.cn/problem/P1525

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
int n,m,res,p[N],vis[N];
struct node
{
    int a,b,c;
    bool operator<(const node&w) const
    {
        return c>w.c;
    }
}per[N];
int find(int x)
{
    if(x!=p[x]) p[x]=find(p[x]);
    return p[x];
}
int main()
{
    cin>>n>>m;

    //根据题意理解,考虑贪心,根据库鲁斯卡尔,即最小生成树的思路
    //如果将边权从大到小排序,然后开始进行合并
    //考虑如何合并,首先如果两人已经在同一个监狱了,由于我们从大到小排序,所以这个一定是最大的,直接输出结束即可
    //如果没在,那么要进行一个判断,设两人为x和y,有 x不能和y在同一个监狱,z不能和x在同一个监狱,那么z会和y在一个监狱
    //所以如果此时x没有标记z的话,y就变成z,然后等待另一个y,将y和z合并,即 敌人的敌人是朋友
    //没有合并的不需要考虑了,因为我们一定是最大的

    for(int i=1;i<=n;i++) p[i]=i;
    for(int i=1;i<=m;i++) cin>>per[i].a>>per[i].b>>per[i].c;
    sort(per+1,per+1+m);
    for(int i=1;i<=m;i++){
        int x=per[i].a,y=per[i].b,w=per[i].c;
        if(find(x)==find(y)) return cout<<w,0;
        if(vis[x]==0) vis[x]=y; //如果此时x没有先前的敌对,那就先标记
        else p[find(y)]=find(vis[x]); //将y和x的敌对放到同一个监狱
        if(vis[y]==0) vis[y]=x;
        else p[find(x)]=find(vis[y]);
    }
    cout<<0; //如果都符合,输出0
    return 0;
}

//https://www.luogu.com.cn/problem/P1621

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
int n,m,res,ans,num,k;
int prime[N],prime_[N],p[N];
bool vis[N];
int find(int x)
{
    if(x!=p[x]) p[x]=find(p[x]);
    return p[x];
}
int main()
{
    cin>>n>>m>>k;
    for(int i=n;i<=m;i++) p[i]=i;
    //预处理出来2-m的所有质数
    for(int i=2;i<=m;i++){
        if(!vis[i]) prime_[++res]=i;
        for(int j=1;prime_[j]<=m/i;j++){
            vis[prime_[j]*i]=true;
            if(!(i%prime_[j])) break;
        }
    }
    //预处理k-m的质数
    for(int i=1;i<=res;i++) if(prime_[i]>=k) prime[++num]=prime_[i];
    //对于每个质数,算出对应的这个数的最小倍数,然后遍历这个质数对应最小的质数到最大数的区间即可
    for(int i=1;i<=num;i++){
        int x=(n+prime[i]-1)/prime[i]*prime[i];
        for(int j=x;j<=m;j+=prime[i]) p[find(j)]=find(x);
    }
    //统计集合数量,即根节点还是本身的数量
    for(int i=n;i<=m;i++) if(p[i]==i) ans++;
    cout<<ans;
    return 0;
}

带权并查集:

//https://www.luogu.com.cn/problem/P1196
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e5+10,mod=1e9+7;
signed main()
{
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int n; cin>>n;
    vector<int>p(N+1),sz(N+1),dep(N+1);
    for(int i=1;i<=N;i++) p[i]=i,sz[i]=1;
    function<int(int)>find;
    find=[&](int x)->int{
        if(x==p[x]) return p[x];
        int root=find(p[x]);
        dep[x]+=dep[p[x]];
        return p[x]=root;
    };
    while(n--){
        char op; 
        int a,b; cin>>op>>a>>b;
        if(op=='M'){
            int u=find(a),v=find(b);
            if(u==v) continue;
            p[u]=v,dep[u]=sz[v],sz[v]+=sz[u];
        }
        else{
            if(find(a)!=find(b)) cout<<-1<<'\n';
            else cout<<abs(dep[a]-dep[b])-1<<'\n';
        }
    }
    return 0;
}

__EOF__

本文作者：Sakurajimamai
本文链接：https://www.cnblogs.com/o-Sakurajimamai-o/p/17427994.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2023-05-24 13:02 o-Sakurajimamai-o 阅读(10) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 7.30作业

· 基础算法大全(更新ing

· P2078 朋友

· 并查集笔记

· 并查集（Union Find Set）

公告

并查集

发表于 2023-05-24 13:02阅读：10评论：0推荐：0

算法合集 / 数据结构 luogu

关注

跳至底部

昵称： o-Sakurajimamai-o
园龄： 1年9个月
粉丝： 9
关注： 0

+加关注

o-Sakurajimamai-o

我永远喜欢樱岛麻衣

并查集

公告

Sakurajimamai

并查集

搜索

常用链接

合集 (1)

随笔分类 (416)

随笔档案 (215)

阅读排行榜

评论排行榜

推荐排行榜

最新评论