C++博客-Mato is No.1-随笔分类-线段树

统计的力量

Mato_No1 — Fri, 13 Sep 2013 05:29:00 GMT

摘要: Orz zkw！！！最近看完了《统计的力量》……觉得这实在是太神了……原来线段树可以这么写……zkw线段树的思想：先将线段长度N变为2的整数次方，使线段树成为满二叉树，然后就可以通过各种位运算直接链接到某个结点，不必递归了，因此大大减小了常数……本沙茶利用zkw线段树在BZOJ1756和1798上都刷到... 阅读全文

Mato_No1 2013-09-13 13:29 发表评论

【AHOI2013复仇】两道有关删边后最短路径维护的猥琐题

Mato_No1 — Sat, 19 Jan 2013 08:49:00 GMT

摘要: 【先祝贺一下@Jollwish神犇进入CMO国家集训队……合肥OI人总算出了个国家集训队员（虽然不是OI的）……】最近捉了两道猥琐题……都是有关图中删去某边后的最短路径的问题……核心思想几乎相同……但是，它们很明显是综合题，代码量太大了（与NOIP2012的drive和block... 阅读全文

Mato_No1 2013-01-19 16:49 发表评论

【AHOI2013复仇】关于线段树下标的一种优化表示法

Mato_No1 — Sat, 01 Dec 2012 04:11:00 GMT

在线段树中，一般都不需要刻意保存其左右子结点的下标，而直接由其本身的下标导出，传统的写法是：
根结点：1
A的左子结点：2A（写成A<<1）
A的右子结点：2A+1（写成(A<<1)+1）
这种表示法可以表示出整棵线段树，因为：
（1）每个结点的子结点的下标都比它大，这样就不会出现环；
（2）每个结点的父结点都是唯一的（其本身下标整除2）；
但是，这种表示法有一个弱点：结点的下标是有可能超过2N的，但不会超过4N，因此，为了表示出跨度为N的线段，我们需要开4N的空间，然而，其中只有2N-1个位置是有用的（因为表示跨度为N的线段的线段树共有(2N-1)个结点），这样，就有一半的空间被浪费。尤其是这种线段树推广到多维的时候——K维线段树就只有1/2^K的位置是有用的，空间利用率非常低。在某些卡空间的场合，它就囧掉了。

那么，有木有好一点的写法呢？最好能使空间利用率达到100%——也就是所有结点的下标刚好就是1~(2N-1)！！（0号结点一般作为“哨兵”，不被占用）
并且，这种写法要保证仅仅由结点的下标和它表示的线段的左右端点（因为在遍历线段时，下标和左右端点基本上都是同时知道的），就能得出其子结点的下标，而不需要借助额外的东东（最好mid都不需要算）。
这种写法就是——直接将每个结点的DFS遍历次序当做它的下标！！
比如，跨度为6的线段树：

容易发现，根结点下标为1，下标为A的结点的左子结点下标为(A+1)，右子结点下标为A+SZ(A.L)+1，其中SZ(A.L)为A的左子树大小。
若A的左右端点为l、r，mid=(l+r)/2（下取整），则A的左子树所表示的线段为[l, mid]，所以SZ(A.L)=(mid-l+1)*2-1=(mid-l)*2+1=((r-l-1)/2（上取整）)*2+1
这样，A的右子结点下标就是A+((r-l+1)/2（上取整))*2，也就是A加上大于(r-l)的最小的偶数；
写在代码里就是：

int mid=l+r>>1;
opr(l, mid, A+1);
opr(mid+1, r, (r-l&1?A+r-l+1:A+r-l+2));

或者，借助位运算，可以免去条件判断：

int mid=l+r>>1;
opr(l, mid, A+1);
opr(mid+1, r, A+r-l+2-((r^l)&1));

经测试，后者（使用位运算的）虽然总的运算次数多于前者（使用条件判断的），但后者比前者快一点点，其原因可能与C语言中的条件运算符速度较慢有关；

这样，我们就成功地将线段树下标的空间利用率提高到了100%！！以后只需要开2N空间就行了囧……
与传统表示法相比，这种新式表示法虽然可以节省空间，但时间消耗要更大一些（时间和空间总是矛盾的囧……），因为它在找右子结点的时候需要较多的运算。平均起来，新式表示法比传统表示法要慢10~15%，对于某些坑爹的数据（对右子结点调用比较多的那种）可能慢得更多。此外，在下放标记的时候，传统表示法只需要知道结点下标就行了，而新式表示法必须同时知道结点的左右端点，这样在dm中就需要传递三个参数，从而要慢一些，当然，我们可以不用dm，直接在操作里面写标记下放。

Mato_No1 2012-12-01 12:11 发表评论

【AHOI2013复仇】再看HDU2871

Mato_No1 — Sun, 25 Nov 2012 06:54:00 GMT

原题地址
本沙茶去年曾经用双线段树的方法捉了这题（详见这里），最近重新审视这题发现，借助平衡树，可以得到更简单的方法。

