树状数组的相关学习:
问题引入:
求数组的区间和,给一个数组求任意区间的和,首先想到的做法就是前缀和,这个做法的话,预处理需要有o(n),然后求区间和的时间是o(1)。总的时间就是o(n),但是当数组里面的元素在动态的更新的时候,数组的更新操作需要查找o(n),更新o(1),但是区间和的更新需要o(n);假如有m个更新的操作,就需要有o(nm)的时间复杂度,显然这个复杂度有点大,比如下面这道题:
第一行包含两个整数N、M,分别表示该数列数字的个数和操作的总个数。
第二行包含N个用空格分隔的整数,其中第i个数字表示数列第i项的初始值。
接下来M行每行包含3个整数,表示一个操作,具体如下:
操作1: 格式:1 x k 含义:将第x个数加上k
操作2: 格式:2 x y 含义:输出区间[x,y]内每个数的和
1<=N<=500000,1<=M<=500000
很显然NM达到了2.5*10^11的量级,显然用前缀和是不够的,但是如果有一种方法的查找和修改的时间都达到logn 级别的就可以解决问题了。
下面来介绍树状数组:
树状数组的优点:修改和查询的复杂度都是O(logN)
下面给出树状数组最基本的代码:
这中间我看到了二进制的应用很快捷,
比如说,tree[]数组和原数组a[n]之间的关系,二进制的应用;
求和时的ans和tree树的二进制的应用;
int lowbit(int t)
//核心部位:二进制上面的应用大大加快了运行速度。
{
return t&(-t);
}
void add(int x,int y)//修改函数
{
for(int i=x;i<=n;i+=lowbit(i))
tree[i]+=y;
}
int getsum(int x)//求和函数
{
int ans=0;
for(int i=x;i>0;i-=lowbit(i))
ans+=tree[i];return ans;
}
树状数组 重点是在树状的数组
大家都知道二叉树吧
叶子结点代表A数组A[1]~A[8]
…
现在变形一下
现在定义每一列的顶端结点C[]数组
如下图
C[i]代表 子树的叶子结点的权值之和// 这里以求和举例
如图可以知道
C[1]=A[1];
C[2]=A[1]+A[2];
C[3]=A[3];
C[4]=A[1]+A[2]+A[3]+A[4];
C[5]=A[5];
C[6]=A[5]+A[6];
C[7]=A[7];
C[8]=A[1]+A[2]+A[3]+A[4]+A[5]+A[6]+A[7]+A[8];
下面观察如下图
将C[]数组的结点序号转化为二进制
1=(001) C[1]=A[1];
2=(010) C[2]=A[1]+A[2];
3=(011) C[3]=A[3];
4=(100) C[4]=A[1]+A[2]+A[3]+A[4];
5=(101) C[5]=A[5];
6=(110) C[6]=A[5]+A[6];
7=(111) C[7]=A[7];
8=(1000) C[8]=A[1]+A[2]+A[3]+A[4]+A[5]+A[6]+A[7]+A[8];
对照式子可以发现 C[i]=A[i-2k+1]+A[i-2k+2]+…A[i]; (k为i的二进制中从最低位到高位连续零的长度)。
例如i=8时,k=3;
2
3
=
8
;
8
−
2
3
+
1
=
1
;
2^3=8; 8-2^3+1=1;
23=8;8−23+1=1;
故c[8]= A[1]+A[2]+A[3]+A[4]+A[5]+A[6]+A[7]+A[8];
如 i=5时,k=0;
2
0
=
1
;
5
−
2
0
+
1
=
5
;
2^0=1; 5-2^0+1=5;
20=1;5−20+1=5;
故 c[5]=A[5];
如 i=4 ,k = 2;
2
2
=
4
;
4
−
2
2
+
1
=
1
;
2^2=4; 4-2^2+1=1;
22=4;4−22+1=1;
故 c[4] = A[1]+A[2]+A[3]+A[4];
现在引入lowbit(x)
lowbit(x) 其实就是取出x的最低位1 换言之 lowbit(x)=2^k (k为i的二进制中从最低位到高位连续零的长度)。
下面说代码
int lowbit(int t)
{
return t&(-t);
}
//-t 代表t的负数 计算机中负数使用对应的正数的补码来表示
这里利用的负数的存储特性,负数是以补码存储的,对于整数运算 x&(-x)有
当x为0时,即 0 & 0,结果为0;
当x为奇数时,最后一个比特位为1,取反加1没有进位,故x和-x除最后一位外前面的位正好相反,按位与结果为0。结果为1。
当x为偶数,且为2的m次方时,x的二进制表示中只有一位是1(从右往左的第m+1位),其右边有m位0,故x取反加1后,从右到左第有m个0,第m+1位及其左边全是1。这样,x& (-x) 得到的就是x。
当x为偶数,却不为2的m次方的形式时,可以写作x= y * (2k)。其中,y的最低位为1。实际上就是把x用一个奇数左移k位来表示。这时,x的二进制表示最右边有k个0,从右往左第k+1位为1。当对x取反时,最右边的k位0变成1,第k+1位变为0;再加1,最右边的k位就又变成了0,第k+1位因为进位的关系变成了1。左边的位因为没有进位,正好和x原来对应的位上的值相反。二者按位与,得到:第k+1位上为1,左边右边都为0。结果为2k。
总结一下:x&(-x),当x为0时结果为0;x为奇数时,结果为1;x为偶数时,结果为x中2的最大次方的因子。
//例如 :
// t=6(0110) 此时 k=1
//-t=-6=(1001+1)=(1010)
// t&(-t)=(0010)=2=2^1
C[i]=A[i-2k+1]+A[i-2k+2]+…A[i];
C[i]=A[i-lowbit(i)+1]+A[i-lowbit(i)+2]+…A[i];
区间查询
ok 下面利用C[i]数组,求A数组中前i项的和
举个例子 i=7;
sum[7]=A[1]+A[2]+A[3]+A[4]+A[5]+A[6]+A[7] ; 前i项和
C[4]=A[1]+A[2]+A[3]+A[4]; C[6]=A[5]+A[6]; C[7]=A[7];
可以推出: sum[7]=C[4]+C[6]+C[7];
序号写为二进制: sum[(111)]=C[(100)]+C[(110)]+C[(111)];
再举个例子 i=5
sum[7]=A[1]+A[2]+A[3]+A[4]+A[5] ; 前i项和
C[4]=A[1]+A[2]+A[3]+A[4]; C[5]=A[5];
可以推出: sum[5]=C[4]+C[5];
序号写为二进制: sum[(101)]=C[(100)]+C[(101)];
细细观察二进制 树状数组追其根本就是二进制的应用
结合代码
int getsum(int x)
{
int ans=0;
for(int i=x;i>0;i-=lowbit(i))
ans+=C[i];
return ans;
}
对于i=7 进行演示
7(111) ans+=C[7]
lowbit(7)=001 7-lowbit(7)=6(110) ans+=C[6]
lowbit(6)=010 6-lowbit(6)=4(100) ans+=C[4]
lowbit(4)=100 4-lowbit(4)=0(000)
sum[7]=C[4]+C[6]+C[7]
对于i=5 进行演示
5(101) ans+=C[5]
lowbit(5)=001 5-lowbit(5)=4(100) ans+=C[4]
lowbit(4)=100 4-lowbit(4)=0(000)
sum[5]=C[4]+C[5];
单点更新
当我们修改A[]数组中的某一个值时 应当如何更新C[]数组呢?
回想一下 区间查询的过程,再看一下上文中列出的图
结合代码分析
void add(int x,int y)
{
for(int i=x;i<=n;i+=lowbit(i))
tree[i]+=y;
}
//可以发现 更新过程是查询过程的逆过程
//由叶子结点向上更新C[]数组
如图:
当更新A[1]时 需要向上更新C[1] ,C[2],C[4],C[8]
C[1], C[2], C[4], C[8]
写为二进制 C[(001)],C[(010)],C[(100)],C[(1000)]
1(001) C[1]+=A[1]
lowbit(1)=001 1+lowbit(1)=2(010) C[2]+=A[1]
lowbit(2)=010 2+lowbit(2)=4(100) C[4]+=A[1]
lowbit(4)=100 4+lowbit(4)=8(1000) C[8]+=A[1]
然后自己总结下,自己的感想:一个就是看到二进制的快捷应用,感到很神奇,速度一下子就提高了好多,然后在一个就是需要注意的是更新的时候需要下向上更新,求和的时候从上向下求和。
接下来 就介绍一些相关的题目的代码:
1.敌兵布阵
#include <iostream>
#include<string.h>
#include<stdio.h>
#include<string>
using namespace std;
const int N=50050;
int n;
int tree[N];
int lowbit(int x){
return x&(-x);
}
long long query(int x){
long long ans=0;
for(int i=x;i>0;i-=lowbit(i)){
ans+=tree[i];
}
return ans;
}
void update(int x,int y){
for(int i=x;i<=n;i+=lowbit(i)){
tree[i]+=y;
}
}
int main(){
int t,sum,ans,x,y,num,j;
string str;
cin>>t;
for(int i=1;i<=t;i++){
memset(tree,0,sizeof(tree));
cin>>n;
for(j=1;j<=n;j++){
scanf("%d",&num);
add(j,num);
}
printf("Case %d:\n",i);
while(cin>>str){
if(str[0]=='E')break;
else {
cin>>x>>y;
if(str[0]=='Q')printf("%lld\n",query(y)-query(x-1));
if(str[0]=='A')update(x,y);
if(str[0]=='S')update(x,-y);
}
str.clear() ;
}
}
return 0;
}
poj2299
利用树状数组可以在o(log(n))的时间复杂度求出当前数字的前缀和,进而可以求出在当前数字后面数字的个数(i-sum(x))(i表示已经加入的总数字的数目,sum(x)表示小于等于x的数字的数目,它们之差就是大于x的数字的数目)
这样就把逆序对问题和树状数组联系起来了。
树状数组求逆序对的问题还是很有意思的。
#include <iostream>
#include<algorithm>
#include <string.h>
#include<stdio.h>
using namespace std;
const int N=5e5+50;
int n;
int tree[N];
int lowbit(int x){
return x&(-x);
}
long long query(int x){
long long ans=0;
for(int i=x;i>0;i-=lowbit(i)){
ans+=tree[i];
}
return ans;
}
void update(int x,int y){
for(int i=x;i<=n;i+=lowbit(i)){
tree[i]+=y;
}
}
struct node{
int val;
int id;
};
struct node a[N];
int b[N];
bool cmp(struct node c,struct node b){
return c.val<b.val;
}
int main(){
int t,sum,x,y,num,j,i;
while(cin>>n){
if(n==0)break;
else{
long long ans=0;
memset(tree,0,sizeof(tree));
for(j=1;j<=n;j++){
scanf("%d",&num);
a[j].val=num;
a[j].id=j;
}
sort(a+1,a+1+n,cmp);
for(i=1;i<=n;i++){
b[a[i].id]=i;
}
for(i=1;i<=n;i++){
update(b[i],1);
ans+=(i-query(b[i]));
}cout<<ans<<endl;
}
}
return 0;
}