BZOJ1500: [NOI2005]维修数列

Posted 2020-11-02 符拉迪沃斯托克

BZOJ1500: [NOI2005]维修数列

Description

请写一个程序，要求维护一个数列，支持以下 6 种操作：

请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格

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

 

题解Here!

区间翻转，当然 Splay ！

如果你真的要用 Fhq Treap 我也不会拦着。。。

初始化

首先，对于原序列，我们一个一个读入，然后插入，那么效率就是O(nlogn)。

而splay的常数本身就很大，对于1s的时限比较紧，所以考虑一个优化：

就是把原序列一次性读入后，直接类似线段树的buildtree，搞一个整体建树，即不断的将当前点维护的区间进行二分，到达单元素区间后，就把对应的序列值插入进去，即：

mid=l+r>>1;
lson=buildtree(l,mid-1);
rt=newnode(val[rt]);
rson=buildtree(mid+1,r);
pushup(rt);

这样，我们一开始建的树就是一个非常平衡的树，可以使后续操作的常数更小，并且建树整个复杂度只是O(2n)的。

注意添加头尾的哨兵节点。

Insert操作

不用想，不可能是边读入边插入。那怎么办？

我们可以这么做，先把k+1（注意我们将需要操作的区间右移了一个单位，所以题目所给k，我们需要操作k+1）移到根节点的位置，把原树中的k+2移到根节点的右儿子的位置。

然后把需要insert的区间，建成一个平衡树，将其根直接连到原树中k+2的左儿子上就行了。

Delete操作

同样，不可能是边读入边删除。

我们同样的，把需要delete的区间变成 [ k+1 , k+tot ]（注意，是删去k后面的tot个数，那么可以发现我们需要操作的原区间是[k,k+tot-1]）；

然后把 k 号节点移到根节点的位置，把 k+tot+2 移到根节点的右儿子位置，然后直接把 k+tot+2 的左子树全部清为0，就把这段区间删掉了。

可以发现，比insert还简单一点。

Reverse操作

接下来，这道题的重头戏就要开始了——为什么一定要用 Splay 。

splay的区间操作基本原理还类似于线段树的区间操作，即延迟修改，又称打懒惰标记。

我们依旧是将操作区间变成 [ k+1 , k+tot ] ，然后把 k 和 k+tot+1 分别移到根与其右儿子的位置，然后对这个右儿子的左儿子打上翻转标记即可。

Make-Same操作

我们同样需要先将需要操作的区间变成 [k+1 , k+tot ] ，然后把 k 和 k+tot+1 分别移到根和右儿子的位置，然后对这个右儿子的左儿子打上修改标记即可。

Get-Sum操作

我们还是将操作区间变成 [ k+1 , k+tot ] ，然后把 k 和 k+tot+1 分别移到根和右儿子的位置，然后直接输出这个右儿子的左儿子上记录的和值。

Max-Sum操作

对于这个求最大子序列的操作，即Max-Sum操作，我们不能局限于最开始学最大子序列的线性dp方法，而是要注意刚开始，基本很多书都会介绍一个分治的O(nlogn)的方法，但是由于存在O(n)的方法，导致这个方法并不受重视，但是这个方法确实很巧妙，当数列存在修改操作时，线性的算法就不再适用了。

这种带修改的最大子序列的问题，最开始是由线段树来维护，具体来说就是，对于线段树上的每个节点所代表的区间，维护3个量：

suml 表示从区间左端点 l 开始的连续的前缀最大子序列。

sumr 表示从区间右端点 r 开始的连续的后缀最大子序列。

sum 表示这个区间中的最大子序列。

那么在合并[l,mid]和[mid+1,r]时，就类似一个dp的过程了！其中

suml[l,r]=max(suml[l,mid],w[l,mid]+sum[mid+1,r])
sumr[l,r]=max(sumr[mid+1,r],w[mid+1,r]+sumr[l,mid])
sum[l,r]=max(sum[l,mid],sum[mid+1,r],suml[mid+1,r]+sumr[l,mid+1])
//w[l,r]是区间和值

这个还是很好理解的，就是选不选mid的两个决策。

但是其实在实现的时候，我们并不用 [ l , r ] 的二维方式来记录这三个标记，而是用对应的节点编号来表示区间，这个可以看程序，其实是个很简单的东西。

那么最大子序列这个询问操作就可以很简单的解决了，还是类比前面的方法，就是把 k 和 k+tot+1 移到对应的根和右儿子的位置，然后直接输出右儿子的左儿子上的 sum 标记即可。

懒惰标记

最后，相信认真看了的童鞋会有疑问，这个标记怎么下传呢？

首先，我们在每次将 k 和 k+tot+1 移到对应的位置时，需要一个查找 k大值 的 kth 操作，这个才是我们真正需要处理的区间端点编号。

那么就好了，我们只需在查找的过程中下传标记 pushdown 一下就好了！（其实线段树中也是这么做的）

