acwing21并查集

合并集合

一共有 n 个数，编号是 1∼n，最开始每个数各自在一个集合中。
现在要进行 m 个操作，操作共有两种：
M a b，将编号为 a 和 b 的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作；
Q a b，询问编号为 a 和 b 的两个数是否在同一个集合中；
输入格式
第一行输入整数 n 和 m。
接下来 m 行，每行包含一个操作指令，指令为 M a b 或 Q a b 中的一种。
输出格式
对于每个询问指令 Q a b，都要输出一个结果，如果 a 和 b 在同一集合内，则输出 Yes，否则输出 No。
每个结果占一行。
数据范围
1≤n,m≤105
输入样例：

4 5
M 1 2
M 3 4
Q 1 2
Q 1 3
Q 3 4

输出样例：

Yes
No
Yes

题解：基础并查集板子，用find(fid)函数来实现找到x的集合，用记忆化来实现路径压缩。

#include<iostream>
using namespace std;
const int N=1e5+10;
int p[N];
int fid(int x)//查找集合+路径压缩
{
	if(p[x]==x) return p[x];
	else return p[x]=fid(p[x]);
}
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	  p[i]=i;//给每个数一个单独的集合标志
	while(m--)
	{
		char op[2];
		scanf("%s",op);
		int x,y;
		cin>>x>>y;
		if(op[0]=='M')
		{  //x，y在同一集合也无所谓 
			p[fid(x)]=fid(y);//合并
		}
		else 
		{   
			if(fid(x)==fid(y))
			cout<<"Yes"<<endl;
			else cout<<"No"<<endl;;
		}
	}
 } 

连通块

给定一个包含 n 个点（编号为 1∼n）的无向图，初始时图中没有边。
现在要进行 m 个操作，操作共有三种：
C a b，在点 a 和点 b 之间连一条边，a 和 b 可能相等；
Q1 a b，询问点 a 和点 b 是否在同一个连通块中，a 和 b 可能相等；
Q2 a，询问点 a 所在连通块中点的数量；
输入格式
第一行输入整数 n 和 m。
接下来 m 行，每行包含一个操作指令，指令为 C a b，Q1 a b 或 Q2 a 中的一种。

输出格式
对于每个询问指令 Q1 a b，如果 a 和 b 在同一个连通块中，则输出 Yes，否则输出 No。
对于每个询问指令 Q2 a，输出一个整数表示点 a 所在连通块中点的数量
每个结果占一行。

数据范围
1≤n,m≤105
输入样例：

5 5
C 1 2
Q1 1 2
Q2 1
C 2 5
Q2 5

输出样例：

Yes
2
3

题解：这道题就是在维护集合的同时记录了每个集合的size，把每个集合的size累加到每个集合的根节点上，最后输出size[find(x)]—就能得到x的连通块大小。

#include<iostream>
using namespace std;
const int N=1e5+10;
int siz[N],p[N];
int  fid(int x)
{
	if(p[x]==x) return p[x];
	else return p[x]=fid(p[x]); 
}
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	char op[2];
	for(int i=1;i<=n;i++)
	p[i]=i,siz[i]=1;
	
	while(m--)
	{  scanf("%s",op);
		if(op[0]=='C')
		{   int x,y;
		    scanf("%d%d",&x,&y);
			if(fid(y)!=fid(x))
			siz[fid(y)]+=siz[fid(x)];
			p[fid(x)]=fid(y);
		}
		else if(op[1]=='1')
		{   int z,c;
		    scanf("%d%d",&z,&c);
			if(fid(z)==fid(c)) cout<<"Yes"<<endl;
			else cout<<"No"<<endl;
		}
		else if(op[1]=='2')
		{   int v;
		    scanf("%d",&v);
			printf("%d\n",siz[fid(v)]);
		}
	}
	 
	
}

食物链

动物王国中有三类动物 A,B,C，这三类动物的食物链构成了有趣的环形。

A 吃 B，B 吃 C，C 吃 A。

现有 N 个动物，以 1∼N 编号。

每个动物都是 A,B,C 中的一种，但是我们并不知道它到底是哪一种。

有人用两种说法对这 N 个动物所构成的食物链关系进行描述：

第一种说法是 1 X Y，表示 X 和 Y 是同类。

第二种说法是 2 X Y，表示 X 吃 Y。

此人对 N 个动物，用上述两种说法，一句接一句地说出 K 句话，这 K 句话有的是真的，有的是假的。

当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

当前的话与前面的某些真的话冲突，就是假话；
当前的话中 X 或 Y 比 N 大，就是假话；
当前的话表示 X 吃 X，就是假话。
你的任务是根据给定的 N 和 K 句话，输出假话的总数。

输入格式
第一行是两个整数 N 和 K，以一个空格分隔。

以下 K 行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中 D 表示说法的种类。

若 D=1，则表示 X 和 Y 是同类。

若 D=2，则表示 X 吃 Y。

输出格式
只有一个整数，表示假话的数目。

数据范围
1≤N≤50000,
0≤K≤100000
输入样例：

100 7
1 101 1 
2 1 2
2 2 3 
2 3 3 
1 1 3 
2 3 1 
1 5 5

输出样例：

3

题解：对于该题，我们要维护并查集中的距离，并实现判断。

对于距离的维护我们可以通过合并树集，找特殊解“ ？ ”来实现一个判断：

具体见代码注释：

#include <iostream>
using namespace std;
const int N = 50010;
int n, m;
int p[N], d[N];
int find(int x)
{
    if (p[x] != x)
    {
        int t = find(p[x]);//p[x]是一个全局变量，实际上find(p[x])之后，仅仅实现了p[p[x]]=t————即上一层递归的赋值，
        //而这一层的p[x]要等更新完距离之后才能赋值。因为d[p[x]]表示父节点到根节点的距离而不是根节点到根节点的距离
        //find一遍p[x]之后才能保证p[x]是到根的距离。
        d[x] += d[p[x]];//d[x到父节点]+d[父节点到根]
        p[x] = t;//完成这一层对p[x]的赋值
    }
    return p[x];
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) p[i] = i;
    int res = 0;
    while (m -- )
    {
        int t, x, y;
        scanf("%d%d%d", &t, &x, &y);
        if (x > n || y > n) res ++ ;//超过动物总数——假话
        else
        {
            int px = find(x), py = find(y);
            if (t == 1)
            {
                if (px == py && (d[x] - d[y]) % 3) res ++ ;//如果在一个树上，且%3不同，就是假话
                else if (px != py)//如果不在一个树上，说明第一次说——当做真话处理
                {
                    p[px] = py;//让y成为px的根节点，此时px到py的距离为" ? "
                    d[px] = d[y] - d[x];//(d[px]+ ? )% 3  = = d[py]% 3 ,因此“？”可以取一组特殊解
                }
            }
            else
            {   //如果x吃y 则d[px]比d[py] 在%3的意义下 多 “ 1 ”。
                if (px == py && (d[x] - d[y] - 1) % 3) res ++ ; //如果x吃y ——(d[x] - d[y] - 1) % 3 == 0，不为0则假
                else if (px != py)//第一次说——当做真话处理
                {
                    p[px] = py;
                    d[px] = d[y] + 1 - d[x];//(d[px]+ ? - d[py])% 3== 1 ,因此“？”可以取一组特殊解
                }
            }
        }
    }

    printf("%d\n", res);

    return 0;
}