hdu 2243 AC自动机 + 矩阵加速

problem:

给你 n 个病毒，问长度为 [1, m] 的，包括病毒的有多少。全都是小写字母。

think:

和 poj 2778 有点像。不一样的是：

1)  这个是求包括的，我这么做的，加一维用来表示已经包括了病毒的状态。

2)  求长度是 [1, m] 的。在矩阵里面维度变成二倍。

[A 1]
[1 0] 左下面的 1 就是最后所求。A是矩阵的话，就把 1 变成 I 矩阵， 把 0 变成 零矩阵。

这里建立好的转移矩阵左下面的是 I 矩阵， 所以ans矩阵初始化的时候不是 I 矩阵，而是转移矩阵。

如果把 ans 矩阵初始化为大 I 矩阵，那么矩阵乘 (m+1) 次就好了。

code:

[cpp]  view plain copy print ?

1. const int NN = 33;  
2. const int kind = 26;  
3.   
4. int cnt;//状态数，矩阵大小  
5. char ch[9];  
6.   
7. int fail[NN];//每个状态的fail指针  
8. int child[NN][kind];//01两种  
9. int end[NN];//每个状态是否已经包含一整个病毒  
10. LL dp[NN][NN];//转移矩阵  
11.   
12. struct tri{  
13.     LL a[NN<<1][NN<<1];  
14. };  
15.   
16. int newNode(){  
17.     ++cnt;  
18.     for(int i=0; i<kind; ++i) child[cnt][i] = -1;  
19.     end[cnt] = 0;  
20.     return cnt;  
21. }  
22.   
23. void insert(char *str, int root){  
24.     int p = root;  
25.     for(int i=0; str[i]; ++i){  
26.         int k = str[i] - 'a';  
27.         if(child[p][k] == -1) child[p][k] = newNode();  
28.         p = child[p][k];  
29.     }  
30.     end[p] = 1;  
31. }  
32.   
33. //这个建立fail指针不同于hdu2222  
34. //这里的fail不能有空指针，必须要指向一个状态  
35. queue<int>q;  
36. void build_fail(int root){  
37.     while(!q.empty()) q.pop();  
38.     fail[root] = root;  
39.     q.push(root);  
40.     while(!q.empty()){  
41.         int tmp = q.front();  
42.         q.pop();  
43.         if(end[fail[tmp]]==1) end[tmp] = 1;//tmp也已经包括病毒  
44.         for(int k = 0; k < kind; ++k){  
45.             if(child[tmp][k]!=-1){  
46.                 if(tmp==root) fail[child[tmp][k]] = root;  
47.                 else fail[child[tmp][k]] = child[fail[tmp]][k];  
48.                 q.push(child[tmp][k]);  
49.             } else {  
50.                 if(tmp==root) child[root][k] = root;  
51.                 else child[tmp][k] = child[fail[tmp]][k];  
52.             }  
53.         }  
54.     }  
55. }  
56.   
57. void init_dp(){  
58.     memset(dp, 0, sizeof(dp));  
59.     for(int i = 0; i <= cnt; ++i){  
60.         if(end[i]==1){  
61.             dp[i][cnt+1] = 26;  
62.             continue;  
63.         }  
64.         for(int j = 0; j < kind; ++j){  
65.             int tmp = child[i][j];  
66.             if(end[tmp]==0) ++dp[i][tmp];  
67.             else ++dp[i][cnt+1];  
68.         }  
69.     }  
70.     dp[cnt+1][cnt+1] = 26;  
71.     ++cnt;  
72. }  
73.   
74. tri mul(tri x, tri y){  
75.     tri z;  
76.     for(int i = 0; i <= cnt; ++i){  
77.         for(int j = 0; j <= cnt; ++j){  
78.             z.a[i][j] = 0;  
79.             for(int k = 0; k <= cnt; ++k){  
80.                 z.a[i][j] += x.a[i][k] * y.a[k][j];  
81.             }  
82.         }  
83.     }  
84.     return z;  
85. }  
86.   
87. LL solve(int m){  
88.     if(m==0) return 0;  
89.     tri ans, tmp;  
90.     // 这里的ans不是I矩阵，是因为dp左下方的就是一个小的I矩阵  
91.     for(int i = 0; i <= cnt; ++i){  
92.         for(int j = 0; j <= cnt; ++j){  
93.             ans.a[i][j] = tmp.a[i][j] = dp[i][j];  
94.             ans.a[i][j+cnt+1] = tmp.a[i][j+cnt+1] = 0;  
95.             ans.a[i+cnt+1][j] = tmp.a[i+cnt+1][j] = i==j;  
96.             ans.a[i+cnt+1][j+cnt+1] = tmp.a[i+cnt+1][j+cnt+1] = i==j;  
97.         }  
98.     }  
99.     cnt = cnt * 2 + 1;  
100.     while(m){  
101.         if(m&1) ans = mul(ans, tmp);  
102.         tmp = mul(tmp, tmp);  
103.         m >>= 1;  
104.     }  
105.   
106.     LL res = ans.a[cnt/2+1][cnt/2];  
107.     return res;  
108. }  
109.   
110. int main(){  
111.     int n, m;  
112.     while(scanf("%d%d", &n, &m)!=EOF){  
113.         cnt = -1;  
114.         int root = newNode();  
115.   
116.         for(int i = 0; i < n; ++i){  
117.             scanf("%s", ch);  
118.             insert(ch, root);  
119.         }  
120.         build_fail(root);  
121.         init_dp();  
122.         LL res = solve(m);  
123.         cout<<res<<endl;  
124.     }  
125.     return 0;  
126. }