并查集,以及可拆分并查集

普通并查集. 合并 均摊O(log(n)) 查询 均摊O(log(n))

//常用版本

//Union Find
int f[1005000];

void INIT(int size)
{ for(int i=0;i<=size;i++) f[i]=i; }

int findf(int x) 
{ return f[x]==x ? x : f[x]=findf(f[x]); };

int connect(int x)
{ f[findf(a)]=findf(b); }

 VIJOS 1443 会卡掉不加启发式的并查集.

 

优化并查集. 加上了启发式合并. 复杂度: 合并 均摊O(α(n)); 查询 均摊O(α(n)). α函数是Ackerman函数的反函数.一般认为其小于等于4.

//union find
int f[5000],r[5000];
inline void INIT(int size)
{ for(int i=0;i<size;i++) f[i]=i,r[i]=1; }

int findf(int x)
{ return f[x]==x ? x : f[x]=findf(f[x]); }

inline void connect(int a,int b)
{
    if(r[a]>r[b]) swap(a,b);
    int fa=findf(a);
    int fb=findf(b);
    r[fb]+=r[fa];
    f[fa]=fb;
}

 

使用r数组表示"秩",即集合大小,存储在每个集合的根节点.

合并的时候将秩小的集合的根节点的父亲设到秩大的集合的根.

常数较上者而言更加大.

 

另外,如果离线处理询问,那么可以通过建图然后FloodFill的方式达到严格O(n)预处理+O(1)询问,常数较大.

 

可拆分并查集.

最坏情况: 合并 O(n) 查询 O(n) 拆分 O(n)

平均情况(对于随机生成的数据): 合并 O(logn) 查询 O(logn) 拆分 O(logn)

对于某种方式生成的随机数据跑得很快的样子?

反正随便卡.....

 

//union find
int f[1050];
void INIT(int size)
{ for(int i=0;i<=size;i++) f[i]=i; }

int findf(int x)
{ while(f[x]!=x) x=f[x]; return x; }

void setroot(int x)
{ if(f[x]!=x) setroot(f[x]); f[x]=f[f[x]]=x; }

void link(int a,int b)
{ setroot(a); f[a]=b; }

void cut(int a,int b)
{ setroot(a); f[b]=b; }

 

 

 

可以看到后边这种比较像LCT...

 

链式并查集.

复杂度 均摊 O(nlogn)

AC VIJOS 1443 银河英雄传说

常数好大....复杂度也好大.......这道题用了1653ms.....

这个并查可以用于维护一些奇怪的东西..... (做这题的时候脑子里全是LCT怎么办)

//Union Find
int L[30050]; //left node pointer.
int R[30050]; //right node pointer.
int C[30050]; //center node.
int tot[30050]; //chain nodes amount.
int nxt[30050]; //next node.
int v[30050]; //value of all nodes.

void INIT(int size)
{
    for(int i=0;i<=size;i++)
    L[i]=R[i]=C[i]=i,tot[i]=1,nxt[i]=-1;
}

void Merge(int x,int y)
{
    //link x to y's tail.
    int cx=C[x];
    int cy=C[y];
    if(tot[cx]>tot[cy]) //change chain y's info
    {
        for(int i=L[cy];i!=-1;i=nxt[i])
            C[i]=cx; //chagne center node.
        nxt[R[cy]]=L[cx];
        L[cx]=L[cy];
        tot[cx]+=tot[cy];
    }
    else //change chain x's info.
    {
        for(int i=L[cx];i!=-1;i=nxt[i])
            C[i]=cy; //change center node.
        nxt[R[cy]]=L[cx];
        R[cy]=R[cx];
        tot[cy]+=tot[cx];
    }
}


char op[505000];
int a[505000];
int b[505000];

int n=30000,m;

