树状数组的理解以及简单应用

 

树状数组的应用其实就是一个巧妙地运用了二进制运算来进行 logn 插入、 logn 查询 的 前缀和 算法。

 

原理分析：

假设有 9 个数字组成的数组：

 A[] = 1  2  5  4  3  7  8  6  9

我们使得树状数组 c[] 以以下方法存储：

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]

C[9] = A[9]

这样我们是看不出来咋存滴，我们先写成 二进制 再来看看：

C[1] = A[1]

C[10] = A[1] + A[2]

C[11] = A[3]

C[100] = A[1] + A[2] + A[3] + A[4]

C[101] = A[5]

C[110] = A[5] + A[6]

C[111] = A[7]

C[1000] = A[1] + A[2] + A[3] + A[4] + A[5] + A[6] + A[7] + A[8]

C[1001] = A[9]

重点来了，现在我们来构造 C 数组 ，我们观察 A[] 在哪里出现过：

A[1] →→  C[1] 、C[10] 、 C[100] 、C[1000]

A[2] →→  C[10] 、C[100] 、C[1000]

A[3] →→  C[11] 、C[100] 、C[1000]

A[4] →→  C[100] 、C[1000]

A[5] →→  C[110] 、C[1000]

A[6] →→  C[110] 、C[1000]

......           ..........................

好我现在告诉你啥规律~

比如我们来看 A[3] ： 3 的二进制是 1 1 ，它先对自己的 C[3（11）] 有贡献，故 C[3] += A[3] 。然后 A[3] 再对 C[4（110）] 有贡献，故 C[4] += A[3] 。同样，它还对 C[8（1000）] 有贡献，即 C[8] += A[3] 。

那 3 是如何一步一步转化成 4 、8 的呢？

3 的二进制是 1 1    1 1 保留它最低位的 1 ，其它位的 1 去掉（即变为 0），则有：0 1 ，然后使 1 1 加上 0 1 → 1 0 0 （即 4）

4 的二进制是 1 0 0    1 0 0 保留它最低位的 1，则有：1 0 0 ，然后使 1 0 0 加上 1 0 0 → 1 0 0 0（即 8）

其他什么，A[1] 、A[2] ......同理，大家可以试着写一下

 

那么 “ 保留它最低位的 1 ，其它位的 1 去掉（即变为 0）” 这句话所变成的二进制，再转化为十进制数的值，如何求呢？

 这里需要一个 自定义的 lowbit 函数，这个函数可以得出上面问题的答案：

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

 

故我们可以构造出树状数组了~（实现看注释）

 

inline void update(int x,ll k)  // x 表示 c[i] 中的 i ，k 表示 为当前 c[x] 贡献的值
{
    while(x<=n){ //当然超出 c 数组长度的，就不需要构造。比如 x=3 x=4 x=8 然后再到 x=16 ，16我们就不要存了，因为题目我只需要 C[1] 到 C[9] 的值
        c[x]+=k;
        x+=lowbit(x); // 比如上面的例子A[3]，这样写就可以使得 x=3 转化为 x=4 x=8 ，然后 c[4]+= A[3] ,c[8]+= A[3] 了
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
        update(i,a[i]);
    }
}

 

 

那么构造出了 C数组，如何求出前缀和的呢？

比如现在要知道

A[1] + A[2] + A[3] + A[4] + A[5] 的值：  C[5] + C[4]  ， 5 的二进制： 1 0 1 ， 4 的二进制： 1 0 0 ，差 0 0 1 

A[1] + A[2] + A[3] + A[4] + A[5] + A[6] 的值： C[6] + C[4] ， 6 的二进制： 1 1 0 ，4 的二进制： 1 0 0 ，差 0 1 0 

那 A[1] + A[2] + ..... + A[9] 的值： C[8] + C[9] ， 9 的二进制： 1 0 0 1 ， 8的二进制： 1 0 0 0 ，差 0 0 0 1

 

而现在我们可以观察到：

5 与 4 的差值为 5 - lowbit（5）

6 与 4 的差值为 6 - lowbit（6）

9 与 8 的差值为 9 - lowbit（9）

