hihocoder第42周 3*N骨牌覆盖（状态dp+矩阵快速幂）

http://hihocoder.com/contest/hiho42/problem/1

给定一个n，问我们3*n的矩阵有多少种覆盖的方法

第41周做的骨牌覆盖是2*n的，状态转移方程是dp[i] = dp[i-1] + dp[i-2],递推数列可以用矩阵快速幂来加速计算

我们可以用状态dp来做这一题，如果某个格子上被铺了骨牌，就标记为1，否则为0

那么每一列一共有8个状态。

两种状态的表示法

第一种：

dp[i][s] 表示填满第i行后，第i+1行的状态为s，

那么s的转移情况如下，

0->1,4,7

1->0,6

2->5

3->4

4->0,3

5->2

6->1

7->0

那么就可以构造出转换的矩阵

int mat[8][8] = {
    { 0, 1, 0, 0, 1, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 1, 0 },
    { 0, 0, 0, 0, 0, 1, 0, 0 },
    { 0, 0, 0, 0, 1, 0, 0, 0 },
    { 1, 0, 0, 1, 0, 0, 0, 0 },
    { 0, 0, 1, 0, 0, 0, 0, 0 },
    { 0, 1, 0, 0, 0, 0, 0, 0 },
    { 1, 0, 0, 0, 0, 0, 0, 0 }
};

初始时，只有状态0存在，状态1,2,3,4,5,6,7都不存在

所以初始的向量为 A = [1,0,0,0,0,0,0,0,0]

转换n次后为，  A*mat^n

转化n次后，获得的是第i+1行的不同状态的个数，我们要的是第i+1行状态为0的个数，即A[0]

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <math.h>
using namespace std;
#pragma warning(disable:4996)
typedef long long LL;
const int INF = 1 << 30;
const int MOD = 12357;
/*

*/
int mat[8][8] = {
    { 0, 1, 0, 0, 1, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 1, 0 },
    { 0, 0, 0, 0, 0, 1, 0, 0 },
    { 0, 0, 0, 0, 1, 0, 0, 0 },
    { 1, 0, 0, 1, 0, 0, 0, 0 },
    { 0, 0, 1, 0, 0, 0, 0, 0 },
    { 0, 1, 0, 0, 0, 0, 0, 0 },
    { 1, 0, 0, 0, 0, 0, 0, 0 }
};
int mat2[8][8] = {
    { 1, 0, 0, 0, 0, 0, 0, 0 },
    { 0, 1, 0, 0, 0, 0, 0, 0 },
    { 0, 0, 1, 0, 0, 0, 0, 0 },
    { 0, 0, 0, 1, 0, 0, 0, 0 },
    { 0, 0, 0, 0, 1, 0, 0, 0 },
    { 0, 0, 0, 0, 0, 1, 0, 0 },
    { 0, 0, 0, 0, 0, 0, 1, 0 },
    { 0, 0, 0, 0, 0, 0, 0, 1 },
};
struct Matrix
{
    int mat[8][8];
    Matrix()
    {
        memset(mat, 0, sizeof(mat));
    }
};
Matrix operator*(const Matrix &lhs, const Matrix &rhs)
{
    Matrix ret;//零矩阵
    for (int i = 0; i < 8; ++i)
    {
        for (int j = 0; j < 8; ++j)
        {
            for (int k = 0; k < 8; ++k)
            {
                ret.mat[i][j] = (ret.mat[i][j] + lhs.mat[i][k] * rhs.mat[k][j]) % MOD;
            }
        }
    }

    return ret;
}
Matrix operator^(Matrix a, int n)
{
    Matrix ret;//单位矩阵
    for (int i = 0; i < 8; ++i)
    {
        for (int j = 0; j < 8; ++j)
            ret.mat[i][j] = mat2[i][j];
    }
    while (n)
    {
        if (n & 1)
        {
            ret = ret * a;
        }
        n >>= 1;
        a = a * a;
    }
    return ret;
}

int main()
{
    int n;
    while (scanf("%d", &n) != EOF)
    {        
        
        Matrix  a;
        for (int i = 0; i < 8; ++i)
        {
            for (int j = 0; j < 8; ++j)
                a.mat[i][j] = mat[i][j];
        }
        a = a^n;
        cout << a.mat[0][0] << endl;

    }
    return 0;
}

第二种转换方法为：

dp[i][s]表示填满第i-1行时，第i行的状态为s

同样的，可以得到转化的矩阵， 其实，两种转化的方法就是转化矩阵的不同

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <math.h>
using namespace std;
#pragma warning(disable:4996)
typedef long long LL;                   
const int INF = 1<<30;
const int MOD = 12357;
/*

*/
int mat[8][8] = { 
        { 0, 0, 0, 0, 0, 0, 0, 1 },
        { 0, 0, 0, 0, 0, 0, 1, 0 },
        { 0, 0, 0, 0, 0, 1, 0, 0 },
        { 0, 0, 0, 0, 1, 0, 0, 1 },
        { 0, 0, 0, 1, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 1, 0, 0, 1, 0 }
};
int mat2[8][8] = {
        { 1, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 0, 1, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 1, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 1, 0, 0 },
        { 0, 0, 0, 0, 0, 0, 1, 0 },
        { 0, 0, 0, 0, 0, 0, 0, 1 },
};
struct Matrix
{
    int mat[8][8];
    Matrix()
    {
        memset(mat, 0, sizeof(mat));
    }
};
Matrix operator*(const Matrix &lhs, const Matrix &rhs)
{
    Matrix ret;//零矩阵
    for (int i = 0; i < 8; ++i)
    {
        for (int j = 0; j < 8; ++j)
        {
            for (int k = 0; k < 8; ++k)
            {
                ret.mat[i][j] = (ret.mat[i][j] + lhs.mat[i][k] * rhs.mat[k][j]) % MOD;
            }
        }
    }

    return ret;
}
Matrix operator^(Matrix a, int n)
{
    Matrix ret;//单位矩阵
    for (int i = 0; i < 8; ++i)
    {
        for (int j = 0; j < 8; ++j)
            ret.mat[i][j] = mat2[i][j];
    }
    while (n)
    {
        if (n & 1)
        {
            ret = ret * a;
        }
        n >>= 1;
        a = a * a;
    }
    return ret;
}

int main()
{
    int n;
    while (scanf("%d", &n) != EOF)
    {
        n += 2;
        Matrix  a;
        for (int i = 0; i < 8; ++i)
        {
            for (int j = 0; j < 8; ++j)
                a.mat[i][j] = mat[i][j];
        }
        a = a^n;
        cout << a.mat[7][7] << endl;

    }
    return 0;
}