Description
人们总是难免会碰到大佬。他们趾高气昂地谈论凡人不能理解的算法和数据结构，走到任何一个地方，大佬的气场就能让周围的人吓得瑟瑟发抖，不敢言语。
你作为一个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，你能且仅能选择如下的行为之一：
1.还一句嘴，大佬会有点惊讶，导致大佬的自信值C减小1。
2.做一天的水题，使得自己的当前自信值增加 w[i],并将新自信值和自信值上限 mc比较，若新自信值大于mc，则新自信值更新为mc。
例如，mc=50，当前自信值为40，若w[i]=5，则新自信值为45，若w[i]=11，则新自信值为50。
3.让自己的等级值L加1。
4.让自己的讽刺能力F乘以自己当前等级L，使讽刺能力F更新为F*L。
5.怼大佬，让大佬的自信值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。
和某一个大佬较量时，其他大佬不会插手。
Input
第一行三个正整数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个大佬的初始自信值。
1 ≤n,mc ≤100; 1≤m≤20; 1≤a[i],w[i]≤mc; 1≤C[i] ≤10
Output
共m行，如果能战胜第k个大佬（让他的自信值恰好等于0），那么第k行输出1，否则输出0。
Sample Input
10 20 100
22 18 15 16 20 19 33 15 38 49
92 14 94 92 66 94 1 16 90 51
4
5
9
338
5222
549
7491
9
12
3288
3
1
2191
833
3
6991
2754
3231
360
6
22 18 15 16 20 19 33 15 38 49
92 14 94 92 66 94 1 16 90 51
4
5
9
338
5222
549
7491
9
12
3288
3
1
2191
833
3
6991
2754
3231
360
6
Sample Output
1
1
1
0
0
0
0
1
1
0
1
1
0
0
1
0
0
0
0
1
1
1
0
0
0
0
1
1
0
1
1
0
0
1
0
0
0
0
1
题解Here!
题面好评！题面好评！题面好评！
又一道神题。。。
题目说每天有那么多选择。
但是其实只要不死，那么选择最大伤害可以枚举。
而怎样不死又可以$DP$求解。
具体来说是这样：
首先要保证不死，那么我们设$dp[i][j]$表示当前在$i$天，自信值为$j$，前$i$天中最多可以有$dp[i][j]$天不刷题。
不刷题就是可以用来怼大佬。
其实这就相当于全部的状态都枚举出来的裸$DP$。
做完这一步，我们取$dp$数组的最大值，即最多有多少天可以用来怼大佬。
假设有$D$天。
在D天中，每一天选择$3,4,5$中的某一个来怼大佬。
剩下的天数多退少补执行$1$操作到正好即可。
然而怼大佬只能怼两次。。。
于是开始推限制条件：
设两次怼大佬的情况分别为$(d_1,f_1),(d_2,f_2)$，即花费$d_1,d_2$天打出$f_1,f_2$伤害。
假设大佬生命为$Hp$，那么一定有：
$$Hp-f_1-f_2>=0$$
否则大佬生命值就为负了。。。
然后还要满足能打死，也就是$$Hp-f_1-f_2<=D-d_1-d_2$$
也就是大佬剩下的生命要能在剩余天数内执行操作$1$打完。
当然这是怼两次的情况。。。
也可以选择怼一次，也就是：$$Hp-f_1>=0 && Hp-f_1<=D-d_1$$。
还可以不怼，也就是：$$Hp>=0 && Hp<=D$$
只要有符合条件的就可以怼掉大佬，也就是输出$1$。
怎么做呢？
我们可以用$BFS+ ext{判重}$枚举出所有可能的$(d,f)$。
然后以$f$为第一关键字，$d$为第二关键字，排序。
按照$f$从大到小的枚举第一次怼。
然后我们发现这个是有单调性的：
我们把上面那个限制移个项：$$D>=Hp-f_1+d_1-f_2+d_2$$
$f_1,d_1$是我们枚举的，那么自然$-f_1+d_2$最小即可。
那么在满足$f_1+f_2<=Hp$的条件下，增大$f_2$，即指针向后扫，每次取$-f1+d2$最小，然后比较，扫过去即可。
复杂度是$O( ext{状态数})$的。
附代码：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#define MAXN 110
#define MAXM 2000010
#define MOD 1000007
#define MAX 999999999
using namespace std;
int n,m,q,top=0,maxc=0,maxd=0;
int a[MAXN],w[MAXN],c[MAXN],dp[MAXN][MAXN];
struct node{
int step,f,l;
};
queue<node> que;
pair<int,int> p[MAXM];
inline int read(){
int date=0,w=1;char c=0;
while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
return date*w;
}
namespace Map{
int top=0,head[MOD+10];
struct Edge{
int next,x,y;
}edge[MAXM];
inline void add(int x,int y){
int t=(1LL*x*100+y)%MOD;
top++;
edge[top].x=x;edge[top].y=y;edge[top].next=head[t];head[t]=top;
}
inline bool check(int x,int y){
int t=(1LL*x*100+y)%MOD;
for(int i=head[t];i;i=edge[i].next)if(x==edge[i].x&&y==edge[i].y)return true;
return false;
}
};
void make(){
for(int i=1;i<=n;i++)
for(int j=a[i];j<=q;j++){
dp[i][j-a[i]]=max(dp[i][j-a[i]],dp[i-1][j]+1);
int t=min(q,j-a[i]+w[i]);
dp[i][t]=max(dp[i][t],dp[i-1][j]);
}
for(int i=1;i<=n;i++)for(int j=0;j<=q;j++)maxd=max(maxd,dp[i][j]);
}
void bfs(){
node u,v;
que.push((node){1,1,0});
while(!que.empty()){
u=que.front();
que.pop();
if(u.step<maxd){
que.push((node){u.step+1,u.f,u.l+1});
if(u.l>1&&1LL*u.f*u.l<=1LL*maxc&&!Map::check(u.f*u.l,u.step+1)){
v=(node){u.step+1,u.f*u.l,u.l};
que.push(v);
p[++top]=make_pair(v.f,v.step);
Map::add(v.f,v.step);
}
}
}
}
int solve(int x){
bool flag=false;
int minn=MAX;
for(int i=top,k=1;i>=1;i--){
while(k<=top&&p[i].first+p[k].first<=c[x]){
minn=min(minn,p[k].second-p[k].first);
k++;
}
if(minn+p[i].second-p[i].first+c[x]<=maxd)return 1;
if(p[i].first<=c[x]&&c[x]-p[i].first+p[i].second<=maxd)return 1;
}
return 0;
}
void work(){
for(int i=1;i<=m;i++){
if(c[i]<=maxd){
printf("1
");
continue;
}
printf("%d
",solve(i));
}
}
void init(){
n=read();m=read();q=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++){
c[i]=read();
maxc=max(maxc,c[i]);
}
make();
bfs();
sort(p+1,p+top+1);
}
int main(){
init();
work();
return 0;
}