Killing Monsters(hdu4970)

Killing Monsters

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

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.

 

题意：
n个格子，m个塔，每个塔有攻击范围[ l , r ],从格子 l 开始到格子 r 的范围内~每个敌人会受到di点伤害，
然后给出k个敌人的hp和初始位置，这k个敌人朝着第n个格子走去，如果敌人的hp小于等于0就会死亡，问最后又多少个敌人存活；

思路：开一个大小为N的数组attack，初始化为0；对于每个tower的攻击（l,r,d）将attack[l]的值加上d，attack[r+1]的值减去d，然后对attack数组从前往后扫一遍，可以求出经过每个格子时，受的攻击值；再对attack数组从后往前扫一遍，又可以求出每个格子出发到格子N，受到的总攻击值，最后，对每个怪物判断血量是否足够即可，时间复杂度o（N）。

 

#include<stdio.h>
#include<string.h>
#define ll __int64

ll N,l,r,d,m,k,count,h,x;
ll attack[+];
int main()
{
    ll i,j;
    while(scanf("%I64d",&N),N)
    {
        memset(attack,,sizeof(attack));
        count=N;
        scanf("%I64d",&m);
        for(i=;i<m;i++)
        {
            scanf("%I64d%I64d%I64d",&l,&r,&d);
            attack[l]+=d;
            attack[r+]-=d;
        }
        for(i=;i<=N;i++)//从前往后扫一遍
        {
            attack[i]+=attack[i-];
        }
        for(i=N-;i>=;i--)//从后往前扫一遍
        {
            attack[i]+=attack[i+];
        }
        scanf("%I64d",&k);
        for(i=;i<k;i++)
        {
            scanf("%I64d%I64d",&h,&x);
            if(attack[x]>=h)
                count--;
        }
        printf("%I64d\n",count);
    }
    return ;
}

昨天又比赛去了，然后就忘记写博客了，，，，，还要继续努力啊！