bzoj3600: 没有人的算术

题意：太难说了。。手动去看吧反正不是权限题。

膜拜VFK大爷的神题！

其实一开始思路挺清楚的，如果我们能做到用一个实数去代表“数”，这就是裸的动态区间最值查询。

关键是怎么用实数去表示。如果我们单纯的把两个数进行O（1）运算去得到一个实数，这样很轻松就会被卡掉，因为无论是longlong还是double都是有限度的。怎么做呢？

这里有一个技巧：我们维护一个重量平衡树，每个节点管辖一个区间，这个区间的中位数为这个点的权值，而它的左儿子管辖左半边，右儿子管辖右半边。

问题来了，这不是差不多吗？并不是这样。因为我们会重构，树高有保证，所以我们肯定能表示出每一个数，而且还是绰绰有余。

重量平衡树可以用不旋转的treap或替罪羊树。

（吐槽一句，第一次写替罪羊树，真的好TM难写啊还套了个线段树而且我常数大的飞起，写了一整天）

#include<bits/stdc++.h>
using namespace std;
#define N 500005
#define LL long long
inline LL read(){
    LL x=0,f=1; char a=getchar();
    while(a<'0' || a>'9') {if(a=='-') f=-1; a=getchar();}
    while(a>='0' && a<='9') x=x*10+a-'0',a=getchar();
    return x*f;
}
int n,m; char st[5];
LL MX;
#define SGT Scapegoat_Tree
#define ST Segment_Tree

