寒假实录 chapter 1

最新推荐文章于 2023-04-26 16:40:30 发布
最新推荐文章于 2023-04-26 16:40:30 发布
阅读量216 收藏
点赞数
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_40948489/article/details/103824008
版权

P1006 传纸条

解：题意可以转化为两个人从起点出发到终点的不重复路径，定义数组dp[i][j][k],表示前i步第一个人在j列，第二个人在k列的最大满意度。

#include <bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
typedef long long ll;
int a[100][100];
int dp[200][100][100];
int n,m;
int main()
{
    scanf("%d %d",&m,&n);
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
    memset(dp,-1,sizeof dp);
    dp[2][1][1]=0;
    for(int i=3;i<n+m;i++)
    {
        for(int j=1;j<=n;j++)
        {
            for(int k=j+1;k<=n;k++)
            {
                int tmp=dp[i][j][k];
                if(dp[i-1][j][k]>tmp) tmp=dp[i-1][j][k];
                if(dp[i-1][j-1][k]>tmp) tmp=dp[i-1][j-1][k];
                if(dp[i-1][j][k-1]>tmp) tmp=dp[i-1][j][k-1];
                if(dp[i-1][j-1][k-1]>tmp) tmp=dp[i-1][j-1][k-1];
                if(tmp==-1) continue;
                dp[i][j][k]=tmp+a[i-j][j]+a[i-k][k];
            }
        }
    }
    printf("%d\n",max(dp[n+m-1][n][n-1],dp[n+m-1][n-1][n]));
    return 0;

}

P1417 烹调方案

解：乍一看我觉得事背包问题，其实b[i]这个属性对于顺序是有影响的。

两种情况：当i先被选时有x=a_{i}-(t+c_{i})*b_{i}+a_{j}-(t+c_{i}+c_{j})*b_{j}

当j先被选时有y=a_{j}-(t+c_{j})*b_{j}+a_{i}-(t+c_{i}+c_{j})*b_{i}。

当i应当被选时有x>y，化简后即为-b_{j}*c_{i}>-b_{i}*c_{j}

按照这个结果排个序。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
struct node
{
    ll a,b,c;
}p[100];
int T,n;
ll dp[100010];
bool cmp(node x,node y)
{
    return -y.b*x.c>-x.b*y.c;
}
int main()
{
    scanf("%d %d",&T,&n);
    for(int i=1;i<=n;i++) scanf("%d",&p[i].a);
    for(int i=1;i<=n;i++) scanf("%d",&p[i].b);
    for(int i=1;i<=n;i++) scanf("%d",&p[i].c);
    sort(p+1,p+n+1,cmp);
    for(int i=1;i<=n;i++)
    {
        for(int j=T;j>=p[i].c;j--)
        {
            dp[j]=max(dp[j-p[i].c]+p[i].a-j*p[i].b,dp[j]);
        }
    }
    ll ans=0;
    for(int i=1;i<=T;i++) ans=max(ans,dp[i]);
    printf("%d\n",ans);
    return 0;
}

P1736 创意吃鱼法

