[bzoj1500][NOI2005]维修数列[Treap][可持久化Treap]

非旋转式Treap1500　：）

#include <bits/stdc++.h>
#pragma    GCC    optimize(3)

using namespace std;

const int    INF=0x3f3f3f3f;

struct node
{
    int    val,key,size;
    int    sum,lx,rx,mx,revf,chgf;
    node    *l,*r;
    node() { }
    node(const int x)
    {
        mx=val=sum=x; key=rand();
        size=1; lx=rx=(x>0?x:0);
        chgf=INF; revf=0; l=r=0;
    }

    void    push_down()
    {
        if(chgf!=INF)
        {
            sum=chgf*size;
            val=chgf;
            lx=rx=(chgf>=0?sum:0);
            mx=(chgf>=0?sum:chgf);
            if(l) l->chgf=chgf;
            if(r) r->chgf=chgf;
            chgf=INF; revf=0;
        }
        if(revf)
        {
            if(l)l->revf^=1;
            if(r)r->revf^=1;
            swap(l,r);
            swap(lx,rx);
            revf=0;
        } return ;
    }

    void    update()
    {
        if(l)l->push_down();
        if(r)r->push_down();
        sum=(l?l->sum:0)+(r?r->sum:0)+val;
        size=(l?l->size:0)+(r?r->size:0)+1;
        mx=max(max((l?l->mx:-INF),(r?r->mx:-INF)),
          (l?l->rx:0)+(r?r->lx:0)+val);
        lx=max((l?l->lx:0), (l?l->sum:0)+val+(r?r->lx:0));
        rx=max((r?r->rx:0), (r?r->sum:0)+val+(l?l->rx:0));
        return ;
    }

}U[510000],*Trash[510000],*ALL=U; int top;

node *    ALLOC(const int x)
{
    return new(top?Trash[top--]:++ALL)node(x);
}

void    RECYCLE(node * t)
{
    if(!t)return ;
    RECYCLE(t->l);
    RECYCLE(t->r);
    Trash[++top]=t;
    return ;
}

struct Treap
{
    typedef    pair<node *,node *> PNN;
    public:
    Treap() { root=0; }

    private:

    node * root;

    node *    merge(node * t1,node * t2)
    {
        if(!t1) return t2; if(!t2) return t1;
        t1->push_down(); t2->push_down();
        if(t1->key < t2->key)
            return t1->r=merge(t1->r,t2),t1->update(),t1;
        return t2->l=merge(t1,t2->l),t2->update(),t2;
    }

    PNN    split(node * t,const int pos)
    {
        if(t)  t->push_down();
        if(!t) return make_pair((node*)0,(node*)0);
        if(!pos) return make_pair((node*)0,t);
        if(t->l && t->l->size==pos)
        {
            node * temp=t->l;
            return t->l=0,t->update(),make_pair(temp,t);
        }
        if(t->l && t->l->size+1==pos)
        {
            node * temp=t->r;
            return t->r=0,t->update(),make_pair(t,temp);
        }
        if(t->l && t->l->size>pos)
        {
            PNN    temp=split(t->l,pos);
            return t->l=temp.second,t->update(),
              make_pair(temp.first,t);
        }
        if(!t->r) return make_pair(t,(node*)0);
        PNN    temp=split(t->r,pos-(t->l?t->l->size:0)-1);
        return t->r=temp.first,t->update(),make_pair(t,temp.second);
    }

    node *    build(const int * A,const int N)
    {
        stack<node *> stk; node * temp=0;
        for(int i=0;i<N;++i)
        {
            node * t=ALLOC(A[i]);
            while(!stk.empty() && t->key<stk.top()->key)
                temp=stk.top(),temp->update(),stk.pop();
            if(!stk.empty())
            {
                t->l=stk.top()->r;
                t->update();
                stk.top()->r=t;
                stk.top()->update();
                stk.push(t);
            }
            else
            {
                t->l=temp;
                t->update();
                stk.push(t);
            }
        }
        while(!stk.empty()) temp=stk.top(),temp->update(),stk.pop();
        return temp;
    }

    public:
    void insert(const int pos,const int * A,const int N)
    {
        PNN    t=split(root,pos);
        t.first=merge(t.first,build(A,N));
        root=merge(t.first,t.second);
        return ;
    }

    void    erase(const int l,const int r)
    {
        PNN    t1=split(root,l-1);
        PNN    t2=split(t1.second,r-l+1);
        RECYCLE(t2.first);
        root=merge(t1.first,t2.second);
    }

    void    make_same(const int l,const int r,const int d)
    {
        PNN    t1=split(root,l-1);
        PNN    t2=split(t1.second,r-l+1);
        t2.first->chgf=d;
        t2.first->push_down();
        root=merge(t1.first,merge(t2.first,t2.second));
    }

    void    reverse(const int l,const int r)
    {
        PNN    t1=split(root,l-1);
        PNN    t2=split(t1.second,r-l+1);
        t2.first->revf^=1;
        t2.first->push_down();
        root=merge(t1.first,merge(t2.first,t2.second));
    }

    int    get_sum(const int l,const int r)
    {
        if(l>r)return 0;
        PNN    t1=split(root,l-1);
        PNN    t2=split(t1.second,r-l+1);
        t2.first->push_down();
        int    temp=t2.first->sum;
        root=merge(t1.first,merge(t2.first,t2.second));
        return temp;
    }
    
    int    max_sum()
    {
        PNN    t1=split(root,0);
        PNN    t2=split(t1.second,root->size);
        t2.first->push_down();
        int    temp=t2.first->mx;
        root=merge(t1.first,merge(t2.first,t2.second));
        return temp;
    }
}S;

int    n,m,x,y,z;
int    a[510000];
char    op[20];

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;++i) scanf("%d",&a[i]);
    S.insert(0,a,n);
    while(m--)
    {
        scanf("%s",op);
        if(op[2]=='S') // Insert
        {
            scanf("%d%d",&x,&y);
            for(int i=0;i<y;++i) scanf("%d",&a[i]);
            S.insert(x,a,y);
        }
        if(op[2]=='L') // Delete
        {
            scanf("%d%d",&x,&y);
            S.erase(x,x+y-1);
        }
        if(op[2]=='K') // Make_same
        {
            scanf("%d%d%d",&x,&y,&z);
            S.make_same(x,x+y-1,z);
        }
        if(op[2]=='V') // Reverse
        {
            scanf("%d%d",&x,&y);
            S.reverse(x,x+y-1);
        }
        if(op[2]=='T') // Get_sum
        {
            scanf("%d%d",&x,&y);
            printf("%d\n",S.get_sum(x,x+y-1));
        }
        if(op[2]=='X') // Max_sum
        {
            printf("%d\n",S.max_sum());
        }
    }
    
    return 0;
}