划分树

最新推荐文章于 2024-03-05 10:03:14 发布
最新推荐文章于 2024-03-05 10:03:14 发布
阅读量1.1w 收藏 12
点赞数 4
分类专栏： 线段树及数据结构 文章标签： build query struct tree 存储 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shiqi_614/article/details/8041390
版权

划分树，从网上看到的代码的风格主要有两种。

下面的介绍直接是从网上找的看的懂的贴了份过来，其中有些修改。

划分树的定义

         划分树定义为，它的每一个节点保存区间[lft,rht]所有元素，元素顺序与原数组（输入）相同，但是，两个子树的元素为该节点所有元素排序后(rht-lft+1)/2个进入左子树，其余的到右子树，同时维护一个num域，num[i]表示lft->i这个点有多少个进入了左子树。

 

划分树的Sample

 

   如果由下而上看这个图，我们就会发现它和归并排序的（归并树）的过程很类似，或者说正好相反。归并树是由下而上的排序，而它确实是由上而下的排序（观察’4’的运动轨迹，我们可以猜到，划分树的排序也是一种稳定的排序方法，这里不是说明的重点，不予证明），但这正是它可以用来解决第k大元素的理由所在。（具体的理由，写完再补）

l  划分树的存储结构（采用层次存储结构（由下而上，由左到右，每层两个孩子，见上图））

constint N=1e5+5;
int sorted[N];            //对原来集合中的元素排序后的值
struct node
{
         int valu[N];       //val记录第k层当前位置元素的值
         int num[N];                //num记录元素所在区间的当前位置之前进入左孩子的个数
         LL sum[N];        //sum记录比当前元素小的元素的和
}t[20];

l  划分树的建立build

划分树的建立和普通的二叉树的建立过程差不多，仍然采取中序的过程（先根节点，然后左右孩子）。

树的建立相对比较简单，我们依据的是已经排好序的位置进行建树，所以先用快排将原集合还序。要维护每个节点的num域。
版本一：

void build(int lft,int rht,int ind)
{
	if(lft==rht) return;
	int mid=lft+(rht-lft)>>1;
	int isame=mid-lft+1,same=0;
	/* isame用来标记和中间值val_mid相等的，且分到左孩子的数的个数 
	   初始时，假定当前区间[lft,rht]有mid-lft+1个和valu_mid相等。
	   先踢掉中间值小的，剩下的就是要插入到左边的
	 */
	for(int i=lft;i<=rht;i++)
		if(t[ind].valu[i]<sorted[mid]) isame--;
	int ln=lft,rn=mid+1;
	for(int i=lft;i<=rht;i++)
	{
		if(i==lft)		//初始一个子树
		{
			t[p].num[i]=0;
			t[p].sum[i]=0;
		}
		else 			//初始区间下一个节点
		{
			t[p].num[i]=t[p].num[i-1];
			t[p].sum[i]=t[p].sum[i-1];
		}
		/* 如果大于，肯定进入右孩子，否则判断是否还有相等的应该进入左孩子的，
		   没有，直接进入右孩子，否则进入左孩子，同时更新节点的sum域和num域
		 */
		if(t[p].val[i]<sorted[mid])
		{
			t[p].num[i]++;
			t[p].sum[i]+=t[p].valu[i];
			t[p+1].valu[ln++]=t[p].valu[i];
		}
		else if(t[p].valu[i]>sorted[mid])
			t[p+1].valu[rn++]=t[p].valu[i];
		else 
		{
			if(same<isame)
			{
				same++;
				t[p].num[i]++;
				t[p].sum[i]+=t[p].valu[i];
				t[p+1].valu[ln++]=t[p].valu[i];
			}
			else 
			{
				t[p+1].valu[rn++]=t[p].valu[i];
			}
		}
	}
	build(lft,mid,ind+1);
	build(mid+1,rht,ind+1);
}
可以看出在版本一里，每个区间的起点的num[ind][lft]和sum[ind][lft]都会被赋值为0。另一种方式在建立这棵树的时候，并没有这么做，而是在前面的基础上继续。也就是说只有将num[ind][0]和sum[ind][0]赋值为0。另外这个版本里我将排序后的数组是order而不是sorted

版本二：

