树状数组

  给定一个区间，如果要频繁修改该区间内的元素，且频繁查询该区间内任意小区间的元素之和时，可以用树状数组。

普通的一次修改时间复杂度是O(1)，而查询的时间复杂度是O(n). 树状数组的修改和查询的时间复杂度均为O(logn)

给定区间1-->n，区间内对应的元素为a[i] (1 <= i <= n )

树状数组是这样一个数组c

c[i] = a[i - 2^k + 1]  + ... + a[i] ,  k 为i在二进制下末尾0的个数（所以树状数组不能从0开始，只能从1开始)，也即2^k是i在二进制下，第一个不为0的bit所表示的大小

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

lowbit(t); 的作用是求出t在二进制下，第一个不为0的bit所表示的大小
4(10) = 0000 0100(2)     lowbit(4) = 4;
-4(10) = 1111 1100(2)    4&(-4) = 0000 0100
5(10) = 0000 0101(2)    lowbit(5) = 1
-5(10) = 1111 1011(2)    5&(-5) = 0000 0001

 

如果，当要修改一个元素a[pos]时，就要修改c[pos]及其c[pos]的父亲，c[pos]父亲的父亲，即c[pos]往根结点一路上溯，不断修改c[]即可

c[pos]的父结点的下标为 pos += lowbit(pos)

void modify(int pos, int val)//当a[pos]发生改变时
{
    while(pos <= n)
    {
        c[pos] += val;//c[pos] 肯定包含a[pos] ,但是之后的c数组，哪个又包含a[pos]呢
        pos += lowbit(pos);//c[pos]的父结点的下标为 pos += lowbit(pos)
    }
}

 如图，如果求前n项的和，比如n=6时，c[6] = a[5] + a[6],c[6]包含lowbit(6)项，即2项，所以还要求得前4项的和，即n-=lowbit(n)

int getSum(int pos)
{
    int sum = 0;
    while(pos >= 1)
    {
        sum += c[pos];
        pos -= lowbit(pos);
    }
    return sum;
}

 hdu1166敌兵布阵  http://acm.hdu.edu.cn/showproblem.php?pid=1166

