HDU 4031 Attack（树状数组修改区间查询点）

Problem Description

Today is the 10th Annual of “September 11 attacks”, the Al Qaeda is about to attack American again. However, American is protected by a high wall this time, which can be treating as a segment with length N. Al Qaeda has a super weapon, every second it can attack a continuous range of the wall. American deployed N energy shield. Each one defends one unit length of the wall. However, after the shield defends one attack, it needs t seconds to cool down. If the shield defends an attack at kth second, it can’t defend any attack between (k+1)th second and (k+t-1)th second, inclusive. The shield will defend automatically when it is under attack if it is ready.

During the war, it is very important to understand the situation of both self and the enemy. So the commanders of American want to know how much time some part of the wall is successfully attacked. Successfully attacked means that the attack is not defended by the shield.

 

Input

The beginning of the data is an integer T (T ≤ 20), the number of test case.
The first line of each test case is three integers, N, Q, t, the length of the wall, the number of attacks and queries, and the time each shield needs to cool down.
The next Q lines each describe one attack or one query. It may be one of the following formats
1. Attack si ti
  Al Qaeda attack the wall from si to ti, inclusive. 1 ≤ si ≤ ti ≤ N
2. Query p
  How many times the pth unit have been successfully attacked. 1 ≤ p ≤ N
The kth attack happened at the kth second. Queries don’t take time.
1 ≤ N, Q ≤ 20000
1 ≤ t ≤ 50

 

Output

For the ith case, output one line “Case i: ” at first. Then for each query, output one line containing one integer, the number of time the pth unit was successfully attacked when asked.

 

Sample Input

   
   
   
   

    
    
    
    2
3 7 2
Attack 1 2
Query 2
Attack 2 3
Query 2
Attack 1 3
Query 1
Query 3
9 7 3
Attack 5 5
Attack 4 6
Attack 3 7
Attack 2 8
Attack 1 9
Query 5
Query 3
   
   
   
   

 

Sample Output

   
   
   
   

    
    
    
    Case 1:
0
1
0
1
Case 2:
3
2
   
   
   
   

题意：

长度为n的城墙，进行q次询问，护盾冷却时间为cd，每次询问包含Attack和Query，Attack的时候是过一秒城墙l，r段被攻击，Query是询问输出城墙某一点到这个时间被攻击到的次数。

思路：

树状数组，通常树状数组是更新点询问区间，而这题是要更新区间询问点，对于更新区间，其实可以转化为更新点：对于区间[l,r]，我们更新点l为正，

点r+1为负，这样一来等效于更新了区间。然后在询问点的时候，对于我们这个保存方式，保存的是城墙被攻击的次数，所以要转化一下，

被攻击到的次数=总攻击次数-成功保护的次数。每次询问到一个点的时候，记录下从开始到当前时间这个点一共成功保护了多少次。

代码：

#include <stdio.h>
#include <string.h>

const int N = 20005;

int t, n, q, cd, bit[N], pro[N], time, pt[N], rt[N], lt[N];

void Add(int x, int v) {
	while (x <= n) {
		bit[x] += v;
		x += (x&(-x));
	}
}

int Sum(int x) {
	int ans = 0;
	while (x > 0) {
		ans += bit[x];
		x -= (x&(-x));
	}
	return ans;
}

void init() {
	time = 0;
	memset(bit, 0, sizeof(bit));
	memset(pro, 0, sizeof(pro));
	memset(lt, 0, sizeof(lt));
	memset(rt, 0, sizeof(rt));
	memset(pt, 0, sizeof(pt));
	scanf("%d%d%d", &n, &q, &cd);
}

void solve() {
	char Q[10];
	for (int i = 0; i < q; i++) {
		scanf("%s", Q);
		if (Q[0] == 'A') {
			int l, r;
			scanf("%d%d", &l, &r);
			Add(l, 1);
			Add(r + 1, -1);
			lt[time] = l;
			rt[time] = r;
			time++;
		}
		else {
			int num; scanf("%d", &num);
			for (int j = pt[num]; j < time; j++) {
				if (num >= lt[j] && num <= rt[j]) {
					pt[num] = j + cd;
					pro[num]++;
					j += cd - 1;
				}
			}
			printf("%d\n", Sum(num) - pro[num]);
		}
	}
}

int main() {
	int cas = 0;
	scanf("%d", &t);
	while (t--) {
		printf("Case %d:\n", ++cas);
		init();
		solve();
	}
	return 0;
}