HDU 3487 Splay

给定两种操作，一种是把一个数列的某一段切下来插到剩余数列的某一个位置上。 一种是翻转操作，把数列的某一段进行翻转。

都是Splay的基本操作。标准的Rotateto调整出 [a,b]区间。然后对[a,b]区间修改parent标记和child标记。然后记住PushUp把修改标记推到树根上。简单一点就直接对某个节点spaly(x,0)就OK！

#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define keyTree   sp[sp[root].child[1]].child[0]
#define MaxL 300005

struct SplayTreeNode
{
    int parent, child[2];   // parent and child[0] left child[1] right
    int sz, val;  // sz 大小,size表示当前节点为根的子树的节点个数. val 表示当前节点的键值。
    int lazy;    // add 延迟标记
    long long sum;   // 以x为根节点的子树的所有的和
};

int num[MaxL];
vector<int> ret;
struct SpalyTree
{
    SplayTreeNode sp[MaxL];   // save space
    int gc[MaxL];   // Garbage Collection idx
    int root;  // root idx
    int idx;   // Forward allocate tree
    int idxrev; // garbage allocated nodes used for next allocation priority

    /*
         A                        B
       /       R(B,RR)->       /
      B     C    <-R(A,LL)     D     A
     /                             /
    D   E                          E    C
    */
    void Rotate(int x,int f)   // f ==0 l rot,1 r rot
    {
        int y = sp[x].parent;
        PushDown(y);
        PushDown(x);
        sp[y].child[!f] = sp[x].child[f];
        sp[sp[x].child[f]].parent = y;
        sp[x].parent = sp[y].parent;
        if(sp[x].parent)
            sp[sp[y].parent].child[ sp[sp[y].parent].child[1] == y]= x;
        sp[x].child[f] = y;
        sp[y].parent = x;
        PushUp(y);
    }

    void Splay(int x, int goal)
    {
        PushDown(x);
        while(sp[x].parent != goal)
        {
            if(sp[sp[x].parent].parent == goal)
                Rotate(x, sp[sp[x].parent].child[0] == x);
            else
            {
                int y = sp[x].parent, z = sp[y].parent;
                int f = sp[z].child[0] == y;
                if(sp[y].child[f] == x)
                    Rotate(x,!f), Rotate(x,f);
                else
                    Rotate(y,f), Rotate(x,f);
            }
        }
        PushUp(x);
        if(goal == 0) root = x;
    }

    //  把第k位的数转到goal下边
    int RotateTo(int k, int goal)
    {
        int x = root;
        PushDown(x);
        while(sp[sp[x].child[0]].sz !=k)
        {
            if( k< sp [ sp[x].child[0] ].sz)
                x = sp[x].child[0];
            else
            {
                k -= sp[sp[x].child[0]].sz +1;
                x = sp[x].child[1];
            }
            PushDown(x);
        }
//        cout<<"Rotate "<<x<<" goal "<<goal<<endl;
        Splay(x, goal);
        return x;
    }

    void NewNode(int &x, int c)
    {
        if( idxrev) x = gc[--idxrev];
        else  x = ++idx;
        sp[x].child[1] = 0, sp[x].child[0] = 0, sp[x].parent = 0;
        sp[x].sz = 1;
        sp[x].val = sp[x].sum = c;
        sp[x].lazy = 0;
    }

    //把以x为祖先结点（x 也算）删掉放进内存池,回收内存
    void eraseSubTree(int x)
    {
        int father = sp[x].parent;
        int head = idxrev , tail = idxrev;
        for (gc[tail++] = x ; head < tail ; head ++)
        {
            idxrev++;
            if( sp[gc[head]].child[0]) gc[tail++] = sp[gc[head]].child[0];
            if( sp[gc[head]].child[1]) gc[tail++] = sp[gc[head]].child[1];
        }
        sp[father].child[ sp[father].child[1] == x] = 0;
        PushUp(father);
    }

    void makeTree(int &x, int l, int r, int parent)
    {
        if(l > r) return ;
        int m = (l+r)>>1;
        NewNode(x,m);
        makeTree(sp[x].child[0], l, m-1, x);
        makeTree(sp[x].child[1], m+1, r, x);
        sp[x].parent = parent;
        PushUp(x);
    }
    void Init(int n)
    {
        idx = idxrev =  0;
        root = 0;
        sp[0].child[0] = sp[0].child[1] = sp[0].parent  = 0;
        sp[0].sz = sp[0].lazy = sp[0].sum = 0;
        NewNode(root, -1);
        NewNode(sp[root].child[1], -1);
        sp[idx].parent = root;
        sp[root].sz = 2;
        makeTree( sp [sp[root].child[1] ].child[0] , 1, n, sp[root].child[1]);
        PushUp(sp[root].child[1]);
        PushUp(root);
    }

    void Output(int x)
    {
        PushDown(x);
        if(x)
        {
            Output( sp[x].child[0]);
            if(sp[x].val > 0) ret.push_back(sp[x].val);
//            printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size = %2d ,val = %2d
",x, sp[x].child[0],sp[x].child[1],sp[x].parent,sp[x].sz,sp[x].val);
            Output( sp[x].child[1]);
        }

    }
    void Travel(int x)
    {
        PushDown(x);
        if(x)
        {
            Travel( sp[x].child[0]);
            printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size = %2d ,val = %2d
",x, sp[x].child[0],sp[x].child[1],sp[x].parent,sp[x].sz,sp[x].val);
            Travel( sp[x].child[1]);
        }
    }
    void PushUp(int x )
    {
        sp[x].sz = 1 + sp[sp[x].child[0]].sz + sp[sp[x].child[1]].sz;
    }

    void PushDown(int x)
    {
        if(sp[x].lazy)
        {
            if(sp[x].child[0]) sp[sp[x].child[0]].lazy ^= 1;
            if(sp[x].child[1]) sp[sp[x].child[1]].lazy ^= 1;
            swap(sp[x].child[0],sp[x].child[1]);
            sp[x].lazy = 0;
        }
    }

    void cut(int l, int r, int pos)
    {
        RotateTo(l-1,0);
        RotateTo(r+1,root);
        int x = keyTree;
        sp[sp[x].parent].child[0] = 0;
        sp[x].parent = 0;
        //Splay( sp[root].child[1], 0);
        PushUp(sp[root].child[1]);
        PushUp(root);


        RotateTo(pos, 0);
        sp[x].parent = RotateTo(pos+1, root);
        keyTree = x;
        //Splay(x, 0);
        PushUp(sp[root].child[1]);
        PushUp(root);
    }

    void rev( int l, int r)
    {
        RotateTo(l-1, 0);
        RotateTo(r+1, root);
        sp[keyTree].lazy ^= 1;
    }

} spt;

char cmd[10];
int main()
{
//    freopen("1.txt", "r", stdin);
    int n,m;
    while(scanf("%d %d",&n, &m), n!=-1 || m!=-1)
    {
        ret.clear();
        spt.Init(n);
        for(int i=0, a, b, c; i<m; i++)
        {
            scanf("%s", cmd);
            if(cmd[0]=='C')
            {

                scanf("%d%d%d", &a, &b, &c);
                spt.cut(a,b,c);
            }
            else
            {
                scanf("%d%d", &a, &b);
                spt.rev(a,b);
            }
        }
        spt.Output(spt.root);
        for(int i=0; i<ret.size(); i++)
        {
            cout<<ret[i];
            if(i != ret.size() -1)
                cout<<" ";
        }

        cout<<endl;
    }
    return 0;
}