K-D Tree

最新推荐文章于 2023-04-18 15:21:41 发布
最新推荐文章于 2023-04-18 15:21:41 发布
阅读量142 收藏
点赞数 1
分类专栏： 数据结构 K-D Tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shejunda/article/details/107890925
版权

K-D Tree

感觉K-D Tree 是将数据组织成易于搜索的结构

剩下的就是暴力搜索和剪枝了

P3769 [CH弱省胡策R2]TATT

先排序一维（目的是当前的点只能从前面的点转移，详见cmp1）

让后按排序完的顺序询问，插入

剪枝：1.当前询问子树的左子树（右子树同）的最长长度maxl<now(当前答案），不进入左子树（右子树）搜索

           2.当前子树的左子树（右子树）某个维度i的最小值minl[i]>p.x[i]（当前点在此维度的值），不进入左（右）子树

           3.对于当前子树，左右 子树maxl谁大先搜谁（这样如果跟新答案，maxl小的另一个子树就符合剪枝1，不用搜了）

#include<bits/stdc++.h>
using namespace std;

const int maxn=5e4+5;
const double alphy=0.725;
int n,top,cnt,now,T,rt,ans,Dim;
struct node{
	int x[4],len;
}p[maxn],q[maxn];
struct Tree{
	int size,lc,rc,maxl;
	int minl[4];
	node p;
}tr[maxn];
int rub[maxn];
int newnode(){
	if(top)return rub[top--];
	return ++T;
}
void update(int k){
	tr[k].size=tr[tr[k].lc].size+tr[tr[k].rc].size+1;
	tr[k].maxl=max(tr[k].p.len,max(tr[tr[k].lc].maxl,tr[tr[k].rc].maxl));
	for(int i=0;i<3;i++){
		tr[k].minl[i]=tr[k].p.x[i];
		if(tr[k].lc)tr[k].minl[i]=min(tr[k].minl[i],tr[tr[k].lc].minl[i]);
		if(tr[k].rc)tr[k].minl[i]=min(tr[k].minl[i],tr[tr[k].rc].minl[i]);
	}
}
bool cmp(node a,node b){
	return a.x[Dim]<b.x[Dim];
}
int build(int l,int r,int dim)
{
	if(l>r)return 0;
	int mid=(l+r)>>1,k=newnode();
	Dim=dim;
	nth_element(p+l,p+mid,p+r+1,cmp);
	tr[k].p=p[mid];
	tr[k].lc=build(l,mid-1,(dim+1)%3);
	tr[k].rc=build(mid+1,r,(dim+1)%3);
	update(k);
	return k;
}
void work(int k){
	if(tr[k].lc)work(tr[k].lc);
	if(tr[k].rc)work(tr[k].rc);
	rub[++top]=k;
	p[++cnt]=tr[k].p;
}
bool bad(int k){return tr[k].size*alphy<tr[tr[k].lc].size||tr[k].size*alphy<tr[tr[k].rc].size;}
void rebuild(int &k,int dim){
	cnt=0;
	work(k);
	k=build(1,cnt,dim);
}
void insert(int &k,node p,int dim)
{
	if(!k){
		k=newnode();
		tr[k].p=p;
		tr[k].lc=tr[k].rc=0;
		update(k);
		return;
	}
	if(p.x[dim]<=tr[k].p.x[dim])insert(tr[k].lc,p,(dim+1)%3);
	else insert(tr[k].rc,p,(dim+1)%3);
	update(k);
	if(bad(k))rebuild(k,dim);
}
bool is_ok(int k,int x[]){
	for(int i=0;i<3;i++){
		if(tr[k].p.x[i]>x[i])return 0;
	}
	return 1;
}
bool is_in(int k,int x[]){
	for(int i=0;i<3;i++){
		if(tr[k].minl[i]>x[i])return 0;
	}
	return 1;
}
void query(int k,int x[])
{
	int d0=1;
	if(is_ok(k,x))d0=tr[k].p.len+1;
	now=max(now,d0);
	if(tr[tr[k].lc].maxl>tr[tr[k].rc].maxl){
		if(tr[k].lc&&tr[tr[k].lc].maxl>=now&&is_in(tr[k].lc,x))query(tr[k].lc,x);
		if(tr[k].rc&&tr[tr[k].rc].maxl>=now&&is_in(tr[k].rc,x))query(tr[k].rc,x);
	}
	else{
		if(tr[k].rc&&tr[tr[k].rc].maxl>=now&&is_in(tr[k].rc,x))query(tr[k].rc,x);
		if(tr[k].lc&&tr[tr[k].lc].maxl>=now&&is_in(tr[k].lc,x))query(tr[k].lc,x);
	}
}

bool cmp1(node a,node b){
	if(a.x[3]==b.x[3]){
		if(a.x[2]==b.x[2]){
			if(a.x[1]==b.x[1]){
				return a.x[0]<b.x[0];
			}
			return a.x[1]<b.x[1];
		}
		return a.x[2]<b.x[2];
	}
	return a.x[3]<b.x[3];
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		for(int j=0;j<4;j++)scanf("%d",&q[i].x[j]);
	sort(q+1,q+1+n,cmp1);
	for(int i=1;i<=n;i++){
		now=1; query(rt,q[i].x);
//		cout<<now<<endl;
		ans=max(ans,now);
		q[i].len=now;
		insert(rt,q[i],0);
	}
	cout<<ans<<endl;
	return 0;	
}

P6247 [SDOI2012]最近最远点对

#include<bits/stdc++.h>
using namespace std;

#define dl double
const int maxn=1e5+5;
const dl inf=1e30;
int n,rt,T,Dim;
struct node{
	dl x[2];
}p[maxn];
struct Tree{
	int size,lc,rc;
	dl maxa[2],mina[2];
	node p;
}tr[maxn];
dl now_max=0,now_min=inf,now;
int newnode(){return ++T;}
void update(int k){
	for(int i=0;i<=1;i++){
		tr[k].mina[i]=tr[k].maxa[i]=tr[k].p.x[i];
		if(tr[k].lc){
			tr[k].mina[i]=min(tr[k].mina[i],tr[tr[k].lc].mina[i]);
			tr[k].maxa[i]=max(tr[k].maxa[i],tr[tr[k].lc].maxa[i]);
		}
		if(tr[k].rc){
			tr[k].mina[i]=min(tr[k].mina[i],tr[tr[k].rc].mina[i]);
			tr[k].maxa[i]=max(tr[k].maxa[i],tr[tr[k].rc].maxa[i]);
		}
	}
}
bool cmp(node a,node b){
	return a.x[Dim]<b.x[Dim];
}
int build(int l,int r,int dim)
{
	if(l>r)return 0;
	int mid=(l+r)>>1,k=newnode();
	Dim=dim;
	nth_element(p+l,p+mid,p+r+1,cmp);
	tr[k].p=p[mid];
	tr[k].lc=build(l,mid-1,dim^1);
	tr[k].rc=build(mid+1,r,dim^1);
	update(k);
	return k;
}
dl pow_me(dl x){return x*x;}
dl get_max(int k,dl x,dl y){
	dl res=0;
	res+=max(pow_me(tr[k].mina[0]-x),pow_me(tr[k].maxa[0]-x));
	res+=max(pow_me(tr[k].mina[1]-y),pow_me(tr[k].maxa[1]-y));
	return res;
}
void query_max(int k,dl x,dl y){
	dl d0=pow_me(tr[k].p.x[0]-x)+pow_me(tr[k].p.x[1]-y),d1,d2;
	now=max(now,d0);
	if(tr[k].lc)d1=get_max(tr[k].lc,x,y);
	if(tr[k].rc)d2=get_max(tr[k].rc,x,y);
	if(d1>d2){
		if(d1>now)query_max(tr[k].lc,x,y);
		if(d2>now)query_max(tr[k].rc,x,y);
	}
	else{
		if(d2>now)query_max(tr[k].rc,x,y);
		if(d1>now)query_max(tr[k].lc,x,y);
	}
}
dl get_min(int k,dl x,dl y){
	dl res=0;
	if(x>tr[k].maxa[0])res+=pow_me(tr[k].maxa[0]-x);
	else if(x<tr[k].mina[0])res+=pow_me(tr[k].mina[0]-x);
	if(y>tr[k].maxa[1])res+=pow_me(tr[k].maxa[1]-y);
	else if(y<tr[k].mina[1])res+=pow_me(tr[k].mina[1]-y);
	return res;
}
void query_min(int k,dl x,dl y){
	dl d0=pow_me(tr[k].p.x[0]-x)+pow_me(tr[k].p.x[1]-y),d1=inf,d2=inf;
	if(d0!=0)now=min(d0,now);
	if(tr[k].lc)d1=get_min(tr[k].lc,x,y);
	if(tr[k].rc)d2=get_min(tr[k].rc,x,y);
	if(d1<d2){
		if(d1<now)query_min(tr[k].lc,x,y);
		if(d2<now)query_min(tr[k].rc,x,y);
	}
	else{
		if(d2<now)query_min(tr[k].rc,x,y);
		if(d1<now)query_min(tr[k].lc,x,y);
	}
}

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)scanf("%lf%lf",&p[i].x[0],&p[i].x[1]);
	rt=build(1,n,0);
	for(int i=1;i<=n;i++)now=0,query_max(rt,p[i].x[0],p[i].x[1]),now_max=max(now_max,now);
	for(int i=1;i<=n;i++)now=inf,query_min(rt,p[i].x[0],p[i].x[1]),now_min=min(now_min,now);
