C++博客-Mato is No.1-随笔分类-平衡树

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

PKU3017

Mato_No1 — Fri, 08 Jul 2011 04:40:00 GMT

【原题见这里】

本沙茶见过的最猥琐的DP题啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊……

设F[i]为将A[1..i]拆分成若干段的最大值最小和，则有
F[i]=min{F[j] + max[j+1, i]}（B[i]<=j边界：F[0]=0。

下面是优化过程。JZP神犇的论文里面已经够详细了。这里只是简要说明一下。
首先容易证明，F是单调递增的。
然后一个很关键的定理是：若F[i]的最优决策为j，则有A[j]>∀A[k]（j
证明：用反证法。若A[j+1..i]中存在不小于A[j]的值，则可得max[j..i]=max[j+1..i]，又因为F单调递增，所以F[j-1]+max[j..i]<=F[j]+max[j+1.i]，即决策(j-1)一定不比决策j差，也就是决策j不可能成为最优决策。
这样，可以维护一个下标严格递增、A值严格递减的队列Q（即对于队列中的任意两个元素Q[i]和Q[j]，若iA[Q[j].pos]，具体实现时pos可省略）。则可能成为最优决策的决策要么是在这个队列Q里，要么是B[i]。对于队列中的某个决策Q[x]，该决策导出的值为F[Q[x]]+A[Q[x + 1]]（很容易证明max[Q[x]+1..i]=A[Q[x + 1]]），找到这些导出的值中的最小值即可（注意，队尾元素没有导出值）。对于决策B[i]，只需要在预处理的时候同时得到MAX[i]=max[B[i]+1..i]即可（也可以在O(N)时间内得到），决策B[i]导出的值为F[B[i]]+MAX[i]。
在删除队首过时元素的时候，需要把导出值也删除，删除队尾元素也一样，插入的时候，若插入前队列不为空，则需要插入一个导出值。也就是，需要一个支持在对数时间内进行插入、删除任意结点、找最小值等操作，显然用平衡树最好。

注意事项：
（1）不管是在队首删除还是在队尾删除，若删除的是队列中的最后一个元素，则不需要在平衡树中删除导出值；
（2）插入时，若插入前队列为空，则不需要在平衡树中插入导出值；
（3）在计算F[i]时，应先将决策i压入。

