[BZOJ2626][清橙A1302]JZPFAR-K-D树

JZPFAR

Description

　　平面上有n个点。现在有m次询问，每次给定一个点(px, py)和一个整数k，输出n个点中离(px, py)的距离第k大的点的标号。如果有两个(或多个)点距离(px, py)相同，那么认为标号较小的点距离较大。

Input

　　第一行，一个整数n，表示点的个数。
　　下面n行，每行两个整数x_i, y_i，表示n个点的坐标。点的标号按照输入顺序，分别为1..n。
　　下面一行，一个整数m，表示询问个数。
　　下面m行，每行三个整数px_i, py_i, k_i，表示一个询问。

Output

　　m行，每行一个整数，表示相应的询问的答案。
　　

Sample Input

3
0 0
0 1
0 2
3
1 1 2
0 0 3
0 1 1

Sample Output

3
1
1

数据规模和约定
50%的数据中，n个点的坐标在某范围内随机分布。
100%的数据中，n<=10^5, m<=10^4, 1<=k<=20，所有点(包括询问的点)的坐标满足绝对值<=10^9，n个点中任意两点坐标不同，m个询问的点的坐标在某范围内随机分布。

---

一个小于号调了咱一上午……

(╯‵□′)╯︵┻━┻

---

思路:
根据题面可知这是K-D树。
然而咱要求的不是最近邻而是第k近邻…….

那么，可以用一个优先队列维护当前已经访问过的距查询位置前K大的点，每查到一个点就判断一下，如果它距查询点的距离比队首更远，就弹出队首并把当前点加入队列即可。

同时判断是否能递归左右子树的条件也变成了是否大于队首点距查询位置的距离。

然后……上面那一步一定不能把大于小于号写反!!!(╯‵□′)╯︵┻━┻

---

#include<iostream>
#include<queue>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

const int Inf=0x3f3f3f3f;
typedef long long ll;

inline ll maxx(ll a,ll b){if(a>b)return a;return b;}
inline ll minn(ll a,ll b){if(a<b)return a;return b;}
inline ll abss(ll a){if(a<0)return -a;return a;}
inline ll sqr(ll a){return a*a;}

inline ll read()
{
    ll x=0,f=1;char ch=getchar();
    while(ch<'0' || '9'<ch)
    {
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while('0'<=ch && ch<='9')
    {
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}

int n,m,main_d;
int sum[10];

struct point
{
    ll coord[2],mn[2],mx[2];
    int l,r,id;

    ll &operator [](int x)
    {
        return coord[x];
    }

    inline void init()
    {
        for(int i=0;i<2;i++)
            mn[i]=mx[i]=coord[i];
    }

    point(ll x=0,ll y=0)
    {
        l=r=0;
        coord[0]=x;
        coord[1]=y;
    }
}t[100009];

bool operator < (point satori,point koishi)
{
    return satori[main_d]<koishi[main_d];
}

struct node
{
    ll dis;
    int id;
    node(int ind,ll d)
    {
        id=ind;dis=d;
    }
};

bool operator <(node satori,node koishi)
{
    if(satori.dis==koishi.dis)
        return satori.id<koishi.id;
    return satori.dis>koishi.dis;
}

struct K_Dimensional_Tree
{
    int root;
    priority_queue<node> satori;

    inline void clean()
    {
        while(!satori.empty())
            satori.pop();
    }

    inline ll dis(point satori,point koishi)
    {
        return sqr(satori[0]-koishi[0])+sqr(satori[1]-koishi[1]);
    }

    inline ll range(point satori,point koishi)
    {
        ll ans=0;
        for(int i=0;i<2;i++)
            ans+=maxx(sqr(satori.mn[i]-koishi[i]),sqr(satori.mx[i]-koishi[i]));
        return ans;
    }

    void update(int n)
    {
        static int a[2];
        a[0]=t[n].l,a[1]=t[n].r;
        for(int j=0;j<2;j++)
            if(a[j])
                for(int i=0;i<2;i++)
                {
                    t[n].mn[i]=minn(t[n].mn[i],t[a[j]].mn[i]);
                    t[n].mx[i]=maxx(t[n].mx[i],t[a[j]].mx[i]);
                }
    }

    int biu(int l,int r,int d)
    {
        main_d=d;
        if(l>r)return 0;

        int mid=l+r>>1;
        nth_element(t+l,t+mid,t+r+1);
        t[mid].init();

        if(l<mid)
            t[mid].l=biu(l,mid-1,d^1);
        if(mid<r)
            t[mid].r=biu(mid+1,r,d^1);

        update(mid);
        return mid;
    }

    void query(int x,point p)
    {
        if(!x)return;

        ll dist=dis(t[x],p);
        ll dl=-Inf,dr=-Inf;
        int l=t[x].l,r=t[x].r;

        if(dist>satori.top().dis || (dist==satori.top().dis && satori.top().id>t[x].id))
        {
            satori.pop();
            satori.push((node){t[x].id,dist});
        }

        if(l)
            dl=range(t[l],p);
        if(r)
            dr=range(t[r],p);

        if(dl>dr)
        {
            if(l && dl>=satori.top().dis)
                query(l,p);
            if(r && dr>=satori.top().dis)
                query(r,p);
        }
        else
        {
            if(r && dr>=satori.top().dis)
                query(r,p);
            if(l && dl>=satori.top().dis)
                query(l,p);
        }
    }
}koishi;

int main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        t[i][0]=read();
        t[i][1]=read();
        t[i].id=i;
    }

    koishi.root=koishi.biu(1,n,0);

    m=read();
    for(int i=1,k;i<=m;i++)
    {
        point q;
        q[0]=read();
        q[1]=read();
        k=read();

        koishi.clean();
        for(int i=1;i<=k;i++)
            koishi.satori.push((node){0,-Inf});
        koishi.query(koishi.root,q);

        printf("%d\n",koishi.satori.top().id);
    }

    return 0;
}