hdu 2604 Queuing (Matrix)

http://acm.hdu.edu.cn/showproblem.php?pid=2604

　　题意是找出长度为n的，不包含“fmf”或“fff”的字符串的个数。

　　这题我是直接套用之前的ac自动机的模板的，构造出自动机，然后利用矩阵快速幂求出结果。当然，这题可以直接推出递推公式，然后再套入矩阵中。复杂度O(m^2 log n)，其中m是矩阵大小，n是要求计算的长度。

代码如下：

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

using namespace std;

const int MS = 20;
int CS = MS;
int MOD = 30;

struct Mat {
    int val[MS][MS];
    Mat(int u = 0) {
        for (int i = 0; i < CS; i++) {
            for (int j = 0; j < CS; j++) {
                val[i][j] = 0;
            }
            val[i][i] = u % MOD;
        }
    }
    void print() {
        puts("Debug:");
        for (int i = 0; i < CS; i++) {
            for (int j = 0; j < CS; j++) {
                cout << val[i][j] << ' ';
            }
            cout << endl;
        }
        puts("~~~~~~");
    }
} Base, op;

Mat operator + (Mat &a, Mat &b) {
    Mat ret;
    for (int i = 0; i < CS; i++) {
        for (int j = 0; j < CS; j++) {
            ret.val[i][j] = (a.val[i][j] + b.val[i][j]) % MOD;
        }
    }
    return ret;
}

Mat operator * (Mat &a, Mat &b) {
    Mat ret = Mat();
    for (int i = 0; i < CS; i++) {
        for (int k = 0; k < CS; k++) {
            if (a.val[i][k]) {
                for (int j = 0; j < CS; j++) {
                    ret.val[i][j] += a.val[i][k] * b.val[k][j];
                    ret.val[i][j] %= MOD;
                }
            }
        }
    }
    return ret;
}

Mat operator ^ (Mat &a, int p) {
    Mat t = a;
    Mat ret = Mat(1);
    while (p > 0) {
        if (p & 1) ret = ret * t;
        t = t * t;
        p >>= 1;
    }
    return ret;
}

const int kind = 2;
const int N = 10;
int root, cntNode;

struct Node {
    int c[kind];
    int fail;
    bool end;
    void init() {
        memset(c, -1, sizeof(c));
        fail = -1;
        end = false;
    }
} node[N];
int Q[N], qh, qt;

void init() {
    root = cntNode = 0;
    node[root].init();
}

void insert(char *s) {
    int p = root, idx;
    while (*s) {
        idx = (*s == 'f');
        if (node[p].c[idx] == -1) {
            node[++cntNode].init();
            node[p].c[idx] = cntNode;
        }
        p = node[p].c[idx];
        s++;
    }
    node[p].end = true;
}

void buildMat() {
    op = Mat();
    Base = Mat();
    Base.val[0][0] = 1;
    qh = qt = 1;
    Q[qt++] = root;
    while (qh < qt) {
        int u = Q[qh++];
        for (int i = 0; i < kind; i++) {
            int c = node[u].c[i];
            if (~c) {
                if (u == root) {
                    node[c].fail = root;
                } else {
                    node[c].fail = node[node[u].fail].c[i];
                    if (node[node[c].fail].end) node[c].end = true;
                }
                Q[qt++] = c;
            } else {
                if (u == root) {
                    node[u].c[i] = root;
                } else {
                    node[u].c[i] = node[node[u].fail].c[i];
                }
            }
        }
    }
    for (int i = 0; i < CS; i++) {
        if (node[i].end) continue;
        for (int j = 0; j < kind; j++) {
            int t = node[i].c[j];
            if (node[t].end) continue;
            op.val[i][t]++;
        }
    }
}

void PRE() {
    char *str[2] = { "fmf", "fff"};
    init();
    insert(str[0]);
    insert(str[1]);
    CS = cntNode + 1;
    buildMat();
}

int main() {
    int n;
    PRE();
//    op.print();
    while (cin >> n >> MOD) {
        Base = op;
        Base = Base ^ n;
//        Base.print();
        int ans = 0;
        for (int i = 0; i < CS; i++) {
            ans += Base.val[0][i];
            ans %= MOD;
        }
        cout << ans << endl;
    }
    return 0;
}

——written by Lyon