【XR-1】分块

题目link：https://www.luogu.com.cn/problem/P5343

---

Part1：

首先这道题能够想到一个比较显然的 $dp$ 。

设 $dp[i]$ 表示长度为 $i$ 的序列有几种分块方式。

那么容易的出转移方程： $dp[i]$ $=$ $∑$ $dp[i$ $-$ $p[j]]$ $(1$ $≤$ $j$ $≤$ $l)$ ，其中 $l$ 为相同长度的块数， $p[j]$ 表示第 $j$ 个相同长度的块。

这样便可以 $O(n)$ 求出答案，可以通过 $60$$\%$ 的数据，但是 $100$$\%$ 的数据中 $0$ $≤$ $n$ $≤$ $10^{18}$ 。

---

Part2：

考虑优化，显然这个递推式是一个常系数线性递推，而这个 $l$ 的大小最大为 $100$ ，因此可以用矩阵快速幂优化。

因此只需要预处理出前 $100$ 的 $dp$ 值，之后构造初始向量和转移矩阵就可以了。

---

时间复杂度 $O($$x^3$ $*$ $log$ $k)$。

---

Code：

#include <cstdio>
#include <algorithm>

typedef long long LL;

const int MAXN = 100;
const LL MOD = 1e9 + 7;

LL n, dp[MAXN + 5];
int pr, nf, prPiece[MAXN + 5], nfPiece[MAXN + 5];
int len, piece[MAXN + 5], x;

struct Mat {

    int N, M;
    LL arr[MAXN + 5][MAXN + 5];

    Mat() {}
    Mat(int _N, int _M, LL val = 0ll) {
        N = _N, M = _M;
        for(int i = 1; i <= N; ++i) {
            for(int j = 1; j <= M; ++j) {
                arr[i][j] = (i == j) ? val : 0ll;
            }
        }
    }

    // void print() {
    //     for(int i = 1; i <= N; ++i) {
    //         for(int j = 1; j <= M; ++j) {
    //             printf("%lld%c", arr[i][j], j == M ? '\n' : ' ');
    //         }
    //     }
    //     puts("");
    // }

};

Mat operator* (const Mat &A, const Mat &B) {

    Mat res(A.N, B.M);

    for(int i = 1; i <= res.N; ++i) {
        for(int j = 1; j <= res.M; ++j) {
            for(int k = 1; k <= A.M; ++k) {
                res.arr[i][j] += (A.arr[i][k] * B.arr[k][j]) % MOD;
                res.arr[i][j] %= MOD;
            }
        }
    }

    return res;
}

Mat qpow(Mat A, LL k) {

    Mat res(A.N, A.M, 1);

    for(; k; k >>= 1) {
        if(k & 1) res = res * A;
        A = A * A;
    }

    return res;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int main() {

    scanf("%lld", &n);

    scanf("%d", &pr);
    for(int i = 1; i <= pr; ++i) {
        scanf("%d", &prPiece[i]);
    }

    scanf("%d", &nf);
    for(int i = 1; i <= nf; ++i) {
        scanf("%d", &nfPiece[i]);
    }

    std::sort(prPiece + 1, prPiece + pr + 1);
    std::sort(nfPiece + 1, nfPiece + nf + 1);
    int ptPr = 1, ptNf = 1;
    while(ptPr <= pr && ptNf <= nf) {
        if(prPiece[ptPr] < nfPiece[ptNf]) {
            ++ptPr;
        }
        else if(prPiece[ptPr] > nfPiece[ptNf]) {
            ++ptNf;
        }
        else {
            if(prPiece[ptPr] != prPiece[ptPr - 1] && nfPiece[ptNf] != nfPiece[ptNf - 1]) {
                piece[++len] = prPiece[ptPr];
            }
            ++ptPr, ++ptNf;
        }
    }

    for(int i = 1; i <= len; ++i) {
        x = max(x, piece[i]);
    }

    Mat fac(x, x), vec(1, x);
    dp[0] = 1ll;
    for(int i = 1; i <= x; ++i) {
        for(int j = 1; j <= len; ++j) {
            if(i - piece[j] < 0) break;
            dp[i] += dp[i - piece[j]];
            dp[i] %= MOD;
        }
    }

    for(int i = 1; i <= x; ++i) {
        vec.arr[1][i] = dp[x - i + 1];
    }

    for(int i = 1; i <= len; ++i) {
        fac.arr[piece[i]][1] = 1ll;
    }

    for(int i = 1; i <= fac.N; ++i) {
        for(int j = 2; j <= fac.M; ++j) {
            fac.arr[i][j] = (i == j - 1) ? 1ll : 0ll;
        }
    }

    if(n <= x) {
        printf("%lld\n", dp[n]);
    }
    else {
        printf("%lld\n", (vec * qpow(fac, n - x)).arr[1][1]);
    }

    return 0;
}