树状数组是用来解决数列多次单点修改和前缀和查询的利器。

首先我们来看问题的原型:

已知一个长度为n(n<=10 0000)的数列，初始值都是零，现在我们要对数列施加两种类型的操作共q(q<=10 0000)次：

1、在数列第i个位置上增加a

2、查询数列前i个数的和

这两种操作可能会交替出现。

思路：

方法1：

用数组存储数列，对于修改直接在相应位置上o(1)完成，对于查询，直接在数组上循环求和o(n),如果求前缀和的次数居多，则时间接近o(qn),很显然会超时。

方法2：

方法1时间主要浪费在求和，我们可以事先预处理前缀和数组s，那么对于查询操作则是o(1)，但是对于修改操作，则需要把修改位置后面的s数组元素都修改，时间o(n),如果修改操作居多的话，则总时间接近于o(qn)，也超时。

方法3：

树状数组。树状数组也是预处理的思想。

先介绍一个函数lowbit(x)，设x的二进制最低位有连续k个0，lowbit(x)的值等于2的k次方。

例如：

lowbit(1)=2^0=1,lowbit(2)=2^1=2,lowbit(3)=2^0=1,lowbit(4)=2^2=4 …

函数怎么实现的，请读者们先摁住好奇心。

方法2中，之所以修改操作是特别慢，是因为预处理太仔细了，导致每次修改操作会影响很多个预处理的值，我们对此加以改进。对于长度为n的数列，也事先预处理n个信息:

S[1]---表示以1结尾，长度为lowbit(1)的区间和

S[2]---表示以2结尾，长度为lowbit(2)的区间和

S[3]---表示以3结尾，长度为lowbit(3)的区间和

……

S[n]---表示以n结尾，长度为lowbit(n)的区间和

有了这n个信息，对于任意的前缀和，都可以通过很少的几个s元素拼凑出来。

例如求前8个元素的前缀和，s[8]就是所求；

求前9个元素的前缀和，s[9]+s[8]就是所求；

求前10个元素的前缀和，s[10]+s[8]就是所求；

求前11个元素的前缀和，s[11]+s[10]+s[8]就是所求；

求前12个元素的前缀和，s[12]+s[8]就是所求；

求前13个元素的前缀和，s[13]+s[12]+s[8]就是所求；

求前14个元素的前缀和，s[14]+s[12]+s[8]就是所求；

求前15个元素的前缀和，s[15]+s[14]+s[12]+s[8]就是所求；

……

为什么呢？

我们用pre[15]表示前15个元素的前缀和。因为S[15]存储的是以15结尾长度为lowbit(15)的一段区间和。所以s[15]就是pre[15]的最后面一段长度为lowbit(15)的和(后缀和)，在pre[15]中去除掉s[15]，还剩余pre[14](因为15-lowbit(15)=14)；即pre[15]=pre[14]+s[15]。

同样的S[14]存储的是以14结尾长度为lowbit(14)的一段区间和，也就是pre[14]的后缀和，在pre[14]中去掉s[14]，还剩余pre[12](因为14-lowbit(14)=12);即pre[14]=pre[12]+s[14]，把前面式子中pre[14]用pre[12]+s[14]替换，得到pre[15]=pre[12]+s[14]+s[15].

同样的s[12]中存储的是以12结尾长度为lowbit(12)的一段区间和，即pre[12]的最后一段，在pre[12]中去掉s[12]还剩余pre[8](因为12-lowbit(12)=8);即pre[12]=pre[8]+s[12]。所以pre[15]=pre[8]+s[12]+s[14]+s[15].

同样的s[8]中存储的是以8结尾长度为lowbit(8)的一段区间和，即pre[8]的最后一段，在pre[8]中去掉s[8]还剩余pre[0](因为8-lowbit(8)=0);即pre[8]=pre[0]+s[8]。至此结束，因为pre[0]就是0。代入上面的式子，所以pre[15]=s[8]+s[12]+s[14]+s[15].

所以pre[15]可以用4个预处理的s元素拼凑起来，而且这四个元素是很有规律的，首先必然包含s[15]，然后下一个是s中下标为15-lowbit(15)，即s[14];再然后是s的下标为14-lowbit(14),即s[12],再再然后是s中下标为12-lowbit(12)的元素，即s[8];再再再然后是下标为8-lowbit(8)，即s[0],出现0就结束。请大家仔细体会这个规律。

Pre[15]被4个s元素拼接起来，这不是偶然，因为15的二进制串中(1111)恰好有4个1。Pre[x]需要几个s元素，恰好等于x二进制串中1的个数。为什么呢？

因为pre[x]=pre[x-lowbit(x)]+s[x]，x-lowbit(x)这个差值的二进制串恰好比x少了最右边的一个1。读者可以在纸上多写几个数验证一下。

要点：只要我们事先预处理出s[1]、s[2]、s[3]、…、s[n]，对于任意前缀和pre[x],都能用很少的几个s元素拼接起来(x的二进制串中数字1的个数，不超过logx)。

如果我们修改数列某一个元素，则肯定会影响s数组的元素，所有必须对s数组有相应的修改。

例如修改数列第一个元素，因为s[1]后缀和包含数列第一个元素，所以需要修改s[1],同样s[2]、s[4]、s[8]、s[16]、…他们都包含了第一个元素，这些s数组元素都要修改。需要修改的元素1-->2-->4-->8-->16-->…有什么联系呢？

如果修改第二个元素，因为s[2]后缀和包含第数列二个元素，所以需要修改s[2],同样s[2]、s[4]、s[8]、s[16]、…他们都包含了数列第二个元素，这些s数组元素都要修改。需要修改的元素2-->4-->8-->16-->…有什么联系呢？

如果修改第三个元素，因为s[3]后缀和包含数列第三个元素，所以需要修改s[3],同样s[4]、s[8]、s[16]、…他们都包含了数列第三个元素，这些s数组元素都要修改。需要修改的元素3-->4-->8-->16-->…有什么联系呢？(请读者思考几分钟，为什么是只修改这些点？)

要点：如果修改数列第x个元素的值，则s[x]要修改，s[x+lowbit(x)]要修改，……，直到超出n为止。总共个数不超过logn。

总结：查询一个前缀和，最多需要查询logn个s数组元素，修改一个数列元素，最多需要修改logn个数组元素，取得一个很平衡的时间效率，非常不错。树状数组非常适合求数列元素修改和区间查询反复出现的问题。

为什么取名字叫树状数组呢？

我们修改每个数列元素时，要修改的s数组元素链条都串起来，如下图构成一个树形，所以取名叫树状数组。

红色方框是s数组元素，黑色方框是数列元素。修改一个数列元素，要修改从他开始的链条，直到超出n为止。

最后一个问题，怎么求lowbit(x)? x&-x就是答案！

设x的二进制为(假设最低位有3个0)：  XXXXX1000

则x的反码是:                           XXXXX0111(红色与上面黑色的x相反)

X的反码+1，恰好是-x的补码：           XXXXX1000

所以x&-x，红色和黑色的X做与运算后恰好为0，结果就是1000.对应十进制就是2^3.

详细代码如下：

int lowbit(int x)

{

return x&-x;

}

int getsum(int x)

{

int tot=0;

while(x>0)

{

tot+=s[x];

X-=lowbit(x);

}

return tot;

}

void change(int x,int d)

{

While(x<=n)

{

S[x]+=d;

x+=lowbit(x);

}

}