HDU 4970 Killing Monsters（树状数组）

Killing Monsters

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 2838    Accepted Submission(s):
1068

Problem Description

Kingdom Rush is a popular TD game, in which you should
build some towers to protect your kingdom from monsters. And now another wave of
monsters is coming and you need again to know whether you can get through
it.

The path of monsters is a straight line, and there are N blocks on it
(numbered from 1 to N continuously). Before enemies come, you have M towers
built. Each tower has an attack range [L, R], meaning that it can attack all
enemies in every block i, where L<=i<=R. Once a monster steps into block
i, every tower whose attack range include block i will attack the monster once
and only once. For example, a tower with attack range [1, 3] will attack a
monster three times if the monster is alive, one in block 1, another in block 2
and the last in block 3.

A witch helps your enemies and makes every
monster has its own place of appearance (the ith monster appears at block Xi).
All monsters go straightly to block N.

Now that you know each monster has
HP Hi and each tower has a value of attack Di, one attack will cause Di damage
(decrease HP by Di). If the HP of a monster is decreased to 0 or below 0, it
will die and disappear.
Your task is to calculate the number of monsters
surviving from your towers so as to make a plan B.

 

Input

The input contains multiple test cases.

The
first line of each case is an integer N (0 < N <= 100000), the number of
blocks in the path. The second line is an integer M (0 < M <= 100000), the
number of towers you have. The next M lines each contain three numbers, Li, Ri,
Di (1 <= Li <= Ri <= N, 0 < Di <= 1000), indicating the attack
range [L, R] and the value of attack D of the ith tower. The next line is an
integer K (0 < K <= 100000), the number of coming monsters. The following
K lines each contain two integers Hi and Xi (0 < Hi <= 10^18, 1 <= Xi
<= N) indicating the ith monster’s live point and the number of the block
where the ith monster appears.

The input is terminated by N = 0.

 

Output

Output one line containing the number of surviving
monsters.

 

Sample Input

5
2
1 3 1
5 5 2
5
1 3
3 1
5 2
7 3
9 1
0

 

Sample Output

3

Hint

In the sample, three monsters with origin HP 5, 7 and 9 will survive.

 

Author

SYSU

 

题目大意：在长度为N的路上，有M个攻击塔，给定M个攻击台的攻击范围和伤害，现在有Q只怪物，给出Q只怪物的HP和出现位置，怪物固定向右进攻，问所有有多少只怪物活着。

 

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #define lowbit(x) (x&(-x))  

 using namespace std;

 int n, m, k, l, r, d, x, ans;
 long long sum[], a[], h;

 void update(int i, int v)
 {
     while (i <= n)
     {
         a[i] += v;
         i += lowbit(i);
     }
 }

 long long get_sum(int i) //求的是该点的和
 {
     long long all = ;
     while (i>)
     {
         all += a[i];
         i -= lowbit(i);
     }
     return all;
 }

 int main()
 {
     while (scanf("%d", &n), n != )
     {
         scanf("%d", &m);
         memset(a, , sizeof(a));
         while (m-->)
         {
             scanf("%d%d%d", &l, &r, &d);
             update(l, d);//类似气球贴标签，这样求前缀和就是该数对应块上的炮弹叠加和
             update(r + , -d);
         }
         sum[n + ] = ;
         for (int i = n; i>; --i)
         {
             sum[i] = sum[i + ] + get_sum(i);

         }
         /*for (int i = 1; i <= n; i++)
             cout << get_sum(i) << endl;*/
         scanf("%d", &k);
         ans = ;
         while (k-->)
         {
             scanf("%I64d%d", &h, &x);
             if (h>sum[x])
                 ++ans;
         }
         printf("%d\n", ans);
     }
     return ;
 }

巧妙的数组（类似贴气球）

解题思路：对于攻击台，l，r，val，在v[l]处加上val，v[r+1]处减掉val。然后遍历一遍v数组递推出各个点的伤害。并且处理处伤害的前缀和。然后对于每只怪物去判断。

做完后查看题解，发现本题查询时很有规律，所以不必使用树状数组，读入数据时，对damage数组进行如下操作：damage[L]+=d，damage[R+1]-=d，表示区间[L,R]内点每个点都会加上d，最后正着扫一边，即可得到i点能造成点伤害damage[i]，再倒着扫一边，即可得到区间[i,n]能造成点伤害总和damage[i]

 #include <cstdio>
 #include <cstring>
 #include <algorithm>

 using namespace std;
 const int maxn = 1e5 + ;
 typedef unsigned long long ll;

 int N, M;
 ll v[maxn];

 void init()
 {
     int l, r, val;

     scanf("%d", &M);
     memset(v, , sizeof(v));
     for (int i = ; i < M; i++)
     {
         scanf("%d%d%d", &l, &r, &val);
         v[l] += val;
         v[r + ] -= val;
     }

     ll mv = ;
     for (int i = ; i <= N; i++)
     {
         mv += v[i];
         v[i] = mv;
     }

     for (int i = ; i <= N; i++)
         v[i] += v[i - ];
 }

 int main()
 {

     while (scanf("%d", &N) ==  && N)
     {
         init();

         scanf("%d", &M);

         int pos, ret = ;
         ll HP;
         for (int i = ; i < M; i++)
         {
             scanf("%I64d%d", &HP, &pos);
             if (HP > v[N] - v[pos - ])
                 ret++;
         }
         printf("%d\n", ret);
     }
     return ;
 }