bzoj 1208 宠物收养所 splay或set

题目：

http://www.lydsy.com/JudgeOnline/problem.php?id=1208

题意：*

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以后的结果。

思路：

用splay或者set均可以做，就是找前驱后继，因为屋子里同时只有宠物或者人，所以一个splay树或者set就可以了。更换了splay树的删除姿势，以前那个太挫了
splay

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;

const int N = 100010, INF = 0x3f3f3f3f, MOD = 1000000;
int son[N][2], key[N], pre[N], siz[N];
int root, num;
void new_node(int &x, int fa, int v)
{
    x = ++num;
    pre[x] = fa, key[x] = v;
    siz[x] = 1;
    son[x][0] = son[x][1] = 0;
}
void push_up(int x)
{
    siz[x] = siz[son[x][0]] + siz[son[x][1]] + 1;
}
void _rotate(int x, int dir)
{
    int y = pre[x];
    son[y][!dir] = son[x][dir], pre[son[x][dir]] = y;
    if(pre[y]) son[pre[y]][son[pre[y]][1]==y] = x;
    pre[x] = pre[y];
    son[x][dir] = y, pre[y] = x;
    push_up(x);
}
void splay(int x, int goal)
{
    while(pre[x] != goal)
    {
        int y = pre[x];
        if(pre[y] == goal) _rotate(x, son[y][0] == x);
        else
        {
            int dir = son[pre[y]][0] == y;
            if(son[y][dir] == x) _rotate(x, !dir), _rotate(x, dir);
            else _rotate(y, dir), _rotate(x, dir);
        }
    }
    push_up(x);
    if(goal == 0) root = x;
}
int get_prec(int x)
{
    int t = son[x][0];
    while(son[t][1]) t = son[t][1];
    return t;
}
int get_subs(int x)
{
    int t = son[x][1];
    while(son[t][0]) t = son[t][0];
    return t;
}
int _find(int v)
{
    int x = root;
    while(x && key[x] != v) x = son[x][key[x]<v];
    return x;
}
void _delete(int v)
{
    int x = _find(v);
    if(!x) return;
    splay(x, 0); //把待删除节点旋转到根
    if(!son[root][0] || !son[root][1]) //若根没有两个儿子，直接把一个儿子提到根
        root = son[root][0] + son[root][1], pre[root] = 0;
    else //若根有两个儿子，把根的后继旋转到根的右儿子，再提到根
    {
        int t = get_subs(root);
        splay(t, root);
        son[son[root][1]][0] = son[root][0], root = son[root][1];
        pre[son[root][0]] = root, pre[root] = 0;
        push_up(root);
    }
}
bool _insert(int v)
{
    if(!root) new_node(root, 0, v);
    else
    {
        int x = root;
        while(son[x][key[x]<v])
        {
            if(key[x] == v)
            {
                splay(x, 0);
                return false;
            }
            x = son[x][key[x]<v];
        }
        new_node(son[x][key[x]<v], x, v);
        splay(son[x][key[x]<v], 0);
    }
    return true;
}
int main()
{
    int n, a, b, res = 0, flag = 0;
    root = num = 0;
    _insert(-INF);
    _insert(INF);
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d%d", &a, &b);
        if(siz[root] == 2) flag = a;
        if(flag == a) _insert(b);
        else
        {
            _insert(b);
            int c = key[get_prec(root)], d = key[get_subs(root)];
            c = b-c <= d-b ? c : d;
            res = (res % MOD +  abs(b - c) % MOD) % MOD;
            _delete(b), _delete(c);
        }
    }
    printf("%d\n", res);
    return 0;
}

set

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#include <cmath>
using namespace std;

const int MOD = 1000000;
typedef long long ll;
int main()
{
    int n, flag = 0;
    scanf("%d", &n);
    set<int> ste;
    set<int> :: iterator p;
    int res = 0;
    for(int i = 1; i <= n; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        if(ste.empty()) flag = a;
        if(flag == a) ste.insert(b);
        else
        {
            p = ste.lower_bound(b);
            if(*p == b) ste.erase(*p);
            else
            {
                int t1 = *p, t2;
                if(p == ste.begin())
                {
                    res = (res % MOD + abs(b - t1) % MOD) % MOD, ste.erase(t1);
                }
                else if(p == ste.end())
                {
                    t2 = *(--p);
                    res = (res % MOD + abs(b - t2) % MOD) % MOD, ste.erase(t2);
                }
                else
                {
                    t2 = *(--p);
                    if(b - t2 <= t1 - b) res = (res % MOD + abs(b - t2) % MOD) % MOD, ste.erase(t2);
                    else res = (res % MOD + abs(b - t1) % MOD) % MOD, ste.erase(t1);
                }
            }
        }
    }
    printf("%d\n", res);
    return 0;
}