【算法与实现】线段树&树状数组(下)

最新推荐文章于 2023-04-18 18:56:31 发布
最新推荐文章于 2023-04-18 18:56:31 发布
阅读量747 收藏
点赞数
分类专栏： 算法与实现 文章标签： 算法 数据结构 c++ 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fyfmfof/article/details/39682845
版权

线段树&树状数组(下)

二、树状数组

 

1.结构描述

对于序列a，我们设一个数组C满足下列条件：

①     C[i]=a[i-2^k+1]+ …+a[i]

②     K为i在二进制下末尾0的个数

③     2^k就是i保留最右边的1，其余位全变0

④     i从1开始计算

则有：C即为a的树状数组


对于i，如何求2^k？

2^k=i&(i^(i-1))也就是i&(-i)

通常我们用lowbit(x)表示x对应的2^k，即lowbit(x)=x&(-x)

lowbit(x)实际上就是x的二进制表示形式留下最右边的1，其他位都变成0

则有：C[i]=a[i-lowbit(i)+1]+ … +a[i]，用图表示如下：


树状数组的好处在于能快速求任意区间和a[i]+a[i+1]+ … +a[j]

设sum(k)=a[1]+a[2]+ … +a[k]

则a[i]+a[i+1]+ … +a[j]=sum(j)-sum(i-1)


有了树状数组，sum(k)就能在O(logN)时间内求出，N是a数组元素个数。而且更新一个a的元素所花的时间也是O(logN)的(因为a更新了C也得更新)。根据C的构成规律，可以发现sum(k)可以表示为：



如：sum(6)=C[4]+C[6]

Lowbit(x)实际上就是x的二进制表示形式留下最右边的1，其他位都变成0




如果a[i]更新了，那么以下的几项都需要更新：




初始状态下由a构建树状数组C的时间复杂度是O(N)

应为

C[k]=sum(k)-sum(k-lowbit(k))

 

