Noip模拟70 2021.10.6

T1 暴雨

放在第一道的神仙题，不同的做法，吊人有的都在用线段树维护$set$预处理

我是直接$dp$的，可能代码的复杂度比那种的稍微小一点

设$f[i][j][p][0/1]$表示考虑了前$i$列，里面的最大值高度是$j$，

并且后面还至少存在高度为$j$的土块，在前$i$列挖平了$p$个土块，积水的体积是奇数或者偶数的方案数

采用刷表更新$dp$值的方法，更新$f[i][j][k][u]$的所有可能到达的状态

可能有人问数组怎么开，因为$k \leq 26$所以最大值的哪一维只记录前$k+1$大即可

适当的给原数组离散化。

记录几个值

$val[i][j]$表示前$i$列第$j$大的土块的高度，

$cnt[i]$表示前$i$列有几个可以转移的前$j$大值（记录可转移的状态个数）

然后考虑$dp$，用$i$更新$i+1$

考虑两种情况，

1.$val[i][j] \geq a[i+1]$

$f[i+1][J][k][0/1]+=f[i][j][k][0/1]$

$f[i+1][J][k+1][0/1]+=f[i][j][k][0/1]$

2.$val[i][j] \leq a[i+1]$

$f[i+1][a_{i+1}][k][0/1]+=f[i][j][k][0/1]$

$f[i+1][J][k+1][0/1]+=f[i][j][k][0/1]$

直接做转移即可，然后因为$dp$转移的时候有一个限制，就是保证后面至少有一个高度为$j$的土块

所以为了让转移合法，我们从前往后，从后往前分别转移一次

然后考虑对$dp$值合并合并的时候保证$g,f$数组满足转移时候的关系即可

写代码的时候注意不要往超越边界的地方转移，卡一下边界即可

#include<bits/stdc++.h>
#define sit multiset<int>::iterator
using namespace std;
namespace AE86{
    #define out(x) cout<<#x<<":"<<x<<endl
    #define fuck cout<<"fuck"<<endl
    inline int read(){
        int x=0,f=1;char ch=getchar();
        while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
        while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}return x*f;
    }inline void write(int x,char opt='\n'){
        char ch[20];int len=0;if(x<0)x=~x+1,putchar('-');
        do{ch[len++]=x%10+(1<<5)+(1<<4);x/=10;}while(x);
        for(int i=len-1;i>=0;--i)putchar(ch[i]);putchar(opt);}
}using namespace AE86;
const int NN=25010,mod=1e9+7;
int n,K,h[NN],id[NN],ans;
struct DP{
    int a[NN],f[NN][26][26][2],val[NN][26],cnt[NN];
    multiset<int> S;unordered_map<int,int> mp[NN];
    inline void calc(){
        S.insert(0);
        for(int i=1;i<=n;i++){
            S.insert(a[i]); sit it=S.end();
            for(int j=1;j<=K+1;j++){
                if(it==S.begin()) break; --it;
                val[i][mp[i][*it]=++cnt[i]]=*it;
            }
        }
        f[0][1][0][0]=1; val[0][cnt[0]=1]=0;
        for(int i=0;i<n;i++) for(int j=1;j<=cnt[i];j++) for(int k=0;k<=K;k++)
            for(int u=0;u<=1;u++) if(f[i][j][k][u]){
                if(val[i][j]>=a[i+1]){
                    int J=mp[i+1][val[i][j]],sta=u^(val[i][j]-a[i+1]&1);
                    f[i+1][J][k][sta]=(f[i+1][J][k][sta]+f[i][j][k][u])%mod;
                    sta=u^(val[i][j]&1);
                    if(k+1<=K) f[i+1][J][k+1][sta]=(f[i+1][J][k+1][sta]+f[i][j][k][u])%mod;
                }else{
                    int J=mp[i+1][a[i+1]],sta=u^(val[i][j]&1);
                    f[i+1][J][k][u]=(f[i+1][J][k][u]+f[i][j][k][u])%mod;
                    J=mp[i+1][val[i][j]];
                    if(k+1<=K) f[i+1][J][k+1][sta]=(f[i+1][J][k+1][sta]+f[i][j][k][u])%mod;
                }
        }
    }
}F,G;
namespace WSN{
    inline short main(){
        freopen("rain.in","r",stdin);
        freopen("rain.out","w",stdout);
        n=read(); K=read(); for(int i=1;i<=n;i++) h[i]=read(),F.a[i]=G.a[n-i+1]=h[i],id[i]=i;
        F.calc(); G.calc();
        sort(id+1,id+n+1,[](int x,int y)->bool{return h[x]>h[y];});
        for(int i=1;i<=n;i++){
            if(h[id[i]]<h[id[K+1]]) break;
            int now=id[i],val=h[now];
            for(int j=F.cnt[now-1];j;j--){
                if(F.val[now-1][j]>val) break;
                for(int k=G.cnt[n-now];k;k--){
                    if(G.val[n-now][k]>=val) break;
                    for(int u=0;u<=K;u++){
                        ans=(ans+1ll*F.f[now-1][j][u][0]*G.f[n-now][k][K-u][0]%mod)%mod;
                        ans=(ans+1ll*F.f[now-1][j][u][1]*G.f[n-now][k][K-u][1]%mod)%mod;
                    }
                }
            }
        } write(ans%mod);
        return 0;
    }
}
signed main(){return WSN::main();}