因为我们所有的操作都需要先 kth 一下，所以我们可以保证才每次操作的结果计算出来时，对应的节点的标记都已经传好了。

而我们在修改时，直接修改对应节点的记录标记和懒惰标记，因为我们的懒惰标记记录的都是已经对当前节点产生贡献，但是还没有当前节点的子树区间产生贡献！

然后就是每处有修改的地方都要 pushup 一下就好了。

附：pushdown的写法

不少人会将pushdown写成：

if(lson)a[lson].flag^=1;
if(rson)a[rson].flag^=1;
a[rt].flag^=1;
swap(lson,rson);

但是这是不对的！应该：

if(a[rt].flag){
    if(a[rt].son[0]){
        a[a[rt].son[0]].flag^=1;
        swap(a[a[rt].son[0]].son[0],a[a[rt].son[0]].son[1]);
    }
    if(a[rt].son[1]){
        a[a[rt].son[1]].flag^=1;
        swap(a[a[rt].son[1]].son[0],a[a[rt].son[1]].son[1]);
    }
    a[rt].flag^=1;
}

虽然我也不知道为什么。。。

我只知道要类似线段树的pushdown。。。

细节处理

由于本题数据空间卡的非常紧，我们就需要用时间换空间，直接开 4000000*logm 的数据是不现实的。

但是由于题目保证了同一时间在序列中的数字的个数最多是500000，所以我们考虑一个回收机制：

把用过但是已经删掉的节点编号记录到一个队列中，在新建节点时直接把队列中的冗余编号搞过来就好了。

吐槽：这种题就是毒瘤，考场上估计只有国家队队爷才有时间敲正解。。。