解：用两个数组a,b分别维护向左(右)和向上的最长的0(不包括当前点)。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
int dp[2510][2510];
int n,m;
int a[2510][2510];
int L[2510][2510],up[2510][2510];
int main()
{
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        memset(L,0,sizeof L);
        memset(up,0,sizeof up);
        memset(dp,0,sizeof dp);
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                scanf("%d",&a[i][j]);
            }
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(!a[i][j])
                {
                    L[i][j]=L[i][j-1]+1;
                    up[i][j]=up[i-1][j]+1;
                }
                else
                {
                    dp[i][j]=min(dp[i-1][j-1],min(L[i][j-1],up[i-1][j]))+1;
                    ans=max(ans,dp[i][j]);
                }
            }
        }
        memset(L,0,sizeof L);
        memset(up,0,sizeof up);
        memset(dp,0,sizeof dp);
        for(int i=1;i<=n;i++)
        {
            for(int j=m;j>=1;j--)
            {
                if(!a[i][j])
                {
                    L[i][j]=L[i][j+1]+1;
                    up[i][j]=up[i-1][j]+1;
                }
                else
                {
                    dp[i][j]=min(dp[i-1][j+1],min(L[i][j+1],up[i-1][j]))+1;
                    ans=max(ans,dp[i][j]);
                }
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

P1064 金明的预算方案

解：有依赖的背包问题。因为本题的主件最多只有2个附件。那么这个主机的所有附件组合集合可以直接枚举。转化为分组背包问题，每组的物品即是该主件和附件的所有组合情况。

小数据写法

#include <bits/stdc++.h>
using namespace std;
#define ll long long
struct node
{
    int v,p,q;
};
node a[100];
vector<node> g[100];
vector<node> p[100];
int dp[32010];
int N,m;
int main()
{
    scanf("%d %d",&N,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d %d %d",&a[i].v,&a[i].p,&a[i].q);
        if(a[i].q)
        {
            g[a[i].q].push_back(a[i]);
        }
        else g[i].push_back(a[i]);
    }
    for(int i=1;i<=m;i++)
    {
        if(g[i].size()==3)
        {
            p[i].push_back(node{g[i][0].v,g[i][0].v*g[i][0].p,0});
            p[i].push_back(node{g[i][0].v+g[i][1].v,g[i][0].v*g[i][0].p+g[i][1].v*g[i][1].p,0});
            p[i].push_back(node{g[i][0].v+g[i][2].v,g[i][0].v*g[i][0].p+g[i][2].v*g[i][2].p,0});
            p[i].push_back(node{g[i][0].v+g[i][2].v+g[i][1].v,g[i][0].v*g[i][0].p+g[i][1].v*g[i][1].p+g[i][2].v*g[i][2].p,0});
        }
        else if(g[i].size()==2)
        {
            p[i].push_back(node{g[i][0].v,g[i][0].v*g[i][0].p,0});
            p[i].push_back(node{g[i][0].v+g[i][1].v,g[i][0].v*g[i][0].p+g[i][1].v*g[i][1].p,0});
        }
        else if(g[i].size()==1)
        {
            p[i].push_back(node{g[i][0].v,g[i][0].v*g[i][0].p,0});
        }
    }
    for(int i=1;i<=m;i++)
    {
        if(p[i].size()!=0)
        {
            for(int j=N;j>=0;j--)
            {
                for(int k=0;k<p[i].size();k++)
                {
                    if(j>=p[i][k].v)
                        dp[j]=max(dp[j],dp[j-p[i][k].v]+p[i][k].p);
                }
            }
        }
    }
    printf("%d\n",dp[N]);
    return 0;
}

大数据写法（貌似我的常熟不够优秀）（做法参见背包九讲2.0）

#include <bits/stdc++.h>
using namespace std;
#define ll long long
struct node
{
    int v,p,q;
};
node a[1010];
vector<node> g[1010];
vector<node> p[1010];
int dp[100010];
int N,m;
int main()
{
    scanf("%d %d",&N,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d %d %d",&a[i].v,&a[i].p,&a[i].q);
        if(a[i].q)
        {
            g[a[i].q].push_back(a[i]);
        }
        else g[i].push_back(a[i]);
    }
    for(int i=1;i<=m;i++)
    {
        if(g[i].size()!=0)
        {
            memset(dp,-1,sizeof dp);
            dp[0]=0;
            for(int j=1;j<(int)g[i].size();j++){
                for(int k=N-g[i][0].v;k>=g[i][j].v;k--)
                {
                    if(dp[k]<dp[k-g[i][j].v]+g[i][j].v*g[i][j].p&&dp[k-g[i][j].v]!=-1)
                        dp[k]=dp[k-g[i][j].v]+g[i][j].v*g[i][j].p;
                }
            }
            for(int j=0;j<=N-g[i][0].v;j++)
            {
                if(dp[j]!=-1)
                {
                    p[i].push_back(node{j+g[i][0].v,dp[j]+g[i][0].v*g[i][0].p,0});
                }
            }
        }
    }
    memset(dp,0,sizeof dp);
    for(int i=1;i<=m;i++)
    {
        if(p[i].size()!=0)
        {
            for(int j=N;j>=0;j--)
            {
                for(int k=0;k<p[i].size();k++)
                {
                    if(j>=p[i][k].v)
                        dp[j]=max(dp[j],dp[j-p[i][k].v]+p[i][k].p);
                }
            }
        }
    }
    printf("%d\n",dp[N]);
    return 0;
}

P1541 乌龟棋

定义dp[i][j][k][h]，表示当选i张为1的牌、j张为2的牌、k张为3的牌和h张为4的牌的最大分数。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
int N,M;
int a[400];
int b[10];
int dp[42][42][42][42];
int main()
{
    scanf("%d %d",&N,&M);
    for(int i=1;i<=N;i++) scanf("%d",&a[i]);
    for(int j=1;j<=M;j++)
    {
        int x;
        scanf("%d",&x);
        b[x]++;
    }
    dp[0][0][0][0]=a[1];
    for(int i=0;i<=b[1];i++)
    {
        for(int j=0;j<=b[2];j++)
        {
            for(int k=0;k<=b[3];k++)
            {
                for(int l=0;l<=b[4];l++)
                {
                    int now=1+i+2*j+3*k+4*l;
                    if(i!=0)
                        dp[i][j][k][l]=max(dp[i][j][k][l],dp[i-1][j][k][l]+a[now]);
                    if(j!=0)
                        dp[i][j][k][l]=max(dp[i][j][k][l],dp[i][j-1][k][l]+a[now]);
                    if(k!=0)
                        dp[i][j][k][l]=max(dp[i][j][k][l],dp[i][j][k-1][l]+a[now]);
                    if(l!=0)
                        dp[i][j][k][l]=max(dp[i][j][k][l],dp[i][j][k][l-1]+a[now]);
                }
            }
        }
    }
    printf("%d\n",dp[b[1]][b[2]][b[3]][b[4]]);
    return 0;
}

问题记录：为何不能定义dp[i][j]表示用i张牌走到下标为j的时候的最大分数?

P1063 能量项链

解：发现转移方程形如dp[i][j]\leftarrow (dp[i][k],dp[k][j])大概就是区间dp了吧，本题定义dp[i][j]表示数串以a[i]开头，a[j]结尾的最大能量。因为本题是环形，只需要将数组a在复制一段，破环为链。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
int N;
ll a[400];
ll dp[410][410];
int main()
{
    scanf("%d",&N);
    for(int i=1;i<=N;i++)
    {
        scanf("%lld",&a[i]);
        a[i+N]=a[i];
    }
    for(int i=2;i<=N;i++)
    {
        for(int j=1;j+i<=2*N;j++)
        {
            int k=j+i;
            for(int l=j+1;l<=k-1;l++)
            {
                dp[j][k]=max(dp[j][k],dp[j][l]+dp[l][k]+a[j]*a[k]*a[l]);
            }
        }
    }
    ll ans=0;
    for(int i=1;i<=N;i++) ans=max(ans,dp[i][i+N]);
    printf("%lld\n",ans);
    return 0;
}

P1052 过河

解：耳目一新，缩点。因为LCM(1...10)=2520，即无论跳多远和怎么跳都会到达2520这个点，即石头之间的距离对2520取模即可将距离等效缩小。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
int L;
int s,t,M;
int dp[300000];
ll a[200];
int stone[300000];
int flag[200];
int d[200];
int main()
{
    scanf("%d",&L);
    scanf("%d %d %d",&s,&t,&M);
    for(int i=1;i<=M;i++) scanf("%lld",&a[i]);
    sort(a+1,a+M+1);
    for(int i=1;i<=M;i++)
    {
        flag[i]=(a[i]-a[i-1])%2520;
    }
    for(int i=1;i<=M;i++)
    {
        d[i]=flag[i]+d[i-1];
        stone[d[i]]++;
    }
    L=d[M]+t;
    for(int i=1;i<=L;i++) dp[i]=M;
    dp[0]=0;
    for(int i=1;i<=L;i++)
    {
        for(int j=s;j<=t;j++)
        {
            if(j>i) continue;
            if(stone[i]) dp[i]=min(dp[i],dp[i-j]+stone[i]);
            else dp[i]=min(dp[i],dp[i-j]);
        }
    }
    int ans=M;
    for(int i=d[M];i<d[M]+t;i++) ans=min(ans,dp[i]);
    printf("%d\n",ans);
    return 0;
}

Blue Jeans

解：求多个串的最长公共子串。枚举第一个字符串的所有子串用KMP与其他的串进行匹配。

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
string s[20];
int nexts[100];
vector<string> ans;
void getnext(string x)
{
    int m=x.size();
    int i,j;
    j=nexts[0]=-1;
    i=0;
    while(i<m)
    {
        while(j!=-1&&x[i]!=x[j]) j=nexts[j];
        nexts[++i]=++j;
    }
}
bool kmp(string x,string y)
{
    int n=y.size();
    int m=x.size();
    getnext(x);
    int i,j;i=j=0;
    while(i<n)
    {
        while(j!=-1&&x[j]!=y[i]) j=nexts[j];
        ++j;++i;
        if(j>=m)
        {
            return true;
        }
    }
    return false;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T;
    cin>>T;
    while(T--)
    {
        int M;
        cin>>M;
        for(int i=1;i<=M;i++)
        {
            cin>>s[i];
        }
        string com;
        ans.clear();
        for(int i=0;i<s[1].size();i++)
        {
            for(int j=i;j<s[1].size();j++)
            {
                com.clear();
                for(int k=i;k<=j;k++) com+=s[1][k];
                if((int)com.size()<3) continue;
                int flag=0;
                for(int k=2;k<=M;k++)
                {
                    if(kmp(com,s[k])==true)
                    {
                        flag++;
                    }
                }
                if(flag==M-1) ans.push_back(com);
            }
        }
        int mx=0;
        for(int i=0;i<(int)ans.size();i++) mx=max(mx,(int)ans[i].size());
        if(mx<3) cout<<"no significant commonalities"<<'\n';
        else
        {
            sort(ans.begin(),ans.end());
            for(int i=0;i<(int)ans.size();i++)
            {
                if((int)ans[i].size()==mx)
                {
                    cout<<ans[i]<<'\n';
                    break;
                }
            }
        }
    }
    return 0;
}

Count the string

解：KMP next数组的理解题。

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
#define mod 10007
char s[200010];
int nexts[200010];
void getnext(char x[])
{
    int m=strlen(x);
    int i,j;
    j=nexts[0]=-1;
    i=0;
    while(i<m)
    {
        while(-1!=j&&x[i]!=x[j]) j=nexts[j];
        nexts[++i]=++j;
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        scanf("%s",s);
        getnext(s);
        int ans=0;
        for(int i=n;i>=0;i--)
        {
            int k=nexts[i];
            while(k>0)
            {
                ans=(ans+1)%mod;
                k=nexts[k];
            }
        }
        printf("%d\n",(ans+n)%mod);
    }
    return 0;
}

String Problem

解：KMP求最小循环节和字符串的最大(小)表示法。

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
#define mod 10007
char s[1000010];
//char s1[300];
int nexts[1000010];
//char sub[300];
//char res[300];
void getnext(char x[])
{
    int m=strlen(x);
    int i,j;
    j=nexts[0]=-1;
    i=0;
    while(i<m)
    {
        while(-1!=j&&x[i]!=x[j]) j=nexts[j];
        nexts[++i]=++j;
    }
}
int kmp(char x[],char y[])
{
    int n=strlen(y);int m=strlen(x);
    int i,j;
    i=0;j=0;
    while(i<n)
    {
        while(j!=-1&&x[j]!=y[i]) j=nexts[j];
        ++i;++j;
        if(j>=m) return m;
    }
    return 0;
}
int get_index(int flag)
{
    int i,j,k;
    i=k=0;j=1;
    int n;n=strlen(s);
    while(i<n&&j<n&&k<n)
    {

        if(s[(i+k)%n]==s[(j+k)%n]) k++;
        else if(flag==0)
        {
            if(s[(i+k)%n]>s[(j+k)%n]) i=i+k+1;
            else j=j+k+1;
            if(i==j) j++;k=0;
        }
        else if(flag==1)
        {
            if(s[(i+k)%n]>s[(j+k)%n]) j=j+k+1;
            else i=i+k+1;
            if(i==j) j++;k=0;
        }

    }
    return min(i+1,j+1);
}
int main()
{
    while(scanf("%s",s)!=EOF)
    {
        getnext(s);
        int n=strlen(s);
        int small,big,st,bt;
        int len=n-nexts[n];
        small=get_index(0);big=get_index(1);
        st=bt=n/len;
        printf("%d %d %d %d\n",small,st,big,bt);
    }

    return 0;
}

Finding Palindromes

解：容我说一句，这题真**沙比，oj是真的不行。无缘无故报re。写得我最心累的一题。

EXKMP+Trie

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
const int maxn=2e6+7;
char s[maxn];
char t[maxn];
int nexts[maxn];
int extend[maxn];
int pv[2][maxn];
int len[maxn];
void getnext(char x[],int nexts[],int lenx)
{
    nexts[0]=lenx;
    int j=0;
    while(j+1<lenx&&x[j]==x[j+1]) j++;
    nexts[1]=j;
    int k=1;
    for(int i=2;i<lenx;i++)
    {
        int P=nexts[k]+k-1;
        int L=nexts[i-k];
        if(L+i<P+1) nexts[i]=L;
        else
        {
            j=max(0,P-i+1);
            while(i+j<lenx&&x[j]==x[i+j]) j++;
            nexts[i]=j;
            k=i;
        }
    }
}
void exkmp(char x[],int lenx,char y[],int leny,int nexts[],int extend[],int L,int flag)
{
    getnext(x,nexts,lenx);
    int j=0;
    while(j<lenx&&j<leny&&x[j]==y[j]) j++;
    extend[0]=j;
    int k=0;
    for(int i=1;i<leny;i++)
    {
        int P=extend[k]+k-1;
        int Ls=nexts[i-k];
        if(i+Ls<P+1) extend[i]=Ls;
        else
        {
            j=max(0,P-i+1);
            while(i+j<leny&&j<lenx&&y[i+j]==x[j]) j++;
            extend[i]=j;
            k=i;
        }
    }
    for(int i=0;i<leny;i++)
    {
        pv[flag][i+L]=(i+extend[i]==leny);
        //cout<<pv[flag][i+L]<<endl;
    }
}
struct Trie
{
    int ch[maxn][26];
    int ed[maxn];
    int value[maxn];
    int sz;
    void init()
    {
        memset(ch[0],0,sizeof ch[0]);
        ed[0]=0;sz=0;
        value[0]=0;
    }
    void add(char *s,int lens,int L)
    {
        int u=0;
        for(int i=0;i<lens;i++)
        {
            int id=s[i]-'a';
            value[u]+=pv[0][L+i];
            if(!ch[u][id])
            {
                ch[u][id]=++sz;
                memset(ch[sz],0,sizeof ch[sz]);
                value[sz]=0;
                ed[sz]=0;
            }
            u=ch[u][id];
        }
        ed[u]++;
    }
    int finds(char *s,int lens,int L)
    {
        int res=0;
        int u=0;
        for(int i=0;i<lens;i++)
        {
            int id=s[i]-'a';
            u=ch[u][id];
            if(!u) break;
            if((i<lens-1&&pv[1][i+L+1])||i==lens-1)
            {
                res+=ed[u];
            }
        }
        if(u) res+=value[u];
        return res;
    }
}trie;

int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        int tot=0;
        trie.init();
        memset(pv,0,sizeof pv);
        for(int i=1;i<=n;i++)
        {
            scanf("%d%s",&len[i],s+tot);
            memcpy(t+tot,s+tot,len[i]);
            reverse(t+tot,t+tot+len[i]);
            exkmp(t+tot,len[i],s+tot,len[i],nexts,extend,tot,0);
            exkmp(s+tot,len[i],t+tot,len[i],nexts,extend,tot,1);
            trie.add(s+tot,len[i],tot);
            tot+=len[i];
        }
        ll ans=0;
        tot=0;
        for(int i=1;i<=n;i++)
        {
            ans+=1ll*trie.finds(t+tot,len[i],tot);
            tot+=len[i];
        }
        printf("%lld\n",ans);
    }
    return 0;
}