跟构造 C 数组一样，每次用 ans += C[x] ，然后 x-=lowbit（x） ，直到 x 自己减自己，为 0 时结束，这样我就能得到 1 ~ x 的前缀和了~

ll query(int x)
{
    ll ans=0;
    while(x){
        ans+=c[x];
        x-=lowbit(x);
    }
    return ans;
}

 

到这里，树状数组的板子就完成了~ 总代码在这：

#include<iostream>
#include<algorithm>
#include<string.h>
#define maxn 500008
using namespace std;
typedef long long ll;
int n;
ll a[maxn],c[maxn];
ll lowbit(ll x){return x&(-x);}
inline void update(int x,ll k)
{
    while(x<=n){
        c[x]+=k;// 依次把 k 加入到能贡献的 C 中
        x+=lowbit(x); // x 往上移
    }
}
ll query(int x)
{
    ll ans=0;
    while(x){
        ans+=c[x]; // 通过累加获得前缀和
        x-=lowbit(x);    // x 往下移
    }
    return ans;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
        update(i,a[i]);    //将 a[i] 所能提供的贡献，加入到 C 数组中
    }
    for(int i=1;i<=n;i++){ // 依次求前缀和
        printf("%lld ",query(i) );
    }
    cout<<endl;
}

树状数组

 

例题1：洛谷  P3374

该题是 树状数组的 单点修改、区间查询的模板题。

由于我们是通过存储每个数，然后把每个数贡献给 C ，然后统计 C 的总和，得出前缀和的。

1、所以当单点修改加上 p ，我们只需要将这个点再次加上 p 就可以了，是不是很方便~

2、现在我们可以知道所有 1 ~ n 的前缀和了，那么区间 l ~ r 总和不就是 1 ~ r 的前缀和 减去 1 ~ l -1  的前缀和吗（注意：这里不是 1 ~ l ，因为前缀和 1 ~ l 的值中包含了 A[l] ，如果减去的是 1 ~ l，那么会减去 A[l] 导致答案不正确）

代码如下：

#include<iostream>
#include<algorithm>
#include<string.h>
#define maxn 500008
using namespace std;
typedef long long ll;
int n,m;
ll a[maxn],c[maxn];
ll lowbit(ll x){return x&(-x);}
inline void update(int x,ll k)
{
    while(x<=n){
        c[x]+=k;
        x+=lowbit(x);
    }
}
ll query(int x)
{
    ll ans=0;
    while(x){
        ans+=c[x];
        x-=lowbit(x);
    }
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
        update(i,a[i]);
    }
    int A,B,C;
    while(m--)
    {
        scanf("%d%d%d",&A,&B,&C);
        if(A==1){
            update(B,C);
        }
        else{
            printf("%lld\n",query(C)-query(B-1));
        }
    }
}

P3374

 

例题2：洛谷  P3368

该题是 树状数组的 单点修改、区间查询的模板题。需要用到 “差分” 的概念。

 

差分概念链接

看完差分概念，想必你就可以很轻松 A 这题了~

#include<iostream>
#include<algorithm>
#include<string.h>
#define maxn 500008
using namespace std;
typedef long long ll;
int n,m;
ll a[maxn],c[maxn];
ll lowbit(ll x){return x&(-x);}
inline void update(int x,ll k)
{
    while(x<=n){
        c[x]+=k;
        x+=lowbit(x);
    }
    return;
}
inline ll query(int x)
{
    ll ans=0;
    while(x){
        ans+=c[x];
        x-=lowbit(x);
    }
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
        update(i,a[i]-a[i-1]);
    }
    int A,B,C,D;
    while(m--)
    {
        scanf("%d%d",&A,&B);
        if(A==1){
            scanf("%d%d",&C,&D);
            update(B,D),update(C+1,-D);
        }
        else printf("%lld\n",query(B));
    }
}

P3368

 

例题3：洛谷  P1908

 

该题是 树状数组求 逆序对数 的模板题。

我们先不用树状数组，先用单单的前缀和思想，来求解逆序数。

例如数组 A[] = 1  4  5  3  2

