KD-Tree 总结

      hdu 2966 In case of failure    求每个点的最短距离点的距离。直接建KD树，然后查询最近点距离就可以了。此题是比着点击打开链接写的，可以用另一种不用删除和插入的写法。

/*
    hdu 2966 In case of failure 求离每个点最近点的距离。
    差方建树。。
    有插入删除操作（可以不用插入删除）
*/
#include <iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
#define D 2
#define N 200010
const int inf=1000000001;
const long long Inf=1ll*inf*inf;
struct kdnode
{
    int x[D];
    int split;
    int l,r,p;
} kdtree[N],q[N];
bool operator==(const kdnode &a,const kdnode &b)
{
    for(int i=0; i<D; i++)
    {
        if(a.x[i]!=b.x[i])return false;
    }
    return true;
}
double avg[D],var[D];
int n;
void calAvg(int l,int r)
{
    for(int i=0; i<D; i++)avg[i]=0;
    for(int i=l; i<=r; i++)
        for(int j=0; j<D; j++)
            avg[j]+=1.0*kdtree[i].x[j]/(r-l+1);
}
void calVar(int l,int r)
{
    for(int i=0; i<D; i++)var[i]=0;
    for(int i=l; i<=r; i++)
        for(int j=0; j<D; j++)
            var[j]+=1.0*(kdtree[i].x[j]-avg[j])/n*(kdtree[i].x[j]-avg[j]);
}
int splitD;
double maxVar;
bool cmp(kdnode a,kdnode b)
{
    return a.x[splitD]<b.x[splitD];
}
int construct(int p,int l,int r)
{
    if(r<l)return -1;
    int root=(l+r)/2;
    calAvg(l,r);
    calVar(l,r);
    maxVar=-1.0;
    for(int i=0; i<D; i++)
        if(var[i]>maxVar)
            maxVar=var[i],splitD=i;
    sort(kdtree+l,kdtree+r+1,cmp);
    kdtree[root].split=splitD;
    kdtree[root].l=construct(root,l,root-1);
    kdtree[root].r=construct(root,root+1,r);
    kdtree[root].p=p;
    return root;
}
int Find(int root,kdnode x)
{
    if(root==-1)return -1;
    if(x==kdtree[root])
    {
        return root;
    }
    int d=kdtree[root].split;
    if(x.x[d]>kdtree[root].x[d])
    {
        return Find(kdtree[root].r,x);
    }
    else if(x.x[d]<kdtree[root].x[d])
    {
        return Find(kdtree[root].l,x);
    }
    else
    {
        int l=Find(kdtree[root].l,x);
        int r=Find(kdtree[root].r,x);
        return (l==-1?r:l);
    }
}
int FindMin(int root,int d)
{
    int ret=root;
    if(kdtree[root].l!=-1)
    {
        int v=FindMin(kdtree[root].l,d);
        if(kdtree[ret].x[d]>kdtree[v].x[d])
            ret=v;
     }
    if(kdtree[root].r!=-1)
    {
        int v=FindMin(kdtree[root].r,d);
        if(kdtree[ret].x[d]>kdtree[v].x[d])
            ret=v;
    }
    return ret;
}
int FindMax(int root,int d)
{
    int ret=root;
    if(kdtree[root].l!=-1)
    {
        int v=FindMax(kdtree[root].l,d);
        if(kdtree[ret].x[d]<kdtree[v].x[d])
            ret=v;
    }
    if(kdtree[root].r!=-1)
    {
        int v=FindMax(kdtree[root].r,d);
        if(kdtree[ret].x[d]<kdtree[v].x[d])
            ret=v;
    }
    return ret;
}
void DeleteNode(int v)
{
    int p=kdtree[v].p;
    kdtree[v].p=-1;
    if(kdtree[p].l==v)
        kdtree[p].l=-1;
    else
        kdtree[p].r=-1;
}
void Remove(int root,kdnode x)
{
    int pos=Find(root,x);
    if(kdtree[pos].l==-1&&kdtree[pos].r==-1)
    {
        DeleteNode(pos);
    }
    else if(kdtree[pos].l==-1)
    {
        int alt=FindMin(kdtree[pos].r,kdtree[pos].split);
        for(int i=0; i<D; i++)kdtree[pos].x[i]=kdtree[alt].x[i];
        Remove(alt,kdtree[alt]);
    }
    else
    {
        int alt=FindMax(kdtree[pos].l,kdtree[pos].split);
        for(int i=0; i<D; i++)kdtree[pos].x[i]=kdtree[alt].x[i];
        Remove(alt,kdtree[alt]);
    }
}
void Insert(int root,int x)
{
    int d=kdtree[root].split;
    if(kdtree[root].x[d]<kdtree[x].x[d])
    {
        if(kdtree[root].r==-1)
        {
            kdtree[root].r=x;
            kdtree[x].p=root;
        }
        else Insert(kdtree[root].r,x);
    }
    else
    {
        if(kdtree[root].l==-1)
        {
            kdtree[root].l=x;
            kdtree[x].p=root;
        }
        else Insert(kdtree[root].l,x);
    }
}
void Add(int root,kdnode x)
{
    int pos=n;
    kdtree[n++]=x;
    Insert(root,pos);
}