所以，树状数组适合单个元素经常修改而且还反复要求部分的区间的和的情况。上述问题虽然也可以用线段树解决，但是用树状数组来做，编程效率和程序运行效率都更高（时间复杂度相同，但是树状数组常数小）如果每次要修改的不是单个元素，而是一个区间，那就不能用树状数组了(效率过低）。

 

树状数组时间复杂度总结：

建数组：O(n)

更新：O(logn)

局部求和：O(logn)

 


2.相关案例

POJ 3321 Apple Tree

每个分叉点及末梢可能有苹果（最多1个），每次可以摘掉一个苹果，或有一个苹果新长出来，随时查询某个分叉点往上的子树里，一共有多少个苹果。(分叉点数：100,000 )此题可用树状数组来做，代码如下:

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;

#define MY_MAX 100010

typedef class Link
{
public:
	int num;
	Link *next;
	Link(int a)
	{
		num=a;
		next=NULL;
	}
}*Head;


Head linkList[MY_MAX]={0};
int hash[MY_MAX];
bool isVisted[MY_MAX]={0};
int nFork[MY_MAX]={0};
int nCount=0;

int dfs(Head p,int fork)
{
	int s=1;
	if(isVisted[fork])
		return 0;
	isVisted[fork]=true;
	hash[fork]=++nCount;
	while(p!=NULL)
	{
		s+=dfs(linkList[p->num],p->num);
		p=p->next;
	}
	nFork[fork]=s;
	return s;
}

void InsertLink(int x,int y)
{
	if(linkList[x]==NULL)
		linkList[x]=new Link(y);
	else
	{
		Head link=linkList[x];
		while(link->next!=NULL)
		{
			link=link->next;
		}
		link->next=new Link(y);
	}
}

int Lowbit[MY_MAX];
int sum[MY_MAX]={0};
int A[MY_MAX];
int C[MY_MAX];

int QuerySum(int x)
{
	int Sum=0;
	while(x>0)
	{
		Sum+=C[x];
		x-=Lowbit[x];
	}
	return Sum;
}

void Change(int x,int val)
{
	while(x<=nCount)
	{
		C[x]+=val;
		x+=Lowbit[x];
	}
}

int main()
{
	char c;
	int i,n,a,b,m,t,s=0;
	scanf("%d",&n);
	for(i=1;i<n;i++)
	{
		scanf("%d%d",&a,&b);
		InsertLink(a,b);
		InsertLink(b,a);
	}
	dfs(linkList[1],1);
	for(i=1;i<=n;i++)
	{
		Lowbit[i]=i&(0-i);
		A[i]=1;
	}
	for(i=1;i<=n;i++)
	{
		s+=A[hash[i]];
		sum[i]=s;
		C[i]=sum[i]-sum[i-Lowbit[i]];
	}
	scanf("%d",&m);
	while(m--)
	{
		getchar();
		scanf("%c%d",&c,&t);
		if(c=='C')
		{
			if(A[hash[t]]==0)
			{
				A[hash[t]]=1;
				Change(hash[t],1);
			}
			else
			{
				A[hash[t]]=0;
				Change(hash[t],-1);
			}
		}
		else
			printf("%d\n",QuerySum(hash[t]+nFork[t]-1)-QuerySum(hash[t]-1));
	}
	return 0;
}//树状数组求和速度比线段树要快，但是试用范围比较有限


三、二维线段树&树状数组

 

1.二维树状数组


案例：POJ 1195Mobile phones，题目大意为一个由数字构成的大矩阵，开始是全0,能进行两种操作

①对矩阵里的某个数加上一个整数（可正可负）。

②查询某个子矩阵里所有数字的和。

要求对每次查询，输出结果


二维树状数组解法代码如下：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;

#define MAX 1100

int C[MAX][MAX];
int lowbit[MAX];
int nCount=0;

void Add(int x,int y,int t)
{
	while(x<=nCount)
	{
		int y0=y;
		while(y0<=nCount)
		{
			C[x][y0]+=t;
			y0+=lowbit[y0];
		}
		x+=lowbit[x];
	}
}

int QuerySum(int x,int y)
{
	int s=0;
	while(x>0)
	{
		int y0=y;
		while(y0>0)
		{
			s+=C[x][y0];
			y0-=lowbit[y0];
		}
		x-=lowbit[x];
	}
	return s;
}

int main()
{
	int n,a,b,c,d,i;
	while(scanf("%d",&n)&&n!=3)
	{
		switch(n)
		{
		case 0:
			{
				scanf("%d",&a);
				nCount=a;
				memset(C,0,sizeof(C));
				for(i=1;i<=a;i++)
					lowbit[i]=i&(0-i);
			}
			break;
		case 1:
			{
				scanf("%d%d%d",&a,&b,&c);
				Add(a+1,b+1,c);
			}
			break;
		case 2:
			{
				scanf("%d%d%d%d",&a,&b,&c,&d);
				a++;b++;c++;d++;
				printf("%d\n",QuerySum(c,d)+QuerySum(a-1,b-1)
					-QuerySum(a-1,d)-QuerySum(c,b-1));
			}
		}
	}
	return 0;
}

2.二维线段树



案例：POJ 1195Mobile phones，还是上面的问题，这次用二维线段树(树套树)的方法来解决，代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

#define MY_MAX 1100

//开到4倍存储会溢出
int Tree[MY_MAX * 3][MY_MAX * 3];
int S;

//建树过程省略也是6的不行

void Add_x( int rooty,int rootx, int L, int R, int x ,int a)
{
	Tree[rooty][rootx] += a;
	if( L == R ) 
		return;
	int mid = (L + R )/2;
	if( x <= mid )
		Add_x(rooty,( rootx << 1) + 1, L ,mid, x, a);
	else
		Add_x(rooty,( rootx << 1) + 2, mid + 1,R, x, a);
}

void Add_y(int rooty, int L,int R, int y, int x,int a)
{
	Add_x( rooty,0, 1, S, x,a);
	if( L == R)
		return;
	int mid = (L + R )/2;
	if( y <= mid ) 
		Add_y( ( rooty << 1) + 1, L, mid,y, x, a);
	else
		Add_y( ( rooty << 1) + 2, mid+1, R, y, x, a);
}

int QuerySum_x(int rooty, int rootx, int L, int R ,int x1,int x2)
{
	if( L == x1 && R == x2)
		return Tree[rooty][rootx];
	int mid = ( L + R ) /2 ;
	if( x2 <= mid ) 
		return QuerySum_x( rooty, (rootx << 1) + 1, 
		L, mid,x1,x2);
	else if( x1 > mid )
		return QuerySum_x( rooty, (rootx << 1) + 2, 
		mid+1,R, x1,x2);
	else
		return QuerySum_x( rooty,(rootx << 1) + 1,
		L, mid ,x1,mid) +
		QuerySum_x( rooty,(rootx << 1) + 2,
		mid + 1, R, mid + 1,x2);
}

int QuerySum_y(int rooty, int L, int R ,int y1, int y2, int x1,int x2)
{
	if( L == y1 && R == y2 )
		return QuerySum_x(rooty,0,1,S,x1,x2);
	int mid = ( L + R ) /2;
	if( y2 <= mid ) 
		return QuerySum_y( (rooty << 1) + 1, L,
		mid ,y1,y2,x1,x2);
	if( y1 > mid )
		return QuerySum_y( (rooty << 1) + 2, 
		mid + 1,R, y1,y2,x1,x2);
	else
		return QuerySum_y( (rooty << 1) + 1, L, 
		mid ,y1,mid ,x1,x2) +
		QuerySum_y( (rooty << 1) + 2, 
		mid + 1, R, mid + 1,y2 ,x1,x2);
}

int main()
{
	int cmd; int x,y,a,l,b,r,t;    int Sum = 0;
	while( true) {
		scanf("%d",&cmd);
		switch( cmd) {
		case 0:
			scanf("%d",& S);
			memset( Tree,0,sizeof(Tree));
			break;
		case 1:
			scanf("%d%d%d",&x ,&y,&a);
			Add_y(0, 1,S, y + 1, x + 1, a);
			break;
		case 2:
			scanf("%d%d%d%d",&l , &b, &r,&t);
			l ++; b++; r ++; t ++;
			printf("%d\n",QuerySum_y(0,1,S,b,t,l,r));
			break;
		case 3:
			return 0;
		}
	}
}
在上面的代码中我们可以看出建树的过程是可以省略的，直接以数组的形式进行相关数据的存储然后进行先关操作，但这样是有一定条件的，就个人观点有以下两个条件：

①不能超过存储上限，因为此方法不适用与指针操作，所以存储单元最大要开至4倍大小。

②如果需要再线段树建树过程中完成某些特殊操作则不适用。



3.实战例题

POJ 2155 Matrix大意是N * N 的矩阵，每个元素要么是0，要么是1，开始全0不断进行两种操作：

①C x1 y1 x2 y2表示要将左上角为(x1,y1),右下角为(x2,y2)的子矩阵里的全部元素都取反（0变1，1变0）(1<=x1<=x2<=n,1<=y1<=y2<=n)。

②Q x y查询(x,y)处元素的值。


个人AC代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

#define MY_MAX 1010

int Tree[MY_MAX * 3][MY_MAX * 3];
int S;

void Add_x(int rooty,int rootx, int L, int R, int x1 ,int x2)
{
	if(L==x1&&R==x2)
	{
		Tree[rooty][rootx]++;
		return;
	}
	int mid = (L + R )>>1;
	if( x2 <= mid ) 
		Add_x( rooty, ( rootx << 1) + 1, L, mid, x1, x2);
	else if( x1 > mid )
		Add_x( rooty, ( rootx << 1) + 2, mid+1, R, x1, x2);
	else
	{
		Add_x( rooty, ( rootx << 1) + 1, L, mid, x1, mid);
		Add_x( rooty, ( rootx << 1) + 2, mid+1, R, mid+1, x2);
	}
}

void Add_y(int rooty, int L,int R, int x1, int y1, int x2, int y2)
{
	if(L==y1&&R==y2)
	{
		Add_x( rooty, 0, 1, S, x1, x2);
		return;
	}
	int mid = (L + R )>>1;
	if( y2 <= mid ) 
		Add_y( ( rooty << 1) + 1, L, mid, x1, y1, x2, y2);
	else if( y1 > mid )
		Add_y( ( rooty << 1) + 2, mid+1, R, x1, y1, x2, y2);
	else
	{
		Add_y( ( rooty << 1) + 1, L, mid, x1, y1, x2, mid);
		Add_y( ( rooty << 1) + 2, mid+1, R, x1, mid+1, x2, y2);
	}
}

int Query_x(int rooty,int rootx,int L,int R, int x)
{
	int ans=0;
	ans+=Tree[rooty][rootx];
	if(L==R)
		return ans;
	int mid=(L+R)>>1;
	if(x<=mid)
		ans+=Query_x(rooty,(rootx<<1)+1,L,mid,x);
	else
		ans+=Query_x(rooty,(rootx<<1)+2,mid+1,R,x);
	return ans;
}

int Query_y(int rooty, int L,int R, int x, int y)
{
	int ans=0;
	ans+=Query_x(rooty,0,1,S,x);
	if(L==R)
		return ans;
	int mid=(L+R)>>1;
	if(y<=mid)
		ans+=Query_y((rooty<<1)+1,L,mid,x,y);
	else
		ans+=Query_y((rooty<<1)+2,mid+1,R,x,y);
	return ans;
}

int main()
{
	char cc;
	int n,s,m,a,b,c,d;
	scanf("%d",&n);
	while(n--)
	{
		scanf("%d%d",&s,&m);
		memset(Tree,0,sizeof(Tree));
		S=s;
		while(m--)
		{
			getchar();
			scanf("%c",&cc);
			if(cc=='C')
			{
				scanf("%d%d%d%d",&a,&b,&c,&d);
				Add_y(0,1,S,a,b,c,d);
			}
			else
			{
				scanf("%d%d",&a,&b);
				printf("%d\n",Query_y(0,1,S,a,b)&1);
			}
		}
		puts("");
	}
	return 0;
}

在讨论区发现一个代码个人觉得很优秀就贴过来学习一下啦，不是本人写的但很值得学习一下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;
#define lson l , m , rt << 1 
#define rson m + 1 , r , rt << 1 | 1

bool seg[4010][4010];
int n,m,T,ans;

void buildy(int i,int l,int r,int rt)
{
	seg[i][rt] = 0;
	if(l == r) return ;
	int m = (l + r) >> 1;
	buildy(i,lson);
	buildy(i,rson);
}

void buildx(int l,int r,int rt)
{
	buildy(rt,1,n,1);
	if(l == r) return ;
	int m = (l + r) >> 1;
	buildx(lson);
	buildx(rson);
}
void updatey(int i,int L,int R,int l,int r,int rt)
{
	if(L <= l && r <= R)
	{
		seg[i][rt]^= 1;
		return ;
	}
	int m = (l + r) >> 1;
	if(m >= L)
	updatey(i,L,R,lson);
	if(m < R)
	updatey(i,L,R,rson);	
}

void updatex(int L,int R,int y1,int y2,int l,int r,int rt)
{
	if(L <= l && r <= R)
	{
		updatey(rt,y1,y2,1,n,1);
		return ;
	}
	int m = (l + r) >> 1;
	if(L <= m) updatex(L,R,y1,y2,lson);
	if(R > m)  updatex(L,R,y1,y2,rson);
}

void queryy(int i,int y,int l,int r,int rt)
{
	ans^= seg[i][rt];
	if(l == r)
	return ; 
	int m = (l + r) >> 1;
	if(y <= m) queryy(i,y,lson);
	else  queryy(i,y,rson);
}

void queryx(int x,int y,int l,int r,int rt)
{
	queryy(rt,y,1,n,1);
	if(l == r)
	return ;
	int m = (l + r) >> 1;
	if(x <= m) queryx(x,y,lson);
	else queryx(x,y,rson);
}

int main()
{
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d",&n,&m);
		buildx(1,n,1);
		for(int i = 0 ; i < m ; i++)
		{
			char s[2];
			scanf("%s",s);
			if(s[0] == 'C')
			{
				int x1,x2,y1,y2;
				scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
				updatex(x1,x2,y1,y2,1,n,1);
			}
			else
			{
				ans = 0;
				int x,y;
				scanf("%d%d",&x,&y);
				queryx(x,y,1,n,1);
				printf("%d\n",ans);
			}
		}
		if(T)
		printf("\n");
	}
	return 0;
}
在上面的代码中可以看到线段树的维护和查询或者建树是的区间判断是可以又3个分支的判断简化为2个if进行依次判断的，而且这份代码中位运算的运用很不错，Mark了。




