P2286 [HNOI2004]宠物收养场

题目描述

凡凡开了一间宠物收养场。收养场提供两种服务：收养被主人遗弃的宠物和让新的主人领养这些宠物。

每个领养者都希望领养到自己满意的宠物，凡凡根据领养者的要求通过他自己发明的一个特殊的公式，得出该领养者希望领养的宠物的特点值a（a是一个正整数，a<2^31），而他也给每个处在收养场的宠物一个特点值。这样他就能够很方便的处理整个领养宠物的过程了，宠物收养场总是会有两种情况发生：被遗弃的宠物过多或者是想要收养宠物的人太多，而宠物太少。

被遗弃的宠物过多时，假若到来一个领养者，这个领养者希望领养的宠物的特点值为a，那么它将会领养一只目前未被领养的宠物中特点值最接近a的一只宠物。（任何两只宠物的特点值都不可能是相同的，任何两个领养者的希望领养宠物的特点值也不可能是一样的）如果有两只满足要求的宠物，即存在两只宠物他们的特点值分别为a-b和a+b，那么领养者将会领养特点值为a-b的那只宠物。

收养宠物的人过多，假若到来一只被收养的宠物，那么哪个领养者能够领养它呢？能够领养它的领养者，是那个希望被领养宠物的特点值最接近该宠物特点值的领养者，如果该宠物的特点值为a，存在两个领养者他们希望领养宠物的特点值分别为a-b和a+b，那么特点值为a-b的那个领养者将成功领养该宠物。

一个领养者领养了一个特点值为a的宠物，而它本身希望领养的宠物的特点值为b，那么这个领养者的不满意程度为abs(a-b)。

你得到了一年当中，领养者和被收养宠物到来收养所的情况，请你计算所有收养了宠物的领养者的不满意程度的总和。这一年初始时，收养所里面既没有宠物，也没有领养者。

输入输出格式

输入格式：

第一行为一个正整数n，n<=80000，表示一年当中来到收养场的宠物和领养者的总数。接下来的n行，按到来时间的先后顺序描述了一年当中来到收养场的宠物和领养者的情况。每行有两个正整数a, b，其中a=0表示宠物，a=1表示领养者，b表示宠物的特点值或是领养者希望领养宠物的特点值。（同一时间呆在收养所中的，要么全是宠物，要么全是领养者，这些宠物和领养者的个数不会超过10000个）

输出格式：

仅有一个正整数，表示一年当中所有收养了宠物的领养者的不满意程度的总和mod 1000000以后的结果。

输入输出样例

输入样例#1： 复制

5                  
0 2                      
0 4                         
1 3
1 2
1 5

输出样例#1： 复制

3
注：abs(3-2) + abs(2-4)=3，
最后一个领养者没有宠物可以领养。

/*
    这个题一开始只开了一颗treap，但是zbq告诉我说，
    那些没领着宠物的人不会走，
    直到有宠物可以领或者是直到输入完数据也没有宠物可以领，然后失望的回家。
    （其实这是题目里说了的   没get到题目意思） 
    所以我们肯定不能把那些没有领猫的人扔了，我们要把他们存起来，
    所以我们开两颗treap，一颗存宠物，一颗存人。
    
    当有人来领宠物的时候，就判断：
        如果当前没有宠物，就把人存起来； 
        否则就去宠物树里找个满足要求的宠物让他领回去。
    当有宠物加入的时候，就判断：
        如果当前没有人来领养宠物，就把宠物存起来，
        否则就去人树里给它找个最合适的主领回去。
    
    怎么找宠物和主人：
        因为是找最接近要求的人和宠物，
        所以我们按当前的要求x找对应的pre（前驱）和nxt（后继），表示比x小的中最大的那个、比x大的中最小的那个 
        然后判断哪个更优，让答案加上这个最优解的贡献，最后把这个最优解给erase掉。
    
    因为我使用指针写的，自定义的null，所以不能直接扔到结构体里面封装起来做，但是有黑科技叫做namespace， 用namespace开两个空间，
    一个空间一颗treap，然后做就行了。
    
    代码比较长，但是其实有一半的东西是完全一样的 两颗namespace里的东西是完完全全一个样的。 
*/ 
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<ctime>
using namespace std;

const long long N=8e4+5;
const long long mod=1000000;
const long long INF=2147483647;

long long n,opt,x;

long long read()
{
    char c=getchar();long long num=0,f=1;
    for(;!isdigit(c);c=getchar())
        f=c=='-'?-1:f;
    for(;isdigit(c);c=getchar())
        num=num*10+c-'0';
    return num*f;
}

namespace Pet    //宠物树 
{
    struct Node
    {
        Node *son[2];
        long long key;
        long long heap_key;
        long long size;
    }node[N],_null;
    
    typedef Node* Tree;
    Tree null,root,now_node;    //null是自定义的空节点 
    
    void init()        //初始化 
    {
        srand(time(NULL));
        now_node=node;
        null=root=&_null;
        null->son[0]=null->son[1]=null;        //左右儿子等于空节点本身 
    }
    
    Tree newNode(long long key)        //新开节点 
    {
        ++now_node;
        now_node->key=key;
        now_node->size=1;
        now_node->heap_key=rand();
        now_node->son[0]=now_node->son[1]=null;        //左右儿子等于空节点 
        return now_node;
    }
    
    void rotate(Tree &root,bool flag)    //旋转 
    {
        Tree tmp=root->son[!flag];
        root->son[!flag]=tmp->son[flag];
        tmp->son[flag]=root;
        root->size=root->son[0]->size+root->son[1]->size+1;
        tmp->size=tmp->son[0]->size+tmp->son[1]->size+1;
        root=tmp;
    }
    