long long dist(kdnode a,kdnode b)
{
    long long ret=0;
    for(int i=0; i<D; i++)
    {
        ret+=1ll*(a.x[i]-b.x[i])*(a.x[i]-b.x[i]);
    }
    return ret;
}
long long query(int root,kdnode x)
{
    if(root==-1)return Inf;
    int d=kdtree[root].split;
    long long ret;
    if(x.x[d]<kdtree[root].x[d])
    {
        ret=query(kdtree[root].l,x);
        double dd=1.0*x.x[d]+sqrt(1.0*ret);
        if(dd>=1.0*kdtree[root].x[d])
        {
            ret=min(ret,query(kdtree[root].r,x));
        }
    }
    else if(x.x[d]>kdtree[root].x[d])
    {
        ret=query(kdtree[root].r,x);
        double dd=1.0*x.x[d]-sqrt(1.0*ret);
        if(dd<=1.0*kdtree[root].x[d])
        {
            ret=min(ret,query(kdtree[root].l,x));
        }
    }
    else
    {
        ret=query(kdtree[root].l,x);
        ret=min(ret,query(kdtree[root].r,x));
    }
    ret=min(ret,dist(kdtree[root],x));
    return ret;
}
int main()
{
//    freopen("in","r",stdin);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=0; i<n; i++)
        {
            kdtree[i].split=0;
            kdtree[i].p=kdtree[i].l=kdtree[i].r=-1;
            for(int j=0; j<D; j++)
            {
                scanf("%d",&kdtree[i].x[j]);
                q[i]=kdtree[i];
            }
        }

        int root=construct(-1,0,n-1);

        int m=n;
        for(int i=0; i<m; i++)
        {
            Remove(root,q[i]);
            cout<<query(root,q[i])<<endl;
            Add(root,q[i]);
        }
    }
    return 0;
}

hdu 4347 The Closest M Points 求离目标点最近的m个点，可以用优先队列去维护最近距离的集合，下面这个代码是转：wxfwxf328这位同学的。没有用差方最大的维作为当前维的split。代码很短。

/*
    hdu 4347 The Closest M Points 求离一点，最近的m点坐标
    建树比较随机，没有差方建树。。。
    类似线段树一样建树

    而且询问集合没有，当前查询点，可以通过求最近的m + 1个点，然后把最近的那个点（本身）去掉，即为所求解
*/
#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=55555,K=5;
const int inf=0x3f3f3f3f;

#define sqr(x) (x)*(x)
int k,n,idx;   //k为维数,n为点数
struct point
{
    int x[K];
    bool operator < (const point &u) const
    {
        return x[idx]<u.x[idx];
    }
}po[N];

typedef pair<double,point>tp;
priority_queue<tp>nq;

struct kdTree
{
    point pt[N<<2];
    int son[N<<2];

