考研路茫茫--单词情结 - HDU 2243(AC自动机+矩阵乘法)

分析：与poj的2778差不多的，求出来所有的情况然后减去不包含的就行了，这次使用了一下kuangbin的那种自动机写法，确实还不错，因为尤是在建立矩阵的时候更加方便。

 

代码如下：

===============================================================================================================================

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<iostream>
using namespace std;

const int MAXN = ;
const int MAXM = ;
const int mod  = ;

struct Matrix
{///定义矩阵
    int size;
    unsigned long long edge[MAXN][MAXN];

    Matrix(int Len)
    {
        size = Len;
        memset(edge, false, sizeof(edge));
    }
    Matrix operator *(const Matrix &Map) const
    {
        Matrix ans(size);

        for(int i=; i<size; i++)
        for(int j=; j<size; j++)
        for(int k=; k<size; k++)
        {
            ans.edge[i][j] += edge[i][k] * Map.edge[k][j];
        }

        return ans;
    }
};

struct Ac_Trie
{
    int next[MAXN][MAXM];
    int fail[MAXN], End[MAXN];
    int Len, root;

    Ac_Trie()
    {
        memset(next, -, sizeof(next));
        memset(End, false, sizeof(End));
        Len = , root = ;
    }

    void Insert(char s[])
    {
        int p = root;

        for(int i=; s[i]; i++)
        {
            int k = s[i] - 'a';

            if(next[p][k] == -)
                next[p][k] = Len++;
            p = next[p][k];
        }

        End[p] = true;
    }

    void GetFail()
    {
        queue<int> Q;
        int p = root;

        fail[p] = root;

        for(int i=; i<MAXM; i++)
        {
            if(next[p][i] == -)
                next[p][i] = root;
            else
            {
                fail[next[p][i]] = root;
                Q.push(next[p][i]);
            }
        }

        while(Q.size())
        {
            p = Q.front();
            Q.pop();

            for(int i=; i<MAXM; i++)
            {
                if(next[p][i] == -)
                    next[p][i] = next[fail[p]][i];
                else
                {
                    fail[next[p][i]] = next[fail[p]][i];
                    Q.push(next[p][i]);
                }
            }

            End[p] |= End[fail[p]];
        }
    }

    Matrix GetMatrix()
    {
        Matrix ans(Len+);

        for(int i=; i<Len; i++)
        for(int k=; k<MAXM; k++)
        {
            if(End[next[i][k]] == false)
                ans.edge[i][next[i][k]] += ;
        }

        for(int i=; i<=Len; i++)
            ans.edge[i][Len] = ;

        return ans;
    }
};

Matrix QuickPow(long long K, Matrix Map)
{
    Matrix ans(Map.size);

    for(int i=; i<ans.size; i++)
        ans.edge[i][i] = ;

    while(K)
    {
        if(K & )
            ans = ans * Map;
        Map = Map * Map;

        K /= ;
    }

    return ans;
}

int main()
{
    long long N, L;

    while(scanf("%lld%lld", &N, &L) != EOF)
    {
        char s[MAXN];
        Ac_Trie a;

        while(N--)
        {
            scanf("%s", s);
            a.Insert(s);
        }

        a.GetFail();
        Matrix ans = a.GetMatrix();

        unsigned long long sum1=, sum=;

        ans = QuickPow(L, ans);

        for(int i=; i<ans.size; i++)
            sum1 += ans.edge[][i];

        ans.size = ;
        ans.edge[][] = ;
        ans.edge[][] = ;
        ans.edge[][] = ans.edge[][] = ;

        ans = QuickPow(L, ans);

        sum = ans.edge[][] + ans.edge[][];

        cout << sum - sum1 <<endl;
    }

    return ;
}