int main()
{
    m=getint();
    
    INIT(n);
    
    for(int i=0;i<m;i++)
    {
        char inp[20];
        scanf("%s",inp);
        op[i]=inp[0];
        a[i]=getint()-1;
        b[i]=getint()-1;
    }
    
    //first operations dealing.
    for(int i=0;i<m;i++)
    if(op[i]=='M')
        Merge(a[i],b[i]);
    
    //tag nodes' value.
    for(int i=0;i<n;i++)
    if(v[i]==0)
    {
        int cnt=0;
        for(int j=L[C[i]];j!=-1;j=nxt[j])
        v[j]=++cnt;
    }
    
    INIT(n);
    
    //second operations dealing.
    for(int i=0;i<m;i++)
    {
        if(op[i]=='M')
            Merge(a[i],b[i]);
        else
        {
            if(C[a[i]]==C[b[i]])
            printf("%d\n",abs(v[a[i]]-v[b[i]])-1);
            else
            printf("-1\n");
        }
    }
    
    return 0;
}

做法就是对每一条链维护一个"中心节点",这个节点存储了链的总结点数,链的左端点和链的右端点.

合并的时候把这些存储的值的转移安排好就行了.......

实在不懂就看代码......

千万注意Merge函数中nxt数组赋值的顺序......

next数组的值一定要在cx赋值完毕以后修改,不然赋值操作会把一整个集合扫一遍!....

这样总时间复杂度就是O(n^2)的了....害我T了一发 TAT

AC BZOJ 1483 又是按秩合并.....

全都是调试用的注释的版本

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
typedef long double ldb;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while((c<'0' || c>'9')/* && !feof(stdin)*/) mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9'/* && !feof(stdin)*/) res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


int C[105000];    //color array.
int N[1005000]; //store the amount of same-color node.
int F[105000]; //father(center) node of this color
int L[105000]; //what color do this node actually have.
int R[105000]; //root of a chain. 

int p[1005000]; //pointer to the previous same-color node.
int t[1005000]; //true color of "color code".

int n,m;
int res;

void ChangeColor(int i,int color)
{
    if(C[i-1]!=C[i] && C[i-1]==color) res--;
    if(C[i+1]!=C[i] && C[i+1]==color) res--;
    if(C[i-1]==C[i] && C[i-1]!=color) res++;
    if(C[i+1]==C[i] && C[i+1]!=color) res++;
    C[i]=color;
}


int main()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    
    n=getint();
    m=getint();
    C[0]=C[n+1]=-1;
    for(int i=1;i<=n;i++) N[C[i]=getint()]++;
    for(int i=1;i<=n;i++) res+=( C[i]!=C[i-1] );
    for(int i=1;i<=n;i++) { F[i]=p[C[i]]; p[C[i]]=i; }
    for(int i=1;i<=n;i++) R[i]=( F[i] ? R[F[i]]:i );
    
    for(int i=0;i<=1000000;i++) t[i]=i;
    
    //for(int i=1;i<=n;i++) 
    //printf("i:%d color:%d f:%d cnt:%d root:%d l:%d\n",i,C[i],F[i],N[i],R[i],L[i]);
    
    
    //printf("p:");for(int i=1;i<9;i++) printf("%d ",p[i]); printf("\n");
    //printf("t:");for(int i=1;i<9;i++) printf("%d ",t[i]); printf("\n");
    //printf("C:");for(int j=1;j<=n;j++) printf("%d ",C[j]); printf("\n");
    
    for(int i=0;i<m;i++)
    {
        int c=getint();
        if(c==1)
        {
            int a=getint();
            int b=getint(); //change all color a into b.
            if(a==b) continue;
            //printf("true color of %d is %d\ntrue color of %d is %d\n",a,t[a],b,t[b]);
            if(N[t[a]]>N[t[b]]) swap(t[a],t[b]);
            //printf("change color %d[%d] to %d[%d]\n",t[a],R[p[t[a]]],t[b],R[p[t[b]]]);
            a=t[a]; b=t[b];
            
            int x=p[a],y=p[b]; if(!p[a]) goto FINAL; //continue;
            printf("%d %d\n",x,y);
            N[b]+=N[a]; N[a]=0; p[a]=0; p[b]=x;
            while(F[x]){ R[x]=R[y]; ChangeColor(x,b); x=F[x]; }
            R[x]=R[y]; ChangeColor(x,b); F[x]=y;
        }
        else if(c==2) printf("%d\n",res);
        
        /*
        FINAL: if(c!=2) {
        for(int i=1;i<=n;i++) if(p[t[i]]){ printf("color:%d .",t[i]); 
        for(int j=p[t[i]];j;j=F[j])printf("->%d",j);  printf("\n");}
        printf("p:");for(int i=1;i<=n;i++) printf("%d ",p[i]); printf("\n");
        printf("t:");for(int i=1;i<=n;i++) printf("%d ",t[i]); printf("\n");
        printf("C:");for(int j=1;j<=n;j++) printf("%d ",C[j]); printf("\n"); }
        */
    }
    
    
    return 0;
}


