nbu 2415 Zero打怪兽

题目链接：http://acm.nbu.edu.cn/v1.0/Problems/Problem.php?pid=2415

题目大意：

有n只怪兽，第i只怪兽的攻击力为ATKi，防御力为DEFi，打败该怪兽获得经验EXPi。

一开始Zero，攻击力为ATK，防御力为DEF，经验值EXP=0，血量为HP。

经验值一旦达到100，就会升级，攻击力增加IN_ATK，防御力增加IN_DEP，血量增加IN_HP，经验值减少100。

Zero每次和怪兽的战斗都会遵循如下顺序：
1：如果Zero还活着，Zero打怪兽， 怪兽会受到MAX（1，Zero的攻击力-怪兽的防御力）的伤害（这个伤害最小为1）.
2:如果怪兽还活着，怪物打Zero，Zero会受到MAX（1，怪兽的攻击力-Zero的防御力）的伤害（这个伤害最小为1）.
战斗会按照这个顺序循环下去直到有一个被打败为止，打败的状态 为HP<=0;

问Zero打败所有怪兽后的最多剩余血量，如果无法打败所有怪兽输出“You must be kidding me!”。

1<=n<=20

1<=Expi<=100

题目思路：

根据打怪兽的顺序，显然可以有  20！种方法（状态），遍历所有显然不可行。

我们发现Expi最多为100，那么累积经验不会超过100*20=2000，那么可否枚举求得在某一个累积经验值下的最大血量呢？

显然某一个经验值对应多个打怪顺序，而且打的怪也可能不一样，这势必对状态的转移造I成了麻烦，甚至可以说是无法转移的。

那么我们在多一个限定条件，就是求某一累积经验值下打的怪相同的最大剩余血量，其实打的怪相同，经验值肯定相同，所以即打相同怪的最大剩余血量。

那么我们可以把打怪的状态看成一个二进制数。

如5个怪，10110表示打了第1，3，4只怪，而我们的答案就是要求11111情况下的最大剩余血量。

到这里，很清晰了，这是一道状态压缩的题目。

到这里，会发现我的思路里，我并没有提到攻击力，和防御力的影响，其实呢，仔细一想，累积经验值固定，那么攻击力和防御力必然也是固定，可以通过累加经验值直接计算，所以转移时只需要注意累积经验值和血量即可。

而转移的方程也是很容易想到的，

比如已知状态s（如10010），那么现在添加一只怪兽，状态为t（如01000）

这个可以向s|t（10010|01000 = 11010）转移，

但是如果t为10000，那么显然不能转移到s|t，即必须满足s&t==0，才可转移，因为一只怪兽只能打一次。

dp[s|t]=_max(dp[s|t], dp[s]-hp) , hp表示打完这只怪兽后损耗的血量（可能为负，因为升级会加血）。

代码：

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<ctype.h>
#include<iostream>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<string>
using namespace std;
#define ll long long
#define clr(x,c,n) memset(x,c,sizeof(x[0])*(n))
#define clr_all(x,c) memset(x,c,sizeof(x))
#define IT iterator
#define ls rt<<1
#define rs ls|1
#define lson l,mid,ls
#define rson mid+1,r,rs
#define middle l+r>>1
#define MOD 1000000007
#define inf 0x3f3f3f3f
#define eps (1e-8)
#define PI 3.1415926535897932384626433832795
#define E 2.7182818284590452353602874713527
template <class T> T _min(T a,T b){return a<b? a:b;}
template <class T> T _max(T a,T b){return a>b? a:b;}
template <class T> T _abs(T a){return a>0? a:-a;}
template <class T> T _mod(T a,T m){return a<m? (a<0? (a%m+m)%m:a):a%m;}
template <class T> T _gcd(T a,T b){while(b){T t=b;b=a%b;a=t;}return a;}
template <class T> void _swap(T &a,T &b){T t=b;b=a;a=t;}
template <class T> void getmax(T &a,T b){a= a>b? a:b;}
template <class T> void getmin(T &a,T b){a= (a!=-1 && a<b)? a:b;}
int TS,cas=1;
const int M=100000+5;
int a,d,h,ia,id,ih,n;
int ga[22],gd[22],gh[22],ge[22];
queue<int>q;
int dp[1<<20];
int Exp[1<<20];
char name[22];

void run(){
	int i,j,k;
	scanf("%d",&n);
	for(i=0;i<n;i++)
		scanf("%s%d%d%d%d",&name,&ga[i],&gd[i],&gh[i],&ge[i]);
	for(i=0;i<(1<<n);i++) dp[i]=Exp[i]=0;
	dp[0]=h;
	q.push(0);
	for(i=0;i<n;i++){
		int c=q.size();
		for(j=0;j<c;j++){
			int s=q.front();
			int now_a=a+Exp[s]/100*ia;
			int now_d=d+Exp[s]/100*id;
			int now_e=Exp[s]%100;
			q.pop();
			for(k=0;k<n;k++){
				int t=1<<k,hp=0;
				if(s&t) continue;
				int zMAX=_max(now_a-gd[k],1);
				int gMAX=_max(ga[k]-now_d,1);
				int num=gh[k]/zMAX+(gh[k]%zMAX!=0);
				if(num > 1) hp=(num-1)*gMAX;
				if(dp[s] <= hp) continue;
				if(now_e+ge[k] >= 100) hp-=ih;
				dp[s|t]=_max(dp[s|t],dp[s]-hp);
				if(!Exp[s|t]){
					Exp[s|t]=Exp[s]+ge[k];
					q.push(s|t);
				}
			}
		}
	}
	if(dp[(1<<n)-1]) printf("%d\n",dp[(1<<n)-1]);
	else puts("You must be kidding me!");
}

void presof(){
}

int main(){
	//freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
	presof();
	//run();
	while(~scanf("%d%d%d%d%d%d",&a,&d,&h,&ia,&id,&ih)) run();
	//for(scanf("%d",&TS),cas=1;cas<=TS;cas++) run();
	return 0;
}