0x41并查集

最新推荐文章于 2023-03-29 15:03:35 发布
最新推荐文章于 2023-03-29 15:03:35 发布
阅读量257 收藏
点赞数
分类专栏： 算法竞赛进阶指南
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39848541/article/details/119580952
版权
本文详细介绍了并查集这种数据结构，包括其基本操作如查找和合并，并讲解了路径压缩和按秩合并的优化策略。通过示例代码展示了如何实现并查集，以及在实际问题中的应用，如程序自动分析、超市商品管理和食物链问题的解决。
摘要由CSDN通过智能技术生成

并查集：一种可以动态维护若干个不重叠的集合，并支持合并与查询的数据结构。
1.get :查询元素属于哪一个集合
2.merge：合并两集合

使用“代表元法”表示并查集：选择固定元素代表集合

使用树形结构存储每个集合，树上每一个节点都是一个元素，树根是集合的代表元素。整个并查集是一个森林，通过维护数组fa[n]记录整个森林，fa[x]保存x 的父节点，特别的,树根的fa[x]值等于自身。
合并操作：将其中一个树根直接连接到另一棵树上，即fa[root1]=root2
查询归属：递归访问父节点直到树根。

路径压缩：（常用）
在每次查询过程中，将过程中访问过的节点（即所查询元素的全部祖先）直接指向树根：优化查询效率
按秩合并：
将集合的秩（可以是树的深度or集合大小等）记录树根上，合并时将秩较小的树根作为秩较大的树根的子节点。
（将小的结构合并到大的结构中去，只增加小的结构的查询代价）

(1)朴素并查集：

    int fa[N]; //存储每个点的祖宗节点
  
    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ ) fa[i] = i;
    //所有元素各自独立构成集合，n棵只有根节点的树
    
    int Get(int x)    // 返回x的祖宗节点
    {
        if (fa[x] != x) fa[x] = Get(fa[x]);//路径压缩
        return fa[x];
    }

    // 合并a和b所在的两个集合：
    void Merge(int a,int b)
    {
    	fa[Get(a)] = Get(b);
	}

(2)维护size的并查集：

    int fa[N], size[N];
    //fa[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量
    
	// 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        fa[i] = i;   size[i] = 1;
    }
    
    // 返回x的祖宗节点
    int Get(int x)
    {
        if (fa[x] != x) fa[x] = Get(fa[x]);
        return fa[x];
    }
    
    // 合并a和b所在的两个集合：
    void Merge(int a,int b)
    {
    	size[Get(b)] += size[Get(a)];
    	fa[Get(a)] = Get(b);
	}
    

(3)维护到祖宗节点距离的并查集：

    int fa[N], d[N];
    //fa[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离
    
    for (int i = 1; i <= n; i ++ )	 // 初始化，假定节点编号是1~n
    {
        p[i] = i;    d[i] = 0;
    }
    
    int Get(int x) // 返回x的祖宗节点
    {
        if (fa[x] != x)
        {
            int u = Get(fa[x]);
            d[x] += d[fa[x]];
            fa[x] = u;
        }
        return fa[x];
    }
    
    // 合并a和b所在的两个集合：
     void Merge(int a,int b)
    {
    	 fa[Get(a)] = Get(b);
   		 d[Get(a)] = distance; // 根据具体问题，初始化find(a)的偏移量
	}