/*
10 2
1 2 1 3 3 1 1 2 2 1
1 2
2 3
*/

不带注释的版本

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
typedef long double ldb;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while((c<'0' || c>'9')/* && !feof(stdin)*/) mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9'/* && !feof(stdin)*/) res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


int C[105000];    //color array.
int N[1005000]; //store the amount of same-color node.
int F[105000]; //father(center) node of this color
int L[105000]; //what color do this node actually have.
int R[105000]; //root of a chain. 

int p[1005000]; //pointer to the previous same-color node.
int t[1005000]; //true color of "color code".

int n,m;
int res;

void ChangeColor(int i,int color)
{
    if(C[i-1]!=C[i] && C[i-1]==color) res--;
    if(C[i+1]!=C[i] && C[i+1]==color) res--;
    if(C[i-1]==C[i] && C[i-1]!=color) res++;
    if(C[i+1]==C[i] && C[i+1]!=color) res++;
    C[i]=color;
}


int main()
{
    n=getint();
    m=getint();
    C[0]=C[n+1]=-1;
    for(int i=1;i<=n;i++) N[C[i]=getint()]++;
    for(int i=1;i<=n;i++) res+=( C[i]!=C[i-1] );
    for(int i=1;i<=n;i++) { F[i]=p[C[i]]; p[C[i]]=i; }
    for(int i=1;i<=n;i++) R[i]=( F[i] ? R[F[i]]:i );
    
    for(int i=0;i<=1000000;i++) t[i]=i;
    
    for(int i=0;i<m;i++)
    {
        int c=getint();
        if(c==1)
        {
            int a=getint();
            int b=getint();
            if(a==b) continue;
            if(N[t[a]]>N[t[b]]) swap(t[a],t[b]);
            a=t[a]; b=t[b];
            
            int x=p[a],y=p[b]; if(!p[a]) continue;
            N[b]+=N[a]; N[a]=0; p[a]=0; p[b]=x;
            while(F[x]){ R[x]=R[y]; ChangeColor(x,b); x=F[x]; }
            R[x]=R[y]; ChangeColor(x,b); F[x]=y;
        }
        else if(c==2) printf("%d\n",res);

    }
    
    return 0;
}

按秩合并呢,总结起来两点:

1.如何存储集合的大小; 2.如何合并两条链.

存储集合的大小,可以直接对每条链维护一个中央节点来存储,然后合并的时候注意一下把数据合并过去.

也可以用一种集合的对应关系(在本题中是颜色)来快速存储与合并.

合并两条链,先把a(我们把较小的那条链叫做a)的全局数据(比如链长)合并到b(另外一条链).

然后扫描a,每扫描到一个点就把它的数据(比如中央节点指针)改掉.

链a的末尾节点要特别处理,把链a末尾接到链b上(或把链b末尾接到链a上).

然后把b的链头改成a的链头,再把a的链头置空(或把a的链头改成b的链头,两个链头都不置空).

链头是否置空以及是否能够左右两次合并要依照题目来看.

 ....