KD-Tree入门

最新推荐文章于 2024-04-28 22:56:18 发布
最新推荐文章于 2024-04-28 22:56:18 发布
阅读量2.5k 收藏
点赞数
分类专栏： KD-Tree 算法学习 文章标签： kd-tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zeyu_King/article/details/46571839
版权

经过这几天研究kd-tree，我可以说kd-tree就是按照基本的思路随便写就可以了吗？

以二维平面为例，在二维平面上有若干点，我们如何建立kd-tree?

第一层以x坐标的中位数将所有点分为两部分，分别放到左右子树上，第二层以y坐标的为中位数再将当前的集合平分，第三层依然以x坐标……如此递归下去。

以查询最近点为例，我们在当前节点上找到查询点应被分在哪一个子树上，优点遍历这个子树，如果在此子树中找到的最有答案小于这个点到分割线的距离，就不需要遍历另一个子树了，据说期望复杂度为O(n^(D-1)/D)，然而我并不知道为什么

三个例题写了三个风格完全不同的代码。。。

１、hdu4347

查找ｋ维空间中距离某个点最近的m个点，距离定义为欧几里得距离距离。

kd-tree的基础题，随便写写就可以了。。。。

#include <queue>
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;
const int Maxn = 100005;
int n,K,Q,m,D,i,root;
int son[Maxn][2];
struct Point
{
  int x[5];
  void read()
  {
    for (int i=0;i<K;i++)
      scanf("%d",&x[i]);
  }
  void print()
  {
    for (int i=0;i<K-1;i++)
      printf("%d ",x[i]);
    printf("%d\n",x[K-1]);
  }
  bool operator <(const Point &a)const
  {
    return x[D] < a.x[D];
  }
} dot[Maxn], P;

typedef pair<int,int> PR;
#define di first
#define id second
priority_queue <PR> heap;
vector <int> ans;

int build(int l,int r,int now){
  if (l>r) return 0;
  D = now;
  int mid = (l+r)>>1;
  nth_element(dot+l,dot+mid,dot+r+1);
  //L[mid] = l; R[mid] = r;
  son[mid][0] = build(l,mid-1,(now+1)%K);
  son[mid][1] = build(mid+1,r,(now+1)%K);
  return mid;
}
#define sqr(x) ((x)*(x))
int Distance(Point P1,Point P2){
  int ret = 0;
  for (int i=0;i<K;i++)
    ret += sqr(P1.x[i]-P2.x[i]);
  return ret;
}

void query(int cur,int now){
  if (cur==0) return;
  PR nd(Distance(dot[cur],P), cur);
  int x = son[cur][0], y = son[cur][1];
  if (dot[cur].x[now]<P.x[now]) swap(x,y);
  query(x,(now+1)%K);
  if (heap.size()<m) heap.push(nd);
  else
  {
    if (nd.di<heap.top().di) heap.pop(), heap.push(nd);
  }
  if ( sqr(dot[cur].x[now]-P.x[now]) <= heap.top().di )
    query(y,(now+1)%K);
}

int main(){
  freopen("hdu4347.in","r",stdin);
  freopen("hdu4347.out","w",stdout);
  while (~scanf("%d%d",&n,&K)){
    for (i=1;i<=n;i++)
      dot[i].read();
    root = build(1,n,0);
    scanf("%d",&Q);
    while (Q--){
      P.read(); scanf("%d",&m);
      printf("the closest %d points are:\n",m);
      query(root, 0);
      while (!heap.empty())
      {
        ans.push_back(heap.top().id);
        heap.pop();
      }
      while (!ans.empty())
      {
        dot[ans.back()].print();
        ans.pop_back();
      }
    }
  }
  return 0;
}

２、bzoj2648 SJY摆棋子

求曼哈顿距离最近点。

看的hzwer的程序，那个calc判断查询点距离那个部分近还是比较精妙的

