BZOJ 1500 Luogu P2042 [NOI2005] 维护数列 (Splay)

手动博客搬家: 本文发表于20180825 00:34:49, 原地址https://blog.csdn.net/suncongbo/article/details/82027387

题目链接: (luogu) https://www.luogu.org/problem/show?pid=2042

(bzoj) https://www.lydsy.com/JudgeOnline/problem.php?id=1500

思路分析:

这个题嘛。。思路没啥好说的

用splay每个点维护四个量：\(sum[0..3]\), \(sum[3]\)表示splay整个子树代表的区间内元素之和；\(sum[1]\)和\(sum[2]\)分别表示这个区间内以左、右端点开始的元素最大和；\(sum[0]\)表示这个区间内(不限端点)的最大子段和。

比如：序列是

a: 1 -4 -2 9 -5 -7 -999 666 -999 3 0
sum[3]=1+(-4)+(-2)+8+(-5)+(-7)+(-999)+666+(-999)+3+0=-1338
sum[2]=3+0=3
sum[1]=1+(-4)+(-2)+9=4
sum[0]=666=666

区间合并的话，我们可以先想想线段树怎么合并两段区间，分类讨论即可。平衡树由于根节点上还有值，因此合并两段区间+一个值，稍微麻烦点。(这部分略去，不会的可以去做bzoj 1756)

然后就可以开心地码啦！

部分易错点

1. 由于所有插入的元素可能达到\(4\times 10^6\)个, 如果建这么多个splay节点，每一个开\(int\)数组记录，则每个节点维护每个值就会花\(16MB\)空间，然而空间限制\(128MB\), 也就是我们至多维护\(7\)个量。(什么你说8个??你\(128MB\)空间全开了这一个数组，多开一个字节就MLE了啊)而至少我没有想出用每个节点\(7\)个量维护的方法。貌似开\(fa, son[2], sum[4], tag\)就已经\(8\)个了啊..
   
   解决办法: 手写内存回收池, 对于已经删除的节点，把它\(clear\)掉并把编号放到一个内存回收池中，insert时先从内存回收池中取出一个编号来用，如果内存回收池为空再开新节点。这样可以保证平衡树的大小约等于当前序列的大小，因此开\(5\times 10^5\)即可。
2. 由于插入的次数虽然少，但是插入的元素总数是很多的 (一次插入多个)。如果一个一个地插，会导致每次都要\(O(\log n*tot)\), 还带着splay这么大的常数，\(4\times 10^6\)的规模显然是无法承受的。
   
   解决办法：先在\(O(tot)\)的时间内把加入的那\(tot\)个节点建出一棵新的完全BST，然后把\(posi\) splay到根, \(posi+1\) splay到根的右儿子，此时根的右儿子的左儿子为空，把新的平衡树挂到根的右儿子的左儿子上即可。同时注意内存回收池的使用。删除也是类似。删除的时候，首先把删除的节点一起放到根的右儿子的左儿子上，然后\(O(tot)\)地遍历这棵子树，把里面的节点\(clear\)掉并放入内存回收池。
3. 有个地方题面说的不明白: \(MAX-SUM\)操作选出来的子列要非空。
   
   因此碰到了全是负数的整个序列，答案应该是绝对值最小的那个，而不是\(0\).
   
   解决办法: 首先，正常节点的\(sum[0..3], val, tag\)都要设成\(-INF\)而不是\(0\). 根据splay常识，对区间\([l,r]\)单独拎出来进行操作时我们先把\(l-1\) splay到根，再把\(r+1\) splay到根的右儿子。因此为了避免\(l-1\)和\(r+1\)合法，我们可以把要处理的区间平移一位变成\([2,n+1]\), 而\(1\)号点和\((n+2)\)号点作为缓冲点。如果这两个点的\(sum[0..3], val, tag\)不慎设成了0, 则也会导致\(MAX-SUM\)无法处理答案为负(因为程序自动默认两个缓冲点是和最大的子列)。因此无论是正常点还是缓冲点都应该初值赋为\(-INF\). (否则洛谷\(90\)分)
4. 本题有个极坑之处，\(GET-SUM\)操作的\(tot\)可能为\(0\)!
   
   解决办法: 特判 (否则洛谷\(80\)分)

