【Algorithm】并查集

并查集：

1. 将两个集合合并

2. 询问两个元素是否在一集合当中

基本原理：每个集合用一棵树来表示。树根的编号就是整个集合的编号。每个节点存储它的父节点，p[x] 表示 x 的父节点。

问题1：如何判断树根：if ( p[x] == x )

问题2：如何求 x 的集合编号：while ( p[x] != x) x = p[x];

问题3：如何合并两个集合：px 是 x 的集合编号，py 是 y 的集合编号。p[x] = y

朴素并查集

int p[N]; //存储每个点的祖宗节点

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ ) p[i] = i;

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);

维护size的并查集

 int p[N], size[N];
    //p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        size[i] = 1;
    }

    // 合并a和b所在的两个集合：
    size[find(b)] += size[find(a)];
    p[find(a)] = find(b);

维护到祖宗节点距离的并查集

 int p[N], d[N];
    //p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x)
        {
            int u = find(p[x]);
            d[x] += d[p[x]];
            p[x] = u;
        }
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        d[i] = 0;
    }

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);
    d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量

食物链

 方法一：

        x, y 是同类的话的 d[x] 与 d[y] 模三同余

        x 吃 y 的话的 d[x] - 1 与 d[y] 模三同余

        y 吃 x 的话的 d[x] + 1 与 d[y] 模三同余

#include <iostream>

using namespace std;

const int N = 50000 + 10;

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

方法二：

        x 是同类域.
        x + n 是捕食域
        x + n + n 是天敌域

#include <iostream>
using namespace std;

int n, k;
int father[200010];

int find(int x)
{
    return father[x] == x ? x : father[x] = find(father[x]);
}

void merge(int x, int y)
{
    father[find(x)] = find(y);
}

int main()
{
    cin >> n >> k;
    for(int i = 1; i <= 3 * n; i++)
        father[i] = i;
    /**
     * f[i] i是a
     * f[i+n] i是b
     * f[i+2*n] i是c
     */
    int cnt = 0;
    for(int i = 1; i <= k; i++) {
        int op, x, y;
        cin >> op >> x >> y;
        if(x > n || y > n) {
            cnt++; continue;
        }

        if(op == 1) {
            if(find(x) == find(y + n) || find(x) == find(y + 2 * n))
                cnt++;
            else {
                merge(x, y);
                merge(x + n, y + n);
                merge(x + 2 * n, y + 2 * n);
            }
        }

        else {
            if(find(x) == find(y) || find(x) == find(y + n))
                cnt++;
            else {
                merge(x, y + 2 * n); // y 的捕食域加入 x
                merge(x + n, y); // x 的捕食域加入 y
                merge(x + 2 * n, y + n); // x 的天敌域是y的捕食域.
            }
        }
    }
     cout << cnt << "\n";

     return 0;
}