但是这题暴力插入不要重建就可以过还是比较良心

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
const int Maxn = 1000005;
const int INF = 1e9;
int n,m,D,ans,root;
int son[Maxn][2];
struct Point 
{
  int x[2], mn[2], mx[2];
  void read()
  {
    scanf("%d%d",&x[0],&x[1]);
  }
  bool operator <(const Point &a)const
  {
    return x[D]<a.x[D];
  }
} dot[Maxn], P;

int Dis(Point P0,Point P1)
{
  return abs(P0.x[0]-P1.x[0]) + abs(P0.x[1]-P1.x[1]);
}

void update(int p)
{
  Point L = dot[son[p][0]];
  Point R = dot[son[p][1]];
  for (int i=0;i<2;i++){
    if (son[p][0])
    {
      dot[p].mn[i]=min(dot[p].mn[i], L.mn[i]);
      dot[p].mx[i]=max(dot[p].mx[i], L.mx[i]);
    }
    if (son[p][1])
    {
      dot[p].mn[i]=min(dot[p].mn[i], R.mn[i]);
      dot[p].mx[i]=max(dot[p].mx[i], R.mx[i]);
    }
  }
}

int build(int l,int r,int now)
{
  if (l>r) return 0;
  D = now;
  int mid = (l+r)>>1;
  nth_element(dot+l,dot+mid,dot+r+1);
  for (int i=0;i<2;i++)
    dot[mid].mn[i] = dot[mid].mx[i] = dot[mid].x[i];
  son[mid][0] = build(l,mid-1,now^1);
  son[mid][1] = build(mid+1,r,now^1);
  update(mid);
  return mid;
}

void insert(int p,int now)
{
  if (dot[p].x[now]>P.x[now]){
    if (son[p][0]) insert(son[p][0],now^1);
    else
    {
      son[p][0]=++n;
      for (int i=0;i<2;i++)
        dot[n].x[i] = dot[n].mn[i] = dot[n].mx[i] = P.x[i];
    }
  } else
  {
    if (son[p][1]) insert(son[p][1],now^1);
    else
    {
      son[p][1]=++n;
      for (int i=0;i<2;i++)
        dot[n].x[i] = dot[n].mn[i] = dot[n].mx[i] = P.x[i];
    }
  }
  update(p);
}

int calc(Point Q)
{
  int ret=0;
  for (int i=0;i<2;i++)
  {
    ret+=max(0,Q.mn[i]-P.x[i]);
    ret+=max(0,P.x[i]-Q.mx[i]);
  }
  return ret;
}

void query(int p,int now)
{
  int dl=INF, dr=INF;
  ans=min(ans, Dis(dot[p], P));
  if (son[p][0]) dl=calc(dot[son[p][0]]);
  if (son[p][1]) dr=calc(dot[son[p][1]]);
  if (dl<=dr)
  {
    if (ans>dl) query(son[p][0],now^1);
    if (ans>dr) query(son[p][1],now^1);
  } else
  {
    if (ans>dr) query(son[p][1],now^1);
    if (ans>dl) query(son[p][0],now^1);
  }
}

int main(){
  freopen("2648.in","r",stdin);
  freopen("2648.out","w",stdout);
  scanf("%d%d",&n,&m);
  for (int i=1;i<=n;i++)
    dot[i].read();
  root = build(1,n,0);
  while (m--){
    int type;
    scanf("%d",&type);
    P.read();
    if (type==1) insert(root,0);
    else
    {
      ans = INF;
      query(root, 0);
      printf("%d\n",ans);
    }
  }
  return 0;
}

3、bzoj4066 简单题

出看题目：这不是cdq分治？

然后你会注意到空间只有20M

如果你是卡空间狂魔仍然认为这题可以用cdq水过，你就会发现这题强制在线。。。。

正解是kd-tree！？

对于棋盘上点权的问题可以用kd-tree直接在线维护

不过这个需要重建kd-tree以防止过于整棵树不平衡，可以设一个比例fac，当某棵小子树的大小大于这棵子树的大小的fac倍时，重建整棵子树。

听说有人不重建水过了？