前四条是客观吐槽，后几条就是我自己犯的若干sb问题了

大概是写出了锅*7, 我好菜啊

1. 建树时没有分清原数组中的下标和\(splay\)中的编号。
   
   详见代码。build函数中的mid是原数组，pos是节点编号，而cfa，是父亲节点在原数组中的编号。(有点乱。。)
2. 在\(REVERSE\)操作之后没有交换\(sum[1]\)和\(sum[2]\)并\(pushup\).
   
   由于我们维护的是最大子段和，如果左右子节点被交换，那么\(sum[1]\)和\(sum[2]\)也随之交换。(可以认为节点的加法，即区间合并，不满足交换律)因此在\(REVERSE\)打标记的同时应当交换两个儿子以及该节点的\(sum[1]\)和\(sum[2]\), 并\(pushup\).同时，在pushdown时如果有\(reverse\)标记，也要交换当前节点的\(sum[1]\)和\(sum[2]\)
3. 为了偷懒减少代码长度，\(sum[0]\)的合并少考虑了一种情况。(原地爆炸...以后再也不偷懒了呜呜呜)

好吧再多也没得说了，反正这道题尽管很毒瘤，但也是练习Splay的一道经典码农题，以后一定一定要抽空多写几遍！

怎么跑得这么慢啊...luogu不开O2要排后100了，bzoj开O2, 2137人AC我排1300多呜呜呜

代码实现

(luogu: 4399 ms without O2; bzoj: 5912 ms)

#include<cstdio>
#include<algorithm>
#include<cstring>
#define llong long long
using namespace std;

const int SZ = 5e5;
const int N = 4e6;
const int INF = 6e8;
struct SplayNode
{
    int fa,son[2],tag,sum[4],sz,val;
    bool rev;
    SplayNode() {fa = son[0] = son[1] = rev = val = sz = 0; tag = sum[0] = sum[1] = sum[2] = sum[3] = -INF;}
    void clear() {fa = son[0] = son[1] = rev = val = sz = 0; tag = sum[0] = sum[1] = sum[2] = sum[3] = -INF;}
} spl[SZ+4],tmp[SZ+4];
int ids[N+4];
int id[SZ+4];
int a[SZ+4];
char opt[14];
int n,q,siz,rtn,tp;

int newnode()
{
    if(tp>0) {int ret = ids[tp]; ids[tp] = 0; tp--; return ret;}
    else {siz++; return siz;}
}

void pushup(int pos) //这里有简化很多的写法，推荐看洛谷题解
{
    if(pos==0) return;
    int ls = spl[pos].son[0],rs = spl[pos].son[1];
    if(ls==0 && rs==0) {spl[pos].sz = 1; spl[pos].sum[0] = spl[pos].sum[1] = spl[pos].sum[2] = spl[pos].sum[3]  = spl[pos].val; return;}
    if(ls==0 && rs!=0)
    {
        spl[pos].sz = spl[rs].sz+1;
        spl[pos].sum[3] = spl[rs].sum[3]+spl[pos].val;
        spl[pos].sum[2] = max(spl[pos].sum[3],spl[rs].sum[2]);
        spl[pos].sum[1] = max(spl[pos].sum[3],max(spl[pos].val,spl[pos].val+spl[rs].sum[1]));
        spl[pos].sum[0] = max(max(spl[pos].sum[1],spl[pos].sum[2]),spl[rs].sum[0]);
        return;
    }
    if(ls!=0 && rs==0)
    {
        spl[pos].sz = spl[ls].sz+1;
        spl[pos].sum[3] = spl[ls].sum[3]+spl[pos].val;
        spl[pos].sum[2] = max(spl[pos].sum[3],max(spl[pos].val,spl[pos].val+spl[ls].sum[2]));
        spl[pos].sum[1] = max(spl[pos].sum[3],spl[ls].sum[1]);
        spl[pos].sum[0] = max(max(spl[pos].sum[1],spl[pos].sum[2]),spl[ls].sum[0]);
        return;
    }
    spl[pos].sz = spl[ls].sz+spl[rs].sz+1;
    spl[pos].sum[3] = spl[ls].sum[3]+spl[pos].val+spl[rs].sum[3];
    spl[pos].sum[2] = max(max(spl[pos].sum[3],spl[rs].sum[2]),spl[rs].sum[3]+spl[pos].val+(spl[ls].sum[2]>0 ? spl[ls].sum[2] : 0));
    spl[pos].sum[1] = max(max(spl[pos].sum[3],spl[ls].sum[1]),spl[ls].sum[3]+spl[pos].val+(spl[rs].sum[1]>0 ? spl[rs].sum[1] : 0));
    spl[pos].sum[0] = max(max(max(spl[pos].sum[1],spl[pos].sum[2]),max(spl[ls].sum[0],spl[rs].sum[0])),max(max(spl[pos].val,spl[ls].sum[2]+spl[pos].val+spl[rs].sum[1]),max(spl[pos].val+spl[ls].sum[2],spl[pos].val+spl[rs].sum[1])));
}

