敌兵布阵:线段树：单点修改+区间查询/树状数组

敌兵布阵

Problem Description

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<iostream>
#include<string>
using namespace std;

const int maxz = 50010;
int T, n;

struct node {
	int l, r, value;			//	value：区间和
}t[4 * maxz];

inline int read() {
	int i = 0, j = 1;
	char ch = getchar();
	while (ch<'0' || ch>'9') { if (ch == '-')j = -1; ch = getchar(); }
	while (ch >= '0'&&ch <= '9') i = i * 10 + ch - '0', ch = getchar();
	return i*j;
}

void pushup(int p)    //更新节点信息  这里是求和
{
    t[p].value=t[p<<1].value +t[p<<1|1].value;
}

void built(int p, int l, int r) {			//建树，p：根节点 l：区间左值  r：区间右值
	t[p].l = l;			//节点的l  就是区间左值
	t[p].r = r;			//节点的r  就是区间右值

	if (l == r) {					//说明是叶子节点
		t[p].value = read();		//把输入放在建树里边
		return;
	}

	int mid = (l + r) >> 1;
	built(2 * p, l, mid);					//建左区间树
	built(2 * p + 1, mid + 1, r);			//建右区间数
	pushup(p);								//子节点更新后要更新当前节点信息
}

void update(int p, int now, int ans) {		//单点修改	p:根节点		now：要修改的节点  ans：修改值
	if (t[p].l == t[p].r) {				//叶子节点
		t[p].value += ans;				
		return;
	}

	int mid = (t[p].l + t[p].r) >> 1;		
	if (now <= mid)						//修改
		update(2 * p, now, ans);
	if (now>mid) 
		update(2 * p + 1, now, ans);
	pushup(p);								//子节点更新后要更新当前节点信息
}

int query(int p, int l, int r) {		//区间查询 p：根节点		l:区间左值	r:区间右值
	if (l <= t[p].l &&t[p].r <= r)
		return t[p].value;

	int cnt = 0;
	int mid = (t[p].l + t[p].r)/2;
	if (l <= mid)cnt += query(2 * p, l,r);		
	if (r > mid)cnt += query(2 * p + 1, l, r);
	return cnt;
}

int main() {
	string s;
	int x, y;
	cin >> T;
	for (int k = 1; k <= T; k++){
		cout << "Case " << k << ":\n";
		cin >> n;
		built(1, 1, n);
		while (cin >> s&&s[0] != 'E') {
			x = read();
			y = read();
			if (s[0] == 'Q')
				cout << query(1, x, y) << endl;
			else if (s[0] == 'A') 
				update(1, x, y);
			else 
				update(1, x, -y);
		}
	}
	return 0;
}

 

 树状数组：

/*
树状数组，一般用来解决带单点修改的区间求和问题，建树时间复杂度为O(nlongn),修改查询时间复杂度为 O（longn），主要原理是用一个c数组来存储规定区间的和
*/

#include<iostream>
#include<string>
#include<algorithm>
#include<string.h>
using namespace std;
const int maxn = 50010;
int t, n, a[maxn], c[maxn + 1024];

inline int read() {
	int s = 0, w = 1;
	char ch = getchar();
	while (ch<'0' || ch>'9') { if (ch == '-')w = -1; ch = getchar(); }
	while (ch >= '0'&&ch <= '9') s = s * 10 + ch - '0', ch = getchar();
	return s*w;
}

int lowbt(int x) {				//取二进制最小位的1
	return x&(-x);
}
void update(int a, int b, int n) {		//单点修改
	for (int i = a; i <= n; i += lowbt(i))
		c[i] += b;
}
int query(int a) {						//区间查询
	int cnt = 0;
	for (int i = a; i>0; i -= lowbt(i)) {
		cnt += c[i];
	}
	return cnt;
}
int main() {
	cin >> t;
	for (int k = 1; k <= t; k++) {
		memset(c, 0, sizeof(c));		//不要忘了初始化
		string s;
		int x, y;
		cout << "Case " << k << ":\n";
		cin >> n;
		for (int i = 1; i <= n; i++)
			a[i] = read(), update(i, a[i], n);

		while (cin >> s&&s[0] != 'E') {
			x = read(), y = read();
			if (s[0] == 'Q') {
				cout << query(y) - query(x - 1) << "\n";
			}
			else if (s[0] == 'A') {
				update(x, y, n);
			}
			else {
				update(x, -y, n);
			}
		}
	}
	return 0;
}