BZOJ3159: 决战（FHQ Treap）

传送门：

解题思路：

算是补坑了，这题除了Invert以外就可以树剖线段树解决了。

考虑Invert操作，延续先前树链剖分的做法，考虑先前算法的瓶颈。

最暴力的方法是暴力交换权值，然而这种方法忽略了当前树链剖分序的一个性质，那就是很多部分的树链是连续的，而且仅有$O(lg n)$个区间。

考虑只有一个区间的做法，就很显然是区间翻转（这个不会搞的话你是怎么做到这道题的），于是，由于区间个数并不多，我们大胆猜想：正确的解法就是考虑翻如何转这些不连续区间

由于链区间具有一定的连续性，且我们需要翻转其权值，考虑更换我们所使用的数据结构，Splay和FHQ Treap都可以，我个人更倾向于使用后者（因为好写）。

现在问题瓶颈就是如何翻转不连续的区间权值。

其实方法很简单，将这$O(lg n)$个拼接在一起，翻转，再重新安回去，很显然这样做的时间复杂度是$O((lg n)^2))$的。

考虑具体的操作，由于下标索引在拆树的时候可能改变非常恶心，所以我们预处理出x-y中所有链区间，按dfs序排序，倒着拆，把x到lca上的树链翻转后拼接，再与y到lca上的树链翻转。最后再翻转，正着安回去。

大概就可以愉快地AC了。

