可持久化并查集

 void buildntree(int left ,int right){
     int mid=(left+right)/2;
     tr[++cnt].l=left;tr[cnt].r=right;
     if (left!=right){
         int t=cnt;
         tr[t].lc=cnt+1;
         buildntree(left,mid);
         tr[t].rc=cnt+1;
         buildntree(mid+1,right);
     }else {
     tr[cnt].fa=left;
     tr[cnt].size=1;
         }
 }

 int getfa(int po,int targ){
     int mid=(tr[po].l+tr[po].r)/2;
     if (tr[po].l==tr[po].r) return(tr[po].fa);
     if (targ<=mid) return(getfa(tr[po].lc,targ)); else return(getfa(tr[po].rc,targ));
 }

 int getsize(int po,int targ){
     int mid=(tr[po].l+tr[po].r)/2;
     if (tr[po].l==tr[po].r) return(tr[po].size);
     if (targ<=mid) return(getsize(tr[po].lc,targ)); else return(getsize(tr[po].rc,targ));
 }

 void expdfa(int targ,int cha){
     tr[++cnt].l=tr[fol].l;
     tr[cnt].r=tr[fol].r;
     tr[cnt].fa=tr[fol].fa;
     tr[cnt].size=tr[fol].size;
    int mid=(tr[fol].l+tr[fol].r)/2;
    if (tr[fol].l==tr[fol].r){tr[cnt].fa=cha;return;}
     if (targ<=mid){
         tr[cnt].rc=tr[fol].rc;
         fol=tr[fol].lc;
         tr[cnt].lc=cnt+1;
         expdfa(targ,cha);
     }else{
         tr[cnt].lc=tr[fol].lc;
         fol=tr[fol].rc;
         tr[cnt].rc=cnt+1;
         expdfa(targ,cha);
     }
 }

 void expdsize(int targ){
     tr[++cnt].l=tr[fol].l;
     tr[cnt].r=tr[fol].r;
     tr[cnt].fa=tr[fol].fa;
     tr[cnt].size=tr[fol].size;
    int mid=(tr[fol].l+tr[fol].r)/2;
    if (tr[fol].l==tr[fol].r){tr[cnt].size++;return;}
     if (targ<=mid){
         tr[cnt].rc=tr[fol].rc;
         fol=tr[fol].lc;
         tr[cnt].lc=cnt+1;
         expdsize(targ);
     }else{
         tr[cnt].lc=tr[fol].lc;
         fol=tr[fol].rc;
         tr[cnt].rc=cnt+1;
         expdsize(targ);
     }
 }

int fax=getfa(dl[top].root,op[i][1]),
                     fay=getfa(dl[top].root,op[i][2]);
                 while (getfa(dl[top].root,fax)!=fax) fax=getfa(dl[top].root,fax);
              while (getfa(dl[top].root,fay)!=fay) fay=getfa(dl[top].root,fay);
                 if (fax!=fay){
                         dl[top+1].root=cnt+1;
                         dl[top+1].ans=dl[top].ans+i;
                         dl[top+1].sid=dl[top].sid+1;
                         int sizx=getsize(dl[top].root,fax);
                         int sizy=getsize(dl[top].root,fay);
                         fol=dl[top].root;
                         if (sizx<sizy) expdfa(fax,fay);
                    if (sizx>=sizy) expdfa(fay,fax);
                    if (sizx==sizy){int t=cnt+1;fol=dl[top+1].root;expdsize(fax);dl[top+1].root=t;}
                    top++;}
                    else{dl[top+1].root=dl[top].root;
                        dl[top+1].ans=dl[top].ans;
                        dl[top+1].sid=dl[top].sid;
                        top++;};
时间: 2024-10-07 09:30:27

可持久化并查集的相关文章

可持久化并查集加强版 BZOJ 3674

http://www.lydsy.com/JudgeOnline/problem.php?id=3674 3674: 可持久化并查集加强版 Time Limit: 15 Sec  Memory Limit: 256 MBSubmit: 3225  Solved: 1192[Submit][Status][Discuss] Description Description:自从zkysb出了可持久化并查集后--hzwer:乱写能AC,暴力踩标程KuribohG:我不路径压缩就过了!ndsf:暴力就可

bzoj3674: 可持久化并查集

用可持久化线段树维护可持久化并查集. 调了一下午,改为按秩合并就过了... #include<bits/stdc++.h> #define REP(i,a,b) for(int i=a;i<=b;i++) #define MS0(a) memset(a,0,sizeof(a)) using namespace std; typedef long long ll; const int maxn=200100; const int INF=1e9+10; int n,m; int fa[ma

