c++ 树状数组

关于树状数组

树状数组，即 Binary Indexed Tree ，主要用于维护查询前缀和

属于 log 型数据结构

和线段树比较

都是 log 级别

树状数组常数、耗费的空间、代码量都比线段树小

树状数组无法完成复杂的区间操作，功能有限

树状数组介绍

二叉树大家一定不陌生



然而真实的树状数组省去了一些空间



其中黑色的是原数组，红色的是树状数组

根据图可以看出 S[] 的由来

S[1] = A[1]

S[2] = A[1] + A[2]

S[3] = A[3]

S[4] = A[1] + A[2] + A[3] + A[4]

按照上面的规律：

S[5] = A[5]

S[6] = A[5] + A[6]

······

可以发现：这颗树是有规律的

S[i] = A[i-2^k+1] + A[i-2^k+2] + ··· + A[i]

其中 k 是 i 在 2 进制下末尾连续 0 的个数

比如 i=4D=100B 则 k=2

那如何求和呢，如要求位置 6 的和，就应该是 S[6]+S[4]

根据上式可以算出每个位置的前缀和 V[i]=S[i]+S[i-2^k1]+S[(i-2^k1)-2^k2]+ ···

新的问题来了： 2^k 怎么求？

有两种方法： i&(i^(i-1)) 和 i&-i ，他们统一叫做 lowbit

lowbit 原理

lowbit 相当于求二进制从末尾到第一个 1 这一段

如 lowbit(1010B)=10B

方法 1

i-1 就是 i 在二进制中从末尾到末尾第一个 1 全部取反

如 20D=10100B 19D=10011B

把它们位异或一下，使得末尾有若干个 1 ，并去掉了前面相同的部分，如 10100B^10011B=00111B

再与原数位与一下，由于除了原数末尾第一个 1 以外都不同，所以其余都是 0

如 10100B&00111B=100B ，就是 lowbit 了

方法 2

然而现实中用的更多还是这个也许这个好记

-x 即为 x 的反码加一

而反码在加一时由于取反了，后面有一段都是 1 ，所以就会一直进位直到遇到 0 并使其变成 1

由于取反了，只有那一位 1 是相同的，这样只要位与一下，只留下那个 1 就行了

树状数组的操作

既然 get 到了精髓，后面的操作也简单了许多

约定

变量名	意义
n	原数组长度
t[]	树状数组

单点修改

上面说了 S[i] = A[i-2^k+1] + A[i-2^k+2] + ··· + A[i]

那既然 A[i] 修改了， S[i+2^k] 、 S[i+2^k+2^k] ··· 都被修改了

inline void add(int p,int v){
    for(;p<=n;p+=p&-p)
        t[p]+=v;
}

单查

前面也给出公式了，直接循环

inline int sum(int p){
    register int ans=0;
    for(;p;p-=p&-p)
        ans+=t[p];
    return ans;
}

区查

有了前缀和自然可以求区间和

直接返回sum(r)-sum(l-1)

例题

单修 + 区查

洛谷 P3374

前面已经讲过了

#include<bits/stdc++.h>
using namespace std;
inline char nc(){
    static char buf[100000],*S=buf,*T=buf;
    return S==T&&(T=(S=buf)+fread(buf,1,100000,stdin),S==T)?EOF:*S++;
}
inline int read(){
    static char c=nc();register int f=1,x=0;
    for(;c>'9'||c<'0';c=nc()) c==45?f=-1:1;
    for(;c>'/'&&c<':';c=nc()) x=(x<<3)+(x<<1)+(c^48);
    return x*f;
}
char fwt[100000],*ohed=fwt;
const char *otal=ohed+100000;
inline void pc(char ch){
    if(ohed==otal) fwrite(fwt,1,100000,stdout),ohed=fwt;
    *ohed++=ch;
}
inline void write(int x){
    if(x<0) pc('-'),x=-x;
    if(x>9) write(x/10);
    pc(x%10+'0');
}
int n,m,opt,x,y,t[500002];
inline void add(int p,int v){
    for(;p<=n;p+=p&-p)
        t[p]+=v;
}
inline int sum(int p){
    register int ans=0;
    for(;p;p-=p&-p)
        ans+=t[p];
    return ans;
}
int main(){
    n=read(),m=read();
    for(register int i=1;i<=n;i++){
        x=read();
        add(i,x);
    }
    while(m--){
        opt=read(),x=read(),y=read();
        if(opt==1) add(x,y);
        else write(sum(y)-sum(x-1)),pc('\n');
    }
    fwrite(fwt,1,ohed-fwt,stdout);
}

区改 + 单查

虽然看上去没大变化，但是如果按照之前的思路，复杂度为 \(O(mn\ log\ n)\) ，比普通数组还差

所以需要运用差分的思想，设 d[i] 为 a[i] 的差分数组，且 d[i]=a[i]-a[i-1]

那么 \(a_i = \sum\limits_{j=1}^i d_j\)

因为是单点查询，所以我们考虑直接维护 d 这个数组的前缀和

