POJ 3420 Quad Tiling 状压DP+递推+矩阵快速幂

Quad Tiling

题解：首先根据题目数据量来看，肯定是必须有递推公式的了或者滚动数组什么的。

因此我们考虑递推情况，对于$4\cdot n$，最后一列的放置情况。

1. 如果是$4$个$[1\cdot 2]$排列，那么$dp[n]=dp[n-2]$。
2. 如果是$2$个$[2\cdot 1]$排列，那么$dp[n]=dp[n-1]$。
3. 如果是$1$个$[1\cdot 2]$+$1$个$[2\cdot 1]$ + $1$个$[1\cdot 2]$排列，那么$dp[n]=dp[n-2]+dp[n-4]+.....+dp[0]$
4. 如果是$2$个$[1\cdot 2]$+$1$个$[2\cdot 1]$ 或者$1$个$[2\cdot 1]$+$2$个$[1\cdot 2]$，那么$dp[n]=dp[n-2]+dp[n-3]+dp[n-4]+....+dp[0]$。

因此有$dp[n]=dp[n-1]+dp[n-2]+2\cdot (dp[n-2]+dp[n-3]+..dp[0])+dp[n-2]+dp[n-4]+...dp[0]$，但是发现此时式子还是比较复杂，无法用矩阵，但是当减去$dp[n-2]$后，就会发现$dp[n]=dp[n-1]+5\cdot dp[n-2]+dp[n-3]-dp[n-4]$。此时套用矩阵快速幂即可。

代码

#include<iostream>
#include<cstring>
typedef long long LL;
using namespace std;
const int NUM = 4,MAXN = 4;
int mod, dp[4] = {1,1,5,11};
struct Matrix//矩阵的类
{
    LL a[NUM][NUM];
    Matrix() {}
    Matrix(LL *t)
    {
        int k = 0;
        for(int i = 0; i < NUM; ++i)
            for(int j = 0; j < NUM; ++j)
                a[i][j] = t[k++];
    }
    void init()           //将其初始化为单位矩阵
    {
        memset(a, 0, sizeof(a));
        for (int i = 0; i < MAXN; i++)
            a[i][i] = 1;
    }
};

Matrix mul(Matrix A,Matrix B)  //(a*b)%mod  矩阵乘法
{
    Matrix ans;
    for (int i = 0; i < MAXN; i++)
        for (int j = 0; j < MAXN; j++) {
            ans.a[i][j] = 0;
            for (int k = 0; k < MAXN; k++)
                ans.a[i][j] = (ans.a[i][j] + A.a[i][k] * B.a[k][j] + mod) % mod;
        }
    return ans;
}

LL solve(int n)
{
    LL t[16] = {1,5,1,-1,1,0,0,0,0,1,0,0,0,0,1,0};
    Matrix ans, A(t);
    ans.init();
    while(n > 0) {
        if(n & 1) ans = mul(ans,A);
        A = mul(A,A);
        n >>= 1;
    }
    LL ret = 0;
    for(int i = 0; i < 4; ++i)
        ret = (ret + ans.a[0][3 - i] * dp[i]) % mod;
    return ret;
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("input.in","r",stdin);
#endif
    int n;
    //  [1 5 1 -1] ^ (n - 3) [1 ] =  [dp[n]    ] dp[n - 1]
    //  [1 0 0  0]			 [1 ]    [dp[n - 1]] dp[n - 2]
    //  [0 1 0  0]			 [5 ]    [dp[n - 2]] dp[n - 3]
    //  [0 0 1  0]			 [11]    [dp[n - 3]] dp[n - 4]
    //  dp[n] = dp[n - 1] + 5 * dp[n - 2] + dp[n - 3] + dp[n - 4];
    //  dp[n - 1] = dp[n - 1]
    //  dp[n - 2] = dp[n - 2]
    //  dp[n - 3] = dp[n - 3]
    while(cin >> n >> mod && (mod + n)) {
        if(n < 4) {
            cout << dp[n] % mod << endl;
        }else{
            cout << solve(n - 3) << endl;
        }
    }

    return 0;
}