T2 AVL树

不知道有没有什么简便的暴力

反正我打了$98$行才拿到了$20$分

当时就知道这一场要崩掉了，花了将近一个小时调暴力（？）

早知道去打别的题了，比如$T4$的六十分感觉貌似不难想，就是可能是调有点费劲

然后不会，就咕咕咕了

#include<bits/stdc++.h>
#define int long long
using namespace std;
namespace AE86{
    #define out(x) cout<<"x="<<x<<endl
    #define fuck cout<<"fuck"<<endl
    inline int read(){
        int x=0,f=1;char ch=getchar();
        while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
        while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}return x*f;
    }inline void write(int x,char opt='\n'){
        char ch[20];int len=0;if(x<0)x=~x+1,putchar('-');
        do{ch[len++]=x%10+(1<<5)+(1<<4);x/=10;}while(x);
        for(int i=len-1;i>=0;--i)putchar(ch[i]);putchar(opt);}
}using namespace AE86;
const int NN=5e5+5;
int n,k,fa[NN],son[NN][2],root,dep[NN],mdp[NN];
bool vis[NN];
inline void getdep(int f,int x){
    if(son[x][0]){
        dep[son[x][0]]=dep[x]+1;
        getdep(x,son[x][0]);
    }
    if(son[x][1]){
        dep[son[x][1]]=dep[x]+1;
        getdep(x,son[x][1]);
    }
}
inline void dfs(int f,int x){
    if(!vis[x]) return;
    mdp[x]=dep[x];
    if(son[x][0]){
        dfs(x,son[x][0]);
        mdp[x]=max(mdp[x],mdp[son[x][0]]);
    }
    if(son[x][1]){
        dfs(x,son[x][1]);
        mdp[x]=max(mdp[x],mdp[son[x][1]]);
    }
}
vector<int> pre;
inline void bian(int x){
    if(son[x][0]&&vis[son[x][0]]) bian(son[x][0]);
    pre.push_back(x);
    if(son[x][1]&&vis[son[x][1]]) bian(son[x][1]);
}
int ans[NN],sta;
namespace WSN{
    inline short main(){
        freopen("avl.in","r",stdin);
        freopen("avl.out","w",stdout);
        n=read(); k=read(); memset(ans,0x3f,sizeof(ans));
        for(int i=1,x;i<=n;i++){
            x=read(); fa[i]=x; son[x][i>x]=i;
            if(x==-1) root=i;
        }
        if(k==1){
            for(int i=1;i<=n;i++) printf(fa[i]!=-1?"0":"1");
            return puts(""),0;
        }
        getdep(-1,root);
        for(int i=1;i<(1<<n);++i) if((i&(1<<root-1))&&__builtin_popcount(i)==k){
            for(int i=1;i<=n;++i) mdp[i]=0;
            for(int j=1;j<=n;++j) if(i&(1<<j-1)) vis[j]=1;
            dfs(-1,root); bool flag=0;
            for(int j=1;j<=n;++j){
                if(vis[j]&&(vis[son[j][0]]||vis[son[j][1]])){
                    int a=mdp[son[j][0]]-dep[son[j][0]];
                    int b=mdp[son[j][1]]-dep[son[j][1]];
                    if(!vis[son[j][0]]) a=-1;
                    if(!vis[son[j][1]]) b=-1;
                    if(abs(a-b)>1){flag=1;break;}
                }
            }
            if(!flag){
                pre.clear(); bian(root);
                if(pre.size()==k){
                    for(int j=0;j<pre.size();++j){
                        if(ans[j+1]>pre[j]){
                            for(int j=0;j<pre.size();++j) ans[j+1]=pre[j];
                            sta=i; break;
                        }
                        if(ans[j+1]<pre[j]) break;
                    }
                }
            }
            for(int j=1;j<=n;++j) if(i&(1<<j-1)) vis[j]=0;
        }
        for(int i=1;i<(1<<n);++i) if(sta==i){
            for(int j=1;j<=n;++j)
                if(i&(1<<j-1)) printf("1");
                else printf("0"); puts("");
            break;
        }
        return 0;
    }
}
signed main(){return WSN::main();}