题目大意：
有一个长度为N的内存条，每个位置的状态有占用和不占用两种，有4种操作：
（1）Reset：清空所有内存（即将所有位置的状态改为不占用，删除所有内存块）；
（2）New x：申请一个新的内存块，即找到一个长度为x的连续不占用位置区间，将它们标记为占用，若有多个这样的区间，取最左边的，若木有输出Reject New；
（3）Free x：在已申请的内存块中，找到包含位置x的并释放（将该内存块删除，同时其占用的所有位置改为不占用），若木有内存块包含位置x，则输出Reject Free；
（4）Get x：找出已申请的内存块中，左起第x个，并输出其左端点；若已申请的内存块数目不足x个，则输出Reject Get。

可以发现，每个已经申请的内存块尽管代表一段区间，但仍然是独立的单位，因此，可以把内存块当成结点，用平衡树维护（关键字为内存块的左端点位置），New操作中内存块的插入与Free操作中内存块的删除均在此平衡树内进行，Reset操作只需要将整棵树销毁即可。
问题是，在New操作中，需要找到一个长度为x的连续不占用区间，而连续的不占用区间并不是独立的单位，因此需要使用线段树维护。在线段树中，需要维护<1>结点区间内最长连续不占用块的长度；<2>结点区间左端、右端连续不占用块的长度（否则无法维护<1>）；同时，由于在New操作中需要区间整体改占用，Free操作中又需要区间整体改不占用，所以应当支持整体改值的标记，对于Reset操作，只需要全部位置改不占用即可（不能重新建树！！）；

这样，利用一棵平衡树加一棵线段树，就可以得到一个很简单的方法了（代码量是双平衡树或双线段树的一半左右）；

这题的启示是，在解决数据结构统计类题的时候，到底选用什么样的数据结构，是有讲究的，因为它将直接影响到编程复杂度。一般来说，线段树比平衡树好写，但是对本题而言，双线段树反而不如平衡树加线段树好写，这是因为对于内存块使用平衡树维护比使用线段树维护更好。在以后做这种题的时候，要多想一下，找到简便方法。

Mato_No1 2012-11-25 14:54 发表评论

线段树操作极品题——HDU2871

Mato_No1 — Sun, 18 Dec 2011 00:58:00 GMT

原题地址
这是一道线段树操作的极品题，因为它的4个操作刚好覆盖了线段树操作问题的3种处理思路，可以说是把线段树操作的全部内容都包含进去了。

线段树是一种静态的数据结构，因为一棵线段树一旦建成，其形态就永远不会发生变化，改变的仅仅是结点上记录的各种信息的值。因此，对于线段树操作，核心问题也就是如何维护和处理这些信息。总的来说，对于线段树结点信息的维护和处理，有以下3种基本思路：
（1）左右归中型：
所谓左右归中，就是用左右子结点存储的信息来得到父结点存储的信息的值，这是最常见的线段树维护方法。举一些简单的例子：比如结点的SUM域表示该结点区间上所有元素的和，那么这个域维护的方法就是“父结点SUM=左子结点SUM+右子结点SUM”，再比如结点的MAX/MIN域表示该结点区间上所有元素的最大/小值，那么维护方法就是“父结点MAX/MIN=max/min{左子结点MAX/MIN,右子结点MAX/MIN}”。这种维护方法也比较简单，只要在每次对子结点进行修改之后upd一下就行了（对于那些自顶向下递归，而且涉及到改值的操作，在递归完左右子结点后一定要记得upd一下），在这之中有一个很重要的思想就是“左右连续段”思想：如果题目中要求任意一个区间内的具有某种性质的最长的连续序列（也就是子区间），比如最长连续上升子序列、01值问题中连续的0段或者非0段（在具体问题中就是连续的空闲段或者占用段）等，可以在每个结点上维护三个域：lS、rS和S，分别表示该结点区间左端（从区间的最左端开始的）具有这种性质的最长连续序列的长度，该结点区间右端（到区间的最右端结束的）具有这种性质的最长连续序列的长度和该区间内具有这种性质的最长连续序列的长度（也就是要求的那个东东），则维护方法为“父结点lS=左子结点lS（左子结点lS<左子结点len）或左子结点len+右子结点lS（左子结点lS=左子结点len），父结点rS类似，父结点S=max{左子结点S,右子结点S,左子结点rS+右子结点lS}”，此外，由于要求的这个区间可能被拆成多个连续的结点区间，因此需要按顺序合并这些区间，合并的方法是：设立S0和S1，S0表示不保证能延伸下去的区间长度，S0=上一个区间的S1+本区间的lS；S1表示可以延伸下去的区间长度，S1=上一个区间的S1+本区间len（如果本区间整个都是满足条件的，即S=len）或本区间的rS（本区间不都是满足条件的，即S在HDU2871中，应用左右归中的方法维护的信息就是“最长连续空闲段”的长度，New操作需要；

（2）调整边界型：
考虑这样一个问题：现在要插入、删除一些[0, 100000)的整数，并且在此过程中不断询问第K小的整数是多少，怎么办？平衡树可以实现，但线段树显然是更好的方法。对每个结点，存储一个K0值表示位于该结点区间内的整数的个数，则查找第K小的时候只需要不断执行以下操作：Kth(A, K)，表示在结点A代表的区间内找第K小的，然后，若K<=结点A的左子结点K0值，则执行Kth(A的左子结点, K)，否则执行Kth(A的右子结点, K-A左子结点的K0)（这和平衡树神似），直到找到叶结点为止。这种方法称为“调整边界型”，即随着结点深入，不断缩小（自顶向下）或扩大（自底向上）范围，最后找到结果。像找第K小这样的操作属于自顶向下型，而像“找到X所在的具有某种性质的最长的连续区间”就属于自底向上型（注意和本题的Free不一样）；

