C++博客-Mato is No.1-随笔分类-专题:数据结构动态模拟问题

关于树分治的问题

Mato_No1 — Sat, 31 Aug 2013 15:39:00 GMT

摘要: （从NOI以后一直在各网站上做水题……谁叫我这么弱做不动难题呢……）（最近实在感觉到弱得令人吃惊……这样下去还混什么集训队啊……于是只好去挑难题了……中间对某些知识点有一些见解……就总结在这里了囧……）（最近见到了比较多的树分治的题... 阅读全文

Mato_No1 2013-08-31 23:39 发表评论

【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 发表评论

终于会写动态树了

Mato_No1 — Sun, 26 Feb 2012 05:03:00 GMT

【背景】
2012年1月19日，本沙茶开始看动态树论文，搞懂了一些；
2012年1月20日，开始写动态树，使用的题是QTREE，花了整整一天时间总算写完，交上去，TLE……
2012年1月21日，又调了一天，对拍了100+组随机数据都瞬间出解，交上去，还是TLE……
2012年2月8日，WC2012，fanhq666讲动态树，又搞懂了一点，于是当天晚上回房间以后就开始继续调，交上去，TLE……
2012年2月9日，晚上继续调QTREE，TLE……
在挑战动态树N次失败之后，本沙茶昨天再次去挑战动态树……这次换了一个题：BZOJ2002（传说中的动态树模板题）
一开始还是TLE了，不过后来把数据搞到手以后，发现TLE的原因并不是常数大，而是死循环了，最后，经过2h+的调试，总算找到了错误（有好几处），终于AC了……

【关于BZOJ2002】
从每个点i往(i+Ki)连一条边，如果(i+Ki)不存在则往一个附加的结点（本沙茶的代码中为1号点，因为0号点是不能使用的）连一条边，这样就是一棵树（除1号点外，每个点有且只有一个后继……），然后，问题中的两种操作就是“改接”和“询问到根的距离”，可以用动态树搞；

【代码】

【易疵点】
（1）注意一个点的父结点p有两种可能：如果该结点是某棵伸展树的根结点则p为它通过轻边连向的另一棵伸展树中的某一个点的编号（在原树中，就是该结点所在伸展树代表的链的最上层的那个节点的父结点），否则为该结点在伸展树中的父结点编号（通过重边相连）；
（2）在改接时删除边的时候，如果删除的是轻边则直接把父结点设为0即可，如果是重边则要sc一下再将父结点设为0；
（3）rot里面有一个地方很关键，极易疵！就是如果p是伸展树的根结点，则除了No的rf改为1，p的rf改为0之外，还要把No的父结点设为p的父结点；
（4）本题中不涉及整棵大树的根（就是root），如果需要root，则rot中还要加一句：if (root == p) root = No;
（5）cut里面有一种简便写法（不需要找到x的父结点的）：先access(x)，将x伸展到根之后，x及其右子树就是原树中以x为根的子树，左子树就是其它部分，所以直接将x与其左子结点断开即可（注意断开的是重边所以要sc一下，再将x的左子结点的父结点设为0、rf设为1，再upd一下）；
（6）一定要搞清楚rf的变化（该改时一定要改！）

最后，放上fanhq666超级大神的总结：
0 1

Mato_No1 2012-02-26 13:03 发表评论

新型LCA算法及树的路径剖分模板总结

Mato_No1 — Sat, 14 Jan 2012 04:34:00 GMT