附代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#define MAXN 500010
#define MAX 999999999
using namespace std;
queue<int> point;
int n,m,size=1,root,val[MAXN];
struct node{
    int f,s,flag,set,son[2];
    int v,w,sum,suml,sumr;
}a[MAXN];
inline int read(){
    int date=0,w=1;char c=0;
    while(c<‘0‘||c>‘9‘){if(c==‘-‘)w=-1;c=getchar();}
    while(c>=‘0‘&&c<=‘9‘){date=date*10+c-‘0‘;c=getchar();}
    return date*w;
}
inline void clean(int rt){
    a[rt].son[0]=a[rt].son[1]=a[rt].f=a[rt].s=a[rt].flag=a[rt].v=a[rt].w=0;
    a[rt].sum=a[rt].suml=a[rt].sumr=-MAX;
}
inline void pushup(int rt){
    if(!rt)return;
    a[rt].s=a[a[rt].son[0]].s+a[a[rt].son[1]].s+1;
    a[rt].w=a[a[rt].son[0]].w+a[a[rt].son[1]].w+a[rt].v;
    a[rt].suml=max(a[a[rt].son[0]].suml,a[a[rt].son[0]].w+a[rt].v+max(0,a[a[rt].son[1]].suml));
    a[rt].sumr=max(a[a[rt].son[1]].sumr,a[a[rt].son[1]].w+a[rt].v+max(0,a[a[rt].son[0]].sumr));
    a[rt].sum=max(a[rt].v+max(0,a[a[rt].son[0]].sumr)+max(0,a[a[rt].son[1]].suml),max(a[a[rt].son[0]].sum,a[a[rt].son[1]].sum));
}
inline void pushdown(int rt){
    if(!rt)return;
    if(a[rt].set!=-MAX){
        if(a[rt].son[0]){
            a[a[rt].son[0]].set=a[a[rt].son[0]].v=a[rt].set;
            a[a[rt].son[0]].w=a[rt].set*a[a[rt].son[0]].s;
            a[a[rt].son[0]].suml=a[a[rt].son[0]].sumr=a[a[rt].son[0]].sum=max(a[a[rt].son[0]].set,a[a[rt].son[0]].w);
        }
        if(a[rt].son[1]){
            a[a[rt].son[1]].set=a[a[rt].son[1]].v=a[rt].set;
            a[a[rt].son[1]].w=a[rt].set*a[a[rt].son[1]].s;
            a[a[rt].son[1]].suml=a[a[rt].son[1]].sumr=a[a[rt].son[1]].sum=max(a[a[rt].son[1]].set,a[a[rt].son[1]].w);
        }
        a[rt].set=-MAX;
        a[rt].flag=0;
    }
    if(a[rt].flag){
        if(a[rt].son[0]){
            a[a[rt].son[0]].flag^=1;
        	swap(a[a[rt].son[0]].suml,a[a[rt].son[0]].sumr);
            swap(a[a[rt].son[0]].son[0],a[a[rt].son[0]].son[1]);
        }
        if(a[rt].son[1]){
            a[a[rt].son[1]].flag^=1;
        	swap(a[a[rt].son[1]].suml,a[a[rt].son[1]].sumr);
            swap(a[a[rt].son[1]].son[0],a[a[rt].son[1]].son[1]);
        }
        a[rt].flag^=1;
    }
}
inline int newnode(int x){
    int rt;
    if(point.empty())rt=size++;
    else{
        rt=point.front();
        point.pop();
    }
    a[rt].v=x;
    a[rt].suml=a[rt].sumr=a[rt].sum=-MAX;
    a[rt].flag=0;a[rt].set=-MAX;
    return rt;
}
inline void turn(int rt,int k){
    int x=a[rt].f,y=a[x].f;
    a[x].son[k^1]=a[rt].son[k];
    if(a[rt].son[k])a[a[rt].son[k]].f=x;
    a[rt].f=y;
    if(y)a[y].son[a[y].son[1]==x]=rt;
    a[x].f=rt;
    a[rt].son[k]=x;
    pushup(x);pushup(rt);
}
void splay(int rt,int ancestry){
    while(a[rt].f!=ancestry){
        int x=a[rt].f,y=a[x].f;
        if(y==ancestry)turn(rt,a[x].son[0]==rt);
        else{
            int k=a[y].son[0]==x?1:0;
            if(a[x].son[k]==rt){turn(rt,k^1);turn(rt,k);}
            else{turn(x,k);turn(rt,k);}
        }
    }
    if(ancestry==0)root=rt;
}
int kth(int rt,int k){
    if(a[rt].s<k)return 0;
    while(1){
        pushdown(rt);
        int y=a[rt].son[0];
        if(k>a[y].s+1){
            rt=a[rt].son[1];
            k-=a[y].s+1;
        }
        else if(k<=a[y].s)rt=y;
        else return rt;
    }
}
int buildtree(int l,int r){
    if(l>r)return 0;
    int rt,mid=l+r>>1,lson=0,rson=0;
    lson=buildtree(l,mid-1);
    rt=newnode(val[mid]);
    rson=buildtree(mid+1,r);
    a[rt].son[0]=lson;
    a[rt].son[1]=rson;
    if(lson)a[lson].f=rt;
    if(rson)a[rson].f=rt;
    pushup(rt);
    return rt;
}
inline void split(int front,int next){
    splay(front,0);splay(next,front);
}
inline void insert(int rt,int x,int y){
    int front=kth(rt,x+1),next=kth(rt,x+2);
    split(front,next);
    int k=a[next].son[0];
    rt=buildtree(1,y);
    a[next].son[0]=rt;a[rt].f=next;
    pushup(next);pushup(front);
}
void delete_x(int rt){
    if(!rt)return;
    point.push(rt);
    if(a[rt].son[0])delete_x(a[rt].son[0]);
    if(a[rt].son[1])delete_x(a[rt].son[1]);
    clean(rt);
}
inline void remove(int rt,int l,int r){
    int front=kth(rt,l),next=kth(rt,r+2);
    split(front,next);
    int k=a[next].son[0];
    if(k)delete_x(k);
    a[next].son[0]=0;
    pushup(next);pushup(front);
}
inline void reverge(int rt,int l,int r){
    int front=kth(rt,l),next=kth(rt,r+2);
    split(front,next);
    int k=a[next].son[0];
    if(!k)return;
    a[k].flag^=1;
    swap(a[k].son[0],a[k].son[1]);
    swap(a[k].suml,a[k].sumr);
    pushup(next);pushup(front);
}
inline void same(int rt,int l,int r,int x){
    int front=kth(rt,l),next=kth(rt,r+2);
    split(front,next);
    int k=a[next].son[0];
    if(!k)return;
    a[k].set=a[k].v=x;
    a[k].w=x*a[k].s;
    a[k].suml=a[k].sumr=a[k].sum=max(x,a[k].w);
    pushup(next);pushup(front);
}
void work(){
    int x,y,k;
    char ch[20];
    while(m--){
        scanf("%s",ch);
        switch(ch[0]){
            case ‘I‘:{
                x=read();y=read();
                for(int i=1;i<=y;i++)val[i]=read();
                insert(root,x,y);
                n+=y;
                break;
            }
            case ‘D‘:x=read();y=read();n-=y;remove(root,x,x+y-1);break;
            case ‘R‘:x=read();y=read();reverge(root,x,x+y-1);break;
            case ‘G‘:{
                x=read();y=read();
    			int front=kth(root,x),next=kth(root,x+y+1);
                split(front,next);
                int k=a[next].son[0];
                printf("%d\n",a[k].w);
                break;
            }
            case ‘M‘:{
                if(ch[4]==‘-‘){
                	x=read();y=read();k=read();
                	same(root,x,x+y-1,k);
                }
                else{
                    x=1;y=n;
    				int front=kth(root,x),next=kth(root,x+y+1);
                    split(front,next);
                    int k=a[next].son[0];
                    printf("%d\n",a[k].sum);
                }
                break;
            }
        }
    }
}
void init(){
    n=read();m=read();
    for(int i=1;i<=n;i++)val[i]=read();
    val[0]=val[n+1]=0;
    clean(0);clean(n+1);
    root=buildtree(0,n+1);
}
int main(){
    init();
    work();
    return 0;
}