DNA Sequence

解：这道题有点神了。首次见到fail数组的另类考查吧。AC自动机+矩阵快速幂。先建立关于各个模式串的AC自动机，根据fail数组构建矩阵，因为fail数组保存的就是所有不符合要求的字符串的连接关系，由此建立矩阵。此处再用到一个结论就是节点i到节点j经过K次的方案数 正好就是矩阵的K次幂。

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
const int maxn=1010;
#define LL long long
const int mod=100000;
map<char,int>ma;
struct matrix
{
    LL x[110][110];//使用时按照题目需要改变数组的大小，此为4*4的矩阵
};
matrix mutimatrix(matrix a,matrix b,int t)//该函数用于算两个矩阵相乘
{
    matrix temp;
    memset(temp.x,0,sizeof(temp.x));
    for(int i=0;i<t;i++)
    for(int j=0;j<t;j++)
    for(int k=0;k<t;k++)
    {
        temp.x[i][j]+=a.x[i][k]*b.x[k][j];
        temp.x[i][j]%=mod;
    }
    return temp;
}

matrix k_powmatrix(matrix a,LL n,int t)//矩阵快速幂，和之前的快速幂迭代写法差不多。
{
    matrix temp;
    memset(temp.x,0,sizeof(temp.x));
    for(int i=0;i<t;i++)
    temp.x[i][i]=1;

    while(n)
    {
        if(n&1)
        temp=mutimatrix(temp,a,t);
        a=mutimatrix(a,a,t);
        n>>=1;
    }
    return temp;
}

