abc 305

G - Banned Substrings

题意：
构造一个全部由 a，b 组成的长为 m 的字符串。其中不能包括以下 n 个字符串。问有多少种方案

题解：

对 n 个禁止字符串跑ac自动机，建立一个状态机

将这题转化为：在状态机上从 0 节点出发走 m 步回到 0 节点，其中一些点不能经过的总方案数。

朴素dp

• dp[i][k]: 已走 i 步，当前在 k 节点的总方案数目

• 转移：dp[i][k] = ${\sum }_{k=0}^{tot}(ma{t}_{jk}\ast dp[i-1][k])$

  mat：从 k 到 j 的方案数

此时 n 最大为 1e18，直接跑dp不现实
可以用矩阵快速幂优化 dp

转移方程可以看成矩阵乘以向量的线性变换，即求出变换矩阵 $ma{t}^n$(这里可以用快速幂实现O(logn) 内跑完) ，然后得到 b = Ax

一文详解如何使用「矩阵快速幂」优化 DP 过程（含模板 & 完整数学推导）

可以直接看第二个例题 和 本题很相似

一个动态规划方程能够用矩阵乘法来进行优化，那么必须满足：

1. 状态必须是一维或者两维，如果状态本身有超过两维，可以通过把多维状态压缩到一维的方法降到两维（此时状态数并没有变化）。

2. 每一个状态f [i] [j]必须满足只和f [i − 1] [k]有关，并且只能是线性关系。

3. 满足前两条的情况下，可以使用矩阵乘法，但是可能并不能达到优化复杂度的目的。如果对于不同的i，转移矩阵没有规律，那么是无法使用快速幂来加速矩阵乘法的。通常情况下，都有转移矩阵都相同或者至少是循环出现。

4. 假设第一维的大小是N，第二维的大小是M，则矩阵乘法的时间复杂度是O ( M3 log N ) ，而直接转移的复杂度至多是O ( M2N ) ，有时候甚至更小。通常只有M很小 而N相当大的时候才会使用矩阵乘法，否则得不偿失。

code：

#include <bits/stdc++.h>
using namespace std;
using li = long long;
using vi = vector<int>;

const int N = 6 * 126, mod = 998244353;
const int chs = 2;
inline li Mod(li u) { return (u % mod + mod) % mod; }

int trie[N][chs], tot;
int fail[N];
bool ed[N];

void insert(string s) {
    int p = 0;
    for (char i : s) {
        int ch = i - 'a';
        if (!trie[p][ch])
            trie[p][ch] = ++tot;
        p = trie[p][ch];
    }
    ed[p] = 1;
}

void build() {
    queue<int> q;
    for (int i = 0; i < chs; ++i) {
        if (trie[0][i])
            q.push(trie[0][i]);
    }

    while (q.size()) {
        int nod = q.front(); q.pop();

        for (int i = 0; i < chs; ++i) {
            int p = trie[nod][i], fa_p = trie[fail[nod]][i];
            if (p)
                fail[p] = fa_p,
                q.push(p);
            else
                trie[nod][i] = fa_p;
            ed[trie[nod][i]] |= ed[fa_p];
        }
    }
}

struct Mat {
    vector<vi> mat;
    int siz;

    Mat(int len) {
        siz = len;
        mat = vector<vi>(len, vi(len));
        for (int i = 0; i < len; ++i)
            mat[i][i] = 1;
    }
    Mat(const vector<vi>& m) : mat(m), siz(m.size()) {}

    Mat operator*=(const Mat& y) {
        vector<vi> a(y.siz, vi(y.siz));
        for (int i = 0; i <= y.siz - 5; ++i) {
            for (int j = 0; j <= y.siz - 5; ++j) {
                for (int k = 0; k <= y.siz - 5; ++k) {
                    a[i][j] = Mod((li)a[i][j] + Mod((li)mat[i][k] * y.mat[k][j]));
                }
            }
        }
        mat = a;
        return *this;
    }
};

Mat power(Mat a, li cnt) {
    Mat res(a.siz);
    while (cnt) {
        if (cnt & 1) {
            res *= a;
        }
        a *= a, cnt >>= 1ll;
    }
    return res;
}


signed main() {
    ios::sync_with_stdio(false), cin.tie(0);
    li m, n; cin >> m >> n;
    for (int i = 1; i <= n; ++i) {
        string s; cin >> s;
        insert(s);
    }

    build();

    vector<vi> a(tot + 5, vi(tot + 5));
    for (int i = 0; i <= tot; ++i) {
        if (ed[i])
            continue;
        for (int ch = 0; ch < chs; ++ch) {
            if (ed[trie[i][ch]])
                continue;
            ++a[trie[i][ch]][i];
        }
    }

    Mat mat(a);
    mat = power(mat, m);

    li res = 0;
    for (int i = 0; i <= tot; ++i)
        (res += mat.mat[i][0]) %= mod;
    cout << res;
}