日韩亚洲国产精品,亚洲一区在线视频,国产农村妇女精品一区二区

【AHOI2013复仇】再看HDU2871

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

原题地址
本沙茶去�q�曾�l�用双线�D�|��的方法捉了这题（详见�q�里�Q�，最�q�重新审视这题发玎ͼ�借助�q��树，可以得到更简单的�Ҏ��?br />
题目大意�Q?br />有一个长度�ؓN的内存条�Q�每个位�|�的状态有占用和不占用两种�Q�有4�U�操作：
�Q?�Q�Reset�Q�清�I�所有内存（卛_��所有位�|�的状态改��Z��占用�Q�删除所有内存块�Q�；
�Q?�Q�New x�Q�申请一个新的内存块�Q�即扑ֈ�一个长度�ؓx的连�l�不占用位置区间�Q�将它们标记为占用，若有多个�q�样的区��_��取最左边的，若木有输出Reject New�Q?br />�Q?�Q�Free x�Q�在已申��L��内存块中�Q�找到包含位�|�x的�ƈ释放�Q�将该内存块删除�Q�同时其占用的所有位�|�改��Z��占用�Q�，若木有内存块包含位置x�Q�则输出Reject Free�Q?br />�Q?�Q�Get x�Q�找出已甌��的内存块中，左�v�W�x个，�q�输出其左端点；若已甌��的内存块数目不��x个，则输出Reject Get�?br />
可以发现�Q�每个已�l�申��L��内存块尽��代表一�D�区��_��但仍然是独立的单位，因此�Q�可以把内存块当成结点，用��^衡树�l�护�Q�关键字为内存块的左端点位置�Q�，New操作中内存块的插入与Free操作中内存块的删除均在此�q��树内�q�行�Q�Reset操作只需要将整棵树销毁即可�?br />问题是，在New操作中，需要找��C��个长度�ؓx的连�l�不占用区间�Q�而连�l�的不占用区间�ƈ不是独立的单位，因此需要��用线�D�|��l�护。在�U�段树中�Q�需要维�?lt;1>�l�点区间内最长连�l�不占用块的长度�Q?lt;2>�l�点区间左端、右端连�l�不占用块的长度�Q�否则无法维�?lt;1>�Q�；同时�Q�由于在New操作中需要区间整体改占用�Q�Free操作中又需要区间整体改不占用，所以应当支持整体改值的标记�Q�对于Reset操作�Q�只需要全部位�|�改不占用即可（不能重新建树�Q�！�Q�；

�q�样�Q�利用一��^衡树加一��늺��D�|��Q�就可以得到一个很��单的�Ҏ��了（代码量是双��^衡树或双�U�段树的一半左叻I��Q?br />
�q�题的启�C�是�Q�在解决数据�l�构�l�计�c�题的时候，到底选用什么样的数据结构，是有讲究的，因�ؓ它将直接影响到编�E�复杂度。一般来��_��U�段树比�q��树好写，但是�Ҏ��题而言�Q�双�U�段树反而不如��^衡树加线�D�|��好写�Q�这是因为对于内存块使用�q��树维护比使用�U�段树维护更好。在以后做这�U�题的时候，要多想一下，扑ֈ��便方法�?br />

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

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

【背景�?br />2012�q?�?9日，本沙茶开始看动态树论文�Q�搞懂了一些；
2012�q?�?0日，开始写动态树�Q��用的题是QTREE�Q�花了整整一天时间�ȝ��写完�Q�交上去�Q�TLE……
2012�q?�?1日，又调了一天，�Ҏ��?00+�l�随机数据都瞬间��Q�交上去�Q�还是TLE……
2012�q?�?日，WC2012�Q�fanhq666讲动态树�Q�又搞懂了一点，于是当天晚上回房间以后就开始��l�调�Q�交上去�Q�TLE……
2012�q?�?日，晚上�l�箋调QTREE�Q�TLE……
在挑战动态树N�ơ失败之后，本沙茶昨天再�ơ去挑战动态树……�q�次换了一个题�Q?a title="BZOJ2002" >BZOJ2002�Q�传说中的动态树模板题）
一开始还是TLE了，不过后来把数据搞到手以后�Q�发现TLE的原因�ƈ不是常数大，而是��d�@环了�Q�最后，�l�过2h+的调试，�ȝ��扑ֈ�了错误（有好几处�Q�，�l�于AC�?#8230;…

