POJ 2778：DNA Sequence（AC自动机构造矩阵）

http://poj.org/problem?id=2778

题意：有m个病毒DNA，问构造一个长度为n的不带病毒DNA的字符串可以有多少种。

思路：看到这题有点懵，想了挺久题解的思路。

使用AC自动机判断总共有哪些状态，和哪些状态是不可取的。

然后构造出矩阵mat，mat[i][j]代表从状态i走到状态j走一步可以有多少种走法，然后走n步就是mat[i][j]^n（就像你走第一步可以有2种走法，走第二步可以有2^2种走法，走第三步可以有2^3种走法一样的道理（一开始还想不懂））。

在AC自动机判断状态不可取的时候，不但是插入的串末尾不可取，而且如果fail指针指向的状态是不可取的，那么当前的状态也是不可取的！因为fail指针指向的是当前匹配了的串的最长后缀，那么当前匹配了的串必定包含了fail指针指向的串（病毒串）。

还参考了很多数据==。

 #include <cstdio>
 #include <cstring>
 #include <queue>
 using namespace std;
 #define N 105
 #define TOL 4
 #define MOD 100000
 typedef long long LL;

 int sz;

 typedef struct Node {
     Node *next[TOL];
     Node *fail; int flag, id;
     Node () {
         for(int i = ; i < TOL; i++) next[i] = NULL;
         fail = NULL; flag = ; id = sz++;
     }
 } node;

 class Matrix {

     public:

         LL mat[N][N];

         void init() { memset(mat, , sizeof(mat)); }

         void identity() { memset(mat, , sizeof(mat)); for(int i = ; i < sz; i++) mat[i][i] = ; }

         static void print(Matrix now) {
             printf("sz : %d\n", sz);
             for(int i = ; i < sz; i++) {
                 for(int j = ; j < sz; j++) {
                     printf("%d ", now.mat[i][j]);
                 }
                 puts("");
             }
         }

         friend Matrix operator * (const Matrix &a, const Matrix &b) {
             Matrix c; c.init();
             for(int i = ; i < sz; i++) {
                 for(int k = ; k < sz; k++) {
                     for(int j = ; j < sz; j++) {
                         c.mat[i][k] = c.mat[i][k] + a.mat[i][j] * b.mat[j][k];
                     }
                     c.mat[i][k] %= MOD; // 如果放在里面会TLE
                 }
             }
             return c;
         }

         friend Matrix operator ^ (Matrix a, int k) {
             Matrix b; b.identity();
             while(k) {
                 if(k & ) b = b * a;
                 a = a * a;
                 k >>= ;
             }
             return b;
         }

         void solve(Matrix now, int n) {
             now = now ^ n;
             int sum = ;
             for(int i = ; i < sz; i++) { sum = (sum + now.mat[][i]); if(sum >= MOD) sum -= MOD; }
             printf("%d\n", sum % MOD);
         }
 };

 class AC_DFA {

     private:

         node* root;
         vector<node*> dic;

     public:

         AC_DFA() {
             dic.clear();
             root = new node();
             sz = ; dic.push_back(root);
         }

         ~AC_DFA() {
             for(int i = ; i < sz; i++) delete dic[i];
         }

         int get(char c) {
             if(c == 'A') return ;
             if(c == 'C') return ;
             if(c == 'G') return ;
             return ;
         }

         void insert(char *s) {
             node* now = root;
             int len = strlen(s);
             for(int i = ; i < len; i++) {
                 int c = get(s[i]);
                 if(now->next[c] == NULL) now->next[c] = new node(), dic.push_back(now->next[c]);
                 now = now->next[c];
             }
             now->flag = ;
         }

         void build() {
             queue<node*> que;
             root->fail = NULL;
             que.push(root);
             while(!que.empty()) {
                 node* now = que.front(); que.pop();
                 for(int i = ; i < TOL; i++) {
                     if(now->next[i]) {
                         node* p = now->fail;
                         while(p && p->next[i] == NULL) p = p->fail;
                         // 如果指向的fail是病毒,那么now->next[i]也是带病毒的,因为指向的fail是其最大后缀
                         if(p) now->next[i]->fail = p->next[i], now->next[i]->flag |= p->next[i]->flag;
                         else now->next[i]->fail = root;
                         que.push(now->next[i]);
                     } else {
                         if(now == root) now->next[i] = root;
                         else now->next[i] = now->fail->next[i];
                     }
                 }
             }
         }

         Matrix buildMatrix() {
             Matrix a; a.init();
             for(int i = ; i < dic.size(); i++) {
                 for(int j = ; j < TOL; j++) {
                     if(dic[i]->next[j]->flag == ) {
                         int tmp = dic[i]->next[j]->id;
                         a.mat[i][tmp]++;
                     }
                 }
             }
             return a;
         }
 };

 int main() {
     int m, n;
     scanf("%d%d", &m, &n);
     char s[N];
     AC_DFA ac;
     for(int i = ; i < m; i++)
         scanf("%s", s), ac.insert(s);
     ac.build();
     Matrix now = ac.buildMatrix();
     now.solve(now, n);
     return ;
 }

 /*
 4 3
 AT
 AC
 AG
 AA
 10 100
 AGAGAGT
 CGTATTG
 AAAATTTCGC
 GCGTA
 TCGA
 AATTGGA
 TAGATAGC
 AGCGTATT
 TTCGA
 TACGTATTG
 3 10
 AT
 GATC
 TGAC
 48233
 */