#include <stdio.h>
#include <string.h>
const int N = 50000 + 10;
int c[N], n;
int lowbit(int t)
{
    return t&(-t);
}
void modify(int pos, int val)//当a[pos]发生改变时
{
    while(pos <= n)
    {
        c[pos] += val;//c[pos] 肯定包含a[pos] ,但是之后的c数组，哪个又包含a[pos]呢
        pos += lowbit(pos);//c[pos]的父结点的下标为 pos += lowbit(pos)
    }
}
int getSum(int pos)
{
    int sum = 0;
    while(pos >= 1)
    {
        sum += c[pos];
        pos -= lowbit(pos);
    }
    return sum;
}
int main()
{
    int t, val, a, b, i, tCase = 1;
    char op[10];
    scanf("%d",&t);
    while(t--)
    {
        memset(c, 0, sizeof(c));
        scanf("%d",&n);
        for(i=1; i<=n; ++i)
        {
            scanf("%d",&val);
            modify(i, val);
        }
        printf("Case %d:
",tCase++);
        while(true)
        {
            scanf("%s",op);
            if(op[0] == 'E')
                break;
            if(op[0] == 'Q')
            {
                scanf("%d%d",&a,&b);
                int ans = getSum(b);
                if(a - 1 >= 1)
                    ans -= getSum(a-1);
                printf("%d
",ans);
            }
            else if(op[0] == 'A')
            {
                scanf("%d%d",&a,&b);
                modify(a, b);
            }
            else
            {
                scanf("%d%d",&a,&b);
                modify(a, -b);
            }
        }

    }
    return 0;
}

 蓝桥杯 小朋友排队 http://lx.lanqiao.org/problem.page?gpid=T123

只要算出每个小朋友要移动的次数，那么就能算出不开心的程度。从而算出总的不开心程度。

每个小朋友要移动的次数等于，左边大于它的数字的个数和右边小于它的数字的个数。即逆序数，

如果用暴力，时间复杂度是O(N*N)。     逆序数可以用树状数组求，时间复杂度是O(N*logN）

#include <stdio.h>
#include <string.h>
typedef __int64 LL;
const int N = 100000 + 10;    
const int M = 1000000 + 10;
LL c[M+1],n,unHappy[N],a[N],b[N];
void init()    
{
    for(int i=1; i<N; ++i)
        unHappy[i] = unHappy[i-1] + i;
}
int lowbit(int x)
{
    return x&-x;
}
void modify(int pos, int val)
{
    while(pos<=M)
    {
        c[pos] += val;
        pos += lowbit(pos);
    }

}
int sum(int pos)
{
    int ret = 0;
    while(pos)
    {
        ret += c[pos];
        pos -= lowbit(pos);
    }
    return ret;
}
int main()
{
    init();
    scanf("%d",&n);
    LL i,x,ans = 0;
    for(i=1; i<=n; ++i)
    {
        scanf("%I64d",&a[i]);
        a[i]++;
        b[i] += sum(M) - sum(a[i]);
        modify(a[i],1);
    }
    memset(c,0,sizeof(c));
    for(i=n; i>=1; --i)
    {
        b[i] += sum(a[i]-1);
        modify(a[i],1);
        ans += unHappy[b[i]];
    }
    printf("%I64d
",ans);
    return 0;
}

扩展---二维树状数组 

一维树状数组很容易扩展到二维，二维树状数组如下所示：

C[x][y] = sum(A[i][j])

其中，x-lowbit[x]+1 <= i<=x且y-lowbit[y]+1 <= j <=y

http://acm.fafu.edu.cn/problem.php?id=1100

一个由数字构成的大矩阵，能进行两种操作

1) 对矩阵里的某个数加上一个整数（可正可负）

2) 查询某个子矩阵里所有数字的和

要求对每次查询，输出结果

要求矩形（L,B)左上角的坐标，(R,T)右下角的坐标

树状数组的getSum(R,t)函数是获得(1,1)到(R,T)的所有元素和，所以要减去getSum(L,B-1), 减去getSum(L-1,T) ，然后加上getSum(L-1,B-1)

树状数组解法：

#include <stdio.h>
#include <string.h>
const int N = 1024 + 10;
int c[N][N], n;
void init()
{
    for(int i=0; i<=n; ++i)
        for(int j=0; j<=n; ++j)
            c[i][j] = 0;
}
int lowbit(int t)
{
    return t & (-t);
}
void modify(int x, int y, int val)
{
    for(int i=x; i<=n; i+=lowbit(i))
        for(int j=y; j<=n; j+=lowbit(j))
            c[i][j] += val;
}
int getSum(int x, int y)
{
    int ans = 0;
    for(int i=x; i>=1; i-=lowbit(i))
        for(int j=y; j>=1; j-=lowbit(j))
            ans += c[i][j];
    return ans;
}
int main()
{
    int op,x, y, a, l, b, r, t;
    while(scanf("%d%d",&x,&n)!=EOF)
    {
        init();
        while(scanf("%d",&op) && op != 3)
        {
            switch(op)
            {
            case 1:
                scanf("%d%d%d",&x,&y,&a);
                ++x; ++y;
                modify(x, y, a);
                break;
            case 2:
                scanf("%d%d%d%d",&l,&b,&r,&t);
                ++l; ++b; ++r; ++t;
                printf("%d
",getSum(r,t) + getSum(l-1,b-1) - getSum( r,b-1 )-getSum(l-1,t) ); 
                break;
            }
        }
    }
    return 0;
}

线段树解法:

/*
0 4
1 1 2 3
2 0 0 2 2
1 1 1 2
1 1 2 -1
2 1 1 2 3
3
多重二分--->线段树的每个结点也是一颗树
将x二分，每次将x二分的情况下再将y二分
*/
//#define _CRT_SECURE_NO_DEPRECATE
#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;
typedef __int64 LL;
const int N = 1024 + 10;
int sum[N * 3][N * 3];
int n,op, x, y, v, L,B,R,T;
LL ans;
void sub_update(int f, int sLoc, int val, int l, int r, int rt)
{
    if(l == r)
    {
        sum[f][rt] += val;
        return;
    }
    int mid = (l + r) >> 1;
    if(sLoc <= mid)
        sub_update(f, sLoc, val, l, mid, rt<<1);
    else
        sub_update(f, sLoc, val, mid+1, r, rt<<1|1);
    sum[f][rt] = sum[f][rt<<1] + sum[f][rt<<1|1];
}
void update(int fLoc, int sLoc, int val, int l, int r, int rt)
{
    sub_update(rt, sLoc, val, 1, n, 1);
    if(l == r)
        return;
    int mid = (l + r) >> 1;
    if(fLoc <= mid)
        update(fLoc, sLoc, val, l ,mid, rt<<1);
    else
        update(fLoc, sLoc, val, mid+1, r, rt<<1|1);
}

LL sub_query(int f, int sL, int sR, int l, int r, int rt)
{
    if(sL == l && sR == r)
        return sum[f][rt];
    int mid = (l + r) >> 1;
    LL ret = 0;
    if(sR <= mid)
        ret += sub_query(f, sL, sR, l, mid, rt<<1);
    else if(sL > mid)
        ret += sub_query(f, sL, sR, mid+1, r, rt<<1|1);
    else
    {
        ret += sub_query(f, sL, mid, l, mid, rt<<1);
        ret += sub_query(f, mid+1, sR, mid+1, r, rt<<1|1);
    }
    return ret;
}
LL query(int fL, int fR, int sL, int sR, int l, int r, int rt)
{
    if(fL == l && fR == r)
        return sub_query(rt, sL, sR, 1, n, 1);
    int mid = (l + r) >> 1;
    LL ret = 0;
    if(fR <= mid)
        ret += query(fL, fR, sL, sR, l, mid, rt<<1);
    else if(fL > mid)
        ret += query(fL, fR, sL, sR, mid+1, r, rt<<1|1);
    else
    {
        ret += query(fL, mid, sL, sR, l, mid, rt<<1);
        ret += query(mid+1, fR, sL, sR, mid+1, r, rt<<1|1);
    }
    return ret;
}
void input(int &x)
{
    char ch = getchar();
    bool flag = ch == '-';
    while(ch<'0' || ch>'9')
    {
        ch = getchar();
        if(ch == '-')
            flag = true;
    }
    x = 0;
    while(ch>='0' && ch<='9')
    {
        x = x * 10 + ch -'0';
        ch = getchar();
    }
    x = flag ? -x : x;
}
int main()
{
    while(scanf("%d%d",&op,&n)!=EOF)
    {
        ++n;
        memset(sum, 0, sizeof(sum));
        while(true)
        {
            //scanf("%d",&op);
            input(op);
            if(op == 1)
            {
                //scanf("%d%d%d",&x,&y,&v);
                input(x);input(y);input(v);
                ++x; ++y;
                update(x, y, v, 1, n, 1);
            }
            else if(op == 2)
            {
                input(L);input(B);input(R);input(T);
                //scanf("%d%d%d%d",&L,&B,&R,&T);
                ++L; ++B; ++R; ++T;
                printf("%I64d
",query(L, R, B, T, 1, n, 1));
            }
            else
                break;
        }
    }
}

 二维线段树入门：http://wenku.baidu.com/view/bdc5eb0216fc700aba68fc05.html