【关于BZOJ2002�?br />从每个点i往(i+Ki)�q�一条边�Q�如�?i+Ki)不存在则往一个附加的�l�点�Q�本沙茶的代码中�?��L��Q�因�?��L��是不能��用的�Q�连一条边�Q�这样就是一��|��Q�除1��L��外，每个�Ҏ��且只有一个后�l?#8230;…�Q�，然后�Q�问题中的两�U�操作就�?#8220;�Ҏ��”�?#8220;询问到根的距��?#8221;�Q�可以用动态树搞；

【代码�?br />

#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 = 200004, INF = ~0U >> 2;
struct node {
    int c[2], p, sz;
    bool rf, d;
} T[MAXN];
int n;
void sc(int _p, int _c, bool _d)
{
    T[_p].c[_d] = _c; T[_c].p = _p; T[_c].d = _d;
}
void upd(int No)
{
    T[No].sz = T[T[No].c[0]].sz + T[T[No].c[1]].sz + 1;
}
void rot(int No)
{
    int p = T[No].p; bool d = T[No].d;
    if (T[p].rf) {T[p].rf = 0; T[No].rf = 1; T[No].p = T[p].p;} else sc(T[p].p, No, T[p].d);
    sc(p, T[No].c[!d], d); sc(No, p, !d); upd(p);
}
void splay(int No)
{
    int p; while (!T[No].rf) if (T[p = T[No].p].rf) rot(No); else if (T[No].d == T[p].d) {rot(p); rot(No);} else {rot(No); rot(No);} upd(No);
}
int access(int x)
{
    int tmp = 0;
    do {
        splay(x); T[T[x].c[1]].rf = 1; T[tmp].rf = 0; sc(x, tmp, 1); upd(x); tmp = x; x = T[x].p;
    } while (x);
}
void cut(int x)
{
    access(x); splay(x); T[T[x].c[0]].rf = 1; T[T[x].c[0]].p = 0; sc(x, 0, 0); upd(x);
}
void join(int x, int p)
{
    access(x); T[x].p = p;
}
int main()
{
    int m, x, y, z;
    scanf("%d", &n); n++;
    re3(i, 2, n) {scanf("%d", &x); T[i].sz = 1; T[i].rf = 1; if (i + x <= n) T[i].p = i + x; else T[i].p = 1;}
    T[1].sz = 1; T[1].rf = 1; T[0].sz = 0;
    scanf("%d", &m);
    re(i, m) {
        scanf("%d", &x);
        if (x == 1) {
            scanf("%d", &y); y += 2;
            access(y); splay(y); printf("%d\n", T[T[y].c[0]].sz);
        } else {
            scanf("%d%d", &y, &z); y += 2;
            cut(y); if (y + z <= n) join(y, y + z); else join(y, 1);
        }
    }
    return 0;
}

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

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

新型LCA��法及树的�\径剖分模板�ȝ��

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

�?】新型LCA��法�Q�（在WJMZBMR��犇�I�间上发现的�Q�系��犇自创�Q�Orz�Q�！�Q�）
�q�种��法可以在仅使用树的路径剖分预处理中求出的DEP和UP来求��L��两点的LCA�Q�时间复杂度为O(log₂N)�Q�不需要单独的预处理�?br />步骤�Q�假设求a0、b0两点的LCA�Q�：
�Q?�Q�若UP[a0]==UP[b0]�Q�则a0、b0位于同一条重链上�Q�显然a0、b0中深度小的那个就是LCA了，�q�回�l�果�Q�结束；
�Q?�Q�若UP[a0]!=UP[b0]且DEP[UP[a0]]>=DEP[UP[b0]]�Q�则LCA不可能在a0所在的那条重链�?/strong>。证明：若LCA在a0所在的重链上，则UP[a0]必然也是a0、b0的公��q��先，也就是UP[a0]是b0的祖先。由于UP[a0]的深度大于等于UP[b0]�Q�若DEP[UP[a0]]>DEP[b0]�Q�则UP[a0]昄��不可能是b0的祖先，否则�Q�在b0所在的重链上必然存在一个点C�Q�满��DEP[C]=DEP[UP[a0]]�Q�显�Ӟ��C也是b0的祖先，�q�就说明在树中同一深度处存在两个不同的�l�点�Q�它们都是b0的祖先，�q�是不可能的�Q�所以，LCA不可能在a0所在重链上。那么，a0��可以上溯到UP[a0]的父�l�点处（也就是E[FA[UP[a0]]].a�Q�，b0不动�Q�然后��l�判断；
�Q?�Q�若UP[a0]!=UP[b0]且DEP[UP[a0]]�׃��a0、b0最多上溯O(log₂N)�ơ，所以该��法一定能在O(log₂N)旉��内求出LCA(a0, b0)�?br />该算法的应用很广�Q�不光可以在树的路径剖分中快速求出LCA�Q�精��代码�Q�同时也减少了一些时��_��因�ؓ它不需要像RMQ那样�q�行预处理）�Q�而且�Q�在一般的求LCA问题中，也可以先剖分求出UP再求LCA�?br />代码�Q?
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;
    }
}

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

