BZOJ1500 [NOI2005]维修数列

本文版权归ljh2000和博客园共有，欢迎转载，但须保留此声明，并给出原文链接，谢谢合作。

本文作者：ljh2000
作者博客：http://www.cnblogs.com/ljh2000-jump/
转载请注明出处，侵权必究，保留最终解释权！

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、insert操作：因为有大量元素插入，如果每个都新建结点的话空间开不下，所以我们必须要回收空间，也就是说之前delete操作删掉的结点我要把它回收利用。因为我们是在pos后插入若干元素，那么我可以把pos变成根结点，pos+1变成右子树的根，那么pos+1的左子树为空，我可以先把需要插入的元素构成一棵树，再把这棵树插入到左子树上，往上update一遍。

　　2、delete操作：考虑删除若干元素该怎么做。因为我们想删除一段区间[l,r]，那么我们可以把l-1旋转到根，r+1旋转到根的右子树的根，那么此时r+1的左子树就是要删除的，我们可以直接把左子树删掉，然后回收结点。注意我需要扫一遍这需要删除的整棵左子树，把上面的标记什么的全部清空。看上去这个复杂度是O（n）的，但实际上题目中说插入元素不超过400w，也就是说删除元素也不会超过这么多，所以复杂度没有问题。

　　3、make-same操作：因为我们要把一段区间修改为一个数，所以与上述做法类似，旋转使得需要操作的区间处在一棵子树中，然后给根结点打上标记，表示这个点为根结点的子树全部修改为一个值。每次旋转的时候记得下传就可以了。

　　4、reverse操作：翻转区间与make-same类似，给结点打上标记，表示这棵子树需要翻转，每次下传即可。可以画图发现，每次我下传的时候把左右子树交换则最终可以起到翻转的效果。

　　5、get-sum操作：得到区间之后直接调用根结点的维护的sum值即可。

　　6、max-sum操作：我可以对于每个结点，存储一个它所控制的区间的前缀最大值、后缀最大值和整体最大值，做法经典，不再赘述。

 

 

　　 大概总结：

　　       这道题的的确确是一道码农题，但是只要思维清晰，对于splay的操作熟悉的话，打起来也会很快。

　      　细节很多，写的时候一定谨慎，因为查起错来会很麻烦，务必尽最大努力一遍写对。想清楚再写，想一想模板的模式，没事的时候也可以复习复习splay模板，也想一想自己打splay的时候犯过什么错。

 

 

（　我的查错经过：（蒟蒻的查错辛酸史）

 

　　错误一：翻转标记下传时，不是赋值，而是把儿子结点的标记^1；

 

　　错误二：求第x大的元素时忘记pushdown；

 

　　错误三：插入的时候，我得到pos的位置时不应该直接把pos旋转，而应该先找到位置处在pos的元素是谁；

 

　　错误四：删除的时候，遍历整棵删除子树时需要清空所有标记，但是我忘记清空翻转和make-same标记了。）

  

//It is made by ljh2000
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <ctime>
#include <vector>
#include <queue>
#include <map>
#include <set>
using namespace std;
typedef long long LL;
const int inf = (1<<30);
const int MAXN = 500011;
int rt,tot,n,m;
int a[MAXN],lx[MAXN],rx[MAXN],mx[MAXN];
int tr[MAXN][2],same[MAXN],tag[MAXN],father[MAXN];
int sum[MAXN],size[MAXN],val[MAXN],id[MAXN];
char ch[12];
queue<int>Q;

inline int getint()
{
    int w=0,q=0; char c=getchar();
    while((c<'0' || c>'9') && c!='-') c=getchar(); if(c=='-') q=1,c=getchar(); 
    while (c>='0' && c<='9') w=w*10+c-'0', c=getchar(); return q ? -w : w;
}

inline void Del(int x){
    if(!x) return ;
    int l=tr[x][0],r=tr[x][1];
    if(l) Del(l); if(r) Del(r);
    father[x]=0; tr[x][0]=tr[x][1]=0; 
    val[x]=lx[x]=rx[x]=mx[x]=0; 
    same[x]=tag[x]=0;//!!!
    Q.push(x);
}

inline void update(int x){
    int l=tr[x][0],r=tr[x][1]; size[x]=size[l]+size[r]+1; sum[x]=sum[l]+sum[r]+val[x];
    mx[x]=max(max(mx[l],mx[r]),rx[l]+val[x]+lx[r]); lx[x]=max(lx[l],sum[l]+val[x]+lx[r]); rx[x]=max(rx[r],sum[r]+val[x]+rx[l]);
}

