两个AC自动机+矩阵的题

POJ 2778 DNA Sequence
题意：给出n个匹配串，已知原串的长度为m，求原串中不包含任何一个匹配串的情况数。
先把n个匹配串建成AC自动机，然后根据trie图建矩阵，最后矩阵快速幂求解。
建AC自动机要注意这些矩阵的题，next数组必须有值。初始值为-1方便更新。
建矩阵的时候要注意trie图只是根据next数组来建的，和fail半毛钱关系都没有。那么为什么要用AC自动机呢？这是因为题目要求不包含任何一个匹配串，那么插入匹配串的时候，有些节点是直接就更新了vis值了，然而还有些节点包含上述节点的字符串的时候vis不会更新。于是需要AC自动机。
矩阵快速幂的原理就是图论里面的矩阵的幂：表示从某个状态走n步到某个状态的方案数。现在可以明白为什么next数组必须有值，比如说根的有些next会指向自己，因为这些next开头的字符串根本不可能匹配到匹配串，于是状态没变。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#define ll long long
using namespace std;
int n,m;
char s[11];
struct mat{
    ll a[110][110];
}asdf;
struct ACautomata{
    int next[110][4],fail[110],id[110],num,root;
    bool vis[110];
    int newnode()
    {
        memset(next[num],-1,sizeof next[num]);
        vis[num]=0;
        return num++;
    }
    void init()
    {
        id['A']=0;
        id['C']=1;
        id['G']=2;
        id['T']=3;
        num=0;
        root=newnode();
    }
    void insert(char *s)
    {
        int len=strlen(s),cur=root;
        for(int i=0;i<len;++i)
        {
            int &tmp=next[cur][id[s[i]]];
            if(tmp==-1)tmp=newnode();
            cur=tmp;
        }
        vis[cur]=1;
    }
    void getfail()
    {
        queue<int>q;
        fail[root]=root;
        for(int i=0;i<4;++i)
        {
            int u=next[root][i];
            if(u!=-1)
            {
                fail[u]=0;
                q.push(u);
            }
            else next[root][i]=0;
        }
        while(!q.empty())
        {
            int cur=q.front();
            q.pop();
            if(vis[fail[cur]])vis[cur]=1;
            for(int i=0;i<4;++i)
            {
                int u=next[cur][i];
                if(u!=-1)
                {
                    fail[u]=next[fail[cur]][i];
                    q.push(u);
                }
                else next[cur][i]=next[fail[cur]][i];//所有next都必须有值
            }
        }
    }
    mat build()
    {
        mat tmp;
        memset(tmp.a,0,sizeof tmp.a);
        for(int i=0;i<num;++i)
            for(int j=0;j<4;++j)
                if(!vis[i]&&!vis[next[i][j]])++tmp.a[i][next[i][j]];//如果是i点和它的可达节点都满足题意（不是匹配串）那么就连边
        return tmp;
    }
}ac;
mat mul(mat x,mat y)
{
    mat tmp;
    memset(tmp.a,0,sizeof tmp.a);
    for(int i=0;i<ac.num;++i)
        for(int j=0;j<ac.num;++j)
            for(int k=0;k<ac.num;++k)
                tmp.a[i][j]=(tmp.a[i][j]+x.a[i][k]*y.a[k][j])%100000;//mod 100000，要用long long
    return tmp;
}
mat pow(mat x,ll cnt)
{
    mat tmp;
    for(int i=0;i<ac.num;++i)
        for(int j=0;j<ac.num;++j)
            tmp.a[i][j]=i==j;
    while(cnt)
    {
        if(cnt&1)tmp=mul(tmp,x);
        x=mul(x,x);
        cnt>>=1;
    }
    return tmp;
}
int main()
{
    ac.init();
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
    {
        scanf("%s",s);
        ac.insert(s);
    }
    ac.getfail();
    asdf=ac.build();
    asdf=pow(asdf,m);
    ll ans=0;
    for(int i=0;i<ac.num;++i)//最后答案就是矩阵第一行的所有元素之和，表示一个虚节点到所有实节点的方案数之和
        ans=(ans+asdf.a[0][i])%100000;
    printf("%I64d\n",ans);
}

