朝花夕拾——树状数组 与 lowbit

最近用到了lowbit 函数，回顾一下树状数组。

百度搜出来的博客真的写的垃圾，是碳基生物能看的东西？

没有底下这张图也不知道在讲什么树状数组。底下这张图至少能好理解一百倍。

C就代表树状数组，A代表一个平常的数组。现在来介绍C数组。

$C[i]$代表它所能管理到的数组A的和，比如C[8] 就能管理全部$A[1]+...+A[8]$，C[6]就只能管理A5和A6，C5就只能管理A5。

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];

那么可以看一下对应的二进制

8 = 1000
7 =  111
6 =  110
5 =  101
4 =  100
3 =   11
2 =   10
1 =    1

我们不妨来找一下规律：

sum(1) = C[1]            1
sum(2) = C[2]            10
sum(3) = C[2]+C[3]       11 10
sum(4) = C[4]            100
sum(5) = C[4]+C[5]       101 100
sum(6) = C[4]+C[6]       110 100
sum(7) = C[4]+C[6]+C[7]  111 110 100
sum(8) = C[8]            1000

可以发现

1. 如果和只需要一项的，那么它的二进制表达有只有一个在最高位的1。
2. 如果是多项C的相加，那么每次都会消掉最低位的一个1。比如111 - 110 - 100 - 0
3. 1可以看作2的特例

而且刚好有一个函数可以找到最低位的1以及后面的0所组成的数。

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

比如

高位←   →低位
10011000   的lowbit就是1000
  10010    的lowbit就是10
  1001     的lowbit就是1
   10      的lowbit就是10它本身

原理：
这里采用了负数的补码：x的补码是x按位取反再加1

100100 x
011011 x的取反
011100 x的取反 + 1
100100 x
000100 (x的取反 + 1)&(x)

1 构建树状数组

再次祭出这张图片，我们需要从A构建出C。

我们需要专注C的关系，当你从i找到首个在它之上，且能管住它的节点

i += lowbit(i)
比如C[1]之上且能管住它的节点是C[2]
比如C[2]之上且能管住它的节点是C[4]
比如C[3]之上且能管住它的节点是C[4]
比如C[5]之上且能管住它的节点是C[6]
比如C[6]之上且能管住它的节点是C[8]
比如C[7]之上且能管住它的节点是C[8]
你可以发现正好符合这个lowbit

如果节点的值如果发生了改变，那么这个改变就要向上传递给管理它的节点。还是根据下表决定的

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];

比如A[6]发生了变化，那么就要通知C[6]和C[8]发生变化。

n是上界，也就是a数组的长度
for (int i=1;i<=n;++i) {
    c[i] += a[i];
    int nextpos = i + lowbit(i);
    if (nextpos <= n) {
        c[pos] += c[i];
    }
}

注意这里，构建的时候为什么只用向上传递一层？比如A[6]向上传递给A[8]，难道A[8]不用向上传递给A[16]吗？

因为这里你是从i=1向上不断构建的，当你把一次增加的值向上传递一层后，这一层增加的值会在之后的遍历中自动向上传递的。

所以在这里直接引出单点修改。

2 单点修改

这里可以看到，与构建时不同的是，在这里是要把增加的值逐层向上传递的。

n是上界，也就是a数组的长度
void update(int i, int x) {
    while (i <= n) {
        c[i] += x;
        i += lowbit(i);
    }
}

3 区间查询

要说区间查询我们就要先介绍这个函数，sum函数求的是A[1] + ... + A[i]，但是可以看到这个函数是逆向从高向低计算的。

int ask(int i) {
    sum = 0;
    while (i >= 1) {
        sum += c[i];
        i -= lowbit(i);
    }
    return sum;
}

我们上面提到了一个规律：

sum(1) = C[1]            1
sum(2) = C[2]            10
sum(3) = C[2]+C[3]       11 10
sum(4) = C[4]            100
sum(5) = C[4]+C[5]       101 100
sum(6) = C[4]+C[6]       110 100
sum(7) = C[4]+C[6]+C[7]  111 110 100
sum(8) = C[8]            1000

可以发现

1. 如果和只需要一项的，那么它的二进制表达有只有一个在最高位的1。
2. 如果是多项C的相加，那么每次都会消掉最低位的一个1。比如111 - 110 - 100 - 0
3. 1可以看作2的特例

这也就是上面代码的实现，要注意的是，在单点更新和区间查询时的下标的转移是不一样的，前者的下标转移是逐步向管理它的节点转移的，而后者并没有这个规律。他会优先跳向，能直接管理很多节点的节点。下面的例子中，在C4后就直接停止了，因为lowbit(4)=4; 4-4=0

3 一道例题

例题

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

long long n, q;
vector<long long> a(1e6+7, 0);
vector<long long> c(1e6+7, 0);

long long lowbit(long long x) {
    return x & (-x);
}

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

long long ask(long long i) {
    long long sum = 0;
    while (i >= 1) {
        sum += c[i];
        i -= lowbit(i);
    }
    return sum;
}

int main ()
{
    scanf("%lld%lld", &n, &q);
    for(long long i=1;i<=n;++i) {
        scanf("%lld", &a[i]);
    }
    for (long long i=1;i<=n;++i) {
        c[i] += a[i];
        long long pos = i + lowbit(i);
        if (pos <= n) {
            c[pos] += c[i];
        }
    }
    long long type, p1, p2;
    while(q --) {
        scanf("%lld%lld%lld", &type, &p1, &p2);
        if (type == 1) {
            update(p1, p2);
        } else {
            cout<<(ask(p2) - ask(p1 - 1))<<endl;
        }
    }
    return 0;
}