DP [I] [J] indicates the damage caused by J slowdown in step I. We put the damage caused by a greedy strategy at the end, and the damage caused by sustained damage and deceleration at the front of I is the highest.
Therefore, the damage in the first (I, j) is DP [I] [J] = max (DP [I-1] [J] + (J * z + T) * (max (0ll, i-1-j) * y, DP [I-1] [J-1] + (J-1) * z + T) * (I-j) * y );
The damage caused each time is: DP [I] [J] + (n-I) * (J * z + T) * (x + (I-j) * Y ). Take the maximum value, which is the maximum damage.
Stupid tower defense
Time Limit: 12000/6000 MS (Java/others) memory limit: 131072/131072 K (Java/Others)
Total submission (s): 1194 accepted submission (s): 350
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: 12
#include <algorithm>#include <iostream>#include <stdlib.h>#include <string.h>#include <iomanip>#include <stdio.h>#include <string>#include <queue>#include <cmath>#include <stack>#include <ctime>#include <map>#include <set>#define eps 1e-9///#define M 1000100#define LL __int64///#define LL long long///#define INF 0x7ffffff#define INF 0x3f3f3f3f#define PI 3.1415926535898#define zero(x) ((fabs(x)<eps)?0:x)using namespace std;const int maxn = 2010;LL dp[maxn][maxn];int main(){ int T; cin >>T; int Case = 1; while(T--) { LL n, x, y, z, t; cin >>n>>x>>y>>z>>t; memset(dp, 0, sizeof(dp)); LL ans = n*t*x; for(LL i = 1; i <= n; i++) { for(LL j = 0; j <= i; j++) { if(j == 0) dp[i][j] = dp[i-1][j]+t*(i-1-j)*y; else dp[i][j] = max(dp[i-1][j]+(j*z+t)*(max(0LL, i-1-j))*y, dp[i-1][j-1]+((j-1)*z+t)*(i-j)*y); ans = max(ans, dp[i][j]+(n-i)*(j*z+t)*(x+(i-j)*y)); } } cout<<"Case #"<<Case++<<": "<<ans<<endl; } return 0;}