BZOJ 1588 营业额统计 Splay

主要操作为Splay中插入节点，查找前驱和后继节点。

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
#define MaxL 100005
#define INF 0x7ffffff
#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 lazy;     //  延迟标记
    long long sum;   // 以x为根节点的子树的所有的和
};

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

    // x to be the child of goal, x and goal are key
    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下边，一般用来调整区间, 返回其key 键
    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;
    }

    // insert a value, return the key
    // first find the key, then insert a value.
    // 不重复插入
    pair<int,bool> Insert(int val)
    {
        int p = root;
        while( sp[p].val == val || sp[p].child[ sp[p].val < val ])
        {
            if(sp[p].val == val)
            {
                Splay(p, 0);
                return make_pair(p,false);
            }
            p = sp[p].child[sp[p].val < val];
        }
        int x = NewNode(sp[p].child[sp[p].val < val], val);
        sp[x].parent = p;
        Splay(x, 0);
        return make_pair(x, true);
    }

    int findPrefix(int x)
    {
        Splay(x,0);
        int p = sp[x].child[0];
        if(p)
        {
            while(sp[p].child[1])
                p = sp[p].child[1];
        }
        return p;
    }

    int findSuffix(int x)
    {
        Splay(x, 0);
        int p = sp[x].child[1];
        if(p)
        {
            while(sp[p].child[0])
                p = sp[p].child[0];
        }
        return p;
    }


    int 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;
        return x;
    }

    //把以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].lazy = sp[0].sum = 0;
    }

    void Travel(int 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]);
        }
    }

    //Problem Specific Function
    void PushUp(int x )
    {
        sp[x].sz = 1 + sp[sp[x].child[0]].sz + sp[sp[x].child[1]].sz;
        sp[x].sum = sp[x].lazy + sp[x].val + sp[sp[x].child[0]].sum + sp[sp[x].child[1]].sum;
    }

    void PushDown(int x)
    {
        if(sp[x].lazy)
        {
            sp[x].val += sp[x].lazy;
            sp[sp[x].child[0]].lazy += sp[x].lazy;
            sp[sp[x].child[1]].lazy += sp[x].lazy;
            sp[sp[x].child[0]].sum += (long long) sp[ sp[x].child[0]].sz * sp[x].lazy;
            sp[sp[x].child[1]].sum += (long long) sp[ sp[x].child[1]].sz * sp[x].lazy;
            sp[x].lazy = 0;
        }
    }

    void update(int l, int r, int c )
    {
        RotateTo(l-1,0);
        RotateTo(r+1,root);
        sp[keyTree].lazy += c;
        sp[keyTree].sum += (long long) c * sp[keyTree].sz;
    }

    // query for the interval [l,r]
    void query(int l, int r)
    {
        RotateTo(l-1,0);
        RotateTo(r+1,root);
//        int keyTree =  sp [sp[root].child[1] ].child[0];
        printf("%lld
",sp[keyTree].sum);
    }
} spt;

int abs(int x)
{
    if(x < 0) return -x;
    else return x;
}
int main()
{

    //freopen("1.txt","r",stdin);
    int n,m;
    cin>>n;
    m = 0;
    for(int i=0; i<n; i++)
        scanf("%d",&num[i]);
    spt.Init(0);
    int ret = 0;
    while(m!=n)
    {
        pair<int,bool> state = spt.Insert(num[m]);
        if(state.second != 0)
        {
            int pre = spt.findPrefix(state.first);
            int nxt = spt.findSuffix(state.first);
            int ans = INF;
            if(pre)
                ans = abs(num[m] - spt.sp[pre].val);
            if(nxt)
            {
                int x = abs(num[m] - spt.sp[nxt].val);
                ans = std::min(ans, x );
            }

            if(pre == 0 && nxt == 0) ans = num[0];
//            cout<<num[m]<<" "<<pre<<" "<<nxt<<" "<<ans<<endl;
            ret += ans;
        }
        m++;
    }
    cout<<ret<<endl;;
    return 0;
}