【BZOJ3674】可持久化并查集加强版

可持久化并查集我觉得就是可持久化数组的一种应用.可持久化数组,顾名思义,就是有历史版本的数组,那么如果我们暴力修改储存的话,修改O(n)查询O(1),空间O(n*m),这样肯定不可行,那么我们发现主席树有这样的功能,他可以快速复制,修改O(log),查询O(log),空间(m*log),是一个可行的方案.然后我们可持久化f数组维护fa,每次按照深度启发式合并,不进行路径压缩,这样能保证时间复杂度位单次O(log^2),空间复杂度为O(2*n+m*log).我不知道为什么不路径压缩,路径压缩是完全

bzoj3674 可持久化并查集加强版

Description 自从zkysb出了可持久化并查集后--hzwer:乱写能AC,暴力踩标程KuribohG:我不路径压缩就过了!ndsf:暴力就可以轻松虐!zky:-- n个集合 m个操作操作:1 a b 合并a,b所在集合2 k 回到第k次操作之后的状态(查询算作操作)3 a b 询问a,b是否属于同一集合,是则输出1否则输出0请注意本题采用强制在线,所给的a,b,k均经过加密,加密方法为x = x xor lastans,lastans的初始值为00<n,m<=2*10^5 Samp

[bzoj3673][可持久化并查集 by zky] (rope(可持久化数组)+并查集=可持久化并查集)

Description n个集合 m个操作 操作: 1 a b 合并a,b所在集合 2 k 回到第k次操作之后的状态(查询算作操作) 3 a b 询问a,b是否属于同一集合,是则输出1否则输出0 0<n,m<=2*10^4 Input Output Sample Input 5 6 1 1 2 3 1 2 2 0 3 1 2 2 1 3 1 2 Sample Output 1 0 1 Solution 用rope实现可持久化数组,用rope的历史记录功能实现可持久化并查集,通过时间168ms

【BZOJ-3673&amp;3674】可持久化并查集 可持久化线段树 + 并查集

3673: 可持久化并查集 by zky Time Limit: 5 Sec  Memory Limit: 128 MBSubmit: 1878  Solved: 846[Submit][Status][Discuss] Description n个集合 m个操作操作:1 a b 合并a,b所在集合2 k 回到第k次操作之后的状态(查询算作操作)3 a b 询问a,b是否属于同一集合,是则输出1否则输出0 0<n,m<=2*10^4 Input Output Sample Input 5 6

BZOJ 3673: 可持久化并查集 by zky

3673: 可持久化并查集 by zky Time Limit: 5 Sec  Memory Limit: 128 MBSubmit: 2084  Solved: 941[Submit][Status][Discuss] Description n个集合 m个操作操作:1 a b 合并a,b所在集合2 k 回到第k次操作之后的状态(查询算作操作)3 a b 询问a,b是否属于同一集合,是则输出1否则输出0 0<n,m<=2*10^4 Input Output Sample Input 5 6

BZOJ 3674: 可持久化并查集加强版

3674: 可持久化并查集加强版 Time Limit: 15 Sec  Memory Limit: 256 MBSubmit: 2605  Solved: 977[Submit][Status][Discuss] Description Description:自从zkysb出了可持久化并查集后……hzwer:乱写能AC,暴力踩标程KuribohG:我不路径压缩就过了!ndsf:暴力就可以轻松虐!zky:…… n个集合 m个操作操作:1 a b 合并a,b所在集合2 k 回到第k次操作之后的状

3674: 可持久化并查集加强版

Time Limit: 15 Sec  Memory Limit: 256 MBSubmit: 3592  Solved: 1337[Submit][Status][Discuss] Description Description:自从zkysb出了可持久化并查集后……hzwer:乱写能AC,暴力踩标程KuribohG:我不路径压缩就过了!ndsf:暴力就可以轻松虐!zky:…… n个集合 m个操作操作:1 a b 合并a,b所在集合2 k 回到第k次操作之后的状态(查询算作操作)3 a b 询

半可持久化并查集

对于常见的可持久化并查集, 我们可以通过 按秩合并 + 可持久化数组 . 但是, 此半可持久化并查集, 非彼可持久化并查集. 我们不用支持时间旅行, 即不用支持回到过去的某个版本, 而只用储存历史信息. 举个例子来说吧. n 个点, 支持两种操作: ① 将某两个点之间连边; ② 查询在前 t 次操作下, 某两个点是否连通. 强制在线. 核心模型 给定 n 个点, m 条带权边的无向图. 求在所有边权不超过 d 的边的作用下, 某个点或某两个点的连通性信息. 强制在线. 之前举的那个例子也可以这样