void build(int lft,int rht,int ind)
{
	if(lft==rht) return;
	int mid=MID(lft,rht);
	int same=mid-lft+1,ln=lft,rn=mid+1;
	for(int i=lft;i<=rht;i++)
		if(valu[ind][i]<order[mid]) same--;
	for(int i=lft;i<=rht;i++)
	{
		int flag=0;
		if((valu[ind][i]<order[mid])||valu[ind][i]==order[mid]&&same>0)
		{
			flag=1;
			valu[ind+1][ln++]=valu[ind][i];
			if(valu[ind][i]==order[mid]) same--;
			lsum[ind][i]=lsum[ind][i-1]+valu[ind][i];
		}
		else
		{
			lsum[ind][i]=lsum[ind][i-1];
			valu[ind+1][rn++]=valu[ind][i];
		}
		toLft[ind][i]=toLft[ind][i-1]+flag;
	}
	build(lft,mid,ind+1);
	build(mid+1,rht,ind+1);
}

l  划分树的查找

在区间[a,b]上查找第k大的元素，同时返回它的位置和区间小于[a,b]的所有数的和。

1.      如果t[p].num[b]-t[p].num[a-1]>=k，即，进入左孩子的个数已经超过k个，那么就往左孩子里面查找，同时更新[a,b]=>[lft+t[p].num[a-1]，lft+t[p].num[b]-1]

2.      如果t[p].num[b]-t[p].num[a-1]<k，即，进入p的左孩子的个数小于k个，那么就要往右孩子查找第k-s(s表示进入左孩子的个数)个元素。同时更新sum域，因而这样求出的sum只是严格小于在[a,b]区间中第k大的数的和。

详细过程见代码和注释：
/*在区间[a,b]上查找第k大元素，同时sum返回区间[a,b]中小于第k大元素的和*/ 

int query(int a,int b,int k,int p,int lft,int rht)
{
	if(lft==rht) return t[p].valu[a];
	/*到达叶子结点就找到该元素，返回
	S 记录区间[a,b]中进入左孩子的元素的个数
	SS 记录区间[lft,a-1]中进入左孩子的元素的个数
	SSS 记录区间[a,b]中小于第k大的元素的值和
	B2 表示[lft,a-1]中分到右孩子的个数
	BB 表示[a,b]中分到右孩子的个数
*/
	int s,ss,b2,bb,mid=lft+(rht-lft)/2;
	double sss=0;
	if(a==lft)//端点重合的情况，单独考虑
	{
		s = t[p].num[b]; 
		ss = 0; 
		sss = t[p].sum[b];
	}
	else 
	{
		s = t[p].num[b] - t[p].num[a-1];
		ss = t[p].num[a-1]; 
		sss = t[p].sum[b] - t[p].sum[a-1];
	}
	if(s>=k)	//进入左孩子，同时更新区间端点值。
	{
		a = lft + ss;// 
		b = lft + ss + s - 1; 
		return query(a, b, k, p+1, lft, mid);
	}
	else 
	{
		bb = a - lft - ss;
		b2 = b - a - 1 - s; 
		a = mid + bb + 1; 
		b = mid + bb + b2; 
		sum += sss;
		return query(a,b,k-s,p+1,mid+1,rht);
	}
}
版本二： 

int query(int st,int ed,int k,int lft,int rht,int ind)
{
	if(lft==rht) return valu[ind][lft];
	/*
	  	lx表示从lft到st-1这段区间内有多少个数进入左子树
		ly表示从st到ed这段区间内有多少个数进入左子树
		rx表示从lft到st-1这段区间内有多少个数进入右子树
		ry表示从st到ed这段区间内有多少个数进入右子树
	 */
	int mid=MID(lft,rht);
	int lx=toLft[ind][st-1]-toLft[ind][lft-1];
	int ly=toLft[ind][ed]-toLft[ind][st-1];
	int rx=st-1-lft+1-lx;
	int ry=ed-st+1-ly;
	if(ly>=k) return query(lft+lx,lft+lx+ly-1,k,lft,mid,ind+1);
	else
	{
		isum+=lsum[ind][ed]-lsum[ind][st-1];
		st=mid+1+rx;
		ed=mid+1+rx+ry-1;
		return query(st,ed,k-ly,mid+1,rht,ind+1);
	}
}


