NC17890 方格填色

题目链接

题目

题目描述

给一个m x n的方格，Applese想要给方格填上颜色，每个格子可以是黑色或者白色。他要求左右相邻两格不能同为白色且相邻两列不能全为黑色。

求满足条件的方案数。

输入描述

输入两个整数m, n。$(1 ≤ m ≤ 5, 1 ≤ n ≤ 10^{18})$。

输出描述

输出答案对 $10^9 + 7$ 取模的结果。

**示例1 **

输入

3 1

输出

8

示例2

输入

3 5

输出

1640

示例3

输入

5 5

输出

351032

题解

知识点：状压dp，运算优化。

注意到可以一列一列摆，设 $0$ 代表黑色，$1$ 代表白色，这样比反过来方便。设第 $i$ 列状态为 $st1$ ，第 $i-1$ 列状态为 $st2$ ，于是首先 $st1$ 和 $st2$ 自己都要满足 st & (st<<1) 不能为 $1$ ，即相邻不为白色，随后 st1 & st2 必须大于 $0$ ，即两列不能都为黑色。设 $dp[i][st]$ 表示摆到第 $i$ 列，状态 $st$ 时的方案数，有转移方程：

$$dp[i][st1] = \sum dp[i-1][st2]$$

注意到 $n$ 十分的大，考虑优化。发现转移方程只和这一列的 $st1$ 和上一列的 $st2$ 有关，并且对于一组 $(st1,st2)$ 能否转移是不随 $i$ 变化的，因此我们可以预先确定每一组 $(st1,st2)$ 是否可以从 $st2$ 转移到 $st1$。显然，用矩阵快速幂，可以解决这个问题了。假设 $f(i,j)$ ，表示状态 $(i,j)$ 是否可以转移，用 $01$ 表示，于是 $f(i,j) = !(i \& j) \and (i | j)$。矩阵构造如下：

$$\left ( \begin{array}{c} dp[n][0]\\ dp[n][1]\\ \vdots\\ dp[n][2^m-1] \end{array} \right) = \left ( \begin{array}{c} f(0,0) & f(1,0) & \cdots & f(2^m-1,0)\\ f(0,1) & f(1,1) & \cdots & f(2^m-1,1)\\ \vdots & \vdots & \ddots & \vdots\\ f(0,2^m-1) & f(1,2^m-1) & \cdots & f(2^m-1,2^m-1) \end{array} \right) ^{n-1} \left ( \begin{array}{c} dp[1][0]\\ dp[1][1]\\ \vdots\\ dp[1][2^m-1] \end{array} \right)$$

时间复杂度 $O(8^m \log n)$

空间复杂度 $O(4^m)$

代码

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
const int mod = 1e9 + 7;
 
///矩阵快速幂取余，O(n^3logk)
struct Matrix {
 
    int n, m;//不能const，快速幂要复制
    vector<vector<ll>> mat;
 
    explicit Matrix(int _n) :n(_n), m(_n), mat(_n + 1, vector<ll>(_n + 1)) {
        for (int i = 1;i <= n;i++)
            for (int j = 1;j <= m;j++)
                mat[i][j] = i == j;
    }//初始化n阶单位矩阵，explicit防止误用类型转换
 
    Matrix(int _n, int _m) :n(_n), m(_m), mat(_n + 1, vector<ll>(_m + 1)) {}//初始化nxm零矩阵
 
    friend Matrix operator*(const Matrix &A, const Matrix &B) {
        Matrix ans(A.n, B.m);
        if (A.m != B.n) return ans;
        for (int i = 1;i <= A.n;i++)
            for (int j = 1;j <= B.m;j++)
                for (int k = 1;k <= A.m;k++) //a.m == b.n
                    ans.mat[i][j] = (ans.mat[i][j] + A.mat[i][k] * B.mat[k][j]) % mod;
        return ans;
    }//矩阵乘法取余
 
    friend Matrix operator^(Matrix A, ll k) {
        Matrix ans(A.n);//A必须是方阵
        while (k) {
            if (k & 1) ans = ans * A;
            k >>= 1;
            A = A * A;
        }
        return ans;
    }//快速幂取余
 
    void output() const {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++)
                cout << mat[i][j] << ' ';
            cout << '\n';
        }
        cout << '\n';
    }//输出检测
};
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    ll m, n;
    cin >> m >> n;
    Matrix init(1 << m, 1);
    for (int i = 1;i <= (1 << m);i++)
        init.mat[i][1] = 1;
    Matrix feat(1 << m, 1 << m);
    for (int i = 0;i < (1 << m);i++)
        for (int j = 0;j < (1 << m);j++)
            feat.mat[i + 1][j + 1] = !(i & j) && (i | j);
    Matrix res = (feat ^ (n - 1)) * init;
    int ans = 0;
    for (int i = 1;i <= (1 << m);i++) ans = (ans + res.mat[i][1]) % mod;
    cout << ans << '\n';
    return 0;
}