（3）标记辅助型：
这种维护信息的方法，特点是利用标记来维护信息，即对于某些结点（主要是叶结点，因为其标记不再下放），直接使用标记来得到一些数据，比如对于HDU2871这一题，其中对于叶结点位于的插入线段的标号，使用的就是标记。

下面是本题4个操作的具体实现：
<1>线段树结点定义：
本题需要两棵线段树，这是因为New与Free操作对于tot域（插入线段左端点的总个数）会造成不同的影响，具体来说，在New操作中，tot值不会被同时加上（需要另外一个操作加上），然而在Free操作中，tot值会被同时清空，这样就会导致在对某个结点清空（该结点包含在某个Free操作要清空的线段中）并打上0标记之后，如果紧接着又插入一条包含这个结点区间的新线段，则这个结点的0标记就会丧失，这样在紧接着下传的时候，其子结点的tot值就不会被清空（事实上已经被清空了）。所以，将tot域彻底转移到另一棵线段树里。

struct node {
    int len, mr, lsc, rsc, sc;
} T[MAXN << 2];
struct node0 {
    int tot;
    bool mr;
} T0[MAXN << 2];

其中lsc、rsc、sc就是连续空闲段的长度（用左右归中的方法维护），mr是一个整体赋值标记，在T中，mr的值若为-1表示无标记（未被整体赋值），若为0表示被整体清空，若大于0表示整体被一条线段覆盖，mr值就是这条线段的编号（为区分不同线段，这里按照输入顺序对每一条New操作插入的线段以1、2……编号），在T0中，mr=1表示在Reset中被整体清空，mr=0表示无标记。
<2>操作处理：
1)Reset操作：将T、T0的根结点打上清空标记即可；
2)New：涉及到两个操作，分别是找最左的长度为x的连续空闲段，以及插入一条线段。对于前者，可以根据lsc、rsc、sc的值，按照“先左子结点，再跨越两个子结点，最后右子结点”的顺序求得（详见代码）；对于后者就不用说了，太容易实现了（注意标记的处理以及upd，另外要插入一个tot）；
3)Free：也涉及两个操作，分别是找一个点x所在的线段（插入过的线段）长度以及删除一条线段，对于前者可将New插入过的所有线段的左右端点预存起来，然后找到代表区间[x, x]的结点的mr值（也就是结点x被编号为神马的线段覆盖），再在预存的线段中找到即可。对于后者，直接清空即可（不要在T0中打标记，而要单独删除一个tot）；
4)Get：直接利用T0中的tot找到第K小的值即可；

代码

Mato_No1 2011-12-18 08:58 发表评论

数据结构复习题汇总（不断更新中）

Mato_No1 — Fri, 22 Jul 2011 18:24:00 GMT

【1】IOI2009 hiring（这个在各大OJ上都找不到囧，只能看这里了囧，第11页）
可以发现本题就是求一个比率rate，使得第i个人（如果用的话）工资为rate*Qi，并且还要满足以下两个限制条件：
（1）每人的最低工资限制：第i个人如果用的话，有rate*Qi>=Si，即rate>=Si/Qi；
（2）总开销限制：rate*所有用的人的Q值之和<=W，即所有用的人的Q值之和<=W/rate。
这样，可以先将所有人按照(S/Q)的值递增排序，然后枚举需要用的最后一个人（排序后的，也就是S/Q值最大的那个人），设为i，则总花费最省的做法显然是取rate=Si/Qi。然后根据（2）式得出“所有用的人的Q值之和”的最大值W0=W/rate，其中，第i个人是必须要用的，故将W0值先减去Qi（若W0总时间复杂度：O(N * (log20000 + logN))（还有排序的时间）
代码

【2】RQNOJ469
先按照任意一种属性（这里为A）递增排序，然后枚举值i，排序后第1位~第i位的全部给A（看A属性，它们中A属性最大的一定是i），排序后第(i+1)位及以后的，看其B、C两种属性的大小，若B属性更小就看B属性，若C属性更小就看C属性，然后得出两种属性的最大值即可。因此可以得到下面的算法：先排序，然后将所有的毛的B或C属性（哪种更小就看哪种）插入平衡树（这里需要两棵平衡树，一棵存放B属性的值，一棵存放C属性的值），然后递增枚举i（注意i=0的情况不要漏掉），将第i位的B或C属性在平衡树中删除，然后找出两棵平衡树中的最大值即可。
但是需要注意一种特殊情况：所有的毛都看同一个属性，此时按照上面的算法可能求不出最优解，比如：
10 6 5
10 2 8
此时，第1个C属性更小，第2个B属性更小，若第1个看C属性，第2个看B属性，则总和为5+2=7，而如果两个都看B属性则总和为6。此时就需要特判（预先求出三种属性中的最大值），然后再用上面的算法求解，就能保证求出最优解了。
代码

