kd树模板+全图最小生成树
标签（空格分隔）： kd树+最小生成树
下面给出kd树有注释的讲解代码，和没有注释的模板代码：
const int K = 5;//维度
int n,m,idx;
struct Point {
int id;//节点编号
int x[K];//对应每一个维度的坐标
bool operator < (const Point &u) const {
return x[idx]<u.x[idx];//按照第idx维坐标从小到大排列
}
}po[Maxn];
double pow(double x){
return 1.0*x*x;
}
double pow(int x){
return 1.0*x*x;
}
struct PDP{
double dis;//距离目标点的距离
Point p;//这个点
bool operator<(const PDP pdp) const{
if(dis!=pdp.dis) return dis< pdp.dis;
else {
for(int i = 0; i < K; i++)
if(p.x[i] != pdp.p.x[i]) return p.x[i] < pdp.p.x[i];
return false;
}
}//按照距离排序，距离一样按照每一维度的从小到大排列
PDP (double _dis,Point _p)
{
dis = _dis;
p = _p;
}//构造函数
};
priority_queue<PDP> nq;//优先队列保存于跟新距离某个点距离第k大的这些点
struct Tree{//kd树，因为一定是二叉树，所以可以用编号保存树
Point p[Maxn<<2];//树的节点
int son[Maxn<<2];//每个节点的孩子个数，用来判断是否到达根节点
void build (int l, int r, int u = 1, int dep = 0)//建树
{
if(l>r) return;
son[u] = r-l;
son[u<<1] = son[u<<1|1] = -1;
idx = dep%K;//维度划分方式
int mid = (l+r)>>1;//以中间点来划分树
nth_element(po+l,po+mid,po+r+1);//比mid对应第idx维度下的坐标小的都在左边，大的在右边。
p[u] = po[mid];//定义节点的编号
build(l,mid-1,u<<1,dep+1);
build(mid+1,r,u<<1|1,dep+1);
}
void query(Point a, int m, int u = 1, int dep = 0)//查询距离a前m大的数
{
if(son[u]==-1) return ;
PDP nd(0,p[u]);//判断根节点
for(int i = 0; i < K; i++)
nd.dis += pow(nd.p.x[i]-a.x[i]);//计算根节点到节点a的距离
int dim = dep%K, fg = 0;//当前维度和是否需要继续向下判断
int x = u<<1, y = u<<1|1;//左右孩子，每次都是先判断左孩子
if(a.x[dim]>=p[u].x[dim]) swap(x,y);//如果这个点位于根节点的左孩子，那么先找左孩子肯定比较更容易找到解
if(~son[x]) query(a,m,x,dep+1);//如果左孩子的值不等于-1即不空则查询左区间
if(nq.size() < m) nq.push(nd),fg = 1;//如果队列中不足m个元素，则把这个点加入队列
else {
if(nd.dis < nq.top().dis) nq.pop(),nq.push(nd);//如果这个点的距离比当前队列中最大的那个还要小，则替换最大的
if(pow(a.x[dim]-p[u].x[dim]) < nq.top().dis) fg = 1;//如果在这个维度上a距离分界点的距离都要大于队列中m个元素距离a的距离则没有必要再搜索右子树了。相反要搜索右子树，fg = 1;
}
if(~son[y] && fg) query(a,m,y,dep+1);//右子树不空且有必要搜索右子树时候搜索右子树
}
}kd;
kd树模板
const int K = 5;
int n,m,idx;
struct Point {
int id;
int x[K];
bool operator < (const Point &u) const {
return x[idx]<u.x[idx];
}
}po[Maxn];
double pow(double x){
return 1.0*x*x;
}
double pow(int x){
return 1.0*x*x;
}
struct PDP{
double dis;
Point p;
bool operator<(const PDP pdp) const{
if(dis!=pdp.dis) return dis< pdp.dis;
else {
for(int i = 0; i < K; i++)
if(p.x[i] != pdp.p.x[i]) return p.x[i] < pdp.p.x[i];
return false;
}
}
PDP (double _dis,Point _p)
{
dis = _dis;
p = _p;
}
};
priority_queue<PDP> nq;
struct Tree{
Point p[Maxn<<2];
int son[Maxn<<2];
void build (int l, int r, int u = 1, int dep = 0)
{
if(l>r) return;
son[u] = r-l;
son[u<<1] = son[u<<1|1] = -1;
idx = dep%K;
int mid = (l+r)>>1;
nth_element(po+l,po+mid,po+r+1);
p[u] = po[mid];
build(l,mid-1,u<<1,dep+1);
build(mid+1,r,u<<1|1,dep+1);
}
void query(Point a, int m, int u = 1, int dep = 0)
{
if(son[u]==-1) return ;
PDP nd(0,p[u]);
for(int i = 0; i < K; i++)
nd.dis += pow(nd.p.x[i]-a.x[i]);
int dim = dep%K, fg = 0;
int x = u<<1, y = u<<1|1;
if(a.x[dim]>=p[u].x[dim]) swap(x,y);
if(~son[x]) query(a,m,x,dep+1);
if(nq.size() < m) nq.push(nd),fg = 1;
else {
if(nd.dis < nq.top().dis) nq.pop(),nq.push(nd);
if(pow(a.x[dim]-p[u].x[dim]) < nq.top().dis) fg = 1;
}
if(~son[y] && fg) query(a,m,y,dep+1);
}
}kd;
下面是这个题的ac代码
//kd树+最小生成树
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<iostream>
#include<cmath>
#define Maxn 20008
#define Maxm 500008
using namespace std;
const int K = 5;//维度
int n,m,idx;
struct Point {
int id;//节点编号
int x[K];//对应每一个维度的坐标
bool operator < (const Point &u) const {
return x[idx]<u.x[idx];//按照第idx维坐标从小到大排列
}
}po[Maxn];
double pow(double x){
return 1.0*x*x;
}
double pow(int x){
return 1.0*x*x;
}
struct PDP{
double dis;//距离目标点的距离
Point p;//这个点
bool operator<(const PDP pdp) const{
if(dis!=pdp.dis) return dis< pdp.dis;
else {
for(int i = 0; i < K; i++)
if(p.x[i] != pdp.p.x[i]) return p.x[i] < pdp.p.x[i];
return false;
}
}//按照距离排序，距离一样按照每一维度的从小到大排列
PDP (double _dis,Point _p)
{
dis = _dis;
p = _p;
}//构造函数
};
priority_queue<PDP> nq;//优先队列保存于跟新距离某个点距离第k大的这些点
struct Tree{//kd树，因为一定是二叉树，所以可以用编号保存树
Point p[Maxn<<2];//树的节点
int son[Maxn<<2];//每个节点的孩子个数，用来判断是否到达根节点
void build (int l, int r, int u = 1, int dep = 0)//建树
{
if(l>r) return;
son[u] = r-l;
son[u<<1] = son[u<<1|1] = -1;
idx = dep%K;//维度划分方式
int mid = (l+r)>>1;//以中间点来划分树
nth_element(po+l,po+mid,po+r+1);//比mid对应第idx维度下的坐标小的都在左边，大的在右边。
p[u] = po[mid];//定义节点的编号
build(l,mid-1,u<<1,dep+1);
build(mid+1,r,u<<1|1,dep+1);
}
void query(Point a, int m, int u = 1, int dep = 0)//查询距离a前m大的数
{
if(son[u]==-1) return ;
PDP nd(0,p[u]);//判断根节点
for(int i = 0; i < K; i++)
nd.dis += pow(nd.p.x[i]-a.x[i]);//计算根节点到节点a的距离
int dim = dep%K, fg = 0;//当前维度和是否需要继续向下判断
int x = u<<1, y = u<<1|1;//左右孩子，每次都是先判断左孩子
if(a.x[dim]>=p[u].x[dim]) swap(x,y);//如果这个点位于根节点的左孩子，那么先找左孩子肯定比较更容易找到解
if(~son[x]) query(a,m,x,dep+1);//如果左孩子的值不等于-1即不空则查询左区间
if(nq.size() < m) nq.push(nd),fg = 1;//如果队列中不足m个元素，则把这个点加入队列
else {
if(nd.dis < nq.top().dis) nq.pop(),nq.push(nd);//如果这个点的距离比当前队列中最大的那个还要小，则替换最大的
if(pow(a.x[dim]-p[u].x[dim]) < nq.top().dis) fg = 1;//如果在这个维度上a距离分界点的距离都要大于队列中m个元素距离a的距离则没有必要再搜索右子树了。相反要搜索右子树，fg = 1;
}
if(~son[y] && fg) query(a,m,y,dep+1);//右子树不空且有必要搜索右子树时候搜索右子树
}
}kd;
void print(Point &a)
{
for(int j = 0; j < K; j++)
printf("%d%c",a.x[j],j==K-1?'\n':' ');
}
double E[Maxn];
int Ecnt,fa[Maxn];
int getfa(int x)
{
if(fa[x]==x) return x;
return fa[x] = getfa(fa[x]);
}
struct Edge{
int u,v;
double cost;
bool operator <(const Edge e) const{
if(cost != e.cost) return cost < e.cost;
else if(u!=e.u) return u<e.u;
else if(v!=e.v) return v<e.v;
return false;
}
}edge[Maxm];//存图，保存所有的边
void add(int u, int v, double cost){
edge[Ecnt].u = u,edge[Ecnt].v = v,edge[Ecnt++].cost = cost;
}
bool cmp(Edge a, Edge b)
{
return a.cost < b.cost;
}
double Kruskal(int n,int m)
{
int u,v,x;
double cost, ans = 0;
sort(edge,edge+m,cmp);
for(u = 0; u < n; u++) fa[u] = u,E[u] = -1;
for(int i = 0; i < m; i++){
u = edge[i].u, v = edge[i].v, cost = edge[i].cost;
if(getfa(u) == getfa(v)) continue;
ans += cost;
E[u] = max(E[u],cost);
E[v] = max(E[v],cost);
fa[fa[u]] = fa[v];
}
return ans;
}//最小生成树
vector<int> ve[Maxn];
void init()
{
Ecnt = 0;
for(int i = 0; i < n; i++) ve[i].clear();
}
inline double dis(Point _A, Point _B)
{
double ret = 0;
for(int i = 0; i < K; i++) ret += pow(_A.x[i]-_B.x[i]);
return sqrt(ret);
}
double result[Maxn];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d %d",&n,&m);
for(int i = 0; i < n; i++){
po[i].id = i;
for(int j = 0; j < K; j++)
scanf("%d",&po[i].x[j]);
}
kd.build(0,n-1);
init();
for(int i = 0; i < n; i++)
{
kd.query(po[i],min(m+1,n));
int ori = po[i].id;
for(int j = 0; !nq.empty();j++){
Point tm = nq.top().p;
nq.pop();
double cost = dis(po[i],tm);
if(ori != tm.id) add(ori,tm.id,cost);
}
}
Kruskal(n,Ecnt);
for(int i = 0; i < n; i++) result[i] = -1;
for(int i = 0; i < n; i++) {
int id = getfa(i);
result[id] = max(result[id],E[i]);
}
sort(result,result+n);
int num = n,t;
for(t = 0; t < n; t++){
if(result[t] <= 0) num--;
else break;
}
printf("%d\n",num);
for(; t<n; t++){
printf("%lf",result[t]);
if(t<n-1) printf(" ");
}
puts("");
}
return 0;
}