namespace Scapegoat_Tree{
    #define eps 1e-12
    const double alpha=0.75;
    int ltst,wh,size=1,tmp[N],root=1,anew;
    struct sgt{
        LL l,r,mid; int fir,sec;
        int son[2],sz;
    }tr[N];
    inline int dcmp(int x,int y){
        if(fabs((double)tr[x].sz*alpha-(double)tr[y].sz)<eps) return 0;
        else return (double)tr[x].sz*alpha>(double)tr[y].sz?1:-1;
    }
    inline void update(int x){
        tr[x].sz=tr[tr[x].son[0]].sz+tr[tr[x].son[1]].sz+1;
    }
    inline bool balance(int x){
        return dcmp(x,tr[x].son[0])>=0 && dcmp(x,tr[x].son[1])>=0;
    }
    void travel(int x){
        if(!x) return;
        travel(tr[x].son[0]);
        tmp[++tmp[0]]=x;
        travel(tr[x].son[1]);
    }
    void rebuild(int &x,int l,int r,LL L,LL R){
        if(l>r) {x=0; return;}
        int mid=(l+r)>>1;
        LL M=(L+R)/2;
        x=tmp[mid]; tr[x].l=L; tr[x].r=R; tr[x].mid=M;
        if(l==r) {tr[x].sz=1; tr[x].son[0]=0; tr[x].son[1]=0; return;}
        rebuild(tr[x].son[0],l,mid-1,L,M); rebuild(tr[x].son[1],mid+1,r,M,R);
        update(x);
    }
    void insert(int& x,LL L,LL R,int fir,int sec){
        if(!x) {x=++size; anew=x;tr[x]=(sgt){L,R,(L+R)/2,fir,sec,0,0,1}; return;}
        if(tr[tr[x].fir].mid==tr[fir].mid && tr[tr[x].sec].mid==tr[sec].mid) {anew=x; return;}
        else if(tr[tr[x].fir].mid==tr[fir].mid){
            if(tr[tr[x].sec].mid>tr[sec].mid) insert(tr[x].son[0],tr[x].l,tr[x].mid,fir,sec);
            else insert(tr[x].son[1],tr[x].mid,tr[x].r,fir,sec);
        }
        else{
            if(tr[tr[x].fir].mid>tr[fir].mid) insert(tr[x].son[0],tr[x].l,tr[x].mid,fir,sec);
            else insert(tr[x].son[1],tr[x].mid,tr[x].r,fir,sec);
        }
        update(x);
        if(tr[x].son[0] && !balance(tr[x].son[0])) ltst=x,wh=0;
        else if(tr[x].son[1] && !balance(tr[x].son[1])) ltst=x,wh=1;
        if(x==root && !balance(x)) tmp[0]=0,travel(root),rebuild(root,1,tmp[0],1,MX);
    }
}
namespace Segment_Tree{
    int a[N];
    struct seg{
        int l,r,son[2],mx_pos,num;         
    }tr[N];
    inline void update(int x){
        if(SGT::tr[tr[tr[tr[x].son[0]].mx_pos].num].mid==SGT::tr[tr[tr[tr[x].son[1]].mx_pos].num].mid){
            int le=tr[tr[x].son[0]].mx_pos,ri=tr[tr[x].son[1]].mx_pos;
            tr[x].mx_pos=tr[le].l<tr[ri].l?le:ri;
        }
        else if(SGT::tr[tr[tr[tr[x].son[0]].mx_pos].num].mid>SGT::tr[tr[tr[tr[x].son[1]].mx_pos].num].mid) 
        tr[x].mx_pos=tr[tr[x].son[0]].mx_pos;
        else tr[x].mx_pos=tr[tr[x].son[1]].mx_pos;
    }
    void build(int x,int l,int r){
        if(l==r) {tr[x]=(seg){l,r,0,0,x,1};return;}
        int mid=(l+r)>>1; tr[x].l=l; tr[x].r=r;
        tr[x].son[0]=x<<1; build(tr[x].son[0],l,mid);
        tr[x].son[1]=x<<1|1; build(tr[x].son[1],mid+1,r);
        update(x);
    }
    void modify(int x,int ai,int v){
        int l=tr[x].l,r=tr[x].r;
        if(l==r) {tr[x].num=v; return;}
        int mid=(l+r)>>1;
        if(ai<=mid) modify(tr[x].son[0],ai,v);
        else modify(tr[x].son[1],ai,v);
        update(x);
    }
    int query(int x,int L,int R){
        int l=tr[x].l,r=tr[x].r;
        if(l==L && r==R) return tr[x].mx_pos;
        int mid=(l+r)>>1;
        if(R<=mid) return query(tr[x].son[0],L,R);
        else if(mid<L) return query(tr[x].son[1],L,R);
        else{
            int le=query(tr[x].son[0],L,mid),ri=query(tr[x].son[1],mid+1,R);
            if(SGT::tr[tr[le].num].mid==SGT::tr[tr[ri].num].mid) return tr[le].l<tr[ri].l?le:ri;
            return SGT::tr[tr[le].num].mid>SGT::tr[tr[ri].num].mid?le:ri;
        }
    }
}

int main(){
    n=read(); m=read(); MX=1;
    for(int i=1;i<=60;i++) MX*=2;
    ST::build(1,1,n); SGT::tr[1]=(SGT::sgt){1,MX,(1+MX)/2,0,0,0,0,1};
    for(int i=1;i<=n;i++) ST::a[i]=1;
    while(m--){
        scanf("%s",st); int k,l=read(),r=read();
        if(st[0]=='C'){
            k=read(); 
            l=ST::a[l]; r=ST::a[r]; SGT::ltst=0; SGT::insert(SGT::root,1,MX,l,r);
            if(SGT::ltst) {
                SGT::tmp[0]=0; SGT::travel(SGT::tr[SGT::ltst].son[SGT::wh]); 
                LL L=SGT::tr[SGT::tr[SGT::ltst].son[SGT::wh]].l,R=SGT::tr[SGT::tr[SGT::ltst].son[SGT::wh]].r;
                SGT::rebuild(SGT::tr[SGT::ltst].son[SGT::wh],1,SGT::tmp[0],L,R);
            }
            ST::modify(1,k,SGT::anew),ST::a[k]=SGT::anew;
        }else{
            int ans=ST::query(1,l,r);
            ans=ST::tr[ans].l;
            printf("%d
",ans);
        }
    }
    return 0;
}