怎么区间修改？运用差分思想，可以先从 l 开始加上那个值，再从 r 开始减去那个值，最后求和时就相当于区间修改了

洛谷 P3368

#include<bits/stdc++.h>
using namespace std;
inline char gc(){
    static char buf[100000],*S=buf,*T=buf;
    return S==T&&(T=(S=buf)+fread(buf,1,100000,stdin),S==T)?EOF:*S++;
}
inline int read(){
    static char c=gc();register int f=1,x=0;
    for(;c>'9'||c<'0';c=gc()) c==45?f=-1:1;
    for(;c>'/'&&c<':';c=gc()) x=(x<<3)+(x<<1)+(c^48);
    return x*f;
}
char fwt[100000],*ohed=fwt;
const char *otal=ohed+100000;
inline void pc(char ch){
    if(ohed==otal) fwrite(fwt,1,100000,stdout),ohed=fwt;
    *ohed++=ch;
}
inline void write(int x){
    if(x<0) x=-x,pc('-');
    if(x>9) write(x/10);
    pc(x%10+'0');
}
int n,m,opt,x,y,k,lst,t[500002];
inline void add(int p,int v){
    for(;p<=n;p+=p&-p)
        t[p]+=v;
}
inline int sum(int p){
    register int ans=0;
    for(;p;p-=p&-p)
        ans+=t[p];
    return ans;
}
int main(){
    n=read(),m=read();
    for(register int i=1;i<=n;i++){
        x=read();
        add(i,x-lst);
        lst=x;
    }
    while(m--){
        opt=read(),x=read();
        if(opt==1){
            y=read(),k=read();
            add(x,k),add(y+1,-k);
        }
        else write(sum(x)),pc('\n');
    }
    fwrite(fwt,1,ohed-fwt,stdout);
}

区改 + 区查

还是运用差分思想，但是如何在差分数组中求前缀和呢？

已知 \(sum_i = \sum\limits_{j=1}^i a_j\)

把 a[j] 换成差分数组，得到 \(sum_i = \sum\limits_{j=1}^i \sum\limits_{k=1}^j d_k\)

可以看出每个元素出现的次数是递减的，变换一下，得 \(i*(d_1+d_2+d_3+···)-(0*d_1+1*d_2+2*d_3+···)\)

写成求和公式： \((i*\sum\limits_{j=1}^i d_j)-(\sum\limits_{j=1}^i (j-1)*d_j)\)

这时我们发现：后面那一部分可以用树状数组存下来，快速求和

洛谷 P3372

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
inline char gc(){
    static char buf[100000],*S=buf,*T=buf;
    return S==T&&(T=(S=buf)+fread(buf,1,100000,stdin),S==T)?EOF:*S++;
}
inline ll read(){
    static char c=gc();register ll f=1,x=0;
    for(;c>'9'||c<'0';c=gc()) c==45?f=-1:1;
    for(;c>'/'&&c<':';c=gc()) x=(x<<3)+(x<<1)+(c^48);
    return x*f;
}
char fwt[100000],*ohed=fwt;
const char *otal=ohed+100000;
inline void pc(char ch){
    if(ohed==otal) fwrite(fwt,1,100000,stdout),ohed=fwt;
    *ohed++=ch;
}
inline void write(ll x){
    if(x<0) x=-x,pc('-');
    if(x>9) write(x/10);
    pc(x%10+'0');
}
ll x,y,ls,rs,tmp,t1[100005],t2[100005];
int n,m,opt,lst,k;
inline void add(int p,int v,ll t[]){
    for(;p<=n;p+=p&-p)
        t[p]+=v;
}
inline ll sum(int p,ll t[]){
    ll ans=0;
    for(;p;p-=p&-p)
        ans+=t[p];
    return ans;
}
int main(){
    n=read(),m=read();
    for(register int i=1;i<=n;i++){
        x=read(),tmp=x-lst;
	add(i,tmp,t1);
	add(i,tmp*(i-1),t2);
	lst=x;
    }
    while(m--){
        opt=read(),x=read(),y=read();
        if(opt==1){
            k=read();
	    add(x,k,t1);
	    add(x,k*(x-1),t2);
	    add(y+1,-k,t1);
	    add(y+1,-k*y,t2);
        }
	else{
	    rs=y*sum(y,t1)-sum(y,t2);
	    ls=(x-1)*sum(x-1,t1)-sum(x-1,t2);
	    write(rs-ls),pc('\n');
	}
    }
    fwrite(fwt,1,ohed-fwt,stdout);
}

高级操作

代替平衡树

你没看错，树状数组可以代替平衡树

这时我们的 t[] 维护的就是数字的个数。

sum 便是 x 的排名

加入 x 直接add(x,1);，删除 x 直接add(x,-1);

求出第 k 大

可以直接二分

int kth(int k){
    int l=1,r=n,mid;
    while(l<r){
        mid=(l+r)/2;
        if(sum(mid)<k) l=mid+1;
        else r=mid;
    }
    return r;
}

或者通过倍增进行差分（比二分快许多）

