SPOJ 4487 Splay 基本操作

插入操作，删除操作和置换操作都是单点的，所以不需要lazy标记。这个很简单，都是两次RotateTo，一次Splay操作就搞定。

求最大连续字段和的操作和线段树的题目类似，只需要保存最左边的连续最大字段和，最右边的连续最大字段和，整个子树的连续最大字段和就OK，整个子树的和就OK。

注意PushUp函数的写法就OK

//Problem Specific Function
    void PushUp(int x )
    {
        int ll = sp[x].child[0], rr = sp[x].child[1];
        // sz, lsum , rsum , msum, sum
        sp[x].sz = 1 + sp[sp[x].child[0]].sz + sp[sp[x].child[1]].sz;
        sp[x].sum =  sp[x].val + sp[sp[x].child[0]].sum + sp[sp[x].child[1]].sum;
        sp[x].lsum = max(sp[ll].lsum, sp[ll].sum + sp[x].val + max(sp[rr].lsum, 0));
        sp[x].rsum = max(sp[rr].rsum, sp[rr].sum + sp[x].val + max(sp[ll].rsum , 0));
        // 这里类似于线段树的
        sp[x].msum = max(max(sp[ll].msum, sp[rr].msum), sp[x].val + max(sp[ll].rsum, 0) + max(sp[rr].lsum, 0));
    }

这个题目的代码

#include <cstdio>
#include <iostream>

using namespace std;
#define INF 10009
#define MaxL 222222
#define keyTree   sp[sp[root].child[1]].child[0]

struct SplayTreeNode
{
    int parent, child[2];   // parent and child[0] left child[1] right
    int sz, val;  // sz 表示当前节点为根的子树总节点个数.  val表示当前节点的键值。
    int sum;    // 以x为根节点的子树的所有的和
    int lsum;   // 以该点为根的子树的左子树最大的连续和 [left, x)
    int rsum;   // 以该点为根的子树的右子树 最大的连续和 (x, right]
    int msum;   // 以该点为根的子树中的连续最大字段和
};

int num[MaxL];
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 = sp[x].lsum = sp[x].rsum  = sp[x].msum = 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,num[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].sum = 0;
        sp[0].val = sp[0].lsum = sp[0].rsum = sp[0].msum = -INF;
        NewNode(root, -INF);
        NewNode(sp[root].child[1], -INF);
        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 Travel(int x)
    {
        if(x)
        {
            Travel( sp[x].child[0]);
            printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size = %2d ,val = %2d  sum = %2d
",x, sp[x].child[0],sp[x].child[1],sp[x].parent,sp[x].sz,sp[x].val, sp[x].sum);
            Travel( sp[x].child[1]);
        }
    }

    //Problem Specific Function
    void PushUp(int x )
    {
        int ll = sp[x].child[0], rr = sp[x].child[1];
        // sz, lsum , rsum , msum, sum
        sp[x].sz = 1 + sp[sp[x].child[0]].sz + sp[sp[x].child[1]].sz;
        sp[x].sum =  sp[x].val + sp[sp[x].child[0]].sum + sp[sp[x].child[1]].sum;
        sp[x].lsum = max(sp[ll].lsum, sp[ll].sum + sp[x].val + max(sp[rr].lsum, 0));
        sp[x].rsum = max(sp[rr].rsum, sp[rr].sum + sp[x].val + max(sp[ll].rsum , 0));
        // 这里类似于线段树的
        sp[x].msum = max(max(sp[ll].msum, sp[rr].msum), sp[x].val + max(sp[ll].rsum, 0) + max(sp[rr].lsum, 0));
    }

    void Insert(int pos, int m)
    {
        RotateTo(pos - 1, 0);
        RotateTo(pos, root);
        int p = 0;
        NewNode(p, m);
        keyTree = p;
        sp[p].parent = sp[root].child[1];
        Splay(p,0);
    }

    void Delete(int pos)
    {
        RotateTo(pos-1, 0);
        RotateTo(pos+1, root);
        eraseSubTree(keyTree);
        Splay(sp[root].child[1], 0);
    }

    void Replace(int pos, int m)
    {
        RotateTo(pos-1, 0);
        RotateTo(pos+1, root);
        int x = keyTree;
        sp[x].val = sp[x].sum = sp[x].lsum = sp[x].rsum  = sp[x].msum = m;
        Splay(keyTree,0);
    }

    int Query(int l, int r)
    {
        RotateTo(l -1, 0);
        RotateTo(r+1, root);

        int ret =  sp[keyTree].msum;
        Splay(keyTree,0);
        return ret;
    }
} spt;


int main()
{
//    freopen("1.txt","r",stdin);
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1; i<=n; i++)
            scanf("%d",&num[i]);
        spt.Init(n);
        int q;
        scanf("%d", &q);
        while(q--)
        {
            char op[2];
            scanf("%s",op);
            int pos,m;
            if(op[0]=='I')
            {
                n++;
                scanf("%d%d",&pos, &m);
                spt.Insert(pos,m);
            }
            else if(op[0]=='D')
            {
                n--;
//                scanf_(pos);
                scanf("%d", & pos);
                spt.Delete(pos);
            }
            else if(op[0]=='R')
            {
                scanf("%d%d",&pos, &m);
                spt.Replace(pos,m);
            }
            else if(op[0]=='Q')
            {
                scanf("%d%d", &pos, &m);
                printf("%d
", spt.Query(pos,m));
            }
        }
    }
    return 0;
}