    void build(int l,int r,int rt=1,int dep=0)
    {
        if(l>r) return;
        son[rt]=r-l;
        son[rt*2]=son[rt*2+1]=-1;
        idx=dep%k;
        int mid=(l+r)/2;
        nth_element(po+l,po+mid,po+r+1);
        pt[rt]=po[mid];
        build(l,mid-1,rt*2,dep+1);
        build(mid+1,r,rt*2+1,dep+1);
    }
    void query(point p,int m,int rt=1,int dep=0)
    {
        if(son[rt]==-1) return;
        tp nd(0,pt[rt]);
        for(int i=0;i<k;i++) nd.first+=sqr(nd.second.x[i]-p.x[i]);
        int dim=dep%k,x=rt*2,y=rt*2+1,fg=0;
        if(p.x[dim]>=pt[rt].x[dim]) swap(x,y);
        if(~son[x]) query(p,m,x,dep+1);
        if(nq.size()<m) nq.push(nd),fg=1;
        else
        {
            if(nd.first<nq.top().first) nq.pop(),nq.push(nd);
            if(sqr(p.x[dim]-pt[rt].x[dim])<nq.top().first) fg=1;
        }
        if(~son[y]&&fg) query(p,m,y,dep+1);
    }
}kd;
void print(point &p)
{
    for(int j=0;j<k;j++) printf("%d%c",p.x[j],j==k-1?'\n':' ');
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        for(int i=0;i<n;i++) for(int j=0;j<k;j++) scanf("%d",&po[i].x[j]);
        kd.build(0,n-1);
        int t,m;
        for(scanf("%d",&t);t--;)
        {
            point ask;
            for(int j=0;j<k;j++) scanf("%d",&ask.x[j]);
            scanf("%d",&m); kd.query(ask,m);
            printf("the closest %d points are:\n", m);
            point pt[20];
            for(int j=0;!nq.empty();j++) pt[j]=nq.top().second,nq.pop();
            for(int j=m-1;j>=0;j--) print(pt[j]);
        }
    }
    return 0;
}

用差方的建树方法后的代码（竟然要慢一些，=.=!!!）：

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<cmath>
using namespace std;
#define N 100010

const int inf=1000000001;
const long long Inf=1ll*inf*inf;
int D;
struct kdnode
{
    int x[6];
    int split;
    int l,r,p;
    long long dis;
    bool operator < (const kdnode& rhs) const
    {
        return dis < rhs.dis;
    }
} kdtree[N];
priority_queue<kdnode> kdQ;
double avg[6],var[6];
int n;
void calAvg(int l,int r)
{
    for(int i=0; i<D; i++)avg[i]=0;
    for(int i=l; i<=r; i++)
        for(int j=0; j<D; j++)
            avg[j]+=1.0*kdtree[i].x[j]/(r-l+1);
}
void calVar(int l,int r)
{
    for(int i=0; i<D; i++)var[i]=0;
    for(int i=l; i<=r; i++)
        for(int j=0; j<D; j++)
            var[j]+=1.0*(kdtree[i].x[j]-avg[j])/n*(kdtree[i].x[j]-avg[j]);
}
int splitD;
double maxVar;
bool cmp(kdnode a,kdnode b)
{
    return a.x[splitD]<b.x[splitD];
}
int construct(int p,int l,int r)
{
    if(r<l)return -1;
    int root=(l+r)/2;
    calAvg(l,r);
    calVar(l,r);
    maxVar=-1.0;
    for(int i=0; i<D; i++)
        if(var[i]>maxVar)
            maxVar=var[i],splitD=i;
    sort(kdtree+l,kdtree+r+1,cmp);
    kdtree[root].split=splitD;
    kdtree[root].l=construct(root,l,root-1);
    kdtree[root].r=construct(root,root+1,r);
    kdtree[root].p=p;
    return root;
}

long long dist(kdnode a,kdnode b)
{
    long long ret=0;
    for(int i=0; i<D; i++)
    {
        ret+=1ll*(a.x[i]-b.x[i])*(a.x[i]-b.x[i]);
    }
    return ret;
}
void query(int root,kdnode x, int m)
{
    if(root==-1)return;
    int d=kdtree[root].split;
    kdnode tmp = kdtree[root];
    tmp.dis = dist(tmp, x);
    int xx = kdtree[root].l, yy = kdtree[root].r;
    if(x.x[d] > kdtree[root].x[d]) swap(xx, yy);
    if(xx != -1)
    {
        query(xx,x, m);
    }
    bool flag = false;
    if(kdQ.size()<m) kdQ.push(tmp), flag = true;
    else
    {
        if(tmp.dis < kdQ.top().dis) kdQ.pop(), kdQ.push(tmp);
        int ds = x.x[d] - kdtree[root].x[d];
        if(ds * ds < kdQ.top().dis) flag = true;
    }
    if(yy!=-1&&flag) query(yy,x,m);
}

kdnode ans[20];

