AtCoder Grand Contest 024

链接

D. Isomorphism Freak

大水题。可以证明任意染色方案都可以转化为以某个点（或边的中点）为根时任意点所有儿子同构。

由于 $n$ 很小，直接枚举以哪个点（边）为根，直接统计某一深度的儿子最大值再累乘即可。

可以发现度数为 $2$ 的点没有贡献，度数为 $3$ 的点深度最多是 50，总答案在 long long 范围内。

复杂度 $O(n^2)$。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#define N 210
#define ll long long
using namespace std;
vector<int>g[N];
int son[N];
void dfs(int u,int p,int d)
{
    int t=0;
    for(int v:g[u]) if(v!=p) dfs(v,u,d+1),++t;
    son[d]=max(son[d],t);
}
int md;ll ans;
void solve(int u,int v)
{
    if(v==0)
    {
        int d=0;
        memset(son,0,sizeof(son));
        dfs(u,0,1);
        long long res=1;
        for(d=1;son[d];d++) res*=son[d];
        if(d>md) return;
        if(d==md) ans=min(ans,res);
        else md=d,ans=res;
    }
    else
    {
        int d=0;
        memset(son,0,sizeof(son));
        dfs(u,v,1);dfs(v,u,1);son[0]=2;
        long long res=1;
        for(d=0;son[d];d++) res*=son[d];
        if(d>md) return;
        if(d==md) ans=min(ans,res);
        else md=d,ans=res;
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1,u,v;i<n;i++) scanf("%d%d",&u,&v),g[u].push_back(v),g[v].push_back(u);
    md=n;
    for(int i=1;i<=n;i++) solve(i,0);
    for(int u=1;u<=n;u++) for(int v:g[u]) if(u<v) solve(u,v);
    printf("%d %lld\n",md,ans);
    return 0;
}

E. Sequence Growing Hard

考虑什么情况下会有计重问题：比如 $1223\rightarrow 12223$，往中间三个位置插入 $2$ 都是等价的。

那么我们不妨假设永远在相同字典序最后加字符。可以发现这样规定后，字典序递增也解决了：只要插入的字符字典序大于插入前的字符即可。

这样可以设计一个 dp：令 $f_{i,j,k}$ 表示当前长度为 $i$，加入的字符是 $j$，当前插入字符前面有 $k$ 个字符。

如果当前位置不放置字符，那么 $f_{i,j,k}\rightarrow f_{i,j,k-1}$。

如果不放置当前数字，那么 $f_{i,j,k}\rightarrow f_{i,j+1,k}$，但为了防止记重，这里要求已经不能放置该字符，即 $k=0$。

考虑如果当前位置插入字符，看似只有一种决策，但是注意这种情况：$133311\rightarrow 1333121$。此时插入的字符并不是 $j$。看起来 dp 状态有问题？但是注意我们要求插入的顺序必须从小到大，即上述字符我们应当先插入 $2$ 再插入 $3$。换句话说，除了插入之外还有一个删除的顺序。那么对于前面还有 $k$ 个字符的位置来说，就有 $k+1$ 种删除的顺序，所以应该有 $f_{i,j,k}\rightarrow^{\times (k+1)} f_{i+1,j,k}$

总复杂度 $O(n^3)$。

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 310
using namespace std;
int f[N][N][N],mod;
int main()
{
    int n,m;
    scanf("%d%d%d",&n,&m,&mod);
    for(int i=1;i<=m;i++) f[1][i][0]=1;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            for(int k=i;k;k--) f[i+1][j][k]=(f[i+1][j][k]+1ll*f[i][j][k]*(k+1))%mod,f[i][j][k-1]=(f[i][j][k-1]+f[i][j][k])%mod;
            f[i][j+1][i]=(f[i][j+1][i]+f[i][j][0])%mod;
            f[i+1][j][0]=(f[i+1][j][0]+f[i][j][0])%mod;
        }
    printf("%d\n",f[n][m][0]);
    return 0;
}

F. Simple Subsequence Problem

题意

给定若干长度不超过 $n$ 的字符串，问满足是其中 $k$ 个字符串子序列的字符串最长是多少，在此前提下要求字典序最小。$n\leq 20$。

题解

经典 DFA 题。

考虑有种东西叫做序列自动机，就是每次贪心往后找某个字符第一次出现的位置。

对于这道题，注意到事实上可行串的个数并不多，所以考虑对于每一个串都求出它是多少个串的子串。

具体来说，定义状态 $A|B$ 表示剩余能匹配的字符串是 $B$，已经匹配的字符串是 $A$。转移可以直接停止（$A|\epsilon$），匹配 $1$（$A1|B_1$），匹配 $0$，（$A0|B_0$）。

注意虽然 $A,B$ 都是 $2^n$，但是 $A$ 和 $B$ 总长度是 $n$，所以总状态数 $n2^n$。这里有一个小 trick，即记录状态 $1AB$ 和 $|B|$，这样找到第一个 $1$，就能唯一确定一组 $\{A,B\}$。

最后一遍扫描即可。总复杂度 $O(2^nn)$。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<bitset>
#define N 21
using namespace std;
int f[1<<N][N],_2[N+2];
short c0[1<<N],c1[1<<N];//c0,c1:1x，标志 1 后第一个 0 的位置和第一个 1 的位置
int pre0(int x,int lx){return 1<<lx|x;}
int calc(int x,int y,int ly){return (x<<ly)|y;}
char s[1<<N];
int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    int m=1<<(n+1);
    for(int i=1;i<=n+1;i++) _2[i]=_2[i-1]<<1|1;
    memset(c0,-1,sizeof(c0));memset(c1,-1,sizeof(c1));
    for(int i=2;i<m;i++)
    {
        if(c0[i>>1]!=-1) c0[i]=c0[i>>1]+1;
        if(c1[i>>1]!=-1) c1[i]=c1[i>>1]+1;
        if((i&1) && c1[i]==-1) c1[i]=0;
        if(!(i&1) && c0[i]==-1) c0[i]=0;
    }
    for(int i=0;i<=n;i++)
    {
        scanf("%s",s);
        for(int j=0;j<1<<i;j++) if(s[j]=='1') f[calc(1,j,i)][i]++;
    }
    for(int i=n;i>0;i--)
        for(int s=1;s<m;s++)
        if(f[s][i])
        {
            int t=s>>i,u=pre0(s&_2[i],i);
            // cout<<bitset<5>(s)<<" "<<i<<" "<<bitset<5>(u)<<" : ";
            if(c0[u]!=-1)
            {
                int v=t<<(c0[u]+1)|(s&_2[c0[u]]);
                f[v][c0[u]]+=f[s][i];
                // cout<<bitset<5>(v)<<","<<c0[u]<<" ";
            }
            if(c1[u]!=-1)
            {
                int v=t<<(c1[u]+1)|(1<<c1[u])|(s&_2[c1[u]]);
                f[v][c1[u]]+=f[s][i];
                // cout<<bitset<5>(v)<<","<<c1[u]<<" ";
            }
            f[t][0]+=f[s][i];
            // cout<<" "<<f[s][i]<<endl;
        }
    int mn=m,len=0;
    for(int s=1;s<m;s++)
    if(f[s][0]>=k)
    {
        int t=-1;
        for(int i=n;i>=0;i--) if(s>>i&1){t=i;break;}
        if(t>len) len=t,mn=s;
        else if(t==len) mn=min(mn,s);
    }
    for(int i=len-1;i>=0;i--) printf("%d",mn>>i&1);
    return 0;
}