代码：
#include <iostream>
#include <stdio.h>
using namespace std;
#define re1(i, n) for (int i=1; i<=n; i++)
const int MAXN = 100001;
struct node {
    int l, r, p, sz0, sz, mul;
    long long v;
} T[MAXN];
const long long INF = ~0Ull >> 2;
int n, N = 0, a[MAXN], b[MAXN], MAX[MAXN], Q[MAXN], front = 0, rear = -1, root = 0;
long long m, F[MAXN], res = 0;
void init()
{
    cin >> n >> m;
    re1(i, n) scanf("%d", &a[i]); a[0] = ~0U >> 2;
}
void prepare()
{
    re1(i, n) if (a[i] > m) {res = -1; return;}
    int x = 1;
    long long sum = 0;
    re1(i, n) {
        for (sum+=a[i]; sum>m; sum-=a[x++]) ;
        b[i] = x - 1;
    }
    re1(i, n) {
        for (; front<=rear && Q[front]<=b[i]; front++) ;
        for (; front<=rear && a[Q[rear]]<=a[i]; rear--) ;
        Q[++rear] = i; MAX[i] = a[Q[front]];
    }
}
void vst(int x)
{
    if (x) {
        cout << T[x].v << ' ';
        vst(T[x].l); vst(T[x].r);
    }
}
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 == root) T[root = 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 == root) T[root = 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(long long _v)
{
    int i = root;
    long long 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;
}
int Find_Kth(int K)
{
    int i = root, s0, m0;
    while (1) {
        s0 = T[T[i].l].sz0; m0 = T[i].mul;
        if (K <= s0) i = T[i].l; else if (K <= s0 + m0) return i; else {K -= s0 + m0; i = T[i].r;}
    }
}
void ins(long long _v)
{
    if (!root) {
        T[++N].v = _v; T[N].l = T[N].r = T[N].p = 0; T[N].sz0 = T[N].sz = T[N].mul = 1; root = N;
    } else {
        int i = root, j;
        long long 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[++N].v = _v; T[N].l = T[N].r = 0; T[N].sz0 = T[N].sz = T[N].mul = 1; if (_v < v0) slc(i, N); else src(i, N);
        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, p;
        if (l && r) {
            int y; while (y = T[l].r) l = y;
            T[x].v = T[l].v; T[x].mul = T[l].mul; p = T[l].p;
            if (l == T[p].l) slc(p, T[l].l); else src(p, T[l].l);
            while (p) {upd(p); p = T[p].p;}
        } else {
            if (x == root) T[root = l + r].p = 0; else {p = T[x].p; if (x == T[p].l) slc(p, l + r); else src(p, l + r); while(p) {upd(p); p = T[p].p;}}
        }
    }
}
long long h(int x)
{
    return F[Q[x]] + a[Q[x + 1]];
}
void solve()
{
    F[0] = 0; front = 0; rear = 0; Q[0] = 0;
    re1(i, n) {
        for (; front<=rear && Q[front]<b[i];) {if (front < rear) del(find(h(front))); front++;}
        for (; front<=rear && a[Q[rear]]<=a[i];) {if (front < rear) del(find(h(rear - 1))); rear--;}
        Q[++rear] = i; if (front < rear) ins(h(rear - 1));
        if (root) F[i] = T[Find_Kth(1)].v; else F[i] = INF;
        if (F[b[i]] + MAX[i] < F[i]) F[i] = F[b[i]] + MAX[i];
    }
    res = F[n];
}
void pri()
{
    cout << res << endl;
}
int main()
{
    init();
    prepare();
    if (!res) solve();
    pri();
    return 0;
}

Mato_No1 2011-07-08 12:40 发表评论

线段树套平衡树可修改的区间第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 发表评论

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

平衡树调试技巧

Mato_No1 — Wed, 22 Jun 2011 16:07:00 GMT
平衡树操作，尤其是Splay Tree的区间操作（当线段树用的那种），代码长且极易搞疵，当操作多的时候，甚至可能调试的时间比写代码的时间都长！
这里来总结一下平衡树在实际应用（编程）中的易疵点和调试技巧。
【平衡树（这里主要指Splay Tree）的操作】
这个MS前面已经总结过了，主要分以下几类：
（1）基本操作：查找、单结点插入、单结点删除、找第K小、求结点的排名、找指定结点的前趋和后继；
（2）进阶操作：找给定的值在树中的前趋和后继、对一个序列建平衡树、插入整棵子树、删除整棵子树；
（3）区间操作（与线段树的结合）：标记（自顶向下）；
（4）区间操作（与线段树的结合）：最大值、总和等自底向上维护的信息；
（5）一些特别猥琐的操作（比如PKU3580的revolve）；
【主要函数及其易疵点】
（1）void sc(int _p, int _c, bool _d);
将_p的_d子结点（0左1右）置为_c，这个就三句话，应该不会搞疵；
（2）void upd(int x);
更新x记录的一些信息（自底向上维护的信息，包括大小域sz），这个，有几个信息就写几句话就行了，不易搞疵；
（3）void rot(int x);
旋转操作，将x旋转到其父结点的位置。这个函数中有两个易疵点：一是若x的父结点为根，则需要在旋转后将根置为x，且将x的父结点置为0（特别注意这个）；二是若x的父结点不为根，则需要将x的父结点的父结点的对应子结点（原来是x的父结点的那个）置为x；另外旋转完成后别忘了更新；
（4）void splay(int x, int r);
伸展操作，将x伸展到r的子结点处，这个操作是最核心的操作，只要记住了过程，且rot不搞疵，这个也就不会搞疵；
（5）void dm(int x);
对于有标记的结点的下放标记操作，极易疵！
首先，对于任何结点，标记一打上就必须立即生效，因此除了将x的标记取消、x的两个子结点（如果存在的话）打上标记外，还要更新两个子结点的一些域（当然这里更新千万不能用upd更新）；
其次，要搞清楚x的每一个标记的类型，是叠加型标记（如整体加上某一个数的标记）、覆盖型标记（如整体置为某一个数的标记）还是逆向标记（如是否翻转过的标记，因为翻转两次等于没转），然后在下放标记的时候注意写法（因为x的子结点原来可能也有标记，此时只有覆盖型标记需要将x的子结点的原来的标记覆盖掉，对于叠加型标记，应为加法运算，对于逆向标记，应为取反操作，还有其它类型的标记分别处理）；
最后还有一点，就是x的左子结点或右子结点可能不存在（0），此时就不能对这里的0号结点下放标记。
（6）int Find_Kth(int x, int K);
在以结点x为根的子树中找第K小的结点，返回结点编号；若省略x，默认x=root（即在整棵树中找）；
这个一般不会搞疵，注意两个地方即可：一是有mul域的时候需要考虑mul域，二是结点如果有标记，需要在找的时候下放标记。（凡是查找操作，包括插入新结点时的查找，在查找过程中必须不断下放标记，因为查找之后很可能就要伸展）；
（7）void ins(int _v);
       void ins(int x, int _v)
插入一个值为_v的结点。前者是普通插入，后者是用Splay Tree处理序列（当线段树用）时的插入，表示在第x小的结点后插入；
前者注意有三种情况：树为空；树非空且值为_v的结点不存在；树非空且值为_v的结点已存在；
后者需要注意，在将第x小的结点伸展到根，将第(x+1)小的结点伸展到根的右子结点，再插入后，需要upd上述两个结点（注意upd顺序）；
（8）void del(int x);
将结点x删除。这个一般不会搞疵，唯一要注意的一点是删除后的upd；
（9）打标记操作（add、reverse、makesame等）：
其实打标记操作的代码量是很少的，关键就是对于不同标记要分别处理，同（5）；
（10）各种询问操作：
这个直接调出相应的域即可，几乎不可能搞疵；
（11）极其猥琐的操作（revolve等）：
这个属于最易疵的操作（否则就体现不出其猥琐了）：
首先要搞清楚这个操作的具体过程，不要连具体过程都搞疵了，这样写出来的代码肯定是疵的；
然后，注意一些非常猥琐的细节问题（很多时候，本沙茶都是栽在细节上的）；
另外，这些操作中一般都会出现多次伸展，别忘了伸展后的upd；
（12）其它易疵点：
[1]“移动”是由“插入”和“删除”两部分组成的，因此凡是涉及到“移动”类的操作（如将某棵子树或某个结点移动到另一个位置等），必须要同时出现“插入”和“删除”，而不能只插入不删除；
[2]注意检查主函数main()中是否有搞疵的地方；

易疵点也就这么多了，下面是调试技巧：
【Splay Tree调试技巧】
（1）先用样例调试，保证样例能够通过（注意，样例中必须包含所有题目中给出的操作，如果不是这样，那在调试完样例后还要加一组包含所有题目中给出的操作的小数据）；
（2）然后用mkdt造大数据，一般平衡树操作题的合法数据都不难造，只要注意别越界就行了；
（3）在调试过程中应不断少量增大数据规模，因为在能找出问题的情况下，数据规模越小越好；
（4）如果调试过程中发现死循环或者RE：
[1]首先输出每个操作，找出是在哪个操作处出了问题；
[2]进入该操作内部检查，也就是把该操作的代码读一遍，一般都能找出问题；
[3]如果找不出问题，可以进入该操作内部跟踪检查；
[4]如果跟踪检查仍然没找出问题，那可能是该操作是对的，而其它操作出了问题，此时可以弄一个vst，把整棵树遍历一下，找出真正出问题的操作，转[2]；
（5）排除了死循环或RE后，接下来就是检查输出结果是否正确了：
[1]对于小规模数据可人工计算检查，对于较大规模数据则必须采用对照方法，即弄一个模拟法的代码，保证该代码正确，然后进行对照；
[2]如果发现加入遍历时，结果正确，但去掉遍历后结果不正确，则表明是处理结点标记的时候出了问题（因为在遍历过程中需要下放标记），进入dm或加标记操作中检查即可；
[3]其它情况下，可以在遍历中输出整个序列（或整棵树），进行对照，找出问题所在；
[4]如果数据过大，操作过多，人工分析时间较长，就只能采用读代码的方式检查了；
（6）最后，用mkdt造一个最大规模的数据，检查是否TLE、是否越界（数组是否开小）；
如果以上各点全部通过，就可以宣布AC了。

Mato_No1 2011-06-23 00:07 发表评论

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

Splay Tree 重复次数mul以及一些进阶操作

Mato_No1 — Tue, 21 Jun 2011 03:31:00 GMT
额……最近两天光顾着刷题忘了总结了……正好现在把总结的东东全部补上吧囧……

【重复次数mul】
在前面第一篇总结Splay Tree的时候就提到了结点的重复次数(mul)域，这个东东至今在网上还米看见有犇用（在本沙茶见过的范围内），但是不可否认的是这个域在某些情况下几乎是“必须使用”的。
所谓重复次数，就是将树中所有值(v)相同的结点全部合并成一个，这些结点的总个数就是合并后的结点的mul值。比如，在一棵空树中插入3个值为5的结点后，在使用mul域的情况下，树中只有一个结点，其v值为5，mul值为3。
在平衡树中，值相同的结点确实非常碍事。按照二叉查找树的定义：“要么是一棵空树，要么是一棵满足以下条件的非空树：根结点左子树中所有结点的值均小于根结点，根结点右子树中所有结点的值均大于根结点，且根的左右子树均为二叉查找树”，在二叉查找树中，是不应该出现值相同的结点的。可是在实际问题中，出现值相同的结点几乎是不可避免的。此时，树的定义就会变得非常模糊，也就是要把二叉查找树定义中的“小于”全部改为“小于等于”，“大于”全部改为“大于等于”。这样定义的树在一般情况下也米有神马问题，但是在找前趋(Pred)和找后继(Succ)操作中，问题就来了。因为根结点的前趋和后继的值可能与根结点相等（比如 HNOI2004 宠物收养所那一题），这时，根结点的前趋既有可能在左子树里，也有可能在右子树里，根结点的后继也一样。此时，这两个操作就无法进行了。
【mul域的维护】
mul域其实可以看成结点的一个本身属性，和v一样。因此在旋转、伸展操作中任何结点的mul值都是不会改变的。可能改变结点mul值的地方只有两处：一是插入，二是删除。在插入一个值为_v的结点的时候，如果发现值为_v的结点在树中已经存在，则只会将这个结点的mul值加1，而不是真正插入一个新的结点。同样的，在删除一个结点的时候，如果这个结点的mul值大于1，则只会将这个结点的mul值减1，而不是真正删除。
【mul域的作用】
mul域最主要的作用就是解决值相同的结点对于某些操作的影响。另外，mul域的引入可以减少树中结点的总个数（尤其是当插入的结点数很多而结点的值的范围不大的时候），从而降低时间复杂度（准确来说可以降低常数）。
【Splay Tree的进阶操作】
<1>找非根结点的前趋和后继。
Splay Tree由于有伸展操作，可以将要求前趋或后继的点伸展到根再求前趋或后继。如果要不通过伸展操作找一个非根结点的前趋或后继怎么办？
设这个结点为x。如果x有左子结点，则x的前趋就是x的左子结点的右链上的最后一个结点；如果x没有左子结点，则x的前趋就是从x开始往上（往x的祖先）查找，直到找到第一个是其父结点的右子结点的结点为止，则这个结点的父结点就是x的前趋（或者说，就是不断沿着x的父结点往上找，一开始都是往右的，找到第一个往左的就行了）。后继则正好相反。证明可以用中序遍历。
<2>找某个值v0的前趋和后继（值为v0的结点在树中不一定存在）。
所谓v0的前趋和后继，就是指在树中值小于（也有的是不大于）v0的最大的结点的值，和树中值大于（也有的是不小于）v0的最小的结点的值。在有了操作（1）【不通过伸展操作找非根结点的前趋和后继】以后，这个操作变得极为容易：先进行普通的查找操作（查找值为v0的结点），如果能找到，则剩下的步骤就和操作（1）一样了；如果找不到，则必然是找到某个空结点（0）处，假设在这里插入一个值为v0的结点（只是假设，不是真插入），则该结点显然是没有左子结点的，因此就是“从该结点开始往上查找，直到找到第一个是其父结点的右子结点的结点为止，则这个结点的父结点就是该结点的前趋”，也就是v0的前趋；后继类似。
在查找过程中可以进行一个常数优化：设点i为查找过程中“右转”的最后一个结点（即找到该结点后，接下来是该结点的右子结点），每次往右子结点转的时候就更新i，则最后结点i就是值v0的前趋；后继类似。
<3>删除所有值在某区间内的结点（这个区间可以是开区间、闭区间或半开半闭区间）。
以开区间为例：删除树中所有值在(l, r)范围内的结点。先找到l的前趋P和r的后继S（注意这里的前趋和后继是包括“等于”的），然后将P伸展到根，S伸展到P的右子结点处，则S的左子树中就是所有值在(l, r)范围内的结点，直接删掉这棵子树即可（注意删除后要更新S和P）；若改为闭区间，则将前趋和后继中的“等于”去掉（即必须是小于或大于）；半开半闭区间则一半按开区间处理，一半按闭区间处理。问题是，如果点P或点S不存在怎么办。有两种解决办法，一是若P和S之一存在，则将其伸展到根，然后直接删掉其左子树或右子树即可；若P和S都不存在，则树为空，直接将root置为0即可；二是按照sequence的办法，加入两个边界结点，当前趋或后继不存在时就认为是边界结点。
其实不光是删除，在找到了这棵子树后可以对它进行一些整体操作，从而让Splay Tree具有线段树的功能（这个在下面的NOI2005 sequence那一题里面会总结）。
<4>插入一棵树（当然这棵树也是Splay Tree，并且原树中的结点值序列与新树中的结点值序列不相交）。
有时候，题目中会连续出现很多插入操作，中间没有其它操作，此时，与其一个一个插入，还不如将它们先建成一棵树（建树的方法在下一篇里总结），再整体插入。整体插入的方法：设L和R分别是新树里值最小的结点和值最大的结点，在原树中找到L的前趋P和R的后继S，将P伸展到根，S伸展到P的右子结点处，由于原树中的结点值序列与新树中的结点值序列不相交（也就是原树中的结点值要么小于L的值，要么大于R的值），因此S无左子结点，此时将新树作为S的左子树即可。

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

终于摘掉了不会平衡树的帽子

Mato_No1 — Sat, 18 Jun 2011 13:21:00 GMT
     摘要: 今天真是有纪念意义啊……以前试着捉了N遍的cashier今天竟然AC了，本沙茶终于掌握了平衡树！！！【Splay Tree及其实现】<1>结点记录的信息：一般情况下Splay Tree是用线性存储器（结构数组）来存储的，可以避免在Linux下的指针异常问题。这样对于某个结点，至少要记录以下的域：值（又叫关键字）、左子结点的下标、右子结点的下标、父结点下标、子树大...  阅读全文

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

C++博客-Mato is No.1-随笔分类-平衡树

【AHOI2013复仇】再看HDU2871

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

PKU3017

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

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

平衡树调试技巧

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

Splay Tree 重复次数mul以及一些进阶操作

终于摘掉了不会平衡树的帽子

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