struct Trie
{
    int nexts[maxn][4];
    int fail[maxn],ed[maxn];
    int root,L;
    int newnode()
    {
        for(int i=0;i<4;i++)
            nexts[L][i]=-1;
        ed[L++]=0;
        return L-1;
    }
    void init()
    {
        ma['A']=0;ma['C']=1;ma['G']=2;ma['T']=3;
        L=0;root=newnode();
    }
    void inserts(char s[])
    {
        int now=root;
        int len=strlen(s);
        for(int i=0;i<len;i++)
        {
            int c=ma[s[i]];
            if(nexts[now][c]==-1)
            {
                nexts[now][c]=newnode();
            }
            now=nexts[now][c];
        }
        ed[now]=1;
    }
    void get_fail()
    {
        queue<int> q;
        fail[root]=root;
        for(int i=0;i<4;i++)
        {
            if(nexts[root][i]==-1)nexts[root][i]=root;
            else
            {
                fail[nexts[root][i]]=root;
                q.push(nexts[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            if(ed[fail[now]]!=0) ed[now]=1;
            for(int i=0;i<4;i++)
            {
                if(nexts[now][i]==-1) nexts[now][i]=nexts[fail[now]][i];
                else
                {
                    fail[nexts[now][i]]=nexts[fail[now]][i];
                    q.push(nexts[now][i]);
                }
            }
        }
    }
    int used[1200];
    void query(char s[])
    {
        memset(used,0,sizeof used);
        int len=strlen(s);
        int now=root;
        for(int i=0;i<len;i++)
        {
            int c=ma[s[i]];
            now=nexts[now][c];
            int tmp=now;
            while(tmp!=root)
            {
                if(ed[tmp]!=0) used[ed[tmp]]++;
                tmp=fail[tmp];
            }
        }
    }
}trie;
char s[200];
int main()
{
    trie.init();
    int m;ll n;
    scanf("%d %lld",&m,&n);
    for(int i=1;i<=m;i++)
    {
        scanf("%s",s);
        trie.inserts(s);
    }
    trie.get_fail();
    matrix mt,res;
    memset(mt.x,0,sizeof mt.x);
    for(int i=0;i<trie.L;i++)
    {
        if(trie.ed[i]!=0) continue;
        for(int j=0;j<4;j++)
        {
            if(trie.ed[trie.nexts[i][j]]!=0) continue;
            mt.x[i][trie.nexts[i][j]]++;
        }
    }
    res=k_powmatrix(mt,n,trie.L);
    ll ans=0;
    for(int i=0;i<trie.L;i++)
    {
        ans=(ans+res.x[0][i])%mod;
    }
    printf("%lld\n",ans);
    return 0;
}

考研路茫茫――单词情结

解：这题也很神。和上题类似，ac自动机+矩阵快速幂。确认过眼神，是做不出的题。

本题的一个矩阵要构造成\begin{bmatrix} 26 & 0 \\ 1 & 1 \end{bmatrix}*\begin{bmatrix} f(n-1) &1 \end{bmatrix}  才行。有点儿不理解，换个形式构造就不对了。

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
const int maxn=1010;
#define LL long long
struct Matrix
{
    unsigned long long mat[40][40];
    int n;
    Matrix(){}
    Matrix(int _n)
    {
        n=_n;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                mat[i][j] = 0;
    }
    Matrix operator *(const Matrix &b)const
    {
        Matrix ret = Matrix(n);
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                for(int k=0;k<n;k++)
                    ret.mat[i][j]+=mat[i][k]*b.mat[k][j];
        return ret;
    }
};
struct Trie
{
    int nexts[maxn][26];
    int fail[maxn],ed[maxn];
    int root,L;
    int newnode()
    {
        for(int i=0;i<26;i++)
            nexts[L][i]=-1;
        ed[L++]=0;
        return L-1;
    }
    void init()
    {
        L=0;root=newnode();
    }
    void inserts(char s[])
    {
        int now=root;
        int len=strlen(s);
        for(int i=0;i<len;i++)
        {
            int c=s[i]-'a';
            if(nexts[now][c]==-1)
            {
                nexts[now][c]=newnode();
            }
            now=nexts[now][c];
        }
        ed[now]=1;
    }
    void get_fail()
    {
        queue<int> q;
        fail[root]=root;
        for(int i=0;i<26;i++)
        {
            if(nexts[root][i]==-1)nexts[root][i]=root;
            else
            {
                fail[nexts[root][i]]=root;
                q.push(nexts[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            if(ed[fail[now]]!=0) ed[now]=1;
            for(int i=0;i<26;i++)
            {
                if(nexts[now][i]==-1) nexts[now][i]=nexts[fail[now]][i];
                else
                {
                    fail[nexts[now][i]]=nexts[fail[now]][i];
                    q.push(nexts[now][i]);
                }
            }
        }
    }

//    int used[1200];
//    void query(char s[])
//    {
//        memset(used,0,sizeof used);
//        int len=strlen(s);
//        int now=root;
//        for(int i=0;i<len;i++)
//        {
//            int c=s[i]-'a';
//            now=nexts[now][c];
//            int tmp=now;
//            while(tmp!=root)
//            {
//                if(ed[tmp]!=0) used[ed[tmp]]++;
//                tmp=fail[tmp];
//            }
//        }
//    }
}trie;
char s[110];
int main()
{
    int N;ll len;
    while(scanf("%d %lld",&N,&len)!=EOF)
    {
        trie.init();
        for(int i=1;i<=N;i++)
        {
            scanf("%s",s);
            trie.inserts(s);
        }
        trie.get_fail();
        Matrix res1,E;
        res1=Matrix(2);
        res1.mat[0][0]=26;res1.mat[1][1]=res1.mat[1][0]=1;
        E=Matrix(2);
        E.mat[0][0]=E.mat[1][1]=1;
        ll tmp=len;
        while(tmp)
        {
            if(tmp&1) E=E*res1;
            res1=res1*res1;
            tmp>>=1;
        }
        unsigned long long ans1=E.mat[0][0]+E.mat[1][0];
        ans1--;
        res1=Matrix(trie.L+1);
        for(int i=0;i<trie.L;i++)
        {
            if(trie.ed[i]==1) continue;
            for(int j=0;j<26;j++)
            {
                if(trie.ed[trie.nexts[i][j]]==1) continue;
                res1.mat[i][trie.nexts[i][j]]++;
            }
        }
        E=Matrix(trie.L+1);
        for(int i=0;i<=trie.L;i++)
        {
            E.mat[i][i]=1;
            res1.mat[i][trie.L]=1;
        }
        tmp=len;
        while(tmp)
        {
            if(tmp&1) E=E*res1;
            res1=res1*res1;
            tmp>>=1;
        }
        unsigned long long ans2=0;
        for(int i=0;i<E.n;i++) ans2+=E.mat[0][i];
        ans2--;
        unsigned long long ans=ans1-ans2;
        printf("%llu\n",ans);
    }
    return 0;
}

Wireless Password

解：再次见识AC自动机的各种考法。AC自动机+DP。建立关于给定的模式串的AC自动机后，根据tried图，可以定义dp[i][j][k]为当长度为i，走到节点j时，单词情况为k的方案数。

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
const int maxn=110;
#define LL long long
#define mod 20090717

struct Trie
{
    int nexts[maxn][26];
    int fail[maxn],ed[maxn];
    int root,L;
    ll dp[30][110][1030];
    int newnode()
    {
        for(int i=0;i<26;i++)
            nexts[L][i]=-1;
        ed[L++]=0;
        return L-1;
    }
    void init()
    {
        L=0;root=newnode();
    }
    void inserts(char s[],int id)
    {
        int now=root;
        int len=strlen(s);
        for(int i=0;i<len;i++)
        {
            int c=s[i]-'a';
            if(nexts[now][c]==-1)
            {
                nexts[now][c]=newnode();
            }
            now=nexts[now][c];
        }
        ed[now]|=(1<<id);
    }
    void get_fail()
    {
        queue<int> q;
        fail[root]=root;
        for(int i=0;i<26;i++)
        {
            if(nexts[root][i]==-1)nexts[root][i]=root;
            else
            {
                fail[nexts[root][i]]=root;
                q.push(nexts[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            if(ed[fail[now]]!=0) ed[now]|=ed[fail[now]];
            for(int i=0;i<26;i++)
            {
                if(nexts[now][i]==-1) nexts[now][i]=nexts[fail[now]][i];
                else
                {
                    fail[nexts[now][i]]=nexts[fail[now]][i];
                    q.push(nexts[now][i]);
                }
            }
        }
    }
    ll solve(int n,int m,int K)
    {
        memset(dp,0,sizeof dp);
        dp[0][0][0]=1;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<L;j++)
            {
                for(int k=0;k<(1<<m);k++)
                {
                    if(dp[i][j][k]>0)
                    for(int ch=0;ch<26;ch++)
                    {
                        int ni=i+1;int nj=nexts[j][ch];int nk=k|ed[nexts[j][ch]];
                        dp[ni][nj][nk]+=dp[i][j][k];
                        dp[ni][nj][nk]%=mod;
                    }
                }
            }
        }
        ll ans=0;
        for(int i=0;i<(1<<m);i++)
        {
            if(__builtin_popcount(i)<K) continue;
            for(int j=0;j<L;j++)
            {
                ans+=dp[n][j][i];
                ans%=mod;
            }
        }
        return ans;
    }

}trie;
char s[110];
int main()
{
    int N,M,K;
    while(scanf("%d %d %d",&N,&M,&K)!=EOF)
    {
        if(N==0&&M==0&&K==0) break;
        trie.init();
        for(int i=0;i<M;i++)
        {
            scanf("%s",s);
            trie.inserts(s,i);
        }
        trie.get_fail();
        ll ans=trie.solve(N,M,K);
        printf("%lld\n",ans);
    }
    return 0;
}

Ring

解：AC自动机+dp。dp[i][j]:长度为i走到节点j的最大价值。dp[i+1][j]=max(dp[i][j],dp[i][fa(j)]+ed[fa(j)])

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
const int maxn=2100;
#define LL long long
#define mod 20090717
//struct Matrix
//{
//    long long mat[110][110];
//    int n;
//    Matrix(){}
//    Matrix(int _n)
//    {
//        n=_n;
//        for(int i=0;i<n;i++)
//            for(int j=0;j<n;j++)
//                mat[i][j] = 0;
//    }
//    Matrix operator *(const Matrix &b)const
//    {
//        Matrix ret = Matrix(n);
//        for(int i=0;i<n;i++)
//            for(int j=0;j<n;j++)
//                for(int k=0;k<n;k++)
//                    ret.mat[i][j]+=mat[i][k]*b.mat[k][j];
//        return ret;
//    }
//};
int cost[110];
struct Trie
{
    int nexts[maxn][26];
    int fail[maxn],ed[maxn];
    int root,L;
    int dp[110][2100];
    string path[110][2100];
    int newnode()
    {
        for(int i=0;i<26;i++)
            nexts[L][i]=-1;
        ed[L++]=0;
        return L-1;
    }
    void init()
    {
        L=0;root=newnode();
    }
    bool cmp(string s,string t)
    {
        if(t=="")return false;
        if(s.size()>t.size()) return true;
        if(s.size()<t.size()) return false;
        return s>t;
    }
    void inserts(char s[],int id)
    {
        int now=root;
        int len=strlen(s);
        for(int i=0;i<len;i++)
        {
            int c=s[i]-'a';
            if(nexts[now][c]==-1)
            {
                nexts[now][c]=newnode();
            }
            now=nexts[now][c];
        }
        ed[now]=cost[id];
    }
    void get_fail()
    {
        queue<int> q;
        fail[root]=root;
        for(int i=0;i<26;i++)
        {
            if(nexts[root][i]==-1)nexts[root][i]=root;
            else
            {
                fail[nexts[root][i]]=root;
                q.push(nexts[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            //if(ed[fail[now]]!=0) ed[now]|=ed[fail[now]];
            for(int i=0;i<26;i++)
            {
                if(nexts[now][i]==-1) nexts[now][i]=nexts[fail[now]][i];
                else
                {
                    fail[nexts[now][i]]=nexts[fail[now]][i];
                    q.push(nexts[now][i]);
                }
            }
        }
    }
    string solve(int n)
    {
        memset(dp,-1,sizeof dp);
        dp[0][0]=0;int res=0;
        for(int i=0;i<=n;i++)
            for(int j=0;j<=L;j++)
                path[i][j]="";
        for(int i=0;i<=n;i++)
        {
            for(int j=0;j<L;j++)
            {
                if(dp[i][j]==-1) continue;
                for(int k=0;k<26;k++)
                {
                    int ni=i+1;int nj=nexts[j][k];
                    if(dp[ni][nj]<dp[i][j]+ed[nexts[j][k]])
                    {
                        dp[ni][nj]=dp[i][j]+ed[nexts[j][k]];
                        path[ni][nj]=path[i][j]+(char)(k+'a');
                    }
                    else if(dp[ni][nj]==dp[i][j]+ed[nexts[j][k]])
                    {
                        if(cmp(path[ni][nj],path[i][j]+(char)(k+'a')))
                        {
                            path[ni][nj]=path[i][j]+(char)(k+'a');
                        }
                    }
                }
                res=max(res,dp[i][j]);
                //cout<<dp[i][j]<<" ";
            }
            //cout<<endl;
        }
        string ans="";
        if(res==0) return ans;
        for(int i=0;i<=n;i++)
        {
            for(int j=0;j<L;j++)
            {
                if(dp[i][j]==res)
                {
                    if(ans=="") ans=path[i][j];
                    else if(cmp(ans,path[i][j])) ans=path[i][j];
                }
            }
        }
        return ans;
    }

}trie;
char s[110][50];

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int N,M;
        scanf("%d %d",&N,&M);
        trie.init();
        for(int i=0;i<M;i++)
        {
            scanf("%s",s[i]);
            //trie.inserts(s,i);
        }
        for(int i=0;i<M;i++) scanf("%d",&cost[i]);
        for(int i=0;i<M;i++) trie.inserts(s[i],i);
        trie.get_fail();
        string ans=trie.solve(N);
        cout<<ans<<'\n';
    }
    return 0;
}

DNA repair

解：说实话我还是不能独立的做出这种题。通过trie图，构造一个字符串，这个字符串不会包含任何模式串。dp[i][j]:表示当字符长度为i，走到节点j的最小修改数。dp[i][next[j][k]]=min(dp[i][j],dp[i-1][j]+(s[i]!=k);

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
const int maxn=2100;
#define LL long long
#define mod 20090717
#define inf 0x3f3f3f3f

char s[1100];
struct Trie
{
    int nexts[maxn][26];
    int fail[maxn],ed[maxn];
    int root,L;
    int dp[1010][1010];
    map<char,int>ma;
    char num[4];
    int newnode()
    {
        for(int i=0;i<4;i++)
            nexts[L][i]=-1;
        ed[L++]=0;
        return L-1;
    }
    void init()
    {
        L=0;root=newnode();
        ma['A']=0;ma['C']=1;ma['G']=2;ma['T']=3;
        num[0]='A';num[1]='C';num[2]='G';num[3]='T';
    }
    bool cmp(string s,string t)
    {
        if(t=="")return false;
        if(s.size()>t.size()) return true;
        if(s.size()<t.size()) return false;
        return s>t;
    }
    void inserts(char s[])
    {
        int now=root;
        int len=strlen(s);
        for(int i=0;i<len;i++)
        {
            int c=ma[s[i]];
            if(nexts[now][c]==-1)
            {
                nexts[now][c]=newnode();
            }
            now=nexts[now][c];
        }
        ed[now]=1;
    }
    void get_fail()
    {
        queue<int> q;
        fail[root]=root;
        for(int i=0;i<4;i++)
        {
            if(nexts[root][i]==-1)nexts[root][i]=root;
            else
            {
                fail[nexts[root][i]]=root;
                q.push(nexts[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            if(ed[fail[now]]!=0) ed[now]=1;
            for(int i=0;i<4;i++)
            {
                if(nexts[now][i]==-1) nexts[now][i]=nexts[fail[now]][i];
                else
                {
                    fail[nexts[now][i]]=nexts[fail[now]][i];
                    q.push(nexts[now][i]);
                }
            }
        }
    }
    int solve(int n)
    {
        for(int i=0;i<=n;i++)
            for(int j=0;j<=L;j++)
                dp[i][j]=inf;
        dp[0][0]=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<L;j++)
            {
                if(dp[i-1][j]==inf) continue;
                for(int k=0;k<4;k++)
                {
                    if(ed[nexts[j][k]]==1) continue;
                    int ni=i;int nj=nexts[j][k];
                    dp[ni][nj]=min(dp[ni][nj],dp[i-1][j]+(s[i]!=num[k]));//当构造的串的当前位与给定的串的对应位不一样时就要加1表示改变。
                }
            }
        }
        int ans=inf;
        for(int i=0;i<L;i++) ans=min(ans,dp[n][i]);
        if(ans==inf) return -1;
        return ans;
    }
}trie;

int main()
{
    int N;
    int kcase=0;
    while(scanf("%d",&N)!=EOF)
    {
        if(N==0) break;
        trie.init();
        for(int i=0;i<N;i++)
        {
            scanf("%s",s);
            trie.inserts(s);
        }
        trie.get_fail();
        scanf("%s",s+1);
        int len=strlen(s+1);
        int ans=trie.solve(len);
        printf("Case %d: %d\n",++kcase,ans);
    }
    return 0;
}

Lost's revenge

解：还是AC自动机+DP。dp[i][j]:走到节点i，四个碱基的使用情况为j的最大数量。j表示各个碱基数量。可以使用哈希的形式表示这所有的情况。dp[nexts[i][ch]][S1]=max(dp[i][S2]+ed[nexts[i][ch]],dp[nexts[i][ch]][S1])

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
const int maxn=2100;
#define LL long long
#define mod 20090717
#define inf 0x3f3f3f3f
char s[1100];
struct Trie
{
    int nexts[maxn][26];
    int fail[maxn],ed[maxn];
    int root,L;
    int dp[600][15000];
    int hashs[45][45][45][45];
    int cnt;
    //map<char,int>ma;
    int num[4];
    int newnode()
    {
        for(int i=0;i<4;i++)
            nexts[L][i]=-1;
        ed[L++]=0;
        return L-1;
    }
    void init()
    {
        L=0;root=newnode();
        //ma['A']=0;ma['C']=1;ma['G']=2;ma['T']=3;
        //num[0]='A';num[1]='C';num[2]='G';num[3]='T';
        num[0]=num[1]=num[2]=num[3]=0;
        cnt=0;
    }
    int ma(char x)
    {
        if(x=='A') return 0;
        if(x=='C') return 1;
        if(x=='G') return 2;
        if(x=='T') return 3;
    }
    bool cmp(string s,string t)
    {
        if(t=="")return false;
        if(s.size()>t.size()) return true;
        if(s.size()<t.size()) return false;
        return s>t;
    }
    void inserts(char s[])
    {
        int now=root;
        int len=strlen(s);
        for(int i=0;i<len;i++)
        {
            int c=ma(s[i]);
            if(nexts[now][c]==-1)
            {
                nexts[now][c]=newnode();
            }
            now=nexts[now][c];
        }
        ed[now]++;
    }
    void get_fail()
    {
        queue<int> q;
        fail[root]=root;
        for(int i=0;i<4;i++)
        {
            if(nexts[root][i]==-1)nexts[root][i]=root;
            else
            {
                fail[nexts[root][i]]=root;
                q.push(nexts[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            if(ed[fail[now]]!=0) ed[now]+=ed[fail[now]];
            for(int i=0;i<4;i++)
            {
                if(nexts[now][i]==-1) nexts[now][i]=nexts[fail[now]][i];
                else
                {
                    fail[nexts[now][i]]=nexts[fail[now]][i];
                    q.push(nexts[now][i]);
                }
            }
        }
    }
    int solve(int n)
    {
        memset(dp,-1,sizeof dp);
        for(int i=1;i<=n;i++)
            num[ma(s[i])]++;

        for(int i=0;i<=num[0];i++)
            for(int j=0;j<=num[1];j++)
                for(int k=0;k<=num[2];k++)
                    for(int h=0;h<=num[3];h++)
                        hashs[i][j][k][h]=cnt++;

        dp[0][0]=0;
        for(int i=0;i<=num[0];i++)
        {
            for(int j=0;j<=num[1];j++)
            {
                for(int k=0;k<=num[2];k++)
                {
                    for(int h=0;h<=num[3];h++)
                    {
                        if(i+j+k+h==0) continue;
                        for(int ti=0;ti<L;ti++)
                        {
                                for(int ch=0;ch<4;ch++)
                                {
                                    int tmp1=hashs[i][j][k][h];
                                    int tmp2;
                                    if(ch==0){
                                        if(i==0) continue;
                                        else tmp2=hashs[i-1][j][k][h];
                                    }
                                    else if(ch==1)
                                    {
                                        if(j==0) continue;
                                        else tmp2=hashs[i][j-1][k][h];
                                    }
                                    else if(ch==2)
                                    {
                                        if(k==0) continue;
                                        else tmp2=hashs[i][j][k-1][h];
                                    }
                                    else
                                    {
                                        if(h==0) continue;
                                        else tmp2=hashs[i][j][k][h-1];
                                    }
                                    if(dp[ti][tmp2]==-1) continue;
                                    dp[nexts[ti][ch]][tmp1]=max(dp[ti][tmp2]+ed[nexts[ti][ch]],dp[nexts[ti][ch]][tmp1]);
                                }
                        }
                    }
                }
            }
        }
        int res=0;int st=hashs[num[0]][num[1]][num[2]][num[3]];
        for(int i=0;i<L;i++) res=max(res,dp[i][st]);
        return res;
    }
}trie;

int main()
{
    int N;
    int kcase=0;
    while(scanf("%d",&N)!=EOF)
    {
        if(N==0) break;
        trie.init();
        for(int i=0;i<N;i++)
        {
            scanf("%s",s);
            trie.inserts(s);
        }
        trie.get_fail();
        scanf("%s",s+1);
        int len=strlen(s+1);
        int ans=trie.solve(len);
        printf("Case %d: %d\n",++kcase,ans);
    }
    return 0;
}

Resource Archiver

解：这题就比之前的更牛逼一点了。AC自动机+DP+BFS。确实是想不出，到了比赛这种题也是没时间去做的。把给出来的好串和坏串都加入到AC自动机的字典数里。由于内存不允许，不能直接定义dp[i][j]表示走到节点i时构造的字符串的包含好串的情况为j。但可以发现，n远小于m，即好的点远小于总数。将所有好串的尾节点重新编号，并且求出两两之间的最短距离。则dp[i][j]即表示走到好的节点i时的情况为j。dp[i][ j | ma[j] ]=min(dp[i][ j | ma[j] ] , dp[k][j]+cost[k][i]);

//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <iostream>

using namespace std;
#define ll long long
const int maxn=60000;
#define LL long long
#define mod 20090717
#define inf 0x3f3f3f3f

char s[1100];
struct Trie
{
    int nexts[maxn][2];
    int fail[maxn],ed[maxn],vir[maxn];
    int root,L;
    int dp[600][15000];
    int dist[maxn];bool vis[maxn];
    int tot;int ma[500];
    int cost[550][550];
    int newnode()
    {
        for(int i=0;i<2;i++)
            nexts[L][i]=-1;
        vir[L]=0;ed[L++]=0;
        return L-1;
    }
    void init()
    {
        tot=0;
        L=0;root=newnode();
    }
    void inserts(char s[],int id,int flag)
    {
        int now=root;
        int len=strlen(s);
        for(int i=0;i<len;i++)
        {
            int c=s[i]-'0';
            if(nexts[now][c]==-1)
            {
                nexts[now][c]=newnode();
            }
            now=nexts[now][c];
        }
        if(flag) vir[now]=1;
        else ed[now]|=(1<<id);
    }
    void get_fail()
    {
        queue<int> q;
        fail[root]=root;
        for(int i=0;i<2;i++)
        {
            if(nexts[root][i]==-1)nexts[root][i]=root;
            else
            {
                fail[nexts[root][i]]=root;
                q.push(nexts[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            ed[now]|=ed[fail[now]];
            vir[now]+=vir[fail[now]];
            for(int i=0;i<2;i++)
            {
                if(nexts[now][i]==-1) nexts[now][i]=nexts[fail[now]][i];
                else
                {
                    fail[nexts[now][i]]=nexts[fail[now]][i];
                    q.push(nexts[now][i]);
                }
            }
        }
    }
    void bfs(int st)
    {
        queue<int> q;
        while(!q.empty()) q.pop();
        memset(vis,0,sizeof vis);
        for(int i=0;i<L;i++) dist[i]=inf;
        q.push(ma[st]);
        dist[ma[st]]=0;vis[ma[st]]=1;
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            for(int i=0;i<2;i++)
            {
                int nex=nexts[now][i];
                if(vis[nex])continue;
                if(vir[nex]) continue;
                dist[nex]=dist[now]+1;
                vis[nex]=1;
                q.push(nex);
            }
        }
        for(int i=0;i<tot;i++)
        {
            cost[st][i]=dist[ma[i]];
        }
    }
    void get_new_node()
    {
        ma[tot++]=0;
        for(int i=0;i<L;i++)
        {
            if(ed[i]!=0) ma[tot++]=i;
        }
        for(int i=0;i<tot;i++)
        {
            bfs(i);
        }
    }
    int solve(int n)
    {
        get_new_node();
        for(int i=0;i<tot;i++)
            for(int j=0;j<(1<<n);j++)
                dp[i][j]=inf;
        dp[0][0]=0;
        for(int j=0;j<(1<<n);j++)
        {
            for(int i=0;i<tot;i++)
            {
                if(dp[i][j]>=inf) continue;
                for(int k=0;k<tot;k++)
                {
                    if(i==k) continue;
                    dp[k][j|ed[ma[k]]]=min(dp[k][j|ed[ma[k]]],dp[i][j]+cost[i][k]);
                }
            }
        }
        int res=inf;
        for(int i=0;i<tot;i++) res=min(res,dp[i][(1<<n)-1]);
        return res;
    }
}trie;

int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        if(n==0&&m==0) break;
        trie.init();
        for(int i=0;i<n;i++)
        {
            scanf("%s",s);
            trie.inserts(s,i,0);
        }
        for(int i=0;i<m;i++)
        {
            scanf("%s",s);
            trie.inserts(s,i,1);
        }
        trie.get_fail();
        int ans=trie.solve(n);
        printf("%d\n",ans);
    }
    return 0;
}

之前也没有怎么学过字符串的算法，终于在前几天学了AC自动机。在懂得差不多的原理之后(其实有些部分还是模糊的)。正所谓纸上得来终觉浅，还是要通过做题去发现自己还有哪些不懂以及这个算法它能怎么考。通过这几天的bin巨的专题抗压训练后可以发现，基本不会在比赛中会直接单独考查AC自动机的多模匹配的作用，更多的是在它通过fail数组构造得出的一个trie图上做文章。遇到的类型有：①给定一些模式串问能有多少种构造方法得到不包含给定串的字符串，这种题通常就是通过trie图，判断不可以走到模式串的结尾来构造一个矩阵，通过矩阵快速幂得到方案数。②其他的就是通过各种DP乱搞的方式，但有个规律是dp的其中一维是和trie图上的节点有关(在我做过的题看来是这样的)。

HUGOkungggg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
洛谷 P1049 装箱问题 (01背包)
weixin_45417428的博客
10-14 211
P1049 装箱问题 时间限制1.00s 内存限制125.00MB 题目描述 有一个箱子容量为VV（正整数，V≤20000），同时有nn个物品（0<n≤30，每个物品有一个体积（正整数）。 要求nn个物品中，任取若干个装入箱内，使箱子的剩余空间为最小。 输入格式 1个整数，表示箱子容量 1个整数，表示有n个物品 接下来n行，分别表示这n个物品的各自体积 输出格式 1个整数，表示箱子剩余空间。 输入输出样例 输入 #1 24 6 8 3 12 7 9 7 输出 #1 0 #include<bi
统计天数
程序员三木的博客
01-14 575
题目描述 炎热的夏日，KC 非常的不爽。他宁可忍受北极的寒冷，也不愿忍受厦门的夏天。最近，他开始研究天气的变化。他希望用研究的结果预测未来的天气。 经历千辛万苦，他收集了连续 N(1≤N≤106)N(1 \leq N \leq 10^6)N(1≤N≤106) 的最高气温数据。 现在，他想知道最高气温一直上升的最长连续天数。 输入格式 第 1 行：一个整数 NNN 。1≤N≤1061 \leq N ...
P1678 烦恼的高考志愿
少年的博客
05-30 327
二分查找题目来源题解（AC） 题目来源 烦恼的高考????‍???? 题解（AC） #include <cstdio> #include<iostream> #include <cstring> #include <cmath> #include <algorithm> #include<vector> using namespace std; int a[100000],b[100000]; int m, n; int erfen(i
P1157 组合的输出
懒狗千星的博客
03-16 331
题目链接 参考题解 思路： 先用一个数组模拟数字的出现情况，0表示输出的数字，例如样例中的n = 5， r = 3： 1 2 3 4 5 0 0 0 1 1 如上表，此时输出为1 2 3； 之后使用next_permutation()列举出所有情况，输出，ac。 代码 #include <iostream> #include <iomanip> #include <algorithm> using namespace std; int ans[30]
洛谷P1614 爱与愁的心痛
水蛙菌
02-15 7585
题目链接 题目背景 （本道题目隐藏了两首歌名，找找看哪~~~） 《爱与愁的故事第一弹·heartache》第一章。 《我为歌狂》当中伍思凯神曲《舞月光》居然没赢给萨顶顶，爱与愁大神心痛啊~~~而且最近还有一些令人伤心的事情，都让人心痛（最近真的很烦哈)…… 题目描述 最近有 n 个不爽的事，每句话都有一个正整数刺痛值（心理承受力极差）。爱与愁大神想知道连续 m 个刺痛值的和的最小值是多少，但是由于业务繁忙，爱与愁大神只好请你编个程序告诉他。 输入格式 第一行有两个用空格隔开的整数，分别代表 n 和 m。 第
计算机寒假实习报告.doc
11-24
1. **实习目的**： 实习的目的是提升个人的社会活动能力，理解社会现实，通过实践拉近与社会的距离，识别社会问题，看清社会现象，并在实践中应用和巩固所学知识，增强职业技能，磨砺意志，同时培养社会责任感。 2...
可爱卡通我的寒假生活PPT模板
11-22
这是整理发布的一款以可爱卡通我的寒假生活为主题的PPT模板，适合原创PPT使用，有需要的小伙伴快下载使用吧！该文档为可爱卡通我的寒假生活PPT模板，是一份很不错的参考资料，具有较高参考价值，感兴趣的可以下载看...
赵汶寒假留校申请表1
08-08
电子科技大学研究生寒假留校申请表姓名赵汶学号201822090524民族汉宿舍号603本人电话17612720824导师郝宗波家庭联系人赵久伦家庭电话18786
2013.1寒假学习计划1
08-08
【寒假学习计划】针对2013年1月的寒假，该学习计划涵盖了广泛的IT相关领域，包括编程语言、计算机科学基础知识以及英语强化。以下是详细的知识点解析： **预习内容：** 1. **复变函数和积分变换**：这部分是数学...
计算机寒假实习报告范文.doc
11-22
【计算机寒假实习报告范文】 实习是提升个人能力和适应职场生活的重要环节，特别是在计算机科学领域，实习可以帮助学生将理论知识转化为实践经验。这篇计算机寒假实习报告详细记录了一位实习生在某公司的经历，展示...
洛谷 P1115最大字段和(dp)
weixin_45417428的博客
10-09 254
P1115 最大子段和 时间限制1.00s 内存限制125.00MB 题目描述 给出一个长度为 n 的序列 a，选出其中连续且非空的一段使得这段和最大。 输入格式 第一行是一个整数，表示序列的长度 n。 第二行有 n 个整数，第 i 个整数表示序列的第 i 个数字 a i 。 输出格式 输出一行一个整数表示答案。 输入输出样例 输入 #1 7 2 -4 3 -1 2 -4 3 输出 #1 4 说明/提示 样例 1 解释 选取 [3, 5] 子段{3,−1,2}，其和为 44。 数据规模与约定 对于40%
P1567 统计天数（洛谷）
Weleness的博客
01-17 4855
题目描述 炎热的夏日，KC 非常的不爽。他宁可忍受北极的寒冷，也不愿忍受厦门的夏天。最近，他开始研究天气的变化。他希望用研究的结果预测未来的天气。 经历千辛万苦，他收集了连续 N(1 \leq N \leq 10^6)N(1≤N≤10 6 ) 的最高气温数据。 现在，他想知道最高气温一直上升的最长连续天数。 输入格式 第 1 行：一个整数 NN 。1 \leq N \leq 10^61≤N≤10 ...
洛谷P1867 【Mc生存】经验值
热门推荐
水蛙菌
02-16 1万+
题目链接 题目背景 初一福利第2弹。。。 题目描述 话说 clearman 在 MC 世界开了个祥艺奶牛场，用熔浆、TNT 等丧心病狂的折磨牛，获取牛肉、牛奶等刷经验。他想知道他到底达到什么层次。 他总共进行了 n 项操作，每次操作要付出 x 生命值（初始生命是 10 点，初一党都知道！并且要先计算付出的生命值，如果小于等于 0，则死亡，本次即以下操作都无效。但切记：付出生命值可以是负数，也就是说可以回复 −x 点生命值，但上限只能是 10！切记！），每次操作可以获得 a 经验值（不能为负），他最后能达到
P2782 友好城市
m0_74039681的博客
04-25 79
P2782 友好城市 最长不下降子序列
P1420 最长连号
Xiaorui_xuan的博客
04-12 486
P1420 最长连号 提交124.28k 通过55.99k 时间限制1.00s 内存限制128.00MB 提交答案加入题单 复制题目 题目提供者yeszy 难度入门 历史分数100 提交记录查看题解 标签 查看算法标签 进入讨论版 相关讨论 查看讨论 推荐题目 查看推荐 洛谷推荐关闭 展开 题目描述 输入长度为nn的一个正整数序列，要求输出序列中最长连号的长度。 连号指在序列中，从小到大的连续自然数。 输入格式 第一行，...
P1106删数问题
weixin_44132485的博客
04-27 235
一、题目 二、解题思路 首先想到使用暴力求解，显然所有情况共ANkA_N^kANk​种，计算量比较大，很有可能超时。 该题为从N个数中取k个数，对于这种问题，应当想到是否可用动规解决。分析发现，对于该问题来说，后面的结果不影响前面的结果，具体来说，假设已经从前i个数中取了j个数，随后我们在i+1~N中取数字的时候，不管怎么取，前i个数的结果都是确定的，不会因为后面取什么数而改变，因此，可以确定该题能使用动规解决。 假设dp[i][j]表示前j个数中，取i个数后的最优解。由于该题的数字很大，显然无法使用i
P1094 [NOIP2007 普及组] 纪念品分组提交133.32k通过60.77k时间限制1.00s内存限制125.00MB提交答案
最新发布
Ldxx603的博客
04-26 81
【代码】P1094 [NOIP2007 普及组] 纪念品分组提交133.32k通过60.77k时间限制1.00s内存限制125.00MB提交答案。
洛谷P1426 小鱼会有危险吗
水蛙菌
02-10 9341
题目链接 题目描述 有一次，小鱼要从 A 处沿直线往右边游，小鱼第一秒可以游 7 米，从第二秒开始每秒游的距离只有前一秒的 98%。有个极其邪恶的猎人在距离 A 处右边 s 米的地方，安装了一个隐蔽的探测器，探测器左右 x 米之内是探测范围。一旦小鱼进入探测器的范围，探测器就会在这一秒结束时把信号传递给那个猎人，猎人在一秒后就要对探测器范围内的水域进行抓捕，这时如果小鱼还在这范围内就危险了。也就是说小鱼一旦进入探测器范围，如果能在下 1 秒的时间内马上游出探测器的范围，还是安全的。现在给出 s 和 x 的数
洛谷P1423 小玉在游泳
水蛙菌
02-10 7254
题目链接 题目描述 小玉开心的在游泳，可是她很快难过的发现，自己的力气不够，游泳好累哦。已知小玉第一步能游2米，可是随着越来越累，力气越来越小，她接下来的每一步都只能游出上一步距离的98%。现在小玉想知道，如果要游到距离x米的地方，她需要游多少步呢。请你编程解决这个问题。 输入格式 输入一个数字（不一定是整数，小于100m），表示要游的目标距离。 输出格式 输出一个整数，表示小玉一共需要游多少步。 输入输出样例 输入 #1 4.3 输出 #1 3 代码： #include<iostream> u
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值