蓝桥杯第六届省赛B组———垒骰子

题目

赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。
经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！
我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。
假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。
atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
由于方案数可能过多，请输出模 10^9 + 7 的结果。

不要小看了 atm 的骰子数量哦～

「输入格式」
第一行两个整数 n m
n表示骰子数目
接下来 m 行，每行两个整数 a b ，表示 a 和 b 数字不能紧贴在一起。

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

「样例输入」
2 1
1 2

「样例输出」
544

「数据范围」
对于 30% 的数据：n <= 5
对于 60% 的数据：n <= 100
对于 100% 的数据：0 < n <= 10^9, m <= 36

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 2000ms

思路

这一题是我根据蓝桥杯邓未老师的题解写出来的， 最简单的思路是用动态规划（用二维数组，表示当前骰子这一面朝上有多少种），但是不能得满分，正确思路是用矩阵，这里面涉及的知识有矩阵的乘法、矩阵的快速幂。

首先定义一个 a[6][6] 大小的冲突矩阵，a[i][j] 表示当前骰子 i 朝上， 上一个骰子 j 朝上是否冲突， 如果冲突则为 0，否则为 1（这是最开始的冲突矩阵）

假设冲突矩阵为 T ，fn 表示 n 个骰子有多少种情况， 那么 f2 = T * f1， f3 = T * f2，所以 fn = f1 * （T^(n - 1))。

当然最后还要乘以 4 的 n 次方

代码

#include <iostream>
using namespace std;
typedef long long LL;
const int mod = 1000000007;
int op[7];
struct M {
	LL a[6][6];
	M(){
		for (int i = 0; i < 6; i++) {
			for (int j = 0; j < 6; j++) {
				a[i][j] = 1;
			}
		}
	}
};
void init()
{
	op[1] = 4;
	op[2] = 5;
	op[3] = 6;
	op[4] = 1;
	op[5] = 2;
	op[6] = 3;
}
M Multiply(M m, M n)//矩阵乘法
{
	M ans;
	for (int i = 0; i < 6; i++) {
		for (int j = 0; j < 6; j++) {
			ans.a[i][j] = 0;//因为ans.a被构造函数初始化为1，所以要赋值为0
			for (int k = 0; k < 6; k++) {
				ans.a[i][j] = (ans.a[i][j] + m.a[i][k] * n.a[k][j]) % mod;
			} 
		}
	}
	return ans;
}
M mpow(M base, int p) //矩阵快速幂
{
	M ans;
	for (int i = 0; i < 6; i++) {
		for (int j = 0; j < 6; j++) {
			if (i != j) ans.a[i][j] = 0;
		}
	}
	while (p > 0) {
		if (p & 1) ans = Multiply(ans, base);
		p >>= 1;
		base = Multiply(base, base);
	}
	return ans;
}
int main()
{
	init();
	M m1;
	int n, m;
	cin >> n >> m;
	for (int i = 0; i < m; i++) {
		int a, b;
		cin >> a >> b;
		m1.a[op[a] - 1][b - 1] = 0;//表示a的背面朝上时，上一个骰子朝上的不能是b 
		m1.a[op[b] - 1][a - 1] = 0;
	}
	M ans = mpow(m1, n - 1); 
	LL sum = 0;
	for (int i = 0; i < 6; i++) {
		for (int j = 0; j < 6; j++) {
			sum = (sum + ans.a[i][j]) % mod;
		}
	}
	LL base = 4;
	LL p = n;
	LL res = 1;
	while (p > 0) {
		if (p & 1) res = (res * base) % mod;
		p >>= 1;
		base = (base * base) % mod;
	}
	cout << (sum * res) % mod << endl;
	return 0;
}