算法编程题：魔塔
魔塔
题目大意
英雄在魔塔里杀怪闯关，根据怪物顺序一只一只杀，英雄有三个属性，分别是血量、攻击、防御。每一只怪物也有三个属性，分别是血量、攻击、防御。英雄和一只怪物的具体战斗情境如下。双方轮流攻击，英雄永远先攻，攻击方造成伤害为 max(1,攻击方攻击-防御方防御)。英雄只能根据怪物顺序杀怪，每击杀一只怪物后，可以选择一下三项之一
- 提升攻击力10点
- 提升防御力10点
- 提升血量1000点
问怎样选择可以让英雄尽可能杀更多的怪。
输入：
第一行输入4个数，h,a,d,n分别表示英雄的初始血量，英雄的初始攻击，英雄的初始防御以及怪物的数量 1<=n<=200, 1<=h,a,d<=10^9
接下来n行，每行三个数字hi,ai,di表示第i只怪物的血量，攻击，防御
输出：
一个数字，表示最多能杀到多少只怪
题解
此题很容易想到的方法是dfs遍历，我第一思路也是这个，但是时间复杂度是O(3^n)，n=200太高了，肯定不行。
第二思路是中间可能涉及到很多重复子问题，也许用dp可以解决，但是状态很难找，如果把英雄的攻击，防御，和血量当作状态的话，要开辟的dp空间太大，因为1<=h,a,d<=10^9。
这时候可以换一个角度，把英雄攻击，防御和血量的提升次数当作状态，则用一个dp[n][n][n]数组就足够表示所有状态了。
dp[i][j][k]表示在攻击+i次，防御+j次，血量+k次情况下，攻击完第i+j+k个怪物(怪物编号从0开始)时，需要消耗的血量
状态转移方程也不难想到，dp[i][j][k]可以通过dp[i-1][j][k]和dp[i][j-1][k]和dp[i][j][k-1]得来。当然，要判断一下三个前置状态的合法性。
上代码
public class Main {
//不考虑英雄血量，杀死怪物要掉多少血
public static long fight(long[] hero, long[] monster){
//怪物每回合掉血量
long monsterPerTurn = Math.max(1, hero[1] - monster[2]);
//英雄每回合掉血量
long heroPerTurn = Math.max(1, monster[1] - hero[2]);
//怪物死亡需要攻击次数，怪物攻击次数 = 怪物死亡需要次数 - 1,需要向上取整
long monsterDieTurn = (monster[0] / monsterPerTurn) + monster[0] % monsterPerTurn == 0 ? 0 : 1;
//怪物可对英雄造成的伤害, 该伤害可能非常高，因为有可能英雄每次攻击刮痧，只造成一点伤害，而怪物每次造成成吨伤害
//所以在特殊情况下要考虑long数据类型不足以存放，造成数据大小上溢，本题数据范围暂时不用考虑
long monsterDamage = (monsterDieTurn - 1) * heroPerTurn;
return monsterDamage;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N;
long[] hero = new long[3];
hero[0] = sc.nextLong();
hero[1] = sc.nextLong();
hero[2] = sc.nextLong();
N = sc.nextInt();
long[][] monsters = new long[N][3];
for (int i = 0; i < N; i++) {
monsters[i][0] = sc.nextLong();
monsters[i][1] = sc.nextLong();
monsters[i][2] = sc.nextLong();
}
//dp[i][j][k]表示在攻击+i次，防御+j次，血量+k次情况下，攻击完第i+j+k个怪物(怪物编号从0开始)时，需要消耗的血量
long[][][] dp = new long[N][N][N];
dp[0][0][0] = fight(hero, monsters[0]);
if (dp[0][0][0] >= hero[0]){
System.out.println(0);
} else {
//打N只怪兽
// full用来记录是否能全通关
boolean full = false;
for (int t = 1; t < N; t++) {
//打第t只，i + j + k = t
//flag用来判断有没有可能打的过第t-1只,如果打得过，那么这轮总有一个dp[i][j][k]!=MAX_VALUE
boolean flag = false;
for (int i = 0; i <= t; i++) {
for (int j = 0; j <= t - i; j++) {
int k = t - i - j;
//dp[i][j][k]可能由三种状态得来，先将dp[i][j][k]赋最大值
dp[i][j][k] = Long.MAX_VALUE;
//英雄状态(其实血量不用记，改成0也不影响)
long[] hero1 = new long[]{hero[0]+10*i,hero[1]+10*j,hero[2]+1000*k};
//记录攻击本只怪物需要消耗多少血量
long fightThisTurn = fight(hero1,monsters[t]);
//1.dp[i-1][j][k] 打完t-1只后，加攻击
if (i - 1 >= 0 && dp[i-1][j][k] - k * 1000 < hero[0]){
dp[i][j][k] = Math.min(dp[i][j][k], dp[i-1][j][k] + fightThisTurn);
}
//2.dp[i][j-1][k] 打完t-1只后，加防御
if (j - 1 >= 0 && dp[i][j-1][k] - k * 1000 < hero[0]){
dp[i][j][k] = Math.min(dp[i][j][k], dp[i][j-1][k] + fightThisTurn);
}
//3.dp[i][j][k-1] 打完t-1只后，加血
if (k - 1 >= 0 && dp[i][j][k-1] - (k - 1) * 1000 < hero[0]){
dp[i][j][k] = Math.min(dp[i][j][k], dp[i][j][k-1] + fightThisTurn);
}
// 说明上面三个情况，有一种是成立，可以求出dp[i][j][k]
if (dp[i][j][k] != Long.MAX_VALUE){
if (t == N - 1 && dp[i][j][k] < hero[0] + k * 1000){
full = true;
}
flag = true;
}
}
}
// flag = false说明t-1时，所有dp[i][j][k]需要的血量都超出了初始血量，失败
if (!flag){
System.out.println(t - 1);
break;
}
// 全通关
if (t == N - 1 && full){
System.out.println(N);
break;
}
// 功亏一篑
if (t == N - 1 && !full){
System.out.println(N - 1);
break;
}
}
}
}
}
结尾
这是一道笔试题，是我在其他论坛上看到有人讨论感兴趣写出来的，不是我真实笔试碰到的题，以上代码均未通过测试，可能有很多错误，只是提供一种思路仅供参考。有错误欢迎指出。
