Stupid tower defense
Time Limit: 12000/6000 MS (Java/others) memory limit: 131072/131072 K (Java/Others)
Problem descriptionfsf 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 shoshould have got M * y damage per second. the same, if you are already pass through K blue towers, the enemy shoshould have took T + K * z seconds every unit length.
FSF now wants to know the maximum damage the enemy can get.
Inputthere 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)
Outputfor each case, You shoshould 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
12 4 3 2 1
Sample output
Case #1: 12HintFor 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.
A straight line with N unit lengths is given. Every passing through a unit length takes t s. There are three types of towers. The Red Tower can cause X points of damage per second in the current lattice. The Green Tower can cause y points of damage per second in the subsequent lattice. The blue tower can increase the length of time by Z seconds. Ask how to arrange the sequence of the Three Towers to maximize the damage and output the maximum damage value.
Analysis: If you want to arrange a Red Tower, it will not cause much damage in front of it. Therefore, we can enumerate the number I of the Red Tower and perform DP on the first n-I tower. Set DP [I] [J] to indicate the maximum damage caused by J blue towers in the first I units, DP [I] [J] = max (DP [I-1] [J-1] + (I-j) * y * (t + (J-1) * z ), DP [I-1] [J] + (I-j-1) * y * (t + J * z) where (I-j) * y * (t + (J-1) * z) indicates the damage caused by the I-j green tower on the I grid. (I-j-1) * y * (t + J * z) indicates the damage caused by the i-j-1 green tower on the I grid. After DP [I] [J] is obtained, the total damage of the number of red towers is damage = DP [I] [J] + (n-I) * x * (t + J * z) + (n-I) * (t + J * z) * (I-j) * Y (the damage caused by the last n-I red towers plus the damage caused by the previous I-j green towers on the last n-I grids), so the final ans = max (ANS, damage ).
# Include <cstdio> # include <cstring> # include <algorithm> using namespace STD; const int n = 1505; typedef _ int64 ll; ll DP [N] [N]; int main () {ll X, Y, Z, t, n, I, j; int T, CAS = 0; scanf ("% d", & T ); while (t --) {scanf ("% i64d % i64d % i64d % i64d", & N, & X, & Y, & Z, & T ); memset (DP, 0, sizeof (DP); LL ans = N * T * X; // put all in the Red Tower for (I = 1; I <= N; I ++) // the length of the first I units {for (j = 0; j <= I; j ++) // The number of blue towers {If (j = 0) DP [I] [J] = DP [I-1] [J] + (I-j-1) * y * t; else {ll tmp1 = DP [I-1] [J-1] + (I-j) * y * (t + (J-1) * z ); // place the blue tower ll tmp2 = DP [I-1] [J] + (I-j-1) * y * (t + J * z) in unit length J ); // No blue tower DP [I] [J] = max (tmp1, tmp2);} ans = max (ANS, DP [I] [J] + (n-I) * x * (t + J * z) + (n-I) * (t + J * z) * (I-j) * Y);} printf ("case # % d: % i64d \ n", ++ cas, ANS);} return 0 ;}
