BZOJ1208: [HNOI2004]宠物收养所

Description
最近，阿Q开了一间宠物收养所。收养所提供两种服务：收养被主人遗弃的宠物和让新的主人领养这些宠物。每个领养者都希望领养到自己满意的宠物，阿Q根据领养者的要求通过他自己发明的一个特殊的公式，得出该领养者希望领养的宠物的特点值a（a是一个正整数，a<2^31），而他也给每个处在收养所的宠物一个特点值。这样他就能够很方便的处理整个领养宠物的过程了，宠物收养所总是会有两种情况发生：被遗弃的宠物过多或者是想要收养宠物的人太多，而宠物太少。
1．被遗弃的宠物过多时，假若到来一个领养者，这个领养者希望领养的宠物的特点值为a，那么它将会领养一只目前未被领养的宠物中特点值最接近a的一只宠物。（任何两只宠物的特点值都不可能是相同的，任何两个领养者的希望领养宠物的特点值也不可能是一样的）如果有两只满足要求的宠物，即存在两只宠物他们的特点值分别为a-b和a+b，那么领养者将会领养特点值为a-b的那只宠物。
2．收养宠物的人过多，假若到来一只被收养的宠物，那么哪个领养者能够领养它呢？能够领养它的领养者，是那个希望被领养宠物的特点值最接近该宠物特点值的领养者，如果该宠物的特点值为a，存在两个领养者他们希望领养宠物的特点值分别为a-b和a+b，那么特点值为a-b的那个领养者将成功领养该宠物。
一个领养者领养了一个特点值为a的宠物，而它本身希望领养的宠物的特点值为b，那么这个领养者的不满意程度为abs(a-b)。【任务描述】你得到了一年当中，领养者和被收养宠物到来收养所的情况，希望你计算所有收养了宠物的领养者的不满意程度的总和。这一年初始时，收养所里面既没有宠物，也没有领养者。
Input
第一行为一个正整数n，n<=80000，表示一年当中来到收养所的宠物和领养者的总数。接下来的n行，按到来时间的先后顺序描述了一年当中来到收养所的宠物和领养者的情况。每行有两个正整数a,
b，其中a=0表示宠物，a=1表示领养者，b表示宠物的特点值或是领养者希望领养宠物的特点值。（同一时间呆在收养所中的，要么全是宠物，要么全是领养者，这些宠物和领养者的个数不会超过10000个）
Output
仅有一个正整数，表示一年当中所有收养了宠物的领养者的不满意程度的总和mod 1000000以后的结果。
Sample Input
5
0 2
0 4
1 3
1 2
1 5
Sample Output
3
(abs(3-2) + abs(2-4)=3，最后一个领养者没有宠物可以领养)
HINT
Source
Splay

又是一道二叉排序树模板题，随便用一些高级数据结构即可，用一个变量now记录当前是“宠物树”还是“领养者树”，相同则加点，不同则删点，节点数为0时重新确认now，删点时可以查询前缀和后缀并优先选择前缀。
注意：我写的是SBT，其中left和right数组为iostream库的关键字还是怎么样的，无法编译，所以干脆不要调用iostream库。
在COGS上交了n遍，全部T掉，不知为何，但在BZOJ上能过。

#include
#include
#define isnum(t) ((t>=48)and(t<=57))
using namespace std;
const int N=80010;
const int mod=1000000;
int nodenum,key[N],left[N],right[N],size[N];
int n,now,ans,root;
void in(int &x)
{
    char t=getchar();int f=1;x=0;
    while(!isnum(t)){if(t=='-')f=-1;t=getchar();}
    while(isnum(t)){x=x*10+t-48;t=getchar();}
    x*=f;
}
void leftrot(int &t)
{
    int y=right[t];
    right[t]=left[y];
    left[y]=t;
    size[y]=size[t];
    size[t]=size[left[t]]+size[right[t]]+1;
    t=y;
}
void rightrot(int &t)
{
    int y=left[t];
    left[t]=right[y];
    right[y]=t;
    size[y]=size[t];
    size[t]=size[left[t]]+size[right[t]]+1;
    t=y;
}
void maintain(int &t,bool flag)
{
    if (!flag)
    {
        if (size[left[left[t]]]>size[right[t]]) rightrot(t);
        else
        if (size[right[left[t]]]>size[right[t]])
        {leftrot(left[t]);rightrot(t);}
        else return;
    }
    else
    {
        if (size[right[right[t]]]>size[left[t]]) leftrot(t);
        else
        if (size[left[right[t]]]>size[left[t]])
        {rightrot(right[t]);leftrot(t);}
        else return;
    }
    maintain(left[t],0);
    maintain(right[t],1);
    maintain(t,0);
    maintain(t,1);
}
void sinsert(int &t,int data)
{
    if (t==0)
    {
        t=++nodenum;
        left[t]=right[t]=0;
        key[t]=data;size[t]=1;
        return;
    }
    ++size[t];
    if (dataleft[t],data);
    else sinsert(right[t],data);
    maintain(t,data>=key[t]);
}
int sdelete(int &t,int v)
{
    --size[t];
    if ((v==key[t])or((vand(!left[t]))or((v>key[t])and(!right[t])))
    {
        int ans=key[t];
        if (!(left[t]*right[t])) t=left[t]+right[t];
        else
        {
            int tmp=left[t];
            while(right[tmp]) tmp=right[tmp];
            key[t]=sdelete(left[t],key[tmp]);
        }
        return ans;
    }
    else
    if (vleft[t],v);
    else return sdelete(right[t],v);
}
int prev(int x1,int y1,int data)
{
    if (!x1) return y1;
    if (data>=key[x1]) return prev(right[x1],x1,data);
    else return prev(left[x1],y1,data);
}
int succ(int x1,int y1,int data)
{
    if (!x1) return y1;
    if (data>=key[x1]) return succ(right[x1],y1,data);
    else return succ(left[x1],x1,data);
}
int sfind(int t,int data)
{
    while((t)and(key[t]!=data))
    {
        if (dataleft[t];
        else t=right[t];
    }
    return t;
}
int main()
{
    in(n);
    for (int i=1;i<=n;++i)
    {
        int x,y;
        in(x),in(y);
        if (!nodenum)
        {
            now=x;
            sinsert(root,y);
        }
        else
        if (now==x) sinsert(root,y);
        else
        {
            int tmp=sfind(root,y);
            if (!tmp)
            {
                int x1=prev(root,0,y);
                int x2=succ(root,0,y);
                if (x1&&x2)
                    if ((abs(key[x1]-y)<abs(key[x2]-y)))
                    {
                        ans=(ans+abs(key[x1]-y))%mod;
                        sdelete(root,key[x1]);
                    }
                    else
                    if ((abs(key[x1]-y)>abs(key[x2]-y)))
                    {
                        ans=(ans+abs(key[x2]-y))%mod;
                        sdelete(root,key[x2]);
                    }
                    else
                    {
                        ans=(ans+abs(key[x1]-y))%mod;
                        sdelete(root,key[x1]);
                    }
                else
                if (x1)
                {
                    ans=(ans+abs(key[x1]-y))%mod;
                    sdelete(root,key[x1]);
                }
                else
                {
                    ans=(ans+abs(key[x2]-y))%mod;
                    sdelete(root,key[x2]);
                }
            }
            else
            sdelete(root,y);
            --nodenum;
        }
    }
    printf("%d\n",ans);
    return 0;
}