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 = 0; i < TOL; i++) next[i] = NULL;
        fail = NULL; flag = 0; id = sz++;
    }
} node;

class Matrix {

    public:

        LL mat[N][N];

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

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

        static void print(Matrix now) {
            printf("sz : %d
", sz);
            for(int i = 0; i < sz; i++) {
                for(int j = 0; 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 = 0; i < sz; i++) {
                for(int k = 0; k < sz; k++) {
                    for(int j = 0; 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 & 1) b = b * a;
                a = a * a;
                k >>= 1;
            }
            return b;
        }

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

class AC_DFA {

    private:

        node* root;
        vector<node*> dic;

    public:

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

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

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

        void insert(char *s) {
            node* now = root;
            int len = strlen(s);
            for(int i = 0; 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 = 1;
        }

        void build() {
            queue<node*> que;
            root->fail = NULL;
            que.push(root);
            while(!que.empty()) {
                node* now = que.front(); que.pop();
                for(int i = 0; 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 = 0; i < dic.size(); i++) {
                for(int j = 0; j < TOL; j++) {
                    if(dic[i]->next[j]->flag == 0) {
                        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 = 0; i < m; i++)
        scanf("%s", s), ac.insert(s);
    ac.build();
    Matrix now = ac.buildMatrix();
    now.solve(now, n);
    return 0;
}

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