树状数组学习笔记

最新推荐文章于 2023-04-20 09:15:13 发布

置顶 VictoryCzt

最新推荐文章于 2023-04-20 09:15:13 发布

阅读量538

点赞数 4

文章标签：树状数组

本文链接：https://blog.csdn.net/VictoryCzt/article/details/84728443

版权

一个轻量级的数据结构-树状数组

对于数据结构来说，树状数组的大多数功能，用线段树，甚至平衡树之类的都可以实现；但是由于树状数组十分好写且常数巨小，所以在有些卡常题里面，和时间紧张的时候还是一个非常不错的选择，但是树状数组的功能比较局限，这里稍微讲一下原理和一些功能及其实现。

Tips. 文中所说的 $l o g$ 均为 $log_2$

树状数组或者二叉索引树也称作 $Binary\ Indexed\ Tree$ ，又叫做 $F e n w i c k$ 树（ $F e n w i c k$ 树这个名字，我第一次在lrj的蓝书上看见还以为是什么新奇玩意，结果是树状数组-_-||）。

树状数组主要维护的是一个前缀的东西（比如前缀和，前缀异或和，前缀最值等）；而对于暴力的维护这个东西，每次是变量所有元素，复杂度最坏达到 $O(n^2)$ ；而树状数组就是在暴力上进行一个优化，将其下标按照二进制来分层维护。

下面就从一个简单的例子，维护一个数列的单点修改和查询区间和，来讲解：

对于一个长度为 $9$ 的数列 $[5, 2, 1, 8, 9, 3, 4, 6, 2]$ ，我们先将其下标从 $1\sim 9$ 标号，然后构建树状数组。

树状数组开始也是一个线性的数组，如下图：

然后我们可以把一些位置抽出来，使其不再只表示自身的值，而表示前 $2^k$ 个位置的和，但是这个 $2^k$ 如何定呢？总不能乱定吧，所以这里我们使用原数组下标的二进制的最末尾的 $1$ 所代表的值来定义 $2^k$ ，如下图：

然后我们来看，如何快速的来进行修改与查询。

对于修改一个位置的值，我们只需将其变化加到包含它的位置上即可，根据包含关系，我们可以将其建成一棵树，如下图：

但是我们不能真的将树建出来，不仅空间变大，时间常数也会变大，代码复杂度变大，还不如打线段树（不过将树建出来似乎可以对其进行可持久化？XD.）。

我们来看，假如对于第一个位置的数加上 $3$ ，我们就会修改下面的 $1, 2, 4, 8$ 位置上的值，也就是树上的 $1\rightarrow 8$ 这条路径，而将其下标变成二进制来看，就是 $0001, 0010, 0100, 1000$ ，每次对于下标都加上了这个位置的 $2^k$ 的值，所以我们在访问修改的时候不用建出树来，直接用二进制的规律在数组上跳即可，比如再看将第三个位置上的数加上 $2$ ，会修改 $3, 4, 8$ 这几个节点，再来看下表二进制的变换: $0011, 0100, 1000$ ，发现 $1000=0100+0100(2^2),0100=0011+0001(2^0)$ ，所以根据这个规律就可以不用建树啦!

修改如下图，橙色为第一个加 $3$ ，绿色为第三个加 $2$ (两次操作互不影响)：

那么对于区间求和，加入求 $l\sim r$ 的和，因为树状数组维护的前缀和，所以我们可以将其转化为 $sum(1\sim r)-sum(1\sim l-1)$ 来计算，同样的对于一个前缀和，假如为 $1\sim 5$ 的和，我们同样只要将其包含的节点的值加上即可，我们来看前 $5$ 个的和，就是树上 $5$ 号节点的值加上 $4$ 号节点的值，而下标是 $0101, 0100$ ，同样的我们发现 $0100=0101-0001(2^0)$ ，所以对于一个前缀和，我们加上的是它的最后一个下标，每次减去自己位置的 $2^k$ 的直到为 $0$ 为止的这些位置的和，所以还是不用建树，直接在数组上跳即可。

而对于如何求得一个下标的 $2^k$ ，根据 $2^k$ 在前面的定义，我们可以使用一个函数 $l o w b i t (x)$ ，这个函数表示求 $x$ 数的二进制下最末尾的 $1$ 所代表的值，例如
$lowbit(9)=lowbit(1001)=0001=2^0\\ lowbit(6)=lowbit(0110)=0010=2^1$
但是这个函数总不能暴力实现去找吧，如果暴力的话这个函数的复杂度就变成了 $l o g n$ 了，我们需要更快的。

