树状数组

1.什么是树状数组？

顾名思义，就是用数组来模拟树形结构呗。那么衍生出一个问题，为什么不直接建树？答案是没必要，因为树状数组能处理的问题就没必要建树。和Trie树的构造方式有类似之处。

2.树状数组可以解决什么问题

可以解决大部分基于区间上的更新以及求和问题。

3.树状数组和线段树的区别在哪里

树状数组可以解决的问题都可以用线段树解决，这两者的区别在哪里呢？树状数组的系数要少很多，就比如字符串模拟大数可以解决大数问题，也可以解决1+1的问题，但没人会在1+1的问题上用大数模拟。

4.树状数组的优点和缺点

修改和查询的复杂度都是O(logN)，而且相比线段树系数要少很多，比传统数组要快，而且容易写。

缺点是遇到复杂的区间问题还是不能解决，功能还是有限。

• 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[i] = A[i - 2k+1] + A[i - 2k+2] + ... + A[i];   //k为i的二进制中从最低位到高位连续零的长度

int n;
int a[1005], c[1005];     //a[]为原数组， c[]为建立的树状数组

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

void update(int i, int k) {  //在a[i]位置加上k
    while(i <= n) {
        c[i] += k;
        i += lowbit(i);
    }
}

int getsum(int i) {     //求区间a[1]~a[i]的总和 
    int res = 0;
    while(i > 0) {
        res += c[i];
        i -= lowbit(i);
    }
    return res;
}

HDU 1166 敌兵布阵

C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。
中央情报局要研究敌人究竟演习什么战术,所以Tidy要随时向Derek汇报某一段连续的工兵营地一共有多少人,例如Derek问:“Tidy,马上汇报第3个营地到第10个营地共有多少人!”Tidy就要马上开始计算这一段的总人数并汇报。但敌兵营地的人数经常变动，而Derek每次询问的段都不一样，所以Tidy不得不每次都一个一个营地的去数，很快就精疲力尽了，Derek对Tidy的计算速度越来越不满:"你个死肥仔，算得这么慢，我炒你鱿鱼!”Tidy想：“你自己来算算看，这可真是一项累人的工作!我恨不得你炒我鱿鱼呢!”无奈之下，Tidy只好打电话向计算机专家Windbreaker求救,Windbreaker说：“死肥仔，叫你平时做多点acm题和看多点算法书，现在尝到苦果了吧!”Tidy说："我知错了。。。"但Windbreaker已经挂掉电话了。Tidy很苦恼，这么算他真的会崩溃的，聪明的读者，你能写个程序帮他完成这项工作吗？不过如果你的程序效率不够高的话，Tidy还是会受到Derek的责骂的.

Input
第一行一个整数T，表示有T组数据。
每组数据第一行一个正整数N（N<=50000）,表示敌人有N个工兵营地，接下来有N个正整数,第i个正整数ai代表第i个工兵营地里开始时有ai个人（1<=ai<=50）。
接下来每行有一条命令，命令有4种形式：
(1) Add i j,i和j为正整数,表示第i个营地增加j个人（j不超过30）
(2)Sub i j ,i和j为正整数,表示第i个营地减少j个人（j不超过30）;
(3)Query i j ,i和j为正整数,i<=j，表示询问第i到第j个营地的总人数;
(4)End 表示结束，这条命令在每组数据最后出现;
每组数据最多有40000条命令

Output
对第i组数据,首先输出“Case i:”和回车,
对于每个Query询问，输出一个整数并回车,表示询问的段中的总人数,这个数保持在int以内。
Sample Input
1
10
1 2 3 4 5 6 7 8 9 10
Query 1 3
Add 3 6
Query 2 7
Sub 10 2
Add 6 3
Query 3 10
End 

Sample Output
Case 1:
6
33
59

#include <bits/stdc++.h>
using namespace std;

int n,m;
int a[50005],c[50005]; //对应原数组和树状数组

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

void updata(int i,int k){    //在i位置加上k
    while(i <= n){
        c[i] += k;
        i += lowbit(i);
    }= 
}

