迎龙年浅谈 Binary Indexed Trees

什么是 Binary Indexed Trees？

就是树状数组啦。树状数组，是一种高级数据结构，用于高效地解决某一类问题。

那么这一类问题是什么呢？那么让我们一起来看一下：

问题引入

给定一个序列 $a$，给定 $Q$ 个 $l,r$，求 $\sum _{i=l}^r{a}_i$。

这一类问题，我们明显可以暴力枚举，时间复杂度为 $\mathrm{\Theta }(\sum _{i=1}^{Q}r-l+1)$。

明显，若 $l,r$ 过于大，这样也解决不了，因此有了前缀和。

前缀和，是用来统计前 $\sum _{i=1}^j{a}_i$，也就是说，回答每一次查询只需要 $\mathrm{\Theta }(1)$ 即可，即为 $a_r-a_{l-1}$。

这种算法在此问题已经算很高级了，但是如果我们改一下：

---

给定一个序列 $a$，给定 $Q$ 个 操作，每次给定 $opt,l,r$，分如下 $2$ 种操作：

• $opt=1$，将 $a_l$ 增加为 $r$。

• $opt=2$，求 $\sum _{i=l}^r{a}_i$。

这时，暴力枚举最坏的时间复杂度变为了 $\mathrm{\Theta }(\sum _{i=1}^Q{r}_i-l_i+1)$，前缀和的最坏时间复杂度则变成了 $\mathrm{\Theta }(Qn)$。

因此，我们有了树状数组或者线段树，虽然它们对于每次操作都是 $\mathcal{O}(logn)$，但是线段树应用范围更广，但是这里采用树状数组解决，因为它实现更简单。但是等你都熟练了之后，你会发现，只不过是多了几行代码而已。。。

树状数组的引用

首先我们需要了解一下二进制。

我们知道，任意一个整数 $x$ 都可以分为 $2^{a_1}+2^{a_2}+2^{a_3}+\dots +2^{a_m}$。

设 $a_1>a_2>a_3>\dots >a_m$，则最多可以分解为 $\log n$ 的区间。

• 区间 $1$ 长度为 $2^{a_1}$，表示范围为 $[1,2^{a_1}]$。

• 区间 $2$ 长度为 $2^{a_2}$，表示范围为 $[2^{a_1}+1,2^{a_1}+2^{a_2}]$。

$\dots \dots \dots \dots$

• 区间 $m$ 长度为 $2_{a_m}$，表示范围为 $[2^{a_1}+2^{a_2}+2^{a_3}+\dots +2^{a_{m-1}}+1,2^{a_1}+2^{a_2}+2^{a_3}+\dots +2^{a_m}]$。

因此，区间 $[l,r]$ 的长度为 $2^{\mathtt{\text{r 的二进制末尾 0 个数}}}$，也就是 $r$ 最右边的 $1$ 所代表的数。

我们编程通常用 lowbit(x) 表示，计算方法为 $x\mathrm{and}(x\mathrm{xor}(x-1))=x\mathrm{and}(-x)$。

这其实涉及到计算机补码的知识，可以自己百度一下。

inline int lowbit(int x){
	return x&-x;//有无括号无所谓啦。
}

---

树状数组是一种基于二进制思想的数据结构，用来维护序列的前缀和。
—— 网上的一句话。

也就是说，我们可以用 $tre{e}_i$ 表示 $\sum _{i=x-\mathrm{lowbit}(\mathrm{x})+1}^x{a}_i$。

那么我们不难得到如下图（非原创）：

把 $c$ 当成 $tree$ 吧。。。

为什么 $tre{e}_8$ 连接了 $tre{e}_7,tre{e}_6,tre{e}_4$ 以及 $a_8$ 呢？首先 $a_8$ 不用解释了，然后 $7+lowbit(7)=8$，$6+lowbit(6)=8$，$4+lowbit(4)=8$。

单点修改

如果对于 $a_x$ 进行修改，那么 $tre{e}_x\sim tre{e}_n$ 的值都会进行变化，因此可以用一个循环将满足条件的 $tre{e}_y\leftarrow tre{e}_y+a_i$：

inline void updata(int k,int x){
	for(;k<=n;k+=lowbit(k))//每次增加 lowbit(k)。
    	tree[k]+=x;
}

区间查询

很明显，最好理解，每次减少 $lowbit(i)$，并且累加 $tre{e}_i$ 即可。