代码：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define lll tr[spc].ls
#define rrr tr[spc].rs
typedef long long lnt;
struct chain{
    int ind;
    int len;
    bool x;
}ch[100010];
struct trnt{
    int ls,rs;
    int lzt;
    int wgt;
    int rnd;
    lnt lzta;
    lnt val;
    lnt sum;
    lnt maxval,minval;
    void rediff(int seed){
        ls=rs=lzt=0;
        lzta=val=sum=maxval=minval=0;
        rnd=seed+rand()%500+1;
        wgt=1;
        return ;
    }
}tr[1000010];
struct pnt{
    int hd;
    int fa;
    int tp;
    int dep;
    int ind;
    int mxs;
    int wgt;
}p[100010];
struct ent{
    int twd;
    int lst;
}e[100010];
int cnt;
int siz;
int dfn;
int top;
int n,m,r;
char cmd[100];
int rootl,rootr,rootm,root;
int pos[100010],size[100010];
int cmp(chain a,chain b){
    return a.ind<b.ind;
}
void ade(int f,int t){
    cnt++;
    e[cnt].twd=t;
    e[cnt].lst=p[f].hd;
    p[f].hd=cnt;
    return ;
}
void push_up(int spc){
    tr[spc].wgt=1;
    tr[spc].minval=tr[spc].maxval=tr[spc].sum=tr[spc].val;
    if(lll){
        tr[spc].wgt+=tr[lll].wgt;
        tr[spc].sum+=tr[lll].sum;
        tr[spc].minval=std::min(tr[spc].minval,tr[lll].minval);
        tr[spc].maxval=std::max(tr[spc].maxval,tr[lll].maxval);
    }
    if(rrr){
        tr[spc].wgt+=tr[rrr].wgt;
        tr[spc].sum+=tr[rrr].sum;
        tr[spc].minval=std::min(tr[spc].minval,tr[rrr].minval);
        tr[spc].maxval=std::max(tr[spc].maxval,tr[rrr].maxval);
    }
    return ;
}
void add(int spc,lnt val){
    if(!spc){
        return ;
    }
    tr[spc].val+=val;
    tr[spc].lzta+=val;
    tr[spc].maxval+=val;
    tr[spc].minval+=val;
    tr[spc].sum+=val*tr[spc].wgt;
    return ;
}
void trr(int spc){
    if(!spc){
        return ;
    }
    std::swap(lll,rrr);
    tr[spc].lzt^=1;
    return ;
}
void push_down(int spc){
    if(tr[spc].lzt){
        trr(lll);
        trr(rrr);
        tr[spc].lzt=0;
    }
    if(tr[spc].lzta){
        add(lll,tr[spc].lzta);
        add(rrr,tr[spc].lzta);
        tr[spc].lzta=0;
    }
    return ;
}
void build(int l,int r,int &spc,int seed){
    if(l>r){
        return ;
    }
    int mid=(l+r)>>1;
    spc=++siz;
    tr[spc].rediff(seed);
    build(l,mid-1,lll,tr[spc].rnd);
    build(mid+1,r,rrr,tr[spc].rnd);
    push_up(spc);
    return ;
}
void split(int spc,int &ll,int &rr,int k){
    if(!spc){
        ll=rr=0;
        return ;
    }
    push_down(spc);
    if(tr[lll].wgt<k){
        ll=spc;
        split(rrr,rrr,rr,k-tr[lll].wgt-1);
    }else{
        rr=spc;
        split(lll,ll,lll,k);
    }
    push_up(spc);
    return ;
}
int merge(int ll,int rr){
    if(!ll||!rr){
        return ll|rr;
    }else{
        if(tr[ll].rnd<tr[rr].rnd){
            push_down(ll);
            tr[ll].rs=merge(tr[ll].rs,rr);
            push_up(ll);
            return ll;
        }else{
            push_down(rr);
            tr[rr].ls=merge(ll,tr[rr].ls);
            push_up(rr);
            return rr;
        }
    }
    return 0;
}
void Basic_dfs(int x,int f){
    p[x].fa=f;
    p[x].wgt=1;
    p[x].dep=p[f].dep+1;
    int maxs(-1);
    for(int i=p[x].hd;i;i=e[i].lst){
        int to=e[i].twd;
        if(to==f){
            continue;
        }
        Basic_dfs(to,x);
        p[x].wgt+=p[to].wgt;
        if(p[to].wgt>maxs){
            p[x].mxs=to;
            maxs=p[to].wgt;
        }
    }
    return ;
}
void Build_dfs(int x,int t){
    if(!x){
        return ;
    }
    p[x].tp=t;
    p[x].ind=++dfn;
    Build_dfs(p[x].mxs,t);
    for(int i=p[x].hd;i;i=e[i].lst){
        int to=e[i].twd;
        if(p[to].ind){
            continue;
        }
        Build_dfs(to,to);
    }
    return ;
}
void Increase(int x,int y,lnt z){
    while(p[x].tp!=p[y].tp){
        if(p[p[x].tp].dep<p[p[y].tp].dep){
            std::swap(x,y);
        }
        int S(p[p[x].tp].ind-1),T(p[x].ind);
        split(root,rootl,rootr,T);
        split(rootl,rootl,rootm,S);
        add(rootm,z);
        root=merge(rootl,merge(rootm,rootr));
        x=p[p[x].tp].fa;
        
    }
    if(p[x].dep>p[y].dep){
        std::swap(x,y);
    }
    int S(p[x].ind-1),T(p[y].ind);
    split(root,rootl,rootr,T);
    split(rootl,rootl,rootm,S);
    add(rootm,z);
    root=merge(rootl,merge(rootm,rootr));
    return ;
}
void Invert(int x,int y){
    top=0;
    if(p[x].ind>p[y].ind){
        std::swap(x,y);
    }
    int lca(r);
    int tmpx(x),tmpy(y);
    while(p[x].tp!=p[y].tp){
        if(p[p[x].tp].dep>p[p[y].tp].dep){
            top++;
            ch[top].ind=p[p[x].tp].ind;
            ch[top].len=p[x].ind-p[p[x].tp].ind+1;
            ch[top].x=true;
            x=p[p[x].tp].fa;
        }else{
            top++;
            ch[top].ind=p[p[y].tp].ind;
            ch[top].len=p[y].ind-p[p[y].tp].ind+1;
            ch[top].x=false;
            y=p[p[y].tp].fa;
        }
    }
    if(p[x].dep<=p[y].dep){
        top++;
        ch[top].ind=p[x].ind;
        ch[top].len=p[y].ind-p[x].ind+1;
        ch[top].x=false;
    }else{
        top++;
        ch[top].ind=p[y].ind;
        ch[top].len=p[x].ind-p[y].ind+1;
        ch[top].x=true;
    }
    std::sort(ch+1,ch+top+1,cmp);
    int tmptop(top);
    int root_(0);
    while(top){
        int S(ch[top].ind-1),T(ch[top].ind+ch[top].len-1);
        split(root,rootl,rootr,T);
        split(rootl,rootl,rootm,S);
        root=merge(rootl,rootr);
        if(ch[top].x){
            trr(rootm);
        }
        root_=merge(rootm,root_);
        top--;
    }
    trr(root_);
    top=1;
    while(top<=tmptop){
        int S(ch[top].ind-1);
        split(root,rootl,rootr,S);
        split(root_,rootm,root_,ch[top].len);
        if(ch[top].x){
            trr(rootm);
        }
        root=merge(rootl,merge(rootm,rootr));
        top++;
    }
    return ;
}
lnt Sum(int x,int y){
    lnt ans(0);
    while(p[x].tp!=p[y].tp){
        if(p[p[x].tp].dep<p[p[y].tp].dep){
            std::swap(x,y);
        }
        int S(p[p[x].tp].ind-1),T(p[x].ind);
        split(root,rootl,rootr,T);
        split(rootl,rootl,rootm,S);
        ans=ans+tr[rootm].sum;
        root=merge(rootl,merge(rootm,rootr));
        x=p[p[x].tp].fa;
    }
    if(p[x].dep>p[y].dep){
        std::swap(x,y);
    }
    int S(p[x].ind-1),T(p[y].ind);
    split(root,rootl,rootr,T);
    split(rootl,rootl,rootm,S);
    ans=ans+tr[rootm].sum;
    root=merge(rootl,merge(rootm,rootr));
    return ans;
}
lnt Major(int x,int y){
    lnt ans(-0x3f3f3f3f3f3fll);
    while(p[x].tp!=p[y].tp){
        if(p[p[x].tp].dep<p[p[y].tp].dep){
            std::swap(x,y);
        }
        int S(p[p[x].tp].ind-1),T(p[x].ind);
        split(root,rootl,rootr,T);
        split(rootl,rootl,rootm,S);
        ans=std::max(ans,tr[rootm].maxval);
        root=merge(rootl,merge(rootm,rootr));
        x=p[p[x].tp].fa;
    }
    if(p[x].dep>p[y].dep){
        std::swap(x,y);
    }
    int S(p[x].ind-1),T(p[y].ind);
    split(root,rootl,rootr,T);
    split(rootl,rootl,rootm,S);
    ans=std::max(ans,tr[rootm].maxval);
    root=merge(rootl,merge(rootm,rootr));
    return ans;
}
lnt Minor(int x,int y){
    lnt ans(0x3f3f3f3f3f3fll);
    while(p[x].tp!=p[y].tp){
        if(p[p[x].tp].dep<p[p[y].tp].dep){
            std::swap(x,y);
        }
        int S(p[p[x].tp].ind-1),T(p[x].ind);
        split(root,rootl,rootr,T);
        split(rootl,rootl,rootm,S);
        ans=std::min(ans,tr[rootm].minval);
        root=merge(rootl,merge(rootm,rootr));
        x=p[p[x].tp].fa;
    }
    if(p[x].dep>p[y].dep){
        std::swap(x,y);
    }
    int S(p[x].ind-1),T(p[y].ind);
    split(root,rootl,rootr,T);
    split(rootl,rootl,rootm,S);
    ans=std::min(ans,tr[rootm].minval);
    root=merge(rootl,merge(rootm,rootr));
    return ans;
}
void pia(int spc){
    if(!spc){
        return ;
    }
    push_down(spc);
    pia(lll);
    printf("%lld ",tr[spc].val);
    pia(rrr);
    return ;
}
int main(){
    scanf("%d%d%d",&n,&m,&r);
    for(int i=1;i<=n;++i){
        int a,b;
        scanf("%d%d",&a,&b);
        ade(a,b);
        ade(b,a);
    }
    build(1,n,root,0);
    Basic_dfs(r,r);
    Build_dfs(r,r);
    int pro(0);
    while(m--){
        int x,y,z;
        scanf("%s",cmd+1);
        if(cmd[1]=='I'){
            if(cmd[3]=='c'){
                scanf("%d%d%d",&x,&y,&z);
                Increase(x,y,lnt(z));
            }
            if(cmd[3]=='v'){
                scanf("%d%d",&x,&y);
                Invert(x,y);
            }
        }
        if(cmd[1]=='S'){
            scanf("%d%d",&x,&y);
            printf("%lld
",Sum(x,y));
        }
        if(cmd[1]=='M'){
            if(cmd[2]=='a'){
                scanf("%d%d",&x,&y);
                printf("%lld
",Major(x,y));
            }
            if(cmd[2]=='i'){
                scanf("%d%d",&x,&y);
                printf("%lld
",Minor(x,y));
            }
        }
    }
    return 0;
}