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

上周的3*N的骨牌，因为状态只有8中，所以我们可以手算出状态转移的矩阵

但是这周是k*N，状态矩阵不好手算，都是我们改成用程序自动生成一个状态转移的矩阵就行了，然后用这个矩阵进行快速幂即可

枚举枚举上下两行的状态，然后判断上一行的状态能不能转移为这一行的状态

如果上一行的某个位置为0，那么这一行的该位置必须为1

如果上一行的某个位置为1，那么这一行的该位置可以为0

如果上一行的某个位置为1，且这一行的该位置为1， 那么上下两行该位置相邻的位置也得为1

根据这三条规则判断状态能不能转移成功，然后生成矩阵

因为状态矩阵很大，不能够开成局部变量，所以一律开成全局的，函数的返回值全部改成void

#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;
const int N = 1 << 8;
int n, k;
struct Matrix
{
    int mat[N][N];
    void makeUnit()
    {
        int m = (1 << k);
        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < m; ++j)
                mat[i][j] = (i == j);
        }
    }
    void makeZero()
    {
        int m = 1 << k;
        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < m; ++j)
                mat[i][j] = 0;
        }
    }
}a, ret1, ret2;
void copy(Matrix &des, const Matrix &s)
{
    int m = 1 << k;
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < m; ++j)
            des.mat[i][j] = s.mat[i][j];
    }
}
void dfs(int x, int y, int col)//这个题目提示的矩阵生成方法，挺厉害的
{
    if (col == k)
    {
        a.mat[y][x] = 1;
        return;
    }
    dfs(x << 1, y << 1 | 1, col + 1);
    dfs(x << 1 | 1, y << 1, col + 1);
    if (col + 2 <= k)
        dfs((x << 2) + 3, (y << 2) + 3, col + 2);
}
void multiply(const Matrix &lhs, const Matrix &rhs)
{
    ret2.makeZero();
    int m = 1 << k;
    for (int z = 0; z < m; ++z)
    {
        for (int i = 0; i < m; ++i)
        {
            if (lhs.mat[i][z] == 0) continue;
            for (int j = 0; j < m; ++j)
            {
                ret2.mat[i][j] += lhs.mat[i][z] * rhs.mat[z][j];
                if (ret2.mat[i][j] >= MOD)
                    ret2.mat[i][j] %= MOD;
            }
        }
    }
}
void pow(Matrix a, int t)
{
    ret1.makeUnit();
    while (t)
    {
        if (t & 1)
        {
            multiply(ret1, a);
            copy(ret1, ret2);
        }
        t >>= 1;
        multiply(a, a);
        copy(a, ret2);
    }
}
bool check(int x, int y)
{
    int m = 1 << k-1;
    while (m)
    {
        if ((x & 1) == 0 && (y & 1) == 1)
        {
            x >>= 1;
            y >>= 1;
            m >>= 1;
        }
        else if ((x & 1) == 1 && (y & 1) == 0)
        {
            x >>= 1;
            y >>= 1;
            m >>= 1;
        }
        else if ((x & 1) == 1 && (y & 1) == 1)
        {
            x >>= 1;
            y >>= 1;
            if ((x & 1) == 1 && (y & 1) == 1)
            {
                x >>= 1;
                y >>= 1;
                m >>= 2;
            }
            else
                return false;
        }
        else
            return false;
    }
    return true;
}
void makeMatrix()
{
    int m = 1 << k;
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < m; ++j)
        {
            if (check(i, j))
                a.mat[i][j] = 1;
        }
    }
}
int main()
{
    scanf("%d%d", &k, &n);
    a.makeZero();
    //dfs(0, 0, 0);
    makeMatrix();
    pow(a, n);
    int m = (1 << k) - 1;
    printf("%d\n", ret1.mat[m][m]);
    return 0;
}