uoj 55 紫荆花之恋 动态点分治+替罪羊式重构+treap

每插入一个点，直接把它当做重心插入原树，当做是动态点分树一样维护

但这样深度会越来越大，所以我们用类似替罪羊的方法

当树失去平衡时，对子树进行一次点分，保证复杂度

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cctype>
using namespace std;
typedef long long LL;
const int M=100007;
const int N=M*80;
double alpha=0.7;
inline int rd(){
    int x=0;bool f=1;char c=getchar();
    for(;!isdigit(c);c=getchar())if(c=='-')f=0;
    for(;isdigit(c);c=getchar())x=x*10+c-48;
    return x;
}

LL w[M];

struct Pool{
    int mempool[N],tot;
    Pool(){
        for(int i=1;i<N;i++) mempool[i]=i;
        tot=0;
    }
    int newmem(){
        return mempool[++tot];
    }
    int delmem(int x){
        mempool[tot--]=x;
    }
}pool1,pool2,pool3;

int g[M],te;
struct edge{
    int y,next;
    LL d;
}e[M<<1];
void addedge(int x,int y,LL d){
    e[++te].y=y;
    e[te].d=d;
    e[te].next=g[x];
    g[x]=te;
}

struct uppp{//不同于前两题，all放在外面维护了
//多维护点分root（fa）+在fa的哪个儿子的子树下（fson）
    int sub;
    int fa,fson;
    LL dis;
    int next;
}up[N];
int hd[M],tu;
void addup(int x,int sub,int fa,int fson,LL dis){
    tu=pool1.newmem();
    up[tu].sub=sub;
    up[tu].fa=fa;
    up[tu].fson=fson;
    up[tu].dis=dis;
    up[tu].next=hd[x];
    hd[x]=tu;
}

int n;
int idsub,idrt,ifa,ifson;
int all[M];//子树信息，动态维护点分树的话这样写方便
int que[M];

int T=0;
int vis[M],sz[M];
int size,mi,rt;

int lc[N],rc[N],cnt[N],fix[N];
LL val[N];
struct treap{
    int siz,root;
    treap(){siz=root=0;}
    void del(int x){
        if(!x) return;
        pool2.delmem(x);
        del(lc[x]);
        del(rc[x]);
    }
    void delet(){
        del(root);
        root=0;
        siz=0;
    }
    int newnode(LL d){
        int x=pool2.newmem();
        lc[x]=rc[x]=0;
        cnt[x]=1;
        val[x]=d;
        fix[x]=rand();
        return x;
    }
    void update(int x){
        cnt[x]=1;
        if(lc[x]) cnt[x]+=cnt[lc[x]];
        if(rc[x]) cnt[x]+=cnt[rc[x]];
    }
    void rotl(int &x){
        int k=rc[x];
        rc[x]=lc[k];
        lc[k]=x;
        update(x);
        update(k);
        x=k;
    }
    void rotr(int &x){
        int k=lc[x];
        lc[x]=rc[k];
        rc[k]=x;
        update(x);
        update(k);
        x=k;
    }
    void insert(int &x,LL d){
        if(!x){
            x=newnode(d);
            return;
        }
        cnt[x]++;
        if(d<=val[x]){
            insert(lc[x],d);
            if(fix[lc[x]]<fix[x])rotr(x);
        }
        else{
            insert(rc[x],d);
            if(fix[rc[x]]<fix[x])rotl(x);
        }
    }
    void ins(LL d){
        insert(root,d);
        siz++;
    }
    int query(int x,LL d){
        if(!x) return 0;
        if(d<val[x]) return query(lc[x],d);
        return cnt[lc[x]]+1+query(rc[x],d);
    }
    LL get(LL d){
        return query(root,d);
    }
}a[N];

