KD-Tree简介（BZOJ4520）

简介

k-d树（k-dimensional树的简称），是一种分割k维数据空间的数据结构。主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。

应用

两个最常见的应用：范围查询、K近邻查询。

范围查询：给定查询点和查询距离的阈值，从数据集中找出所有与查询点距离小于阈值的数据。

K近邻查询： 给定查询点及正整数K，从数据集中找到距离查询点最近的K个数据。特别的，当K=1时，就是最近邻查询。

实现

构建KD-Tree

KD-Tree的本质是一颗BST，但是只有叶子节点保存每个点，其他节点保存的是一些划分的信息。

在构造BST的时候，因为只有一维，我们可以直接比较大小进行构造。而KD-Tree在构造时，则是每次选择其中一维比较。为了保证树的平衡，中位数放在当前节点。小的放左子树，大的放右子树。在构造下一层时，选择另外一维构造。如此构造下去直到当前只有一个点为止。

而在选择用哪一维时，一般有两种方法：

1.按顺序轮着来。这种比较直接。但是当点集在某一维很集中时，会特别难分。这时就要用到下面这种方法。

2.按照方差选择。每次选择方差最大的那一维分。这样就可以避免上述情况的发生。

应用实现（K近邻查询）

范围查询的题还没做到

以BZOJ4520为例

这道题要求我们找到n个点的第k远点对。

最暴力的做法当然是枚举两个点并计算。但是$n^2$显然过不去。而KD-Tree在这道题中的作用就是优化这个暴力，避免计算一些不可能的答案。

KD-Tree在这道题的查询中有以下几个步骤：

1.首先在递归前开一个大根堆

2.计算当前点与目标点之间的距离，如果答案大于堆顶，将堆顶元素取出并把答案压入堆中

3.计算左右子树的点到目标点的最大距离，并根据结果决定先递归哪棵子树

我们维护一个2*k的大根堆（因为距离会被计算两次），每次枚举一个点作为目标点，然后不断更新堆即可。最后的答案就是堆顶。

代码：

#include<queue>
#include<cctype>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 100005
#define F inline
using namespace std;
typedef long long LL;
struct tree{ int d[2],l,r,mn[2],mx[2]; }t[N],tmp;
struct nd{
    LL d; 
    F bool operator < (const nd &a) const{ return a.d<d; }
}tem;
int n,k,x,rt;
priority_queue <nd> que;
F char readc(){
    static char buf[100000],*l=buf,*r=buf;
    if (l==r) r=(l=buf)+fread(buf,1,100000,stdin);
    if (l==r) return EOF; return *l++;
}
F int _read(){
    int x=0,f=1; char ch=readc();
    while (!isdigit(ch)) { if (ch=='-') f=-1; ch=readc(); }
    while (isdigit(ch)) x=(x<<3)+(x<<1)+(ch^48),ch=readc();
    return x*f;
}
//以上为读优
F bool cmp(tree a,tree b){//取中位数
    return a.d[x]==b.d[x]?a.d[x^1]<b.d[x^1]:a.d[x]<b.d[x];
}
F void Max(int *a,int *b,int f){ a[f]=max(a[f],b[f]); }
F void Min(int *a,int *b,int f){ a[f]=min(a[f],b[f]); }
F void updt(tree &x){
    for (int i=0;i<2;i++){
        if (x.l) Max(x.mx,t[x.l].mx,i),Min(x.mn,t[x.l].mn,i);
        if (x.r) Max(x.mx,t[x.r].mx,i),Min(x.mn,t[x.r].mn,i);
    }
}
F int build(int l,int r,int now){//建树
    x=now; int mid=l+r>>1; tree &tt=t[mid];
    nth_element(t+l+1,t+mid+1,t+r+1,cmp);
    if (l<mid) tt.l=build(l,mid-1,x^1);
    if (mid<r) tt.r=build(mid+1,r,x^1);
    for (int i=0;i<2;i++) tt.mn[i]=tt.mx[i]=tt.d[i];
    return updt(t[mid]),mid;
}
F LL sqr(LL x){ return x*x; }
F LL calc(tree x){
    LL l=max(sqr(tmp.d[0]-x.mn[0]),sqr(tmp.d[0]-x.mx[0]));
    LL r=max(sqr(tmp.d[1]-x.mn[1]),sqr(tmp.d[1]-x.mx[1]));
    return l+r;
}
F void dfs(tree x){//查询
    LL l=0,r=0,d=sqr(tmp.d[0]-x.d[0])+sqr(tmp.d[1]-x.d[1]);
    if (d>(que.top()).d) que.pop(),tem.d=d,que.push(tem);//先更新当前点
    if (x.l) l=calc(t[x.l]); if (x.r) r=calc(t[x.r]);
    if (l>r){//递归下去
        if (l>que.top().d) dfs(t[x.l]);
        if (r>que.top().d) dfs(t[x.r]);
    }
    else{
        if (r>que.top().d) dfs(t[x.r]);
        if (l>que.top().d) dfs(t[x.l]);
    }
}
int main(){
    n=_read(),k=_read();
    for (int i=1;i<=n;i++) t[i].d[0]=_read(),t[i].d[1]=_read();
    tem.d=0,rt=build(1,n,0); while (!que.empty()) que.pop();
    for (int i=1;i<=k*2;i++) que.push(tem);//建堆
    for (int i=1;i<=n;i++) tmp=t[i],dfs(t[rt]);//枚举
    return printf("%lld\n",que.top().d),0;//堆顶就是答案
}