注：以上总结部分类容来自于北京大学ACM暑期课程资料，总结只是为了方便自己查阅&和大家交流=.=

本文固定链接：http://blog.csdn.net/fyfmfof/article/details/39682845

F_Guardian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树与树状数组学习总结——线段树
LiuKairui的博客
07-03 2684
线段树 什么是线段树 先说一下什么是线段树吧 大家都知道，初中课本中对于线的定义： 点动成线 那么就是说一条线段可以分成若干个点，再想想我们最常用的一维数组，构成数组的是一个个的变量，如果把变量看成一个个点，那么数组就是一条线了！ 而线段树，就是一棵由线段构成的二叉树，每个结点都代表一条线段 [a,b]（也就是我们前面说的一串变量）。非叶子的结点所对应的线段都有两个子结点，左儿...
算法学习——树状数组和线段树
ivhs的博客
08-13 255
目录1.动态求连续区间和题目输入格式输出格式数据范围输入样例：输出样例：分析 1.动态求连续区间和 题目 给定 n 个数组成的一个数列，规定有两种操作，一是修改某个元素，二是求子数列 [a,b] 的连续和。 输入格式 第一行包含两个整数 n 和 m，分别表示数的个数和操作次数。 第二行包含 n 个整数，表示完整数列。 接下来 m 行，每行包含三个整数 k,a,b （k=0，表示求子数列[a,b]的和；k=1，表示第 a 个数加 b）。 数列从 1 开始计数。 输出格式 输出若干行数字，表示 k=0 时，对应
线段树和树状数组
t_zht的博客
12-28 4520
一、线段树和树状数组的区别 线段树可以在O(log(N))时间复杂度内寻找区间极值和区间和，线段树的创建时间复杂度为O(log(N))，空间复杂度为O(>=2n-1)；树状数组可以在O(log(N))的时间复杂度内计算区间极值和区间和，树状数组的创建时间复杂度为O(Nlog(N))，空间复杂度为O(N)。线段树求解的区间是任意的，越界也无所谓，但是树状数组求解的区间必须是从1开始的合法区间。 二、线段树 　　线段树是一种二叉搜索树，什么叫做二叉搜索树，首先满足二叉树，每个结点度小于等于二，即每个
树状数组和线段树
jinzhao1993的博客
09-11 1830
树状数组的概念树状数组(binary indexed tree)，是一种设计新颖的数组结构，它能够高效地获取数组中连续n个数的和。概括说，树状数组通常用于解决以下问题：数组{a}中的元素可能不断地被修改，怎样才能快速地获取连续几个数的和？树状数组的基本操作传统数组(共n个元素)的元素修改和连续元素求和的复杂度分别为O(1)和O(n)。树状数组通过将线性结构转换成伪树状结构（线性结构只能逐个扫描元素，
树状数组与线段树的应用
m0_63925226的博客
04-18 557
分析：根据输入方式，可以把二维变为一维，可以把样例模拟一下，（把4，5纵向压倒第一层，也就是最下边这一层）每次输入星星时，根据x数组，把该星星之前的星星都加上就行，这样就可以把问题转化为求前缀和，又因为该题需要一边输入星星，一边求·该星星的值，所以不能用朴素的求前缀和问题，朴素前缀和问题时间复杂度时O(n)的，所以需要树状数组来求。图上有的点表示只有这个点的值，比如奇数都只表示自己的点，因为奇数的二进制最后一位都是1，偶数表示若干个点的和，比如8表示5~8的和。
C++代码实例 - 线段树+树状数组.zip
最新发布
06-08
与线段树不同，树状数组基于数组而非树形结构，它利用前缀和的性质，通过位操作快速计算区间和。每个数组元素存储了以该位置为右端点的所有前缀和的增量。插入和查询操作同样能在O(log n)的时间内完成。相比于线段树...
树状数组&线段树.pptx
07-28
树状数组和线段树都是在数据结构与算法领域中非常重要的工具，它们在处理动态区间信息时提供了高效的解决方案，广泛应用于各种在线算法和数据处理问题中。虽然它们的实现原理有所不同，但在许多实际应用中都能找到...
线段树与树状数组专题讲解
07-31
线段树和树状数组是两种在计算机科学和算法设计中常见的数据结构，它们主要用于高效地处理区间查询和更新操作。这两种数据结构在解决动态规划、最值查询、区间求和等问题时尤其有用。 线段树（Segment Tree）： 1....
线段树和树状数组入门介绍
08-11
不同于线段树，树状数组利用位运算，将数组元素的索引转换为其在二进制表示下的最后一个非零位的权重，从而实现快速的区间求和。树状数组的主要优点是实现简单，代码量小，同样具有O(logn)的查询和更新时间复杂度。...
线段树与树状数组及其在不同场合的使用
11-24
线段树 树状数组 首先讲解了线段树，然后讲解树状数组，最后比较了树状数组和线段树的用法。
树状数组与线段树
醉等佳人归
03-20 526
lowbit运算 lowbit(x) = x & (-x) 求能整除x的最大2的幂次的数。如6求出来是2。 树状数组需要解决的应用 先来看一个问题： 给出一个整数序列A，元素个数为N，接下来查询K次，每次查询将给出一个正整数x，求前x个整数之和 正常方法应该使用离线查询，即定义一个sum数组，sum[i]为前i个元素之和，直接查询sum[i]就行了了 【一般对一个操作多次使用就考虑能...
线段树 & 树状数组
weixin_44806108的博客
06-13 570
线段树 & 树状数组
线段树&树状数组总结篇
MissZhou要努力
05-12 1796
1、 入门题：hdu1166敌兵布阵 单点更新区间求和 线段树： using namespace std; struct node { int l,r,sum; }num[maxn*4]; int m[maxn]; char s[10]; int t,n,a,b; void build(int root,int l,int r) { num[root].l=l;
线段树和树状数组的认识与总结
CSDN_Coder_T的博客
08-21 1264
线段树（Segment Tree）和树状数组（Binary Indexed Tree）具有相似是结构特点，都是以二叉树作为基础进行数据运算，都是擅长处理区间上的数，不同的是线段树的每个节点维护的是对应区间的最小值，所以善于处理区间上的最小值，而树状数组的节点维护的是对应区间的数的和，所以更善于处理区间和。 线段树的主要操作为2种：1、给定s和t，求其区间上的最小值；2、给定i和x，把ai的值改成
建树算法详解：线段树与树状数组的矩形求交优化
本文档主要介绍了建树算法中的线段树，这是一种数据结构，用于解决矩形求交问题。线段树是一种空间效率很高的数据结构，特别适用于处理区间查询和更新操作，比如在二维平面上查找两个矩形是否相交。以下是对文档内容...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值