我们来看对于 $9$ ，它的二进制为 $00001001$ （假设这里有8位），而对 $- 9$ 它的二进制为 $11110111$ （最高位表示正负，也就是开始有个 $2^7$ ，然后在加上剩下的位的正数值， $2^7+2^6+2^5+2^4+2^2+2^1+2^0=-9$ ）,我们发现它和 $9$ 与起来（也就是进行and运算）后就为 $00000001$ ，也就是它的最末尾的 $1$ ，所以我们的 $l o w b i t$ 函数就可以 $O (1)$ 的实现啦!

代码：

int lowbit(a){return a&(-a);}

那么树状数组的基本原理我们就懂了（还不懂的话~~去从头再看一遍~~自己在纸上模拟一下就懂了。）

代码实现非常简单了。

int n;//数组长度
int bit_tree[n];
void add(int a,int b){
	for(int i=a;i<=n;i+=lowbit(i)){
		bit_tree[i]+=b;
	}
}
int query_pre_sum(int a){
	int sum=0;
	for(int i=a;i>0;i-=lowbit(i)){
		sum+=bit_tree[i];
	}
	return sum;
}
int query_area(int l,int r){
	return query_pre_sum(r)-query_pre_sum(l-1);
}

复杂度分析：空间显然是 $O (n)$ 的，而每次单点修改，由于一个数字最多加 $l o g n$ 次就会达到上界，所以复杂度为 $l o g n$ ；而区间查询，就是两次前缀查询，而一个数字同样最多减 $l o g n$ 次，那么区间查询的复杂度就是 $2 l o g n$ ，所以对于长度为 $n$ 的，操作为 $m$ 个的，总的复杂度为 $(n + m) l o g n$ （开始建立树状数组有 $n l o g n$ 的复杂度）。

其实有个 $O (n)$ 的建树状数组的方式，也就是预先处理一个最开始的前缀和，然后扫一遍，每次用 $l o w b i t$ 求一个位置是前多少个的和，然后用处理的前缀和算出来即可，复杂度为 $O (n)$ ，空间多一个 $O (n)$ 。

代码大概如下：

int n;
int val[n],sum[n],bit_tree[n];

void build(){
	sum[0]=0;
	for(int i=1;i<=n;i++){
		sum[i]=sum[i-1]+val[i];
		int len=lowbit(i);
		bit_tree[i]=sum[i]-sum[i-len];
	}
}

注意事项：

如果数组的下标从 $0$ 开始，由于 $l o w b i t (0) = 0$ ，所以会陷入死循环，所以我们可以将整个数组向后平移一位，变成下标从 $1$ 开始即可。
循环判断时不要直接打for(int i=a;i;i-=lowbit(i))，最好打成for(int i=a;i>0;i-=lowbit(i))，因为有些时候，下标出错了，变成负数，那么同样会陷入死循环。

树状数组当然不会只有这么一个操作，有了上面的理论基础，我们可以来看看一些更高级的操作了。

一维树状数组

~~后面当然还有二维的树状数组~~

单点修改，区间查询

上面原理解释的样例就讲了。

区间修改，单点查询

由于维护的前缀和，所以我们使用差分，就可以一个点的值转换为前缀查询，而区间修改就变成了两个单点修改了。此时，这里用树状数组维护的数组的位置上的值表示的是（假设 $v a l [i]$ 为原来的 $i$ 的单点值） $v a l [i] - v a l [i - 1] (v a l [0] = 0)$ ，代码如下：

int n;
int bit_tree[n];
void add(int a,int b){
	for(int i=a;i<=n;i+=lowbit(i)){
		bit_tree[i]+=b;
	}
}//这里每次修改的其实是一个后缀
void add_area(int l,int r,int v){
	add(l,v);add(r+1,-v);//差分后的修改方式，由于只会影响l~r,所以将r后的影响要消除
}
int query_pos(int a){
	int ans=0;
	for(int i=a;i>0;i-=lowbit(i)){
		ans+=bit_tree[i];
	}
	return ans;
}

区间修改，区间查询

对于区间修改操作，我们同样采用差分实现，但是对于区间查询就不能直接求得了。

所以，这里我们令一个位置上的值 $pos_i=\sum_{j=1}^i val_j$ ，这里的 $val_j$ 为前面所说的差分后的数组，然后区间查询，我们同样转换为两个前缀和相减，那么对于一个前缀和的值就是 $pre_i=\sum_{j=1}^ipos_i$ ，将其做如下变换：

$pre_i=\sum_{j=1}^i\sum_{k=1}^jval_k$

容易发现，其中每个 $val_k$ 被加了 $i - k + 1$ 次，所以又可以转化为:

$pre_i=\sum_{j=1}^ival_j\times(i-j+1)\\ pre_i=(i+1)\times\sum_{j=1}^ival_j-\sum_{j=1}^ival_j\times j$

所以我们维护两个树状数组，一个维护 $val_i$ ，一个维护 $val_i\times i$ ，查询就是前一个的前缀和乘以 $i + 1$ 再减去后一个的前缀和了。

