2019.2.26考试T2 矩阵快速幂加速DP

\(\color{#0066ff}{题解 }\)

可以发现， 数据范围中的n特别小，容易想到状压

可以想到类似于状压DP的思路，按列进行转移

那么应该有3维，\(f[i][j][k]\)代表到第i列，j的每一位表示这一行有多少连续的男生，k表示当前有多少列全是男生，的方案数

看到m的范围，我们肯定是要找一个\(O(logm)\)的东西加速转移，自然是矩阵加速

然后我们来看看有多少个状态，看看是否可行

j有\(p^n\)个，k有q个（用矩阵转移第一维自然不需要）

那么状态数依然达到了一个\(p^n*q=3^8*3=19683\)

这东西要是\(O(n^3)\)去转移绝对T到飞起，而且空间也是开不下

所以我们考虑减少状态的数量

发现，我们并不需要知道每一行当前有多少个连续的男生，我们只需要知道有多少行的连续的男生是\(0,1\dots p-1\)个

这相当于把一个数n拆分成p个数的和

这样的状态数绝对是少得多了，就可以矩阵加速了

我们可以通过dfs预处理出所有的状态（状态数极限$\le$200）

然后为了推出转移矩阵，我们需要考虑一个状态对另一个状态的贡献，直接\(n^2\)枚举即可

假设我们现在考虑\(x\to y\)的贡献

设\(x_0, x_1, x_2,xx\)表示状态x中，有连续0个男生的行的数量，有连续1个男生的行的数量，有连续2个男生的行的数量，有多少列全是男生，这个已经dfs预处理过，y同理

如果\(xx + 1 == yy\)

那就说明当前这一列必须全是男生，于是\(x_0\)要全给\(y_1\)，\(x_1\)要全给\(y_2\)，而且\(x_2\)必须为0，这样才有1的贡献

然后考虑不全为1的

我们肯定是放女生或男生，那么拿\(x_1\)来说，如果一些行放女生，那么这些行就要转移到\(y_0\)，如果放男生，就要转移到\(y_2\)，那么显然组合一下，方案就是\(C_{x_1}^{x_1-y_2}\)，\(x_0\)同理

然后构造完转移矩阵，加速递推即可

#include<bits/stdc++.h>
#define LL long long
LL in() {
    char ch; LL x = 0, f = 1;
    while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
    for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
    return x * f;
}
const int mod = 1e9 + 7;
LL n, m, p, q, len;
struct Matrix {
    LL ju[222][222];
    Matrix() { memset(ju, 0, sizeof ju); }
    void e() {
        memset(ju, 0, sizeof ju);
        for(int i = 1; i <= len; i++) ju[i][i] = 1;
    }
    friend Matrix operator * (const Matrix &a, const Matrix &b) {
        Matrix c;
        for(int i = 1; i <= len; i++)
            for(int j = 1; j <= len; j++)
                for(int k = 1; k <= len; k++)
                    (c.ju[i][j] += a.ju[i][k] * b.ju[k][j] % mod) %= mod;
        return c;
    }
    Matrix ksm(LL y) {
        Matrix x = *this, re;
        re.e();
        while(y) {
            if(y & 1) re = re * x;
            x = x * x;
            y >>= 1;
        }
        return re;
    }
}beg, A;
LL fac[22], inv[22];
int ls[22];
struct node {
    int st[3], num;
    node(int a = 0, int b = 0, int c = 0, int d = 0): num(d) {
        st[0] = a, st[1] = b, st[2] = c;
    }
}st[105050];
LL ksm(LL x, LL y) {
    LL re = 1LL;
    while(y) {
        if(y & 1) re = re * x % mod;
        x = x * x % mod;
        y >>= 1;
    }
    return re;
}
LL C(int x, int y) {
    return fac[x] * inv[y] % mod * inv[x - y] % mod;
}
void dfs(int dep, int tot) {
    if(dep == p + 1) {
        if(tot) return;
        for(int i = 0; i <= q; i++) st[++len] = node(ls[1], ls[2], ls[3], i);
        return;
    }
    for(int i = tot; i >= 0; i--) ls[dep] = i, dfs(dep + 1, tot - i);
}
void predoit() {
    fac[0] = inv[0] = 1;
    for(int i = 1; i <= 20; i++) fac[i] = 1LL * i * fac[i - 1] % mod, inv[i] = ksm(fac[i], mod - 2);
}
void work(const node &a, const node &b, int x, int y) {
    int a1 = a.st[0], b1 = a.st[1], c1 = a.st[2], d1 = a.num;
    int a2 = b.st[0], b2 = b.st[1], c2 = b.st[2], d2 = b.num;
    if(d1 + 1 == d2) {
        if(a1 == b2 && b1 == c2 && !c1) return (void)(A.ju[y][x]++);
    } else if(d1 == d2) {
        if(a1 == b2 && b1 == c2 && !c1) return;
        if(a1 >= b2 && b1 >= c2) return (void)(A.ju[y][x] = C(a1, a1 - b2) * C(b1, b1 - c2) % mod);
    }
}
void Build_Matrix() {
    dfs(1, n);
#ifdef olinr
    for(int i = 1; i <= len; i++) printf("%d %d %d %d\n", st[i].st[0], st[i].st[1], st[i].st[2], st[i].num);
#endif
    for(int i = 1; i <= len; i++)
        for(int j = 1; j <= len; j++) 
            work(st[i], st[j], i, j);
    beg.ju[1][1] = 1;
}
void query() {
    beg = A.ksm(m) * beg;
    LL ans = 0;
    for(int i = 1; i <= len; i++) (ans += beg.ju[i][1]) %= mod;
    printf("%lld", ans);
}
int main() {
    freopen("b.in", "r", stdin);
    freopen("b.out", "w", stdout);
    n = in(), m = in(), p = in(), q = in();
    predoit();
    Build_Matrix();
    query();
    return 0;
}