[poj2985]The k-th Largest Group[Treap]

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>

using namespace std;

class    Treap
{
    private:
        struct    Treap_Point
        {
            int    l,r,val,size,key,num;
            Treap_Point() { l=r=val=size=key=num=0; }
        };
        typedef    Treap_Point    P;
        P    d[210000];
        int    root,cnt;

        void    update(const int t)
        {
            d[t].size=d[d[t].l].size+
                d[d[t].r].size+d[t].num;
            return ;
        }

        void    rturn(int & t)
        {
            int    temp=d[t].l; d[t].l=d[temp].r; d[temp].r=t;
            d[temp].size=d[t].size; update(t);t=temp; return ;
        }

        void    lturn(int & t)
        {
            int    temp=d[t].r; d[t].r=d[temp].l; d[temp].l=t;
            d[temp].size=d[t].size; update(t);t=temp; return ;
        }

        void    insert(int & t,const int x)
        {
            if(!t)
            {
                cnt++;t=cnt;
                d[t].size=d[t].num=1;d[t].val=x;
                d[t].key=rand();
                return ;
            }
            d[t].size++;
            if(d[t].val==x)d[t].num++;
            else if(x>d[t].val)
            {
                insert(d[t].r,x);
                if(d[d[t].r].key<d[t].key)lturn(t);
            }
            else
            {
                insert(d[t].l,x);
                if(d[d[t].l].key<d[t].key)rturn(t);
            }
            return ;
        }

        void    erase(int & t,const int x)
        {
            if(!t)return ;
            if(d[t].val==x)
            {
                if(d[t].num>1)
                {
                    d[t].num--;d[t].size--;return ;
                }
                if(d[t].l*d[t].r==0)t=d[t].l+d[t].r;
                else if(d[d[t].l].key<d[d[t].r].key)
                    rturn(t),erase(t,x);
                else    lturn(t),erase(t,x);
            }
            else if(x>d[t].val)d[t].size--,erase(d[t].r,x);
            else    d[t].size--,erase(d[t].l,x);
            return ;
        }

        int    get(const int & t,const int x)
        {
            if(t==0)return 0;
            if(x<=d[d[t].l].size)
                return get(d[t].l,x);
            else if(x>d[d[t].l].size+d[t].num)
                return get(d[t].r,x-d[d[t].l].size-d[t].num);
            return d[t].val;
        }
    public:
        Treap() { root=0;cnt=0; }

        void    insert(const int x) { insert(root,x); }
        void    erase(const int x) { erase(root,x); }
        int    get(const int x) { return get(root,x); }
};

int    n,m;
int    fa[210000],Size[210000];
Treap    S;

int    get_anc(const int x)
{
    return fa[x]==x ? x:fa[x]=get_anc(fa[x]);
}

int main()
{
    int    i,op,x,y,a,b;

    scanf("%d%d",&n,&m);

    for(i=1;i<=n;++i)fa[i]=i,S.insert(-1),Size[i]=1;
    
    for(i=1;i<=m;++i)
    {
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d",&x);
            printf("%d
",-S.get(x));
        }
        else
        {
            scanf("%d%d",&x,&y);
            a=get_anc(x),b=get_anc(y);
            if(a==b)continue;
            else
            {
                S.erase(-Size[a]);
                S.erase(-Size[b]);
                S.insert(-Size[a]-Size[b]);
                fa[a]=b;
                Size[b]+=Size[a];
            }
        }
    }

    return 0;
}