树状数组学习

胆识与智慧

于 2018-02-10 20:19:25 发布

阅读量196

点赞数

分类专栏：学习树状数组树状数组

本文链接：https://blog.csdn.net/nishisiyuetian/article/details/79306684

版权

树状数组同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

学习树状数组

2 篇文章 0 订阅

订阅专栏

我觉得，树状数组挺重要的就是那个 lower( x ) = x & -x ，我说说我的理解吧。

每一个正整数都可以拆分成 2 的某些幂之和，例如 15 = 8 + 4 + 2 + 1 , 6 = 4 + 2 , 7 = 4 + 2 + 1 （感觉可以解释LCA的倍增跳）。

那么转换成二进制是什么样的呢？

15 （十进制） = 1111 = 1000 + 100 + 10 + 1

6 （十进制） = 110 = 100 + 10

也就是前15 项可以由 8+4+2+1 项组成，1-8 ， 9-12 ， 13-14 ， 15

前 6 项可以由 4 + 2 项组成， 1-4 ， 5-6

树状数组就是利用了这一点，计算前 15 项之和，可以先算出 1-8 ， 9-12 ， 13-14 ， 15 ，这中间就需要一个“拆”的过程，怎么样把 1111 的每一个 1 都提取出来。

lower(x) = x & -x 就可以。

根据位运算， -x 是把 x 的二进制先取反再+1 ，

例如 15 = 1111，取反加一就是 0000+1 = 0001 ，1111 & 0001运算之后是 0001，这第一步取出来的就是1111中最低位的 1 ，然后 15- lower( 15) = 14 ;

紧接着，对 14 进行同样的操作，14 = 1110，取反+1就是 0001+1 = 0010 ，1110 & 0010 运算后是 0010，这次取出来的是1110中最低位的 1；

紧接着 14 -lower(14) = 12 ,对 12 操作，12 = 1100 ，取反+1就是 0011+1 = 0100 ，1100 & 0100运算之后就是0100 ，取出来的是 1100中的最低位的 1 ；

紧接着 12 - lower(12) = 4 ，对 4 操作 4 = 100 ，取反+1就是 011+1 = 100 , 100 & 100 = 100 ；

最后，4 - lower(4) = 0 , 分解完全。

上面的步骤就是把 15 “凑成” 2 的某些幂之和，15 = 8 + 4 + 2 +1 , 然后 8 = 4 + 4 ， 4 = 2 + 2 ， 2 = 1 + 1 。

以上好像取反+1 就可以了，那 & 操作是什么呢？

举个例子，1010 ，取反+1就是 0101+1 = 0110 ，在这里新生成了一个高位0100，我们只要 0010 ，用&操作，1010&0110就是 0010 ，把新生成的高位消去。

总结一下，lower(x) = x & -x 究竟进行了啥操作——取反，就可以消掉这个数二进制的高位的 1 ，例如 1100 ，就变成 0011 ，然后0011 + 1 ，就相当于是在恰好小于 0100 的数 0011 上 +1 ，，同时，用& 操作消掉新生成的高位，就等于 0100, 神奇地把最低位的 1 剥出来了。我感觉，和前段时间学的非递归的，字典序的全排列很像，字典序是后面的部分已经达到了最大，就倒置过来，然后找下一个数继续开始。这里 x & -x 也是差不多，把前面的 1 清空，后面0的部分取到最大，然后恰好+1 就可以取出原来最低位的 1。

所以，现在看这张图是不是很好理解呢？

void update( int x , int value ){               // 单点更新
	while( x <= n ){          
		c[x] += value ;
		x += lower( x ) ;  // 二进制形成更高位的 1
	}
}

int Sum( int x ){                  // 区间求和
	int ans = 0 ;
	while( x ){
		ans += c[x] ;
		x -= lower( x ) ;  // 拆成 2 的幂之和
	}
	return ans ;
}

这里可以 x -= lower( x ) 很好理解了，就是拆。

那么 x += lower( x ) , 就是一直加，直到 x >= n 停止，也许可以形成更高位，就像上图中的 C[4] 和 C[8] ,可以走到更高的地方 C[8] , 归 C[8] “控制” 。6 二进制 110 , 加上 lower(6) 就是 110 + 010 = 1000 , 这样就可以传递到更高位，和“拆”是相反的操作。

一. 单点修改，区间查询

最简单的树状数组，修改序列的一个值，求区间和

树状数组求逆序数 POJ 2299

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std ;
#define lower(x) x&-x 
typedef long long LL ;
int c[500005] , n ;
struct Node{
	int cost , pos ;
	bool operator < ( const Node &b ) const {
		return cost < b.cost ;
	}
} e[500005];

void update( int x ){
	while( x <= n ){
		++c[x] ;
		x += lower( x ) ;
	}
}