HDU 2243
题意：给出n个匹配串，已知原串的长度不超过m，求原串中包含至少一个匹配串的情况数。
很明显可以看出来这个题就是上面的题的修改版。
包含至少一个=就是所有情况-不包含任意一个
但是这题难点在于长度不超过m，这个是一个求前缀和形式的
然而可以把刚才构造出的矩阵加一维来求和。具体看代码，我也不好解释，自己构造了半天才构造出来。
然后那个等比数列求和也可以用矩阵来优化，用通项公式不太好，除法不方便。
最后说说这题还有什么细节要注意：
1.多组输入数据
2.m的长度是int范围，这个意味着什么呢？刚才构造出的矩阵加一维可以求和，意味着我们不需要再在最后扫描第一行求和了，只需要从原来的m次幂升到m+1次幂。然而m是int范围于是+1会爆掉。。。用longlong来存储就可以了。
3.去模的数是2的64次方。这个很吓人，因为这个比unsigned long long还多1.这个可以不取模，它自己会自然溢出。

#include<cstdio>
#include<cstring>
#include<queue>
#define ll unsigned long long
using namespace std;
ll ans,m;
int n;
char s[6];
struct mat{
    ll a[30][30];
}asd,fgh;
struct ACautomata{
    int next[30][26],fail[30],root,num;
    bool vis[30];
    int newnode()
    {
        memset(next[num],-1,sizeof next[num]);
        vis[num]=0;
        return num++;
    }
    void init()
    {
        num=0;
        root=newnode();
    }
    void insert(char *s)
    {
        int cur=root,len=strlen(s);
        for(int i=0;i<len;++i)
        {
            int &tmp=next[cur][s[i]-'a'];
            if(tmp==-1)tmp=newnode();
            cur=tmp;
        }
        vis[cur]=1;
    }
    void getfail()
    {
        queue<int>q;
        fail[root]=root;
        for(int i=0;i<26;++i)
        {
            int u=next[root][i];
            if(u!=-1)
            {
                fail[u]=0;
                q.push(u);
            }
            else next[root][i]=0;
        }
        while(!q.empty())
        {
            int cur=q.front();
            q.pop();
            if(vis[fail[cur]])vis[cur]=1;
            for(int i=0;i<26;++i)
            {
                int u=next[cur][i];
                if(u!=-1)
                {
                    fail[u]=next[fail[cur]][i];
                    q.push(u);
                }
                else next[cur][i]=next[fail[cur]][i];
            }
        }
    }
    mat build()
    {
        mat tmp;
        memset(tmp.a,0,sizeof tmp.a);
        for(int i=0;i<num;++i)
            for(int j=0;j<26;++j)
                if(!vis[i]&&!vis[next[i][j]])
                    ++tmp.a[i][next[i][j]];
        for(int i=0;i<=num;++i)
            tmp.a[i][num]=1;
        return tmp;
    }
}ac;
mat mul(mat x,mat y)
{
    mat tmp;
    memset(tmp.a,0,sizeof tmp.a);
    for(int i=0;i<=ac.num;++i)
        for(int j=0;j<=ac.num;++j)
            for(int k=0;k<=ac.num;++k)
                tmp.a[i][j]+=x.a[i][k]*y.a[k][j];
    return tmp;
}
mat pow(mat x,ll cnt)
{
    mat tmp;
    for(int i=0;i<=ac.num;++i)
        for(int j=0;j<=ac.num;++j)
            tmp.a[i][j]=i==j;
    while(cnt)
    {
        if(cnt&1)tmp=mul(tmp,x);
        x=mul(x,x);
        cnt>>=1;
    }
    return tmp;
}
int main()
{
    while(~scanf("%d%I64u",&n,&m))
    {
        ac.init();
        for(int i=1;i<=n;++i)
        {
            scanf("%s",s);
            ac.insert(s);
        }
        ac.getfail();
        asd=ac.build();
        asd=pow(asd,m+1);//这个其实多算了一个1，但是后面的等比数列也是多算了一个1，所以减的时候可以消掉
        fgh.a[0][0]=26;
        fgh.a[1][0]=fgh.a[1][1]=1;
        fgh.a[0][1]=0;
        fgh=pow(fgh,m+1);
        printf("%I64u\n",fgh.a[1][0]-asd.a[0][ac.num]);
    }
}