K-D树小结

最新推荐文章于 2021-09-28 10:51:45 发布
最新推荐文章于 2021-09-28 10:51:45 发布
阅读量535 收藏 1
点赞数
分类专栏： K-D树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyf_2002/article/details/76944036
版权

最近几天学了一发K-Dtree，有一点理解。。

首先K-Dtree是一种算法。类似于搜索，但是如果你硬要叫它数据结构也可以。。

K-D树在形态上是一颗二叉排序树，满足左儿子权值小于根节点，根节点权值小于右儿子，由于每个K-D树节点中都有对应的点，那么怎么划分权值就成为了问题。

为了把数据分散的更好，我们可以选择对每一个维度挨个枚举然后进行划分，这时候就要用到std的一个stl了，在algorithm里，nth_element(&a[l],&a[mid],&a[r+1],cmp)，cmp函数要自己写，a是Point结构体的一个数组。

struct Point{
    ll d[2],val;
    inline ll& operator [] (int x){return d[x];}
    inline bool operator < (const Point &a)const{
        return d[now]==a.d[now]?d[now^1]<a.d[now^1]:d[now]<a.d[now];
    }
}a[MAXN];
这份代码里直接重载了<，没有写cmp函数。now是当前划分的维度，在这里划分维度的标准是挨个分，而不是按方差(见其他K-D树讲解)；

如何建树？直接上代码吧。

void build(node *&o,int l,int r,int d=0){
    if(l>r)return;
    now = d;int mid = l+r>>1;
    std::nth_element(&pt[l],&pt[mid],&pt[r+1]);
    o = new node(pt[mid]);
    build(o->ls,l,mid-1,d^1);
    build(o->rs,mid+1,r,d^1);
    o->Maintain();
}
struct node{
    node *ls,*rs;
    Point point;
    ll mn[2],mx[2],sum;

    inline void Update(node *p){
        if(!p)return;
        for(int i=0;i<=1;i++)mn[i]=min(mn[i],p->mn[i]);
        for(int i=0;i<=1;i++)mx[i]=max(mx[i],p->mx[i]);
    }
    
    inline void Maintain(){
        sum = point.val;
        if(ls)Update(ls),sum+=ls->sum;
        if(rs)Update(rs),sum+=rs->sum;
    }
}*root;

然后就是查找了。

维护每个子树所对应的矩形(最大最小x，y坐标。)

然后可以把对应的min_dis()函数当做估价函数，来进行搜索QAQ。

还是直接上代码：

#include <stdio.h>
#include <cstring>
#include <iostream>
#include <queue>
#include <algorithm>
using std::max;
using std::min;
typedef long long ll;
const ll inf = (ll)1e16;
const int MAXN = 100005;
int now,n,m,k;
 
 
template<typename _t>
inline _t read(){
    _t x=0,f=1;
    char ch=getchar();
    for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-f;
    for(;isdigit(ch);ch=getchar())x=x*10+(ch^48);
    return x*f;
}
 
struct Point{
    ll a[3];
    inline bool operator < (const Point & b)const{
        return a[now]<b.a[now]||(a[now]==b.a[now]&&a[now^1]<b.a[now^1]);
    }
    ll &operator [](int x){return a[x];}
}pt[MAXN],cmp;
 
struct res{
    ll dis,id;
    bool operator < (const res & a)const{
        return dis == a.dis? id < a.id : dis > a.dis;
    }
};
std::priority_queue<res>Q;
 
inline ll sqr(ll x){return x*x;}
inline ll dis(Point x,Point y){return sqr(x[0]-y[0])+sqr(x[1]-y[1]);}
 
struct node{
    node *ls,*rs;
    Point point;
    int mn[2],mx[2];
    node(Point &x){
        point = x;
        ls = rs = NULL;
        mn[0]=mx[0]=x[0];
        mn[1]=mx[1]=x[1];
    }
    inline void Maintain(node *x){
        if(x==NULL)return;
        for(int i=0;i<=1;i++)mn[i]=min(mn[i],x->mn[i]);
        for(int i=0;i<=1;i++)mx[i]=max(mx[i],x->mx[i]);
    }
    inline ll calc_dis(){
        ll Ans = 0;
        Ans = max(Ans,dis((Point){mn[0],mn[1]},cmp));
        Ans = max(Ans,dis((Point){mn[0],mx[1]},cmp));
        Ans = max(Ans,dis((Point){mx[0],mn[1]},cmp));
        Ans = max(Ans,dis((Point){mx[0],mx[1]},cmp));
        return Ans;
    }
}*root;
 