void pushdown(int pos)
{
    if(pos==0) return;
    int ls = spl[pos].son[0],rs = spl[pos].son[1];
    if(ls==0 && rs==0) {spl[pos].tag = -INF; spl[pos].rev = 0; return;}
    if(spl[pos].tag>-INF)
    {
        if(ls!=0)
        {
            spl[ls].tag = spl[pos].tag; spl[ls].val = spl[ls].tag;
            spl[ls].sum[3] = spl[ls].tag*spl[ls].sz;
            spl[ls].sum[0] = spl[ls].sum[1] = spl[ls].sum[2] = spl[ls].tag>0 ? spl[ls].tag*spl[ls].sz : spl[ls].tag;
        }
        if(rs!=0)
        {
            spl[rs].tag = spl[pos].tag; spl[rs].val = spl[rs].tag;
            spl[rs].sum[3] = spl[rs].tag*spl[rs].sz;
            spl[rs].sum[0] = spl[rs].sum[1] = spl[rs].sum[2] = spl[rs].tag>0 ? spl[rs].tag*spl[rs].sz : spl[rs].tag;
        }
        spl[pos].tag = -INF;
    }
    if(spl[pos].rev==true)
    {
        if(ls!=0) {spl[ls].rev ^= 1; swap(spl[ls].son[0],spl[ls].son[1]); swap(spl[ls].sum[1],spl[ls].sum[2]);}
        if(rs!=0) {spl[rs].rev ^= 1; swap(spl[rs].son[0],spl[rs].son[1]); swap(spl[rs].sum[1],spl[rs].sum[2]);}
        spl[pos].rev = 0;
    }
}

void rotate(int x,bool dir)
{
    int y = spl[x].fa,z = spl[y].fa;
    pushdown(z); pushdown(y); pushdown(x);
    spl[x].fa = z;
    if(z>0)
    {
        if(spl[z].son[0]==y) spl[z].son[0] = x;
        else spl[z].son[1] = x;
    }
    spl[y].son[dir^1] = spl[x].son[dir];
    if(spl[x].son[dir]>0) spl[spl[x].son[dir]].fa = y;
    spl[x].son[dir] = y; spl[y].fa = x;
    pushup(y); pushup(x); pushup(z);
}

void splaynode(int x,int dest)
{
    while(spl[x].fa!=dest)
    {
        int y = spl[x].fa,z = spl[y].fa;
        if(z==dest)
        {
            if(spl[y].son[0]==x) rotate(x,1);
            else rotate(x,0);
        }
        else if(spl[z].son[0]==y)
        {
            if(spl[y].son[0]==x) {rotate(y,1); rotate(x,1);}
            else {rotate(x,0); rotate(x,1);}
        }
        else
        {
            if(spl[y].son[0]==x) {rotate(x,1); rotate(x,0);}
            else {rotate(y,0); rotate(x,0);}
        }
    }
    if(dest==0) rtn = x;
}

int ranktopos(int th)
{
    int pos = rtn;
    while(pos)
    {
        pushdown(pos);
        if(th<=spl[spl[pos].son[0]].sz) pos = spl[pos].son[0];
        else if(th==spl[spl[pos].son[0]].sz+1) {splaynode(pos,0); return pos;}
        else {th -= spl[spl[pos].son[0]].sz+1; pos = spl[pos].son[1];}
    }
    return 0;
}