237. 程序自动分析

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+10;
int fa[N],id[N],cnt;
struct node{
    int x,y,flag;
}a[N];
bool cmp(node c,node d)
{
    return c.flag>d.flag;
}
int getid(int k)
{
    return lower_bound(id,id+cnt,k)-id;
}
int Find(int k)
{
    if(fa[k]!=k) fa[k]=Find(fa[k]);
    return fa[k];
}
void merge(int c,int d)
{
    fa[Find(c)]=Find(d);
}
int main()
{
    int t;scanf("%d",&t);
    while(t--)
    {
        int n;cnt=0;scanf("%d",&n);
        for(int i=0;i<n;++i)
        {
            scanf("%d%d%d", &a[i].x, &a[i].y,&a[i].flag);
            id[cnt++]=a[i].x;id[cnt++]=a[i].y;
        }sort(a,a+n,cmp);
        sort(id,id+cnt);cnt=unique(id,id+cnt)-id;
        for(int i=0;i<=cnt;++i)
        {
            fa[i]=i;
        }int flag=0;
        for(int i=0;i<n;++i)
        {
            if(a[i].flag==1)
            {
                int xx=getid(a[i].x),yy=getid(a[i].y);
                merge(xx,yy);
               // printf("xx:%d,yy:%d  find(xx):%d,find(yy):%d\n",xx,yy,Find(xx),Find(yy));
            }
            else 
            {
                int xx=getid(a[i].x),yy=getid(a[i].y);
                if(Find(xx)==Find(yy)) flag=1;
                //printf("xx:%d,yy:%d  find(xx):%d,find(yy):%d\n",xx,yy,Find(xx),Find(yy));
            }
        }
        if(flag==1) cout<<"NO"<<endl;
        else cout<<"YES"<<endl;
    }
}

145. 超市

#include <bits/stdc++.h>
using namespace std;
const int N = 1e4+10;
typedef long long ll;
struct node{
    int p,d;
}a[N];
int fa[N];
bool cmp(node x,node y)
{
    return x.p>y.p;
}
int Find(int k)
{
    if(fa[k]!=k) fa[k]=Find(fa[k]);
    return fa[k];
}
void merge(int x,int  y)
{
    fa[Find(x)]=Find(y);
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        int maxday=0;
        for(int i=0;i<n;++i)
        {
            cin>>a[i].p>>a[i].d;
            maxday=max(maxday,a[i].d);
        }
        sort(a,a+n,cmp);
        for(int i=1;i<=maxday;++i)
        fa[i]=i;
        ll res=0;
        for(int i=0;i<n;++i)
        {
            if(Find(a[i].d)>0) 
            {
                res+=a[i].p;
                merge(Find(a[i].d),Find(a[i].d)-1);
            }
        }
        cout<<res<<endl;
    }
   
    
}

边带权的并查集：
238. 银河英雄传说

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 3e4+10;
int fa[N],d[N],Size[N];
int Find(int k)
{
        if(fa[k]==k) return k;
        int root=Find(fa[k]);
        d[k]+=d[fa[k]];
        return fa[k]=root;
}
void merge(int x,int y)
{
        x=Find(x);y=Find(y);
        fa[x]=y;
        d[x]=Size[y];
        Size[y]+=Size[x];
}
int main()
{
        for(int i=1;i<=N;++i)
        {
                fa[i]=i;d[i]=0;Size[i]=1;
        }
   int t;cin>>t;
   while(t--)
   {
           string op;int i,j;
           cin>>op>>i>>j;
           if(op=="M")
           {
                  merge(i,j);
           }
           else if(op=="C")
           {
                   if(Find(i)!=Find(j)) cout <<"-1"<<endl;
                   else cout<<abs(d[i]-d[j])-1<<endl;
           }
   }
}

！！！239. 奇偶游戏

边带权解法