T3 挖掘机

文件名叫$blueshit$就非常妙

自己的$OJ$评测姬比较快，有的拿分块写的

但是正解好像是倍增

看得到行数比较小，而且每一行不联系，所以直接一行一行搞

然后发现找到一个在$[l,r]$区间内的$X$就可以消掉连续的$k$个，这样一定最优

那么我们以$k$为一段，倍增去跳这个段数，然后你选择从$r$忘前跳和从$l$往后跳都可以，就是往后跳的时候边界的处理比较麻烦，建议往前跳

#include<bits/stdc++.h>
using namespace std;
namespace AE86{
    #define out(x) cout<<"x="<<x<<endl
    #define fuck cout<<"fuck"<<endl
    inline int read(){
        int x=0,f=1;char ch=getchar();
        while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
        while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}return x*f;
    }inline void write(int x,char opt='\n'){
        char ch[20];int len=0;if(x<0)x=~x+1,putchar('-');
        do{ch[len++]=x%10+(1<<5)+(1<<4);x/=10;}while(x);
        for(int i=len-1;i>=0;--i)putchar(ch[i]);putchar(opt);}
}using namespace AE86;
const int NN=1e5+5;
int h,w,k,q,d,l,r,a[13][NN],sum[13][NN],b[13][NN],ans;
int bz[13][NN][18];
char ch[NN];
namespace WSN{
    inline short main(){
        freopen("blueshit.in","r",stdin);
        freopen("blueshit.out","w",stdout);
        h=read();w=read();k=read();q=read();
        for(int i=1;i<=h;++i){ scanf("%s",ch+1); bz[i][w+1][0]=w+1;
            for(int j=w;j;--j) bz[i][j][0]=ch[j]=='X'?j:bz[i][j+1][0];
        }
        for(int i=1;i<=h;++i) for(int j=w+1;j;--j) for(int u=1;u<=17;++u)
            bz[i][j][u]=bz[i][min(bz[i][j][u-1]+k,w+1)][u-1];
        while(q--){
            d=read();l=read();r=read();ans=0;
            for(int i=1;i<=d;++i){ int pos=l;
                for(int j=17;~j;--j) if(bz[i][pos][j]<=r)
                    ans+=1<<j,pos=min(bz[i][pos][j]+k,w+1);
            }
            write(ans);
        }
        return 0;
    }
}
signed main(){return WSN::main();}