【1】新型LCA算法：（在WJMZBMR神犇空间上发现的，系神犇自创，Orz！！！）
这种算法可以在仅使用树的路径剖分预处理中求出的DEP和UP来求任意两点的LCA，时间复杂度为O(log₂N)，不需要单独的预处理。
步骤（假设求a0、b0两点的LCA）：
（1）若UP[a0]==UP[b0]，则a0、b0位于同一条重链上，显然a0、b0中深度小的那个就是LCA了，返回结果，结束；
（2）若UP[a0]!=UP[b0]且DEP[UP[a0]]>=DEP[UP[b0]]，则LCA不可能在a0所在的那条重链上。证明：若LCA在a0所在的重链上，则UP[a0]必然也是a0、b0的公共祖先，也就是UP[a0]是b0的祖先。由于UP[a0]的深度大于等于UP[b0]，若DEP[UP[a0]]>DEP[b0]，则UP[a0]显然不可能是b0的祖先，否则，在b0所在的重链上必然存在一个点C，满足DEP[C]=DEP[UP[a0]]，显然，C也是b0的祖先，这就说明在树中同一深度处存在两个不同的结点，它们都是b0的祖先，这是不可能的，所以，LCA不可能在a0所在重链上。那么，a0就可以上溯到UP[a0]的父结点处（也就是E[FA[UP[a0]]].a），b0不动，然后继续判断；
（3）若UP[a0]!=UP[b0]且DEP[UP[a0]]由于a0、b0最多上溯O(log₂N)次，所以该算法一定能在O(log₂N)时间内求出LCA(a0, b0)。
该算法的应用很广，不光可以在树的路径剖分中快速求出LCA，精简代码，同时也减少了一些时间（因为它不需要像RMQ那样进行预处理），而且，在一般的求LCA问题中，也可以先剖分求出UP再求LCA。
代码：

int LCA(int a, int b)
{
    while (1) {
        if (UP[a] == UP[b]) return DEP[a] <= DEP[b] ? a : b;
        else if (DEP[UP[a]] >= DEP[UP[b]]) a = E[FA[UP[a]]].a; else b = E[FA[UP[b]]].a;
    }
}

【2】树的路径剖分模板总结：
（1）预处理部分：由于采用新型LCA算法（注意，求LCA的过程写成专门的函数），所以，原来预处理部分的后3步都不需要了，也就是只要前3步：第一步建有根树求出FA、DEP；第二步求出SZ划分轻重边；第三步找重链建线段树求出UP、ord、tot和root。那些为了求RMQ而设置的数组也不需要了。
（2）操作部分：难点在于上溯过程和衔接。设待操作的路径为a0->b0（注意是有向的，无向的也可以当成有向的处理），LCA0=LCA(a0, b0)；
对于点权型的树，a0->LCA0的过程需要包含LCA0，而b0->LCA0的过程不能包含LCA0。因此当b0==LCA0时，第二步应该什么事都不做，所以要特判；此外，如果N==1（树中只有一个结点），为了防止引用根的父结点，也需要直接特判掉，所以，上溯过程可以分以下4步：
<1>特判：若n=1（此时必然有a0==b0==0），直接操作0号结点，结束；
<2>(a0->LCA)若a0是父边是轻边的叶结点，则单独处理a0，最新点设为a0，a0跳到a0的父结点处开始，否则从a0开始（上溯）。上溯终止条件为DEP[a0]<3>(b0->LCA)与<2>类似，两个不同点：一是有向的信息不要反向，衔接时应不断向左衔接；二是若c==LCA，则l0=ord[c]+1；
<4>最后将<2>中和<3>中得到的两个衔接链再衔接一下即可；

对于边权型的树，a0->LCA0的过程和b0->LCA0的过程都要包含LCA0引出的边，b0==LCA0以及N==1时不需要特判（因为它们会自动地什么事都不做）；在处理过程中，l0=ord[c], r0=ord[a0]-1；要分轻边和重链分别处理；每次a0上溯到c而不是c的父结点处；终止条件为DEP[a0]<=DEP[LCA0]。

