hdu 2243 考研路茫茫――单词情结

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

　　搞了4天题，今天终于AC了！！！

　　这是一道自动机的题，不过要用到矩阵的知识才能完成。所以，在我做这题之前，我先做了poj 3233(n次连续矩阵和)以及poj 2440(状态转移借助矩阵解)作为这题的基础！

　　题意很简单，就是求长度在1到L中，含有给出字符串的串的个数。直接解是比较难接触答案的，所以要借助反面情况，也就是求不含给出字符串的串的个数。然后用全体情况来减回去，就能得到最终答案了！模2^64，只要稍微有点常识的，都能想到直接用unsigned long long来储存，计算机会自动帮你模的了。

　　刚开始做的时候，还想直接在建立自动机的时候就把矩阵构建好，结果搞着搞着，发现被我搞乱了。。。囧！所以最后还是把自动机建立好了，再把矩阵搞好！

代码如下：

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

using namespace std;
typedef unsigned __int64 ull;

const int matSize = 30;
int curSize = matSize;

struct Matrix {
    ull 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 w = curSize, int l = curSize) {
        for (int  i = 0; i < w; i++) {
            for (int j = 0; j < l; j++) {
                if (j) putchar(' ');
                printf("%I64u", val[i][j]);
            }
            puts("");
        }
    }
} Base, op;

Matrix operator + (Matrix &_a, Matrix &_b) {
    Matrix ret;

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

    return ret;
}

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];
                }
            }
        }
    }

    return ret;
}

Matrix operator ^ (Matrix &__a, int _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 kind = 26;
const int maxn = 30;

int root, cntNode;

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

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

int Q[maxn], head, tail;

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

void insert(char *_s) {
    int _p = root, index;

    while (*_s) {
        index = *_s - 'a';
        if (node[_p].child[index] == -1) {
            node[++cntNode].init();
            node[_p].child[index] = cntNode;
        }
        _p = node[_p].child[index];
        _s++;
    }
    node[_p].end = true;
}

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

    head = tail = 0;
    Q[tail++] = root;

    while (head < tail) {
        int u = Q[head++];

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

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

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

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

            if (node[t].end) continue;
            op.val[i][t]++;
        }
    }

//  for (int i = 0; i <= cntNode; i++) {
//      printf("%d : fail %d ", i, node[i].fail);
//      for (int j = 0; j < kind; j++) {
//          printf(" %d", node[i].child[j]);
//      }
//      puts("");
//  }
//  op.print();
}

Matrix calSum(Matrix &_mat, int _p) {
    Matrix ONE = Matrix(true), ep = _mat;
    Matrix ret = Matrix(), cur = Matrix(true), tmp;

    while (_p) {
        if (_p & 1) {
            ret = ret * ep;
            ret = ret + cur;
        }
        tmp = ONE + ep;
        cur = cur * tmp;
        ep = ep * ep;
        _p >>= 1;
    }
    ret = ret * _mat;

    return ret;
}

ull cal(int _p) {
    ull sum = 0;

//    op.print();
    op = calSum(op, _p);
    Base = Base * op;
//    puts("Base:");
//    Base.print();

    op = Matrix();
    op.val[0][0] = 26;
    op = calSum(op, _p);
//    puts("op:");
//    op.print();

    for (int i = 0; i < curSize; i++) {
        sum += op.val[0][i];
        sum -= Base.val[0][i];
    }

    return sum;
}

int main() {
    int n, l;
    char buf[10];

//    freopen("in", "r", stdin);
    while (~scanf("%d%d", &n, &l)) {
        init();
        while (n--) {
            scanf("%s", buf);
            insert(buf);
        }
        curSize = cntNode + 1;
        buildMat();
        printf("%I64u\n", cal(l));
    }

    return 0;
}

——written by Lyon