【AC自动机 && 矩阵 && 字符串长度为 n 不包含 m 个单词的任何一个的个数】POJ - 2778 DNA Sequence

Step1 Problem:

给你 m 个单词（只由字母 ATCG 组成），让你构造长度为 n 的字符串（只由字母 ATCG 组成）不能包含 m 个单词的任何一个，输出满足条件字符串的个数。
数据范围：
0 <= m <= 10, 1 <= n <= 2e9, 单词长度 <= 10.

Step2 Ideas:

学习博客
看到 n 那么大，就应该想到快速幂。
如果你做过这种类型的题：HDU - 2157 A点到B点走K步的路径条数（可以走重复边）
那么我们把所有后缀的状态记录下来，如果我们知道任何一个后缀到另外一个后缀的方案数。那么问题就解决了。
任何一个后缀到另外一个后缀的方案数就需要用到 AC 自动机了。
对于所给单词构建字典树，对于每一个不同节点都是一个前缀，也是一个不同的状态，我们只需要求这些状态到另外的状态的方案数，就等于任何一个后缀到另外一个后缀的方案数
求状态到另外一个状态的方案数，对于每一个状态下一步添加 A 或 T 或 C 或 G 后的状态，如果不是危险，那么方案数+1。

Step3 Code:

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N = 150;
const int MOD = 1e5;
struct node
{
    int data, idx;
    node *next[4], *fail;
};
node a[N];
int id[100], top, n, vis[N];
struct mat
{
    long long a[N][N];
};
mat c;
node *creat_kong()
{
    node *root = &a[top++];
    root->data = 0;
    root->idx = top-1;
    for(int i = 0; i < 4; i++)
        root->next[i] = NULL;
    root->fail = NULL;
    return root;
}
void Insert(node *root, char *s)
{
    int len = strlen(s);
    node *p = root;
    for(int i = 0; i < len; i++)
    {
        int tmp = id[s[i]];
        if(!p->next[tmp]) p->next[tmp] = creat_kong();
        p = p->next[tmp];
    }
    p->data++;
    vis[p->idx] = 1;
}
void get_fail(node *root)
{
    queue<node*> q;
    q.push(root);
    while(!q.empty())
    {
        node *p = q.front(); q.pop();
        if(p != root && vis[p->fail->idx]) vis[p->idx] = 1;
        for(int i = 0; i < 4; i++)
        {
            if(!p->next[i]) continue;
            if(p == root) p->next[i]->fail = root;
            else {
                node *tmp = p->fail;
                while(tmp && !tmp->next[i]) tmp = tmp->fail;
                if(!tmp) p->next[i]->fail = root;
                else p->next[i]->fail = tmp->next[i];
            }
            q.push(p->next[i]);
        }
    }
}
void get_mat(node *root)
{
    memset(c.a, 0, sizeof(c.a));
    for(int k = 0; k < top; k++)
    {
        node *p = &a[k];
        if(vis[p->idx]) continue;
        for(int i = 0; i < 4; i++)
        {
            node *tmp = p;
            while(tmp && !tmp->next[i]) tmp = tmp->fail;
            if(!tmp) c.a[k][0]++;
            else {
                if(vis[tmp->next[i]->idx]) continue;
                c.a[k][tmp->next[i]->idx]++;
            }
        }
    }
}
mat mul(mat x, mat y)
{
    mat sum;
    memset(sum.a, 0, sizeof(sum.a));
    for(int k = 0; k < top; k++)
    {
        for(int i = 0; i < top; i++)
        {
            if(x.a[i][k])
            for(int j = 0; j < top; j++)
            {
                sum.a[i][j] += (x.a[i][k]*y.a[k][j])%MOD;
                sum.a[i][j] %= MOD;
            }
        }
    }
    return sum;
}
mat Pow(mat x, int m)
{
    mat sum;
    memset(sum.a, 0, sizeof(sum.a));
    for(int i = 0; i < top; i++) sum.a[i][i] = 1;
    while(m)
    {
        if(m&1) sum = mul(sum, x);
        x = mul(x, x);
        m >>= 1;
    }
    return sum;
}
int main()
{
    int m;
    id['A'] = 0; id['C'] = 1; id['G'] = 2; id['T'] = 3;
    char s[20];
    while(~scanf("%d %d", &m, &n))
    {
        top = 0;
        memset(vis, 0, sizeof(vis));
        node *root = creat_kong();
        while(m--)
        {
            scanf("%s", s);
            Insert(root, s);
        }
        get_fail(root);
        get_mat(root);
        mat tmp = Pow(c, n);
        int ans = 0;
        for(int i = 0; i < top; i++)
            ans += tmp.a[0][i], ans %= MOD;
        printf("%d\n", ans);
    }
    return 0;
}