ZRDay6A. 萌新拆塔(三进制状压dp)

题意

Sol

这好像是我第一次接触三进制状压

首先，每次打完怪之后吃宝石不一定是最优的，因为有模仿怪的存在，可能你吃完宝石和他打就GG了。。

因此我们需要维护的状态有三个

0：没打

1：打了怪物 没吃宝石

2：打了怪物 吃了宝石

如果我们能知道打了那些怪，吃了那些宝石，那么此时的状态时确定的，预处理出来

然后DP就行了

mdzz这题卡常数

/*
首先打完怪之后吃宝石不一定是最优的
因此我们需要枚举出每个怪物的状态
0：没打
1：打了怪物 没吃宝石
2：打了怪物 吃了宝石
如果我们能知道打了那些怪，吃了那些宝石，那么此时的状态时确定的

*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<vector>
#include<set>
#include<queue>
#include<cmath>
//#define int long long
#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1<<22, stdin), p1 == p2) ? EOF : *p1++)
char buf[( << )], *p1 = buf, *p2 = buf;
#define LL long long
using namespace std;
const int MAXN =  * 1e6 + ;
inline int read() {
    char c = getchar(); int x = , f = ;
    while(c < '' || c > '') {if(c == '-') f = -; c = getchar();}
    while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
    return x * f;
}
int T, N;
int lim, Hp, A, F, M, Mp[MAXN], IA[MAXN], IF[MAXN], IM[MAXN];//攻击 血量 防御 魔防
LL f[MAXN], Po[];
struct Enemy {
    int H, A, D, S, ap, dp, mp, hp;
}a[];
vector<int> v[];
void init() {
    memset(f, , sizeof(f));
    Hp = read(); A = read(); F = read(); M = read();
    N = read();
    lim = Po[N];
    for(int i = ; i <= N; i++) {
        a[i].H = read();  a[i].A = read(); a[i].D = read(); a[i].S = read();
        a[i].ap = read(); a[i].dp = read(); a[i].mp = read(); a[i].hp = read();
    }
    int K = read();
    for(int i = ; i <= N; i++) v[i].clear();
    for(int i = ; i <= K; i++) {
        int u = read(), vv = read();
        v[vv].push_back(u);
    }
}
LL Attack(int sta, int id) {
    LL Now = f[sta], A = IA[sta], D = IF[sta], M = IM[sta];
    LL s = a[id].S, h = a[id].H, aa = a[id].A, d = a[id].D;
    if (s & ) aa = A, d = D; // 模仿
    if (s & ) D = ; // 无视防御
    LL AA = max(0ll, A - d); // 勇士造成伤害
    aa = max(0ll, aa - D) * (((s >> ) & ) + ); // 怪物造成的攻击力，是否连击
    if (AA == ) return ;
    LL t1 = (h - ) / AA + ; // 需要打怪几次
    LL t2 = (s & ) ? (t1 * aa) : ((t1 - ) * aa); // 怪造成的攻击力，是否有先攻
    LL t3 = max(0ll, t2 - M); // 减去魔防
    return max(0ll, Now - t3);
}
void solve() {
    f[] = Hp;
    for(int sta = ; sta < lim; sta++) {
        IA[sta] = A; IF[sta] = F; IM[sta] = M;
        for(int i = ; i <= N; i++)
            if(sta / Po[i - ] %  == )
                IA[sta] += a[i].ap, IF[sta] += a[i].dp, IM[sta] += a[i].mp;
    }
    for(int sta = ; sta < lim; sta++) {
        if(f[sta] == ) continue;
        for(int i = ; i <= N; i++) {
            if(sta / Po[i - ] %  == ) {// not kill
                bool flag = ;
                for(int j = ; j < v[i].size(); j++)
                    if(sta / Po[v[i][j] - ] %  == ) // not kiil
                        {flag = ; break;}
                if(flag == ) continue;
                LL nhp = Attack(sta, i);
                if(nhp > )
                    f[sta + Po[i - ]] = max(f[sta + Po[i - ]], nhp);
            } else if(sta / Po[i - ] %  == ) {
                f[sta + Po[i - ]] = max(f[sta + Po[i - ]], f[sta] + a[i].hp);
            }
        }
    }
    printf("%lld\n", f[lim - ] ==  ? - : f[lim - ]);
}
main() {
    Po[] = ;
    for(int i = ; i <= ; i++) Po[i] =  * Po[i - ];
    T = read();
    while(T--) {
        init();
        solve();
    }
    return ;
}
/*
2 2 1
1 1
2 1 1
*/