void build(node *&o,int l,int r,int d){
    if(l>r)return;
    int mid = l+r>>1;
    now = d;std::nth_element(&pt[l],&pt[mid],&pt[r+1]);
    o = new node(pt[mid]);
    build(o->ls,l,mid-1,d^1);
    build(o->rs,mid+1,r,d^1);
    o->Maintain(o->ls);
    o->Maintain(o->rs);
}
 
inline void Query(node *rt){
    if(rt==NULL)return;
    if(Q.size()==k&&rt->calc_dis()<Q.top().dis)return;
    res ans = (res){dis(rt->point,cmp),rt->point[2]};
    if(Q.size()<k)Q.push(ans);
    else if(ans<Q.top())Q.pop(),Q.push(ans);//这个东西重载了QAQ。。
    ll dis_ls = rt->ls==NULL?inf:rt->ls->calc_dis();
    ll dis_rs = rt->rs==NULL?inf:rt->rs->calc_dis();
    if(dis_ls>dis_rs){
        Query(rt->ls);
        if(dis_rs>=Q.top().dis||Q.size()<k)Query(rt->rs);
    }
    else{
        Query(rt->rs);
        if(dis_ls>=Q.top().dis||Q.size()<k)Query(rt->ls);
    }
}
 
int main(){
    n=read<int>();
    for(int i=1;i<=n;++i)pt[i][0]=read<int>(),pt[i][1]=read<int>(),pt[i][2]=i;
    build(root,1,n,0);
    m=read<int>();
    for(int i=1;i<=m;++i){
        cmp[0]=read<int>();cmp[1]=read<int>();
        k=read<int>();
        while(!Q.empty())Q.pop();
        Query(root);
        printf("%d\n",Q.top().id);
    }
}
这是BZOJ 2626的完整代码。

题目大意：求第k远的点。

那么就维护一个堆，大小为k。。然后就可以了。

BZOJ 1941

求最远和最近的点。

用类似思路就可以了

用估价函数来判断先去哪个儿子。

#include <stdio.h>
#include <cstring>
#include <iostream>
#include <algorithm>
typedef long long ll;
const ll inf = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 500005;
using std::min;
using std::max;
int n,now;
ll Ans_min,Ans_max,Ans=inf;
 
 
template<typename _t>
inline _t read(){
    _t x=0,f=1;
    char ch=getchar();
    for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-f;
    for(;isdigit(ch);ch=getchar())x=x*10+(ch^48);
    return x*f;
}
 
struct Point{
    ll d[2];
    ll& operator [] (const int x){return d[x];}
    inline bool operator != (const Point &b)const{
        return d[0]!=b.d[0]||d[1]!=b.d[1];
    }
    bool operator < (const Point x)const{
        return d[now]<x.d[now]||(d[now]==x.d[now]&&d[now^1]<x.d[now^1]);
    }
}pt[MAXN],cur,cpy[MAXN];
 
inline ll dis(Point a,Point b){return abs(a[0]-b[0])+abs(a[1]-b[1]);} 
 
struct node{
    node *ls,*rs;
    Point point;
    ll mn[2],mx[2];
    node(Point x){
        ls=rs=NULL;
        point = x;
        mn[0]=mx[0]=x[0];
        mn[1]=mx[1]=x[1];
    }
    inline void Maintain(node *x){
        if(x==NULL)return;
        for(int i=0;i<=1;++i)mn[i]=min(mn[i],x->mn[i]);
        for(int i=0;i<=1;++i)mx[i]=max(mx[i],x->mx[i]);
    }
    inline ll min_dis(){
        ll ans = 0;
        ans += max(mn[0]-cur[0],0ll)+max(cur[0]-mx[0],0ll);
        ans += max(mn[1]-cur[1],0ll)+max(cur[1]-mx[1],0ll);
        return ans;
    }
    inline ll max_dis(){
        ll ans = 0;
        ans += max(abs(cur[0]-mn[0]),abs(cur[0]-mx[0]));
        ans += max(abs(cur[1]-mn[1]),abs(cur[1]-mx[1]));
        return ans;
    }
}*root;
 
