考研路茫茫――单词情结 HDU - 2243(ac自动机 + 矩阵快速幂)

时间：2023-03-08 16:09:32
考研路茫茫――单词情结 HDU - 2243(ac自动机 + 矩阵快速幂)

考研路茫茫——单词情结

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 6853    Accepted Submission(s): 2383

Problem Description
背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele也终于要开始背单词了。
一天，Lele在某本单词书上看到了一个根据词根来背单词的方法。比如"ab",放在单词前一般表示"相反，变坏，离去"等。

于是Lele想，如果背了N个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L，只由小写字母组成的，至少包含一个词根的单词，一共可能有多少个呢？这里就不考虑单词是否有实际意义。

比如一共有2个词根 aa 和 ab ，则可能存在104个长度不超过3的单词，分别为
(2个) aa,ab,
(26个)aaa,aab,aac...aaz,
(26个)aba,abb,abc...abz,
(25个)baa,caa,daa...zaa,
(25个)bab,cab,dab...zab。

这个只是很小的情况。而对于其他复杂点的情况，Lele实在是数不出来了，现在就请你帮帮他。

Input
本题目包含多组数据，请处理到文件结束。
每组数据占两行。
第一行有两个正整数N和L。(0<N<6,0<L<2^31)
第二行有N个词根，每个词根仅由小写字母组成，长度不超过5。两个词根中间用一个空格分隔开。
Output
对于每组数据，请在一行里输出一共可能的单词数目。
由于结果可能非常巨大，你只需要输出单词总数模2^64的值。
Sample Input
2 3
aa ab
1 2
a
Sample Output
104
52
Author
linle
Recommend
lcy

其实poj-2778的代码改一下就好了。。

求长度不超过L，只由小写字母组成的，至少包含一个词根的单词

用所有的情况减去一个也不包含的就好了

长度不超过L

在POJ 2778 得到的L*L的矩阵中，需要增加一维，第L+1列全部为1

就好了  自己写一下矩阵 就能看出来

emm。。我还是写写吧

考研路茫茫――单词情结 HDU - 2243(ac自动机 + 矩阵快速幂)

发现了没有  增加一维后 其他位置没变  （最后是累加第一行）

增加一维后的第一行最后一个位置恰好是矩阵上一个次方 第一行各个位置的累加和 + 1  因为开始是矩阵右下角是1  所以多加了一个1

是的  就是这么巧妙

代码。。。看别人的吧  我写的有点吐血。。

代码是谁的我忘了。。。。不要打我。。。emm。。。

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <queue>

#include <cmath>

#define ll unsigned long long

using namespace std;

const int N = ;

const int SIGMA_SIZE = ;

struct Mat {

    ll a[N][N];

}ori, res;

int Next[N][SIGMA_SIZE], fail[N], val[N], sz, n, L;

char str[N];

void init() {

    sz = ;

    memset(Next[], , sizeof(Next[]));

    val[] = ;

}

void insert(char *s) {

    int u = , len = strlen(s);

    for (int i = ; i < len; i++) {

        int k = s[i] - 'a';

        if (!Next[u][k]) {

            memset(Next[sz], , sizeof(Next[sz]));

            val[sz] = ;

            Next[u][k] = sz++;

        }

        u = Next[u][k];

    }

    val[u] = ;

}

void getFail() {

    queue<int> Q;

    fail[] = ;

    for (int i = ; i < SIGMA_SIZE; i++)

        if (Next[][i]) {

            fail[Next[][i]] = ;

            Q.push(Next[][i]);

        }

    while (!Q.empty()) {

        int u = Q.front();

        Q.pop();

        if (val[fail[u]])

            val[u] = ;

        for (int i = ; i < SIGMA_SIZE; i++) {

            if (!Next[u][i])

                Next[u][i] = Next[fail[u]][i];

            else {

                fail[Next[u][i]] = Next[fail[u]][i];

                Q.push(Next[u][i]);

            }

        }

    }

}

Mat multiply(const Mat &x, const Mat &y) {

    Mat temp;

    for (int i = ; i <= sz; i++)

        for (int j = ; j <= sz; j++) {

            temp.a[i][j] = ;

            for (int k = ; k <= sz; k++)

                temp.a[i][j] += x.a[i][k] * y.a[k][j];

        }

    return temp;

}

void calc(int m) {

    while (m) {

        if (m & )

            res = multiply(res, ori);

        m >>= ;

        ori = multiply(ori, ori);

    }

}

int main() {

    while (scanf("%d%d", &n, &L) == ) {

        init();

        for (int i = ; i < n; i++) {

            scanf("%s", str);

            insert(str);

        }

        getFail();

        for (int i = ; i <= sz; i++)

            for (int j = ; j <= sz; j++)

                res.a[i][j] = ori.a[i][j] = ;

        for (int i = ; i <= sz; i++)

            res.a[i][i] = ;

        for (int i = ; i < sz; i++)

            for (int j = ; j < SIGMA_SIZE; j++)

                if (!val[Next[i][j]])

                    ori.a[i][Next[i][j]]++;

        for (int i = ; i <= sz; i++)

            ori.a[i][sz] = ;

        calc(L);

        ll ans = ;

        for (int i = ; i <= sz; i++)

            ans += res.a[][i];

        ori.a[][] = ori.a[][] = ;

        ori.a[][] = ;

        ori.a[][] = ;

        res.a[][] = ;

        res.a[][] = res.a[][] = res.a[][] = ;

        sz = ;

        calc(L);

        ll ans2 = res.a[][];

        printf("%llu\n", ans2 - ans + );

    }

    return ;

}

相关文章