int getsum(int i){        //求A[1 - i]的和
    int res = 0;
    while(i > 0){
        res += c[i];
        i -= lowbit(i);
    }
    return res;
}

int main(){
    int t;
    cin>>t;
    for(int tot = 1; tot <= t; tot++){
        cout << "Case " << tot << ":" << endl;
        memset(a, 0, sizeof a);
        memset(c, 0, sizeof c);
        cin>>n;
        for(int i = 1; i <= n; i++){
            cin>>a[i];
            updata(i,a[i]);   //输入初值的时候，也相当于更新了值
        }

        string s;
        int x,y;
        while(cin>>s && s[0] != 'E'){
            cin>>x>>y;
            if(s[0] == 'Q'){    //求和操作
                int sum = getsum(y) - getsum(x-1);    //x-y区间和也就等于1-y区间和减去1-(x-1)区间和
                cout << sum << endl;
            }
            else if(s[0] == 'A'){
                updata(x,y);
            }
            else if(s[0] == 'S'){
                updata(x,-y);    //减去操作，即为加上相反数
            }
        }

    }
    return 0;
}

 

线段树模板：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
int a[50001];//存储结点的位置
struct node{
    int left,right;//线段区间
    int sum;//区间上的人数
}b[150005];
void Build(int left,int right,int i){//建树
    int mid;
    b[i].left=left;
    b[i].right=right;
    if(left==right){//先用数组存下该队的人
        b[i].sum=a[left];
        return ;
    }
    //cout<<"ok"<<endl;
    mid=(left+right)/2;
    Build(left,mid,2*i);//递归建立左子树
    Build(mid+1,right,2*i+1);//递归建立右子树
    b[i].sum=b[2*i].sum+b[2*i+1].sum;//记录该结点左右子树的值
}
 
void Add(int j,int num,int i){
    if(b[i].left==b[i].right){//到达叶子结点
        b[i].sum+=num;
        return ;//注意返回
    }
    else{
        b[i].sum+=num;//他的所有父节点都增加
        if(j<=b[i*2].right) Add(j,num,2*i);//递归左子树
        else Add(j,num,2*i+1);//建立右子树
    }
}
 
int Query(int left,int right,int i){//查询
    int mid;
    if(b[i].left==left&&b[i].right==right) return b[i].sum;
    mid=(b[i].left+b[i].right)/2;
    if(right<=mid) return Query(left,right,2*i);//在左子树
    else if(left>mid) return Query(left,right,2*i+1);//在右子树
    else return Query(left,mid,2*i)+Query(mid+1,right,2*i+1);//否则在中间
}

int main() {
	int t, k = 0, i, j, num, n;
	char s[10];
	cin >> t;
	while(t--) {
		cin >> n;
		for(i = 1; i <= n; i++)
		cin >> a[i];
	printf("Case %d:\n", ++k);
	Build(1, n ,1);
	while(scanf("%s", s) != EOF) {
			if(!strcmp(s, "End")) break;
			cin >> j >> num;
			if(!strcmp(s, "Query"))
			cout << Query(j, num, 1) << endl;
			if(!strcmp(s, "Add")) Add(j, num, 1);
			if(!strcmp(s, "Sub")) Add(j, -num, 1);
		}
	}
	return 0;
}

HDU 1754

Problem Description
很多学校流行一种比较的习惯。老师们很喜欢询问，从某某到某某当中，分数最高的是多少。
这让很多学生很反感。

不管你喜不喜欢，现在需要你做的是，就是按照老师的要求，写一个程序，模拟老师的询问。当然，老师有时候需要更新某位同学的成绩。
 

Input
本题目包含多组测试，请处理到文件结束。
在每个测试的第一行，有两个正整数 N 和 M ( 0<N<=200000,0<M<5000 )，分别代表学生的数目和操作的数目。
学生ID编号分别从1编到N。
第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学生的成绩。
接下来有M行。每一行有一个字符 C (只取'Q'或'U') ，和两个正整数A，B。
当C为'Q'的时候，表示这是一条询问操作，它询问ID从A到B(包括A,B)的学生当中，成绩最高的是多少。
当C为'U'的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B。
 

