可持久化并查集 （可持久化数组+并查集）

题目链接
可持久化数组相关链接

利用可持久化数组进行维护每个节点的父亲节点，对于题目中给出的三种操作：
第一种操作即将a所在集合的根节点的父亲节点赋值为b所在集合的根节点，直接在可持久化数组上进行单点修改操作。

第二种操作直接将当前版本号赋值为第k次修改的版本号。

第三种操作，直接查询两点所在集合的根节点是否相同即可，不过在可持久化数组中不支持路径压缩，所以我们只能直接递归查找当前节点的父节点，直到找到该集合的根节点，无疑直接这样查找很容易超时，所以我们可以考虑在进行合并操作的时候采用按秩合并，将深度小的集合合并到深度大的集合中去，这样深度大的集合经过合并之后，深度依然没变，尽可能的减少查询父节点的次数。

相关代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 1e5 + 5;
struct node {
    int l, r;
};
node tr[N * 30];
int d[N*30], fa[N*30], root[N*30];
int n, m, idx;
int build(int l, int r) {
    int pos = ++idx;
    if (l == r) {
        tr[pos] = { pos,pos };
        fa[pos] = l;
        return pos;
    }
    else {
        int mid = l + r >> 1;
        tr[pos].l = build(l, mid);
        tr[pos].r = build(mid + 1, r);
        return pos;
    }
}

int update(int pre, int l, int r, int u, int ff) {
    int pos = ++idx;
    if (l == r) {
        tr[pos] = { pos,pos };
        fa[pos] = ff;
        return pos;
    }
    else {
        tr[pos].l = tr[pre].l, tr[pos].r = tr[pre].r;
        int mid = l + r >> 1;
        if (u <= mid) tr[pos].l = update(tr[pre].l, l, mid, u, ff);
        else tr[pos].r = update(tr[pre].r, mid + 1, r, u, ff);
        return pos;
    }
}

void add(int now, int l, int r, int u) {
    if (l == r) {
        d[l] += 1;
        return;
    }
    else {
        int mid = l + r >> 1;
        if (u <= mid) add(tr[now].l, l, mid, u);
        else add(tr[now].r, mid + 1, r, u);
        return;
    }
}

int query(int now, int l, int r, int u) {
    if (l == r) return fa[now];
    else {
        int mid = l + r >> 1;
        if (u <= mid) return query(tr[now].l, l, mid, u);
        else return query(tr[now].r, mid + 1, r, u);
    }
}

int find_fa(int now, int u) {
    int ff = query(now, 1, n, u);
    if (ff != u) return find_fa(now, ff);
    else return ff;
}

int main()
{
    cin >> n >> m;
    root[0] = build(1, n);
    for (int i = 1; i <= m; i++) {
        int op; cin >> op;
        if (op == 1) {
            int a, b; cin >> a >> b;
            int aa = find_fa(root[i - 1], a);
            int bb = find_fa(root[i - 1], b);
            if (d[aa] > d[bb]) swap(aa, bb);
            root[i] = update(root[i - 1], 1, n, aa, bb);
            if (d[aa] == d[bb]) add(root[i], 1, n, bb);
        }
        else if (op == 2) {
            int k; cin >> k;
            root[i] = root[k];
        }
        else {
            root[i] = root[i - 1];
            int a, b; cin >> a >> b;
            int aa = find_fa(root[i],a);
            int bb = find_fa(root[i],b);
            if (aa == bb) cout << 1 << endl;
            else cout << 0 << endl;
        }
    }
    return 0;
}