hdu4939思维DP

题目

Stupid Tower Defense

在坐标轴$[1,n]$上，每两个相邻的整数点之间可以放置一座防御塔。

怪物初始时 $t$ 秒移动一个单位。

• 防御塔$1$：在当前线段上的敌人每秒受到$x$伤害。例如在$[1,2)$上放置一座防御塔$1$，怪物在$[1,2)$上行走每秒会受到$x$伤害。

• 防御塔$2$：在当前线段后的敌人每秒受到$y$伤害。例如在$[1,2)$上放置一座防御塔$2$，怪物在$[2,n)$上行走每秒会受到$y$伤害。

• 防御塔$3$：在当前线段后的敌人被减速$z$。例如在$[1,2)$上放置一座防御塔$3$，怪物在$[2,n)$上行走会被减速$z$，也就是$t=t+z$。

防御塔2/3的效果可以叠加。

数据范围 （2<=n<=1500 , 0<=x,y,z<=60000 1<=t<=3）

问一个敌人从$1$走到$n$受到的最大伤害是多少。

解题思路

经过一点分析，显然有防御塔1肯定是连续的放置在最后面一段区间。

令$DP[i][j]$为前$i$个防御塔，放置$j$个防御塔$2$、$i-j$个防御塔$3$的最大伤害，$i$后面全为防御塔$3$。这时候，前面防御塔2/3的排列顺序对后面的贡献无影响。只记录数量即可。

因此有状态转移方程：

dp[i][j] = dp[i-1][j] + V1;
dp[i][j] = dp[i-1][j-1] + V2;
ans = max(ans , dp[i][j] + 后面全为防御塔1的价值)

AC代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <unordered_map>
#include <map>
#include <vector>
using namespace std;

const int N = 1505;
long long dp[N][N]; //前i个有j个减速 i-j个后攻
int CA;
void solve()
{
    memset(dp, 0, sizeof dp);
    long long n, x, y, z, t;
    scanf("%lld %lld %lld %lld %lld", &n, &x, &y, &z, &t);
    long long ans = t * x * n;
    long long a = 1, b = 0, len = n - 1; //a减速 b后攻 c行程
    ans = max(ans, (a * z + t) * (b * y + x) * len);
    a = 0, b = 1, len = n - 1;
    ans = max(ans, (a * z + t) * (b * y + x) * len);
    dp[1][0] = 0;
    dp[1][1] = 0;
    for (int i = 2; i <= n; i++)
    {
        for (int j = 0; j <= i; j++)
        {
            if (!j)
            {
                dp[i][j] = max(dp[i][j], dp[i - 1][j] + (i - 1) * y * t);
                long long a = 0, b = i, len = n - i; //a减速 b后攻
                ans = max(ans, dp[i][j] + (a * z + t) * (b * y + x) * len);
            }
            else
            {
                //当前放减速
                long long T = t + (j - 1) * z;
                long long D = ((i - 1) - (j - 1)) * y;
                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + T * D); //当前放减速
                long long a = j, b = i - j, len = n - i;            //a减速 b后攻
                ans = max(ans, dp[i][j] + (a * z + t) * (b * y + x) * len);
                //当前放后攻，dp[i][j]从dp[i-1][j]转移 因此只有i!=j 当前才能放后攻
                if (i != j)
                {
                    T = t + j * z;
                    D = ((i - 1) - j) * y;
                    dp[i][j] = max(dp[i][j], dp[i - 1][j] + T * D); //当前放后攻
                    a = j, b = i - j, len = n - i;                  //a减速 b后攻
                    ans = max(ans, dp[i][j] + (a * z + t) * (b * y + x) * len);
                }
            }
        }
    }
    printf("Case #%d: %lld\n", ++CA, ans);
}
int main()
{
    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}