[AH2017/HNOI2017]大佬

题目描述

人们总是难免会碰到大佬。他们趾高气昂地谈论凡人不能理解的算法和数据结构，走到任何一个地方，大佬的气场就能让周围的人吓得瑟瑟发抖，不敢言语。 你作为一个 OIER，面对这样的事情非常不开心，于是发表了对大佬不敬的言论。 大佬便对你开始了报复，你也不示弱，扬言要打倒大佬。

现在给你讲解一下什么是大佬，大佬除了是神犇以外，还有着强大的自信心，自信程度可以被量化为一个正整数 C（ 1<=C<=10^8）， 想要打倒一个大佬的唯一方法是摧毁 Ta 的自信心，也就是让大佬的自信值等于 0（恰好等于 0，不能小于 0）。 由于你被大佬盯上了，所以你需要准备好 n(1<=n<=100)天来和大佬较量，因为这 n 天大佬只会嘲讽你动摇你的自信，到了第n+1 天，如果大佬发现你还不服，就会直接虐到你服，这样你就丧失斗争的能力了。

你的自信程度同样也可以被量化，我们用 mc (1 <= mc <= 100)来表示你的自信值上限。

在第 i 天（ i>=1），大佬会对你发动一次嘲讽，使你的自信值减小 a[i]，如果这个时刻你的自信值小于 0 了，那么你就丧失斗争能力，也就失败了（特别注意你的自信值为 0 的时候还可以继续和大佬斗争）。 在这一天， 大佬对你发动嘲讽之后，如果你的自信值仍大于等于 0，你能且仅能选择如下的行为之一：

还一句嘴，大佬会有点惊讶，导致大佬的自信值 C 减小 1。

做一天的水题，使得自己的当前自信值增加 w[i], 并将新自信值和自信值上限 mc 比较，若新自信值大于 mc，则新自信值更新为 mc。例如， mc=50， 当前自信值为 40， 若w[i]=5，则新自信值为 45，若 w[i]=11，则新自信值为 50。

让自己的等级值 L 加 1。

让自己的讽刺能力 F 乘以自己当前等级 L，使讽刺能力 F 更新为 F*L。

怼大佬，让大佬的自信值 C 减小 F。并在怼完大佬之后，你自己的等级 L 自动降为 0，讽刺能力 F 降为 1。由于怼大佬比较掉人品，所以这个操作只能做不超过 2 次。

特别注意的是，在任何时候，你不能让大佬的自信值为负，因为自信值为负，对大佬来说意味着屈辱，而大佬但凡遇到屈辱就会进化为更厉害的大佬直接虐飞你。在第 1 天，在你被攻击之前，你的自信是满的（初始自信值等于自信值上限 mc）， 你的讽刺能力 F 是 1， 等级是 0。

现在由于你得罪了大佬，你需要准备和大佬正面杠，你知道世界上一共有 m（ 1<=m<= 20）个大佬，他们的嘲讽时间都是 n 天，而且第 i 天的嘲讽值都是 a[i]。不管和哪个大佬较量，你在第 i 天做水题的自信回涨都是 w[i]。 这 m 个大佬中只会有一个来和你较量（ n 天里都是这个大佬和你较量），但是作为你，你需要知道对于任意一个大佬，你是否能摧毁他的自信，也就是让他的自信值恰好等于 0。和某一个大佬较量时，其他大佬不会插手。

输入输出格式

输入格式：

第一行三个正整数 n,m,mc。分别表示有 n 天和 m 个大佬, 你的自信上限为 mc。

接下来一行是用空格隔开的 n 个数，其中第 i(1<=i<=n)个表示 a[i]。

接下来一行是用空格隔开的 n 个数，其中第 i(1<=i<=n)个表示 w[i]。

接下来 m 行，每行一个正整数，其中第 k(1<=k<=m)行的正整数 C[k]表示第 k 个大佬的初始自信值。

输出格式：

共 m 行，如果能战胜第 k 个大佬（让他的自信值恰好等于 0），那么第 k 行输出 1，否则输出 0。

输入输出样例

输入样例#1：

30 20 30
15 5 24 14 13 4 14 21 3 16 7 4 7 8 13 19 16 5 6 13 21 12 7 9 4 15 20 4 13 12
22 21 15 16 17 1 21 19 11 8 3 28 7 10 19 3 27 17 28 3 26 4 22 28 15 5 26 9 5 26
30
10
18
29
18
29
3
12
28
11
28
6 1 6
27
27
18
11
26
1

输出样例#1：

0
1
1
0
1
0
1
1
0
0
0
1
1
1
1
1
1
0
0
1

说明

20%数据保证: 1≤n≤10。

另有 20%数据保证:1 ≤ C[i],n,mc ≤ 30。

100%数据保证: 1 ≤ n,mc ≤ 100; 1≤m≤20; 1≤a[i],w[i]≤mc; 1≤C[i] ≤10^8

