CCF201409-5 拼图（100分）【插头DP+状态压缩】

试题编号： 201409-5
试题名称： 拼图
时间限制： 3.0s
内存限制： 256.0MB
问题描述：

问题描述
　　给出一个n×m的方格图，现在要用如下L型的积木拼到这个图中，使得方格图正好被拼满，请问总共有多少种拼法。其中，方格图的每一个方格正好能放积木中的一块。积木可以任意旋转。

　　
输入格式
　　输入的第一行包含两个整数n, m，表示方格图的大小。
输出格式
　　输出一行，表示可以放的方案数，由于方案数可能很多，所以请输出方案数除以1,000,000,007的余数。
样例输入
6 2
样例输出
4
样例说明
　　四种拼法如下图所示：

　　
评测用例规模与约定
　　在评测时将使用10个评测用例对你的程序进行评测。
　　评测用例1和2满足：1<=n<=30，m=2。
　　评测用例3和4满足：1<=n, m<=6。
　　评测用例5满足：1<=n<=100，1<=m<=6。
　　评测用例6和7满足：1<=n<=1000，1<=m<=6。
　　评测用例8、9和10满足：1<=n<=10^15，1<=m<=7。

问题链接：CCF201409-5 拼图
问题简述：（略）
问题分析：插头DP解法，参见参考链接。
程序说明：（略）
参考链接：
[ACM]CCF CSP [201409-5]E题 拼图
CCF CSP 201409-5 拼图
CCF201409-5拼图(状态压缩DP+矩阵快速幂) （骨牌覆盖问题拓展 ）
CCF201409-5 拼图（30分）
题记：（略）

100分的C++语言程序如下：

/* CCF201409-5 拼图 */

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
const int MOD = 1000000007;
const int M = 7;

// 矩阵快速幂
int c[1 << M][1 << M];
void mat_mul(int a[][1 << M], int b[][1 << M], int sz = 1 << M)
{
    memset(c, 0, sizeof c);
    for (int i = 0; i < sz; i++)
        for (int j = 0; j < sz; j++)
            for (int k = 0; k < sz; k++)
                c[i][j] = (c[i][j] + LL(a[i][k]) * b[k][j]) % MOD;
    for (int i = 0; i < sz; i++)
        for (int j = 0; j < sz; j++)
            a[i][j] = c[i][j];
}

LL n;
int m, a[1 << M][1 << M], ans[1 << M][1 << M];

inline int vacant(int s, int u)
{
    return u >= 0 && u < m && (s & (1 << u)) == 0;
}

int setadd(int s, int u1, int u2 = -1)
{
  s |= 1 << u1;
  if (u2 != -1) s |= 1 << u2;
  return s;
}

void search(int origin, int s1 ,int s2 = 0)
{
    if (s1 == (1 << m) - 1) a[origin][s2]++;
    else {
        for (int i = 0; i < m; i++)    //找到第一个没被占用的格子，然后继续搜索
            if (vacant(s1, i)) {          //格子i没有被占用
                //(1) 2 1(down)
                if (vacant(s1, i + 1) && vacant(s2, i + 1))
                    search(origin, setadd(s1, i, i + 1), setadd(s2, i + 1));
                //(2) 2 1(up)
                if (vacant(s1, i + 1) && vacant(s2, i))
                    search(origin, setadd(s1, i, i + 1), setadd(s2, i));
                //(3) 1 2(up)
                if (vacant(s2, i) && vacant(s2, i - 1))
                    search(origin, setadd(s1, i),setadd(s2, i - 1, i));
                //(4) 1 2(down)
                if (vacant(s2, i) && vacant(s2, i + 1))
                    search(origin, setadd(s1, i), setadd(s2, i, i + 1));
                break;
            }
    }
}

int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> n >> m;
    memset(a, 0, sizeof a);
    for (int S = 0; S < (1 << m); S++) search(S, S);

    // 矩阵初始化
    int sz = 1 << m;
    for (int i = 0; i < sz; i++)
        for (int j = 0; j < sz; j++)
            ans[i][j] = (i == j) ? 1 : 0;

    // 矩阵快速幂计算
    LL b = n - 1;
    while (b) {
        if (b & 1) mat_mul(ans, a);
        mat_mul(a, a);
        b >>= 1;
    }

    // 输出结果
    cout << ans[0][sz - 1] << endl;

    return 0;
}