手动博客搬家: 本文发表于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]\)表示这个区间内(不限端点)的最大子段和。

比如：序列是

  1. a: 1 -4 -2 9 -5 -7 -999 666 -999 3 0
  2. sum[3]=1+(-4)+(-2)+8+(-5)+(-7)+(-999)+666+(-999)+3+0=-1338
  3. sum[2]=3+0=3
  4. sum[1]=1+(-4)+(-2)+9=4
  5. 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)

  1. #include<cstdio>
  2. #include<algorithm>
  3. #include<cstring>
  4. #define llong long long
  5. using namespace std;
  7. const int SZ = 5e5;
  8. const int N = 4e6;
  9. const int INF = 6e8;
  10. struct SplayNode
  11. {
  12.     int fa,son[2],tag,sum[4],sz,val;
  13.     bool rev;
  14.     SplayNode() {fa = son[0] = son[1] = rev = val = sz = 0; tag = sum[0] = sum[1] = sum[2] = sum[3] = -INF;}
  15.     void clear() {fa = son[0] = son[1] = rev = val = sz = 0; tag = sum[0] = sum[1] = sum[2] = sum[3] = -INF;}
  16. } spl[SZ+4],tmp[SZ+4];
  17. int ids[N+4];
  18. int id[SZ+4];
  19. int a[SZ+4];
  20. char opt[14];
  21. int n,q,siz,rtn,tp;
  23. int newnode()
  24. {
  25.     if(tp>0) {int ret = ids[tp]; ids[tp] = 0; tp--; return ret;}
  26.     else {siz++; return siz;}
  27. }
  29. void pushup(int pos) //这里有简化很多的写法，推荐看洛谷题解
  30. {
  31.     if(pos==0) return;
  32.     int ls = spl[pos].son[0],rs = spl[pos].son[1];
  33.     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;}
  34.     if(ls==0 && rs!=0)
  35.     {
  36.         spl[pos].sz = spl[rs].sz+1;
  37.         spl[pos].sum[3] = spl[rs].sum[3]+spl[pos].val;
  38.         spl[pos].sum[2] = max(spl[pos].sum[3],spl[rs].sum[2]);
  39.         spl[pos].sum[1] = max(spl[pos].sum[3],max(spl[pos].val,spl[pos].val+spl[rs].sum[1]));
  40.         spl[pos].sum[0] = max(max(spl[pos].sum[1],spl[pos].sum[2]),spl[rs].sum[0]);
  41.         return;
  42.     }
  43.     if(ls!=0 && rs==0)
  44.     {
  45.         spl[pos].sz = spl[ls].sz+1;
  46.         spl[pos].sum[3] = spl[ls].sum[3]+spl[pos].val;
  47.         spl[pos].sum[2] = max(spl[pos].sum[3],max(spl[pos].val,spl[pos].val+spl[ls].sum[2]));
  48.         spl[pos].sum[1] = max(spl[pos].sum[3],spl[ls].sum[1]);
  49.         spl[pos].sum[0] = max(max(spl[pos].sum[1],spl[pos].sum[2]),spl[ls].sum[0]);
  50.         return;
  51.     }
  52.     spl[pos].sz = spl[ls].sz+spl[rs].sz+1;
  53.     spl[pos].sum[3] = spl[ls].sum[3]+spl[pos].val+spl[rs].sum[3];
  54.     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));
  55.     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));
  56.     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])));
  57. }
  59. void pushdown(int pos)
  60. {
  61.     if(pos==0) return;
  62.     int ls = spl[pos].son[0],rs = spl[pos].son[1];
  63.     if(ls==0 && rs==0) {spl[pos].tag = -INF; spl[pos].rev = 0; return;}
  64.     if(spl[pos].tag>-INF)
  65.     {
  66.         if(ls!=0)
  67.         {
  68.             spl[ls].tag = spl[pos].tag; spl[ls].val = spl[ls].tag;
  69.             spl[ls].sum[3] = spl[ls].tag*spl[ls].sz;
  70.             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;
  71.         }
  72.         if(rs!=0)
  73.         {
  74.             spl[rs].tag = spl[pos].tag; spl[rs].val = spl[rs].tag;
  75.             spl[rs].sum[3] = spl[rs].tag*spl[rs].sz;
  76.             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;
  77.         }
  78.         spl[pos].tag = -INF;
  79.     }
  80.     if(spl[pos].rev==true)
  81.     {
  82.         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]);}
  83.         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]);}
  84.         spl[pos].rev = 0;
  85.     }
  86. }
  88. void rotate(int x,bool dir)
  89. {
  90.     int y = spl[x].fa,z = spl[y].fa;
  91.     pushdown(z); pushdown(y); pushdown(x);
  92.     spl[x].fa = z;
  93.     if(z>0)
  94.     {
  95.         if(spl[z].son[0]==y) spl[z].son[0] = x;
  96.         else spl[z].son[1] = x;
  97.     }
  98.     spl[y].son[dir^1] = spl[x].son[dir];
  99.     if(spl[x].son[dir]>0) spl[spl[x].son[dir]].fa = y;
  100.     spl[x].son[dir] = y; spl[y].fa = x;
  101.     pushup(y); pushup(x); pushup(z);
  102. }
  104. void splaynode(int x,int dest)
  105. {
  106.     while(spl[x].fa!=dest)
  107.     {
  108.         int y = spl[x].fa,z = spl[y].fa;
  109.         if(z==dest)
  110.         {
  111.             if(spl[y].son[0]==x) rotate(x,1);
  112.             else rotate(x,0);
  113.         }
  114.         else if(spl[z].son[0]==y)
  115.         {
  116.             if(spl[y].son[0]==x) {rotate(y,1); rotate(x,1);}
  117.             else {rotate(x,0); rotate(x,1);}
  118.         }
  119.         else
  120.         {
  121.             if(spl[y].son[0]==x) {rotate(x,1); rotate(x,0);}
  122.             else {rotate(y,0); rotate(x,0);}
  123.         }
  124.     }
  125.     if(dest==0) rtn = x;
  126. }
  128. int ranktopos(int th)
  129. {
  130.     int pos = rtn;
  131.     while(pos)
  132.     {
  133.         pushdown(pos);
  134.         if(th<=spl[spl[pos].son[0]].sz) pos = spl[pos].son[0];
  135.         else if(th==spl[spl[pos].son[0]].sz+1) {splaynode(pos,0); return pos;}
  136.         else {th -= spl[spl[pos].son[0]].sz+1; pos = spl[pos].son[1];}
  137.     }
  138.     return 0;
  139. }
  141. void build(int lb,int rb,int cfa)
  142. {
  143.     if(lb>rb) return;
  144.     int mid = (lb+rb)>>1; int pos = newnode(); id[mid] = pos;
  145.     spl[pos].val = spl[pos].sum[0] = spl[pos].sum[1] = spl[pos].sum[2] = spl[pos].sum[3] = a[mid];
  146.     spl[pos].fa = id[cfa];
  147.     if(cfa>mid) spl[id[cfa]].son[0] = pos;
  148.     else spl[id[cfa]].son[1] = pos;
  149.     if(lb==rb) {spl[pos].sz = 1; return;}
  150.     build(lb,mid-1,mid); build(mid+1,rb,mid);
  151.     pushup(pos);
  152. }
  154. void inserttree(int x,int tot)
  155. {
  156.     int posx = ranktopos(x),posy = ranktopos(x+1);
  157.     splaynode(posx,0); splaynode(posy,posx);
  158.     int mid = (1+tot)>>1; int pos = id[mid];
  159.     spl[posy].son[0] = pos; spl[pos].fa = posy;
  160.     pushup(posy); pushup(posx);
  161. }
  163. void deletenode(int pos)
  164. {
  165.     if(spl[pos].son[0]) deletenode(spl[pos].son[0]);
  166.     if(spl[pos].son[1]) deletenode(spl[pos].son[1]);
  167.     tp++; ids[tp] = pos;
  168.     spl[pos].clear();
  169. }
  171. void deletetree(int lb,int rb)
  172. {
  173.     int posl = ranktopos(lb-1),posr = ranktopos(rb+1);
  174.     splaynode(posl,0); splaynode(posr,posl);
  175.     int pos = spl[posr].son[0];
  176.     deletenode(pos);
  177.     spl[posr].son[0] = 0;
  178.     pushup(posr); pushup(posl);
  179. }
  181. void cover(int lb,int rb,int val)
  182. {
  183.     int posl = ranktopos(lb-1),posr = ranktopos(rb+1);
  184.     splaynode(posl,0); splaynode(posr,posl);
  185.     int pos = spl[posr].son[0];
  186.     spl[pos].tag = val; spl[pos].val = val;
  187.     spl[pos].sum[3] = val*spl[pos].sz;
  188.     spl[pos].sum[1] = spl[pos].sum[2] = spl[pos].sum[0] = val>0 ? val*spl[pos].sz : val;
  189.     pushup(posr); pushup(posl);
  190. }
  192. void revint(int lb,int rb)
  193. {
  194.     int posl = ranktopos(lb-1),posr = ranktopos(rb+1);
  195.     splaynode(posl,0); splaynode(posr,posl);
  196.     int pos = spl[posr].son[0];
  197.     spl[pos].rev ^= 1; swap(spl[pos].son[0],spl[pos].son[1]); swap(spl[pos].sum[1],spl[pos].sum[2]);
  198.     pushup(posr); pushup(posl);
  199. }
  201. int querysum(int lb,int rb)
  202. {
  203.     if(rb-lb<0) return 0;
  204.     int posl = ranktopos(lb-1),posr = ranktopos(rb+1);
  205.     splaynode(posl,0); splaynode(posr,posl);
  206.     int pos = spl[posr].son[0];
  207.     return spl[pos].sum[3];
  208. }
  210. int maxsum()
  211. {
  212.     return spl[rtn].sum[0];
  213. }
  215. int main()
  216. {
  217.     scanf("%d%d",&n,&q);
  218.     for(int i=2; i<=n+1; i++) scanf("%d",&a[i]);
  219.     a[1] = a[n+2] = -INF;
  220.     build(1,n+2,0); rtn = id[(n+3)>>1];
  221.     memset(id,0,sizeof(id));
  222.     for(int i=1; i<=q; i++)
  223.     {
  224.         scanf("%s",opt);
  225.         if(opt[0]=='I')
  226.         {
  227.             int x,tot; scanf("%d%d",&x,&tot);
  228.             for(int j=1; j<=tot; j++) {scanf("%d",&a[j]); id[j] = 0;}
  229.             build(1,tot,0);
  230.             inserttree(x+1,tot);
  231.         }
  232.         else if(opt[0]=='D')
  233.         {
  234.             int x,tot; scanf("%d%d",&x,&tot);
  235.             deletetree(x+1,x+tot);
  236.         }
  237.         else if(opt[0]=='M' && opt[2]=='K')
  238.         {
  239.             int x,tot,y; scanf("%d%d%d",&x,&tot,&y);
  240.             cover(x+1,x+tot,y);
  241.         }
  242.         else if(opt[0]=='R')
  243.         {
  244.             int x,tot; scanf("%d%d",&x,&tot);
  245.             revint(x+1,x+tot);
  246.         }
  247.         else if(opt[0]=='G')
  248.         {
  249.             int x,tot; scanf("%d%d",&x,&tot);
  250.             printf("%d\n",querysum(x+1,x+tot));
  251.         }
  252.         else if(opt[0]=='M' && opt[2]=='X')
  253.         {
  254.             printf("%d\n",maxsum());
  255.         }
  256.     }
  257.     return 0;
  258. }

