hud2243 考研路茫茫——单词情结

考研路茫茫——单词情结

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Problem Description

背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele也终于要开始背单词了。
一天，Lele在某本单词书上看到了一个根据词根来背单词的方法。比如"ab",放在单词前一般表示"相反，变坏，离去"等。

于是Lele想，如果背了N个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L，只由小写字母组成的，至少包含一个词根的单词，一共可能有多少个呢？这里就不考虑单词是否有实际意义。

比如一共有2个词根 aa 和 ab ，则可能存在104个长度不超过3的单词，分别为
(2个) aa,ab,
(26个)aaa,aab,aac...aaz,
(26个)aba,abb,abc...abz,
(25个)baa,caa,daa...zaa,
(25个)bab,cab,dab...zab。

这个只是很小的情况。而对于其他复杂点的情况，Lele实在是数不出来了，现在就请你帮帮他。

Input

本题目包含多组数据，请处理到文件结束。
每组数据占两行。
第一行有两个正整数N和L。(0<N<6,0<L<2^31)
第二行有N个词根，每个词根仅由小写字母组成，长度不超过5。两个词根中间用一个空格分隔开。

Output

对于每组数据，请在一行里输出一共可能的单词数目。
由于结果可能非常巨大，你只需要输出单词总数模2^64的值。

Sample Input

2 3
aa ab
1 2
a

Sample Output

104
52

ac自动机上dp。。。我们才用反向思考，求出没有出现的个数。
dp[i][j] 表示节点 i ，走了 j 步，没有出现的个数。
用矩阵优化 j 这一维就好啦~
但是我们要求了是j 1~L 的前缀和。
所以还有一个矩阵
\[ \left[\begin{matrix} a 1\\ 0 1 \\ \end{matrix}\right] \]
这个就是求前缀和。。。如果是矩阵前缀和就把a换成矩阵，1换成等大小的单位矩阵就好了。

#include<bits/stdc++.h>
#define LL unsigned long long
using namespace std;
const int maxn = 120;
struct lpl{
    int n, m; 
    LL a[maxn][maxn];
}op, bas, ini;
struct ld{int son[30]; int fail; bool f;}node[maxn];
bool vis[30];
int N, L, cnt;
LL all, ans;
char s[maxn];


inline lpl operator * (lpl &A, lpl &B){
    lpl ret; ret.n = A.n; ret.m = B.m;
    for(int i = 1; i <= ret.n; ++i)
        for(int j = 1; j <= ret.m; ++j){
            ret.a[i][j] = 0;
            for(int k = 1; k <= ret.n; ++k) ret.a[i][j] += A.a[i][k] * B.a[k][j];
        }
    return ret;
}

inline lpl Fpow(lpl A, int t){
    lpl ret; lpl tmp = A; ret.n = ret.m = A.n; 
    memset(ret.a, 0, sizeof(ret.a)); memset(ini.a, 0, sizeof(ini.a));
    for(int i = 1; i <= ret.n; ++i) ret.a[i][i] = 1;
    while(t){ 
        if(t & 1) ret = ret * tmp;
        tmp = tmp * tmp; t >>= 1;
    }
    return ret;
}

inline void putit(){
    int len, qwe, now; cnt = 1; memset(node, 0, sizeof(node));
    for(int i = 1; i <= N; ++i){
        scanf("%s", s + 1); len = strlen(s + 1); now = 1;
        for(int j = 1; j <= len; ++j){
            qwe = s[j] - 'a' + 1;
            if(!node[now].son[qwe]) node[now].son[qwe] = ++cnt;
            now = node[now].son[qwe]; if(j == len) node[now].f = true;
        }
    }
    lpl lin; lin.n = lin.m = 2; memset(lin.a, 0, sizeof(lin.a));
    lin.a[1][1] = 26; lin.a[1][2] = lin.a[2][2] = 1;
    lin = Fpow(lin, L); all = lin.a[1][1] + lin.a[1][2] - 1;
}

inline void AC(){
    queue<int> q; queue<int> qqq;
    q.push(1); qqq.push(1);
    while(!q.empty()){
        int now = q.front(); q.pop();
        for(int i = 1; i <= 26; ++i){
            if(!node[now].son[i]) continue;
            q.push(node[now].son[i]); qqq.push(node[now].son[i]);
            if(now == 1){node[node[now].son[i]].fail = 1; continue;}
            int t = node[now].fail;
            while(!node[t].son[i] && t) t = node[t].fail;
            if(!t) node[node[now].son[i]].fail = 1;
            else node[node[now].son[i]].fail = node[t].son[i];
        }
    }
    while(!qqq.empty()){
        int now = qqq.front(); qqq.pop();
        int qwe = now;
        while(qwe){
            if(node[qwe].f){node[now].f = true; break;}
            qwe = node[qwe].fail;
        }
    }
}

inline void workk(){
    op.n = cnt, op.m = 1; memset(op.a, 0, sizeof(op.a)); op.a[1][1] = 1;
    memset(bas.a, 0, sizeof(bas.a)); bas.n = bas.m = cnt;
    for(int i = 1; i <= cnt; ++i){
        int now = i, lft = 26; memset(vis, false, sizeof(vis));
        while(now){
            for(int j = 1; j <= 26; ++j){
                if(!node[now].son[j]) continue;
                if(!vis[j]){
                    vis[j] = true; lft--;
                    bas.a[node[now].son[j]][i] = 1;
                }
            }
            now = node[now].fail;
        }
        bas.a[1][i] = lft;
    }
    for(int i = 1; i <= cnt; ++i)
        if(node[i].f)
            for(int j = 1; j <= cnt; ++j) bas.a[i][j] = 0;  
    ini.n = ini.m = cnt * 2;
    for(int i = 1; i <= cnt; ++i){
            ini.a[i][i + cnt] = ini.a[i + cnt][i + cnt] = 1;    
        for(int j = 1; j <= cnt; ++j) ini.a[i][j] = bas.a[i][j];    
    }   
    ini = Fpow(ini, L);
    for(int i = 1; i <= cnt; ++i)
        for(int j = 1; j <= cnt; ++j){
            bas.a[i][j] = ini.a[i][j] + ini.a[i][j + cnt];
            if(i == j) bas.a[i][j]--;
        }
    op = bas * op; ans = 0;
    for(int i = 1; i <= cnt; ++i) ans += op.a[i][1];
    ans = all - ans;
    cout << ans << endl;
}

int main()
{
    while(~scanf("%d%d", &N, &L)){
        putit();
        AC();
        workk();
    }
    return 0;
}

转载于:https://www.cnblogs.com/LLppdd/p/9677888.html