CodeForces 19D Points

离散化+线段树~~~

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <set>
#include <map>
#include <algorithm>
using namespace std;
const int MAXN = 200010;

struct Point
{
    int x, y;
    Point() {}
    Point(int t_x, int t_y) : x(t_x), y(t_y) {}
    friend bool operator < (const Point &p1, const Point &p2)
    {
        if(p1.x == p2.x)
            return p1.y < p2.y;
        return p1.x < p2.x;
    }
}p[MAXN], pp[MAXN];
char         op[MAXN][5];
int          max_y[MAXN<<2];
set<int>     save_y[MAXN];
map<int,int> save_pos;

void push_up(int rt)
{
    max_y[rt] = max(max_y[rt<<1], max_y[rt<<1|1]);
}

void bulid(int l, int r, int rt)
{
    max_y[rt] = -1;
    if(l == r) return ;
    int m = (l + r)>>1;
    bulid(l, m, rt<<1);
    bulid(m + 1, r, rt<<1|1);
    return ;
}

void update(int pos, int op, int y, int l, int r, int rt)
{
    if(l == r)
    {
        if(op == 1)
        {
            save_y[l].insert(y);
            max_y[rt] = max(max_y[rt], y);
            return ;
        }
        else if(op == 2)
        {
            save_y[l].erase(save_y[l].find(y));
            if(save_y[l].empty())
                max_y[rt] = -1;
            else
                max_y[rt] = *(--save_y[l].end());
        }
        return ;
    }
    int m = (l + r)>>1;
    if(pos <= m)
        update(pos, op, y, l, m, rt<<1);
    else
        update(pos, op, y, m + 1, r, rt<<1|1);
    push_up(rt);
    return ;
}


pair<int,int> query(int pos, int y, int l, int r, int rt)
{
    if(max_y[rt] <= y)
    {
        return make_pair(-1, -1);
    }

    if(l == r)
    {
        return make_pair(pp[l].x, *save_y[l].upper_bound(y));
    }
    int m = (l + r)>>1;
    if(pos > m)
        return query(pos, y, m + 1, r, rt<<1|1);
    else
    {
        pair<int,int> ret = query(pos, y, l, m, rt<<1);
        if(ret.first == -1)
            return query(m + 1, y, m + 1, r, rt<<1|1);
        else
            return ret;
    }
}

int main()
{
    //freopen("aa.in", "r", stdin);

    int n, cnt = 0, t_cnt;
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i)
    {
        save_y[i].clear();
        scanf("%s %d %d", op[i], &p[i].x, &p[i].y);
        if(op[i][0] == 'a')
            pp[++cnt] = p[i];
    }
    sort(pp + 1, pp + cnt + 1);
    t_cnt = 1; save_pos.clear(); save_pos[pp[1].x] = t_cnt;
    for(int i = 2; i <= cnt; ++i)
    {
        if(pp[i].x != pp[i-1].x)
        {
            pp[++t_cnt] = pp[i];
            save_pos[pp[i].x] = t_cnt;
        }
    }
    bulid(1, t_cnt, 1);
    for(int i = 1; i <= n; ++i)
    {
        if(op[i][0] == 'a')
        {
            update(save_pos[p[i].x], 1, p[i].y, 1, t_cnt, 1);
        }
        if(op[i][0] == 'r')
        {
            update(save_pos[p[i].x], 2, p[i].y, 1, t_cnt, 1);
        }
        if(op[i][0] == 'f')
        {

            map<int,int>::iterator iter = save_pos.upper_bound(p[i].x);
            if(iter == save_pos.end())
            {
                printf("-1\n");
            }
            else
            {
                pair<int,int> ret = query(iter->second, p[i].y, 1, t_cnt, 1);
                if(ret.first == -1)
                {
                    printf("-1\n");
                }
                else
                {
                    printf("%d %d\n", ret.first, ret.second);
                }
            }
        }
    }
    return 0;
}