#include<bits/stdc++.h>
typedef long long LL;
const int N = 1e4+10;
using namespace std;
struct node{
    int l,r,flag;
}query[N];
int fa[N*2],d[N*2],a[N*2],cnt=0,n,m;
void read()
{
    int n;cin>>n>>m;
    for(int i=0;i<m;++i)
    {
        string s;
        cin>>query[i].l>>query[i].r>>s;
        if(s=="even") query[i].flag=0;
        else query[i].flag=1;
        a[++cnt]=query[i].l-1;a[++cnt]=query[i].r;
    }
    sort(a+1,a+cnt+1);
    cnt=unique(a+1,a+cnt+1)-a-1;
    for(int i=1;i<=cnt;++i)
    {
        fa[i]=i;
    }
}
int Find(int x)
{
    if(fa[x]==x) return x;
    int root=Find(fa[x]);
    d[x]^=d[fa[x]];
    return fa[x]=root;
}
int main()
{
    read();
    for(int i=0;i<m;++i)
    {
        int x=lower_bound(a+1,a+cnt+1,query[i].l-1)-a;
        int y=lower_bound(a+1,a+cnt+1,query[i].r)-a;
        int p=Find(x),q=Find(y);
        if(p==q)
        {
            if((d[x]^d[y])!=query[i].flag) 
            {
                cout<<i<<endl;return 0;
            }
        }else
        {
            fa[p]=q;
            d[p]=d[x]^d[y]^query[i].flag;
        }
       
    }
     cout<<m<<endl;
}

扩展域解法:

#include<bits/stdc++.h>
typedef long long LL;
const int N = 1e4+10;
using namespace std;
int fa[N*2],a[N*2],cnt=0,n,m;
struct node{
    int l,r,flag;
}query[N];
void read()
{
    int n;cin>>n>>m;
    for(int i=0;i<m;++i)
    {
        string s;
        cin>>query[i].l>>query[i].r>>s;
        if(s=="even") query[i].flag=0;
        else query[i].flag=1;
        a[++cnt]=query[i].l-1;a[++cnt]=query[i].r;
    }
    sort(a+1,a+cnt+1);
    cnt=unique(a+1,a+cnt+1)-a-1;
    for(int i=1;i<=cnt*2;++i)
    {
        fa[i]=i;
    }
}
int Find(int x)
{
    if(fa[x]==x) return x;
    return fa[x]=Find(fa[x]);
}
int main()
{
    read();
    for(int i=0;i<m;++i)
    {
        int x=lower_bound(a+1,a+cnt+1,query[i].l-1)-a;
        int y=lower_bound(a+1,a+cnt+1,query[i].r)-a;
        int x_odd=x,x_even=x+cnt;
        int y_odd=y,y_even=y+cnt;
        if(query[i].flag==0)
        {//printf("x:%d;y:%d  Find:x_odd:%d,y_even:%d\n",x,y,Find(x_odd),Find(y_even));
            if(Find(x_odd)==Find(y_even))
            {
                cout<<i<<endl;return 0;
            }
            fa[Find(x_odd)]=Find(y_odd);
            fa[Find(x_even)]=Find(y_even);
        }
        else
        {
            if(Find(x_odd)==Find(y_odd))
            {
                cout<<i<<endl;return 0;
            }
            fa[Find(x_odd)]=Find(y_even);
            fa[Find(x_even)]=Find(y_odd);
        }
    }
     cout<<m<<endl;
}

240. 食物链*