【3】PKU2985
并查集+平衡树基本操作，水题，不解释。
代码

【4】HNOI2011 括号匹配Brackets（目前可以看这个帖子）
Splay Tree维护序列问题。对于一段括号序列A[1..len]，定义优先级P[0..len]如下：
P[0]=0
P[i]=P[i-1]+1（i>0且A[i]为左括号）
P[i]=P[i-1]-1（i>0且A[i]为右括号）
然后，Splay Tree的每个结点需要记录一个Z值和M值，分别表示该结点代表的括号序列中最后一个元素的优先级和优先级最小的元素的优先级。则可以证明：这段括号序列调整至平衡至少需要改变的括号数目为(-M+K+1) / 2，其中K=Z+((-M+1)/2)*2（注意这里的/是整除），此外由于有swap和invert两个操作，因此需要记录RM、TM、RTM值，分别表示将该括号序列执行swap操作后的序列的M值、执行invert操作后的序列的M值，以及同时执行swap和invert操作后序列的M值。
不过，本题需要严重注意的是：虽然replace操作的标记（代码中的mk0）会覆盖掉swap（代码中的mk1）和invert（代码中的mk2）操作的标记，但是在下放标记的时候，需要对三种标记逐一判断，mk0和mk1、mk2并不是不能共存的！因为有可能先打上mk0标记后再打上mk1或mk2标记。
本题虽然是静态的，但仍然不能使用线段树，因为线段树无法支持整体翻转（rev）操作。
代码

Mato_No1 2011-07-23 02:24 发表评论

线段树+扫描法解决矩形的面积并、周长并问题

Mato_No1 — Sat, 02 Jul 2011 03:17:00 GMT

矩形的面积并问题：平面上有N个矩形，各边均平行于坐标轴，求它们覆盖的总面积（重复覆盖的只计一次）。
矩形的周长并问题：平面上有N个矩形，各边均平行于坐标轴，求它们覆盖形成的多边形的周长。

【算法】
面积并：
先将所有矩形的上边界和下边界作为水平线段记录下来，并对所有矩形的左右边界对应的横坐标离散化，设离散化后有N个横坐标，则中间有(N-1)段。对这(N-1)段建立线段树（注意，仍然和普通线段树一样，是双闭区间，不是网上说的一开一闭），然后，按照纵坐标递增顺序扫描前面记录的水平线段（设有M段），对每一段，如果是上边界，找到其离散化后的范围（只需找到其左右端点离散化后的值l、r，则对应范围为[l, r-1]），并插入线段[l, r-1]，否则（下边界），删除线段[l, r-1]。再然后，线段树中的每个结点需要记录该区间内的线段覆盖的总长度len（若该区间被某条尚未删除的线段整体覆盖，则len=总长，否则len=左右子结点len之和），每次操作后，累加面积：T[root].len*该水平线段与下一条水平线段的纵坐标之差。

周长并：
类似，只不过由于组成周长的线段有水平的也有竖直的，线段树结点要记录的除了len意外还有一个ss，表示被线段覆盖的端点数量。另外还有lr和rr两个bool值，分别表示该线段的左端点和右端点是否被某条插入的线段覆盖。则T[x].ss = lch(T[x]).ss + rch(T[x]).ss - 2 * (lch(T[x]).rr && rch(T[x].lr))，若该线段被整体覆盖则T[x].ss=2（两端点）。最后，这次得到的T[root].len与上次得到的T[root].len之差的绝对值就是水平线段的长度，T[root].ss*纵坐标之差就是竖直线段的长度。

Mato_No1 2011-07-02 11:17 发表评论

线段树套平衡树可修改的区间第K小问题

Mato_No1 — Mon, 27 Jun 2011 13:53:00 GMT

在没有修改操作时，应用划分树可以在O(MlogN)时间内解决查找区间第K小的问题，但是在引入修改（将原序列中的某个值改为另一个值）之后，划分树就不行了。
这时，需要数据结构联合的思想。
可以观察一下：
（1）区间操作：使用线段树；
（2）修改值（其实是先删除再插入）和找第K小：使用平衡树；
现在这两种操作都有，应该使用线段树+平衡树！
准确来说是线段树套平衡树，即对原序列建立一棵线段树，其中的每个结点内套一棵对该结点管辖区间内的平衡树。

<1>结点类型（结构）：

struct seg_node {
int l, r, mid, lch, rch, rt;
} T0[MAXN0];
struct SBT_node {
int v, l, r, p, sz0, sz, mul;
} T[MAXN];

其中seg_node是线段树结点类型，SBT_node是平衡树(SBT)结点类型。需要注意的是seg_node里面的rt域（root的缩写），它是该结点内套的平衡树的根结点下标索引（因为对于任意一棵平衡树，只要知道了其根结点就可以遍历整棵树）。

<2>建树：
建树是线段树和平衡树一起建。在建立线段树结点的时候，先建立一棵空的平衡树（rt域置0），然后再在平衡树里面逐个插入该结点管辖区间内的所有元素即可；

