【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，你能且仅能选择如下的行为之一：

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。和某一个大佬较量时，其他大佬不会插手。

输入输出格式

输入格式：

第一行三个正整数 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

题解：
正解感觉需要脑洞，首先要意识到除了增加自信心和扣自信心以外的操作，都不需要在连续几天内完成，于是我们要求出最多能活几天（不做增加自信（刷题）操作）（设为md）.

于是我们要求出这个md，于是用DP求，设F[i][j]为前i天能力值为j最多能活几天（除刷题外有多少天）

然后就是背包的转移方程：

设 tmp=min(mc,j-a[i]+w[i]) （不能超出自信心上限）

F[i][j-a[i]]=max(F[i][j-a[i]],F[i-1][j]+1)，F[i][tmp]=max(F[i-1][j],F[i][tmp]).

然后就枚举最大的F[i][j]作为md

然后用md去得到所有的("怼dalao")方案，一共两维，一个是讽刺值，一个是到这个讽刺值需要的天数

这个一个bfs可以处理出

最后就是判断是否打败dalao：(设大佬自信值为Q)

1.如果Q<=md 那就直接还嘴还死，puts(1).

2.然后就是怼一次：设方案的讽刺值为f1，需要d1天 那么f1+md-d1>=Q 即可

3.怼两次：双指针枚举，复杂度O(n)：设第二个方案的讽刺值为f2，需要f2天 那么f1+f2+md-d1-d2>=Q 即可

移项：f2-d2>=Q+d1-f1-md 因为右边是定值，所以找出左边的最大值比较，满足则put(1).

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int N=105,M=2000005,MOD=9875321,INF=1999999999;
int gi(){
    int str=0;char ch=getchar();
    while(ch>'9' || ch<'0')ch=getchar();
    while(ch>='0' && ch<='9')str=str*10+ch-48,ch=getchar();
    return str;
}
int n,m,mc,a[N],w[N],F[N][N],ques[23];
struct node{
    int day,lev,fc;
};
struct Lin{
    int next,x,y;
}mp[M*2];
int head[MOD+10],num=0,ml=0,tot=0;
void add(int x,int y)
{
    int k=((long long)x*101+y)%MOD;
    mp[++num].next=head[k];mp[num].x=x;mp[num].y=y;head[k]=num;
}
bool Ask(int x,int y)
{
    int k=((long long)x*101+y)%MOD;
    for(int i=head[k];i;i=mp[i].next)if(mp[i].x==x && mp[i].y==y)return false;
    return true;
}
queue<node>q;
struct Ways{
    int d,fc;
}e[M];
void bfs(int md)
{
    node x;
    q.push((node){1,0,1});
    while(!q.empty())
    {
        x=q.front();q.pop();
        if(x.day>=md)continue;
        q.push((node){x.day+1,x.lev+1,x.fc});
        if(x.lev<=1 || (long long)x.lev*x.fc>ml || !Ask(x.lev*x.fc,x.lev))continue;
        q.push((node){x.day+1,x.lev,x.fc*x.lev});
        add(x.fc*x.lev,x.lev);
        e[++tot].d=x.day+1;e[tot].fc=x.lev*x.fc;
    }
}
bool comp(const Ways &p,const Ways &q){return p.fc<q.fc;}
int main()
{
    n=gi();m=gi();mc=gi();
    int pp;
    for(int i=1;i<=n;i++)a[i]=gi();
    for(int i=1;i<=n;i++)w[i]=gi();
    for(int i=1;i<=m;i++){
        ques[i]=gi();
        if(ques[i]>ml)ml=ques[i];
    }
    for(int i=0;i<=n;i++)for(int j=0;j<=mc;j++)F[i][j]=-n;
    F[0][mc]=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=a[i];j<=mc;j++)
        {
            F[i][j-a[i]]=max(F[i][j-a[i]],F[i-1][j]+1);
            pp=min(mc,j-a[i]+w[i]);
            if(F[i-1][j]>F[i][pp])F[i][pp]=F[i-1][j];
        }
    }
    int md=0;
    for(int i=1;i<=n;i++)for(int j=0;j<=mc;j++)if(F[i][j]>md)md=F[i][j];
    bfs(md);
    int flag=0,k,mx;
    sort(e+1,e+tot+1,comp);
    for(int i=1;i<=m;i++)
    {
        if(ques[i]<=md){printf("1
");continue;}
        k=1;mx=-INF;flag=0;
        for(int j=tot;j>=1;j--)
        {
            while(k<=tot && e[k].fc+e[j].fc<=ques[i]){if(e[k].fc-e[k].d>mx)mx=e[k].fc-e[k].d;k++;}
            if(mx>=ques[i]+e[j].d-e[j].fc-md){flag=1;break;}
            if(e[j].fc<=ques[i] && e[j].fc+md-e[j].d>=ques[i]){flag=1;break;}
        }
        printf("%d
",flag);
    }
    return 0;
}