int main()
{
    //freopen("stars.in","r",stdin);
    while(scanf("%d%d",&n, &D)!= EOF)
    {
        for(int i=0; i<n; i++)
        {
            kdtree[i].split=0;
            kdtree[i].p=kdtree[i].l=kdtree[i].r=-1;
            for(int j=0; j<D; j++)
            {
                scanf("%d",&kdtree[i].x[j]);
            }
        }

        int root=construct(-1,0,n-1);
        int t, m;
        kdnode x;
        scanf("%d", &t);
        while(t --)
        {
            for(int i = 0; i < D; i ++)
                scanf("%d", &x.x[i]);
            scanf("%d", &m);
            query(root,x,m);
            for(int i = 0; !kdQ.empty(); i ++)
                ans[i] = kdQ.top(), kdQ.pop();
            printf("the closest %d points are:\n", m);
            for(int i = m - 1; i >= 0; i --)
                for(int j = 0; j < D; j ++)
                    printf("%d%c", ans[i].x[j], j == D - 1 ? '\n' : ' ');
        }
    }
    return 0;
}

hunnu  11446 Star Simulations 求点对距离小于dis的点对个数。直接建树，然后求就可以了。

/*
    http://acm.hunnu.edu.cn/online/?action=problem&type=show&id=11446&courseid=0
    Proname   Star Simulations

    n个点求距离小于dis的的点对个数。
    用方差建树
*/
#include <iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
#define D 3
#define N 200010
const int inf=1000000001;
const long long Inf=1ll*inf*inf;
struct kdnode
{
    int x[D];
    int split;
    int l,r,p;
} kdtree[N],q[N];
bool operator==(const kdnode &a,const kdnode &b)
{
    for(int i=0; i<D; i++)
    {
        if(a.x[i]!=b.x[i])return false;
    }
    return true;
}
double avg[D],var[D];
int n, dis;
void calAvg(int l,int r)
{
    for(int i=0; i<D; i++)avg[i]=0;
    for(int i=l; i<=r; i++)
        for(int j=0; j<D; j++)
            avg[j]+=1.0*kdtree[i].x[j]/(r-l+1);
}
void calVar(int l,int r)
{
    for(int i=0; i<D; i++)var[i]=0;
    for(int i=l; i<=r; i++)
        for(int j=0; j<D; j++)
            var[j]+=1.0*(kdtree[i].x[j]-avg[j])/n*(kdtree[i].x[j]-avg[j]);
}
int splitD;
double maxVar;
bool cmp(kdnode a,kdnode b)
{
    return a.x[splitD]<b.x[splitD];
}
int construct(int p,int l,int r)//普通建树
{
    if(r<l)return -1;
    int root=(l+r)/2;
    calAvg(l,r);
    calVar(l,r);
    maxVar=-1.0;
    for(int i=0; i<D; i++)
        if(var[i]>maxVar)
            maxVar=var[i],splitD=i;
    sort(kdtree+l,kdtree+r+1,cmp);
    kdtree[root].split=splitD;
    kdtree[root].l=construct(root,l,root-1);
    kdtree[root].r=construct(root,root+1,r);
    kdtree[root].p=p;
    return root;
}

long long dist(kdnode a,kdnode b)
{
    long long ret=0;
    for(int i=0; i<D; i++)
    {
        ret+=1ll*(a.x[i]-b.x[i])*(a.x[i]-b.x[i]);
        if(ret > 1ll*dis*dis) return ret;
    }
    return ret;
}
int query(int root,kdnode x)
{
    if(root==-1)return 0;
    int d=kdtree[root].split;
    int ret = 0;
    if(x.x[d]<kdtree[root].x[d])
    {
        ret+=query(kdtree[root].l,x);
        if(x.x[d]+dis>kdtree[root].x[d])
        {
            ret+=query(kdtree[root].r,x);
        }
    }
    else if(x.x[d]>kdtree[root].x[d])
    {
        ret+=query(kdtree[root].r,x);
        if(x.x[d]-dis<kdtree[root].x[d])
        {
            ret+=query(kdtree[root].l,x);
        }
    }
    else
    {
        ret+=query(kdtree[root].l,x);
        ret+=query(kdtree[root].r,x);
    }
    if(dist(x, kdtree[root]) < 1ll*dis*dis) ret ++;
    return ret;
}
int main()
{
    //freopen("stars.in","r",stdin);
    while(scanf("%d%d",&n, &dis), n + dis)
    {
        for(int i=0; i<n; i++)
        {
            kdtree[i].split=0;
            kdtree[i].p=kdtree[i].l=kdtree[i].r=-1;
            for(int j=0; j<D; j++)
            {
                scanf("%d",&kdtree[i].x[j]);
                q[i]=kdtree[i];
            }
        }

        int root=construct(-1,0,n-1);
        int ans = 0;
        for(int i=0; i<n; i++)
        {
            ans += query(root,q[i]) - 1;
        }
        printf("%d\n", ans / 2);
    }
    return 0;
}