Archery Tournament ( 线段树思想+set )

Archery Tournament ( 线段树思想+set )

题意： 有𝑛个操作，每次输入𝑡 𝑥 𝑦(𝑡=1,2;−109≤𝑥,𝑦≤109;𝑦>0). 当𝑡=1，在坐标平面上立一个圆心在𝑥,𝑦，半径为𝑦的圆形靶子。当𝑡=2，往点𝑥,𝑦射一箭，如果在这个点上有靶子，则输出这个靶子是在第几次操作中出现的，并把这个靶子销毁；如果这个点上没有靶子，则输出"−1"。

知识点：线段树、离散化、set的运用（目的是方便删除操作）。

思路：把圆形的靶子压扁，变成一条线段，第 i 号靶子当作i号颜色。就转变成了线段树维护区间染色问题，但是此题可以有重叠，所以每个区间可能被染多个颜色，所有用set来当作树的节点。有一个性质就是，区间更新不需要down， 因为单点查询x时，是自上往下的，所有一定会经过 需要down到x的节点。所有只要在下来的路上，都遍历一下颜色，就不需要down操作了。

范围是-1e～1e9，没法开这么大的线段树，所有需要离散化。

注意：有2e5个点，每个点可能会贡献2个值， 所有线段树最大需要开 4e5 * 4。

代码：

#include <bits/stdc++.h>
#define mid ((left+right)/2)
#define lson node*2,left,mid
#define rson node*2+1,mid+1,right

using namespace std;
const int maxn = 2e6+10;
set<int> G[maxn*5];
int a[maxn],cnt,n,ans;
struct node {
    int x,y,op;
}e[maxn];

void built_tree()
{
    for ( int i=1; i<=200001; i++ ) {
        G[i].clear();
    }
}

void update( int node, int left, int right, int L, int R, int id, int op ) // o掌管插入还是删除
{
    if ( left>=L && right<=R ) {
        if ( op==1 ) G[node].insert(id);
        else if ( op==0 ) G[node].erase(id);
        return ;
    }
    if ( L<=mid ) update(lson,L,R,id,op);
    if ( R>mid )  update(rson,L,R,id,op);
}

int judge( int i, int j )
{
    int x1 = e[i].x;
    int y1 = e[i].y;
    int x2 = e[j].x;
    int y2 = e[j].y;
    if ( 1ll*(x1-x2)*(x1-x2)+1ll*(y1-y2)*(y1-y2)<1ll*y1*y1 ) { // 这个地方需要用long long 运算
        return 1;
    }
    return 0;
}

void query( int node, int left, int right, int x, int id )
{
    if ( ans!=-1 ) return ; // 已经击中一个圆，就不用在继续了。
    if ( left<=x && right>=x ) {
        for ( set<int>::iterator i=G[node].begin(); i!=G[node].end(); i++ ) { // set的遍历方式
            int t = *i;
            if ( judge(t,id)==1 ) {
                ans = t;
                return ;
            }
        }
    }
    if ( left==right ) return ;  // 需要保证接下来有左右子树
    if ( x<=mid ) query(lson,x,id);
    if ( x>mid )  query(rson,x,id);
}

int main()
{
    cin >> n;
    cnt = 0;
    for ( int i=1; i<=n; i++ ) {
        scanf("%d %d %d",&e[i].op,&e[i].x,&e[i].y);
        if ( e[i].op==1 ) {
            a[cnt++] = e[i].x - e[i].y; // 这些是有用的点
            a[cnt++] = e[i].x + e[i].y; // 就是一个圆的左右边界
        }
        else a[cnt++] = e[i].x;  // 这个就是一个点， 不是圆
    }
    built_tree();
    sort(a,a+cnt);
    cnt = unique(a,a+cnt) - a;  // a数组用于离散化
    for ( int i=1; i<=n; i++ ) {
        if ( e[i].op==1 ) {
            int x = lower_bound(a,a+cnt,e[i].x - e[i].y)-a;  // 把e[i].x - e[i].y值 离散化为 下标。
            int y = lower_bound(a,a+cnt,e[i].x + e[i].y)-a;
            update(1,1,cnt,x,y,i,1);
        }
        else if ( e[i].op==2 ) {
            int x = lower_bound(a,a+cnt,e[i].x)-a;
            ans = -1;
            query(1,1,cnt,x,i);
            if ( ans!=-1 ) {
                int x = lower_bound(a,a+cnt,e[ans].x - e[ans].y)-a;
                int y = lower_bound(a,a+cnt,e[ans].x + e[ans].y)-a;
                update(1,1,cnt,x,y,ans,0);
            }
            printf("%d\n",ans);
        }
    }


    return 0;
}