树状数组

最新推荐文章于 2021-07-19 10:17:28 发布

ccDLlyy

最新推荐文章于 2021-07-19 10:17:28 发布

阅读量723

点赞数 1

分类专栏：数据结构

数据结构专栏收录该内容

34 篇文章 0 订阅

订阅专栏

转载自：点击打开链接感谢作者

代码部分前的讲解主要基于线段树单点更新，区间查询后面的为算法变形延伸

树状数组，又称二进制索引树，英文名Binary Indexed Tree。

一、树状数组的用途

主要用来求解数列的前缀和，a[0]+a[1]+...+a[n]。

由此引申出三类比较常见问题：

1、单点更新，区间求值。（HDU1166）

2、区间更新，单点求值。（HDU1556）

3、求逆序对。（HDU2838）

二、树状数组的表示

1、公式表示

设A[]为一个已知的数列。C[]为树状数组。则会有

C[i]=A[j]+...+A[i]；而且有个有趣的性质，设节点编号为i，那么这个节点管辖的区间为2^k（其中k为x二进制末尾0的个数）个元素

具体算这个2^k有一个快捷的办法：x & (-x) 或者 x & (x ^ (x - 1) )

2、图形表示

（注：最下面的一行表示数组A，上面的二进制表示的部分是C）

从以上可以发现：

1、树状数组C是表示普通数组A的一部分的和。

2、小标为奇数时，C[i]只能管辖一个A[i]。

3、C[i]的最后一个数一定是A[i]。

树状数组的充分性：

很容易知道C8表示A1～A8的和，但是C6却是表示A5～A6的和，为什么会产生这样的区别的呢？或者说发明她的人为什么这样区别对待呢？答案是，这样会使操作更简单！看到这相信有些人就有些感觉了，为什么复杂度被log了呢？可以看到，C8可以看作A1～A8的左半边和+右半边和，而其中左半边和是确定的C4，右半边其实也是同样的规则把A5～A8一分为二……继续下去都是一分为二直到不能分树状数组巧妙地利用了二分，树状数组并不神秘，关键是巧妙！

三、树状数组的关键代码

1、

 
  int lowBit(int x)  
 {  
     return x&(-x);  
 }  
 

这段代码可以简单的理解为是树状数组向前或向后衍生是用的。

向后主要是为了找到目前节点的父节点，比如要将C[4]+1，那么4+(4&(-4))=8，C[8]+1，8+(8&(-8))=16，

C[16]+1。

向前主要是为了求前缀和，比如要求A[1]+...+A[12]。那么，C[12]=A[9]+...+A[12]；然后12-12&(-12)=8，

C[8]=A[1]+...+A[8]。

2、

 
  void modify(int pos,int num)  //pos为数组下标位置，num为要增加的值   
 {  
     while(pos<=n)   //n为数组的长度   
     {  
         c[pos]+=num;  
         pos+=lowBit(pos);  
     }  
 }  
 

这段代码是用来更新树状数组的，包括区间更新、单点更新。

就是想刚才所说的，一点更新了，要不断将父节点也更新。

3、

[cpp]view plaincopy 
   
print?
 int getResult(int pos)  //求A[1]+...+A[pos]   
 {  
     int sum=0;   
     while(pos>0)  
     {  
         sum+=c[pos];  
         pos-=lowBit(pos);  
     }  
       
     return sum;   
 }                  

这段代码用来求解前缀和的。

就像刚才说的，求解A[1]+...+A[12]，也就是C[12]+C[8]搞定。

四、树状数组的优点

1、原本的长度为n的数列求和时间复杂度为O(n)，更改的时间复杂度为O(1)。

树状数组将复杂度优化为O(logn)。在n较大时，效率更高。

2、树状数组编码简单。

3、树状数组是一个可以很高效的进行区间统计的数据结构。在思想上类似于线段树，空间复杂度略低，比线段树节省空间，编程复杂度比线段树低，但适用范围比线段树小，对可以进行的运算也有限制，比如每次要查询的是一个区间的最小值，似乎就没有很好的解决办法。

五、注意

1、树状数组的下标要从1开始。

2、pos-pos&(-pos)就到了下一个无联系的节点很容易理解。

为什么pos+pos&(-pos)就得到pos的父节点？这个根据图和上面证明树状数组充分性的二分思想容易看出。

对于玄玄的东西，自己非要去搞复杂的数学证明，反而会扰了心智，如果不是数学家和算法工程师，大致知道如何得到的即可，对于大多数人，关键还是熟练运用算法。

六、拓展

1、有的题目为改变的是一个区间，查询的反而是一个点，即区间更新，单点查询，表面上看，似乎和树状数组的使用方法恰好相反，实际上可以通过一个转化巧妙的解决。

首先对于每个数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]，如果更新up(A，data)和up(B+1,-data)，查询down(C)就能达到要求。

2、无论单点更新、区间查询还是区间更新、单点查询，树状数组均能应用于多维的情况。

七、代码：

HDU1166