询问不讲大家都懂的。。。。

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
const int Maxn = 200005;
int x1,x2,y1,y2,D;
int n,N,st,ans,rt;
int son[Maxn][2];
int pos[Maxn];
struct Point
{
  int x[2], mn[2], mx[2], w, sum, size;
  void read()
  {
    scanf("%d%d%d",&x[0],&x[1],&w);
    x[0]^=ans; x[1]^=ans; w^=ans;
    for (int i=0;i<2;i++)
      mn[i] = mx[i] = x[i];
    sum = w; size = 1;
  }
  bool operator <(const Point &a)const
  {
    return x[D] < a.x[D];
  }
} dot[Maxn];
const double fac = 0.65;

bool cmp(const int &a,const int &b)
{
  return dot[a].x[D] < dot[b].x[D];
}

void update(int p){
  int L = son[p][0], R = son[p][1];
  dot[p].sum=dot[p].w; dot[p].size=1;
  dot[p].sum += dot[L].sum; dot[p].size += dot[L].size;
  dot[p].sum += dot[R].sum; dot[p].size += dot[R].size;
  for (int i=0;i<2;i++){
    dot[p].mn[i] = dot[p].mx[i] = dot[p].x[i];
    if (L)
    {
      dot[p].mn[i] = min(dot[p].mn[i], dot[L].mn[i]);
      dot[p].mx[i] = max(dot[p].mx[i], dot[L].mx[i]);
    }
    if (R)
    {
      dot[p].mn[i] = min(dot[p].mn[i], dot[R].mn[i]);
      dot[p].mx[i] = max(dot[p].mx[i], dot[R].mx[i]);
    }
  }
}

int build(int l,int r,int now){
  if (l>r) return 0;
  D = now;
  int mid = (l+r)>>1;
  nth_element(pos+l,pos+mid,pos+r+1,cmp);
  son[pos[mid]][0] = build(l,mid-1,now^1);
  son[pos[mid]][1] = build(mid+1,r,now^1);
  update(pos[mid]);
  return pos[mid];
}

void dfs(int p){
  pos[++st] = p;
  if (son[p][0]) dfs(son[p][0]);
  if (son[p][1]) dfs(son[p][1]);
}

int ins(int p,int now){
  if (!p) return N;
  int t = (dot[p].x[now]<=dot[N].x[now]);
  if (dot[son[p][t]].size+1 > (dot[p].size+1)*fac)
  {
    pos[st=1]=N; dfs(p);
    p = build(1,st,now);
  } else
    son[p][t] = ins(son[p][t],now^1), update(p);
  return p;
}

int query(int p,int now){
  if (p==0) return 0;
  if (dot[p].mx[0]<x1||dot[p].mn[0]>x2) return 0;
  if (dot[p].mx[1]<y1||dot[p].mn[1]>y2) return 0;
  if (dot[p].mn[0]>=x1&&dot[p].mx[0]<=x2&&dot[p].mn[1]>=y1&&dot[p].mx[1]<=y2)
    return dot[p].sum;
  int ret = 0;
  if (dot[p].x[0]>=x1&&dot[p].x[0]<=x2&&dot[p].x[1]>=y1&&dot[p].x[1]<=y2)
    ret += dot[p].w;
  if (son[p][0]) ret += query(son[p][0],now^1);
  if (son[p][1]) ret += query(son[p][1],now^1);
  return ret;
}

int main(){
  freopen("4066.in","r",stdin);
  freopen("4066.out","w",stdout);
  scanf("%d",&n);
  ans = 0;
  int type;
  while (~scanf("%d",&type)){
    if (type==1){
      dot[++N].read();
      rt = ins(rt, 0);
    } else
    if (type==2){
      scanf("%d%d",&x1,&y1);
      x1 ^= ans; y1 ^= ans;
      scanf("%d%d",&x2,&y2);
      x2 ^= ans; y2 ^= ans;
      ans = query(rt, 0);
      printf("%d\n",ans);
    } else break;
  }
  return 0;
}