inline int query(int k){
	int sum=0;
	for(;k>0;k-=lowbit(k))
    	sum+=tree[k];//累加，不理解建议看看前面的 tree[i] 的表示。
	return sum;

求区间和就 $query(r)-query(l-1)$ 就行啦（就是前缀和思想）。

初始化

很简单，每次 $updata(i,a_i)$ 即可，时间复杂度为 $\mathrm{\Theta }(n\log n)$。

但是还有一种 $\mathrm{\Theta }(n)$ 的方法，考虑每个节点对父亲节点的贡献为 $tre{e}_i$，因此代码如下：

for(int i=1;i<=n;i++){
	tree[i]+=a[i];
	if(i+lowbit(i)<=n) //不要越界。
    tree[i+lowbit(i)]+=tree[i];

例题

以下代码都是本蒟蒻早期时打的代码，没有优化，纯 cin,cout。

• 【模板】树状数组 $1$。（单点修改 $+$ 区间查询）

就是上面说的两种操作，直接背模板即可。

#include <bits/stdc++.h>
using namespace std;
#define int long long

const int N=5e5+10;
int n,q,x,y,a,opt,tree[N];

inline int lowbit(int x){//lowbit 函数求解。
    return x&-x;
}
inline int query(int k){//模板。
	int sum=0;
    for(;k>0;k-=lowbit(k)) sum+=tree[k];
	return sum;
}
inline void update(int k,int x){//模板。
    for(;k<=n;k+=lowbit(k)) tree[k]+=x;
}
signed main() {
	cin>>n>>q;
	for(int i=1;i<=n;++i){
        cin>>a;
        update(i,a);//建立树状数组。
    }
    while(q--){
        cin>>opt>>x>>y;
        if(opt==1) update(x,y);//单点修改。
        else cout<<query(y)-query(x-1)<<endl;//区间查询。
    }
	return 0;
}

---

• 【模板】树状数组 $2$。（区间修改 $+$ 单点查询）

这其实涉及到两种操作，即为区间修改以及单点查询。

如果还是用上面的方法去做，时间复杂度可能会达到 $\mathrm{\Theta }(Qn)$。

所以这种方法是不可行的。

考虑差分，没学过建议学一学。

比如：$a=[1,2,6,11,12,16,15]$，那么差分数组 $b=[1,1,4,5,1,4,-1]$。（逃

也就是说，$b_i=a_i-a_{i-1}$。

很好证明，$a_i=\sum _{j=1}^i{b}_j$，因为 $a_i-a_{i-1}+(a_{i-1}-a_{i-1})+\dots +(a_2-a_1)+(a_1-[a_0\to 0])=a_i$。

所以说，我们可以用树状数组维护差分数组，并不用维护原数组。

但是将 $[l,r]$ 都加上 $x$ 怎么操作呢？我们可以举了栗子：

比如：$a=[1,4,9,16,25,36,49]$，$b=[1,3,5,7,9,11,13]$，将 $[2,5]$ 都加上 $5$，那么原数组为 $[1,9,14,21,30,36,49]$，差分数组就为变为 $[1,8,5,7,9,6,13]$。

仔细观察，我们发现：$[l,r]$ 区间内差分数组 $(l,r]$ 内的没有变，然而 $b_l\leftarrow b_l+x$，$b_r\leftarrow b_r-x$。

设 $i$ 在 $(l,r]$ 之间，则更改后 $b_i=(a_i+x)-(a_{i-1}+x)=a_i-a_{i-1}$，不会发生变化。

但是 $i=l$，$b_i=(a_i+x)-(a_{i-1})=a_i-a_{i-1}+x=b_i+x$;$i=r+1$，$b_i=a_i-(a_{i-1}+x)=a_i-a_{i-1}-x=b_i-x$。

因此，我们只需要对两个端点进行单点修改即可。

update(l,x);//增加。
update(r+1,-x);//减少。

那么怎么输出呢？

因为 $a_i=\sum _{j=1}^i{b}_j$，上面有证明，所以直接查询就行了（反正维护的是差分数组）。

$\boxed{{\displaystyle Code}}$

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N=5e5+10;
int n,q,x,y,s,a[N],opt,tree[N];
inline int lowbit(int x){
    return x&-x;
}
inline int query(int k){
	int sum=0;
    for(;k>0;k-=lowbit(k)) sum+=tree[k];
	return sum;
}
inline void update(int k,int x){
    for(;k<=n;k+=lowbit(k)) tree[k]+=x;
}
signed main() {
	cin>>n>>q;
	for(int i=1;i<=n;++i){
        cin>>a[i];
        update(i,a[i]-a[i-1]);//维护差分数组，O(n) 也可以，只不过 O(n log n) 更容易实现。
    }
    while(q--){
        cin>>opt;
        if(opt==1){
            cin>>x>>y>>s;
            update(x,s);
            update(y+1,-s);//做两次正确的单点修改即为区间修改。
        }
        else{
            cin>>x;
            cout<<query(x)<<endl;//输出。
        }
    }
	return 0;
}

---

• AcWing. 一个简单的整数问题 $2$（区间修改 $+$ 区间查询）

发一个图：

看到区间修改，我们还是要用树状数组维护差分数组。

但是看到区间查询，如果单是只用差分数组，用到我们上面证明的 $a_i=\sum _{j=1}^i{b}_j$，一次查询的时间复杂度为 $\mathcal{O}((r-l+1)\log n)$，这不妥妥的 T 呀。

还是根据证明的 $a_i=\sum _{j=1}^i{b}_i$，则求原数组的前缀和为：

$$s_1=b_1$$

$$s_2=a_1+a_2=b_1+b_1+b_2$$

$$s_3=a_1+a_2+a_3=b_1+b_1+b_2+b_1+b_2+b_3$$

$$\cdots \cdots$$

$$s_n=\sum _{i=1}^n{a}_i=\sum _{i=1}^n{b}_i\times (n-i+1)$$

手工绘画一下（不是矩阵快速幂的矩阵）：

$$\left[\begin{array}{ccccc}{b}_1& b_2& b_3& \cdots & b_n\\ b_1& b_2& b_3& \cdots & b_n\\ b_1& b_2& b_3& \cdots & b_n\\ b_1& b_2& b_3& \cdots & b_n\\ \cdots & \cdots & \cdots \cdots & \cdots & \cdots \\ b_1& b_2& b_3& \cdots & b_n\end{array}\right]$$

上面矩阵的源码：$$\begin{bmatrix}\color{red}{b_1}&\color{red}{b_2}&\color{red}{b_3}&\color{red}{\cdots}&\color{red}{b_n}\\b_1 &\color{red}b_2 & \color{red}{b_3} & \color{red}\cdots & \color{red}{b_n}\\b_1&b_2&\color{red}{b_3}&\color{red}\cdots&\color{red}{b_n}\\b_1&b_2&b_3&\color{red}{\cdots}&\color{red}{b_n}\\\cdots&\cdots&\cdots\cdots&\color{red}{\cdots}&\color{red}{\cdots}\\b_1&b_2&b_3&\cdots&b_n\end{bmatrix}$$

那么：

$$\begin{array}{rl}{s}_n& =(b_1+b_2+\cdots +b_n)\times (n+1)-(b_1\times 1+b_2\times 2+\cdots +n\times b_n)\\ & =\sum _{i=1}^n{b}_i\times (n+1)-\sum _{i=1}^{n}i\times b_i\end{array}$$

所以，额外用一个树状数组维护一个 $i\cdot d_i$ 的差分数组即可。

$\boxed{{\displaystyle Code}}$

注：代码是别人的，我这道题用线段树 A 了，树状数组就不用了。我在代码上多加几条注释。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 1e5 + 10;
int n, m;
int a[N];
LL tr[N], tri[N];
//tr[]数组是对原数组的差分数组 d[] 进行维护，而 tri[] 数组是对原书的的差分数组 d[] * i 进行维护。

int lowbit(int x)
{
    return x & -x;
}
void add(LL c[], int x, int v)
{
    for (int i = x; i <= n; i += lowbit(i))
        c[i] += v;
}
LL query(LL c[], int x)
{
    LL res = 0;
    for (int i = x; i; i -= lowbit(i))
        res += c[i];
    return res;
}

LL get_sum(int x)
{
    return query(tr, x) * (x + 1) - query(tri, x);//公式。
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) scanf("%d", &a[i])
    for (int i = 1; i <= n; ++i) 
        tr[i] = a[i] - a[i - 1], tri[i] = tr[i] * i;//构造数组。
    /*建树。*/
    for (int x = 1; x <= n; ++x)
        for (int i = x - 1; i >= x - lowbit(x) + 1; i -= lowbit(i))
            tr[x] += tr[i], tri[x] += tri[i];
//-----------------------------------------------------------------
    while (m--){
        char op[2];
        int l, r, c;
        scanf("%s", op);
        if (op[0] == 'Q')
        {
            scanf("%d%d", &l, &r);
            printf("%lld\n", get_sum(r) - get_sum(l - 1));//类似于前缀和思想。
        }
        else
        {
            scanf("%d%d%d", &l, &r, &c);
            add(tr, l, c), add(tr, r + 1, -c);
            add(tri, l, l * c), add(tri, r + 1, (r + 1) * -c);//单点修改，很好理解的，就是多了一个数组。
        }
    }
    return 0;
}

作者：一只野生彩色铅笔
链接：https://www.acwing.com/solution/content/44886/
来源：AcWing

---

• 最接近神的人。（树状数组求逆序对个数）

一眼望去，就是求序列里逆序对的个数，于是乎我们 $\mathcal{O}(n^2)$ T 了。

仔细看看数据，$1\le n\le 5\times {10}^5$。

那么这类问题涉及到了树状数组的另一个作用：求逆序对！

由于原本的数组 $a$ 过于庞大，我们考虑离散化。

将序列 $a$ 从大到小排序，如果值相同则按照位置从大到小排序。

这样，相同的值就不会被统计逆序对了。

随后，我们考虑用树状数组维护：

• 已知，一开始，$\mathrm{\forall }tre{e}_i=0$。

• 然后开始遍历，设当前值为 $x$，位置为 $v$。

• 首先查询树状数组 $v-1$ 的位置，查找大于 $x$ 的数的个数（这样才能形成逆序对，即 $a_i>a_j$）。

• 然后对 $v$ 位置以及其后的 $tre{e}_y$ 做 $+1$ 操作，因为已经排序，所以该点对后面的贡献为 $1$。

时间复杂度为 $\mathcal{O}(n\log n)$。

$\boxed{{\displaystyle Code}}$

//笔者：可以复制哦。
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N=5e5+10;
int n,ans,tree[N]；
struct node{
    int num,pos;
};
node a[N];
inline bool cmp(node s1,node s2){
    if(s1.num==s2.num) return s1.pos>s2.pos;
    return s1.num>s2.num;
}
inline int lowbit(int x){
    return x&-x;
}
inline int query(int k){
	int sum=0;
    for(;k>0;k-=lowbit(k)) ans+=tree[k];
	return sum;
}
inline void update(int k){
    for(;k<=n;k+=lowbit(k)) tree[k]++;//直接 ++。
}
signed main() {
	cin>>n;
	for(int i=1;i<=n;++i){
        cin>>a[i].num;
        a[i].pos=i;//记录位置。
       //这种情况下可以不用建树，一开始没有遍历过答案就是 0，并没有初始数组。
    }
	sort(a+1,a+1+n,cmp);
	for(int i=1;i<=n;i++) {
		ans+=query(a[i].pos-1);//查询。
		update(a[i].pos);//修改，做贡献。
	}
	cout<<ans<<endl;
	return 0;
}

• 异或橙子。（操作 $+\to \oplus$ 以及 $\oplus$ 的一些性质）

挺不错的，只不过是有一些性质。

我们都知道，异或的运算法则：相同则 $0$，不同则 $1$。

因此如下性质：

• $a\oplus a=0$

（自己异或自己，二进制一模一样，每一位都相同，肯定是 $0$）。

• $a\oplus 0=a$

（相当于每一位都异或 $0$，分情况讨论。设 $a_i$ 表示 $a$ 的二进制第 $i$ 位，如果 $a_i=1$，则 $1\oplus 0=1$，一样；若 $a_i=0$，则 $0\oplus 0=0$，一样。所以 $a\oplus 0=a$）。

通过计算，设序列长度为 $len$，则第 $i$ 个数会出现 $\sum _{j=1}^i(n-j+1)-(i-j)=\sum _{j=1}^{i}n-i+1=i\times (n-i+1)$。

分情况讨论：

• 如果 $2\mid n$。

  • 如果 $2\mid i$，则任何 $2\mid i$ 的数出现的次数都是偶数次。

  • 如果 $2\mid (i+1)$，则 $n-i+1$ 为偶数，则任何 $2\mid (i+1)$ 的数都会出现偶数次。

• 如果 $2\mid (n+1)$。

  • 如果 $2\mid i$，则 $(n-i+1)$ 为偶数，则任何 $2\mid i$ 的数都会出现偶数次。

  • 若 $2\mid (i+1)$，则两端都是奇数，奇数 $\times$ 奇数 $=$ 奇数，所以任何 $2\mid (i+1)$ 的数都会出现奇数次。

因为偶数次为根据性质 $1$ 抵消变为 $0$，而 $0$ 又会根据性质 $2$ 完全没有作用，因此：

• 若 $2\mid (r-l+1)$，则答案为 $0$。

• 若 $2\mid (r-l)$，则答案为 $a_l\oplus a_{l+2}\oplus a_{l+4}\oplus \dots \oplus a_r$。

这样该怎么求呢？我们可以开两个树状数组维护右端点分别为奇偶数的情况呀！

那么原本的加法运算怎么办呢？那都改为异或运算不就好了嘛！

$\boxed{{\displaystyle Code}}$

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N=5e5+10;
int n,q,x,y,opt,ans,a[N];
inline int lowbit(int x){
    return x&-x;
}
struct node{//定义在结构体更方便。
    int xx[N];
    inline int query(int k){//区间查询。
	    int sum=0;
        for(;k>0;k-=lowbit(k)) sum^=xx[k];
	    return sum;
    }
    inline void update(int k,int x){//单点修改。
        for(;k<=n;k+=lowbit(k)) xx[k]^=x;
    }
};
node tree[3];
signed main() {
	cin>>n>>q;
	for(int i=1;i<=n;++i){
        cin>>a[i];
        tree[i&1].update(i,a[i]);//建树。
    }
	while(q--){
        cin>>opt>>x>>y;
        if(opt==1){
            tree[x&1].update(x,a[x]^y);//别忘了修改哈，把 a[x] 修改为 y 就是异或 a[x]^y。
            a[x]=y;
        }
        else
            if(!((y-x+1)&1)) cout<<"0\n";//区间个数为偶数，答案为 0.
            else cout<<((tree[x&1].query(x-1))^(tree[x&1].query(y)))<<endl;//否则维护即可。
        
    }
	return 0;
}

• 数星星 Stars。（$2$ 个参数的树状数组）

选择暴力，时间复杂度为 $\mathcal{O}(n^2)$，可能勉强能卡过。但是如果改成 $1\le n\le {10}^5$，那不就妥妥的 T 了吗？

所以暴力是不可行的。

题目要求 $x_j\le x_i\mathrm{\Lambda }{y}_j<y_i$，有两个参数 $x$ 和 $y$，那么我们可以先将 $n$ 个星星的 $x$，$y$ 坐标进行从小到大的排序，来让树状数组更简单地实现。

以 $x$ 为第一关键字，$y$ 为第二关键字，每次遍历 $n$ 颗星星。

既然此时 $x$ 已经排好序，那么对于 $y_i$ 的等级，就是 $\sum _{k=1}^{i-1}[y_k\le y_i]$。

这时发现，这不就是树状数组吗？用一个 $\mathtt{\text{query}}(y_i)$ 就解决了。

然后考虑第 $i$ 颗星星对于以后的星星的贡献都为 $1$，因此 $\mathtt{\text{update}}(y_i,1)$ 就解决了。

那么怎么统计等级为 $x$ 的星星个数呢？我们可以开一个桶呀！

$\boxed{{\displaystyle Code}}$

//笔者的话：可以复制哦。
#include <bits/stdc++.h>
using namespace std;

#define lowbit(x) x&(-x)
#define int long long
#define rep(i,x,y) for(int i=x;i<=y;i++)
#define rrep(i,x,y) for(int i=x;i>=y;i--)
#define sc scanf
#define pr printf
inline int read(){int s=0,w=1;char c=getchar();while(!isdigit(c)){if(c=='-') w=-1;c=getchar();}while(isdigit(c)){s=(s<<1)+(s<<3)+(c^48);c=getchar();}return s*w;}

const int N=1e6+10;
int n,maxny,ans[N],tree[N];

struct stars{
    int x,y;
    bool operator <(const stars &t)const{//重载运算符。
        if(x==t.x) return y<t.y;
        return x<t.x;
    }
}a[N];

//以下都是树状数组模板。
inline void update(int k,int t){
    for(k;k<=maxny;k+=lowbit(k))//注意不是 <=n，是 <=maxny（最大的 y 坐标）。
        tree[k]+=t;
}

inline int query(int k){
    int sum=0;
    for(k;k>0;k-=lowbit(k))
        sum+=tree[k];
    return sum;
}

signed main(){
    n=read();
    rep(i,1,n){
        a[i].x=read();
        a[i].y=read();
        ++a[i].x;
        ++a[i].y;
        maxny=max(maxny,a[i].y);//比较最大的 y 坐标。
      //这里也不用建树，理由同上。
    }
	
	sort(a+1,a+1+n);
  
    rep(i,1,n){
        ans[query(a[i].y)]++;//统计答案。
        update(a[i].y,1);//单点修改 ---> 对后面的树状数组做贡献。
    }
    rep(i,1,n)
        pr("%lld\n",ans[i-1]);
    return 0;
}

未完待续。。。