CodeForces 19D Points (线段树+set)

D. Points

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Pete and Bob invented a new interesting game. Bob takes a sheet of paper and locates a Cartesian coordinate system on it as follows: point (0, 0) is
located in the bottom-left corner, Ox axis is directed right, Oy axis
is directed up. Pete gives Bob requests of three types:

• add x y — on the sheet of paper Bob marks a point with coordinates (x, y).
  For each request of this type it's guaranteed that point (x, y) is not yet marked on Bob's sheet at the time of the request.
• remove x y — on the sheet of paper Bob erases the previously marked point with coordinates (x, y).
  For each request of this type it's guaranteed that point (x, y) is already marked on Bob's sheet at the time of the request.
• find x y — on the sheet of paper Bob finds all the marked points, lying strictly above and strictly to the right of point (x, y).
  Among these points Bob chooses the leftmost one, if it is not unique, he chooses the bottommost one, and gives its coordinates to Pete.

Bob managed to answer the requests, when they were 10, 100 or 1000, but when their amount grew up to 2·105,
Bob failed to cope. Now he needs a program that will answer all Pete's requests. Help Bob, please!

Input

The first input line contains number n (1 ≤ n ≤ 2·105)
— amount of requests. Then there follow n lines — descriptions of the requests. add
x y describes the request to add a point, remove x y — the request to erase a point, find
x y — the request to find the bottom-left point. All the coordinates in the input file are non-negative and don't exceed 109.

Output

For each request of type find x y output in a separate line the answer to it — coordinates of the bottommost among the leftmost marked points, lying strictly
above and to the right of point (x, y). If there are no points strictly above and to the right of point (x, y),
output -1.

Examples

input

7
add 1 1
add 3 4
find 0 0
remove 1 1
find 0 0
add 1 1
find 0 0

output

1 1
3 4
1 1

input

13
add 5 5
add 5 6
add 5 7
add 6 5
add 6 6
add 6 7
add 7 5
add 7 6
add 7 7
find 6 6
remove 7 7
find 6 6
find 4 4

output

7 7
-1

5 5

这道题目对时间卡的比较狠，超时了好多次

题目的意思是在二维坐标系上找一个比指定点大的点，

一维用线段树，在线段树上套set.

题目的数据是1e9,我们可以离散化，也可以用动态线段树

这里用动态线段树，不用离散化。

其次，一开始用线段树，节点上的信息是这个区间X坐标被标记的数目。

在查询的时候，可以查询第一个比指定点x大的x坐标，然后再在这个x坐标节点上的set里面找符合条件的y坐标

这样的效率是n的，相当于顺序的一个一个点找过去。

后来线段树维护的是这个区间所有被标记的x坐标对应的y坐标的最大值。

整体效率n*logn*logn
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <vector>
#include <queue>
#include <set>

using namespace std;
typedef long long int LL;
const int maxn=2*1e5;
const int INF=0x7FFFFFFF;
int p;
int rt[maxn+5];
int ls[maxn*35+5];
int rs[maxn*35+5];
int sum[maxn*35+5];
set<int> a[maxn*35+5];
int n,m;
set<int>::iterator it;
int newnode()
{
    ls[p]=rs[p]=0;
    sum[p]=-1;
    return p++;
}
int nn;
void pushup(int node)
{
    if(!ls[node]&&rs[node])
        sum[node]=sum[rs[node]];
    else if(!rs[node]&&ls[node])
        sum[node]=sum[ls[node]];
    else if(ls[node]&&rs[node])
        sum[node]=max(sum[ls[node]],sum[rs[node]]);
    else
        sum[node]=-1;
}
void update(int &node,int l,int r,int tag,int tag2,int flag)
{
    if(!node) node=newnode();
    if(l==r)
    {
        if(flag)
        {

            a[node].insert(tag2);
			if(a[node].empty()) sum[node]=-1;
			else
			{
            it=a[node].end();
            it--;
            sum[node]=*(it);
			}
        }
        else
        {
            a[node].erase(tag2);
			if(a[node].empty()) sum[node]=-1;
			else
			{
            it=a[node].end();
            it--;
            sum[node]=*(it);
			}
        }

        return;
    }
    int mid=(l+r)>>1;
    if(tag<=mid) update(ls[node],l,mid,tag,tag2,flag);
    else update(rs[node],mid+1,r,tag,tag2,flag);
    pushup(node);
}
int query(int node,int l,int r,int tag,int y)
{
    if(!node) return -1;
    if(y>=sum[node]) return -1;

    if(l==r)
    {

		nn=*a[node].upper_bound(y);
		return l;
    }
    int ret;
    int mid=(l+r)>>1;
    if(tag>=mid) ret=query(rs[node],mid+1,r,tag,y);
    else
    {
        ret=query(ls[node],l,mid,tag,y);
        if(ret==-1)
        ret=query(rs[node],mid+1,r,tag,y);
    }
    return ret;
}
int main()
{
    scanf("%d",&n);
    char c[10];
    p=1;
    int root=0;
    int x,y;
	int r=1e9;
    for(int i=1;i<=n;i++)
    {
        scanf("%s",c);
        scanf("%d%d",&x,&y);
        if(c[0]=='a')
        {
            update(root,0,r,x,y,1);
        }
        else if(c[0]=='r')
        {
            update(root,0,r,x,y,0);
        }
        else if(c[0]=='f')
        {
            nn=INF;
            int xx=query(root,0,r,x,y);
            if(xx==-1||nn==INF)
			{
				printf("-1\n");
				continue;
			}
            printf("%d %d\n",xx,nn);
        }
    }
    return 0;
}