树状数组基本概念

最新推荐文章于 2024-08-13 23:02:29 发布

Kylehz

最新推荐文章于 2024-08-13 23:02:29 发布

阅读量526

点赞数

分类专栏：树状数组文章标签：树状数组

树状数组专栏收录该内容

6 篇文章 0 订阅

订阅专栏

如果给定一个数组，要你求里面所有数的和，一般都会想到累加。但是当那个数组很大的时候，累加就显得太耗时了，时间复杂度为O(n)，并且采用累加的方法还有一个局限，那就是，当修改掉数组中的元素后，仍然要你求数组中某段元素的和，就显得麻烦了。所以我们就要用到树状数组，他的时间复杂度为O（lgn），相比之下就快得多。下面就讲一下什么是树状数组：

一般讲到树状数组都会少不了下面这个图：

下面来分析一下上面那个图看能得出什么规律：

据图可知：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，c9=a9，c10=a9+a10，c11=a11........c16=a1+a2+a3+a4+a5+.......+a16。

分析上面的几组式子可知，当 i 为奇数时，ci=ai ；当 i 为偶数时，就要看 i 的因子中最多有二的多少次幂，例如，6 的因子中有 2 的一次幂，等于 2 ，所以 c6=a5+a6（由六向前数两个数的和），4 的因子中有 2 的两次幂，等于 4 ，所以 c4=a1+a2+a3+a4（由四向前数四个数的和）。

（一）有公式：cn=a(n-2^k+1)+.........+an（其中 k 为 n 的二进制表示中从右往左数的 0 的个数）。

那么，如何求 a^k 呢？求法如下：

int lowbit(int x)
{
     return x&(-x);    
}//返回x对应二进制的最后一位1对应的十进制数 如 lowbit（16）=16；

补码：

x =1： 1 &－１（设位数为８）0000 0001 & 1111 1111 = 1

x = 6:6 & -6 0000 0110 &1111 1010 = 2

总结一下，其实就是：

求出2^p(其中p: x 的二进制表示数中，右向左数第一个1的位置)，如6的二进制表示为110，向左数第零个为0，第一个为1，则p=1，故Lowbit(6) = 2^1 = 2。

lowbit（）的返回值就是 2^k 次方的值。

求出来 2^k 之后，数组 c 的值就都出来了，接下来我们要求数组中所有元素的和。

（二）求数组的和的算法如下：

（1）首先，令sum=0，转向第二步；

（2）接下来判断，如果 n>0 的话，就令sum=sum+cn转向第三步，否则的话，终止算法，返回 sum 的值；

（3）n=n - lowbit（n）（将n的二进制表示的最后一个零删掉），回第二步。

可以看出，这个算法就是将这一个个区间的和全部加起来，为什么是效率是log(n)的呢？以下给出证明：

n = n – lowbit(n)这一步实际上等价于将n的二进制的最后一个1减去。而n的二进制里最多有log(n)个1，所以查询效率是log(n)的

代码实现：

int Sum(int n)
{
    int sum=0;
    while(n>0)
    {
         sum+=c[n];
         n-=lowbit(n);
    }    
    return sum;
}

（三）当数组中的元素有变更时，树状数组就发挥它的优势了，算法如下（修改为给某个节点 i 加上 x ）：

（1）当 i<=n 时，执行下一步；否则的话，算法结束;

（2）ci=ci+x ，i=i+lowbit（i）（在 i 的二进制表示的最后加零），返回第一步。

代码实现：

void change(int i,int x)
{
     while(i<=n)
     {
          c[i]=c[i]+x;
          i+=lowbit(i);
     }
}

举个栗子：

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define low(x) x&(-x)
int c[50005],n;
void add(int i,int val)
{
    while(i<=n)
    {
        printf("add c[%d]+= %d\n",i,val);
        c[i]+=val;
        i+=low(i);
    }
}
int getsum(int i)
{
    int sum=0;
    while(i>0)
    {
        printf("sum+=c[%d] \n",i);
        sum+=c[i];
        i-=low(i);
    }
    return sum;
}
int main()
{
    int t,i,k=1;
    cin>>t;
    while(t--)
    {
        scanf("%d",&n);
        c[0]=0;
        int w;
        memset(c,0,sizeof(c));
        for(i=1;i<=n;i++)
        {
            printf("-------\n");
            scanf("%d",&w);
            add(i,w);
        }
        while(cin>>n)printf("---  %d %d\n",n,getsum(n));

    }
    return 0;
}

输入

1
9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9

输出:

1
9
-------
1 2 3 4 5 6 7 8 9
add c[1]+= 1
add c[2]+= 1
add c[4]+= 1
add c[8]+= 1
-------
add c[2]+= 2
add c[4]+= 2
add c[8]+= 2
-------
add c[3]+= 3
add c[4]+= 3
add c[8]+= 3
-------
add c[4]+= 4
add c[8]+= 4
-------
add c[5]+= 5
add c[6]+= 5
add c[8]+= 5
-------
add c[6]+= 6
add c[8]+= 6
-------
add c[7]+= 7
add c[8]+= 7
-------
add c[8]+= 8
-------
add c[9]+= 9
1
sum+=c[1]
--- 1 1
2
sum+=c[2]
--- 2 3
3
sum+=c[3]
sum+=c[2]
--- 3 6
4
sum+=c[4]
--- 4 10
5
sum+=c[5]
sum+=c[4]
--- 5 15
6
sum+=c[6]
sum+=c[4]
--- 6 21
7
sum+=c[7]
sum+=c[6]
sum+=c[4]
--- 7 28
8
sum+=c[8]
--- 8 36
9
sum+=c[9]
sum+=c[8]
--- 9 45

二维树状数组

BIT可用为二维数据结果。假设你有一个带有点的平面(有非负的坐标)。你有三个问题：

1.在(x , y)设置点

2.从(x , y)移除点

3.在矩形(0 , 0), (x , y)计算点数 - 其中(0 , 0)为左下角，(x , y)为右上角，而边是平行于x轴和y轴。

对于1操作，在（x,y）处设置点，即Update(x,y,1)，那么这个Update要怎么写？很简单，因为x，y坐标是离散的，所以我们分别对x,y进行更新即可，函数如下：

void Update(int x,int y,int val)
{
       while(x<=n)
       {
              int y1=y;
              while(y1<=n)
              {
                     C[x][y1]+=val;
                     y1+=y1&(-y1);
              }
              x+=x&(-x);
       }
}

那么根据Update可以推得：GetSum函数为：

int GetSum(int x,int y)
{
       int sum=0;
       while(x>0)
       {
              int y1=y;
              while(y1>0)
              {
                     sum+=C[x][y1];
                     y1-=y1&(-y1);
              }
              x-=x&(-x);
       }
       return sum;
}

求逆序数

树状数组，具体的说是离散化+树状数组。这也是学习树状数组的第一题.

算法的大体流程就是：

1.先对输入的数组离散化，使得各个元素比较接近，而不是离散的，

2.接着，运用树状数组的标准操作来累计数组的逆序数。

算法详细解释：

1.解释为什么要有离散的这么一个过程？

刚开始以为999.999.999这么一个数字，对于int存储类型来说是足够了。

还有只有500000个数字，何必要离散化呢？

刚开始一直想不通，后来明白了，后面在运用树状数组操作的时候，

用到的树状数组C[i]是建立在一个有点像位存储的数组的基础之上的，

不是单纯的建立在输入数组之上。