单点更新，区间求值

 
   #include<iostream> 
      
  
 using namespace std;  
   
 const int maxn=50001;  
   
 int a[maxn];  
 int c[maxn];  
 int n;   
   
 int lowBit(int t)  
 {  
     return t&(-t);  
 }  
   
 void modify(int t,int num)  
 {  
     while(t<=n)  
     {  
         c[t]+=num;  
         t+=lowBit(t);  
     }  
 }  
   
 int getResult(int t)  
 {  
     int num=0;   
     while(t>0)  
     {  
         num+=c[t];  
         t-=lowBit(t);  
     }  
       
     return num;   
 }  
   
 void init()  
 {  
     for(int i=1;i<=n;i++)  
     {  
         scanf("%d",&a[i]);  
           
         modify(i,a[i]);   
     }  
 }  
   
   
 int main()  
 {  
     int cas,Case=1;  
       
     scanf("%d",&cas);   
     while(cas--)  
     {   
         memset(c,0,sizeof(c));   
         printf("Case %d:\n",Case++);  
            
         scanf("%d",&n);  
           
         init();  
           
         char ch[15];  
         int a,b;     
         while(scanf("%s",&ch),strcmp(ch,"End"))  
         {   
             scanf("%d%d",&a,&b);  
                
             switch(ch[0])  
             {  
                 case 'Q':  
                     printf("%d\n",getResult(b)-getResult(a-1));  
                     break;   
                 case 'A':   
                     modify(a,b);  
                     break;  
                 case 'S':  
                     modify(a,-b);  
                     break;  
             }  
          }  
      }  
        
      system("pause");  
      return 0;  
 }   

HDU1556

区间更新，单点求值

 
   #include<iostream> 
      
  
 #include<cstring>  
 using namespace std;  
   
 const int maxn=100001;  
   
 int c[maxn];  
 int n;  
   
 int lowbit(int t)  
 {  
     return t&(-t);  
 }  
   
 void insert(int t,int d)  
 {  
     while(t<=n)  
     {  
         c[t]+=d;  
         t+=lowbit(t);  
     }  
 }  
   
 int getSum(int t)  
 {  
     int sum=0;  
     while(t>0)  
     {  
         sum+=c[t];  
         t-=lowbit(t);  
     }  
       
     return sum;  
 }  
   
 int main()  
 {  
     while(cin>>n,n)  
     {  
         int a,b;  
         memset(c,0,sizeof(c));  
           
         for(int i=1;i<=n;i++)  
         {  
             scanf("%d%d",&a,&b);  
               
             insert(a,1);  
             insert(b+1,-1);  
         }  
           
        for(int j=1;j<n;j++)  
        {  
             printf("%d ",getSum(j));  
        }  
        printf("%d\n",getSum(n));  
     }  
       
     system("pause");  
     return 0;  
 }  

HDU2838

求逆序对

 
   #include<iostream> 
      
  
 #include<cstring>  
 using namespace std;  
   
 const int maxn=100001;  
    
 struct node  
 {  
     int cnt;  
     __int64 sum;  
 }tree[maxn];           
           
 int n;  
   
 int lowBit(int x)  
 {  
     return x&(-x);  
 }  
   
 void modify(int x,int y,int t)  
 {  
     while(x<=n)  
     {  
         tree[x].sum+=y;  
         tree[x].cnt+=t;  //tree[].cnt来保存是否出现过a   
         x+=lowBit(x);  
     }  
 }  
   
 __int64 query_cnt(int x)   //比x小的数的个数   
 {  
     __int64 sum=0;  
     while(x>0)  
     {  
         sum+=tree[x].cnt;  
         x-=lowBit(x);  
     }  
       
     return sum;  
 }  
   
 __int64 query_sum(int x)  //比x小的所有数之和   
 {  
     __int64 sum=0;  
     while(x>0)  
     {  
         sum+=tree[x].sum;  
         x-=lowBit(x);  
     }  
       
     return sum;  
 }  
   
 int main()  
 {  
     while(~scanf("%d",&n))  
     {  
         int a;  
         __int64 ans=0;   
         memset(tree,0,sizeof(tree));  
            
         for(int i=1;i<=n;i++)  
         {  
             scanf("%d",&a);  
               
             modify(a,a,1);  //以a为下标更新数组   
               
             __int64 k1=i-query_cnt(a);   //k1为前i个数比a大的数的个数   
             if(k1!=0)  
             {  
                 __int64 k2=query_sum(n)-query_sum(a); //目前所有数的和-目前所有比a小的数的和，为比a大的数的和     
                 ans+=k1*a+k2;   //调换a所需的时间   
             }  
         }  
           
         printf("%I64d\n",ans);   
     }  
       
     system("pause");  
     return 0;  
 }   

另一个题解：

分析：其实这个结果和逆序数有关，对某个位置i，如果前面比他大的有x个，那么a[i]至少要加x次
如果后面有y个比a[i]小，那么a[i]至少要加y次，也就是说用两个树状数组来分别维护当前位置时前面有多少比他大，后面有多少个比他小

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

#define N 100001
#define ll long long

ll C[N],B[N];
ll num[N];
int T;

int Lowbit(int x){
    return x&(x^(x-1));
}