<3>修改：
修改操作要注意：如果要将A[x]（A为原序列）的值修改为y，则需要自顶向下遍历整棵线段树，将所有包含了A[x]的结点内的平衡树全部执行“删除v=A[x]（这个可以通过真正维护一个序列得到），再插入y”的操作；

<4>找区间第K小：
这个操作极其麻烦。需要借助二分。
设要在区间[l, r]中找到第K小。首先将[l, r]拆分成若干个线段树结点，然后二分一个值x，在这些结点的平衡树中找到x的rank（这里的rank指平衡树中有多少个值比x小，不需要加1），加起来，最后再加1，就是x在[l, r]中的总名次。问题是，设[l..r]中第K小的数为v1，第(K+1)小的数为v2（如果不存在的话，v2=+∞），则[v1, v2)内的数都是“第K小”的。因此，不能二分数字，而应该二分元素。设S[i]为原序列中第i小的数，二分i，然后在根结点的平衡树中找到第i小的即为S[i]，再求其名次，这样直到找到总名次为K的元素为止。问题还没完，序列中可能有元素的值相同，这时可能永远也找不到第K小的（比如序列1 2 3 3 3 4 5，K=4，若“序列中比x小的元素总数+1”为x的名次，则永远也找不到第4小的），因此，若这样求出的“名次”小于等于K，都应该将下一次的左边界设为mid而不是(mid+1)，而“名次”大于K时，该元素肯定不是第K小的，所以下一次右边界设为(mid-1)。

代码（本机测最猥琐数据4s以内，交到ZJU上TLE，不知为什么，神犇指点一下，3x）：

#include <iostream>
#include <stdio.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
const int MAXN0 = 110000, MAXN = 930000, INF = ~0U >> 2;
struct seg_node {
    int l, r, mid, lch, rch, rt;
} T0[MAXN0];
struct SBT_node {
    int v, l, r, p, sz0, sz, mul;
} T[MAXN];
int No0, No, n, root, rt0, a[MAXN0 >> 1], b[MAXN0 >> 1], l1, r1, len;
void slc(int _p, int _c)
{
    T[_p].l = _c; T[_c].p = _p;
}
void src(int _p, int _c)
{
    T[_p].r = _c; T[_c].p = _p;
}
void upd(int x)
{
    T[x].sz0 = T[T[x].l].sz0 + T[T[x].r].sz0 + T[x].mul;
    T[x].sz = T[T[x].l].sz + T[T[x].r].sz + 1;
}
void lrot(int x)
{
    int y = T[x].p; if (y == rt0) T[rt0 = x].p = 0; else {int p = T[y].p; if (y == T[p].l) slc(p, x); else src(p, x);}
    src(y, T[x].l); slc(x, y); T[x].sz0 = T[y].sz0; T[x].sz = T[y].sz; upd(y);
}
void rrot(int x)
{
    int y = T[x].p; if (y == rt0) T[rt0 = x].p = 0; else {int p = T[y].p; if (y == T[p].l) slc(p, x); else src(p, x);}
    slc(y, T[x].r); src(x, y); T[x].sz0 = T[y].sz0; T[x].sz = T[y].sz; upd(y);
}
void maintain(int x, bool ff)
{
    int z;
    if (ff) {
        if (T[T[T[x].r].r].sz > T[T[x].l].sz) {z = T[x].r; lrot(z);}
        else if (T[T[T[x].r].l].sz > T[T[x].l].sz) {z = T[T[x].r].l; rrot(z); lrot(z);} else return;
    } else {
        if (T[T[T[x].l].l].sz > T[T[x].r].sz) {z = T[x].l; rrot(z);}
        else if (T[T[T[x].l].r].sz > T[T[x].r].sz) {z = T[T[x].l].r; lrot(z); rrot(z);} else return;
    }
    maintain(T[z].l, 0); maintain(T[z].r, 1); maintain(z, 0); maintain(z, 1);
}
int find(int _v)
{
    int i = rt0, v0;
    while (i) {
        v0 = T[i].v;
        if (_v == v0) return i; else if (_v < v0) i = T[i].l; else i = T[i].r;
    }
    return 0;
}
void ins(int _v)
{
    if (!rt0) {
        T[++No].v = _v; T[No].l = T[No].r = T[No].p = 0; T[No].sz0 = T[No].sz = T[No].mul = 1; rt0 = No;
    } else {
        int i = rt0, j, v0;
        while (1) {
            T[i].sz0++; v0 = T[i].v;
            if (_v == v0) {T[i].mul++; return;} else if (_v < v0) j = T[i].l; else j = T[i].r;
            if (j) i = j; else break;
        }
        T[++No].v = _v; T[No].l = T[No].r = 0; T[No].sz0 = T[No].sz = T[No].mul = 1; if (_v < v0) slc(i, No); else src(i, No);
        while (i) {T[i].sz++; maintain(i, _v > T[i].v); i = T[i].p;}
    }
}
void del(int x)
{
    if (T[x].mul > 1) {
        T[x].mul--;
        while (x) {T[x].sz0--; x = T[x].p;}
    } else {
        int l = T[x].l, r = T[x].r;
        if (!l || !r) {
            if (x == rt0) T[rt0 = l + r].p = 0; else {
                int p = T[x].p; if (x == T[p].l) slc(p, l + r); else src(p, l + r);
                while (p) {T[p].sz0--; T[p].sz--; p = T[p].p;}
            }
        } else {
            int i = l, j;
            while (j = T[i].r) i = j;
            T[x].v = T[i].v; T[x].mul = T[i].mul; int p = T[i].p; if (i == T[p].l) slc(p, T[i].l); else src(p, T[i].l);
            while (p) {upd(p); p = T[p].p;}
        }
    }
}
int Find_Kth(int K)
{
    int i = rt0, s0, m0;
    while (i) {
        s0 = T[T[i].l].sz0; m0 = T[i].mul;
        if (K <= s0) i = T[i].l; else if (K <= s0 + m0) return T[i].v; else {K -= s0 + m0; i = T[i].r;}
    }
}
int rank(int _v)
{
    int i = rt0, tot = 0, v0;
    while (i) {
        v0 = T[i].v;
        if (_v == v0) {tot += T[T[i].l].sz0; return tot;} else if (_v < v0) i = T[i].l; else {tot += T[T[i].l].sz0 + T[i].mul; i = T[i].r;}
    }
    return tot;
}
int mkt(int l, int r)
{
    T0[++No0].l = l; T0[No0].r = r; int mid = l + r >> 1; T0[No0].mid = mid; rt0 = 0;
    re3(i, l, r) ins(a[i]); T0[No0].rt = rt0;
    if (l < r) {int No00 = No0; T0[No00].lch = mkt(l, mid); T0[No00].rch = mkt(mid + 1, r); return No00;} else {T0[No0].lch = T0[No0].rch = 0; return No0;}
}
void fs(int x)
{
    if (x) {
        int l0 = T0[x].l, r0 = T0[x].r;
        if (l0 >= l1 && r0 <= r1) b[len++] = T0[x].rt; else if (l0 > r1 || r0 < l1) return; else {fs(T0[x].lch); fs(T0[x].rch);}
    }
}
void C(int x, int _v)
{
    int i = root, l0, r0, mid0, v0 = a[x], N;
    while (i) {
        l0 = T0[i].l; r0 = T0[i].r; mid0 = T0[i].mid; rt0 = T0[i].rt;
        N = find(v0); del(N); ins(_v); T0[i].rt = rt0;
        if (x <= mid0) i = T0[i].lch; else i = T0[i].rch;
    }
    a[x] = _v;
}
int Q(int K)
{
    len = 0; fs(root);
    int ls = 1, rs = n, mids, midv, tot;
    while (ls < rs) {
        mids = ls + rs + 1 >> 1; rt0 = T0[root].rt; midv = Find_Kth(mids);
        tot = 1; re(i, len) {rt0 = b[i]; tot += rank(midv);}
        if (tot <= K) ls = mids; else rs = mids - 1;
    }
    rt0 = T0[root].rt; return Find_Kth(ls);
}
int main()
{
    int tests, m, x, y, K;
    char ch;
    scanf("%d", &tests);
    re(testno, tests) {
        scanf("%d%d", &n, &m); No0 = No = 0;
        re(i, n) scanf("%d", &a[i]); ch = getchar();
        root = mkt(0, n - 1);
        re(i, m) {
            ch = getchar();
            if (ch == 'C') {
                scanf("%d%d%*c", &x, &y);
                C(--x, y);
            } else {
                scanf("%d%d%d%*c", &l1, &r1, &K);
                l1--; r1--; printf("%d\n", Q(K));
            }
        }
    }
    return 0;
}

