[BZOJ1009] [HNOI2008] GT考试 (KMP & dp & 矩阵乘法)

Description

　　阿申准备报名参加GT考试，准考证号为N位数X1X2....Xn(0<=Xi<=9),他不希望准考证号上出现不吉利的数字。
　　他的不吉利数学A1A2...Am(0<=Ai<=9)有M位，不出现是指X1X2...Xn中没有恰好一段等于A1A2...Am. A1和X1可以为0

Input

　　第一行输入N,M,K.接下来一行输入M位的数。 N<=10^9,M<=20,K<=1000

Output

　　阿申想知道不出现不吉利数字的号码有多少种，输出模K取余的结果.

Sample Input

4 3 100
111

Sample Output

81

HINT

Source

Solution

　　$f[i][j]$表示由$i$的数字构成的数串中与不吉利数字刚好匹配$j$位的方案数

　　因为我们只需关心后$j$位是否被匹配，如果在不久的将来有一位失配，那么这一段字符就一定不是给定的数串

　　可以看出来，由$f[i]$转移到$f[i+1]$时，需要借助$KMP$算出，具体方法就是枚举$0sim 9$，用$pi$数组算出匹配的位数$k$，$f[i+1][k]$+=$f[i][j]$

　　注意到准考证号位数可以达到$10^9$妈蛋考试时号码都抄不完，$TLE/MLE$无疑

　　由于每一次$f[i]$转移到$f[i+1]$时所有步骤是一样的，所以可以用一个矩阵，用乘法代替一次转移。这样就可以用快速幂优化转移啦

　　构造矩阵暴力即可，注意$f[i][m]$的特殊性，它每次只向$f[i+1][m]$转移。

#include <bits/stdc++.h>
using namespace std;
int mod, pi[25];
struct matrix
{
    int a[25][25], n, m;
 
    matrix() {}
 
    matrix(int x, int y)
    {
        n = x, m = y;
        memset(a, 0, sizeof(a));
    }
 
    matrix operator* (matrix rhs)
    {
        matrix ans(n, rhs.m);
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < rhs.m; ++j)
                for(int k = 0; k < m; ++k)
                    ans.a[i][j] = (ans.a[i][j] + a[i][k] * rhs.a[k][j]) % mod;
        return ans;
    }
 
    matrix operator^ (int rhs)
    {
        matrix ans(n, n), bs = *this;
        for(int i = 0; i < n; ++i)
            ans.a[i][i] = 1;
        for(; rhs; rhs >>= 1, bs = bs * bs)
            if(rhs & 1) ans = ans * bs;
        return ans;
    }
};
char s[25];
 
void getpi(int m)
{
    int j = 0;
    for(int i = 2; i <= m; ++i)
    {
        while(j && s[i] != s[j + 1])
            j = pi[j];
        pi[i] = s[i] == s[j + 1] ? ++j : j;
    }
}
 
int main()
{
    int n, m, ans, bs = 10;
    cin >> n >> m >> mod >> s + 1;
    getpi(m);
    matrix f(1, m + 1), w(m + 1, m + 1);
    f.a[0][0] = 1, w.a[m][m] = 10;
    for(int i = 0; i < m; ++i)
        for(int j = 0; j < 10; ++j)
        {
            int k = i;
            while(k && j != s[k + 1] - 48)
                k = pi[k];
            if(j == s[k + 1] - 48) ++k;
            ++w.a[i][k];
        }
    f = f * (w ^ n);
    for(ans = 1; n; n >>= 1, bs = (bs * bs) % mod)
        if(n & 1) ans = (ans * bs) % mod;
    cout << (ans - f.a[0][m] + mod) % mod << endl;
    return 0;
}