bzoj 3615: MSS

Description

　小C正在出一道题...因为语文水平有限他想不出复杂的背景，所以以下就是题意了。
　　平面上有N个点，开始时每个点属于一个不同的集合。不妨设点P_i属于集合S_i。请维护数据结构支持以下三种操作：
　　"Merge x y"：将集合S_y中的点到S_x中；
　　"Split i d v"（d ∈ {0, 1}）：创建新集合S_c + 1，S_c + 2，之后将集合S_i中的所有点中，第d维坐标不超过v的到集合S_c + 1中，超过v的移动到集合S_c + 2中，其中c为现有集合数（ 包括之前合并和分割中产生的空集 ）；
　　"Query i"：查询集合S_i中点权值的最大值，最小值及和；
　　"Add i d"：将集合S_i中所有点的权值增加d。
　　方便起见，对于d ∈ {0, 1}，输入的所有点的第d维坐标不重复。所有操作涉及的集合非空。

Input

　　第一行一个整数N表示点数。
　　接下来N行，每行3个整数分别表示P_i的坐标与权值。
　　接下来一个整数Q表示操作数。
　　接下来Q行，每行描述一个操作，格式如上所述。

Output

　　对于每个Q操作，输出三个整数，依次表示询问集合权值的最大值，最小值与和。

预处理出点集的一颗二维k-d tree

将每个点到根的路径复制出来作为初始状态

由于树形态相同，合并和分裂可以仿照线段树

分裂时增加的点数$T(n)=2T(\frac{n}{4})+O(1)=O(\sqrt{n})$

合并复杂度与减少的点数同阶

因此总时间复杂度$O(q\sqrt{n})$

由每个点到根的路径长度之和可得空间复杂度的上界$O(nlogn)$

#include<bits/stdc++.h>
#define G getchar()
int _(){
    int x=,f=,c=G;
    while(c<)c=='-'&&(f=-),c=G;
    while(c>)x=x*+c-,c=G;
    return x*f;
}
int _s(){
    int c=G,c0;
    while(c<)c=G;
    c0=c;
    while(c>)c=G;
    return c0;
}
int min(int a,int b){return a<b?a:b;}
int max(int a,int b){return a>b?a:b;}
const int N=,inf=0x3f3f3f3f;
int n,qp;
struct node;
node*newnode();
struct node{
    node*c[];
    int mn[],mx[];
    int mnv,mxv,sz,id;
    long long sum,a;
    void add(long long x){
        if(this){
            a+=x;
            mnv+=x;
            mxv+=x;
            sum+=x*sz;
        }
    }
    void dn(){
        if(a){
            c[]->add(a);
            c[]->add(a);
            a=;
        }
    }
    void up(){
        mnv=inf;mxv=-inf;sum=;
        sz=;
        if(c[]){
            mnv=c[]->mnv;
            mxv=c[]->mxv;
            sum=c[]->sum;
            sz=c[]->sz;
        }
        if(c[]){
            mnv=min(mnv,c[]->mnv);
            mxv=max(mxv,c[]->mxv);
            sum+=c[]->sum;
            sz+=c[]->sz;
        }
    }
    void set(int x0,int x1,int v){
        mn[]=mx[]=x0;
        mn[]=mx[]=x1;
        sum=mnv=mxv=v;
        sz=;a=;
    }
    void query(){
        printf("%d %d %lld\n",mxv,mnv,sum);
    }
    void upds(){
        for(int i=;i<;++i){
            mn[i]=min(c[]->mn[i],c[]->mn[i]);
            mx[i]=max(c[]->mx[i],c[]->mx[i]);
        }
    }
}mem[N*],*pool[N*],*rt0,*n0[N],*rts[N*];
int pp;
node*newnode(){
    return pool[--pp];
}
int dx=;
bool cmp(node*a,node*b){
    return a->mn[dx]<b->mn[dx];
}
node*build(int L,int R){
    if(L==R)return n0[L];
    int M=(L+R)>>;
    std::nth_element(n0+L,n0+M,n0+R+,cmp);
    node*w=newnode();
    dx^=;
    w->c[]=build(L,M);
    w->c[]=build(M+,R);
    w->upds();
    dx^=;
    return w;
}
node*ss[];
int sp=;
void init(node*w){
    ss[sp++]=w;
    if(w->id){
        node*t=w;
        for(int i=sp-;~i;--i){
            node*u=newnode();
            *u=*ss[i];
            int d=u->c[]==ss[i+];
            u->c[d]=t;
            u->c[d^]=;
            u->up();
            t=u;
        }
        rts[w->id]=t;
    }else{
        init(w->c[]);
        init(w->c[]);
    }
    --sp;
}
int _x,_d;
void split(node*w,node*&l,node*&r){
    if(!w)l=r=;
    else if(_x<w->mn[_d])l=,r=w;
    else if(w->mx[_d]<=_x)l=w,r=;
    else{
        w->dn();
        node*u=newnode();
        *u=*w;
        split(w->c[],w->c[],u->c[]);
        split(w->c[],w->c[],u->c[]);
        w->up();u->up();
        l=w,r=u;
    }
}
node*merge(node*a,node*b){
    if(!a)return b;
    if(!b)return a;
    a->dn();b->dn();
    a->c[]=merge(a->c[],b->c[]);
    a->c[]=merge(a->c[],b->c[]);
    a->up();
    pool[pp++]=b;
    return a;
}
int main(){
    n=_();
    pp=n*;
    for(int i=;i<pp;++i)pool[i]=mem+i;
    for(int i=,x,y;i<=n;++i){
        x=_();y=_();
        n0[i]=newnode();
        n0[i]->set(x,y,_());
        n0[i]->id=i;
    }
    rt0=build(,n);
    init(rt0);
    for(qp=_();qp;--qp){
        int o=_s();
        if(o=='M'){
            int x=_(),y=_();
            rts[x]=merge(rts[x],rts[y]);
            rts[y]=;
        }else if(o=='S'){
            int x=_();
            _d=_();_x=_();
            split(rts[x],rts[n+],rts[n+]);
            rts[x]=;
            n+=;
        }else if(o=='Q'){
            rts[_()]->query();
        }else{
            int x=_();
            rts[x]->add(_());
        }
    }
    return ;
}