void build(node *&o,int l,int r,int d=0){
    if(l>r)return;
    int mid = l+r>>1;now=d;
    std::nth_element(&pt[l],&pt[mid],&pt[r+1]);
    o = new node(pt[mid]);
    build(o->ls,l,mid-1,d^1);
    build(o->rs,mid+1,r,d^1);
    o->Maintain(o->ls);
    o->Maintain(o->rs);
    return ;
}
 
void Query_min(node *o){
    if(o==NULL)return;
    if(o->point!=cur)Ans_min=min(Ans_min,dis(cur,o->point));
    ll dis_l = o->ls?o->ls->min_dis():inf;
    ll dis_r = o->rs?o->rs->min_dis():inf;
    if(dis_l<dis_r){
        if(o->ls)Query_min(o->ls);
        if(dis_r<=Ans_min&&o->rs)Query_min(o->rs);
    }
    else{
        if(o->rs)Query_min(o->rs);
        if(dis_l<=Ans_min&&o->ls)Query_min(o->ls);
    }
}
 
void Query_max(node *o){
    if(o==NULL)return;
    if(o->point!=cur)Ans_max=max(Ans_max,dis(cur,o->point));
    ll dis_l = o->ls?o->ls->max_dis():inf;
    ll dis_r = o->rs?o->rs->max_dis():inf;
    if(dis_l>dis_r){
        if(o->ls)Query_max(o->ls);
        if(dis_r>=Ans_max&&o->rs)Query_max(o->rs);
    }
    else{
        if(o->rs)Query_max(o->rs);
        if(dis_l>=Ans_max&&o->ls)Query_max(o->ls);
    }
}
 
inline ll Query_max(Point p){
    Ans_max = -inf;cur = p;
    Query_max(root);
    return Ans_max;
}
 
inline ll Query_min(Point p){
    Ans_min=inf;cur=p;
    Query_min(root);
    return Ans_min;
}
 
int main(){
    n=read<int>();
    for(int i=1;i<=n;i++){
        pt[i][0]=read<int>();
        pt[i][1]=read<int>();
        cpy[i]=pt[i];
    }
    build(root,1,n);
    for(int i=1;i<=n;i++)Ans = min(Query_max(cpy[i])-Query_min(cpy[i]),Ans);
    printf("%lld\n",Ans);
}
BZOJ 4520 和2626基本差不多。对总体维护一个大小为2*k的堆就行了，因为每个点都被算了两遍，所以要2*k。 

#include <stdio.h>
#include <cstring>
#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
typedef long long ll;
const ll inf = (ll)1e16;
const int MAXN = 100005;
int now,n,m,k;
  
  
template<typename _t>
inline _t read(){
    _t x=0,f=1;
    char ch=getchar();
    for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-f;
    for(;isdigit(ch);ch=getchar())x=x*10+(ch^48);
    return x*f;
}
  
struct Point{
    ll a[2];
    inline bool operator < (const Point & b)const{
        return a[now]<b.a[now]||(a[now]==b.a[now]&&a[now^1]<b.a[now^1]);
    }
    ll &operator [](int x){return a[x];}
}pt[MAXN],cmp;
priority_queue<ll,vector<ll> , greater<ll> >Q;
  
inline ll sqr(ll x){return x*x;}
inline ll dis(Point x,Point y){return sqr(x[0]-y[0])+sqr(x[1]-y[1]);}
  
struct node{
    node *ls,*rs;
    Point point;
    int mn[2],mx[2];
    node(Point &x){
        point = x;
        ls = rs = NULL;
        mn[0]=mx[0]=x[0];
        mn[1]=mx[1]=x[1];
    }
    inline void Maintain(node *x){
        if(x==NULL)return;
        for(int i=0;i<=1;i++)mn[i]=min(mn[i],x->mn[i]);
        for(int i=0;i<=1;i++)mx[i]=max(mx[i],x->mx[i]);
    }
    inline ll calc_dis(){
        ll Ans = 0;
        Ans = max(Ans,dis((Point){mn[0],mn[1]},cmp));
        Ans = max(Ans,dis((Point){mn[0],mx[1]},cmp));
        Ans = max(Ans,dis((Point){mx[0],mn[1]},cmp));
        Ans = max(Ans,dis((Point){mx[0],mx[1]},cmp));
        return Ans;
    }
}*root;
  
