树状数组总结

树状数组还是挺方便的，代码短功能也强大，完全可以用来替代一部分线段树的功能

有三种用法

一是对于单点更新，区间查询的

//hdu 1166
#include <stdio.h>
#include <string.h>
#include <iostream>

using namespace std;

int n,t;
int a[50008];
int tree[50008];

void add(int x,int num)
{
    while(x<=n)
    {
        tree[x]+=num;
        x+=x&-x;
    }
}

int read(int x)
{
    int sum = 0;
    while(x)
    {
        sum+=tree[x];
        x-=x&-x;
    }
    return sum;
}

int main()
{
    string tmp;
    int b,c;
    scanf("%d",&t);
    for(int j = 1;j<=t;j++)
    {
        memset(tree,0,sizeof(tree));
        scanf("%d",&n);
        printf("Case %d:
",j);
        for(int i = 1;i<=n;i++)
        {
             scanf("%d",&a[i]);
             add(i,a[i]);
        }

        while(cin>>tmp,tmp!="End")
        {
            if(tmp=="Query")
            {
                scanf("%d%d",&b,&c);
                printf("%d
",read(c)-read(b-1));
            }else if(tmp=="Add")
            {
                scanf("%d%d",&b,&c);
                add(b,c);
            }else if(tmp=="Sub")
            {
                scanf("%d%d",&b,&c);
                add(b,-c);
            }
        }
    }
    return 0;
}

二是对于单点更新，但是查询区间最大最小值的

//hdu 1754
#include <stdio.h>
#include <string.h>
#include <iostream>

using namespace std;

int n,m;
int a[200008];
int tree[200008];

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

void update(int x)
{
    while(x<=m)
    {
        tree[x]=a[x];
        for(int i=1;i<lowbit(x);i<<=1)
            tree[x]=max(tree[x],tree[x-i]);
        x+=lowbit(x);
    }
    return ;
}
int query(int x, int y)
{
    int ans = 0;
    while (y >= x)
    {
        ans = max(a[y], ans);
        y --;
        for (; y-lowbit(y) >= x; y -= lowbit(y))
            ans = max(tree[y], ans);
    }
    return ans;
}

int main()
{
    char tmp;
    int c,d;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        memset(tree,0,sizeof(tree));
        for(int i = 1;i<=m;i++)
        {
            scanf("%d",&a[i]);
            update(i);
        }
        getchar();
        for(int i = 1 ;i <= n;i++)
        {
            scanf("%c%d%d",&tmp,&c,&d);
            if(tmp=='U')
            {
                a[c] = d;
                update(c);
            }
            else if(tmp=='Q')
            {
                printf("%d
",query(c,d));
            }
            getchar();
        }
    }
    return 0;
}

三是对于区间更新，然后区间查询

这个区间更新主要是要用到一个差分数组

我们假设sigma(r，i)表示r数组的前i项和，调用一次的复杂度是log2(i)

设原数组是a[n]，差分数组c[n]，c[i]=a[i]-a[i-1]，那么明显地a[i]=sigma(c,i)，如果想要修改a[i]到a[j](比如+v)，只需令c[i]+=v,c[j+1]-=v

这样c[i]->C[j]便会相当与加了j-i个v

怎么实现“区间修改，区间查询”呢？

观察式子：
a[1]+a[2]+...+a[n]

= (c[1]) + (c[1]+c[2]) + ... + (c[1]+c[2]+...+c[n]) 

= n*c[1] + (n-1)*c[2] +... +c[n]

= n * (c[1]+c[2]+...+c[n]) - (0*c[1]+1*c[2]+...+(n-1)*c[n])  

那么我们就维护一个数组c2[n]，其中c2[i] = (i-1)*c[i]

每当修改c的时候，就同步修改一下c2，这样复杂度就不会改变

那么

式子①

=n*sigma(c,n) - sigma(c2,n)

于是我们做到了在O(logN)的时间内完成一次区间和查询

//poj 3468
#include <stdio.h>
#include <string.h>
#include <iostream>
#define Nmax 200008

using namespace std;

int n,m;
long long a[200008];
long long tree[200008];
long long sum[200008];    //原始的前缀合
long long c1[Nmax];   //前缀和
long long c2[Nmax];   //前缀和*i-1

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

void add(long long *array,long long x,long long num)
{
    while(x<=n)
    {
        array[x] += num;
        x+=x&-x;
    }
}


long long read(long long *array,long long x)
{
    long long sum = 0;
    while(x)
    {
        sum += array[x];
        x-=x&-x;
    }
    return sum;
}

int main()
{
    scanf("%d%d",&n,&m);
    char tmp;
    long long  l,r,q;
    for(int i = 1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
        add(c1,i,a[i]-a[i-1]);
        add(c2,i,(i-1)*(a[i]-a[i-1]));
    }
    getchar();
    for(int i = 1;i<=m;i++)
    {
        scanf("%c",&tmp);
        if(tmp=='C')
        {
            scanf("%lld%lld%lld",&l,&r,&q);
            add(c1,l,q);
            add(c1,r+1,-q);
            add(c2,l,(l-1)*q);
            add(c2,r+1,-q*r);
        }else if(tmp=='Q')
        {
            scanf("%lld%lld",&l,&r);
            long long ans1 = (l-1)*read(c1,l-1)-read(c2,l-1);
            long long ans2 = (r)*read(c1,r)-read(c2,r);
            printf("%lld
",ans2-ans1);
        }
        getchar();
    }
    return 0;
}

四、利用树状数组来求第k小或者第k大

其主要的想法就是利用树状数组来统计每个数出现的次数

然后在通过枚举二进制的方式来进行统计，复杂度是log(n)

详情看代码理解

这个代码是第K大的，如果要求第K小的，那么枚举的时候反过来即可，以及判断条件改一下就OK

如果想取第几名的话，那么改插入的条件，每个值只能插入一次即可。

#include <stdio.h>
#include <string.h>
#define maxn 100000

int tree[maxn],n,k;    //tree是统计次数，每个数字出现的次数

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

void add(int x, int num)
{
    while (x <= maxn)
    {
        tree[x] += num;
        x += lowbit(x);
    }
}

int find(int k)     //找第k大
{
    int cnt = 0, ans = 0;
    for (int i = 20; i >= 0; i--)       //枚举二进制数
    {
        ans += (1 << i);
        if (ans >= maxn|| cnt + tree[ans] >= k)     //如果ans超过最大值或者累加值加起来超过了k，那么说明这个位置的肯定在k的后面
            ans -= (1 << i);
        else
            cnt += tree[ans];     //说明第k肯定在ans的后面
    }
    return ans + 1;
}

void input() {
    memset(tree, 0, sizeof(tree));
    int t;
    scanf("%d%d", &n, &k);
    for (int i = 0; i<n; i++) {
        scanf("%d", &t);
        add(t, 1);                       //t位置的次数加一
    }
    printf("%d/n", find(k));
}