模板题：PKU2831（动态最小生成树问题，需要涉及到最小生成树中两点之间路径上的最大边权，用树的路径剖分。其实本题有离线算法，不需要树的路径剖分）

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
const int MAXN = 1001, MAXM = 100001, INF = ~0U >> 2;
struct _edge {
    int a, b, w;
} _E[MAXM], _E2[MAXM];
struct edge {
    int a, b, w, pre, next;
    bool Z;
} E0[MAXN << 2], E[MAXN << 2];
struct node {
    int maxw, lch, rch;
} T[MAXN << 2];
int n, _m, m0, m, N, u[MAXN], Q[MAXN], FA[MAXN], DEP[MAXN], SZ[MAXN], UP[MAXN], ord[MAXN], w0[MAXN], tot[MAXN], root[MAXN], l0, r0, x0, res;
bool vst[MAXN];
void init_d()
{
    re(i, n) E0[i].pre = E[i].pre = E0[i].next = E[i].next = i;
    m0 = m = n;
}
void add_edge0(int a, int b, int w)
{
    E0[m0].a = a; E0[m0].b = b; E0[m0].w = w; E0[m0].pre = E0[a].pre; E0[m0].next = a; E0[a].pre = m0; E0[E0[m0].pre].next = m0++;
    E0[m0].a = b; E0[m0].b = a; E0[m0].w = w; E0[m0].pre = E0[b].pre; E0[m0].next = b; E0[b].pre = m0; E0[E0[m0].pre].next = m0++;
}
void add_edge(int a, int b, int w)
{
    E[m].a = a; E[m].b = b; E[m].w = w; E[m].Z = 0; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
}
int cmp(const void *s1, const void *s2)
{
    return ((_edge *)s1)->w - ((_edge *)s2)->w;
}
int UFS_find(int x)
{
    int r = x, tmp; while (u[r] >= 0) r = u[r]; while (u[x] >= 0) {tmp = u[x]; u[x] = r; x = tmp;} return r;
}
void UFS_union(int x1, int x2)
{
    if (u[x1] >= u[x2]) {u[x2] += u[x1]; u[x1] = x2;} else {u[x1] += u[x2]; u[x2] = x1;}
}
int mkt(int l, int r)
{
    int No = ++N;
    if (l == r) {T[No].maxw = w0[l]; T[No].lch = T[No].rch = 0;} else {
        int mid = l + r >> 1, l_r = mkt(l, mid), r_r = mkt(mid + 1, r);
        T[No].maxw = T[T[No].lch = l_r].maxw >= T[T[No].rch = r_r].maxw ? T[l_r].maxw : T[r_r].maxw;
    }
    return No;
}
void prepare()
{
    qsort(_E2, _m, sizeof(_E2[0]), cmp);
    re(i, n) u[i] = -1;
    int a, b, r1, r2, total = 0, maxsz, x, n0;
    re(i, _m) {
        a = _E2[i].a; b = _E2[i].b; r1 = UFS_find(a); r2 = UFS_find(b);
        if (r1 != r2) {UFS_union(r1, r2); add_edge0(a, b, _E2[i].w); if (++total == n - 1) break;}
    }
    re(i, n) vst[i] = 0; Q[0] = DEP[0] = N = 0; vst[0] = 1; FA[0] = -1;
    for (int front=0, rear=0; front<=rear; front++) {
        a = Q[front];
        for (int p=E0[a].next; p != a; p=E0[p].next) {
            b = E0[p].b;
            if (!vst[b]) {FA[b] = m; DEP[b] = DEP[a] + 1; vst[b] = 1; Q[++rear] = b; add_edge(a, b, E0[p].w);}
        }
    }
    rre(i, n) {
        a = Q[i]; SZ[a] = 1; maxsz = 0;
        for (int p=E[a].next; p != a; p=E[p].next) {
            b = E[p].b; SZ[a] += SZ[b]; if (SZ[b] > maxsz) {maxsz = SZ[b]; x = p;}
        }
        if (SZ[a] > 1) E[x].Z = 1;
    }
    UP[0] = ord[0] = 0;
    re2(i, 1, n) {
        a = Q[i]; int p = FA[a]; if (E[p].Z) {UP[a] = UP[E[p].a]; ord[a] = ord[E[p].a] + 1;} else {UP[a] = a; ord[a] = 0;}
        if (SZ[a] == 1 && E[FA[a]].Z) {
            b = UP[a]; n0 = ord[a]; for (int j=a; j!=b; j=E[FA[j]].a) w0[--n0] = E[FA[j]].w;
            tot[b] = ord[a]; root[b] = mkt(0, ord[a] - 1);
            for (int j=a; j!=b; j=E[FA[j]].a) {tot[j] = tot[b]; root[j] = root[b];}
        }
    }
}
int LCA(int a, int b)
{
    while (1) {
        if (UP[a] == UP[b]) return DEP[a] <= DEP[b] ? a : b;
        else if (DEP[UP[a]] >= DEP[UP[b]]) a = E[FA[UP[a]]].a; else b = E[FA[UP[b]]].a;
    }
}
void opr0(int l, int r, int No)
{
    if (l >= l0 && r <= r0) {if (T[No].maxw > res) res = T[No].maxw;} else {
        int mid = l + r >> 1;
        if (mid >= l0) opr0(l, mid, T[No].lch);
        if (mid < r0) opr0(mid + 1, r, T[No].rch);
    }
}
int main()
{
    int P, s, a0, b0, w0, LCA0, c;
    scanf("%d%d%d", &n, &_m, &P); init_d();
    re(i, _m) {
        scanf("%d%d%d", &a0, &b0, &w0);
        _E[i].a = _E2[i].a = --a0; _E[i].b = _E2[i].b = --b0; _E[i].w = _E2[i].w = w0;
    }
    prepare();
    re(i, P) {
        scanf("%d%d", &s, &w0); a0 = _E[--s].a; b0 = _E[s].b; LCA0 = LCA(a0, b0);
        res = -INF;
        while (DEP[a0] > DEP[LCA0]) {
            if (E[FA[a0]].Z) {
                if (DEP[UP[a0]] >= DEP[LCA0]) c = UP[a0]; else c = LCA0;
                l0 = ord[c]; r0 = ord[a0] - 1; opr0(0, tot[a0] - 1, root[a0]); a0 = c;
            } else {
                if (E[FA[a0]].w > res) res = E[FA[a0]].w;
                a0 = E[FA[a0]].a;
            }
        }
        while (DEP[b0] > DEP[LCA0]) {
            if (E[FA[b0]].Z) {
                if (DEP[UP[b0]] >= DEP[LCA0]) c = UP[b0]; else c = LCA0;
                l0 = ord[c]; r0 = ord[b0] - 1; opr0(0, tot[b0] - 1, root[b0]); b0 = c;
            } else {
                if (E[FA[b0]].w > res) res = E[FA[b0]].w;
                b0 = E[FA[b0]].a;
            }
        }
        puts(res >= w0 ? "Yes" : "No");
    }
    return 0;
}

