树状数组学习

转自：http://kmplayer.iteye.com/blog/562119

树状数组

博客分类： 
• 算法

CC++C#编程数据结构

1,用途 
树状数组是一种非常优雅的数据结构.当要频繁的对数组元素进行修改,同时又要频繁的查询数组内任一区间元素之和的时候,可以考虑使用树状数组. 
换句话说,树状数组最基本的应用: 
对于一个数组，如果有多次操作，每次的操作有两种：1、修改数组中某一元素的值，2、求和，求数组元素a[1]+a[2]+…a[num]的和。 
2,复杂度 
最直接的算法可以在O(1)时间内完成一次修改,但是需要O(n)时间来进行一次查询.而树状数组的修改和查询均可在O(log(n))的时间内完成. 
3,生成 
设a[1...N]为原数组,定义c[1...N]为对应的树状数组: 
c[i] = a[i - 2^k + 1] + a[i - 2^k + 2] + ... + a[i] 
其中k为i的二进制表示末尾0的个数,所以2^k即为i的二进制表示的最后一个1的权值. 
所以2^k可以表示为n&(n^(n-1))或更简单的n&(-n). 

Cpp代码  

1. int lowbit(int n)  
2. {  
3.     return n& (-n);    
4.         //or return n&(n^(n-1));  
5. }  

也就是说，把k表示成二进制1***10000，那么c[k]就是1***00001 + 1***00010 + ... + 1***10000这一段数的和。 
举例: 
 
可以看出:设节点编号为x，那么这个节点管辖的区间为2^k个元素。（其中k为x二进制末尾0的个数） 
C1 = A1 
C2 = A1 + A2 
C3 = A3 
C4 = A1 + A2 + A3 + A4 
C5 = A5 
C6 = A5 + A6 
C7 = A7 
C8 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8 
... 
C16 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8 + A9 + A10 + A11 + A12 + A13 + A14 + A15 + A16 
4,修改 
修改一个节点，必须修改其所有祖先，最坏情况下为修改第一个元素，最多有log(n)的祖先。 
对a[n]进行修改后,需要相应的修改c数组中的p1, p2, p3...等一系列元素 
其中p1 = n,  pi+1 = pi + lowbit(pi) 
所以修改原数组中的第n个元素可以实现为: 

Cpp代码  

1. void Modify(int n, int delta)  
2. {  
3.     while(n <= N)  
4.     {   
5.         c[n] += delta;   
6.         n += lowbit(n);  
7.     }  
8. }  

5,求和 
当要查询a[1],a[2]...a[n]的元素之和时,需要累加c数组中的q1, q2, q3...等一系列元素 
其中q1  = n,qi+1 = qi - lowbit(qi) 
所以计算a[1] + a[2] + .. a[n]可以实现为: 

Cpp代码  

1. int Sum(int n)  
2. {  
3.     int result = 0;  
4.     while(n != 0)  
5.     {   
6.         result += c[n];   
7.         n -= lowbit(n);   
8.     }  
9.     return result;  
10. }  

为什么是效率是log(n)的呢？以下给出证明： 
n = n – lowbit(n)这一步实际上等价于将n的二进制的最后一个1减去。而n的二进制里最多有log(n)个1，所以查询效率是log(n)的。 