inline void pushdown(int x){
    int l=tr[x][0],r=tr[x][1];
    if(same[x]) {
    same[x]=tag[x]=0; 
    if(l) {
        same[l]=1; val[l]=val[x]; sum[l]=val[l]*size[l];
        if(val[x]>0) mx[l]=lx[l]=rx[l]=sum[l]; else mx[l]=val[x],lx[l]=rx[l]=0;
    }
    if(r) {
        same[r]=1; val[r]=val[x]; sum[r]=val[r]*size[r];
        if(val[x]>0) mx[r]=lx[r]=rx[r]=sum[r]; else mx[r]=val[x],lx[r]=rx[r]=0;
    }
    }
    if(tag[x]) {
    tag[x]=0; tag[l]^=1; tag[r]^=1; swap(tr[l][0],tr[l][1]);
    swap(tr[r][0],tr[r][1]); swap(lx[l],rx[l]); swap(lx[r],rx[r]);      
    }
}

inline void rotate(int x,int &rt){
    int y=father[x],z=father[y];
    int l=(tr[y][1]==x),r=l^1; 
    if(y==rt) rt=x; else tr[z][(tr[z][1]==y)]=x;
    father[x]=z; father[tr[x][r]]=y; tr[y][l]=tr[x][r];
    tr[x][r]=y; father[y]=x; 
    update(y); update(x);
}

inline void splay(int x,int &rt){
    while(x!=rt) {
    int y=father[x],z=father[y];
    if(y!=rt) {
        if((tr[z][0]==y)^(tr[y][0]==x)) rotate(x,rt);//不同边转自己!!!
        else rotate(y,rt);
    }
    rotate(x,rt);
    }
}

inline void build(int l,int r,int fa){
    if(l>r) return ;  int mid=(l+r)/2;
    if(l==r) {
    size[id[l]]=1; same[id[l]]=tag[id[l]]=0; sum[id[l]]=mx[id[l]]=a[l];
    if(a[l]>0) lx[id[l]]=rx[id[l]]=a[l]; else lx[id[l]]=rx[id[l]]=0;        
    }
    else build(l,mid-1,mid),build(mid+1,r,mid);
    tr[id[fa]][mid>fa]=id[mid]; val[id[mid]]=a[mid];
    father[id[mid]]=id[fa];  update(id[mid]);
}

inline int rank(int x,int k){
    pushdown(x);//!!!
    int l=tr[x][0],r=tr[x][1]; if(size[l]+1==k) return x;
    if(size[l]>=k) return rank(l,k); else return rank(r,k-size[l]-1);
}

inline void split(int pos,int num){//操作区间为[pos+1,pos+num]，则需要旋转pos到根，pos+num+1到右子树
    int x=rank(rt,pos); splay(x,rt);
    x=rank(rt,pos+num+1); splay(x,tr[rt][1]);
}

inline void insert(){
    int pos=getint(),num=getint();
    for(int i=1;i<=num;i++) {
    a[i]=getint();
    if(!Q.empty()) id[i]=Q.front(),Q.pop();
    else id[i]=++tot;
    }
    int x=rank(rt,pos+1); splay(x,rt); //!!!
    x=rank(rt,pos+2); splay(x,tr[rt][1]);
    build(1,num,0); int now_root=id[(1+num)/2];
    father[now_root]=tr[rt][1]; tr[tr[rt][1]][0]=now_root;
    update(tr[rt][1]); update(rt);
}

inline void del(){
    int pos=getint(),num=getint(); split(pos,num);
    Del(tr[tr[rt][1]][0]); tr[tr[rt][1]][0]=0;
    update(tr[rt][1]); update(rt);
}

inline void reverse(){
    int pos=getint(),num=getint(); split(pos,num);
    int x=tr[tr[rt][1]][0]; if(same[x]) return ;
    tag[x]^=1;//!!!
    swap(tr[x][0],tr[x][1]); swap(lx[x],rx[x]); 
    update(tr[rt][1]); update(rt);
}

inline void get_sum(){
    int pos=getint(),num=getint(); split(pos,num);
    printf("%d
",sum[tr[tr[rt][1]][0]]);
}

inline void makesame(){
    int pos=getint(),num=getint(),CC=getint(); split(pos,num);
    int x=tr[tr[rt][1]][0]; same[x]=1; val[x]=CC; sum[x]=size[x]*CC; 
    if(CC>0) lx[x]=rx[x]=mx[x]=sum[x]; else lx[x]=rx[x]=0,mx[x]=val[x];
    update(tr[rt][1]); update(rt);
}

inline void work(){
    n=getint(); m=getint(); a[1]=a[n+2]=-inf; mx[0]=-inf;
    for(int i=2;i<=n+1;i++) a[i]=getint(); tot=n+2; rt=(1+n+2)/2;
    for(int i=1;i<=n+2;i++) id[i]=i; build(1,n+2,0);
    while(m--) {
    scanf("%s",ch); lx[0]=rx[0]=size[0]=father[0]=val[0]=0; mx[0]=-inf;
    if(ch[0]=='I') insert();
    else if(ch[0]=='D') del();
    else if(ch[0]=='R') reverse();
    else if(ch[0]=='G') get_sum();
    else if(ch[2]=='K') makesame();
    else printf("%d
",mx[rt]);
    }
}

int main()
{
    work();
    return 0;
}