void build(node *&o,int l,int r,int d){
    if(l>r)return;
    int mid = l+r>>1;
    now = d;nth_element(&pt[l],&pt[mid],&pt[r+1]);
    o = new node(pt[mid]);
    build(o->ls,l,mid-1,d^1);
    build(o->rs,mid+1,r,d^1);
    o->Maintain(o->ls);
    o->Maintain(o->rs);
}
  
inline void Query(node *rt){
    if(rt==NULL)return;
    if(Q.size()==k&&rt->calc_dis()<Q.top())return;
    ll ans = dis(rt->point,cmp);
    if(Q.size()<k)Q.push(ans);
    else if(ans>Q.top())Q.pop(),Q.push(ans);
    ll dis_ls = rt->ls==NULL?inf:rt->ls->calc_dis();
    ll dis_rs = rt->rs==NULL?inf:rt->rs->calc_dis();
    if(dis_ls>dis_rs){
        Query(rt->ls);
        if(dis_rs>=Q.top()||Q.size()<k)Query(rt->rs);
    }
    else{
        Query(rt->rs);
        if(dis_ls>=Q.top()||Q.size()<k)Query(rt->ls);
    }
}
  
int main(){
    n=read<int>();k=read<int>();k<<=1;
    for(int i=1;i<=n;++i)pt[i][0]=read<int>(),pt[i][1]=read<int>();
    build(root,1,n,0);
    for(int i=1;i<=n;i++)cmp=pt[i],Query(root);
    printf("%lld\n",Q.top());
}
其余题目：

bzoj2989  带插入K-D树+替罪羊思想。

bzoj4066 和2989思路差不多。

bzoj2850 巧克力王国