下面给出POJ  2104 K-th Number的两种风格的代码。

风格一：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define MID(a,b) (a+((b-a)>>1))
const int N=1e5+5;
struct node
{
	int valu[N],num[N];
};
struct P_Tree
{
	int n,order[N];
	node t[20];
	void init(int len)
	{
		n=len;
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&order[i]);
			t[0].valu[i]=order[i];
		}
		sort(order+1,order+1+n);
		build(1,n,0);
	}
	void build(int lft,int rht,int ind)
	{
	    //cout<<lft<<" "<<rht<<endl;
	    if(lft==rht) return;
		int mid=MID(lft,rht);
		int lsame=mid-lft+1,same=0,ln=lft,rn=mid+1;
		for(int i=lft;i<=rht;i++)
			if(t[ind].valu[i]<order[mid]) lsame--;
		for(int i=lft;i<=rht;i++)
		{
			if(i==lft) t[ind].num[i]=0;
			else t[ind].num[i]+=t[ind].num[i-1];

			if(t[ind].valu[i]<order[mid])
				t[ind].num[i]++,t[ind+1].valu[ln++]=t[ind].valu[i];
			else if(t[ind].valu[i]>order[mid])
				t[ind+1].valu[rn++]=t[ind].valu[i];
			else
			{
				same++;
				if(lsame>=same)
					t[ind].num[i]++,t[ind+1].valu[ln++]=t[ind].valu[i];
				else t[ind+1].valu[rn++]=t[ind].valu[i];
			}
		}
		build(lft,mid,ind+1);
		build(mid+1,rht,ind+1);
	}
	int query(int st,int ed,int k,int lft,int rht,int ind)
	{
		if(lft==rht) return t[ind].valu[lft];
		int lx,ly,rx,ry,mid=MID(lft,rht);
		if(st==lft) lx=0,ly=t[ind].num[ed];
		else lx=t[ind].num[st-1],ly=t[ind].num[ed]-t[ind].num[st-1];
		if(ly>=k)
		{
			st=lft+lx;
			ed=lft+lx+ly-1;
			return query(st,ed,k,lft,mid,ind+1);
		}
		else
		{
			rx=st-1-lft+1-lx;
			ry=ed-st+1-ly;
			st=mid+1+rx;
			ed=mid+1+rx+ry-1;
			return query(st,ed,k-ly,mid+1,rht,ind+1);
		}
	}
}tree;
int main()
{
	int n,m;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		tree.init(n);
		for(int i=0;i<m;i++)
		{
			int a,b,c;
			scanf("%d%d%d",&a,&b,&c);
			int res=tree.query(a,b,c,1,n,0);
			printf("%d\n",res);
		}
	}
	return 0;
}

风格二： 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define MID(a,b) (a+((b-a)>>1))
typedef long long LL;
const int N=1e5+5;
struct P_Tree
{
	int n,order[N];
	int valu[20][N],num[20][N];
	LL sum[N],lsum[20][N],isum;
	void init(int len)
	{
		n=len;	sum[0]=0;
		for(int i=0;i<20;i++) valu[i][0]=0,num[i][0]=0,lsum[i][0]=0;
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&order[i]);
			valu[0][i]=order[i];
			sum[i]=sum[i-1]+order[i];
		}
		sort(order+1,order+1+n);
		build(1,n,0);
	}
	void build(int lft,int rht,int ind)
	{
		if(lft==rht) return;

		int mid=MID(lft,rht);
		int same=mid-lft+1,ln=lft,rn=mid+1;
		for(int i=lft;i<=rht;i++)
			if(valu[ind][i]<order[mid]) same--;
		for(int i=lft;i<=rht;i++)
		{
			int flag=0;
			if((valu[ind][i]<order[mid])||(valu[ind][i]==order[mid]&&same))
			{
				flag=1;
				valu[ind+1][ln++]=valu[ind][i];
				lsum[ind][i]=lsum[ind][i-1]+valu[ind][i];
				if(valu[ind][i]==order[mid]) same--;
			}
			else 
			{
				valu[ind+1][rn++]=valu[ind][i];
				lsum[ind][i]=lsum[ind][i-1];
			}
			num[ind][i]=num[ind][i-1]+flag;
		}
		build(lft,mid,ind+1);
		build(mid+1,rht,ind+1);
	}
	int query(int st,int ed,int k,int lft,int rht,int ind)
	{
		if(lft==rht) return valu[ind][lft];

		int mid=MID(lft,rht);
		int lx=num[ind][st-1]-num[ind][lft-1];
		int ly=num[ind][ed]-num[ind][st-1];
		int rx=st-1-lft+1-lx;
		int ry=ed-st+1-ly;
		if(ly>=k) return query(lft+lx,lft+lx+ly-1,k,lft,mid,ind+1);
		else 
		{
			isum+=lsum[ind][ed]-lsum[ind][st-1];
			st=mid+1+rx;
			ed=mid+1+rx+ry-1;
			return query(st,ed,k-ly,mid+1,rht,ind+1);
		}
	}
}tree;
int main()
{
	int n,m;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		tree.init(n);
		for(int i=0;i<m;i++)
		{
			int a,b,c;
			scanf("%d%d%d",&a,&b,&c);
			int res=tree.query(a,b,c,1,n,0);
			printf("%d\n",res);
		}
	}
	return 0;
}