换句话说: 
若需改变a[i]，则c[i]、c[i+lowbit(i)]、c[i+lowbit(i)+lowbit(i+lowbit(i)]……就是需要改变的 c数组中的元素。 
若需查询s[i]，则c[i]、c[i-lowbit(i)]、c[i-lowbit(i)-lowbit(i- lowbit(i))]……就是需要累加的c数组中的元素。 

6,与线段树的比较 
树状数组是一个可以很高效的进行区间统计的数据结构。在思想上类似于线段树，比线段树节省空间，编程复杂度比线段树低，但适用范围比线段树小。 

7,应用 
(1)http://acm.pku.edu.cn/JudgeOnline/problem?id=2155 
首先对于每个数A 
定义集合up(A)表示{A, A+lowestbit(A), A+lowestbit(A)+lowestbit(A+lowestbit(A))...} 
定义集合down(A)表示{A, A-lowestbit(A), A-lowestbit(A)-lowestbit(A-lowestbit(A)) ... , 0}。 
可以发现对于任何A<B，up(A)和down(B)的交集有且仅有一个数。 
于是对于这道题目来说，翻转一个区间[A,B]（为了便于讨论先把原问题降为一维的情况），我们可以把down(B)的所有元素的翻转次数+1，再把down(A-1)的所有元素的翻转次数-1。而每次查询一个元素C时，只需要统计up(C)的所有元素的翻转次数之和，即为C实际被翻转的次数。 
(2)http://acm.pku.edu.cn/JudgeOnline/problem?id=3321 
一棵树上长了苹果，每一个树枝节点上有长苹果和不长苹果两种状态，两种操作，一种操作能够改变树枝上苹果的状态，另一种操作询问某一树枝节点一下的所有的苹果有多少。具体做法是做一次dfs，记下每个节点的开始时间low[i]和结束时间high[i]，那么对于i节点的所有子孙的开始时间和结束时间都应位于low[i]和high[i]之间，另外用一个数组c[i]记录附加在节点i上的苹果的个数，然后用树状数组统计low[i]到high[i]之间的附加苹果总数。这里用树状数组统计区间可以用Sum(high[i])-Sum(low[i]-1)来计算。 

Cpp代码  

1. #include <stdio.h>  
2. #include <string.h>  
3. #include <vector>  
4. using namespace std;  
5.   
6. //vector<int> g[100005];  
7. struct Node  
8. {  
9.     int v;  
10.     struct Node *next;  
11. }g[100005];  
12. int n,m,cnt,low[100005],high[100005],c[100005],flag[100005];  
13. bool mark[100005];  
14.   
15. void dfs(int v)  
16. {  
17.     struct Node *p=g[v].next;  
18.     mark[v]=true;  
19.     cnt++;  
20.     low[v]=cnt;  
21.     while(p)  
22.     {  
23.         if(!mark[p->v])  
24.             dfs(p->v);  
25.         p=p->next;  
26.     }  
27.     high[v]=cnt;  
28. }  
29. int lowbit(int k)  
30. {  
31.     return k&(-k);  
32. }  
33. void Modify(int num, int v)  
34. {  
35.     while(num <= n)  
36.     {  
37.         c[num]+=v;  
38.         num+=lowbit(num);  
39.     }  
40. }  
41. int Sum(int num)  
42. {  
43.     int ans=0;  
44.     while(num > 0)  
45.     {  
46.         ans+=c[num];  
47.         num-=lowbit(num);  
48.     }  
49.     return ans;  
50. }  
51.   
52. int main()  
53. {  
54.     int i,a,b,ans;  
55.     char temp[10];  
56.     struct Node *p;  
57.     //freopen("in.txt","r",stdin);  
58.     scanf("%d",&n);  
59.     memset(g,0,sizeof(g));  
60.     for(i=1; i<n; i++)  
61.     {  
62.         scanf("%d%d",&a,&b);  
63.         p=new Node;  
64.         p->next=g[a].next;  
65.         p->v=b;  
66.         g[a].next=p;  
67.         p=new Node;  
68.         p->next=g[b].next;  
69.         p->v=a;  
70.         g[b].next=p;  
71.     }  
72.     memset(mark,false,sizeof(mark));  
73.     memset(c,0,sizeof(c));  
74.     for(i=1; i<=n; i++)  
75.         flag[i]=1;  
76.     cnt=0;  
77.     dfs(1);  
78.     scanf("%d",&m);  
79.     while(m--)  
80.     {  
81.         scanf("%s",temp);  
82.         if(temp[0] == 'Q')  
83.         {  
84.             scanf("%d",&a);  
85.             ans=high[a]-low[a]+1+Sum(high[a])-Sum(low[a]-1);  
86.             printf("%d\n",ans);  
87.         }  
88.         else  
89.         {  
90.             scanf("%d",&a);  
91.             if(flag[a]) Modify(low[a],-1);  
92.             else Modify(low[a],1);  
93.             flag[a]^=1;  
94.         }  
95.     }  
96.     return 0;  
97. }  

(3)http://acm.pku.edu.cn/JudgeOnline/problem?id=2481 
给n个区间[Si,Ei]，区间[Sj,Ej]< [Si,Ei] 有 Si <= Sj and Ej <= Ei and Ei - Si > Ej – Sj。按y坐标从小到达，x坐标从大到小的顺序排序，然后从后往前扫描，记录i之前所有的j区间Sj<Si的个数，这个用树状数组实现。扫描一遍可得出结果。 

Cpp代码  

1. #include <stdio.h>  
2. #include <string>  
3. #include <algorithm>  
4. using namespace std;  
5.   
6. struct P  
7. {  
8.     int x,y,id;  
9. }p[100005];  
10. int n,a[100005],max_n,b[100005];  
11.   
12. int lowbit(int k)  
13. {  
14.     return k&(-k);  
15. }  
16. void Modify(int num, int v)  
17. {  
18.     while(num <= max_n)  
19.     {  
20.         a[num]+=v;  
21.         num+=lowbit(num);  
22.     }  
23. }  
24. int Sum(int num)  
25. {  
26.     int ans=0;  
27.     if(num <= 0) return 0;  
28.     while(num)  
29.     {  
30.         ans+=a[num];  
31.         num-=lowbit(num);  
32.     }  
33.     return ans;  
34. }  
35. bool operator <(const P a, const P b)  
36. {  
37.     if(a.y == b.y) return a.x > b.x;  
38.     return a.y < b.y;  
39. }  
40.   
41. int main()  
42. {  
43.     int i;  
44.     //freopen("in.txt","r",stdin);  
45.     while(scanf("%d",&n), n)  
46.     {  
47.         max_n=0;  
48.         for(i=0; i<n; i++)  
49.         {  
50.             scanf("%d%d",&p[i].x,&p[i].y);  
51.             p[i].id=i;  
52.             p[i].x++;  
53.             p[i].y++;  
54.             if(p[i].y > max_n) max_n=p[i].y;  
55.         }  
56.         sort(p,p+n);  
57.         memset(a,0,sizeof(a));  
58.         for(i=n-1; i>=0; i--)  
59.         {  
60.             if(i != n-1 && p[i].y == p[i+1].y && p[i].x == p[i+1].x)  
61.                 b[p[i].id]=b[p[i+1].id];  
62.             else  
63.                 b[p[i].id]=Sum(p[i].x);  
64.             Modify(p[i].x,1);  
65.         }  
66.         for(i=0; i<n; i++)  
67.         {  
68.             if(i) printf(" ");  
69.             printf("%d",b[i]);  
70.         }  
71.         printf("\n");  
72.     }  
73.     return 0;  
74. }  

(4)用树状数组求区间第K小元素 
算法的时间复杂度是O(log(n))的，如果要求在线计算的话显然很有优势。 
基本思路是： 
先开一个数组，其中记录某个数出现次数，每输入一个树，相当于将该数出现次数加1，对应到树状数组中就相当于insert(t, 1),统计的时候，可以利用树状数组的求和，既可以二分枚举，也可以利用数的二进制表示，下面的代码有效地利用了数的二进制表示。 

Cpp代码  

1. #include <iostream>  
2. using namespace std;  
3.   
4. #define maxn 1<<20  
5. int n,k;  
6. int c[maxn];  
7.   
8. int lowbit(int x){  
9.     return x&-x;  
10. }  
11.   
12. void insert(int x,int t){  
13.        while(x<maxn){  
14.           c[x]+=t;  
15.           x+=lowbit(x);  
16.        }  
17. }  
18. int find(int k){  
19.     int cnt=0,ans=0;  
20.     for(int i=20;i>=0;i--){  
21.         ans+=(1<<i);  
22.         if(ans>=maxn || cnt+c[ans]>=k)ans-=(1<<i);  
23.         else cnt+=c[ans];  
24.     }  
25.     return ans+1;  
26. }  
27. void input(){  
28.        memset(c,0,sizeof(c));  
29.        int t;  
30.        scanf("%d%d",&n,&k);  
31.        for(int i=0;i<n;i++){  
32.             scanf("%d",&t);  
33.             insert(t,1);  
34.        }  
35.        printf("%d\n",find(k));  
36. }  
37. int main(){  
38.     int cases;  
39.     scanf("%d",&cases);  
40.     while(cases--){  
41.         input();  
42.     }  
43.     return 0;  
44. }