void clear(int x,int fa){
    int p,y;

    p=hd[x];

    //清空treap时每个点把它到父亲那两个treap清空就可以了
    if(p&&vis[up[p].fa]!=T){
        a[up[p].sub].delet();
        pool3.delmem(up[p].sub);
    }
    a[all[x]].delet();
    pool3.delmem(all[x]);

    //把需要清的静链清掉
    for(p=hd[x];p&&vis[up[p].fa]!=T;p=up[p].next)
        pool1.delmem(p);
    hd[x]=p;

    for(p=g[x];p;p=e[p].next)
    if(vis[y=e[p].y]!=T&&y!=fa){
        clear(y,x);
    }
}

void getsz(int x,int fa){
    sz[x]=1;
    int p,y;
    for(p=g[x];p;p=e[p].next)
    if(vis[y=e[p].y]!=T&&y!=fa){
        getsz(y,x);
        sz[x]+=sz[y];
    }
}

void getrt(int x,int fa){
    int f,p,y;
    f=size-sz[x];
    for(p=g[x];p;p=e[p].next)
    if(vis[y=e[p].y]!=T&&y!=fa){
        getrt(y,x);
        f=max(f,sz[y]);
    }
    if(f<mi) mi=f,rt=x;
}

void dfs(int x,int fa,LL dis){
    addup(x,idsub,ifa,ifson,dis);
    a[idrt].ins(dis-w[x]);
    a[idsub].ins(dis-w[x]);
    int p,y;
    for(p=g[x];p;p=e[p].next)
        if(vis[y=e[p].y]!=T&&y!=fa) dfs(y,x,dis+e[p].d);
}

void work(int frm){
    getsz(frm,0);
    mi=size=sz[frm];
    getrt(frm,0);
    int x=rt,p,y;
    vis[x]=T;
    ifa=x;
    all[x]=idrt=pool3.newmem();
    a[all[x]].ins(-w[x]);
    for(p=g[x];p;p=e[p].next)
    if(vis[y=e[p].y]!=T){
        idsub=pool3.newmem();
        ifson=y;
        dfs(y,x,e[p].d);
    }
    for(p=g[x];p;p=e[p].next)
        if(vis[y=e[p].y]!=T) work(y);
}

void rebuild(int x){
    clear(x,0);
    work(x);
}

void link(int x,int y,LL d){
    if(y==0){
        all[x]=pool3.newmem();
        a[all[x]].ins(-w[x]);
        return;
    }

    addedge(x,y,d);
    addedge(y,x,d);

    int p;
    //暴力插入
    all[x]=pool3.newmem();
    a[all[x]].ins( -w[x] );

    int tmpt=0;
    for(p=hd[y];p;p=up[p].next) que[++tmpt]=p;
    for(int i=tmpt;i>0;i--){//保证链的搜索顺序还是从下到上
        p=que[i];
        addup(x,up[p].sub,up[p].fa,up[p].fson,d+up[p].dis);
        a[all[up[p].fa]].ins( d+up[p].dis-w[x] );
        a[up[p].sub].ins( d+up[p].dis-w[x] );
    }
    //x-y
    int nw=pool3.newmem();
    addup(x,nw,y,x,d);
    a[all[y]].ins( d-w[x] );
    a[nw].ins( d-w[x] );

    //判断是否要重构
    int reb=0;
    for(p=hd[y];p;p=up[p].next){
        if((double)a[all[up[p].fa]].siz*alpha<(double)a[up[p].sub].siz)
            reb=up[p].fa;
    }

    if(reb){
        T++;//时间戳
        for(p=hd[reb];p;p=up[p].next)//***
            vis[up[p].fa]=T;
        rebuild(reb);
    }

}

LL get(int x){
    LL res=a[all[x]].get(w[x]);
    for(int p=hd[x];p;p=up[p].next){
        res+=a[all[up[p].fa]].get(w[x]-up[p].dis);
        res-=a[up[p].sub].get(w[x]-up[p].dis);
    }
    return res;
}

int main(){
    int i,x,y,z,tt;
    LL res=0;
    n=rd();//滤掉测试点
    n=rd();
    for(i=1;i<=n;i++){
        tt=res%1000000000;
        x=rd()^tt;
        y=rd();
        w[i]=rd();
        link(i,x,y);
        res+=get(i)-1;
        printf("%lld\n",res);
    }
    return 0;
}