//	for(int i=1;i<=n;i++)cout<<now_min[i]<<' ';cout<<endl;
	printf("%.2lf %.2lf\n",sqrt(now_min),sqrt(now_max));
	return 0;
}

P4357 [CQOI2016]K远点对

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1e5+100;
int n,T,Dim,rt;
struct node{
	int x[2];
}p[maxn];
struct Tree{
	int lc,rc,size;
	int maxa[2],mina[2];
	node p;
}tr[maxn];

bool cmp(node a,node b){
	return a.x[Dim]<b.x[Dim];
}
int newnode(){return ++T;}
void update(int x){
	for(int i=0;i<=1;i++){
		tr[x].mina[i]=tr[x].maxa[i]=tr[x].p.x[i];
		if(tr[x].lc){
			tr[x].mina[i]=min(tr[x].mina[i],tr[tr[x].lc].mina[i]);
			tr[x].maxa[i]=max(tr[x].maxa[i],tr[tr[x].lc].maxa[i]);
		}
		if(tr[x].rc){
			tr[x].mina[i]=min(tr[x].mina[i],tr[tr[x].rc].mina[i]);
			tr[x].maxa[i]=max(tr[x].maxa[i],tr[tr[x].rc].maxa[i]);
		}
	}
}
int build(int l,int r,int dim)
{
	if(l>r)return 0;
	int mid=(l+r)>>1,k=newnode();
	Dim=dim;
	nth_element(p+l,p+mid,p+r+1,cmp);
	tr[k].p=p[mid];
	tr[k].lc=build(l,mid-1,dim^1);
	tr[k].rc=build(mid+1,r,dim^1);
	update(k);
	return k;
}
priority_queue<ll,vector<ll> , greater<ll> >q; 
ll pow_me(int x){return 1ll*x*x;}
ll get_dis(int k,int x,int y){
	ll res=0;
	res+=max(pow_me(tr[k].mina[0]-x),pow_me(tr[k].maxa[0]-x));
	res+=max(pow_me(tr[k].mina[1]-y),pow_me(tr[k].maxa[1]-y));
	return res;
}
void query(int k,int x,int y)
{
	ll d0=pow_me(tr[k].p.x[0]-x)+pow_me(tr[k].p.x[1]-y),d1=0,d2=0;
	if(tr[k].lc)d1=get_dis(tr[k].lc,x,y);
	if(tr[k].rc)d2=get_dis(tr[k].rc,x,y);
	
	if(d0>q.top())q.pop(),q.push(d0);
	if(d1>d2){
		if(d1>q.top())query(tr[k].lc,x,y);
		if(d2>q.top())query(tr[k].rc,x,y);
	}
	else{
		if(d2>q.top())query(tr[k].rc,x,y);
		if(d1>q.top())query(tr[k].lc,x,y);
	}
}