对于�Ҏ��型的树，a0->LCA0的过�E�和b0->LCA0的过�E�都要包含LCA0引出的边�Q�b0==LCA0以及N==1时不需要特判（因�ؓ它们会自动地什么事都不做）�Q�在处理�q�程中，l0=ord[c], r0=ord[a0]-1�Q�要分轻边和重链分别处理�Q�每�ơa0上溯到c而不是c的父�l�点处；�l�止条�g为DEP[a0]<=DEP[LCA0]�?br />
模板题：PKU2831�Q�动态最��生成树问题�Q�需要涉及到最��生成树中两点之间�\径上的最大边权，用树的�\径剖分。其实本题有��ȝ��法�Q�不需要树的�\径剖分）

#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;
}

好了�Q�对于模板也��到此�ؓ止了�Q�接下来该搞应用了�?img src ="http://www.shnenglu.com/MatoNo1/aggbug/164163.html" width = "1" height = "1" />

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

Mato_No1 — Thu, 12 Jan 2012 12:44:00 GMT
     摘要: 【例题】[SDOI2011]染色�Q�注�Q�数据范围木有交代，应�ؓ�Q�点数N<=105�Q�操作数M<=105�Q�所有的颜色C为整��C��在[0, 109]之间。一、树的�\径剖分当中点权型�Q�点上有权��D��边上木有）的处理办法：�Q?�Q�找重链建线�D�|��的时候，w0中存储tot+1个数�Q��ؓ该重链自上而下的各点的权��|��例题中�ؓ颜色�Q�；�Q?�Q�除了父�Ҏ��轻边的叶�l�点之外�Q�树中的每个�l�点都属于且仅属于一条重链（�Ҏ��定义�?..  阅读全文

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

Mato_No1 — Tue, 03 Jan 2012 08:41:00 GMT
     摘要: 原题地址【有��x��的�\径剖分的东东在网上介�l�的太多�?#8230;…】常见的路径剖分的方法是轻重边剖分，��x��树中的边分�ؓ轻重两部分，�Ҏ��Q�设SZ[i]��Z��i为根的子树的大小�Q�结�Ҏ��L��Q�，则若点x不是叶结点，则其子结点中SZ值最大的�Q�注意，有多个SZ值最大的子结点应任选一个，只能选一个，防止出现重链�怺��Q�引发歧义）点y�Q�边(x, y)�U�Cؓ重边�Q�其余的辚w��是轻辏V��首��q�的重边�U�Cؓ重链�Q�注�?..  阅读全文

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

Splay Tree处理区间问题的几道好题及�ȝ��

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

