牛客练习赛63 E 题题解

写这份题解之前，还没看见有人写这个题的题解，那么我就来写个吧。不排除我眼瞎的可能性

首先，我们钦定串 为最短的 ，满足 ，再钦定 为 。

如果 ，则答案一定为 。毕竟 不可能出现在比它还短的串中。

那么，不难发现，对于 ， 都能用 和 的若干次拼接表示。

然后再经过分析，不难发现，由于 ，且 ，则 在 中，要么出现在 中，要么出现在 中，要么出现在 或者 或者 的拼接中。

举个栗子，考虑 ，，，（此处下划线为标记 的匹配位置）。

不难发现， 只在 中出现 次，在 中出现 次，在 中出现 次（这里我们认为，只有 在字符串拼接的匹配中，匹配位置包含了前一个串的非空后缀以及后一个串的非空前缀，这个时候 才在这个字符串的拼接中出现了），在 中出现 次，在 中出现 次。

然后在 中，、、、、 的出现次数分别为 、、、、 次，则将上面的出现次数分别对应相乘，就可以知道 在 中出现了 次。结果很正确。

那么，这个计算方式就给了我们一个做法：

1. 分别计算 、、、、 中 的出现次数。
2. 分别计算 、、、、 在 的出现次数。

对于第一步，显然可以使用 计算匹配数。

对于第二步，有一个简单的 递推：分别记录 中五种串的出现次数，以及当前这个串的开头是 还是 ，结尾是 还是 。然后递推的时候每种串的出现次数都用斐波那契数列的递推公式计算，然后特别对拼接位置多出来的一个拼接是 、 还是 加一下就行了。

但是 的复杂度显然不能接受。由于斐波那契数列可以用矩阵优化转移，这个递推本质上也是一个改造的斐波那契数列，所以也可以用矩阵加速。

upd:

看到有人问矩阵咋构造的，那我就再就这个东西讲一讲吧。

假如不考虑拼接的时候新产生的 、、，那么我们就有这样的转移：

若令：

且设有转移矩阵 满足：

则可以构造一个 的矩阵优化上面那个假的转移：

然后我们再考虑，怎么将拼接中间的状态考虑进来。

可以发现，除了 这个串是以 结尾之外， 的结尾一定都是 。

这也就意味着，除了 的拼接中会产生 之外，其他的 的拼接中只可能产生 或者 。

那么，特判掉 的情况之后就能矩阵加速了。

然后，我们就可以考虑两种做法：

1. 在 矩阵中加入四行，分别表示 的 开头/结尾 是 还是 。如果分别用 ， 表示是 还是 的话，那么就可以在 的对应位置中用 构造出一个判断。（其实就是单位根反演）
2. 注意到 和 的拼接是交替进行的，则可以加入两行分别表示 的拼接是 还是 。由于 的拼接和 的拼接是一样的（也就是中间拼接的段同为 或者 ），则可以直接在转移矩阵中加上对应值。

我的代码实现的是第二种方法。则复杂度就是 。方法二中 。

方法二中，最后转移的 矩阵长这样：

长这样：

以下贴出我的代码给大家作为参考。

/********************************************************************************

    Code by a weak man who named CYJian, and he hopes the code could get more points.

    Algorithm: 

 ********************************************************************************/

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

//{{{ FAST IO AND SOME FUNCTIONS
const int __SIZE = 1 << 18;
char ibuf[__SIZE], *iS, *iT;

#define ge (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin), (iS == iT ? EOF : *iS++)) : *iS++)
#define ri read_int()
#define rl read_ll()
#define FILE(s) freopen(s"in", "r", stdin), freopen(s"out", "w", stdout)

template<typename T>
inline void read(T &x) {
    char ch, t = 0; x = 0;
    while(!isdigit(ch = ge)) t |= ch == '-';
    while(isdigit(ch)) x = x * 10 + (ch ^ 48), ch = ge;
    x = t ? -x : x;
}
inline int read_int() { int x; return read(x), x; }
inline ll read_ll() { ll x; return read(x), x; }

template<typename T> inline void chkmin(T&a, T b) { a = a < b ? a : b; }
template<typename T> inline void chkmax(T&a, T b) { a = a > b ? a : b; }
//}}}

const int MAXN = 2000010;
const int mod = 1e9 + 7;