void add(ll C[],ll pos,ll num) {
    while(pos <= N) {//x最大是N
        C[pos] += num;
        pos += Lowbit(pos);
    }
}

ll Sum(ll C[],ll end) {
    ll sum = 0;
    while(end > 0) {
        sum += C[end];
        end -= Lowbit(end);
    }
    return sum;
}

int main() {
    int s, t, i, j, T;
    ll ans;
    while(~scanf("%d",&T)) {
        memset(C,0,sizeof(C));
        memset(B,0,sizeof(B));

        memset(num,0,sizeof(num));
        ans = 0;
        for(i = 1; i <= T; i ++) {
            scanf("%I64d",&num[i]);
            add(C,num[i],1);
            ans += num[i] *(i - Sum(C,num[i])) ;//计算当前点前面大于它的数的个数
        }
        for(i = T; i > 0; --i){//注意是从T至0的，
            ans += num[i] * Sum(B,num[i] - 1);//计算当前点后面小于它的个数
            add(B,num[i],1);//从后面算起，然后加起来，那么Sum求出来的就是它后面小于它的个数了
        }
        printf("%I64d\n",ans);

    }
    return 0;
}

八、二维树状数组

C[x][y]=sum(A[i][j])。其中，x-lowBit(x)+1<=i<=x，y-lowBit(y)+1<=j<=y。

例题：HDU1892

二维树状数组一般就是对矩阵的操作，更新、求值

代码：

 
   #include<iostream> 
      
  
 #include<cstring>  
 using namespace std;  
   
 const int maxn=1005;  
   
 int c[maxn][maxn];  
   
 int lowBit(int x)  
 {  
     return x&(-x);  
 }  
   
 void modify(int x,int y,int val)  
 {  
     for(int i=x;i<maxn;i+=lowBit(i))  
     {  
         for(int j=y;j<maxn;j+=lowBit(j))  
         {  
             c[i][j]+=val;  
         }  
     }  
 }  
   
 int getResult(int x,int y)  
 {  
     int sum=0;  
     for(int i=x;i>0;i-=lowBit(i))  
     {  
         for(int j=y;j>0;j-=lowBit(j))  
         {  
             sum+=c[i][j];  
         }  
     }  
       
     return sum;  
 }  
   
 int getVal(int x,int y)  
 {  
     return getResult(x,y)-getResult(x-1,y)-getResult(x,y-1)+getResult(x-1,y-1);  
 }  
   
 void init()  
 {  
     memset(c,0,sizeof(c));  
       
     for(int i=1;i<maxn;i++)  
     {  
         for(int j=1;j<maxn;j++)  
         {  
             modify(i,j,1);  
         }  
     }  
 }  
       
 int main()  
 {  
     int cas,cas1=1,query;  
       
     scanf("%d",&cas);  
     while(cas--)  
     {  
         init();  
           
         scanf("%d",&query);  
   
         printf("Case %d:\n",cas1++);  
         for(int i=1;i<=query;i++)  
         {  
             char ch;  
             int x1,y1,x2,y2,n;  
               
             getchar();  
             scanf("%c",&ch);  
               
             switch(ch)  
             {  
                 case 'S':  
                     {  
                     scanf("%d%d%d%d",&x1,&y1,&x2,&y2);  
                     int x11=min(x1,x2);  
                     int x22=max(x1,x2);  
                     int y11=min(y1,y2);  
                     int y22=max(y1,y2);  
                     printf("%d\n",getResult(x22+1,y22+1)-getResult(x11,y22+1)-getResult(x22+1,y11)+getResult(x11,y11));  
                     break;  
                     }  
                 case 'A':  
                     {  
                     scanf("%d%d%d",&x1,&y1,&n);  
                     modify(x1+1,y1+1,n);  
                     break;  
                     }  
                 case 'M':  
                     {  
                     scanf("%d%d%d%d%d",&x1,&y1,&x2,&y2,&n);  
                     int v=getVal(x1+1,y1+1);  
                     int Min=min(n,v);  
                     modify(x1+1,y1+1,-Min);  
                     modify(x2+1,y2+1,Min);  
                     break;  
                     }  
                 case 'D':  
                     {  
                     scanf("%d%d%d",&x1,&y1,&n);  
                     int v=getVal(x1+1,y1+1);  
                     int Min=min(v,n);  
                     modify(x1+1,y1+1,-Min);  
                     break;  
                     }  
             }  
         }  
     }  
       
     system("pause");  
     return 0;  
 }  
 
   
 

九、参考文章
http://mindlee.net/2011/07/10/binary-indexed-trees/

http://dongxicheng.org/structure/binary_indexed_tree/

ccDLlyy

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
树状数组

转载自：点击打开链接感谢作者树状数组，又称二进制索引树，英文名Binary Indexed Tree。一、树状数组的用途主要用来求解数列的前缀和，a[0]+a[1]+...+a[n]。由此引申出三类比较常见问题：1、单点更新，区间求值。（HDU1166）2、区间更新，单点求值。（HDU1556）3、求逆序对。（HDU2838）
复制链接

扫一扫

专栏目录