洛谷P3724 [AH2017/HNOI2017]大佬（决策单调性）

传送门

这个思路很妙诶->这里

以下为了方便，我把自信说成血量好了

虽然表面上看起来每一天有很多种选择，然而我们首先要保证的是不死，然后考虑不死的情况下最多能拿出多少天来进行其他操作。不死可以dp，最大伤害可以枚举

首先我们要保证不死。设$dp[i][j]$表示在第$i$天，血量为$j$时最多多少天不刷题，那么这个可以直接dp出来

我们设$D$为dp数组的最大值，即最多有多少天可以使用

在这$D$天里，我们只需要选3,4,5操作，剩下的就可以多退少补

我们假设两次怼大佬的情况分别为$(d1,f1),(d2,f2)$其中$d$表示需要花费几天，$f$表示能打掉多少血

那么$f1+f2<=HP$，否则大佬生命值就为负的了，还得满足$HP-f1-f2<=D-d1-d2$，也就是说剩下的血要能在剩余的天数内执行操作$1$打完

同理，如果怼一次的话就是$f1<=HP$且$HP-f1<=D-d1$，不怼的话就是$HP>=0,HP<=D$

那么我们可以用dfs+判重枚举出所有的$(d,f)$，然后以$f$为第一关键字，$d$为第二关键字排序，移项，发现要满足$D>=HP-f1+d1-f2+d2$，我们可以枚举$(f1,d1)$，然后发现这$f$是有单调性的，那么就可以弄一个指针在那里扫，然后记录一下满足$f2+f1<=HP$的最小的$-f2+d2$，那么可以O(状态数)通过此题

//minamoto
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#define ll long long
using namespace std;
#define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
char buf[1<<21],*p1=buf,*p2=buf;
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getc()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getc());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
const int N=2100005,mod=3587201;
pair<int,int> Q[N];
int n,m,mc,D,MAXC,tp,Maxsize;
int dp[105][105],a[105],w[105],C[105];
struct ed{int step,F,L;};
queue<ed> Que;
struct ED{
    int ver[N],Next[N],head[mod+5],edge[N],tot;
    inline void insert(int u,int v){
        int tmp=((ll)u*100+v)%mod;
        ver[++tot]=u,Next[tot]=head[tmp],head[tmp]=tot,edge[tot]=v;
    }
    inline bool query(int u,int v){
        int tmp=((ll)u*100+v)%mod;
        for(int i=head[tmp];i;i=Next[i])
        if(u==ver[i]&&v==edge[i]) return true;
        return false;
    }
}map;
//手写map，hash判重 
void init(){
    for(int i=1;i<=n;++i)
    for(int j=a[i];j<=mc;++j){
        cmax(dp[i][j-a[i]],dp[i-1][j]+1);
        int tmp=min(mc,j-a[i]+w[i]);
        cmax(dp[i][tmp],dp[i-1][j]);
    }
    for(int i=1;i<=n;++i)
    for(int j=0;j<=mc;++j)
    cmax(D,dp[i][j]);
}
void bfs(){
    Que.push((ed){1,1,0});//初始状态：使用一天，打出1伤害，等级0。
    while(!Que.empty()){
        ed now=Que.front();Que.pop();
        if(now.step<D){
            Que.push((ed){now.step+1,now.F,now.L+1});//加1等级
            if(now.L>1&&(ll)now.F*now.L<=(ll)MAXC&&!map.query(now.F*now.L,now.step+1)){
                //注意加longlong防止爆int，但哈希炸了也没事
                //下面不用加longlong是因为MAXC在int范围内，如果小于肯定没超 
                ed tmp=(ed){now.step+1,now.F*now.L,now.L};
                Que.push(tmp);
                Q[++tp]=make_pair(tmp.F,tmp.step);
                //此处才加入队列，不能直接从Que取出来就加入，因为只加等级的状态是不优的，只有乘了，才更好。
                map.insert(tmp.F,tmp.step);
            }
        }
    }
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read(),m=read(),mc=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(),cmax(MAXC,C[i]);
    init(),bfs();
    sort(Q+1,Q+1+tp);
    for(int i=1;i<=m;++i){
        if(C[i]<=D){puts("1");continue;}//按照单调性找是否有解。
        int flag=0,mn=0x3f3f3f3f;
        for(int j=tp,k=1;j;--j){
            while(k<tp&&Q[k].first+Q[j].first<=C[i]) cmin(mn,Q[k].second-Q[k].first),++k;
            if(mn-Q[j].first+Q[j].second+C[i]<=D){flag=1;break;}
            if(Q[j].first<=C[i]&&C[i]-Q[j].first+Q[j].second<=D){flag=1;break;}
        }
        printf("%d
",flag);
    }
    return 0;
}