shiqi_614
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
树的分治
Insistor
06-14 209
我们先随意指定一个根rt，将这棵树转化成有根树 不难发现树上的路径分为两类，经过根节点rt的路径和包含于rt的某棵子树里(不经过rt)的 对于前者， 我们用dis[u]dis[u]表示结点uu到根节点rtrt的路径长度， 则u到v的路径长即为dis[u]+dis[v]dis[u]+dis[v] 对于后者， 既然uu到vv的路径包含在rtrt的某个子树内， 那么我们就找到这棵子树的根，再对他...
树分治
slark_的博客
07-16 1050
什么是分治算法： 分治算法的思想是将一个规模为N的问题分解为K个规模的较小的子问题，这些子问题相互独立且与原问题性质相同。求出这些问题的解后再将这些子问题的解合并，就可以得到原问题的解。例如快速排序和归并排序。 所谓树分治，就是在树形结构上的一种分治问题，主要操作是去除原本树中的某些对象，使得原树被分解成若干个互不相交的部分，由此可以解决许多以路径为询问对象的问题。 树分治分为以下两种...
数据结构-划分树 详解
HeartFireY的博客
06-03 835
划分树是一种用于解决区间第KK大的数据结构。相比于主席树，其常数、理解难度都较低。但划分树是紧贴"区间第KK大"定义的基于排序的数据结构，在解决此类问题上具有优异的性质，而对于其他问题则体现出局限性。 划分树定义为，它的每一个节点保存区间[lft,rht][lft,rht]所有元素，元素顺序与原数组（输入）相同，但是，两个子树的元素为该节点所有元素排序后 个进入左子树，其余的到右子树，
划分树--详解
Akatsuki
04-21 1414
看了一些博客，感觉有些博客对建树写的挺好，但是对于查询区间却一笔带过。在看懂了之后决定自己写一篇，加深自己的理解，也希望对正在学习划分树的人能够有所帮助。 如有错误，敬请大佬指出。 进入正题： 有这样一类题目，求的是区间内的第k大数。 划分树的定义就是对整体的区间进行划分，把相对于原来序列中较小的值放在左子树，较大的放在右子树，最后按照它的性质进行查询以此找到要查询的区间里的第k大数。 ...
划分树总结
qq_31267769的博客
08-16 221
一、理解 划分树，字面意思是将一列数按照一定规则划分出来形成一个树形的数据结构，而树形的数据结构特点就是查询快，时间复杂度在log级。 二、通俗定义 划分树就是将n个数按一定顺序，逐层划分，形成一个树状结构，但不改变每个数之间的相对位置。 例如： 将一列数按照从小到大的顺序划分，小的一半进入当前节点的左子节点，大的一半进入当前节点的右子节点，但在每个节点内每个数相对原序列的位置不变。...
分段树算法 （leetcode 307 python）
Z685455的博客
12-26 353
题目：给定一个整数数组 nums，求出数组从索引i到j(i≤j) 范围内元素的总和，包含i, j两点。 update(i, val)函数可以通过将下标为i的数值更新为val，从而对数列进行修改。 示例: Given nums = [1, 3, 5] sumRange(0, 2) -> 9 update(1, 2) sumRange...
数的划分1
08-08
标题中的"数的划分1"指的是数学中的一种问题，它涉及到将一个正整数分成若干个正整数的和。这种问题在计算机科学和算法设计中具有重要意义，因为它经常出现在组合优化、动态规划和递归算法等场景下。在描述中，我们...
关于图的符号边划分数 (2009年)
05-19
在符号边控制基础上,提出了符号边划分数概念,并研究了符号边划分数的一些性质,得到了圈Cn和星图 K1,r的符号边划分数。
整数划分，并输出结果
12-13
整数划分，并输出相应结果，注释完整，可以运行，C/C++
划分树模板
04-01
划分树模板
BSP(二叉空间划分树).pdf
08-15
非常详细的BSP树生成过程的图形描述.
划分树算法总结
02-26
划分树讲解。但是文中的代码有些地方有笔误，但是基本想法都是正确的。
数的划分2
08-08
标题“数的划分2”指的是一个算法问题，其核心是探讨如何将一个整数n划分为k个非空且互不相同的子集。这个问题属于组合数学和计算机算法设计的范畴，尤其是在动态规划或回溯搜索等领域有应用。下面将详细阐述这个...
关于划分数P(n)的Cohen不等式的再改进 (1998年)
05-11
本文进一步改进了关于划分数P(u)的Cohen不等式。得到新的结果： P(u)
划分树·详解·模板
wishcxz_acm
01-30 557
用划分树来解决选定区间内的第K大值，其实也就两步！一步是建树，另一步则是查询。      先说我对建树的理解吧！     建树的过程很简单：两步就OK了！    第一步：找到序列的中位数，把大于中位数的扔到中位数的左边，小于中位数的扔到数的右边。这样整个序列就被分成了两个区间。    第二步：对每个子区间，也分别执行第一步操作，直到序列中只有一个元素为止。    可以
数据结构和算法--分段树
最新发布
03-05 315
分段树主要应用于一个数组或序列中，用于快速查询和更新指定区间内的某个特定属性，如区间和、区间最大值、区间最小值等。每个节点代表一个区间，并且这个区间是其左右子节点区间的合并。
ZOJ - 4045District Division dfs划分子树
weixin_30873847的博客
03-12 122
ZOJ - 4045District Division 　　题目大意：给你n个节点的树，然后让你划分这棵数使得，每一块都恰好k个节点并且两两间是连通的，也就是划分成n/k个连通集，如果可以输出YES，并输出对应的划分，否则输出NO 　　　一开始觉得是树形dp，但不知道如何下手，看大佬的做法才恍然大悟，其实就是找子树大小刚好是k的节点，刚让它作为这一分块的根节点，它的父节点就不再记录它的子树大小...
高级数据结构：优先队列、图、前缀树、分段树以及树状数组详解
weixin_30859423的博客
07-05 423
优秀的算法往往取决于你采用哪种数据结构，除了常规数据结构，日常更多也会遇到高级的数据结构，实现要比那些常用的数据结构要复杂得多，这些高级的数据结构能够让你在处理一些复杂问题的过程中多拥有一把利器。同时，掌握好它们的性质以及所适用的场合，在分析问题的时候回归本质，很多题目都能迎刃而解了。 这篇文章将重点介绍几种高级的数据结构，它们是：优先队列、图、前缀树、分段树以及树状数组。 一、...
数据结构之线段树(Segment Tree)
WSYW126的博客
04-15 858
线段树的概念 线段树(Segment Tree)也是一棵树，只不过元素的值代表一个区间。 常用区间的统计操作，比如一个区间的最大值(max)，最小值(min)，和(sum)等等。 线段树是一种平衡二叉搜索树(完全二叉树)，它将一个线段区间划分成一些单元区间。对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]，...
梅尔划分数和滤波器个数不是一样的吗
06-08
梅尔划分数和滤波器个数是两个不同的参数。梅尔划分数是将频率轴按照Mel划分的个数，用于将频谱图映射到Mel频率轴上。而滤波器个数是用于将Mel频率轴上的信号进行滤波，提取其中的特征。 在MFCC的计算中，通常通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值