int kth(int k){
    int ans=0;
    for(int i=30;i>=0;i--){
        ans+=(1<<i);
        if(ans>n||t[ans]>=k)ans-=(1<<i);
        else k-=t[ans];
    }
    return ++ans;
}

前驱

就是排名为 x-1 （小一点点）的数

kth(sum(x-1))

后继

就是排名比 x 大一的数

kth(sum(x)+1)

例题

洛谷 P3369

要注意一点：输入有负数，每输入一个就把它加上 10⁷ ，输出时减去 10⁷ ，那么 n 就应该是 2*10⁷

#include<bits/stdc++.h>
using namespace std;
inline char gc(){
    static char buf[100000],*S=buf,*T=buf;
    return S==T&&(T=(S=buf)+fread(buf,1,100000,stdin),S==T)?EOF:*S++;
}
inline int read(){
    static char c=gc();register int f=1,x=0;
    for(;c>'9'||c<'0';c=gc()) c==45?f=-1:1;
    for(;c>'/'&&c<':';c=gc()) x=(x<<3)+(x<<1)+(c^48);
    return x*f;
}
char fwt[100000],*ohed=fwt;
const char *otal=ohed+100000;
inline void pc(char ch){
    if(ohed==otal) fwrite(fwt,1,100000,stdout),ohed=fwt;
    *ohed++=ch;
}
inline void write(int x){
    if(x<0) x=-x,pc('-');
    if(x>9) write(x/10);
    pc(x%10+'0');
}
int T,opt,x,t[20000001],sz,n;
void add(int p,int v){
    for(;p<=n;p+=(p&-p))
        t[p]+=v;
}
int sum(int p){
    int ans=0;
    for(;p;p-=(p&-p))
        ans+=t[p];
    return ans;
}
int kth(int k){
    int ans=0;
    for(int i=30;i>=0;i--){
        ans+=(1<<i);
        if(ans>n||t[ans]>=k) ans-=(1<<i);
        else k-=t[ans];
    }
    return ++ans;
}
//int kth(int k){
//    int l=1,r=n,mid;
//    while(l<r){
//        mid=(l+r)/2;
//        if(sum(mid)<k) l=mid+1;
//        else r=mid;
//    }
//    return r;
//}
int main(){
    n=20000000;
    T=read();
    while(T--){
        opt=read(),x=read();
        if(opt!=4) x+=10000000;
        if(opt==1) add(x,1);
        else if(opt==2) add(x,-1);
        else if(opt==3) write(sum(x-1)+1),pc('\n');
        else if(opt==4) write(kth(x)-10000000),pc('\n');
        else if(opt==5) write(kth(sum(x-1))-10000000),pc('\n');
        else write(kth(sum(x)+1)-10000000),pc('\n');
    }
    fwrite(fwt,1,ohed-fwt,stdout);
}

求逆序对数

同样，我们用 t[] 维护数字的个数

那么，对于第 i 个数 x ，逆序对数就是 i-sum(x)

离散化

如果直接维护，输入的数据较大（如 10⁹ ），空间无法开那么大

所以可以定义一个结构体， val 表示数， id 表示下标

按照 val 从小到大排序， id 作为第二关键字，排完序后发现： id 等效与 val

这样空间只需开元素数量个

例题

洛谷 P1908

由于 add 的值始终是 1 ，所以简化了 add 函数

#include<bits/stdc++.h>
#define N 500005
using namespace std;
typedef long long ll;
inline char gc(){
    static char buf[100000],*S=buf,*T=buf;
    return S==T&&(T=(S=buf)+fread(buf,1,100000,stdin),S==T)?EOF:*S++;
}
inline int read(){
    static char c=gc();register int f=1,x=0;
    for(;c>'9'||c<'0';c=gc()) c==45?f=-1:1;
    for(;c>'/'&&c<':';c=gc()) x=(x<<3)+(x<<1)+(c^48);
    return x*f;
}
struct opt{
    int val,id;
    bool operator < (const opt &x) const
    {
        if(val==x.val) return id<x.id;
        return val<x.val;
    }
    bool operator > (const opt &x) const
    {
        if(val==x.val) return id>x.id;
	return val>x.val;
    }
}x[N];
void qs(int l,int r){
    int i=l,j=r;
    opt mid=x[rand()%(r-l)+l];
    while(i<=j){
        while(x[i]<mid) i++;
	while(x[j]>mid) j--;
	if(i<=j){
            swap(x[i],x[j]);
            i++,j--;
        }
    }
    if(i<r) qs(i,r);
    if(j>l) qs(l,j);
}
int n,t[N];
ll s;
inline void add(int p){
    for(;p<=n;p+=p&-p)
        t[p]++;
}
inline ll sum(int p){
    ll ans=0;
    for(;p;p-=p&-p)
        ans+=t[p];
    return ans;
}
int main(){
    n=read();
    for(register int i=1;i<=n;i++){
        x[i].val=read();
        x[i].id=i;
    }
    if(n>1) qs(1,n);
    for(register int i=1;i<=n;i++){
        add(x[i].id);
        s+=i-sum(x[i].id);
    }
    printf("%lld",s);
}

---

---

The End