洛谷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[<<],*p1=buf,*p2=buf;
 template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,:;}
 template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,:;}
 inline int read(){
     #define num ch-'0'
     char ch;bool flag=;int res;
     while(!isdigit(ch=getc()))
     (ch=='-')&&(flag=true);
     for(res=num;isdigit(ch=getc());res=res*+num);
     (flag)&&(res=-res);
     #undef num
     return res;
 }
 const int N=,mod=;
 pair<int,int> Q[N];
 int n,m,mc,D,MAXC,tp,Maxsize;
 int dp[][],a[],w[],C[];
 struct ed{int step,F,L;};
 queue<ed> Que;
 struct ED{
     int ver[N],Next[N],head[mod+],edge[N],tot;
     inline void insert(int u,int v){
         int tmp=((ll)u*+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*+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=;i<=n;++i)
     for(int j=a[i];j<=mc;++j){
         cmax(dp[i][j-a[i]],dp[i-][j]+);
         int tmp=min(mc,j-a[i]+w[i]);
         cmax(dp[i][tmp],dp[i-][j]);
     }
     for(int i=;i<=n;++i)
     for(int j=;j<=mc;++j)
     cmax(D,dp[i][j]);
 }
 void bfs(){
     Que.push((ed){,,});//初始状态：使用一天，打出1伤害，等级0。
     while(!Que.empty()){
         ed now=Que.front();Que.pop();
         if(now.step<D){
             Que.push((ed){now.step+,now.F,now.L+});//加1等级
             if(now.L>&&(ll)now.F*now.L<=(ll)MAXC&&!map.query(now.F*now.L,now.step+)){
                 //注意加longlong防止爆int，但哈希炸了也没事
                 //下面不用加longlong是因为MAXC在int范围内，如果小于肯定没超
                 ed tmp=(ed){now.step+,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=;i<=n;++i) a[i]=read();
     for(int i=;i<=n;++i) w[i]=read();
     for(int i=;i<=m;++i) C[i]=read(),cmax(MAXC,C[i]);
     init(),bfs();
     sort(Q+,Q++tp);
     for(int i=;i<=m;++i){
         if(C[i]<=D){puts("");continue;}//按照单调性找是否有解。
         int flag=,mn=0x3f3f3f3f;
         for(int j=tp,k=;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=;break;}
             if(Q[j].first<=C[i]&&C[i]-Q[j].first+Q[j].second<=D){flag=;break;}
         }
         printf("%d\n",flag);
     }
     return ;
 }