char A[MAXN];
char B[MAXN];
char S[MAXN];
char T[MAXN];
int la, lb, ls;

struct Matrix {
    int a[12][12];
    int n, m;

    friend Matrix operator * (Matrix a, Matrix b) {
        Matrix c; c.n = a.n, c.m = b.m;
        memset(c.a, 0, sizeof(c.a));
        for(int i = 0; i < a.n; i++)
            for(int j = 0; j < b.m; j++)
                for(int k = 0; k < a.m; k++)
                    c.a[i][j] = (1LL * a.a[i][k] * b.a[k][j] + c.a[i][j]) % mod;
        return c;
    }
}a;

inline Matrix fsp(Matrix a, ll k) {
    Matrix s; s.n = 12, s.m = 1;
    memset(s.a, 0, sizeof(s.a));
    if(k == 0) {
        s.a[0][0] = 1;
        s.a[6][0] = 1;
        return s;
    }
    --k;
    s.a[1][0] = 1;
    s.a[5][0] = 1;
    s.a[6][0] = 1;
    s.a[7][0] = 1;
    s.a[10][0] = 1;
    while(k) {
        if(k & 1) s = a * s;
        a = a * a, k >>= 1;
    } return s;
}

inline void Add() {
    int l = 0;
    for(int i = 1; i <= la; i++) T[++l] = A[i];
    for(int i = 1; i <= lb; i++) T[++l] = B[i];
    la = lb;
    for(int i = 1; i <= la; i++) A[i] = B[i];
    lb = l;
    for(int i = 1; i <= lb; i++) B[i] = T[i];
}

int fail[MAXN];

inline void Kmp(int n) {
    for(int i = 2; i <= n; i++) {
        int j = fail[i - 1];
        while(j && S[i] != S[j + 1]) j = fail[j];
        j += S[i] == S[j + 1], fail[i] = j;
    }
}

inline int Calc(int n) {
    int cnt = 0;
    for(int i = 1, j = 0; i <= n; i++) {
        while(j && S[j + 1] != T[i]) j = fail[j];
        j += T[i] == S[j + 1];
        if(j == ls) j = fail[j], ++cnt;
    } return cnt;
}

int main() {
#ifdef LOCAL
    FILE("");
#endif

    ll n;
    scanf("%lld%s%s%s", &n, A + 1, B + 1, S + 1);
    --n;

    la = strlen(A + 1);
    lb = strlen(B + 1);
    ls = strlen(S + 1);

    while(n && (la < ls || lb < ls)) Add(), --n;

    int len;

    Kmp(ls);

    len = 0;
    for(int i = 1; i <= la; i++) T[++len] = A[i];
    int len_A = Calc(len);

    len = 0;
    for(int i = 1; i <= lb; i++) T[++len] = B[i];
    int len_B = Calc(len);

    len = 0;
    for(int i = 1; i <= la; i++) T[++len] = A[i];
    for(int i = 1; i <= lb; i++) T[++len] = B[i];
    int len_AB = Calc(len) - len_A - len_B;

    len = 0;
    for(int i = 1; i <= lb; i++) T[++len] = B[i];
    for(int i = 1; i <= la; i++) T[++len] = A[i];
    int len_BA = Calc(len) - len_A - len_B;

    len = 0;
    for(int i = 1; i <= lb; i++) T[++len] = B[i];
    for(int i = 1; i <= lb; i++) T[++len] = B[i];
    int len_BB = Calc(len) - len_B - len_B;

    a.n = a.m = 12;
    a.a[0][5] = 1;
    a.a[1][6] = 1;
    a.a[2][7] = 1;
    a.a[3][8] = 1;
    a.a[4][9] = 1;
    a.a[5][0] = a.a[5][5] = 1;
    a.a[6][1] = a.a[6][6] = 1;
    a.a[7][2] = a.a[7][7] = 1;
    a.a[8][3] = a.a[8][8] = a.a[8][10] = 1;
    a.a[9][4] = a.a[9][9] = a.a[9][11] = 1;
    a.a[10][11] = a.a[11][10] = 1;

    Matrix f = fsp(a, n);

    int res = (1LL * len_A * f.a[0][0] + 1LL * len_B * f.a[1][0] + 1LL * len_AB * f.a[2][0] + 1LL * len_BA * f.a[3][0] + 1LL * len_BB * f.a[4][0]) % mod;

    cout << res << endl;
    return 0;
}