维修数列 Splay(这可能是我写过最麻烦的题之一了。。。用平衡树维护dp。。。丧心病狂啊。。。。)

题目来源BZOJ1500

这题的思路：

1、这题的话，稍微会splay的人，一般前面四个都不是问题。。主要是最后的一个，要你在修改的同时要维护好最大字段和。。。

2、最大字段和其实就是区间合并。具体操作可以看POJ2750，这是这道题的简化版本。

3、然后这题就是三个区间合并嘛。。。慢慢讨论就好了。。。这题写了我一天的时间。。从吃完午饭一直写到了晚上8点才AC。。。

直接贴代码吧。。这题是我为了学LCT，所以想做做Splay的题先熟悉一下Splay。。。结果选了这个BOSS题。。。心理阴影。。。。

我觉得我pushup那段写的挺清楚的23333   思路可以看我的pushup和pushdown函数的代码，应该挺好懂的

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
 
using namespace std;
 
const int N=500005,INF=0x3f3f3f3f;
 
struct Splay_Tree
{
    struct Node
    {
        int val,sum,cover,Size,son[2],mxl,mxr,mx;
        bool rev,cov;
        void init(int _val)
        {
            val=sum=mxl=mxr=mx=_val;
            Size=1;
            rev=cov=cover=son[0]=son[1]=0;
        }
    } T[N];
    stack<int>mem;
    int fa[N],root,tot;
 
    void pushDown(int x)///下放标记（序列操作）
    {
        if(x==0)return ;
        if(T[x].cov)
        {
            if(T[x].son[0])
            {
                T[T[x].son[0]].cov=1;
                T[T[x].son[0]].cover=T[T[x].son[0]].val=T[x].cover;
                T[T[x].son[0]].sum=T[x].cover*T[T[x].son[0]].Size;
                T[T[x].son[0]].rev=0;
                if(T[x].cover>=0)
                    T[T[x].son[0]].mx=T[T[x].son[0]].mxl=T[T[x].son[0]].mxr=T[x].cover*T[T[x].son[0]].Size;
                else
                    T[T[x].son[0]].mx=T[T[x].son[0]].mxl=T[T[x].son[0]].mxr=T[x].cover;
            }
            if(T[x].son[1])
            {
                T[T[x].son[1]].cov=1;
                T[T[x].son[1]].cover=T[T[x].son[1]].val=T[x].cover;
                T[T[x].son[1]].sum=T[x].cover*T[T[x].son[1]].Size;
                T[T[x].son[1]].rev=0;
                if(T[x].cover>=0)
                    T[T[x].son[1]].mx=T[T[x].son[1]].mxl=T[T[x].son[1]].mxr=T[x].cover*T[T[x].son[1]].Size;
                else
                    T[T[x].son[1]].mx=T[T[x].son[1]].mxl=T[T[x].son[1]].mxr=T[x].cover;
            }
            T[x].cov=T[x].cover=T[x].rev=0;
        }
        if(T[x].rev)
        {
            if(T[x].son[0])
            {
                T[T[x].son[0]].rev^=1;
                swap(T[T[x].son[0]].mxl,T[T[x].son[0]].mxr);
            }
            if(T[x].son[1])
            {
                T[T[x].son[1]].rev^=1;
                swap(T[T[x].son[1]].mxl,T[T[x].son[1]].mxr);
            }
            swap(T[x].son[0],T[x].son[1]);
            T[x].rev=0;
        }
    }
 
    void pushUp(int x)///更新节点（序列操作）
    {
        T[x].Size=1;
        T[x].sum=T[x].val;
        if(T[x].son[0])
            T[x].sum+=T[T[x].son[0]].sum,T[x].Size+=T[T[x].son[0]].Size;
        if(T[x].son[1])
            T[x].sum+=T[T[x].son[1]].sum,T[x].Size+=T[T[x].son[1]].Size;
 
        if(T[x].son[0]&&T[x].son[1])
        {
            T[x].mx=T[x].val;
            T[x].mx=max(T[x].mx,T[T[x].son[0]].mx);
            T[x].mx=max(T[x].mx,T[T[x].son[1]].mx);
            T[x].mx=max(T[x].mx,T[T[x].son[0]].mxr+T[x].val+T[T[x].son[1]].mxl);
            T[x].mx=max(T[x].mx,T[x].val+T[T[x].son[0]].mxr);
            T[x].mx=max(T[x].mx,T[x].val+T[T[x].son[1]].mxl);
 
            T[x].mxl=T[T[x].son[0]].mxl;
            T[x].mxl=max(T[x].mxl,T[T[x].son[0]].sum+T[x].val);
            T[x].mxl=max(T[x].mxl,T[T[x].son[0]].sum+T[x].val+T[T[x].son[1]].mxl);
 
            T[x].mxr=T[T[x].son[1]].mxr;
            T[x].mxr=max(T[x].mxr,T[T[x].son[1]].sum+T[x].val);
            T[x].mxr=max(T[x].mxr,T[T[x].son[1]].sum+T[x].val+T[T[x].son[0]].mxr);
        }
        else if(T[x].son[0]&&!T[x].son[1])
        {
            T[x].mx=max(T[T[x].son[0]].mxr+T[x].val,T[T[x].son[0]].mx);
 
            T[x].mx=max(T[x].mx,T[x].val);
 
            T[x].mxl=max(T[T[x].son[0]].mxl,T[T[x].son[0]].sum+T[x].val);
 
            T[x].mxr=max(T[x].val,T[x].val+T[T[x].son[0]].mxr);
        }
        else if(!T[x].son[0]&&T[x].son[1])
        {
            T[x].mx=max(T[T[x].son[1]].mxl+T[x].val,T[T[x].son[1]].mx);
 
            T[x].mx=max(T[x].mx,T[x].val);
 
            T[x].mxl=max(T[x].val,T[x].val+T[T[x].son[1]].mxl);
 
            T[x].mxr=max(T[T[x].son[1]].mxr,T[T[x].son[1]].sum+T[x].val);
        }
        else T[x].mxl=T[x].mxr=T[x].mx=T[x].val;
 
    }
 