#include<bits/stdc++.h>
using namespace std;
const int N = 5e4+10;
int fa[N*3];
int Find(int x)
{
    if(x==fa[x]) return x;
    return fa[x]=Find(fa[x]);
}
int main()
{
    int n,k;cin>>n>>k;
    for(int i=1;i<=n*3;++i)
    {
        fa[i]=i;
    }int ans=0;
    for(int i=0;i<k;++i)
    {
     int d,x,y;
     cin>>d>>x>>y;
     
     if(x>n||y>n) ans++;
     else if(d==1)
     {
         if(Find(x)==Find(y+n)||Find(x)==Find(y+2*n))
         ans++;
         else 
         {
             fa[Find(x)]=Find(y);
             fa[Find(x+n)]=Find(y+n);
             fa[Find(x+2*n)]=Find(y+2*n);
         }
     }
     else if(d==2)
     {
         if(x==y||Find(x)==Find(y)||Find(x)==Find(y+n))
         {
             ans++;
         }
         else 
         {
             fa[Find(x)]=Find(y+2*n);
             fa[Find(x+n)]=Find(y);
             fa[Find(x+2*n)]=Find(y+n);
         }
     }
    }
    cout<<ans<<endl;
}
静妮子i
关注
专栏目录
种类并查集
skysys的研究小屋
04-23 3249
简介 种类并查集：  和基础并查集有很大一部分相同， 多了一个判断2个元素是否属于同一个集团（不是集合， 集合是用来判断2个元素是否能够判断他们属不属于同一个集团：有点绕， 举个例子， 假如知道1和2在不同的集团， 3和4在不同集团，我们就不能判断1和3是否属于一个集团，而集团是用来判断他们是否在同一个集团假如：已知1和2在不同集团，2和3在不同集团， 那么我们就知道1和3在同一个集团
C++ 并查集算法
struct_GS的博客
08-13 4635
并查集简介 并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中。其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受；即使在空间上勉强通过，运行的时间复杂度也极高，根本就不可能在比赛规定的运行时间（1～3秒）内计算出试题需要的结果，只能用并查集来描述。 ...
0x41 数据结构进阶-并查集
橘嘉禾
08-02 1031
A题 程序自动分析 题目链接：https://ac.nowcoder.com/acm/contest/1031/A 题目描述 在实现程序自动分析的过程中，常常需要判定一些约束条件是否能被同时满足。 考虑一个约束满足问题的简化版本：假设 ????1, ????2, ????3, ⋯ 代表程序中出现的变量，给定 ???? 个形如 ???????? = ???????? 或 ???????? ≠ ???????? 的变量相等/不等的约束条件，请判定是否可以分别为每...
并查集**
qwjy的博客
02-06 489
  文章目录       