    void insert(Tree &root,long long key)    //插入 
    {
        if(root==null)
            root=newNode(key);
        else
        {
            bool flag=key>root->key;
            insert(root->son[flag],key);
            ++root->size;
            if(root->heap_key<root->son[flag]->heap_key)
                rotate(root,!flag);
        }
    }
    
    void erase(Tree &root,long long key)    //delete 用erase是因为、、、我与众不同 
    {
        if(root==null)
            return;
        if(key!=root->key)
        {
            bool flag=key>root->key;
            erase(root->son[flag],key);
            --root->size;
        }
        else
        {
            if(root->son[0]==null)
                root=root->son[1];
            else if(root->son[1]==null)
                root=root->son[0];
            else
            {
                bool flag=root->son[0]->heap_key>root->son[1]->heap_key;
                rotate(root,flag);
                erase(root->son[flag],key);
                --root->size;
            }
        }
    }
    
    long long query_pre(Tree root,long long x)        //查前驱 
    {
        if(root==null)
            return -INF;
        if(root->key==x)
            return x;
        if(x>root->key)
            return max(root->key,query_pre(root->son[1],x));
        return query_pre(root->son[0],x);
    }
    
    long long query_nxt(Tree root,long long x)        //查后继 
    {
        if(root==null)
            return INF;
        if(root->key==x)
            return x;
        if(root->key<x)
            return query_nxt(root->son[1],x);
        return min(root->key,query_nxt(root->son[0],x));
    }
}

namespace Peo    //人树 ，里面的东西是从宠物树里粘的，内容一样 
{
    struct Node
    {
        Node *son[2];
        long long key;
        long long heap_key;
        long long size;
    }node[N],_null;
    
    typedef Node* Tree;
    Tree null,root,now_node;
    
    void init()
    {
        srand(time(NULL));
        now_node=node;
        null=root=&_null;
        null->son[0]=null->son[1]=null;
    }
    
    Tree newNode(long long key)
    {
        ++now_node;
        now_node->key=key;
        now_node->size=1;
        now_node->heap_key=rand();
        now_node->son[0]=now_node->son[1]=null;
        return now_node;
    }
    
    void rotate(Tree &root,bool flag)
    {
        Tree tmp=root->son[!flag];
        root->son[!flag]=tmp->son[flag];
        tmp->son[flag]=root;
        root->size=root->son[0]->size+root->son[1]->size+1;
        tmp->size=tmp->son[0]->size+tmp->son[1]->size+1;
        root=tmp;
    }
    
    void insert(Tree &root,long long key)
    {
        if(root==null)
            root=newNode(key);
        else
        {
            bool flag=key>root->key;
            insert(root->son[flag],key);
            ++root->size;
            if(root->heap_key<root->son[flag]->heap_key)
                rotate(root,!flag);
        }
    }
    
    void erase(Tree &root,long long key)
    {
        if(root==null)
            return;
        if(key!=root->key)
        {
            bool flag=key>root->key;
            erase(root->son[flag],key);
            --root->size;
        }
        else
        {
            if(root->son[0]==null)
                root=root->son[1];
            else if(root->son[1]==null)
                root=root->son[0];
            else
            {
                bool flag=root->son[0]->heap_key>root->son[1]->heap_key;
                rotate(root,flag);
                erase(root->son[flag],key);
                --root->size;
            }
        }
    }
    
    long long query_pre(Tree root,long long x)
    {
        if(root==null)
            return -INF;
        if(root->key==x)
            return x;
        if(x>root->key)
            return max(root->key,query_pre(root->son[1],x));
        return query_pre(root->son[0],x);
    }
    
    long long query_nxt(Tree root,long long x)
    {
        if(root==null)
            return INF;
        if(root->key==x)
            return x;
        if(root->key<x)
            return query_nxt(root->son[1],x);
        return min(root->key,query_nxt(root->son[0],x));
    }
}

int main()
{
    Pet::init();    //初始化宠物树 
    Peo::init();    //初始化人树 
    long long ans=0;
    n=read();
    while(n--)
    {
        opt=read(),x=read();
        if(opt==0)    //有新宠物 
        {
            if(Peo::root==Peo::null)    //如果没人领 
            {
                Pet::insert(Pet::root,x);    //把宠物搁着 
            }
            else    //找个最合适的主领回去 
            {
                long long a=Peo::query_pre(Peo::root,x);
                long long b=Peo::query_nxt(Peo::root,x);
                if(abs(x-a)<=abs(x-b))        //看看哪个主更合适 
                {
                    ans+=abs(x-a);
                    Peo::erase(Peo::root,a);    //把这个主删了，表示他已经有宠物了 
                }
                else
                {
                    ans+=abs(x-b);
                    Peo::erase(Peo::root,b);            
                }
            }
        }
        else    //人，和宠物的一样 
        {
            if(Pet::root==Pet::null)
            {
                Peo::insert(Peo::root,x);
            }
            else
            {
                long long a=Pet::query_pre(Pet::root,x);
                long long b=Pet::query_nxt(Pet::root,x);
                if(abs(x-a)<=abs(x-b))
                {
                    ans+=abs(x-a);
                    Pet::erase(Pet::root,a);
                }
                else
                {
                    ans+=abs(x-b);
                    Pet::erase(Pet::root,b);            
                }
            }
        }
    }
    printf("%d",ans%mod);
    return 0;
}