void build(int lb,int rb,int cfa)
{
    if(lb>rb) return;
    int mid = (lb+rb)>>1; int pos = newnode(); id[mid] = pos;
    spl[pos].val = spl[pos].sum[0] = spl[pos].sum[1] = spl[pos].sum[2] = spl[pos].sum[3] = a[mid];
    spl[pos].fa = id[cfa];
    if(cfa>mid) spl[id[cfa]].son[0] = pos;
    else spl[id[cfa]].son[1] = pos;
    if(lb==rb) {spl[pos].sz = 1; return;}
    build(lb,mid-1,mid); build(mid+1,rb,mid);
    pushup(pos);
}

void inserttree(int x,int tot)
{
    int posx = ranktopos(x),posy = ranktopos(x+1);
    splaynode(posx,0); splaynode(posy,posx);
    int mid = (1+tot)>>1; int pos = id[mid];
    spl[posy].son[0] = pos; spl[pos].fa = posy;
    pushup(posy); pushup(posx);
}

void deletenode(int pos)
{
    if(spl[pos].son[0]) deletenode(spl[pos].son[0]);
    if(spl[pos].son[1]) deletenode(spl[pos].son[1]);
    tp++; ids[tp] = pos;
    spl[pos].clear();
}

void deletetree(int lb,int rb)
{
    int posl = ranktopos(lb-1),posr = ranktopos(rb+1);
    splaynode(posl,0); splaynode(posr,posl);
    int pos = spl[posr].son[0];
    deletenode(pos);
    spl[posr].son[0] = 0;
    pushup(posr); pushup(posl);
}

void cover(int lb,int rb,int val)
{
    int posl = ranktopos(lb-1),posr = ranktopos(rb+1);
    splaynode(posl,0); splaynode(posr,posl);
    int pos = spl[posr].son[0];
    spl[pos].tag = val; spl[pos].val = val;
    spl[pos].sum[3] = val*spl[pos].sz;
    spl[pos].sum[1] = spl[pos].sum[2] = spl[pos].sum[0] = val>0 ? val*spl[pos].sz : val;
    pushup(posr); pushup(posl);
}

void revint(int lb,int rb)
{
    int posl = ranktopos(lb-1),posr = ranktopos(rb+1);
    splaynode(posl,0); splaynode(posr,posl);
    int pos = spl[posr].son[0];
    spl[pos].rev ^= 1; swap(spl[pos].son[0],spl[pos].son[1]); swap(spl[pos].sum[1],spl[pos].sum[2]);
    pushup(posr); pushup(posl);
}

int querysum(int lb,int rb)
{
    if(rb-lb<0) return 0;
    int posl = ranktopos(lb-1),posr = ranktopos(rb+1);
    splaynode(posl,0); splaynode(posr,posl);
    int pos = spl[posr].son[0];
    return spl[pos].sum[3];
}

int maxsum()
{
    return spl[rtn].sum[0];
}

int main()
{
    scanf("%d%d",&n,&q);
    for(int i=2; i<=n+1; i++) scanf("%d",&a[i]);
    a[1] = a[n+2] = -INF;
    build(1,n+2,0); rtn = id[(n+3)>>1];
    memset(id,0,sizeof(id));
    for(int i=1; i<=q; i++)
    {
        scanf("%s",opt);
        if(opt[0]=='I')
        {
            int x,tot; scanf("%d%d",&x,&tot);
            for(int j=1; j<=tot; j++) {scanf("%d",&a[j]); id[j] = 0;}
            build(1,tot,0);
            inserttree(x+1,tot);
        }
        else if(opt[0]=='D')
        {
            int x,tot; scanf("%d%d",&x,&tot);
            deletetree(x+1,x+tot);
        }
        else if(opt[0]=='M' && opt[2]=='K')
        {
            int x,tot,y; scanf("%d%d%d",&x,&tot,&y);
            cover(x+1,x+tot,y);
        }
        else if(opt[0]=='R')
        {
            int x,tot; scanf("%d%d",&x,&tot);
            revint(x+1,x+tot);
        }
        else if(opt[0]=='G')
        {
            int x,tot; scanf("%d%d",&x,&tot);
            printf("%d\n",querysum(x+1,x+tot));
        }
        else if(opt[0]=='M' && opt[2]=='X')
        {
            printf("%d\n",maxsum());
        }
    }
    return 0;
}