    /*inline void up(int x)///更新节点（普通平衡树操作）
    {
        T[x].Size=1;
        if(T[x].son[0])
            T[x].Size+=T[T[x].son[0]].Size;
        if(T[x].son[1])
            T[x].Size+=T[T[x].son[1]].Size;
    }*/
 
    void Rotate(int x,int kind)///旋转，有左旋右旋（反正配合splay用就好了233）
    {
        int y=fa[x],z=fa[y];
        T[y].son[!kind]=T[x].son[kind],fa[T[x].son[kind]]=y;
        T[x].son[kind]=y,fa[y]=x;
        T[z].son[T[z].son[1]==y]=x,fa[x]=z;
        pushUp(y);
    }
 
    void Splay(int x,int goal)///把下标为x的元素旋转到目标的儿子节点
    {
        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 pos)///查找第k小元素
    {
        pos--;
        int u=root;
        pushDown(u);
        while(T[T[u].son[0]].Size!=pos)
        {
            if(pos<T[T[u].son[0]].Size)u=T[u].son[0];
            else
            {
                pos-=T[T[u].son[0]].Size+1;
                u=T[u].son[1];
            }
            pushDown(u);
        }
        return u;
    }
 
 
    void Reverse(int L,int R)///序列操作的区间翻转
    {
        if(L>R)return ;
        int u=Select(L-1),v=Select(R+1);
        Splay(u,0);
        Splay(v,u);
        T[T[v].son[0]].rev^=1;
        swap(T[T[v].son[0]].mxl,T[T[v].son[0]].mxr);
        pushDown(T[v].son[0]);
        update(T[v].son[0]);
    }
 
    void Cover(int L,int R,int Val)///序列操作的区间翻转
    {
        if(L>R)return ;
        int u=Select(L-1),v=Select(R+1);
        Splay(u,0);
        Splay(v,u);
        T[T[v].son[0]].cov=1;
        T[T[v].son[0]].cover=T[T[v].son[0]].val=Val;
        pushDown(T[v].son[0]);
        update(T[v].son[0]);
    }
 
    int build(int L,int R,int *a)///区间操作建树
    {
        if(L>R)return 0;
        int mid=(L+R)>>1,sL,sR;
        int loc=mem.top();mem.pop();
        T[loc].init(a[mid]);
        if(L==R)return loc;
        T[loc].son[0]=sL=build(L,mid-1,a);
        T[loc].son[1]=sR=build(mid+1,R,a);
        fa[sL]=fa[sR]=loc;
        pushUp(loc);
        return loc;
    }
 
    void init(int n,int *a)///区间操作，输入n个元素建树
    {
        T[0].init(INF);
        for(int i=500001;i>=1;i--)
            mem.push(i);
        root=build(1,n,a),fa[root]=0;
        fa[0]=0,T[0].son[1]=root,T[0].Size=0;
    }
 
    void Insert(int pos,int n,int *a)
    {
        if(n==0)return ;
        int u=Select(pos-1),v=Select(pos);
        Splay(u,0);
        Splay(v,u);
        fa[T[v].son[0]=build(1,n,a)]=v;
        update(T[v].son[0]);
    }
 
    void Delete(int L,int R)
    {
        if(L>R)return ;
        int u=Select(L-1),v=Select(R+1);
        Splay(u,0);
        Splay(v,u);
        Free(T[v].son[0]);
        T[v].son[0]=0;
        update(v);
    }
 
    int Get_sum(int L,int R)
    {
        if(L>R)return 0;
        int u=Select(L-1),v=Select(R+1);
        Splay(u,0);
        Splay(v,u);
        if(T[v].son[0])
            return T[T[v].son[0]].sum;
        else return 0;
    }
 
    int Get_max(int L,int R)
    {
        if(L>R)return 0;
        int u=Select(L-1),v=Select(R+1);
        Splay(u,0);
        Splay(v,u);
        if(T[v].son[0])
            return T[T[v].son[0]].mx;
        else return 0;
    }
 