好了，对于模板也就到此为止了，接下来该搞应用了。

Mato_No1 2012-01-14 12:34 发表评论

【树的路径剖分】点权型的处理办法、路径的衔接以及一些细节问题

Mato_No1 — Thu, 12 Jan 2012 12:44:00 GMT

摘要: 【例题】[SDOI2011]染色（注：数据范围木有交代，应为：点数N<=105，操作数M<=105，所有的颜色C为整数且在[0, 109]之间。一、树的路径剖分当中点权型（点上有权值而边上木有）的处理办法：（1）找重链建线段树的时候，w0中存储tot+1个数，为该重链自上而下的各点的权值（例题中为颜色）；（2）除了父边是轻边的叶结点之外，树中的每个结点都属于且仅属于一条重链（根据定义得... 阅读全文

Mato_No1 2012-01-12 20:44 发表评论

QTREE——树的路径剖分（又称树链剖分）

Mato_No1 — Tue, 03 Jan 2012 08:41:00 GMT

摘要: 原题地址【有关树的路径剖分的东东在网上介绍的太多了……】常见的路径剖分的方法是轻重边剖分，即把树中的边分为轻重两部分，方法：设SZ[i]为以i为根的子树的大小（结点总数），则若点x不是叶结点，则其子结点中SZ值最大的（注意，有多个SZ值最大的子结点应任选一个，只能选一个，防止出现重链相交，引发歧义）点y，边(x, y)称为重边，其余的边都是轻边。首尾相连的重边称为重链（注意... 阅读全文

Mato_No1 2012-01-03 16:41 发表评论

Splay Tree处理区间问题的几道好题及总结

Mato_No1 — Sat, 25 Jun 2011 03:21:00 GMT