Mato_No1 2011-06-27 21:53 发表评论

【NOI2005 维护数列(sequence)】Splay Tree处理序列问题

Mato_No1 — Tue, 21 Jun 2011 08:06:00 GMT

【原题见这里】
本题是Splay Tree处理序列问题（也就是当线段树用）的一个典型例题。

Splay Tree之所以可以当线段树用，是因为它可以支持一个序列，然后用“左端前趋伸展到根，右端后继伸展到根的右子结点，取根的右子结点的左子结点”这种伸展方法，对一个序列中的一整段进行整体操作。由于要防止出现前趋或后继不存在的情况，需要在这个序列的两端加入两个边界结点，要求其值不能影响到结点各种记载信息的维护（多取0、∞或-∞）。这两个边界结点在树中永远存在，不会被删除。

（1）结点的引用：
在当线段树用的Splay Tree中，真正的关键字是下标而不是值，因此，“序列中第i个结点”实际上对应的是“树中第(i+1)小的结点”（因为左边还有一个边界结点），这就说明在对结点引用时需要找第K小的操作。因此，下面的“结点x”指的是“树中第(x+1)小的结点”。
（2）标记：
在线段树中，如果对一个结点所表示的线段整体进行了某种操作，需要在这个结点上打上一个标记，在下一次再找到这个结点时，其标记就会下放到其两个子结点上。在Splay Tree中也可以引入标记。比如要对[2, 6]这一段进行整体操作，就将结点1伸展到根的位置，将结点7伸展到根的右子树的位置，然后结点7的左子树就表示[2, 6]这一段，对这棵子树的根结点打上标记并立即生效（必须是立即生效，而不是等下一次引用再生效），也就是立即改变该结点记录的一些信息的值。如果下次再次引用到这个结点，就要将其标记下放到其两个子结点处；
需要注意的一点是，如果要伸展某个结点x到r的子结点的位置，就必须保证从x原来的位置到r的这个子结点（x伸展后的位置）上的所有结点上均没有标记，否则就会导致标记混乱。因此，必须首先找到这个结点x，在此过程中不断下放标记。
（3）自底向上维护的信息：
标记可以看成一种自顶向下维护的信息。除了标记以外，作为“线段树”，往往还要维护一些自底向上维护的信息。比如在sequence这题中，就有lmax（左段连续最大和）、rmax（右段连续最大和）、midmax（全段连续最大和）以及sum（全段总和）等信息要维护。对于这类东东其实也很好办，因为子树大小（sz域）就是一种自底向上维护的信息，因此对于这些信息只要按照维护sz域的办法维护即可（统一写在upd函数里）。唯一的不同点是打标记时它们的值可能要改变。
（4）对连续插入的结点建树：
本题的插入不是一个一个插入，而是一下子插入一整段，因此需要先将它们建成一棵树。一般建树操作都是递归的，这里也一样。设目前要对A[l..r]建树（A为待插入序列），若l>r则退出，否则找到位于中间的元素mid = l + r >> 1，将A[mid]作根，再对A[l..mid-1]建左子树，对A[mid+1..r]建右子树即可。这样可以保证一开始建的就是一棵平衡树，减小常数因子。
（5）回收空间：
根据本题的数据范围提示，插入的结点总数最多可能达到4000000，但在任何时刻树中最多只有500002个结点（包括两个边界），此时为了节省空间，可以采用循环队列回收空间的方法。即：一开始将所有的可用空间（可用下标，本题为1~500002）存在循环队列Q里，同时设立头尾指针front和rear，每次如果有新结点插入，就取出Q[front]并作为新结点的下标，如果有结点要删除（本题是一次删除整棵子树，因此在删除后需要分别回收它们的空间），则从rear开始，将每个删除的结点的下标放回到Q里。当然，这种方法是要牺牲一定的时间的，因此在空间不是特别吃紧的情况下不要用。

