洛谷p2444 p4052 AC自动机

ac自动机fail指针，即为当失配后，跳转至与当前后缀相同的一个前缀上。

因此如果一个点的fail指向的点是一个单词的终止，那么说明当前匹配到的这个位置，一定包括这个单词。

因此建立fail指针时，我们可以更新ed的值，由此来判断，当到达这个点的时候是否会经过单词的结尾。

P2444 在ac自动机上找一个无限循环的串，且这个串不可经过单词结尾，通过nxt数组进行dfs，维护两个数组，一个判断是否为圈，另一个判断是否为拜访过的点（拜访之后不重复走）。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <queue>
#include <cstring>
#include <algorithm>
#include <string>
using namespace std;
const int maxn=50000;
struct node{
    int x,y;
};
struct Tire{
    int nxt[maxn][2],fail[maxn];
    int cnt,rt;
    int ed[maxn],vis[maxn],f[maxn];
    int newnode()
    {
        for(int i=0;i<2;i++)
        {
            nxt[cnt][i]=-1;
        }
        ed[cnt++]=0;
        return cnt-1;
    }
    void init()
    {
        cnt=0;
        rt=newnode();
        memset(vis,0,sizeof(vis));
        memset(f,0,sizeof(f));
    }
    void ins(string s,int id)
    {
        int len=s.size();
        int now=rt;
        for(int i=0;i<len;i++)
        {
            if(nxt[now][s[i]-'0']==-1)
            {
                nxt[now][s[i]-'0']=newnode();
            }
            now=nxt[now][s[i]-'0'];
        }
        ed[now]=id;
    }
    void build()
    {
        queue<int>q;
        fail[rt]=rt;
        for(int i=0;i<2;i++)
        {
            if(nxt[rt][i]==-1)
            {
                nxt[rt][i]=rt;
            }
            else
            {
                fail[nxt[rt][i]]=rt;
                q.push(nxt[rt][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            for(int i=0;i<2;i++)
            {
                if(nxt[now][i]==-1)
                {
                    nxt[now][i]=nxt[fail[now]][i];
                }
                else
                {
                    fail[nxt[now][i]]=nxt[fail[now]][i];
                    ed[nxt[now][i]]|=ed[fail[nxt[now][i]]];
                    q.push(nxt[now][i]);
                }
            }
        }
    }
    void dfs(int x)
    {
        vis[x]=1;
        for(int i=0;i<2;i++)
        {
            if(vis[nxt[x][i]]==1)
            {
                printf("TAK");
                exit(0);
            }
            else if(!f[nxt[x][i]]&&!ed[nxt[x][i]])
            {
                f[nxt[x][i]]=1;
                dfs(nxt[x][i]);
            }
        }
        vis[x]=0;
    }
};
Tire ac;
string s;
int main()
{
        int n;
        scanf("%d",&n);
        ac.init();
        for(int i=1;i<=n;i++)
        {
             cin>>s;
             ac.ins(s,i);
        }
        ac.build();
        ac.dfs(ac.rt);
        puts("NIE");
    return 0;
}

P4052 

题意：寻找长度为m的串有多少个包括至少一个已有的单词。

题解：

我们反过来思考，寻找长度为m的串有多少不包括已有的单词，即在ac自动机上进行dp。dp[i][j]表示长度为i的串，遍历到了ac自动机上第j个点有多少个不包括已有单词的点。

if(ed[nxt[j][k]]==0)//如果nxt[j][k]不是单词结尾，即我们可以让他由dp[i-1][j]转换来。

{

dp[i][nxt[j][k]]+=dp[i-1][j];

}

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <queue>
#include <cstring>
#include <algorithm>
#include <string>
using namespace std;
const int maxn=20005;
const int mod=10007;
struct node{
    int x,y;
};
struct Tire{
    int nxt[maxn][26],fail[maxn];
    int cnt,rt;
    int dp[105][maxn];
    int ed[maxn],vis[maxn],f[maxn];
    int newnode()
    {
        for(int i=0;i<26;i++)
        {
            nxt[cnt][i]=-1;
        }
        ed[cnt++]=0;
        return cnt-1;
    }
    void init()
    {
        cnt=0;
        rt=newnode();
        memset(vis,0,sizeof(vis));
        memset(f,0,sizeof(f));
    }
    void ins(string s,int id)
    {
        int len=s.size();
        int now=rt;
        for(int i=0;i<len;i++)
        {
            if(nxt[now][s[i]-'A']==-1)
            {
                nxt[now][s[i]-'A']=newnode();
            }
            now=nxt[now][s[i]-'A'];
        }
        ed[now]=id;
    }
    void build()
    {
        queue<int>q;
        fail[rt]=rt;
        for(int i=0;i<26;i++)
        {
            if(nxt[rt][i]==-1)
            {
                nxt[rt][i]=rt;
            }
            else
            {
                fail[nxt[rt][i]]=rt;
                q.push(nxt[rt][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            for(int i=0;i<26;i++)
            {
                if(nxt[now][i]==-1)
                {
                    nxt[now][i]=nxt[fail[now]][i];
                }
                else
                {
                    fail[nxt[now][i]]=nxt[fail[now]][i];
                    ed[nxt[now][i]]|=ed[fail[nxt[now][i]]];//后缀包括单词结尾，即一定包括结尾，记录
                    q.push(nxt[now][i]);
                }
            }
        }
    }
    void solve(int n)
    {
        dp[0][0]=1;
        for(int i=1;i<=n;i++)
            for(int j=0;j<=cnt;j++)
                for(int k=0;k<26;k++)
                    if(ed[nxt[j][k]]==0)
                    {
                        dp[i][nxt[j][k]]+=dp[i-1][j];
                        dp[i][nxt[j][k]]%=mod;
                    }
        int ans=0;
        for(int i=0;i<=cnt;i++)
            ans+=dp[n][i],ans%=mod;
        int sum=1;
        for(int i=1;i<=n;i++)
            sum*=26,sum%=mod;
        printf("%d\n",(sum-ans+mod)%mod);
    }
};
Tire ac;
string s;
int main()
{
        int n,m;
        scanf("%d%d",&n,&m);
        ac.init();
        for(int i=1;i<=n;i++)
        {
             cin>>s;
             ac.ins(s,i);
        }
        ac.build();
        ac.solve(m);
    return 0;
}