数据结构：并查集（合并集合、连通块中点的数量、食物链）

并查集
主要功能：将两个集合合并、询问两个元素是否在一个集合里
基本原理：每个集合用一棵树表示，树根编号即集合的编号。 每个节点存储它的父节点（p[x]表示x的父节点）
判断树根：if(p[x] == x)
求x的集合编号：while(p[x] != x) x = p[x];（优化路段压缩）
合并两个集合：px是x的集合编号，py是y的集合编号， p[x] = y

1.合并集合的题目要求：
一共有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≤10^5
输入样例：
4 5
M 1 2
M 3 4
Q 1 2
Q 1 3
Q 3 4
输出样例：
Yes
No
Yes

程序代码：

#include 
using namespace std;

const int N = 100010;
int n, m, p[N];

int find(int x)//返回x的祖宗节点（路径压缩）
{
     
    if(p[x] != x)  p[x] = find(p[x]);
    return p[x];
}

int main()
{
     
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++) p[i] = i;
    
    while(m --)
    {
     
        char op[2];
        int a, b;
        scanf("%s%d%d", op, &a, &b);
        if(op[0] == 'M')   p[find(a)] = find(b);
        else 
        {
     
            if(find(a) == find(b))  puts("Yes");
            else puts("No");
        }
    }
    return 0;
}

2.连通块中点的数量题目要求：
给定一个包含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≤10^5
输入样例：
5 5
C 1 2
Q1 1 2
Q2 1
C 2 5
Q2 5
输出样例：
Yes
2
3

程序代码：

#include 
using namespace std;

const int N = 100010;
int n, m, p[N], s[N];//s表示集合内点的数量

int find(int x)
{
     
    if(p[x] != x)  p[x] = find(p[x]);
    return p[x];
}

int main()
{
     
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++)
    {
     
        p[i] = i;
        s[i] = 1;
    }
    
    while(m --)
    {
     
        char op[5];
        int a, b;
        scanf("%s", op);
        
        if(op[0] == 'C')
        {
     
            scanf("%d%d", &a, &b);
            if(find(a) == find(b))  continue;
            s[find(b)] += s[find(a)];
            p[find(a)] = find(b);
        }
        else if(op[1] == '1')
        {
     
            scanf("%d%d", &a, &b);
            if(find(a) == find(b))  puts("Yes");
            else puts("No");
        }
        else
        {
     
            scanf("%d", &a);
            printf("%d\n", s[find(a)]);
        }
    }
    return 0;
}

3.食物链题目要求：
动物王国中有三类动物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句话有的是真的，有的是假的。

当一句话满足下列三条之一时，这句话就是假话，否则就是真话。
1） 当前的话与前面的某些真的话冲突，就是假话；
2） 当前的话中X或Y比N大，就是假话；
3） 当前的话表示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

算法的基本思路：
find函数不仅返回x的祖宗节点，并计算出该节点与根节点的距离。
因为A 、B、C三种动物的食物链是环形，则可以用距离对3取余，来判断种类关系。
余1，可以吃掉根节点；余2，可以被根节点吃掉；余0，与根节点是同类。
当x或者y超过给定的范围，则语句错误。
当判断两种是否是同类时，若这两种是来自同一个根节点且之间的距离不是3的倍数，则不同类；若不是同一根节点，这时需要将x的根节点接到y的根节点上，并确定d[px]。
当判断X是否能吃Y时，若x能吃y（x和y是同一个根节点），则(d[x] - 1 - d[y])%3=0.若不是同一根节点，这时需要将x的根节点接到y的根节点上，并确定d[px]。

程序代码：

#include 
using namespace std;

const int N = 50010;
int n, m, p[N], d[N];//d[N]存放该节点与根节点的距离

int find(int x)
{
     
    if(p[x] != x)
    {
     
        int u = find(p[x]);
        d[x] += d[p[x]];
        p[x] = u;
    }
    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 ++;
                else if(px != py)
                {
     
                    p[px] = py;
                    d[px] = d[y] - d[x];
                }
            }
            else
            {
     
               if(px == py && (d[x] - d[y] - 1) % 3)  res ++;
                else if(px != py)
                {
     
                    p[px] = py;
                    d[px] = d[y] - d[x] + 1;
                } 
            }
        }
    }
    
    printf("%d\n", res);
    return 0;
}