【2012年1月16日更新】
今天重写sequence的时候，秃然发现加入的边界点可能会对lmax、rmax、midmax等的维护造成影响：当序列中所有的值都是负数时，若边界点的值设为0，将使这3个值也为0，所以，边界点的值应设为-INF（不会影响到sum，因为可以单独调出[l, r]的sum，避开边界）。这就说明并非所有这样的题中都可以设置边界点（比如HFTSC2011的那题就不行），如果边界点会对维护的信息造成影响，就不能设置边界点，在各个操作中，分4种情况判断。（代码已经修改）

下面上代码了：

#include <iostream>
#include <stdio.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
const int MAXN = 500002, NOSM = -2000, INF = ~0U >> 2;
struct node {
    int v, c[2], p, sz, sum, lmax, rmax, midmax, sm;
    bool rev, d;
} T[MAXN + 1];
int root, Q[MAXN + 1], front, rear, a[MAXN], len, res;
int max(int SS0, int SS1)
{
    return SS0 >= SS1 ? SS0 : SS1;
}
int max(int SS0, int SS1, int SS2)
{
    int M0 = SS0 >= SS1 ? SS0 : SS1; return M0 >= SS2 ? M0 : SS2;
}
void newnode(int n, int _v)
{
    T[n].v = T[n].sum = T[n].lmax = T[n].rmax = T[n].midmax = _v; T[n].c[0] = T[n].c[1] = 0; T[n].sz = 1; T[n].sm = NOSM; T[n].rev = 0;
}
void sc(int _p, int _c, bool _d)
{
    T[_p].c[_d] = _c; T[_c].p = _p; T[_c].d = _d;
}
void sm_opr(int x, int SM)
{
    T[x].sum = T[x].sz * SM;
    if (SM > 0) T[x].lmax = T[x].rmax = T[x].midmax = T[x].sum; else T[x].lmax = T[x].rmax = T[x].midmax = SM;
}
void rev_opr(int x)
{
    int c0 = T[x].c[0], c1 = T[x].c[1]; sc(x, c0, 1); sc(x, c1, 0);
    int tmp = T[x].lmax; T[x].lmax = T[x].rmax; T[x].rmax = tmp;
}
void dm(int x)
{
    int SM0 = T[x].sm;
    if (SM0 != NOSM) {
        T[x].v = T[T[x].c[0]].sm = T[T[x].c[1]].sm = SM0; T[x].sm = NOSM;
        sm_opr(T[x].c[0], SM0); sm_opr(T[x].c[1], SM0);
    }
    if (T[x].rev) {
        T[T[x].c[0]].rev = !T[T[x].c[0]].rev; T[T[x].c[1]].rev = !T[T[x].c[1]].rev; T[x].rev = 0;
        rev_opr(T[x].c[0]); rev_opr(T[x].c[1]);
    }
}
void upd(int x)
{
    int c0 = T[x].c[0], c1 = T[x].c[1];
    T[x].sz = T[c0].sz + T[c1].sz + 1;
    T[x].sum = T[c0].sum + T[c1].sum + T[x].v;
    T[x].lmax = max(T[c0].lmax, T[c0].sum + T[x].v + max(T[c1].lmax, 0));
    T[x].rmax = max(T[c1].rmax, max(T[c0].rmax, 0) + T[x].v + T[c1].sum);
    T[x].midmax = max(T[c0].midmax, T[c1].midmax, max(T[c0].rmax, 0) + T[x].v + max(T[c1].lmax, 0));
}
void rot(int x)
{
    int y = T[x].p; bool d = T[x].d;
    if (y == root) {root = x; T[root].p = 0;} else sc(T[y].p, x, T[y].d);
    sc(y, T[x].c[!d], d); sc(x, y, !d); upd(y);
}
void splay(int x, int r)
{
    int p; while ((p = T[x].p) != r) if (T[p].p == r) rot(x); else if (T[x].d == T[p].d) {rot(p); rot(x);} else {rot(x); rot(x);} upd(x);
}
int Find_Kth(int K)
{
    int i = root, S0;
    while (i) {
        dm(i); S0 = T[T[i].c[0]].sz + 1;
        if (K == S0) break; else if (K < S0) i = T[i].c[0]; else {K -= S0; i = T[i].c[1];}
    }
    return i;
}
int mkt(int l, int r)
{
    if (l > r) return 0;
    int n0 = Q[front], mid = l + r >> 1; if (front == MAXN) front = 1; else front++;
    newnode(n0, a[mid]); int l_r = mkt(l, mid - 1), r_r = mkt(mid + 1, r);
    sc(n0, l_r, 0); sc(n0, r_r, 1); upd(n0); return n0;
}
void ins(int pos)
{
    int P0 = Find_Kth(pos); splay(P0, 0); int P1 = Find_Kth(pos + 1); splay(P1, root); sc(P1, mkt(0, len - 1), 0); upd(P1); upd(P0);
}
void era(int x)
{
    if (!x) return;
    if (rear == MAXN) rear = 1; else rear++; Q[rear] = x;
    era(T[x].c[0]); era(T[x].c[1]);
}
void del(int l, int r)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int root0 = T[P1].c[0]; sc(P1, 0, 0); upd(P1); upd(P0); era(root0);
}
void mksame(int l, int r, int x)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int n = T[P1].c[0]; T[n].sm = x; sm_opr(n, x); upd(P1); upd(P0);
}
void reve(int l, int r)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int n = T[P1].c[0]; T[n].rev = !T[n].rev; rev_opr(n); upd(P1); upd(P0);
}
int get_sum(int l, int r)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int n = T[P1].c[0]; return T[n].sum;
}
int max_sum()
{
    return T[root].midmax;
}
void prepare()
{
    T[0].sz = T[0].sum = T[0].lmax = T[0].rmax = T[0].midmax = 0;
    front = 3; rear = MAXN; re1(i, MAXN) Q[i] = i;
    newnode(1, -INF); newnode(2, -INF); sc(1, 2, 1); root = 1; T[root].p = 0;
}
int main()
{
    freopen("sequence.in", "r", stdin);
    freopen("sequence.out", "w", stdout);
    prepare();
    int m, l, r, x;
    scanf("%d%d", &len, &m); char ch = getchar(), str[1000];
    re(i, len) scanf("%d", &a[i]); ins(1);
    re(i, m) {
        scanf("%s", str);
        if (!strcmp(str, "INSERT")) {scanf("%d%d", &l, &len); re(i, len) scanf("%d", &a[i]); ins(++l);}
        if (!strcmp(str, "DELETE")) {scanf("%d%d", &l, &r); r += l++; del(l, r);}
        if (!strcmp(str, "MAKE-SAME")) {scanf("%d%d%d", &l, &r, &x); r += l++; mksame(l, r, x);}
        if (!strcmp(str, "REVERSE")) {scanf("%d%d", &l, &r); r += l++; reve(l, r);}
        if (!strcmp(str, "GET-SUM")) {scanf("%d%d", &l, &r); r += l++; printf("%d\n", get_sum(l, r));}
        if (!strcmp(str, "MAX-SUM")) printf("%d\n", max_sum());
        ch = getchar();
    }
    fclose(stdin); fclose(stdout);
    return 0;
}

最后把我的这个代码与BYVoid神犇的本题代码进行测试比较，结果（BYVoid神犇的代码见这里）：

BYVoid神犇的：

本沙茶的：

【相关论文】
运用伸展树解决数列维护问题 by JZP
【感谢】
JZP神犇（提供论文）
BYVoid神犇（提供标程）

Mato_No1 2011-06-21 16:06 发表评论

动态区间最大子序和问题及有关模型

Mato_No1 — Sun, 24 Apr 2011 07:50:00 GMT

摘要: 动态区间最大子序和问题【问题描述】给出一个序列A[0..N-1]和M个操作，每个操作都是以下三种之一：①：查询区间最大子序和操作格式：1 l r表示：查询A[l..r]内的最大子序和（就是A[l..r]内的和最大的连续子序列的和），0<=l<=r阅读全文

Mato_No1 2011-04-24 15:50 发表评论