[NOI2005]维护数列

Description

Input

输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。
第2行包含N个数字，描述初始时的数列。
以下M行，每行一条命令，格式参见问题描述中的表格。
任何时刻数列中最多含有500 000个数，数列中任何一个数字均在[-1 000, 1 000]内。
插入的数字总数不超过4 000 000个，输入文件大小不超过20MBytes。

Output

对于输入数据中的GET-SUM和MAX-SUM操作，向输出文件依次打印结果，每个答案（数字）占一行。

Sample Input

9 8
2 -6 3 5 1 -5 -3 6 3
GET-SUM 5 4
MAX-SUM
INSERT 8 3 -5 7 2
DELETE 12 1
MAKE-SAME 3 3 2
REVERSE 3 6
GET-SUM 5 4
MAX-SUM

Sample Output

-1
10
1
10

HINT

题解：

听说做了这道题splay就差不多过关了。（然而我调了一天）

关于问题中的几个操作：

1.插入

将输入的数列用建二叉树的方式建成一棵splay，然后将目标位置的那个节点旋转到根，再将后面那个节点旋转到根的下方（就是split操作），然后就直接将新的splay接到根节点的右子节点的左子节点上。

2.删除

也是像之前一样，用split操作将删除的区间确定在根节点的右子节点的左子节点处，然后将删除的区间加入内存池就好了。

 

3.修改

先split一下，然后在根节点的右子节点的左子节点打上修改标记。

 

4.旋转

先split一下，然后在根节点的右子节点的左子节点打上旋转标记。

 

5.求和

先split一下，直接输出根节点右子节点的左子节点的sum。

 

6.求和最大的子列

就像线段树维护一样，对于每一个节点，我们令它所控制的区间是以它为根节点子树，然后维护三个参数ls，rs，ms。分别表示这个区间左边最大的子列，右边最大的子列，中间最大的子列。然后每次push_up的时候跟新一下就好。

当然这道题目很折磨人，有很多细节：

1.splay维护区间的时候要在一头一尾加上一个极值，因为如果不加，find可能会找不到

2.输出和最大的子列的时候也是需要split的，因为两端的极值会对根节点的三个参数造成影响。

3.push_up和push_down中维护ls，rs，ms的部分有些地方要和0取max，详见代码。

4.在find中push_down（这个是套路）

