关于树状数组的两种最基本的用法

最新推荐文章于 2021-11-14 21:36:26 发布

沛霖

最新推荐文章于 2021-11-14 21:36:26 发布

阅读量290

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/qq_39930039/article/details/78357449

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

首先，介绍一个树状数组的核心——low_bit[maxn]数组

先介绍这个数组怎么算的：

low_bit[i] = i & (-i);

举个例子：

low_bit[1] == 1
low_bit[2] == 2
low_bit[3] == 1
low_bit[4] == 4
low_bit[5] == 1
low_bit[6] == 2
low_bit[7] == 1
low_bit[8] == 8
low_bit[9] == 1
low_bit[10] == 2

关于这个计算本身的意义：

意义有二：

一是在二进制下的意义——可以百度,刚学的时候没有必要了解的特别清楚

二则是将i分解质因数以后2的幂指数（8 = 2 ^3 ---> low_bit[8] == 3 10 = 2 ^ 1 * 5 ^ 1 ---> low_bit[10] == 1）

这个数组有什么用？

额(⊙o⊙)…这个先不着急，慢慢看下去你就明白了。

先去百度盗一张图：（这张比较清楚）

树状数组其实是一个一维数组。。。。（个人习惯，假设这个数组为tree[maxn]）

如上图，tree[1] 为第1个数字的和

tree[2] 为第1个数字到第2个数字的和

tree[3]为第3个数字的和

tree[4]为第1个到第4个数字的和

（由图开始推。。。）

这个奇奇怪怪的定义究竟是怎么回事呢？

其实是这样的 tree[i] = a[i - low_bit[i]]+ .... + a[i];(这步特别关键，大家一定要带回去把1到10算一遍)

为什么要这个奇奇怪怪的定义？

因为这个东西是用来优化方便查找的（上图为单点修改查找区间和）

这里介绍[1， R]的区间和计算方法，程序中有[L， R]的方法（就是用前缀和的思路）

如前十个数的和：

10 = 2 + 8；

sum = (a[1] + ..... + a[8]) + (a[9] + a[10]);

sum = tree[8] + tree[10]

前7个数的和：

7 = 1 + 2 + 4；

sum = (a[1] + ......+ a[4]) + (a[5] + a[6]) + a[7];

sum = tree[4] + tree[6] + tree[7];

找到规律了吗？（现在可以自行脑补代码）

给大家足够的想象空间.....

然后单点加的操作更简单：

如图中的方法就好了（看代码模拟肯定就明白了）

T1：

题目描述

如题，已知一个数列，你需要进行下面两种操作：

1.将某一个数加上x

2.求出某区间每一个数的和

输入输出格式

输入格式：

第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。

第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。

接下来M行每行包含3或4个整数，表示一个操作，具体如下：

操作1：格式：1 x k 含义：将第x个数加上k

操作2：格式：2 x y 含义：输出区间[x,y]内每个数的和

输出格式：

输出包含若干行整数，即为所有操作2的结果。

说明

时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=8，M<=10

对于70%的数据：N<=10000，M<=10000

对于100%的数据：N<=500000，M<=500000

输入输出样例

故输出结果14、16

代码奉上：

#include<cstdio>

using namespace std;

const int maxn = 5e5 + 5;
int n, m;
int a, b, k;
int aa[maxn] = {0};
int tree[maxn] = {0};
int low_bit[maxn];

inline void prepare()
{
	for(int i = 1; i <= n; ++i)
	{
		low_bit[i] = i & (- i);
	}
	for(int i = 1; i <= n; ++i)
	{
		for(int j = i - low_bit[i] + 1; j <= i; ++j)
		{
			tree[i] += aa[j];
		}
	}
}

inline void workk_1()
{
	while(b <= n)
	{
		tree[b] += k;
		b = b + low_bit[b];
	}
}

int sum(int t)
{
	int ret = 0;
	while(t != 0)
	{
		ret += tree[t];
		t = t - low_bit[t];
	}
	return ret;
}

inline void workk_2()
{
	int aaa = sum(b - 1);
	int bbb = sum(k);
	printf("%d\n", bbb - aaa);
}

int main()
{
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; ++i)
		scanf("%d", &aa[i]);
	prepare();
	for(int i = 1; i <= m; ++i)
	{
		scanf("%d%d%d", &a, &b, &k);
		if(a == 1)	workk_1();
		else workk_2();
	}
	return 0;
}

那么怎么区间加单点查询呢？

很简单，既然都提到了类似前缀和的思路，那么稍微改一改：

原数组a[maxn]储存的内容变一下：

a[i] = i 和 i-1 两个数的差

所以。。。

第i个数就是a[1] + .... + a[i];

这样才可以区间加啊，

例子:区间[L， R]加k

操作如下：

a[L] += k;

a[R + 1] -= k;

(傲娇的我拒绝解释，请开动你的小脑瓜233)

T2：

题目描述

如题，已知一个数列，你需要进行下面两种操作：

1.将某区间每一个数数加上x

2.求出某一个数的和

输入输出格式

输入格式：

第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。

第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。

接下来M行每行包含2或4个整数，表示一个操作，具体如下：

操作1：格式：1 x y k 含义：将区间[x,y]内每个数加上k

操作2：格式：2 x 含义：输出第x个数的值

输出格式：

输出包含若干行整数，即为所有操作2的结果。

说明

时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=8，M<=10

对于70%的数据：N<=10000，M<=10000

对于100%的数据：N<=500000，M<=500000

输入输出样例

故输出结果为6、10

所以。。

代码再次奉上：

#include<cstdio>

using namespace std;

const int maxn = 5e5 + 5;
int n, m;
int a, b, c;
int mark;
int aa[maxn] = {0};
int qwe[maxn] = {0};
int tree[maxn] = {0};
int low_bit[maxn];

inline void prepare()
{
	n = 10;
	for(int i = 1; i <= n; ++i)
	{
		low_bit[i] = i & (- i);
	}
	for(int i = 1; i <= n; ++i)
	{
		for(int j = i - low_bit[i] + 1; j <= i; ++j)
		{
			tree[i] += aa[j];
		}
	}
}

inline void workk_1()
{
	scanf("%d%d%d", &a, &b, &c);
	while(a <= n)
	{
		tree[a] += c;
		a = a + low_bit[a];
	}
	b++;
	while(b <= n)
	{
		tree[b] -= c;
		b = b + low_bit[b];
	}
}

int sum(int t)
{
	int ret = 0;
	while(t != 0)
	{
		ret += tree[t];
		t = t - low_bit[t];
	}
	return ret;
}

inline void workk_2()
{
	scanf("%d", &a);
	printf("%d\n", sum(a));
}

int main()
{
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; ++i)
		scanf("%d", &qwe[i]);
	for(int i = 1; i <= n; ++i)
	{
		aa[i] = qwe[i] - qwe[i - 1];
	}
	prepare();
	for(int i = 1; i <= m; ++i)
	{
		scanf("%d", &mark);
		if(mark == 1)	workk_1();
		else 	workk_2();
	}
	return 0;
}

这就是树状数组的最基本用法。

我们可以发现计算机和2有着许多不清不楚的关系。。。

为什么呢？

至少在这个程序中有一个很有用的性质：

2^0 ~ 2^n 可以凑出所有的数

很多问题都可以靠这个解决或者优化（大大减少了你的傻傻的操作）（Eg：倍增LCA）

具体请大家和我一起多想想o