[HNOI2004, 洛谷P2286]宠物收容所

题目描述

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

每个领养者都希望领养到自己满意的宠物，凡凡根据领养者的要求通过他自己发明的一个特殊的公式，得出该领养者希望领养的宠物的特点值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以后的结果。

思路还是很好想的, 宠物队列和收养者队列必定一者为空或同时为空. 我用了无旋Treap, 写了一小时, 写出了这种这样bug… 调了一个多小时才调好
比如, getMin(), getMax()函数中的while写成了if.
一些函数没有传引用, 一部分逻辑bug.

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cmath>
using namespace std;
const int MOD = 1e6;
struct Treap{
    Treap * left, * right;
    int value, priority, size;
    Treap(){};
    Treap(Treap * l, Treap * r, int v, int p): left(l), right(r), value(v), priority(p){
        size = 1;
    }
    void maintain(){
        size = left->size + right->size + 1;
    }
    int getSize(){
        return size - 2;// 哨兵有两个
    }
};
Treap * null = new Treap(), * pet = null, * person = null;
typedef pair<Treap *, Treap *> pTT;
pTT split_l(Treap * o, int val){
    if(o == null){
        return make_pair(null, null);
    }
    pTT result;
    if(o->value <= val){
        result = split_l(o->right, val);
        o->right = result.first;
        o->maintain();
        result.first = o;
    }
    else{
        result = split_l(o->left, val);
        o->left = result.second;
        o->maintain();
        result.second = o;
    }
    return result;
}
pTT split_r(Treap * o, int val){
    if(o == null){
        return make_pair(null, null);
    }
    pTT result;
    if(o->value < val){
        result = split_r(o->right, val);
        o->right = result.first;
        o->maintain();
        result.first = o;
    }
    else{
        result = split_r(o->left, val);
        o->left = result.second;
        o->maintain();
        result.second = o;
    }
    return result;
}
Treap * merge(Treap * left, Treap * right){
    if(left == null){
        return right;
    }
    if(right == null){
        return left;
    }
    if(left->priority < right->priority){
        left->right = merge(left->right, right);
        left->maintain();
        return left;
    }
    else{
        right->left = merge(left, right->left);
        right->maintain();
        return right;
    }
}
int getMax(Treap * root){
    while(root->right != null){// while 写成 if...
        root = root->right;
    }
    return root->value;
}
int getMin(Treap * root){// 只查询的函数, 不需要引用
    while(root->left != null){
        root = root->left;
    }
    return root->value;
}
int getNext(Treap * & root, int val){
    pTT tree = split_l(root, val);
    int rst = getMin(tree.second);
    root = merge(tree.first, tree.second);
    return rst;
}
int getPre(Treap * & root, int val){
    pTT tree = split_r(root, val);// 这里的逻辑要注意, 先分那个, 再分那个
    pTT right = split_l(tree.second, val);
    if(right.first != null){
        root = merge(tree.first, merge(right.first, right.second));
        return val;
    }
    tree.second = merge(right.first, right.second);

    int rst = getMax(tree.first);
    root = merge(tree.first, tree.second);
    return rst;
}
void insert(Treap * & root, int val){// 这种带修改的函数, 要传引用
    pTT tree = split_l(root, val);
    Treap * t = new Treap(null, null, val, rand());
    root = merge(merge(tree.first, t), tree.second);
}
void remove(Treap * & root, int val){
    pTT tree = split_l(root, val);
    pTT left = split_r(tree.first, val);

    left.second = merge(left.second->left, left.second->right);
    root = merge(merge(left.first, left.second), tree.second);
}
int main(){
    int inf = 0x3f3f3f3f;
    null->size = 0;

    int n, opt, a;
    long long cnt = 0;
    scanf("%d", &n);
    insert(pet, inf), insert(pet, -inf);// 哨兵方便计算
    insert(person, inf), insert(person, -inf);

    while(n--){
        scanf("%d%d", &opt, &a);
        if(opt){
            if(pet->getSize()){
                int pre = getPre(pet, a);
                int suc = getNext(pet, a);
                if(suc - a < a - pre){
                    remove(pet, suc);
                    cnt += suc - a;
                }
                else{
                    remove(pet, pre);
                    cnt += a - pre;
                }
                cnt %= MOD;
            }
            else{
                insert(person, a);
            }
        }
        else{
            if(person->getSize()){
                int pre = getPre(person, a);
                int suc = getNext(person, a);
                if(suc - a < a - pre){
                    remove(person, suc);
                    cnt += suc - a;
                }
                else{
                    remove(person, pre);
                    cnt += a - pre;
                }
                cnt %= MOD;
            }
            else{
                insert(pet, a);
            }
        }
    }
    printf("%lld\n", cnt);
    return 0;
}