//Never forget why you start
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#define inf (0x3f3f3f3f)
#define ll(x) bst[x].child[0]
#define rr(x) bst[x].child[1]
#define son(x,t) bst[x].child[t]
using namespace std;
int n,m,cnt;
int pos[1000005],root,a[1000005];
struct Bst{
  int child[2],fa,size,sum,x,lazy,round,ls,rs,ms,islazy;
}bst[1000005];
queue<int>mem;
void push_up(int rt){
  int l=ll(rt),r=rr(rt);
  bst[rt].sum=bst[l].sum+bst[r].sum+bst[rt].x;
  bst[rt].size=bst[l].size+bst[r].size+1;
  bst[rt].ls=bst[rt].rs=bst[rt].ms=-inf;
  bst[rt].ms=max(max(0,bst[l].rs)+bst[rt].x+max(0,bst[r].ls),max(bst[l].ms,bst[r].ms));
  bst[rt].rs=max(bst[r].rs,bst[r].sum+bst[rt].x+max(0,bst[l].rs));
  bst[rt].ls=max(bst[l].ls,bst[l].sum+bst[rt].x+max(0,bst[r].ls));
}
void rotate(int r,int t){
  int fa=bst[r].fa;
  son(fa,!t)=son(r,t);bst[son(r,t)].fa=fa;
  son(bst[fa].fa,son(bst[fa].fa,1)==fa)=r;bst[r].fa=bst[fa].fa;
  son(r,t)=fa;bst[fa].fa=r;
  push_up(fa);
  push_up(r);
}
void splay(int r,int goal){
  int fa=bst[r].fa;
  while(fa!=goal){
    if(bst[fa].fa==goal)rotate(r,son(fa,0)==r);
    else{
      int t=son(bst[fa].fa,0)==fa;
      if(son(fa,t)==r)rotate(r,!t),rotate(r,t);
      else rotate(fa,t),rotate(r,t);
    }
    fa=bst[r].fa;
  }
  if(goal==0)root=r;
}
void push_down(int root){
  int l=son(root,0),r=son(root,1);
  if(bst[root].round){
    bst[l].round^=1;bst[r].round^=1;
    swap(son(root,0),son(root,1));
    swap(bst[l].ls,bst[l].rs);
    swap(bst[r].ls,bst[r].rs);
    bst[root].round=0;
  }
  if(bst[root].islazy){
    if(l)bst[l].islazy=1,bst[l].lazy=bst[root].x,bst[l].x=bst[root].x,bst[l].sum=bst[l].size*bst[root].x;
    if(r)bst[r].islazy=1,bst[r].lazy=bst[root].x,bst[r].x=bst[root].x,bst[r].sum=bst[r].size*bst[root].x;
    if(bst[root].lazy>=0){
      bst[l].ls=bst[l].rs=bst[l].ms=bst[l].sum;
      bst[r].ls=bst[r].rs=bst[r].ms=bst[r].sum;
    }
    else{
      bst[l].ls=bst[l].rs=bst[l].ms=bst[root].x;
      bst[r].ls=bst[r].rs=bst[r].ms=bst[root].x;
    }
    bst[root].lazy=0;
    bst[root].islazy=0;
  }
}
int find(int r,int k){
  push_down(r);
  int y=bst[son(r,0)].size;
  if(y+1==k)return r;
  else if(y>=k)return find(ll(r),k);
  else return find(rr(r),k-y-1);
}
int newnode(){
  int pos;
  if(!mem.empty())pos=mem.front(),mem.pop();
  else pos=++cnt;
  bst[pos].child[0]=bst[pos].child[1]=bst[pos].fa=0;
  bst[pos].islazy=bst[pos].lazy=bst[pos].round=0;
  bst[pos].rs=bst[pos].ls=bst[pos].ms=-inf;
  bst[pos].sum=bst[pos].x=0;
  bst[pos].size=1;
  return pos;
}
void build(int l,int r,int fa,int f){
  int mid=(l+r)>>1,now=pos[mid]=newnode();
  if(l==r){
    bst[now].sum=bst[now].x=a[l];
    bst[now].ls=bst[now].rs=bst[now].ms=a[l];
  }
  if(l<mid)build(l,mid-1,now,mid);
  if(mid<r)build(mid+1,r,now,mid);
  bst[now].x=a[mid];bst[now].fa=fa;
  push_up(now);
  son(fa,mid>=f)=now;
}
void insert(int place,int tot){
  int i;
  for(i=1;i<=tot;i++)
    scanf("%d",&a[i]);
  build(1,tot,0,0);
  int rt=pos[(tot+1)>>1],x=find(root,place),y=find(root,place+1);
  splay(x,0);splay(y,x);
  son(y,0)=rt;bst[rt].fa=y;
  push_up(y);
  push_up(x);
}
void clean(int r){
  if(r){
    mem.push(r);
    clean(son(r,0));
    clean(son(r,1));
  }
}
void delet(int place,int tot){
  int x=find(root,place-1),y=find(root,place+tot);
  splay(x,0);splay(y,x);
  clean(son(y,0));
  son(y,0)=0;
  push_up(y);push_up(x);
}
void make_same(int place,int tot,int c){
  int x=find(root,place-1),y=find(root,place+tot);
  splay(x,0);splay(y,x);
  int z=son(y,0);
  bst[z].sum=c*bst[z].size;
  bst[z].lazy=c;
  bst[z].islazy=1;
  bst[z].x=c;
  if(c>=0){
    bst[z].ls=bst[z].rs=bst[z].ms=c*bst[z].size;
  }
  else{
    bst[z].ls=bst[z].rs=bst[z].ms=c;
  }
  push_up(y);push_up(x);
}
void rever(int place,int tot){
  int x=find(root,place-1),y=find(root,place+tot);
  splay(x,0);splay(y,x);
  int z=son(y,0);
  bst[z].round^=1;
  swap(bst[z].ls,bst[z].rs);
  push_up(y);push_up(x);
}
int get_sum(int place,int tot){
  int x=find(root,place-1),y=find(root,place+tot);
  splay(x,0);splay(y,x);
  return bst[son(y,0)].sum;
}
int max_sum(){
  int x=find(root,1),y=find(root,bst[root].size);
  splay(x,0);splay(y,x);
  return bst[son(y,0)].ms;
}
int main(){
  int i,j;
  scanf("%d%d",&n,&m);
  a[1]=-inf;a[n+2]=-inf;
  for(i=1;i<=n;i++)
    scanf("%d",&a[i+1]);
  n+=2;
  build(1,n,0,0);
  root=pos[(1+n)>>1];
  for(i=1;i<=m;i++){
    char s[10];int place,tot,c;
    scanf("%s",s);
    if(s[0]=='I')scanf("%d%d",&place,&tot),insert(place+1,tot);
    if(s[0]=='D')scanf("%d%d",&place,&tot),delet(place+1,tot);
    if(s[0]=='M'&&s[2]=='K')scanf("%d%d%d",&place,&tot,&c),make_same(place+1,tot,c);
    if(s[0]=='R')scanf("%d%d",&place,&tot),rever(place+1,tot);
    if(s[0]=='G')scanf("%d%d",&place,&tot),printf("%d\n",get_sum(place+1,tot));
    if(s[0]=='M'&&s[2]=='X')printf("%d\n",max_sum());
  }
  return 0;
}