---

这个题可以分成两部分来做

我们发现在什么时刻攻击都是一样的

所以我们可以把攻击的操作单独分离出来只处理存活情况

然后就用一个简单的递推

用f[i][j] 表示到第i天回血j次的最大生命

可以算出这n天内有几天可以来攻击restep

然后我们对于攻击伤害的处理,我们可以直接暴力bfs

然后用map判一下重

处理出一个集合,一维表示伤害,一维表示要消耗的次数

然后我们设v[i]表示i这种嘲讽的伤害

step[i]表示i这种嘲讽需要消耗多少次

然后考虑只嘲讽一次

那么就只要有\((HP-v[i])+step[i] <= restep\)这样的嘲讽就可以打败大佬

然后再考虑嘲讽两次

那么需要满足两个条件

1 : \(v[L] + v[R] <= HP\)

2 : \((HP-v[L]-v[R]) + step[L] + step[R] <= rsetep\)

所以我们对于每个R都要最小化step[L] - v[L]

然后如果我们把嘲讽值按照从小到大排序

答案又满足单调性

所以直接维护双指针让L,R一直满足条件1

扫一遍并一直最小化step[L]-v[L]

如果满足条件2就可以打败大佬

#include<map>
#include<queue>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int M = 105 ;
const int INF = 1e9 ;
using namespace std ;
inline int read() {
	char c = getchar() ; int x = 0 , w = 1 ;
	while(c>'9'||c<'0') { if(c=='-') w = -1 ; c = getchar() ; }
	while(c>='0'&&c<='9') { x = x*10+c-'0' ; c = getchar() ; }
	return x*w ;
}
int n , m , upp ;
int a[M] , w[M] ;
int f1[M][M] ;
int Ans , restep = 0 , cnt ;
int HP[M] , maxhp ;
map < int , bool > p[M] ;
struct Node { int Step , F , L ; } ;
struct Set { int Step , Val ; } s[M * M * M] ;
inline bool operator < (Set a , Set b) { return a.Val < b.Val ; }
inline void Solve1() {
	memset(f1 , -63 , sizeof(f1)) ;
	f1[0][0] = upp ;
	for(int i = 1 ; i <= n ; i ++) {
		for(int j = 0 ; j <= i ; j ++) {
			if(f1[i - 1][j] - a[i] >= 0) f1[i][j] = max(f1[i][j] , f1[i - 1][j] - a[i]) ;
			if(j > 0 && f1[i - 1][j - 1] - a[i] >= 0) f1[i][j] = max(f1[i][j] , f1[i - 1][j - 1] - a[i] + w[i]) ;
		    f1[i][j] = min(f1[i][j] , upp) ;
		}
	}
	for(int i = 1 ; i <= n ; i ++)
	    for(int j = 0 ; j <= i ; j ++)
	        if(f1[i][j] >= 0)
	            restep = max(restep , i - j) ;
}
inline void BFS() {
	int st , F , L ;
	queue < Node > q ; q.push((Node) { 1 , 1 , 0 }) ;
	s[++cnt].Step = 1 ; s[cnt].Val = 1 ; p[1][1] = true ;
	while(!q.empty()) {
		st = q.front().Step , L = q.front().L , F = q.front().F ; q.pop() ;
		if(st == restep) continue ;
		q.push((Node) { st + 1 , F , L + 1 }) ;
		if(L > 1 && 1LL * F * L <= maxhp && !p[st + 1][F * L]) {
			p[st + 1][F * L] = true ;
			s[++cnt].Step = st + 1 , s[cnt].Val = F * L ;
			q.push((Node) { st + 1 , F * L , L }) ;
		}
	}
}

int main() {
	n = read() ; m = read() ; upp = read() ;
	for(int i = 1 ; i <= n ; i ++) a[i] = read() ;
	for(int i = 1 ; i <= n ; i ++) w[i] = read() ;
	for(int i = 1 ; i <= m ; i ++) HP[i] = read() , maxhp = max(maxhp , HP[i]) ;
	Solve1() ; BFS() ;
	sort(s + 1 , s + cnt + 1) ;
	for(int i = 1 ; i <= m ; i ++) {
		if(HP[i] <= restep) { printf("1\n") ; continue ; }
		int Mday = INF ; bool o = false ;
		for(int R = cnt , L = 1 ; R >= 1 ; R --) {
			while(L < R && s[L].Val + s[R].Val <= HP[i]) {
			    Mday = min(Mday , s[L].Step - s[L].Val) ;
				++ L ;
			}
			if(Mday + HP[i] <= restep + s[R].Val - s[R].Step) 
			{ o = true ; break ; }
		    if(s[R].Val <= HP[i] && HP[i] - s[R].Val + s[R].Step <= restep) 
		    { o = true ; break ; }
		}
		if(o) printf("1\n") ; else printf("0\n") ;
	}
	return 0 ;
}