poj 2778 DNA Sequence

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

　　跟上一篇一样，都是自动机加矩阵的题。不过这次因为忘记将答案取模了，所以wa了一次。。。- -这次的代码相对整齐了点，没有上一篇那么乱了。。。

代码如下：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <map>
#include <algorithm>
#include <cassert>

using namespace std;

const int matSize = 105;
const int initMod = 100000;
int curSize = matSize;
typedef long long ll;

struct Matrix {
    ll val[matSize][matSize];

    Matrix (bool ONE = false) {
        for (int i = 0; i < curSize; i++) {
            for (int j = 0; j < curSize; j++) {
                val[i][j] = 0;
            }
            val[i][i] = ONE;
        }
    }

    void print(int _l = curSize, int _w = curSize) {
        for (int i = 0; i < _l; i++) {
            for (int j = 0; j < _w; j++) {
                if (j) putchar(' ');
                cout << val[i][j];
            }
            puts("");
        }
    }
} Base, op;

Matrix operator * (Matrix &_a, Matrix &_b) {
    Matrix ret = Matrix();

    for (int i = 0; i < curSize; i++) {
        for (int k = 0; k < curSize; k++) {
            if (_a.val[i][k]) {
                for (int j = 0; j < curSize; j++) {
                    ret.val[i][j] += _a.val[i][k] * _b.val[k][j];
                    ret.val[i][j] %= initMod;
                }
            }
        }
    }

    return ret;
}

Matrix operator ^ (Matrix &__a, ll _p) {
    Matrix _a = __a;
    Matrix ret = Matrix(true);

    while (_p) {
        if (_p & 1) {
            ret = ret * _a;
        }
        _a = _a * _a;
        _p >>= 1;
    }

    return ret;
}

const int maxNode = 105;
const int kind = 4;
int root, cntNode;
int Q[maxNode], qh, qt;

struct Node {
    int child[kind];
    int fail;
    bool end;

    Node() {
        for (int i = 0; i < kind; i++) {
            child[i] = -1;
        }
        fail = -1;
        end = false;
    }
} node[maxNode];

map<char, int> con;

void init() {
    con.clear();
    con['A'] = 0;
    con['T'] = 1;
    con['C'] = 2;
    con['G'] = 3;
}

void initTrie() {
    root = 0;
    cntNode = 1;
    node[root] = Node();
}

void insert(char *_s) {
    int cur = root;

    while (*_s) {
        int index = con[*_s];

        if (node[cur].child[index] == -1) {
            node[cur].child[index] = cntNode;
            node[cntNode] = Node();
            cntNode++;
        }
        cur = node[cur].child[index];
        _s++;
    }
    node[cur].end = true;
}

void buildMat() {
    Base = Matrix();
    op = Matrix();
    Base.val[0][0] = 1;

    qh = qt = 0;
    Q[qt++] = root;
    node[root].fail = root;

    while (qh < qt) {
        int cur = Q[qh++];

        for (int i = 0; i < kind; i++) {
            int c = node[cur].child[i];

            if (~c) {
                if (cur == root) {
                    node[c].fail = root;
                } else {
                    node[c].fail = node[node[cur].fail].child[i];
                    if (node[node[c].fail].end) node[c].end = true;
                }
                Q[qt++] = c;
            } else {
                if (cur == root) {
                    node[cur].child[i] = root;
                } else {
                    node[cur].child[i] = node[node[cur].fail].child[i];
                }
            }
        }
    }

    for (int i = 0; i < cntNode; i++) {
        if (node[i].end) continue;

        for (int j = 0; j < kind; j++) {
            if (node[node[i].child[j]].end) continue;
            op.val[i][node[i].child[j]]++;
        }
    }

//    op.print();
}

int main() {
    int n, m;

//    freopen("in", "r", stdin);
    init();
    while (cin >> n >> m) {
        char buf[15];

        initTrie();
        while (n--) {
            cin >> buf;
            insert(buf);
//            puts("Inserted");
        }
        curSize = cntNode;
        buildMat();
        op = op ^ m;
        Base = Base * op;

        ll ans = 0;

        for (int i = 0; i < curSize; i++) {
            ans += op.val[0][i];
        }
        cout << ans % initMod<< endl;
    }

    return 0;
}

——written by Lyon