#include<bits/stdc++.h>
using namespace std;
namespace AE86{
    #define out(x) cout<<"x="<<x<<endl
    #define fuck cout<<"fuck"<<endl
    inline int read(){
        int x=0,f=1;char ch=getchar();
        while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
        while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}return x*f;
    }inline void write(int x,char opt='\n'){
        char ch[20];int len=0;if(x<0)x=~x+1,putchar('-');
        do{ch[len++]=x%10+(1<<5)+(1<<4);x/=10;}while(x);
        for(int i=len-1;i>=0;--i)putchar(ch[i]);putchar(opt);}
}using namespace AE86;
const int NN=1e5+5;
int h,w,k,q,d,l,r,a[13][NN],sum[13][NN],b[13][NN],ans;
int bz[13][NN][18];
char ch[NN];
namespace WSN{
    inline short main(){
        freopen("blueshit.in","r",stdin);
        freopen("blueshit.out","w",stdout);
        h=read();w=read();k=read();q=read();
        for(int i=1;i<=h;++i){ scanf("%s",ch+1);
            for(int j=1;j<=w;++j) bz[i][j][0]=ch[j]=='X'?j:bz[i][j-1][0];
        }
        for(int i=1;i<=h;i++) for(int j=1;j<=w;j++) for(int u=1;u<=17;u++)
            bz[i][j][u]=bz[i][max(bz[i][j][u-1]-k,0)][u-1];
        while(q--){
            d=read();l=read();r=read();ans=0;
            for(int i=1;i<=d;i++){ int pos=r;
                for(int j=17;~j;j--) if(bz[i][pos][j]>=l)
                    ans+=1<<j,pos=max(bz[i][pos][j]-k,0);
            } write(ans);
        }
        return 0;
    }
}
signed main(){return WSN::main();}

T4 游戏

$n^2$的暴力考后打了出来

枚举两个字符串的初始匹配点，然后二分找到最长的匹配长度，更新平局的树状数组，然后从最长匹配点后面比较字典序

然后更新两者谁胜谁负的树状数组，最后直接查询即可

#include<stdio.h>
#include<cstring>
#define int long long
typedef unsigned long long ULL;
const ULL base=131;
const int NN=8010;
int n,m,k;
char A[NN],B[NN];
ULL a[NN],b[NN],pw[NN];
struct BIT{
    int tr[NN];
    inline void update(int x,int v){
        ++x;while(x<NN) tr[x]+=v,x+=(x&(-x));
    }
    inline int query(int x,int ans=0){
        ++x;while(x) ans+=tr[x],x-=(x&(-x));
        return ans;
    }
}c1,c2,c3;

inline int _min_(int a,int b){return a<b?a:b;}
inline ULL get(int l,int r,ULL *a){
    return a[r]-a[l-1]*pw[r-l+1];
}
inline int gcd(int a,int b){
    return b?gcd(b,a%b):a;
}
inline bool check(int p1,int p2,int len){
    if(p1+len-1>n||p2+len-1>m) return 0;
    return get(p1,p1+len-1,a)==get(p2,p2+len-1,b);
}
int st1,st2,ed,l,r,ans,mid;
namespace WSN{
    inline short main(){
        freopen("game.in","r",stdin);
        freopen("game.out","w",stdout);
        pw[0]=1; for(int i=1;i<NN;++i) pw[i]=pw[i-1]*base;
        scanf("%s",A+1); scanf("%s",B+1);
        n=strlen(A+1); m=strlen(B+1); k=_min_(n,m);
        for(int i=1;i<=n;++i) a[i]=a[i-1]*base+(ULL)(A[i]-'a'+1);
        for(int i=1;i<=m;++i) b[i]=b[i-1]*base+(ULL)(B[i]-'a'+1);
        for(int i=1;i<=n;++i){
            for(int j=1;j<=m;++j){
                ans=0; ed=_min_(n-i+1,m-j+1);
                if(A[i]==B[j]){
                    l=0,r=ed;
                    while(l<=r){
                        mid=l+r>>1;
                        if(check(i,j,mid)) l=mid+1,ans=mid;
                        else r=mid-1;
                    }c2.update(1,1); c2.update(ans+1,-1);
                }st1=i+ans,st2=j+ans;
                if(A[st1]<B[st2]) c1.update(ans+1,1),c1.update(ed+1,-1);
                else c3.update(ans+1,1),c3.update(ed+1,-1);
            }
        }
        for(int a1,a2,a3,GCD,tot,b1,b2,b3,C1,C2,C3,i=1;i<=k;++i){
            a1=c1.query(i),a2=c2.query(i),a3=c3.query(i);
            GCD=gcd(a1,gcd(a2,a3)),tot=a1/GCD+a2/GCD+a3/GCD;
            b1=a1/GCD,b2=a2/GCD,b3=a3/GCD;
            C1=gcd(b1,tot),C2=gcd(b2,tot),C3=gcd(b3,tot);
            printf("%lld/%lld %lld/%lld %lld/%lld\n",b1/C1,tot/C1,b2/C2,tot/C2,b3/C3,tot/C3);
        }
        return 0;
    }
}
signed main(){return WSN::main();}