骨牌覆盖

// 骨牌覆盖.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//


/*
http://oj.daimayuan.top/course/22/problem/1047

题目描述
给定一个 n×m 的棋盘，你需要用 1×2的多米诺骨牌去覆盖整个棋盘，
请求出有多少种不同的覆盖方案。由于答案可能很大，请输出答案模 109+7。

输入格式
第一行两个整数 n,m。

输出格式
一行一个数表示答案模 10^9+7
 的结果。

样例输入
2 3
样例输出
3
数据范围 
对于 100% 的数据，保证 1≤n≤109,1≤m≤5。
*/


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 31;
const int P = 1000000007;
int n, m;
int k;
long long f[N+1],a[N + 1][N + 1];

inline void aa() {
	long long w[N + 1][N + 1];
	memset(w, 0, sizeof w);
	for (int i = 0; i < n; i++) {
		for (int k = 0; k < n; k++) {
			if (a[i][k]) {
				for (int j = 0; j < n; j++) {
					if (a[k][i])
						w[i][j] += a[i][k] * a[k][j], w[i][j] %= P;
				}
			}

		}
	}

	memcpy(a, w, sizeof a);
}

inline void fa() {
	long long  w[N + 1];
	memset(w, 0, sizeof w);
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			w[i] += f[j] * a[j][i], w[i] %= P;
		}
	}

	memcpy(f, w, sizeof f);
}

inline void matrixpow(long long k) {
	for (; k; k >>= 1) {
		if (k & 1)
			fa();
		aa();
	}
}

void dfs(int init,int cur,int tar,int x) {
	if (x == m) {
		a[init][tar] = 1;
		return;
	}

	if (cur & (1 << x))
		dfs(init, cur, tar, x + 1);
	else {
		dfs(init, cur + (1 << x), tar + (1 << x), x + 1);
		if (x + 1 < m && !(cur & (1 << (x + 1))) ) {
			dfs(init, cur + (1 << x) + (1 << (x + 1)), tar, x + 1);
		}
	}


}

int main()
{
	scanf("%d%d",&k,&m);
	n = 1 << m;

	for (int i = 0; i < n; i++)
		dfs(i, i, 0, 0);

	f[0] = 1;
	matrixpow(k);
	printf("%lld\n",f[0]);

	return 0;
}

// 907 骨牌覆盖.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
/*
http://oj.daimayuan.top/course/22/problem/1047

给定一个 n×m的棋盘，你需要用 1×2的多米诺骨牌去覆盖整个棋盘，请求出有多少种不同的覆盖方案。
由于答案可能很大，请输出答案模 109+7。

输入格式
第一行两个整数 n,m。

输出格式
一行一个数表示答案模 109+7的结果。

样例输入
2 3
样例输出
3 
数据范围
对于 100%的数据，保证 1≤n≤109,1≤m≤5。
*/

#include <iostream>
#include <cstring>


using  namespace std;

const int  N = 5;
long long  a[1 << N][1 << N];
long long  f[1 << N];
const int MOD = 1000000007;
int n, m;


bool check(int st) {
	//连续的0 必须是双数
	int flag = 0; int cnt = 0;
	for (int i = 0; i < m; i++) {
		if ((st >> i) & 1) {
			if (flag == 1 && cnt % 2) return false;
			else {
				cnt = 0; flag = 0;
			}
		}
		else if (flag == 0) {
			flag = 1; cnt++;
		}
		else if (flag == 1) {
			cnt++;
		}
	}

	if (flag == 1 && cnt % 2) return false;
	return true;
}

void init() {
	for (int i = 0; i < 1 << m; i++) {
		if (check(i)) {
			f[i] = 1;
		}
		for (int j = 0; j < 1 << m; j++) {
			if ((i & j) == 0 && check(i | j)) {
				a[i][j] = 1; a[j][i] = 1;
			}
		}
	}
}


void fa() {
	long long w[1<<N];
	memset(w, 0, sizeof w);
	for (int i = 0; i < 1 << m; i++) {
		for (int j = 0; j < 1 << m; j++) {
			w[i] += f[j] * a[j][i];
			w[i] %= MOD;
		}
	}
	memcpy(f, w, sizeof w);
}


void aa() {
	long long w[1 << N][1 << N];
	memset(w, 0, sizeof w);
	for (int i = 0; i < 1 << m; i++) {
		for (int j = 0; j < 1 << m; j++) {
			for (int k = 0; k < 1 << m; k++) {
				w[i][j] += a[i][k] * a[k][j];
				w[i][j] %= MOD;
			}
		}
	}

	memcpy(a, w, sizeof w);
}

void matrixpow(int k) {
	while (k) {
		if (k & 1)
			fa();
		aa();
		k >>= 1;
	}
}


int main()
{
	cin >> n >> m;
	init();
	
	matrixpow(n - 1);

	cout << f[0] << endl;

	return 0;
}