�Q?�Q�Robotic Sort�Q?a title="HDU1890" >HDU1890�?a title="ZJU2985" >ZJU2985�Q?br />本题主要考察的是�Ҏ��c�问题，序列中给定值的索引问题�?br />当Splay Tree用来处理一个序列的时候，其关键字��是序列中元素的下标�Q�而不是元素的倹{��这��P��如果要查扑ֺ�列中�l�定的值的位置�Q�假讑ֺ�列中��L��两个元素的��g��相等�Q�看��h��无法实现。其实也是有办法实现的：因�ؓ元素在树中的下标是永�q�不变的�Q�也��是�Q�设�q�个序列为A�Q�如果A[i]在插入Splay Tree时的下标为j�Q�那么在A[i]被删除之前，其下标一直是j�Q�永�q�不会变�Q�注意元素在序列中的下标和在树中的下标是不同的）。利用这一性质可以解决�l�定值的索引问题�?br />对于本题�Q�每�ơ将从序列中�W�i��的元素到序列中�W�i个元素（�q�里假定元素下标是从1开始的�Q�而不是从0开始）之间的所有元素反转，�q�输出第i��的元素在反转之前的在序列中的下标。设B[i]为第i��的数的初始位置�Q�S[i]�?span style="color: #ff0000">初始位置在第i位的元素的下标，B[i]和S[i]都可以通过预处理得到。然后，每次交换前，求出S[B[i]]在树中的排名�Q�基本操作）�Q�再�?�Q�因为有边界�l�点�Q�就是该元素目前的位�|�，而序列中�W�i个元素就是树中第(i+1)��的元素�Q�再执行交换卛_��?br />不过需要千万注意的是本题的标记问题�Q�在求S[B[i]]在树中的排名�Ӟ��有可能其��先�l�点上有标记�Q�需要先遍历其所有的��先�l�点�Q�再逆向下放标记�Q�标记只能自��向下传�Q�。另外在交换的时候需要求出S[B[i]]的后�l�，在求后��的过�E�中需要查找，此时千万别忘了下放标讎ͼ��ȝ��_��凡是有查扄��地方�Q�就有dm�Q?br />代码�Q�本沙茶太弱了，是抄别�h的，因此其算法和上面�ȝ��的可能有差别�Q�神犇不要鄙视）

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

现在Splay Tree差不多弄完了�Q�接下来�q�有N多知名的、不知名的高�U�数据结�?#8230;…旉��MS有些不够用了�?#8230;…

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

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

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

【原题见�q�里�?br />本题是Splay Tree处理序列问题�Q�也��是当线�D�|��用）的一个典型例题�?br />
Splay Tree之所以可以当�U�段树用�Q�是因�ؓ它可以支持一个序列，然后�?#8220;左端前趋伸展到根�Q�右端后�l��展到根的叛_��l�点�Q�取根的叛_��l�点的左子结�?#8221;�q�种伸展�Ҏ��Q�对一个序列中的一整段�q�行整体操作。由于要防止出现前趋或后�l�不存在的情况，需要在�q�个序列的两端加入两个边界结点，要求其��g��能媄响到�l�点各种记蝲信息的维护（多取0�?#8734;�?∞�Q�。这两个边界�l�点在树中永�q�存在，不会被删除�?br />
�Q?�Q�结点的引用�Q?br />在当�U�段树用的Splay Tree中，真正的关键字是下标而不是��|��因此�Q?#8220;序列中第i个结�?#8221;实际上对应的�?#8220;树中�W?i+1)��的�l�点”�Q�因为左边还有一个边界结点）�Q�这��p��明在对结点引用时需要找�W�K��的操作。因此，下面�?#8220;�l�点x”指的�?#8220;树中�W?x+1)��的�l�点”�?br />�Q?�Q�标讎ͼ�
在线�D�|��中，如果对一个结�Ҏ��表示的线�D�|��体进行了某种操作�Q�需要在�q�个�l�点上打上一个标讎ͼ�在下一�ơ再扑ֈ��q�个�l�点�Ӟ��其标记就会下攑ֈ�其两个子�l�点上。在Splay Tree中也可以引入标记。比如要对[2, 6]�q�一�D�进行整体操作，��将�l�点1伸展到根的位�|�，��结�?伸展到根的右子树的位�|�，然后�l�点7的左子树��p��C�[2, 6]�q�一�D�，对这��子树的根结�Ҏ��上标记�ƈ立即生效�Q�必��L��立即生效�Q�而不是等下一�ơ引用再生效�Q�，也就是立��x��变该�l�点记录的一些信息的倹{��如果下�ơ再�ơ引用到�q�个�l�点�Q�就要将其标��C��攑ֈ�其两个子�l�点处；
需要注意的一�Ҏ��Q�如果要伸展某个�l�点x到r的子�l�点的位�|�，��必��M��证从x原来的位�|�到r的这个子�l�点�Q�x伸展后的位置�Q�上的所有结点上均没有标讎ͼ�否则��׃��D��标记混�ؕ。因此，必须首先扑ֈ��q�个�l�点x�Q�在此过�E�中不断下放标记�?br />�Q?�Q�自底向上维护的信息�Q?br />标记可以看成一�U�自��向下维护的信息。除了标��C��外，作�ؓ“�U�段�?#8221;�Q�往往�q�要�l�护一些自底向上维护的信息。比如在sequence�q�题中，��有lmax�Q�左�D�连�l�最大和�Q�、rmax�Q�右�D�连�l�最大和�Q�、midmax�Q�全�D�连�l�最大和�Q�以及sum�Q�全�D�|��d��Q�等信息要维护。对于这�c�M��东其实也很好办，因�ؓ子树大小�Q�sz域）��是一�U�自底向上维护的信息�Q�因此对于这些信息只要按照维护sz域的办法�l�护卛_��Q�统一写在upd函数里）。唯一的不同点是打标记时它们的值可能要改变�?br />�Q?�Q�对�q�箋插入的结点徏树：
本题的插入不是一个一个插入，而是一下子插入一整段�Q�因此需要先��它们徏成一��|��。一般徏树操作都是递归的，�q�里也一栗��设目前要对A[l..r]建树�Q�A为待插入序列�Q�，若l>r则退出，否则扑ֈ�位于中间的元素mid = l + r >> 1�Q�将A[mid]作根�Q�再对A[l..mid-1]建左子树�Q�对A[mid+1..r]建右子树卛_��。这样可以保证一开始徏的就是一��^衡树�Q�减��常数因子�?br />�Q?�Q�回收空��_��
�Ҏ��本题的数据范围提�C�，插入的结�Ҏ��L��最多可能达�?000000�Q�但在�Q何时��L��中最多只�?00002个结点（包括两个边界�Q�，此时��Z��节省�I�间�Q�可以采用��@环队列回收空间的�Ҏ��。即�Q�一开始将所有的可用�I�间�Q�可用下标，本题�?~500002�Q�存在��@环队列Q里，同时讄��头尾指针front和rear�Q�每�ơ如果有新结�Ҏ��入，��取出Q[front]�q�作为新�l�点的下标，如果有结点要删除�Q�本题是一�ơ删除整��子树，因此在删除后需要分别回收它们的�I�间�Q�，则从rear开始，��每个删除的�l�点的下标放回到Q里。当�Ӟ��q�种�Ҏ��是要牺牲一定的旉��的，因此在空间不是特别吃紧的情况下不要用�?br />
�?012�q?�?6日更新�?br />今天重写sequence的时候，�U�然发现加入的边界点可能会对lmax、rmax、midmax�{�的�l�护造成影响�Q�当序列中所有的值都是负数时�Q�若边界点的��D��?�Q�将使这3个��g��?�Q�所以，边界点的值应设�ؓ-INF�Q�不会媄响到sum�Q�因为可以单独调出[l, r]的sum�Q�避开边界�Q�。这��p��明�ƈ非所有这��L��题中都可以设�|�边界点�Q�比如HFTSC2011的那题就不行�Q�，如果边界点会对维护的信息造成影响�Q�就不能讄��边界点，在各个操作中�Q�分4�U�情况判断。（代码已经修改�Q?br />
下面上代码了�Q?
#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;
}

最后把我的�q�个代码与BYVoid��犇的本题代码进行测试比较，�l�果�Q�BYVoid��犇的代码见�q�里�Q�：

BYVoid��犇的：

本沙茶的�Q?br />

【相兌��文�?br />Mato_No1 2011-06-21 16:06 发表评论

日韩亚洲国产精品,亚洲一区在线视频,国产农村妇女精品一区二区

【AHOI2013复仇】再看HDU2871

新型LCA���法及树的�\径剖分模板�ȝ��

Splay Tree处理区间问题的几道好题及�ȝ��

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

新型LCA��法及树的�\径剖分模板�ȝ��