int main()
{
	int K;
	scanf("%d%d",&n,&K);
	for(int i=1;i<=n;i++)scanf("%d%d",&p[i].x[0],&p[i].x[1]);
	rt=build(1,n,0);
	for(int i=K*2;i>0;i--)q.push(0);
	for(int i=1;i<=n;i++)query(rt,p[i].x[0],p[i].x[1]);
	printf("%lld",q.top());
	return 0;
}

学习于：https://www.cnblogs.com/ShuraEye/p/12069524.html

shejunda
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
寻找最远点对
编程资料大全
04-21 617
问题 给定平面上N个点的坐标，找出距离最远的两个点。 分析 类似于“最近点对问题”，这个问题也可以用枚举的方法求解，时间复杂度O(n^2)。 “寻找最近点对”是用到分治策略降低复杂度，而“寻找最远点对”可利用几何性质。注意到：对于平面上有n个点，这一对最远点必然存在于这n个点所构成的一个凸包上（证明略），那么可以排除大量点，如下图所示： 在得到凸包以后，可以只在顶点上面找最远点了。同样，...
K-d Tree & 1NN最近邻
05-07
K-d树（K-dimensional tree）是一种在高维空间中组织和检索数据的数据结构，尤其适用于处理多维数据，如图像像素点、地理位置坐标等。它是由二叉树扩展到多维空间的一种结构，通过将数据分布在一系列分割超平面来...
洛谷 P2498 [SDOI2012]拯救小云公主 解题报告
weixin_30348519的博客
07-12 163
P2498 [SDOI2012]拯救小云公主 题目描述 英雄又即将踏上拯救公主的道路…… 这次的拯救目标是——爱和正义的小云公主。 英雄来到\(boss\)的洞穴门口，他一下子就懵了，因为面前不只是一只\(boss\)，而是上千只\(boss\)。当英雄意识到自己还是等级1的时候，他明白这就是一个不可能完成的任务。 但他不死心，他在想，能不能避开\(boss\)去拯救公主呢，嘻嘻。 \(Boss\...
SDOI2012最近最远点对
qw
12-05 916
[题目描述] 给你n个点,求最近点对和最远点对,n [题解] 计算几何裸题,由于本沙茶不会最近点对的二分算法,加上ws的出题人卡住了随机算法,于是苦B的打了一个2-d树交上去.... 用2-d树做最近点对的应该就只有我这个若b了吧好心酸TAT,幸好没卡2-d树,不然白打了140行的代码啊... 代码量骤增(虽然我不知道二分的代码量怎么样,但这个140行的程序代码量算是很大的了) 这个代
P6247【计算几何】【凸包】【旋转卡壳】【最近最远点对】【分治】[SDOI2012]最近最远点对
peacesir的博客
08-13 136
here 一个nloglogn的求最近点对的分治算法，配一个标准的凸包旋转卡壳求最远距离的算法。 //god with me //#pragma GCC optimize(1) //#pragma GCC optimize(2) //#pragma GCC optimize(3,"Ofast","inline") //#include <bits/stdc++.h> #include <algorithm> #include <iostream> #include &l
K-D Tree（K维空间数据结构）
既然弱小，就只顾变强就是了
03-23 2089
K-D Tree是K临近算法中的一种 k-d 是 k-dimensional 的缩写，也就是k维树，换句话说就是说这个树是维护一个k维元素的树，这个树上的节点有k个分量。一个k维的二叉搜索树就是k-d tree了。 先了解一下K-D Tree的概念 例子（网图） K == 3的K-D Tree模型 首先来看下树的组织原则。将每一个元组按0排序（第一项序号为0，第二项序号为...
K-D Tree原理和应用
QtHalcon
12-16 1577
kd 树（k-dimensional tree）是一个包含空间信息的二项树数据结构，它是用来计算 kNN 的一个非常常用的工具。
k-d Tree算法
weixin_44852067的博客
04-18 2269
本文介绍一种用于高维空间中的快速最近邻和近似最近邻查找技术——Kd- Tree(Kd树)。Kd-Tree，即K-dimensional tree，是一种高维索引树形数据结构，常用于在大规模的高维数据空间进行最近邻查找(Nearest Neighbor)和近似最近邻查找(Approximate Nearest Neighbor)，例如图像检索和识别中的高维图像特征向量的K近邻查找与匹配。Kd树在维度较小时（比如203020、302030K≥100K≥100K≥100。
k-d tree算法原理及实现
YOYO的博客
06-11 1037
k-d tree算法原理及实现 原文：https://leileiluoluo.com/posts/kdtree-algorithm-and-implementation.html k-d tree即k-dimensional tree，常用来作空间划分及近邻搜索，是二叉空间划分树的一个特例。通常，对于维度为(k)，数据点数为(N)的数据集，k-d tree适用于(N\gg2^k)的情形。 1）k-d tree算法原理 k-d tree是每个节点均为k维数值点的二叉树，其...
K-D Tree原理详解
我的blog屋
01-06 1728
一、从线性查找到k-D树 参考博客：https://zhuanlan.zhihu.com/p/45346117 1 线性查找 假设数组A为[0, 6, 3, 8, 7, 4, 11]，有一个元素x，我们要找到数组A中距离x最近的元素，应该如何实现呢？比较直接的想法是用数组A中的每一个元素与x作差，差的绝对值最小的那个元素就是我们要找的元素。假设x = 2，那么用数组A中的所有元素与x作差得到[-2...
K-D Tree 维度空间搜索二叉树
Hello World!
11-07 1747
​K-D树全称为K -Dimension Tree ，其实质是一棵二叉树。大家可能知道二叉搜索树，二叉搜索树是在一维数据里面建立的搜索树，用于更快的查找。这里的K - D树可以看作是推广到多维空间里面时对于点查找的搜索树。但是你可能有疑问，为什么不用二叉搜索树来进行多维里面的查找？因为点是不能直接比较大小的，所以这里的二叉搜索树必须另外建立一种建树规则，就形成了一种特殊的二叉搜索树即K - D 树。
K-D Tree_翁家翌.pdf
09-14
K-D Tree 在信息学竞赛中的应用 K-D Tree 是一种常用的数据结构，它可以高效地对高维空间中的点进行搜索、插入和删除操作。它是一种平衡二叉树，每个节点存储了一个 K 维空间域和一个 K 维的点坐标。 基本用法 K-...
knn.zip_K._k-d tree_kd tree knn_k近邻搜索
09-22
这是一个小而有效的程序来执行的K -近邻搜索算法，此算法利用JIT 理论加速循环，比向量化有效...甚至比kd-tree效果要佳。 K-nearest neighbor search已经广泛应用在科学与工程上，比如模式识别，数据挖掘和信号处理。
K-D tree原理查找.pdf
05-11
主要介绍K-D树的创建过程；创建原理；针对空间区域的碰撞结构做了应用导向
基于k-d tree的邻域搜索
07-16
k-d树（k-dimensional tree）是一种在高维空间中用于数据索引的数据结构，它能够高效地执行多种操作，如范围查询、最近邻搜索等。在这个压缩包中，包含的三个文件kd_buildtree.m、kd_knn.m和linyu.m分别对应于构建k-...
基于Springboot的在线英语阅读平台的设计与实现论文
07-16
传统方式管理信息存在诸多不足，如耗时较长、数据错误率高、错误数据更正困难以及数据检索繁琐费力。因此，通过在计算机上部署在线英语阅读分级平台软件，可以充分发挥其高效的信息处理能力，从而规范信息管理流程，使管理工作更加系统化和程序化。同时，该平台的有效应用还能助力管理人员准确快速地处理信息。 在开发工具的选择上，在线英语阅读分级平台经过慎重考虑，为便于开发实现，选用了IDEA作为开发工具，并采用Mysql作为数据库工具。以此为基础搭建开发环境，实现在线英语阅读分级平台的各项功能，包括管理员对用户和新闻公告的管理。 作为一款基于软件开发技术设计实现的应用系统，在线英语阅读分级平台在信息处理方面表现出色，无论是数据添加、数据维护和统计，还是数据查询等处理需求，该平台都能轻松应对。
关于红外传感器的计数器设计.docx
07-16
传感器
中国航空研究院609研究所考研10个学院，38个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
07-16
中国航空研究院609研究所考研10个学院，38个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
MATLAB基础入门教程 MATLAB使用详解 第8章 函数分析 共10页.pptx
最新发布
07-16
【课程大纲】 第1章 MATLAB7.0安装与卸载 共5页.pptx 第2章 MATLAB7.0用户界面 共19页.pptx 第3章 MATLAB7.0入门 共10页.pptx 第4章 MATLAB7.0的矩阵和数组 共28页.pptx 第5章 MATLAB7.0的数据类型 共20页.pptx 第6章 元胞和构架 共12页.pptx 第7章 矩阵分析 共35页.pptx 第8章 函数分析 共10页.pptx 第9章 数据分析 共19页.pptx 第10章 高级数值计算 共32页.pptx 第11章 符号计算 共35页.pptx 第12章 二维图形 共25页.pptx 第13章 三维图形 共11页.pptx 第14章 图形对象和句柄 共29页.pptx 第15章 MATLAB7.0程序设计 共35页.pptx 第16章 程序调试、优化和出错处理 共14页.pptx 第17章 图形用户界面（GUI） 共22页.pptx 第18章 MATLAB 文件IO操作 共15页.pptx 第19章 MATLAB 7.0编译器 共16页.pptx 第20章 应用程序接口 共19页.pptx 第21章 Notebook的运用 共16页.pptx 第22章 SIMULINK入门 共50页.pptx 第23章 SIMULINK高级技术 共47页.pptx 第24章 图像处理工具箱 共27页.pptx 第25章 信号处理工具箱 共45页.pptx 第26章 小波分析工具箱 共8页.pptx
K-D Tree算法、分治法
05-15
K-D Tree（K-Dimensional Tree）算法是一种基于分治法的数据结构，用于高维空间的搜索和排序。它的基本思想是将多维空间中的点以某种方式分割成更小的子空间，然后在每个子空间中递归地进行搜索。这样可以大大降低搜索的复杂度。 具体来说，K-D Tree算法可以分为以下几步： 1. 选择一个维度，将数据点按照该维度的值进行排序。 2. 找到该维度的中位数，将其作为当前节点，并将数据点分为左右两个子集。 3. 递归地构建左子树和右子树，每次选择一个新的维度进行划分。 4. 最终得到一个K-D Tree。 在搜索时，我们可以从根节点开始，按照一定的规则向下遍历，直到找到目标点或者无法继续向下搜索。具体的规则是： 1. 如果目标点在当前节点的左子树中，则继续向左子树搜索。 2. 如果目标点在当前节点的右子树中，则继续向右子树搜索。 3. 如果目标点和当前节点在选定的维度上的值相等，则说明已经找到目标点。 分治法是一种常见的算法思想，它将一个大规模的问题分解成若干个小规模的子问题，每个子问题独立地求解，然后将这些子问题的解合并起来得到原问题的解。分治法通常包含三个步骤：分解、求解、合并。 具体来说，分治法可以分为以下几步： 1. 分解：将原问题分成若干个子问题，每个子问题规模较小且结构与原问题相同。 2. 求解：递归地求解每个子问题，直到问题规模足够小可以直接求解。 3. 合并：将所有子问题的解合并成原问题的解。 分治法的优点是可以有效地降低算法的时间复杂度。但是它的缺点是需要额外的空间来存储子问题的解，而且分解和合并的过程也需要耗费一定的时间。因此，需要根据实际情况选择合适的算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值