（1）Robotic Sort（HDU1890、ZJU2985）
本题主要考察的是对此类问题，序列中给定值的索引问题。
当Splay Tree用来处理一个序列的时候，其关键字就是序列中元素的下标，而不是元素的值。这样，如果要查找序列中给定的值的位置（假设序列中任意两个元素的值不相等）看起来就无法实现。其实也是有办法实现的：因为元素在树中的下标是永远不变的！也就是，设这个序列为A，如果A[i]在插入Splay Tree时的下标为j，那么在A[i]被删除之前，其下标一直是j，永远不会变（注意元素在序列中的下标和在树中的下标是不同的）。利用这一性质可以解决给定值的索引问题。
对于本题，每次将从序列中第i小的元素到序列中第i个元素（这里假定元素下标是从1开始的，而不是从0开始）之间的所有元素反转，并输出第i小的元素在反转之前的在序列中的下标。设B[i]为第i小的数的初始位置，S[i]为初始位置在第i位的元素的下标，B[i]和S[i]都可以通过预处理得到。然后，每次交换前，求出S[B[i]]在树中的排名（基本操作），再减1（因为有边界结点）就是该元素目前的位置，而序列中第i个元素就是树中第(i+1)小的元素，再执行交换即可。
不过需要千万注意的是本题的标记问题，在求S[B[i]]在树中的排名时，有可能其祖先结点上有标记，需要先遍历其所有的祖先结点，再逆向下放标记（标记只能自顶向下传）。另外在交换的时候需要求出S[B[i]]的后继，在求后继的过程中需要查找，此时千万别忘了下放标记（总的说，凡是有查找的地方，就有dm）
代码（本沙茶太弱了，是抄别人的，因此其算法和上面总结的可能有差别，神犇不要鄙视）

（2）SuperMemo（PKU3580）
本题的6个操作中，add、reverse、insert、delete、min都不难搞，而revolve操作需要涉及到区间交换。
可以发现，所谓的旋转其实就是交换两个相邻区间，这对于功能极强的Splay Tree来说根本不难搞。
设这两个相邻区间为[x, y]与[y+1, z]，假设它们均非空（也就是x<=yT2->P0->T1，也就是[y+1, z]∪[x, y]。
另外本题的标记有点难搞，只需注意rev是逆向标记，以及查找与dm共存就行了。
代码
（3）Play with Chain(HDU3487)
这个米有神马好说的，里面的操作在SuperMemo里都有；
代码
（4）AHOI2006 文本编辑器(editor)
这题在这一类题里面算水的。对于光标，只要用一个值来维护就行了。
另外注意本题极为猥琐的2点（题目中米有说明）：一是最初的文本并不是空的，而是有一个空格；二是执行GET操作时光标可能位于文本末尾，此时应输出空格；
代码
（5）HFTSC2011 高精度计算器(apc)，题目见这个帖子；
这题反映出了一个很囧的问题：有些信息会被rev整体破坏。
本题中的操作都是常见操作，但是本题所需要维护的信息却不是那么容易维护。本题要求维护一棵子树中所有结点所表示的元素序列（中序遍历结果）模一个指定的M的值。设F[i]为R^i mod M的值（这里R是进制，也就是题目中的K），则有：
T[x].mod = (T[T[x].c[0]].mod * F[T[T[x].c[1]].sz + 1] + T[x].v * F[T[T[x].c[1]].sz] + T[T[x].c[1]].mod) % M;
这个式子其实是很好理解的。
关键是，本题的猥琐之处并不在此。注意本题的rev操作，它会整体改变树中所有结点所记录的mod值，这时，如果再用上面这个式子来维护T[x].mod，就会出错，因为此时引用到的T[T[x].c[0]].mod和T[T[x].c[1]].mod都是过时的。解决这一问题只有一种方法：记录“逆mod”(rmod)，意思是将整个元素序列反转后的mod，即：
T[x].rmod = (T[T[x].c[1]].rmod * F[T[T[x].c[0]].sz + 1] + T[x].v * F[T[T[x].c[0]].sz] + T[T[x].c[0]].rmod) % M;
这样，在反转某序列的时候，直接将根结点的mod值和rmod值交换就行了。
像mod这样会被反转操作整体破坏的信息还有很多，比如NOI2005 sequence里面的lmax和rmax。如果真的遇到这类信息，只有采用上面的方法。
另外，本题第6、9、10个点有误。
代码

现在Splay Tree差不多弄完了，接下来还有N多知名的、不知名的高级数据结构……时间MS有些不够用了囧……

Mato_No1 2011-06-25 11:21 发表评论

【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 发表评论