Zeyu_King
关注
专栏目录
kd树（K-dimensional tree）
qq_40692109的博客
10-21 1万+
kd-tree简介 Kd-Tree（K-dimensional tree），是一种高维索引树形数据结构，经常使用于在大规模的高维数据空间进行最近邻查找，比如图像检索和识别中的高维图像特征向量的K近邻查找与匹配（查找与所给数据最接近的k个数）。 kd树结构类似于高维的二叉树，树中存储的是一些K维数据。在一个K维数据集合上构建一棵Kd-Tree代表了对该K维数据集合构成的K维空间的一个划分。 kd-t...
KD - Tree 学习笔记
Recalling_Clouds的博客
01-12 236
（这本是 P4169 的一篇无法提交的题解） 而 KD - Tree 本身在竞赛中的应用就比较少，又几乎不作为正解出现，所以这里只拿一道例题来举例讲解 题意： 给定一个二维点集 S ，每次有两种操作： 操作 1 ： 往点集 S 中加入一个点 操作 2 ： 给定一个点 (x,y)(x, y)(x,y) ，询问该点到点集 S 中每个点曼哈顿距离的最小值 两点 (x1,y1),(x2,y2)(x_1, y_1), (x_2, y_2)(x1​,y1​),(x2​,y2​) 之间的曼哈顿距离定义为： ∣x1−x2
KD Tree
weixin_34041003的博客
11-08 149
Kd-树 其实是K-dimension tree的缩写，是对数据点在k维空间中划分的一种数据结构。其实，Kd-树是一种平衡二叉树。 举一示例： 假设有六个二维数据点 = {（2,3），（5,4），（9,6），（4,7），（8,1），（7,2）}，数据点位于二维空间中。为了能有效的找到最近邻，Kd-树采用分而治之的思想，即将整个空间划分为几个小部分。六个二维数据点生成的Kd-树的图为：  ...
kd-tree
weixin_43384504的博客
06-01 1431
kd-tree 简单理解为一种数据结构（所以点云数据处理中最为核心的问题就是建立离散点间的拓扑关系，实现基于邻域关系的快速查找。） k-d树 （k-dimensional树的简称），是一种分割k维数据空间的数据结构。主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。K-D树是二进制空间分割树的特殊的情况。用来组织表示K维空间中点的几何，是一种带有其他约束的二分查找树，为了达到目的，通...
kd_tree
weixin_41857483的博客
10-13 301
1. kd_tree kd-tree（k-dimensional tree），一种对k维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。 主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。 2. 最邻近搜索 kd_tree树最邻近搜索的过程： ...
KDtree
diebenger6280的博客
04-06 154
KDtree What is KDtree? KDtree(K dimensional tree) 是一个支持多维空间的数据结构，主要是将空间内的点进行区域划分，快速维护有关空间点的操作，如空间的最远（近）点对，区间搜索。KDtree的结构与线段树类似，只是线段树是对一维空间的操作，而KDtree是多维操作的，这也导致了KDtree的灵活性没有线段树高。 树上每个点维护的信息： 两个...
基于KD-Tree实现的近似查询处理AQP问题python源码(课程大作业).zip
01-06
基于KD-Tree实现的近似查询处理AQP问题python源码(课程大作业).zip基于KD-Tree实现的近似查询处理AQP问题python源码(课程大作业).zip基于KD-Tree实现的近似查询处理AQP问题python源码(课程大作业).zip基于KD-Tree...
kd-tree的python实现
Flying Dreams
03-28 4869
本文主要内容 [ kD-tree的C语言实现 ]是多年前写过的一篇kd-tree的博客。当时正在看李航老师的《统计学习方法》一书，看到kNN算法和kd-tree之间的关系，非常有兴趣进行深入了解，所以汇总了一些资料，后面由于实际工作中用不到，就放下了。最近重新翻了翻李老师的这本书，发现现在的理解比以前深了很多，而且这种经典是常看常新的，每多翻一次，就多一分收获。 本文主要内容： ...
KD-Tree的原理及其在KNN中的应用（附Python代码
2401_83946044的博客
04-07 858
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。
KD-Tree的原理及其在KNN中的应用（附Python代码）
最新发布
2401_84584238的博客
04-28 392
nearest_point = tree.search_nn(my_tree, target) # 求最近邻坐标点。my_tree = tree.build_tree(dataset, 0) # 使用数据构建kdtree。make_binary_search_tree(data[:mid]), # 左子树。make_binary_search_tree(data[mid+1:])) # 右子树。target = np.random.rand(1, K)[0] # 目标点坐标。
kdtree,kd-tree
04-15
kdtree源文件。有简单的测试文件。速度还可以，2，3百万个点的数据， 几秒就可创建kdtree。希望有用。 下载的朋友在使用时要注意，代码中有个设定最小搜索距离的地方（默认为1）， 在那个setindex函数里。只有小于这个距离的点才认为是要搜索的。这个距离 的设定有点小麻烦－－－代码里边使用的是这个值的开方。比如你把它设为r， 那实际上搜索的是根号r距离内的点。因为 这个我的程序出过问题，所以一定要 告诉大家。这个可以自己改一下。 另外，那个dist［1，2， 3。。。］返回的数据是实际距离的平方，大家如果使 用它了，就要注意了。 稍微看看代码就明白了。。。 我提交了后代码后不知道怎么下载再改，只能在这里说明了。好运！
KDTree
weixin_33701617的博客
10-25 113
学习链接：http://www.cnblogs.com/eyeszjwang/articles/2429382.html 下面实现的kdtree支持以下操作：(1) 插入一个节点(2) 插入n个节点(3) 查找距离某个给定点距离最小的K个节点。 插入的时候可能会导致树严重不平衡，这个时候会重建某个子树。 1 #include <algorithm> 2 ...
KD-Tree算法
热门推荐
MinerYCC
05-06 1万+
kd树（k-dimensional树的简称），是一种分割k维数据空间的数据结构，主要应用于多维空间关键数据的近邻查找(Nearest Neighbor)和近似最近邻查找(Approximate Nearest Neighbor)。 一、Kd-tree其实KDTree就是二叉查找树（Binary Search Tree，BST）的变种。二叉查找树的性质如下：1）若它的左子树不为空，则左子树上所...
KD-Tree 初学（模板+HDU 4347）
alpc_qleonardo
07-07 2266
        KD_Tree的话，一年半以前，那时候翻我们学校给的模板翻到看了，上面写的"by edward_mj"。这个ID浙大的人应该很熟悉，13-14年连续两年带队打进WF。这里我可以吹一下，edward_mj可是和我同一个高中毕业的哟~当时也问了一下学长，学长说KD树是他写的最溜的一个数据结构之一。        直到这几天我才有时间来学学KD树。所谓KD树，顾名思义k-dimensio...
