splay(1区间翻转区间最值与区间修改)

bzoj1251权限题

题目点这里，你懂得

直接上板子，这个要好好体会

操作是最经典的。

 #include <algorithm>
 #include <iostream>
 #include <cstring>
 #include <cstdlib>
 #include <cstdio>
 #include <vector>
 #include <cmath>
 #include <queue>
 #include <map>
 #include <set>
 using namespace std;
 #define file(x) freopen(x".in","r",stdin),freopen(x".out","w",stdout)
 inline void read(int &ans) {
     ans=;char x=getchar();bool f=;
     while(x<''||x>'') {if(x=='-')f=;x=getchar();}
     while(x>=''&&x<='')ans=ans*+x-'',x=getchar();
     f?ans=-ans:;
 }
 const int MAXN=1e5+;
 const int INF=2e9;
 struct splay_tree{
     struct node{
         int val,max,add,size,son[];
         bool rev;//区间是否翻转
         void init(int _val){
             val=max=_val ,size=;
             add=rev=son[]=son[]=;
         }
     }T[MAXN];
     int fa[MAXN],root;

     void pushup(int x){
         T[x].max=T[x].val ,T[x].size=;
         for(int k=;k<;k++)
             if(T[x].son[k]){
                 T[x].max=max(T[x].max,T[T[x].son[k]].max);
                 T[x].size+=T[T[x].son[k]].size;
             }
     }

     void pushdown(int x){
         if(x==)return;
         if(T[x].add){
             for(int k=;k<;k++)
                 if(T[x].son[k]){
                     T[T[x].son[k]].val+=T[x].add;
                     T[T[x].son[k]].max+=T[x].add;
                     T[T[x].son[k]].add+=T[x].add;
                 }
             T[x].add=;
         }
         if(T[x].rev){
             for(int k=;k<;k++)
                 if(T[x].son[k]) T[T[x].son[k]].rev^=;
             swap(T[x].son[],T[x].son[]);
             T[x].rev=;
         }
     }

     void rotate(int x,int k){
         int y=fa[x] ,z=fa[y];
         T[y].son[!k]=T[x].son[k] ,fa[T[x].son[k]]=y;
         T[x].son[k]=y ,fa[y]=x;
         T[z].son[T[z].son[]==y]=x ,fa[x]=z;
         pushup(y);
     }

     void splay(int x,int goal){
         if(x==goal)return;
         while(fa[x]!=goal){
             int y=fa[x] ,z=fa[y];
             pushdown(z) ,pushdown(y) ,pushdown(x);
             int rx=T[y].son[]==x ,ry=T[z].son[]==y;
             if(z==goal)rotate(x,rx);
             else{
                 if(rx==ry)rotate(y,ry);
                 else      rotate(x,rx);
                 rotate(x,ry);
             }
         }
         pushup(x);
         if(goal==)root=x;
     }

     int select(int p){
         int u=root;
         pushdown(u);
         while(p!=T[T[u].son[]].size){
             if(p<T[T[u].son[]].size)u=T[u].son[];
             else{
                 p-=T[T[u].son[]].size+;
                 u=T[u].son[];
             }
             pushdown(u);
         }
         return u;
     }

     void updata(int L,int R,int val){
         int u=select(L-) ,v=select(R+);
         splay(u,);
         splay(v,u);
         T[T[v].son[]].max+=val;
         T[T[v].son[]].val+=val;
         T[T[v].son[]].add+=val;
     }

     void reverse(int l,int r){
         int u=select(l-) ,v=select(r+);
         splay(u,);
         splay(v,u);
         T[T[v].son[]].rev^=;
     }

     int query(int l,int r){
         int u=select(l-) ,v=select(r+);
         splay(u,);
         splay(v,u);
         return T[T[v].son[]].max;
     }

     int build(int l,int r){
         if(l>r)  return ;
         if(l==r) return l;
         int mid=(l+r)>> ,ls, rs;
         ls=T[mid].son[]=build(l,mid-);
         rs=T[mid].son[]=build(mid+,r);
         fa[ls]=fa[rs]=mid;
         pushup(mid);
         return mid;
     }

     void init(int n){
         T[].init(-INF) ,T[].init(-INF) ,T[n+].init(-INF);
         for(int i=;i<=n+;i++)T[i].init();
         root=build(,n+) ,fa[root]=;
         fa[]= ,T[].son[]=root ,T[].size=;
     }
 };

 splay_tree bzoj1251;
 int n,m,a,b,c,d;
 int main() {
     read(n),read(m);
     bzoj1251.init(n);
     for(int i=;i<m;i++){
         read(a),read(b),read(c);
         if(a==)read(d),bzoj1251.updata(b,c,d);
         else if(a==)bzoj1251.reverse(b,c);
         else printf("%d\n",bzoj1251.query(b,c));
     }
     return ;
 }