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=0;char x=getchar();bool f=0;
    while(x<'0'||x>'9') {if(x=='-')f=1;x=getchar();}
    while(x>='0'&&x<='9')ans=ans*10+x-'0',x=getchar();
    f?ans=-ans:0;
}
const int MAXN=1e5+10;
const int INF=2e9;
struct splay_tree{
    struct node{
        int val,max,add,size,son[2];
        bool rev;//区间是否翻转 
        void init(int _val){
            val=max=_val ,size=1;
            add=rev=son[0]=son[1]=0;
        }
    }T[MAXN];
    int fa[MAXN],root;
    
    void pushup(int x){
        T[x].max=T[x].val ,T[x].size=1;
        for(int k=0;k<2;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==0)return;
        if(T[x].add){
            for(int k=0;k<2;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=0;
        }
        if(T[x].rev){
            for(int k=0;k<2;k++)
                if(T[x].son[k]) T[T[x].son[k]].rev^=1;
            swap(T[x].son[0],T[x].son[1]);
            T[x].rev=0;
        }
    }
    
    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[1]==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[0]==x ,ry=T[z].son[0]==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==0)root=x;
    }
    
    int select(int p){
        int u=root;
        pushdown(u);
        while(p!=T[T[u].son[0]].size){
            if(p<T[T[u].son[0]].size)u=T[u].son[0];
            else{
                p-=T[T[u].son[0]].size+1;
                u=T[u].son[1];
            }
            pushdown(u);
        }
        return u;
    }
    
    void updata(int L,int R,int val){
        int u=select(L-1) ,v=select(R+1);
        splay(u,0);
        splay(v,u);
        T[T[v].son[0]].max+=val;
        T[T[v].son[0]].val+=val;
        T[T[v].son[0]].add+=val;
    }
    
    void reverse(int l,int r){
        int u=select(l-1) ,v=select(r+1);
        splay(u,0);
        splay(v,u);
        T[T[v].son[0]].rev^=1;
    }
    
    int query(int l,int r){
        int u=select(l-1) ,v=select(r+1);
        splay(u,0);
        splay(v,u);
        return T[T[v].son[0]].max;
    }
    
    int build(int l,int r){
        if(l>r)  return 0;
        if(l==r) return l;
        int mid=(l+r)>>1 ,ls, rs;
        ls=T[mid].son[0]=build(l,mid-1);
        rs=T[mid].son[1]=build(mid+1,r);
        fa[ls]=fa[rs]=mid;
        pushup(mid);
        return mid;
    }
    
    void init(int n){
        T[0].init(-INF) ,T[1].init(-INF) ,T[n+2].init(-INF);
        for(int i=2;i<=n+1;i++)T[i].init(0);
        root=build(1,n+2) ,fa[root]=0;
        fa[0]=0 ,T[0].son[1]=root ,T[0].size=0;
    }
};

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