然后我们模拟出一个标记数组 B ，来表A[i] 是否出现，出现则使 B[ A[i] ] 等于 1 。一开始初始化为 0 即可。

1	2	3	4	5
0	0	0	0	0

来模拟一遍~

A[1] = 1 ，即 1 出现过，使得 B[1] = 1。 下标 1 表示 A[1] 实际出现位置，A[1] 表示在 1、2、3、4.....中实际位置。1 的前缀和为 1 （包括自己）

1	2	3	4	5
1	0	0	0	0

A[2] = 4 ，即 4 出现过，使得 B[4] = 1。下标 2 表示 A[2] 实际出现位置，A[2] 表示在 1、2、3、4.....中实际位置。4 的前缀和为 2 （包括自己）

1	2	3	4	5
1	0	0	1	0

A[3] = 5 ，即 5 出现过，使得 B[5] = 1 。下标 3 表示 A[3] 实际出现位置，A[3] 表示在 1、2、3、4.....中实际位置。5 的前缀和为 3 （包括自己）

1	2	3	4	5
1	0	0	1	1

A[4] = 3 ，即 3 出现过，使得 B[3] = 1 。下标 4 表示 A[4] 实际出现位置，A[4] 表示在 1、2、3、4.....中实际位置。3 的前缀和为 2 （包括自己）

1	2	3	4	5
1	0	1	1	1

 

诶！重点的来了！你看，下标为 4 ，但是此时 A[4] = 3 ，它的前缀和是 2 ，小于了 4 ！这里说明有 4 - 2 个 逆序对，即 （5，3） 和 （4，3）！

原因：

我们是使 A[i] 出现过后，标记它出现过。i 为A[i] 的真正位置，而 A[i] 才为它的实际位置。

现在 i 都到 4 了，说明除了 3 自己之外，应该还有 3 个数已经被标记，由于都是以 1 作标记，所以此时 A[i] = 3 它前面仅有 1 个数 1 才被标记过，说明有 2 个数不在 3 的前面呀，那就是说明这两个数都比 3 大，而且在 3 之前就出现过~

那么很容易的，我们得到以 （P，3） 为逆序对的个数为： i - S（3）     （S（3）表示 3 的前缀和， P > 3）

你可以理解成： i 为已经被标记过的总数，由于都是用 1 标记，所以S（3）表示有多少个小于 3 的数出现过，那么 i - S（3） 就是那些出现过的但大于 3 的数了~

嗯求前缀和，用树状数组！

但是这题还需要用到离散化。

那么用到离散化求逆序数的话，就有一个很大的问题！

如果用 sort 排序，由于 sort 为不稳定排序，会导致相同的数，位置发生调换。

比如 A[] = 1 4 4 2 ，很明显，离散化后的顺序应该是： 1  3  4  2 ，而不能是 1  4  3  2 。否则会多出一个 （4，3）的逆序对，导致答案不符。

所以我们只需要更早出现的，sort 更早标记就行了~

代码如下：

 

#include<iostream>
#include<algorithm>
#include<string.h>
#define maxn 500008
using namespace std;
typedef long long ll;
int n;
int a[maxn];
ll c[maxn];
struct Node
{
    int id;
    ll val;
}A[maxn];
inline int lowbit(int x){return x&(-x);}
bool cmp(const Node q,const Node w){
    if(q.val==w.val) return q.id<w.id;
    return q.val<w.val;
}
inline void update(int x,int k)
{
    while(x<=n){
        c[x]+=k;
        x+=lowbit(x);
    }
    return;
}
inline ll query(int x)
{
    ll ans=0;
    while(x){
        ans+=c[x];
        x-=lowbit(x);
    }
    return ans;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%lld",&A[i].val);
        A[i].id=i;
    }
    sort(A+1,A+n+1,cmp);
    for(int i=1;i<=n;i++)  a[A[i].id]=i;
    ll ans = 0;
    for(int i=1;i<=n;i++){
        update(a[i],1);
        ans+=i-query(a[i]);
    }
    printf("%lld\n",ans );
}

P1908

 

转载于:https://www.cnblogs.com/Absofuckinglutely/p/11341396.html