kd-Tree
会飞的小鸡的博客
07-25 337
kd-Tree主要用于大规模高维数据密集的查找比对的使用场景中，主要是最近邻查找以及近似最近邻查找。 kd-Tree属于二叉查找树BST的一种，二叉查找树： 若它的左子树不为空，则它的左子树节点上的值皆小于它的根节点 若它的右子树不为空，则它的右子树节点上的值均大于它的根节点 它的左右子树也分别是二叉查找树 构造BST： 在现有的数据中选定一个数据作为根节点的存储数值。（尽可能保证左右子树的...
KD-Tree
dwell548560的博客
05-18 470
http://www.cnblogs.com/lysuns/articles/4710712.html
KD tree
Gentleman_ZH
03-11 329
在处理点云数据时，由于数据量比较大，search操作往往非常耗时。因此引入kd-tree。 1.定义 Kd-Tree是从BST(Binary search tree)发展而来，是一种高维索引树形数据结构，常用于大规模高维数据密集的查找比对的使用场景中，主要是最近邻查找(Nearest Neighbor)以及近似最近邻查找(Approximate Nearest Neighbor)。在计算机视觉...
KD-tree
qq_49382338的博客
07-22 136
KD-tree
kd-tree算法详解：从入门到精通
"这篇资源是关于kd-tree的原始论文，主要介绍了kd-tree算法的基本概念、实现细节以及性能分析。论文作者是Andrew WMoore，来自卡内基梅隆大学，并摘自其博士论文《Efficient Memory-based Learning for Robot ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值