[AH2017/HNOI2017]大佬

快来打我* 2022-01-06 15:57 286阅读 0赞

#### 题目描述 ####

人们总是难免会碰到大佬。他们趾高气昂地谈论凡人不能理解的算法和数据结构，走到任何一个地方，大佬的气场就能让周围的人吓得瑟瑟发抖，不敢言语。 你作为一个 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。和某一个大佬较量时，其他大佬不会插手。

#### 题解 ####

非常有意思的一道题、

我们观察到在每一轮中，进攻：1,3,4,5与防守：2是分别独立的，所以我们可以将这两件事分开考虑。

我们的一个策略就是一防守为主，并且能够抽出更多的时间进攻。

观察到关于自己的自信值的值域较小，可以用背包\\(dp\\)求出期间最多能抽出多少时间来进攻。

然后有一个直观的想法就是我们同样\\(dp\\)出进攻的最优方案。

但这样是有问题的。

因为这道题有一个奇怪的限制就是总伤害不能大于敌方血量，所以直接\\(DP\\)就\\(GG\\)了。

观察到我们进攻的方案数可能不是太多？然后我们可以\\(BFS+hash\\)把所有的情况搜索出来。

现在我们有一堆二元组\\((f,d)\\)，我们需要选出0个，1个或者2个来满足：  
\\\[ f1+f2\\leq C\\ \\ \\ \\ f1+f2+(D-d1-d2)\\geq C \\\]  
即在满足第一个限制的同时要尽可能让\\(f2-d2\\)更大。

这就是一个决策单调性的问题了，对于所有的这种二元组，按照\\(f\\)为第一关键字升序排序，按照\\(d\\)为第二关键字降序排序，从后往前枚举第一个二元组，双指针卡第二个元素即可。

#### 代码 ####

// luogu-judger-enable-o2
    #include<iostream>
    #include<cstdio>
    #include<queue>
    #include<cstring>
    #include<algorithm>
    #include<map>
    #define mm make_pair
    #define P pair<int,int>
    #define N 109
    using namespace std;
    typedef long long ll;
    typedef unsigned int ull;
    const int mod=19260817;
    const ll maxc=1e8;
    int dead,n,m,f[N][N],top,a[N],w[N],mc;
    P st[N*N*N*8];
    inline int rd(){
        int x=0;char c=getchar();bool f=0;
        while(!isdigit(c)){if(c=='-')f=1;c=getchar();}
        while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
        return f?-x:x;
    }
    inline bool cmp(P a,P b){
        if(a.first!=b.first)return a.first<b.first;
        else return a.second>b.second;
    }
    struct node{
        int d,l,f;
        inline bool operator <(const node &b)const{
            if(d!=b.d)return d<b.d;
            else if(l!=b.l)return l<b.l;
            else return f<b.f;
        }
    };
    queue<node>q;
    struct hm{
        int head[mod+2],tot;
        struct edge{
            int n;ull to;
        }e[N*N*N*80];
        inline bool insert(node x){
            ull ans=0;
            ans=1ull*(1ull*x.d*233+x.l)*233+(unsigned int)x.f;
            int u=ans%mod;
            for(int i=head[u];i;i=e[i].n){
                ull v=e[i].to;
                if(v==ans)return 1;
            }
            e[++tot].n=head[u];e[tot].to=ans;head[u]=tot;
            return 0;
        }
    }mp;
    inline void bfs(){
        q.push(node{1,0,1});
        while(!q.empty()){
          node u=q.front();q.pop();
          if(u.d==dead)continue;
         // if(mp.find(node{u.d+1,u.l+1,u.f})==mp.end()){
            q.push(node{u.d+1,u.l+1,u.f});
          //  mp[node{u.d+1,u.l+1,u.f}]=1;
        //  }
          if(1ll*u.f*u.l>maxc||mp.insert(node{u.d+1,u.l,u.f*u.l}))continue;
          q.push(node{u.d+1,u.l,u.f*u.l});
          st[++top]=mm(u.f*u.l,u.d+1);
        }
    }
    int main(){
        n=rd();m=rd();mc=rd();
        for(int i=1;i<=n;++i)a[i]=rd();
        for(int i=1;i<=n;++i)w[i]=rd();
        memset(f,-0x3f,sizeof(f));
        f[0][mc]=0;
        for(int i=0;i<n;++i){
          for(int j=0;j<=mc;++j)if(j>=a[i+1]){
            f[i+1][j-a[i+1]]=max(f[i][j]+1,f[i+1][j-a[i+1]]);
            f[i+1][min(mc,j-a[i+1]+w[i+1])]=max(f[i][j],f[i+1][min(mc,j-a[i+1]+w[i+1])]);
          }
          for(int j=0;j<=mc;++j)dead=max(dead,f[i][j]);
        }
        bfs();
        sort(st+1,st+top+1,cmp);
        top=unique(st+1,st+top+1)-st-1;
        while(m--){
            int nowc=rd();
            int p=0,tag=0,maxx=0,nowf=0;
            for(int i=top;i>=1;--i){
                int f1=st[i].first,d1=st[i].second;
                while(p<top&st[p+1].first+f1<=nowc){
                    ++p;
                    if(st[p].first-st[p].second>maxx){
                        nowf=st[p].first;maxx=st[p].first-st[p].second;
                    }
                }
                if(nowf+f1<=nowc&&maxx+f1-d1+dead>=nowc){tag=1;break;}
            }
            printf("%d\n",tag);
        } 
        return 0;
    }

转载于:https://www.cnblogs.com/ZH-comld/p/10577989.html