BZOJ 1500 Luogu P2042 [NOI2005] 维护数列 (Splay)的更多相关文章

  1. 洛谷 P2042 [NOI2005]维护数列-Splay(插入 删除 修改 翻转 求和 最大的子序列)

    因为要讲座,随便写一下,等讲完有时间好好写一篇splay的博客. 先直接上题目然后贴代码,具体讲解都写代码里了. 参考的博客等的链接都贴代码里了,有空再好好写. P2042 [NOI2005]维护数列 ...

  2. P2042 [NOI2005]维护数列 && Splay区间操作（四）

    到这里 \(A\) 了这题, \(Splay\) 就能算入好门了吧. 今天是个特殊的日子, \(NOI\) 出成绩, 大佬 \(Cu\) 不敢相信这一切这么快, 一下子机房就只剩我和 \(zrs\) ...

  3. P2042 [NOI2005]维护数列[splay或非旋treap·毒瘤题]

    P2042 [NOI2005]维护数列 数列区间和,最大子列和(必须不为空),支持翻转.修改值.插入删除. 练码力的题,很毒瘤.个人因为太菜了,对splay极其生疏,犯了大量错误,在此记录,望以后一定 ...

  4. Luogu P2042 [NOI2005]维护数列(平衡树)

    P2042 [NOI2005]维护数列 题意 题目描述 请写一个程序,要求维护一个数列,支持以下\(6\)种操作:(请注意,格式栏中的下划线'_'表示实际输入文件中的空格) 输入输出格式 输入格式: ...

  5. Luogu P2042 [NOI2005]维护数列

    题目描述 请写一个程序,要求维护一个数列,支持以下 6 种操作:(请注意,格式栏 中的下划线' _ '表示实际输入文件中的空格) 输入输出格式 输入格式: 输入文件的第 1 行包含两个数 N 和 M, ...

  6. NOI2005 维护数列(splay)

    学了半天平衡树,选择了一道题来写一写,发现题目是裸的splay模板,但是还是写不好,这个的精髓之处在于在数列的某一个位置加入一个数列,类似于treap里面的merge,然后还学到了题解里面的的回收空间 ...

  7. 洛谷.2042.[NOI2005]维护数列(Splay)

    题目链接 2017.12.24 第一次写: 时间: 2316ms (1268ms) 空间: 19.42MB (19.5MB)(O2) 注:洛谷测的时间浮动比较大 /* 插入一段数:将这些数先单独建一棵 ...

  8. 洛谷P2042 [NOI2005]维护数列

    #include<cstdio> #include<cstdlib> #include<algorithm> #include<cstring> #in ...

  9. P2042 [NOI2005]维护数列

    思路 超级恶心的pushdown 昏天黑地的调 让我想起了我那前几个月的线段树2 错误 这恶心的一道题终于过了 太多错误,简直说不过来 pushup pushdown 主要就是这俩不太清晰,乱push ...

随机推荐

  1. IntelliJ IDEA 问题总结之二（待补充） —— 快捷键、主题样式、导出jar、sqlite

    随着对idea的使用,问题越来越多,開始第二篇问题总结. 1.快捷键. 用惯了eclipse再用idea后,快捷键就是一个大问题. 并且网上idea的快捷键有非常多版本号.不知道是不是老版本号和新版本 ...

  2. Android 下使用opencv

    两种方式: 1.java API 2.Native/C++ 方式,OpenCV.mk中默认使用动态库的方式链接opencv,设置OPENCV_LIB_TYPE:=STATIC 以静态库方式调用 htt ...

  3. SqlServer还原步骤

    SqlServer还原步骤 2009-09-05 10:32:12|  分类: 数据库|字号 订阅     1 . 删除原有数据库 新建数据库  hywlxt 2. 在master 中新建存储过程 k ...

  4. C# 验证数字的正则表达式集

    验证数字的正则表达式集 博客分类: 正则 正则表达式 验证数字的正则表达式集 验证数字:^[0-9]*$ 验证n位的数字:^\d{n}$ 验证至少n位数字:^\d{n,}$ 验证m-n位的数字:^\d ...

  5. codeforces 899F Letters Removing set+树状数组

    F. Letters Removing time limit per test 2 seconds memory limit per test 256 megabytes input standard ...

  6. JAVA8与lambda表达式

    一.lambda表达式的来源 Lambda 表达式(拉姆达表达式)来源于lambda演算是Alonzo Church给出的一套图灵机等价的形式计算系统.lambda演算系统以函数和变量为基础,也可以进 ...

  7. Coursera Algorithms week1 查并集 练习测验：2 Union-find with specific canonical element

    题目原文: Add a method find() to the union-find data type so that find(i) returns the largest element in ...

  8. ride关键字

    定义变量:set variable 打印 :log 列表:create list 字符转数字型:evaluate 随机数:evaluate random.randint 日志截图:先导入screens ...

  9. prim解决最小生成树问题

    #include <iostream> #include <algorithm> #include <stdio.h> #include <math.h> ...

  10. Ubuntu16.04开启root用户，并远程登录

    Ubuntu安装完成默认是普通权限的用户,root用户需要手动开启,并且还不含opne-ssh模块 1.给root用户设置密码 #  sudo passwd root 会提示输入unix的新密码,这就 ...