    void Free(int x)
    {
        if(x==0)return ;
        Free(T[x].son[0]);
        mem.push(x);
        Free(T[x].son[1]);
    }
 
    /*void Insert(int &t,int val,int par=0)///普通平衡树，往某个地方的下面插入元素，一般是插入根节点
    {
        if(t==0)
        {
            t=++tot;
            T[t].init(val);
            fa[t]=par;
            Splay(tot,0);
        }
        else
        {
            int cur=t;
            if(val<T[t].val)Insert(T[t].son[0],val,cur);
            //else if(val==T[t].val)return ;
            else Insert(T[t].son[1],val,cur);
            up(cur);
        }
    }*/
 
    /*int find(int t,int v)///普通平衡树查找值为v的元素
    {
        if(t==0)return 0;
        else if(T[t].val==v)
        {
            Splay(t,0);
            return t;
        }
        else if(v<T[t].val)return find(T[t].son[0],v);
        else return find(T[t].son[1],v);
    }*/
 
    ///删除根节点元素
    /*void Delete()
    {
        if(!T[root].son[0])
        {
            fa[T[root].son[1]]=0;
            root=T[root].son[1];
        }
        else
        {
            int cur=T[root].son[0];
            while(T[cur].son[1])cur=T[cur].son[1];
            Splay(cur,root);
            T[cur].son[1]=T[root].son[1];
            root=cur,fa[cur]=0,fa[T[root].son[1]]=root;
            up(root);
        }
    }*/
 
    int size()
    {
        return T[root].Size;
    }
 
    ///从t开始找值为v的前驱,返回值
    int pred(int t,int v)
    {
        if(t==0)return v;
        else
        {
            if(v<=T[t].val)return pred(T[t].son[0],v);
            else
            {
                int ans=pred(T[t].son[1],v);
                if(ans==v)
                    ans=T[t].val,Splay(t,0);
                return ans;
            }
        }
    }
    ///查找下标t节点的前驱返回下标
    int pred(int t)
    {
        Splay(t,0);
        int u=T[t].son[0];
        if(u==0)return fa[t];
        while(T[u].son[1])u=T[u].son[1];
        return u;
    }
 
    ///从t开始找值为v的后继,返回值
    int succ(int t,int v)
    {
        if(t==0)return v;
        else
        {
            if(v>=T[t].val)return succ(T[t].son[1],v);
            else
            {
                int ans=succ(T[t].son[0],v);
                if(ans==v)
                    ans=T[t].val,Splay(t,0);
                return ans;
            }
        }
    }
 
    ///查找下标t节点的后继返回下标
    int succ(int t)
    {
        Splay(t,0);
        int u=T[t].son[1];
        if(u==0)return fa[t];
        while(T[u].son[0])u=T[u].son[0];
        return u;
    }
 
    void Preorder( int t ){///输出成序列顺便检查是否有逻辑错误
        if( !t ) return;
        pushDown(t);
        Preorder( T[t].son[0] );
        if(T[t].son[0]&&fa[T[t].son[0]]!=t)
            printf("!");
        printf("%d " , T[t].val );
        Preorder( T[t].son[1] );
    }
 
    /*void init()///普通平衡树初始化
    {
        T[0].init(-INF);
        tot=root=0;
    }*/
 
    void update(int x)///更新下标为x的节点。。手动操作后调用
    {
        while(x!=0)
        pushUp(x),x=fa[x];
    }
 
};
 
Splay_Tree tree;
 
int a[N];
 
char str[22];
 
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=2;i<=n+1;i++)
        scanf("%d",a+i);
    tree.init(n+2,a);
    int sum=n;
    while(m--)
    {
        scanf("%s",str+1);
        if(str[3]=='S')
        {
            int pos,tot;
            scanf("%d%d",&pos,&tot);
            pos++;
            pos++;
            sum+=tot;
            for(int i=1;i<=tot;i++)
                scanf("%d",a+i);
            tree.Insert(pos,tot,a);
        }
        else if(str[3]=='L')
        {
            int pos,tot;
            scanf("%d%d",&pos,&tot);
            pos++;
            tree.Delete(pos,pos+tot-1);
            sum-=tot;
        }
        else if(str[3]=='K')
        {
            int pos,tot,cov;
            scanf("%d%d%d",&pos,&tot,&cov);
            pos++;
            tree.Cover(pos,pos+tot-1,cov);
        }
        else if(str[3]=='V')
        {
            int pos,tot;
            scanf("%d%d",&pos,&tot);
            pos++;
            tree.Reverse(pos,pos+tot-1);
        }
        else if(str[3]=='T')
        {
            int pos,tot;
            scanf("%d%d",&pos,&tot);
            pos++;
            printf("%d
",tree.Get_sum(pos,pos+tot-1));
        }
        if(str[3]=='X')
        {
            printf("%d
",tree.Get_max(2,tree.size()-1));
        }
    }
    return 0;
}