代码如下：

loj 132
#include<cstdio>
#include<cstring>
#include<algorithm>
#define lowbit(a) ((a)&(-(a)))
#define ll long long
using namespace std;
const int M=1e6+10;
int n,m,x;
ll bit1[M],bit2[M];//val[i],val[i]*i
void add(int a,ll b){
	ll t=a;
	for(;a<=n;a+=lowbit(a)){
		bit1[a]+=b;bit2[a]+=b*t;
	}
}
ll query(int a){
	ll t1=0,t2=0,ls=a;
	for(;a;a-=lowbit(a)){
		t1+=bit1[a];
		t2+=bit2[a];
	}
	t1*=(ls+1);
	return t1-t2;
}
ll range_query(int l,int r){
	return query(r)-query(l-1);
}
void range_add(int l,int r,ll v){
	add(l,v);add(r+1,-v);
}
int l,r,opt;
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		scanf("%d",&x);
		range_add(i,i,x);
	}
	while(m--){
		scanf("%d%d%d",&opt,&l,&r);
		if(opt==1){
			scanf("%d",&x);
			range_add(l,r,x);
		}else{
			printf("%lld\n",range_query(l,r));
		}
	}
	return 0;
}

单点修改，区间最值查询

其实树状数组还可以做这个，原理差不多，从维护 $2^k$ 的前缀和变成前缀最值了，但是由于区间最值不能转换成前缀最值来算，所以稍微复杂一点，复杂度也变成 $log^2n$ 。

代码如下：

区间最大
int max_area(int l,int r){
    int ans=0;
    while(l<=r){
        ans=max(ans,val[r]);r--;//每次往后跳一个
        for(;r-lowbit(r)>=l;r-=lowbit(r)) ans=max(ans,maxv[r]);//看r最多跳到哪里，而不超过l
    }
    return ans;
}
int change_pos(int p,int a){
    val[p]=a;
    for(int i=p;i<=n;i+=lowbit(i)){
        maxv[i]=val[i];//修改的时候重新计算值
        for(int j=1;j<lowbit(i);j<<=1) maxv[i]=max(maxv[i],maxv[i-j]);
    }
}
void init(int p){
     for(int i=p;i<=n;i+=lowbit(i)) maxv[i]=max(maxv[i],val[p]);//初始化一个位置的值可以这样写。
}

题目

对于模板题，luogu的线段树的一个可以来练练，然后loj上130~132有非常全的板子。

二维树状数组

~~肯定还有三维的啦，不过这里不详细讲~~

暴力

对于一个 $n\times m$ 的矩阵，我们维护它的矩阵前缀和。暴力的做法就是对于每一行开一个一维树状数组，随便怎么暴力算吧，一次操作的复杂度最坏为 $O (n l o g m)$ ，但是既然一维的可以做到 $l o g n$ ，那么二维的可不可以做到 $l o g n l o g m$ 呢？当然可以。

单点修改，区间查询

首先，空间是优化不到 $O (n)$ 的，只能是 $O (n m)$ 。

同样的我们维护一维的前缀，对于一维的前缀我们再维护一个前缀，也就是 $b i t t r e e [i] [j]$ 表示左上角 $(0,0)\sim(i,j)$ 右下角的矩阵的和，单点修改的时候就是类似于一维的修改，只不过区间求和依然转换为前缀求和，但是计算方式要复杂一点，求一个区间的和 $(x_1,y_1)\sim (x_2,y_2)$ ，如果是二维上的话，就转换为如下图的方式计算：

用 $p r e [i] [j]$ 表示 $(0,0)\sim(i,j)$ 矩阵的和，那么 $(x_1,y_1)\sim(x_2,y_2)$ 计算方式如下:
$sum=pre[x_2][y_2]-pre[x_1-1][y_2]-pre[x_2][y_1-1]+pre[x_1-1][y_1-1]$

蓝色部分多减了一次所以要加回来。

区间修改，单点查询

和一维同理，换成差分数组， $d [i] [j] = v a l [i] [j] - v a l [i - 1] [j] - v a l [i] [j - 1] + v a l [i - 1] [j - 1]$ 即可，维护这个数组的前缀和，单点查询便是这个点的前缀和，区间修改就变成那四个点 $x_1-1,y_1-1),(x_1-1,y_2),(x_2,y_1-1),(x_2,y_2)$ 分别加上 $v, - v, - v, v$ （ $v$ 为要在这个区间加上的值）即可。

区间修改，区间查询

同样，转换为差分数组，求前缀的前缀，推一波式子：

我们令 $d_{i,j}$ 为前面的那个差分数组，那么一个单点的值 $val_{i,j}=\sum_{x=1}^i\sum_{y=1}^jd_{x,y}$ ，前缀和就是 $sum_{x,y}=\sum_{i=1}^x\sum_{j=1}^yval_{x,y}$ ，那么展开如下：