Output
对于每一次询问操作，在一行里面输出最高成绩。
 

Sample Input
5 6
1 2 3 4 5
Q 1 5
U 3 6
Q 3 4
Q 4 5
U 2 9
Q 1 5
 

Sample Output
5
6
5
9

 

线段树解决：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF = 0xffffff0; // 设置一个最大值
const int maxn = 200010;   //叶子节点数目 
struct Node{               //节点结构 
	int l, r;
	int v;
};
Node tree[4 * maxn];       //用数组代替指针表示线段树
int a[maxn];               //存放叶子节点值

int maxV = -INF;          //表示最大值 （求区间最大值） 

//建立线段树，并附初始值 
void build_tree(int root, int l, int r) {
	tree[root].l = l;
	tree[root].r = r;
	if(l == r) {
		tree[root].v = a[l];
		return ;
	}
	int mid = (l + r) / 2;
	//向下递归直到叶子节点为止 
	build_tree(2 * root, l, mid);
	build_tree(2 * root + 1, mid + 1, r); 
	tree[root].v = max(tree[2 * root].v, tree[2 * root + 1].v); //回溯时获得左右孩子的最大值 
}
//更新线段树某个节点的值，线段树维护
void update(int root, int i, int v) {
	if(tree[root].l == i && tree[root].r == i) {
		tree[root].v = v;
		return ;
	}
	int mid = (tree[root].l + tree[root].r) / 2;
	if(mid >= i) update(2 * root, i, v);
	else update(2 * root + 1, i, v);
	
	tree[root].v = max(tree[2 * root].v, tree[2 * root + 1].v);  //回溯获得左右孩子最大值 
} 
//查询区间[s, e]中的最大值
void query(int root, int s, int e) {
	if(tree[root].l == s && tree[root].r == e) {
		maxV = max(maxV, tree[root].v);
		return ;
	}
	int mid = (tree[root].l + tree[root].r) / 2;
	
	//区间过大(二分法划分区间)
	if(mid >= e) query(2 * root, s, e);
	else if(mid < s) query(2 * root + 1, s, e);
	else {
		query(2 * root, s, mid);
		query(2 * root + 1, mid + 1, e);
	} 
} 
int main() {
	int n, m;
	while(scanf("%d%d", &n, &m) != EOF) {
		memset(tree, -INF, sizeof(tree));
		for(int i = 1; i <= n; i++)
		scanf("%d", &a[i]);
		build_tree(1, 1, n);
		
		char ch;    //表示是询问操作还是更新操作 
		int a,b;    //询问操作表示区间[a,b];更新操作表示a的值变为b 
		for(int i = 1; i <= m; i++) {
			getchar();
			scanf("%c", &ch);
			scanf("%d%d", &a, &b);
			if(ch == 'Q') {
				maxV = -INF;
				query(1, a, b);
				printf("%d\n", maxV);
			} 
			else {
				update(1, a, b);
			}
		} 
	} 
	return 0;
}

 

树状数组解决：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int a[200010];
int h[200010];
int n,m;
inline int lowbit(int x)
{
    return x&(-x);
}
void update(int x)
{
    int lx;
    while(x<=n)
    {
        h[x]=a[x];
        lx=lowbit(x);
        for(int i=1;i<lx;i<<=1)
            h[x]=max(h[x],h[x-i]);
        x+=lowbit(x);
    }
}
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(h[y],ans);
    }
    return ans;
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        memset(a,0,sizeof(a));
        memset(h,0,sizeof(h));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            update(i);
        }
        char ch;
        int x,y;
        while(m--)
        {
            getchar();
            scanf("%c",&ch);
            scanf("%d%d",&x,&y);
            if(ch=='U')
            {
                a[x]=y;
                update(x);
            }
            else
            {
                printf("%d\n",query(x,y));
            }
        }
    }
    return 0;
}