树状数组--基础

树状数组主要用于查询任意两位之间的所有元素之和，但是每次只能修改一个元素的值；经过简单修改可以在log(n)的复杂度下进行范围修改，但是这时只能查询其中一个元素的值。

一、和线段树比较：

1）树状数组能解决的线段树一般都能解决，线段树能解决的树状数组不一定能解决。

2）相比较而言，树状数组效率要高很多。

所以对于单点修改，单点查询来说最好的还是树状数组：

二、函数的基本作用：

1）update是用来修改树状数组的，如果是一般的算法只用修改改点就可，但是树状数组必须修改所有改点被管辖的区间。比如把a数组的 a[2]减去1，（令N=16）；则所有2被管辖的点有4，8，16都应该减去1，就是调用函数 update（2，-1）；

void update(int x,int num)
{
    while(x<=N)
     {
         d[x]+=num;
         x+=lowbit(x);
     }
}

2）求和都是求1~x之间的和，所以区间求和是sum(r) - sum(l)。比如getSum（7）的话，就是求a[1]+a[2]+...a[7]。

int getSum(int x)
{
    int s=0;
    while(x>0)
     {
         s+=d[x];
         x-=lowbit(x);
     }
    return s;
}
三、基础例题：

一维：

#include<stdio.h>
#include<string.h>
#include<math.h>
int a[50005];
int n;
int lowbit(int t)
{
    return t&(-t);
}
void insert(int t,int d)
{
    while(t<=n)
    {
        a[t]+=d;
        t=t+lowbit(t);
    }
}
long long getsum(int t)
{
    long long sum=0;
    while(t>0)
    {
        sum+=a[t];
        t=t-lowbit(t);
    }
    return sum;
}
int main()
{
    int T,i,j,k,t;
    scanf("%d",&T);
    t=0;
    while(T--)
    {
        memset(a,0,sizeof(a));
        scanf("%d",&n);
        for(i=1;i<=n;i++)
        {
            scanf("%d",&k);
            insert(i,k);
        }
        char str[10];
        scanf("%s",str);
        printf("Case %d:
",++t);
        while(strcmp(str,"End")!=0)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            if(strcmp(str,"Query")==0)
            printf("%lld
",getsum(y)-getsum(x-1));
            else if(strcmp(str,"Add")==0)
            insert(x,y);
            else if(strcmp(str,"Sub")==0)
            insert(x,(-1)*y);
            scanf("%s",str);
        }
    }
}

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;

const int MAXN=100010;
int c[MAXN];
int n;

int lowbit(int x)
{
    return x&(-x);
}
void add(int i,int val)
{
    while(i<=n)
    {
        c[i]+=val;
        i+=lowbit(i);
    }
}
int sum(int i)
{
    int s=0;
    while(i>0)
    {
        s+=c[i];
        i-=lowbit(i);
    }
    return s;
}
int main()
{
    int a,b;
    while(scanf("%d",&n),n)
    {
        memset(c,0,sizeof(c));
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            add(a,1);
            add(b+1,-1);
        }
        for(int i=1;i<n;i++)
          printf("%d ",sum(i));
        printf("%d
",sum(n));
    }
    return 0;
}

POJ2352题意：某个星星的左下的星星数目代表它的等级，求0~n-1每个等级的星星数目分别有几个

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 35010;
int c[MAXN];
int tot[MAXN];
int n;
int lowbit(int x)
{
    return x&(-x);
}
int getsum(int i)
{
    int s=0;
    while(i>0)
    {
        s += c[i];
        i -= lowbit(i);
    }
    return s;
}
void add(int li, int val)
{
    while(li<=MAXN)
    {
        c[li] += val;
        li += lowbit(li);
    }
}
int main()
{
    ///找前边有几个x，y都比当前小的
    while(~scanf("%d",&n))
    {
        int x,y;
        memset(c,0,sizeof(c));
        memset(tot,0,sizeof(tot));
        for(int j=1; j<=n; j++)
        {
            scanf("%d%d",&x,&y);
            add(x+1,1);
            tot[getsum(x+1)-1]++;///前边有getsum(x+1)-1个比当前小的数字
        }
        for(int j = 0; j < n ; j++)
            printf("%d
",tot[j]);
    }
    return 0;
}

///逆序对数是求前边有几个比当前更大的数字
///POJ2352  是求前边有几个比当前更小的数字
///按照从大到小排序后求前边有几个次序比他更小的就是逆序对数
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#define ll long long
#define repu(i, a, b) for(int i = a; i < b; i ++)
using namespace std;
const int MAXN = 500010;
ll c[MAXN];
int n;
struct S
{
    int val,pos;
    bool operator < (const S& s) const
    {
        return val > s.val;
    }
} a[MAXN];
int b[MAXN];
int lowbit(int x)
{
    return x&(-x);
}
ll getsum(int i)
{
    ll s = 0;
    while(i>0)
    {
        s += c[i];
        i -= lowbit(i);
    }
    return s;
}
void add(int li)
{
    while(li<=MAXN)
    {
        c[li] += 1ll;
        li += lowbit(li);
    }
}
int main()
{
    ///找前边有几个x，y都比当前小的
    while(scanf("%d",&n),n)
    {
        int x,y,k;
        ll sum = 0;
        memset(c,0,sizeof(c));
        repu(i,0,n)
        {
            scanf("%d",&a[i].val);
            a[i].pos = i + 1;
        }
        sort(a,a+n);
        repu(i,0,n)
        {
            x = a[i].pos;
            add(x);
            sum += getsum(x - 1);
        }
        printf("%I64d
",sum);
    }
    return 0;
}

二维：放了好久了已经，今天打BC突然一道博弈，用到二维区间求和，找线段树模板找不到，真的蒙圈了。

HDU5465：

题意：一个n*m的矩阵，然后两个操作：

1 l1,r1,l2,r2表示选取（l1,r1）到（l2,r2）子矩阵；

2 l r c 单点（l,r）的数改成c；

然后Alice和Bob轮流从选取的矩阵中找一个数字减掉d，直到选取的子矩阵中所有数字为0。问谁最终会赢。

分析：这是个博弈的题，而且当时在天津大学的板子上也找到了解决方法，就是两人从N堆石子中取石子，直到一方不能取。

因为是矩阵，累加时间复杂度太高，因此需要树状数组来减时间复杂度。

由于xor有前缀和性质，所以我们可以用一个二维bit来维护(1, 1)-(a, b)的矩阵的xor和，然后由sum(x2, y2)  xor  sum(x2, y1-1)  xor sum(x1-1, y2)  xor  sum(x1-1, y1-1)sum(x2,y2) xor sum(x2,y1−1) xor sum(x1−1,y2) xor sum(x1−1,y1−1)来得到答案即可。单点修改在bit上是很容易的。

#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
#define ll long long
#define mem(m, a) memset(m, a, sizeof(m))
#define repu(i, a, b) for(int i = a; i < b; i++)
#define MAXN 100005
const double PI=-acos(-1.0);
using namespace std;
int num[510][510];
int p[510][510];
int lowbit(int x)
{
    return x&(-x);
}
///更新
int n,m;
void  add(int x,int y,int val)
{
    for(int i=x; i<=n; i+=lowbit(i))
    {
        for(int j=y; j<=m; j+=lowbit(j))
        {
            num[i][j] ^= val;
        }
    }
}
///区间求和,不过是（1,1）到（x,y）
int query(int x,int y)
{
    int ans=0;
    for(int i=x; i>0; i-=lowbit(i))
    {
        for(int j=y; j>0; j-=lowbit(j))
        {
            ans ^= num[i][j];
        }
    }
    return ans;
}
int main()
{
    int op;
    int a,b,c,d,q;
    int T;
    scanf("%d", &T);
    while(T--)
    {
        mem(num,0);
        scanf("%d%d%d",&n, &m, &q);
        repu(i, 1, n + 1)
        repu(j, 1, m + 1)
        {
            scanf("%d", &p[i][j]);
            add(i,j,p[i][j]);
        }
        while(q--)
        {
            scanf("%d",&op);
            if(op == 1)
            {
                scanf("%d%d%d%d",&a,&b,&c,&d);
                int t = query(c,d)^query(a-1,b-1)^query(a-1,d)^query(c,b-1);
                if(t==0) printf("No
");
                else printf("Yes
");
            }
            else
            {
                scanf("%d%d%d",&a,&b,&c);
                add(a,b,p[a][b]);
                p[a][b] = c;
                add(a,b,p[a][b]);
            }
        }
    }
    return 0;
}

注意区间求异或的时候：因为query只能求（1,1）~（x,y）之间的异或，所以有三部分是多余的，因此需要重新异或回来。

那三部分就是（a-1,b-1）,(c，b-1),（a-1,d）;不过原理我还是不明白

 参考自夏天的风