$sum_{x,y}=\sum_{i=1}^x\sum_{j=1}^y\sum_{k=1}^i\sum_{h=1}^jd_{h,k}$

通过观察推导可以发现，一个 $d_{i,j}$ 被加了 $(x-i+1)\times(y-j+1)$ 次，然后同理得到：
$sum_{x,y}=\sum_{i=1}^x\sum_{j=1}^yd_{i,j}\times(x-i+1)\times(y-j+1)\\ sum_{x,y}=(x+1)\times(y+1)\times\sum_{i=1}^x\sum_{j=1}^yd_{i,j}-(y+1)\sum_{i=1}^x\sum_{j=1}^yd_{i,j}\times i-(x+1)\sum_{i=1}^x\sum_{j=1}^yd_{i,j}\times j+\sum_{i=1}^x\sum_{j=1}^yd_{i,j}\times i\times j$

所以和一维一样，我们维护四个二维树状数组，分别是 $d_{i,j},d_{i,j}\times i,d_{i,j}\times j,d_{i,j}\times i\times j$ 即可。

代码如下：

模板题-上帝造题的七分钟

#include<cstdio>
#include<cstring>
#include<algorithm>
#define lowbit(i) (i&(-i))
using namespace std;
const int M=2050;
int n,m;
struct bittree{
    int bit[M][M];
    bittree(){memset(bit,0,sizeof(bit));}
    void add(int a,int b,int v){
        for(;a<=n;a+=lowbit(a))
        for(int j=b;j<=m;j+=lowbit(j))
        bit[a][j]+=v;
    }
    int query(int a,int b){
        int ans=0;
        for(;a;a-=lowbit(a))
        for(int j=b;j;j-=lowbit(j))
        ans+=bit[a][j];
        return ans;
    }
}bt,bti,btj,btij;
int t1,t2,t3,t4;
void update(int a,int b,int v){
    bt.add(a,b,v);
    bti.add(a,b,v*a);
    btj.add(a,b,v*b);
    btij.add(a,b,v*a*b);
}
int getans(int a,int b)
{return bt.query(a,b)*(a*b+a+b+1)-bti.query(a,b)*(b+1)-btj.query(a,b)*(a+1)+btij.query(a,b);}
void add(int a,int b,int c,int d,int v){
    t1=min(a,c);t2=min(b,d);t3=max(a,c);t4=max(d,b);
    update(t3+1,t4+1,v);
    update(t1,t2,v);
    update(t3+1,t2,-v);
    update(t1,t4+1,-v);
}
int query(int a,int b,int c,int d){
    t1=min(a,c);t2=min(b,d);t3=max(a,c);t4=max(d,b);
    return getans(t3,t4)-getans(t3,t2-1)-getans(t1-1,t4)+getans(t1-1,t2-1);
}
int a,b,c,d,v;
char s[2];
int main(){
    scanf("%*c%d%d",&n,&m);
    while(scanf("%s%d%d%d%d",s,&a,&b,&c,&d)==5){
        if(s[0]=='L'){
            scanf("%d",&v);
            add(a,b,c,d,v);
        }else{
            printf("%d\n",query(a,b,c,d));
        }
    }
    return 0;
}

同样的loj上也有模板题，二维的修改和查询复杂度就是 $O (l o g n l o g m)$ 的了，空间为 $O (n m)$ ，开始建树同样有 $O (n m)$ 的和 $O (n m l o g n l o g m)$ 。

对于二维区间最值和一维类似，由于过于复杂，这里不详细说明。

而对于三维及三维以上的树状数组，其实和一二维的同理，但不仅复杂，代码量和复杂度急剧上升，所以除了毒瘤外一般不考~~考到了不要打我QWQ~~。

End

参考文章

胡小兔的博客-Orz

其实二维的数据结构，线段树除了树套树，四叉树的复杂度不对且非常高，所以目前常见的二维数据结构多半是树状数组~~不要给我说K-D tree~~。

有问题或者文章有错误请及时指出并联系博主，博主一定及时~~咕咕咕~~回答或者更改。

VictoryCzt

关注

4
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
树状数组学习笔记

一个轻量级的数据结构-树状数组对于数据结构来说，树状数组的大多数功能，用线段树，甚至平衡树之类的都可以实现；但是由于树状数组十分好写且常数巨小，所以在有些卡常题里面，和时间紧张的时候还是一个非常不错的选择，但是树状数组的功能比较局限，这里稍微讲一下原理和一些功能及其实现。Tips. 文中所说的logloglog均为log2log_2log2树状数组或者二叉索引树也称作Binary&amp;nbs...
复制链接

扫一扫