洛谷P3402 【模板】可持久化并查集

一定注意每一次都要是 $root[cur]=root[cur-1]$,不然进行合并时如果 $a,b$ 在同一集合中就会使 $root[cur]=0$.

Code:

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
//ty==1 for size, ty==0 for father

void setIO(string a){ freopen((a+".in").c_str(),"r",stdin); }

#define maxn 200005
int n,m,cur,root[maxn*4];
struct Node{ 
    int f,siz; 
    Node(int f=0,int siz=0):f(f),siz(siz){}
};
struct Segment_Tree{
    int lson[maxn*50],rson[maxn*50],fa[maxn*50],siz[maxn*50];
    int nodes;
    void build(int l,int r,int &o){
        if(l>r)return;
        o=++nodes;
        if(l==r) { siz[o]=1,fa[o]=l; return; }
        int mid=(l+r)>>1;
        build(l,mid,lson[o]), build(mid+1,r,rson[o]);
    }  
    int update(int l,int r,int o,int pos,int ty,int k){
        int oo=++nodes;
        lson[oo]=lson[o],rson[oo]=rson[o],fa[oo]=fa[o],siz[oo]=siz[o];
        if(l==r) { 
            if(ty==1) siz[oo]=k;  
            if(ty==0) fa[oo]=k;
            return oo;
        }
        int mid=(l+r)>>1;
        if(pos<=mid) lson[oo]=update(l,mid,lson[o],pos,ty,k);
        else rson[oo]=update(mid+1,r,rson[o],pos,ty,k);
        return oo;
    }
    Node query(int l,int r,int o,int pos){
        if(l==r){ return Node(fa[o],siz[o]); }
        int mid=(l+r)>>1;
        if(pos<=mid) return query(l,mid,lson[o],pos);
        else return query(mid+1,r,rson[o],pos);
    }
    Node find(int x,int state){
        Node p=query(1,n,root[state],x);
        return p.f==x?p:find(p.f,state);
    }
    void merge(int a,int b,int state){
        Node x=find(a,state), y=find(b,state);
        if(x.f==y.f) return;
        if(x.siz>y.siz) 
            root[cur]=update(1,n,root[state],x.f,1,y.siz+x.siz),root[cur]=update(1,n,root[cur],y.f,0,x.f);
        else 
            root[cur]=update(1,n,root[state],y.f,1,y.siz+x.siz),root[cur]=update(1,n,root[cur],x.f,0,y.f);
    }
    int ask(int a,int b,int state){
        Node x=find(a,state),y=find(b,state);
        if(x.f==y.f)return 1; return 0;
    }
}S;
int main(){
   // setIO("input");
    int opt,a,b,lastans=0;
    scanf("%d%d",&n,&m);
    S.build(1,n,root[0]);
    for(cur=1;cur<=m;++cur){
        scanf("%d",&opt);
        root[cur]=root[cur-1];
        switch(opt)
        {
            case 1: { scanf("%d%d",&a,&b),a^=lastans,b^=lastans,S.merge(a,b,cur-1); break;}
            case 2: { scanf("%d",&a),a^=lastans,root[cur]=root[a]; break;}
            case 3: { scanf("%d%d",&a,&b),a^=lastans,b^=lastans,lastans=S.ask(a,b,cur-1),printf("%d\n",lastans); break;}
        }
    }
    return 0;
}

  

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
持久化并查集是指在并查集的基础上,支持回退到任意历史版本。这个结构可以用来处理一些需要撤销或者回退操作的问题。以下是一个基本的可持久化并查集的实现。 ```python class Node: def __init__(self, parent=None, rank=0): self.parent = parent self.rank = rank class PersistentUnionFind: def __init__(self, size): self.n = size self.roots = [None] * (2 * size) self.ranks = [None] * (2 * size) def make_set(self, v): self.roots[v] = Node(v) self.ranks[v] = 0 def find(self, node, version): if node.parent is None: return node if node.parent != node: node.parent = self.find(node.parent, version) return node.parent def union(self, x, y, version): x_root = self.find(self.roots[x], version) y_root = self.find(self.roots[y], version) if x_root == y_root: return False if self.ranks[x_root] < self.ranks[y_root]: x_root, y_root = y_root, x_root new_root = Node(x_root, self.ranks[x_root] + (self.ranks[x_root] == self.ranks[y_root])) self.roots[x] = self.roots[y] = new_root self.ranks[x_root] = self.ranks[y_root] = new_root.rank return True def get_version(self): return len(self.roots) // self.n - 1 def get_root(self, v, version): return self.find(self.roots[v], version).parent.val ``` 这个代码中,我们使用了一个 `Node` 类来表示每个节点,其中 `parent` 表示节点的父亲,`rank` 表示节点的秩。我们需要用一个 `roots` 数组来保存所有版本的根节点,以及一个 `ranks` 数组来保存所有节点的秩。`make_set` 函数用来初始化一个新节点,这个节点的父亲指向自己,秩为 0。`find` 函数用来找到节点所在的集合的根节点。如果节点的父亲不是根节点,那么我们就递归地寻找它的父亲。在递归返回之前,我们将所有遍历过的节点的父亲都更新为根节点,这样可以加速下次查找。`union` 函数用来将两个节点所在的集合合并。首先找到两个节点所在集合的根节点,如果根节点相同,那么这两个节点已经在同一个集合中,不需要再次合并。否则,我们将秩较小的根节点挂在秩较大的根节点下面,同时更新秩。`get_version` 函数用来获取当前版本号,而 `get_root` 函数则用来获取节点在指定版本中所在的集合的根节点。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值