HDU4939 Stupid Tower Defense

Stupid Tower Defense

Time Limit: 12000/6000 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others)

Total Submission(s): 838 Accepted Submission(s): 250

Problem Description
FSF is addicted to a stupid tower defense game. The goal of tower defense games is to try to stop enemies from crossing a map by building traps to slow them down and towers which shoot at them as they pass.

The map is a line, which has n unit length. We can build only one tower on each unit length. The enemy takes t seconds on each unit length. And there are 3 kinds of tower in this game: The red tower, the green tower and the blue tower.

The red tower damage on the enemy x points per second when he passes through the tower.

The green tower damage on the enemy y points per second after he passes through the tower.

The blue tower let the enemy go slower than before (that is, the enemy takes more z second to pass an unit length, also, after he passes through the tower.)

Of course, if you are already pass through m green towers, you should have got m*y damage per second. The same, if you are already pass through k blue towers, the enemy should have took t + k*z seconds every unit length.

FSF now wants to know the maximum damage the enemy can get.


Input
There are multiply test cases.

The first line contains an integer T (T<=100), indicates the number of cases.

Each test only contain 5 integers n, x, y, z, t (2<=n<=1500,0<=x, y, z<=60000,1<=t<=3)


Output
For each case, you should output "Case #C: " first, where C indicates the case number and counts from 1. Then output the answer. For each test only one line which have one integer, the answer to this question.


Sample Input
1
2 4 3 2 1


Sample Output
Case #1: 12

Hint
For the first sample, the first tower is blue tower, and the second is red tower. So, the total damage is 4*(1+2)=12 damage points.



Author
UESTC


Source
2014 Multi-University Training Contest 7

 题意：有3中塔，在一条线段上，红塔只对经过当前点的进行上海，绿塔对过了这个点的进行持续伤害，蓝塔一过这个点就减速。

正解是DP。。一开始读错了好无语（想的太简单了）。

红塔肯定是放在最后面的，所以枚举红塔的个数。

用dp[i][j]表示在前i个点有j个蓝塔能够造成的最大伤害。

所以状态转移方程就是dp[i][j]=max(dp[i-1][j-1]+y*(i-j)*(t+(j-1)*z),dp[i-1][j]+y*(i-j-1)*(t+j*z))，前面一个表示把第j座蓝塔放在i点上的伤害，后面一个是所有蓝塔都在前i-1个点中，后面加上的都是表示在i这个点造成的伤害。。

这个方程的边界是dp[i][0]，表示前面i-1都放了绿塔。

#include<cstdio>
#include<algorithm>
#include<cstring>
#define ll __int64
using namespace std;
const int MAXN=1510;
ll dp[MAXN][MAXN];
int main()
{
    ll T,t,n,x,y,z,i,j,flag=1;
    scanf("%I64d",&T);
    while(T--)
    {
        scanf("%I64d%I64d%I64d%I64d%I64d",&n,&x,&y,&z,&t);
        ll ans=n*x*t;
        memset(dp,0,sizeof(dp));
        for(i=1;i<=n;i++)
        {
            dp[i][0]=dp[i-1][0]+t*(i-1)*y;
            ans=max(ans,dp[i][0]+x*(n-i)*t+t*y*(n-i)*i); //后面还乘一个i的原因是这个绿塔对后面放绿塔的位置也有影响
        }
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=i;j++)
            {
                if(i==j)
                    dp[i][j]=0;
                else
                {
                    dp[i][j]=max(dp[i-1][j-1]+y*(i-j)*(t+(j-1)*z),dp[i-1][j]+y*(i-j-1)*(t+j*z));
                }
                ans=max(ans,dp[i][j]+(n-i)*x*(t+j*z)+(n-i)*(t+j*z)*(i-j)*y);
            }
        }
        printf("Case #%I64d: %I64d\n",flag++,ans);
    }
    return 0;
}