int Sum( int x ){
	int ans = 0 ;
	while( x ){
		ans += c[x] ;
		x -= lower( x ) ;
	}
	return ans ;
}

int main(){
	// freopen( "POJ 2299.txt" , "r" , stdin ) ;
	while( ~scanf( "%d" , &n ) && n ){
		memset( c , 0 , sizeof( c ) ) ;
		for( int i = 1 ; i <= n ; ++i ){
			scanf( "%d" , &e[i].cost ) ;
			e[i].pos = i ;
		}
		sort( e+1 , e+n+1 ) ;
		LL ans = 0 ;
		for( int i = n ; i >= 1 ; --i ){   // 从大到小开始统计前面比它大的，类似于桶排序，树状数组只是为了加快求和速度
			ans += Sum( e[i].pos ) ;
			update( e[i].pos ) ;
		}
		cout << ans << endl ;
	}
	return 0 ;
}

二. 区间修改，单点查询：

在一个区间内统一加上某个值，然后询问某一个点的大小。

这里是区间求和的变形。

用一个数组 c 保存 a[i] - a[i-1]

例如 c[1] = a[1] - a[0] , c[2] = a[2] - a[1] , c[3] = a[3] - a[2].....

然后把 c 数组加起来，就是 a[n] - a[n-1] + ( a[n-1] - a[n-2] ) ...... = a[n] - a[0]

所谓的差分，其实就是把查询每一个点变成查询区间和，通过相邻之间的差距，求出第几个数是多少

Hdu 1556

#include <bits/stdc++.h>
using namespace std ;
#define LL long long 
#define lower( x ) x&-x 
int n , c[100005] , l , r , add ;

void update( int x , int add ){
	while( x <= n ){
		c[x] += add ;
		x += lower( x ) ;
	}
}

LL sum( int x ){
	LL ans = 0 ;
	while( x ){
		ans += c[x] ;
		x -= lower( x ) ;
	}
	return ans ;
}

int main(){
	while( ~scanf( "%d" , &n ) && n ){
		memset( c , 0 , sizeof( c ) ) ;
		for( int i = 1 ; i <= n ; ++i ){
			scanf( "%d%d" , &l , &r ) ;
			update( l , 1 ) ;
			update( r+1 , -1 ) ;
		}
		for( int i = 1 ; i < n ; ++i )
			printf( "%lld " , sum( i ) ) ;
		printf( "%lld\n" , sum( n ) ) ;
	}
	return 0 ;
}

三. 区间修改，区间查询

这个也是利用了差分。

sum( n )
=a[1]+a[2]+a[3]+…+a[n-1]+a[n]
=c[1]+(c[1]+c[2])+…+(c[1]+c[2]+…+c[n])
=n*(c[1]+c[2]+…+c[n])-(0*c[1]+1*c[2]+2*c[3]+…+(n-1)*c[n]).

这里就有一个数组，可以直接求和，那就是前面的 c[1]+c[2]+…+c[n]，后面那一部分可以看作另外一个数组

d[n] = (n-1)*c[n]

sum( n ) = n * 总和(c) - 总和(d)

这样就等于是求和 (c) - 求和 (d）

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std ;
#define lower( x ) x & -x 
typedef long long LL ;
int N , Q , l , r ;
LL c[100005] ;
LL d[100005] ;

void update( LL *c , int x , LL add ){
	while( x <= N ){
		c[x] += add ;
		x += lower( x ) ;
	}
}

LL Sum( LL *c , int x ){
	LL ans = 0 ;
	while( x ){
		ans += c[x] ;
		x -= lower( x ) ;
	}
	return ans ;
}

LL Solve( int x ){
	return x * Sum( c , x ) - Sum( d , x ) ;  // 根据公式
}

int main(){
	LL cur , pre = 0 , add ;
	scanf( "%d%d" , &N , &Q ) ;
	for( LL i = 1 ; i <= N ; ++i ){
		scanf( "%lld" , &cur ) ;
		update( c , i , cur-pre ) ;
		update( d , i , (i-1)*(cur-pre) ) ; // 更新 d  数组
		pre = cur ;
	}
	char command[2] ;
	while( Q-- ){
		scanf( "%s" , command ) ;
		if( command[0] == 'C' ){
			scanf( "%d%d%lld" , &l , &r , &add ) ;
			update( c , l , add ) ;
			update( c , r+1 , -add ) ;
			update( d , l , (l-1)*add ) ;
			update( d , r+1 , -r*add ) ;
		}
		else{
			scanf( "%d%d" , &l , &r ) ;
			printf( "%lld\n" , Solve( r ) - Solve( l-1 ) ) ; 
		}
	}
	return 0 ;
}

今天对树状数组学习的还不深，日后再总结。

树状数组从一维到二维