Cooook_
关注
专栏目录
K-d树
27Up的博客
07-31 276
前言 在学习了平衡二叉查找树、红黑树等等之后，今天我们再来学习一个新的数据结构——kd树，kd树是一种分割k维数据空间的数据结构，主要应用于多维空间关键数据的搜索，下面就让我们来详细看看这种算法。 kd树 kd树也是二叉树，是用于分割多维空间的数据结构，所以其每一个节点是一个多维坐标。 先来看看kd树的构造： 在构造1维BST树时，一个1维数据根据其与树的根结点和中间结点进行大小比较的结...
【机器学习笔记】——k近邻（k-nearest neighbor，k-NN）
孙悟充的博客
06-26 1432
目 录 1 k-NN1.1 基本思路1.1.1 距离度量1.1.2 k值的选择1.1.3 决策1.2 基于kd树的k-NN算法1.2.1 构造kd树1.2.2 搜索kd树（基于kd树的k-NN算法）1.2.2.1 基于kd树的最近邻算法1.2.2.2 基于kd树的k-NN算法1.3 k-NN的优缺点1.3.1 优点1.3.2 缺点2 算法实现2.1 原始形式1——自定义二维特征分类数据2.2 原...
关于K-D树的总结
11-30
很好的总结K-d数的一个PPT讲义，建议了解K-D树算法的可以先参考一下这个讲义
K-D树
ACdreamer
03-27 1万+
K-D树，即K-Dimensional Tree，是一种高维索引树型数据结构。常用于大规模高维数据空间的最邻近或者K邻 近查找，例如图像检索中高维图像特征向量的K邻近匹配，对KNN算法的优化等。   Contents      1. K-D树的基本原理    2. K-D树的改进（BBF算法）    3. K-D树的C++实现    4. K-D树的开源框架介绍     1.
k-d树(Kd trees)
qq_39747794的博客
08-31 1万+
前言 在学习了平衡二叉查找树、红黑树等等之后，今天我们再来学习一个新的数据结构——kd树，kd树是一种分割k维数据空间的数据结构，主要应用于多维空间关键数据的搜索，下面就让我们来详细看看这种算法。 kd树 kd树也是二叉树，是用于分割多维空间的数据结构，所以其每一个节点是一个多维坐标。 先来看看kd树的构造： 在构造1维BST树时，一个1维数据根据其与树的根结点和中间结点进行大小比较的结...
KD树
weixin_30783629的博客
12-28 222
k-d树 在计算机科学里，k-d树（k-维树的缩写）是在k维欧几里德空间组织点的数据结构。k-d树可以使用在多种应用场合，如多维键值搜索（例：范围搜寻及最邻近搜索）。k-d树是空间二分树（Binary space partitioning）的一种特殊情况。[1] 可以看到，KD树是基于欧式距离度量的。 简介： k-d树是每个节点都为k维点的二叉树。所有非叶子节点可以视作用一个超平面把空...
机器学习——K-近邻算法（算法原理+分析+实验结果）
weixin_46120403的博客
09-28 1万+
机器学习——K-近邻算法 （一）K-近邻算法概述 （一）K-近邻算法概述 K-近邻法(K-nearest neighbor, K-NN)是1967年由Cover T和Hart P提出的一种基本分类与回归方法。它的工作原理是：存在一个样本数据集合，也称作为训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一个数据与所属分类的对应关系。输入没有标签的新数据后，将新的数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本最相似数据(最近邻)的分类标签。一般...
k-d tree 介绍
dymodi的专栏
07-10 3100
作为存取高维数据的一种数据结构，k-d tree 在静态查询和插入方面的效率还是很高的。本文在这里对 k-d tree 的内容作一些介绍，可能也会结合自己使用 k-d tree 的一些体验作一些点评。其实，k-d tree 是早在1975年的时候由 Stanford 的 Bentley 提出来的。本文的内容也主要来自于他的两篇最原始的文章 [Ben75] 和 [FBF77] 。k-d tree 概述
C语言-B树（B-树）的完整实现
热门推荐
geek_jerome的博客
12-25 2万+
B树的定义 B树是一种平衡的多路查找树。 一颗m阶B树，或为空树，或为满足下列特性的m叉树。 （1）树中每个结点最多含有m棵子树; （2）若根结点不是叶子结点，则至少有两颗子树; （3）除根之外的所有非终端结点至少有[m/2]; （4）每个非终端结点中包含信息：（n,A0,K1,A1,K2,A2,…,Kn,An)。其中 ①Ki（1≤i≤n）为关键字，且关键字按升序排序。 ②指针Ai（
k-d树及knn
08-02
该算法实现了k-d树的建立，以及k邻域的查找，这是用matlab编写的，可以针对三维点云进行k邻域的查找，可以直接被调用。
k-d树
weixin_42613703的博客
07-11 164
https://www.cnblogs.com/earendil/p/8135074.html
k-d tree算法
weixin_30765319的博客
04-02 466
　　　k-d树（k-dimensional树的简称），是一种分割k维数据空间的数据结构。主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。 应用背景 　　SIFT算法中做特征点匹配的时候就会利用到k-d树。而特征点匹配实际上就是一个通过距离函数在高维矢量之间进行相似性检索的问题。针对如何快速而准确地找到查询点的近邻，现在提出了很多高维空间索引结构和近似查询的算法，k-d树就是其中一...
k-d树和基于k-d树的特征点匹配
qq_22305897的博客
04-08 759
k-d树 首先它是一颗树、然后是二叉树，再然后是一颗带权的二叉树。 每个树节点的权拥有多维信息。 建立一套规则对不同维度信息进行左右空间的划分，比如信息为二维坐标(x,y)，我们规定冀奇数层节点的左子树的所有x都要小于当前节点的x，右子树的所有x都要小于当前节点的x。偶数层的左子树的y都要小于当前节点的y，右子树的y都要大于当前节点的y。 基于k-d树的特征点匹配方法 如上图，右边k-d树建...
【基础不牢，地动山摇】K-D树
鱼香土豆丝
07-22 233
为什么在这里介绍最为基础的数据结构“树”呢？ 因为在最近邻算法中树有很重要的作用。首先回顾一下二叉树： 二叉树 二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树常被用于实现二叉查找树和二叉堆。一张图快速理解二叉树： 二叉树的搜索和构造就不再这里介绍了，大家可以参考这篇文章。link K-D树 为什么在上一节介绍二叉树？因为K-D树是每个节点都为k维点的二叉树。...
数据结构习题详解：从双向链表到B-树
深度为h的满m叉树第k层的结点数是m^(k-1)，题目可能误写，但根据一般理解，这里应该是A选项，即mk-1。 8. **关键路径**： 关键路径是在事件结点网络中从源点到汇点的最长路径，它决定项目完成的最早和最晚时间。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值