关于字符编码，你所需要知道的
qiuyepiaoling的专栏
07-12 1390
<br />字符编码的问题看似很小，经常被技术人员忽视，但是很容易导致一些莫名其妙的问题。这里总结了一下字符编码的一些普及性的知识，希望对大家有所帮助。还是得从ASCII码说起<br /> <br />说到字符编码，不得不说ASCII码的简史。计算机一开始发明的时候是用来解决数字计算的问题，后来人们发现，计算机还可以做更多的事，例如文本处理。但由于计算机只识“数”，因此人们必须告诉计算机哪个数字来代表哪个特定字符，例如65代表字母‘A’，66代表字母‘B’，以此类推。但是计算机之间字符-数字的对应关系必须得
＜SPI 波形分析＞＜1＞FLASH读写数据0x41
TJ的博客
11-12 3786
SPI+FLASH波形数据分析
字符编码详解
热门推荐
vivisoul的专栏
12-21 1万+
看到一篇很用心讲字符编码的文章，另外推荐《编码》一书（英文原名《CODE:The Hidden Language of Computer Hardware and Software》） 原文地址 版本：v2.3.1 CrifanLi 摘要 本文主要介绍了字符编码的基础知识，以及常见的字符编码类型，比如ASCII，Unicode，UTF-8，ISO 885...
0x41 并查集
weixin_51942493的博客
11-22 3130
并查集 -> 是一个可以动态维护若干个不重叠的集合，并支持合并与查询的数据结构。 核心： const int N = 1000010; int p[N]; void init(){ p[i] = i; } int find(int x){ if(p[x] != x) p[x] = find(p[x]); return p[x]; } void merge(int a,int b){ int pa=find(a),pb=find(b); if(pa!=pb){ p[pa] = pb
算法竞赛进阶指南——0x41【并查集】
qq_51201910的博客
08-26 323
引言 并查集普通的就那种 高端的有带边权的并查集和扩展域的并查集 普通 vector<int> size(N, 1); //记录并初始化子树大小为1 inline int get_fa(int v) { return f[v] == v ? v : f[v] = get_fa(f[v]); } //路径压缩 inline bool megre(int x, int y) { int fx = get_fa(x), fy = get_fa(y); if (fx == fy)
并查集详解及例题
Hacker_Wind的博客
03-25 1719
一、并查集是什么并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。也就是说并查集用于将分散的树结构进行合并或者查询。二、并查集代码并查集主要分为三个过程1、初始化：将每个散点的父节点设为自己本身。void Init() { for(int i=1;i&lt;=n;i++) { pre[i]=i; } }2、Fi...
HDU 6187 Destroy Walls（并查集）
01-03
使用并查集+贪心：先将已有边的权值从大到小排序，又n个点只需n-1条边，这时再遍历一遍，将有边的两点合并为一个队伍，当边的数量达到n-1时退出循环，因为此时已达到最小生成树。 边的权值由大到小排序是因为要将大...
算法竞赛进阶指南0x41 并查集
m0_73935863的博客
03-29 368
算法竞赛进阶指南0x41 并查集
算法竞赛进阶指南---0x41 （并查集） 银河英雄传说
qq_44791484的博客
02-01 586
题面 题解 题中有两种操作方式，一种是合并两个集合，一种是询问集合中元素的关系（距离），那就是并查集，而且是要维护到祖宗节点距离的并查集 先看查询操作，我们可以用一个d[x] 数组维护 x 到 p[x] 的距离 ，在每次 find(x) 操作之后 +路径压缩，那么x到p[x] 的距离就是 x 到祖宗节点的距离，如果两个战舰x,y在同一个集合中，abs(d[x]-d[y])-1不就是两个战舰之间还有多少个战舰，如果不在就返回-1 接下来就考虑如何维护 d 数组，也就是合并操作，假设合并两个战舰集合
0x41.数据结构进阶 - 并查集
繁凡さん的博客
05-29 993
目录 声明： 本系列博客是《算法竞赛进阶指南》+《算法竞赛入门经典》+《挑战程序设计竞赛》的学习笔记，主要是因为我三本都买了 按照《算法竞赛进阶指南》的目录顺序学习，包含书中的少部分重要知识点、例题解题报告及我个人的学习心得和对该算法的补充拓展，仅用于学习交流和复习，无任何商业用途。博客中部分内容来源于书本和网络（我尽量减少书中引用），由我个人整理总结（习题和代码可全都是我自己敲哒）部分内容由我个人编写而成，如果想要有更好的学习体验或者希望学习到更全面的知识，请于京东搜索购买正版图书：《算法竞赛进阶指南
安徽建筑大学在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-05
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
ADC建模，ADC数字校准，模拟ic设计 模数转器， ADC MATLAB建模， 包含实例和说明 ADC数字校准 三种adc建模
最新发布
10-05
ADC建模，ADC数字校准，模拟ic设计 模数转器， ADC MATLAB建模， 包含实例和说明 ADC数字校准 三种adc建模资料打包价格 ，simulink模型 14bit 100MSAR ADC 12位流水线 pipelined ADC sigma-delta adc 模拟IC，ADC建模 多种sar adc和流水线的matlab模型 ADC的动态fft，静态特性inl、dnl仿真 多种 sarADCMATLAB和simulink 建模全都整合在里面了 实用SAR ADC的Matlab Simulink Model，可用于非理想效应的行为级仿真一个实用的SAR ADC的行为级模型。 对多种非理想效应都进行了建模仿真，包括非线性采样，比较器offset，以及电容适配 ADC的动态fft，静态特性inl、dnl仿真 教程，动态静态参数分析。 东西很多，就不一一介绍了。
电子科技大学成都学院在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-05
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
天津城建大学在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-05
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
数据手册-DAC0832-datasheet.zip
10-05
数据手册-DAC0832-datasheet.zip
hive导出文件并制定分隔符0x01
07-10
如果你想要从Hive表导出文件，并指定分隔符为0x01，你可以使用`SELECT ... INTO CSV`或`SELECT ... INTO FILE`语句。例如： ```sql SELECT * FROM your_table_name INTO CSV 'path/to/output/file', '\0x01'; -- ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值