第六届蓝桥 - 垒骰子(第9题) 动态规划 到 矩阵快速幂

题目描述：

赌圣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

---

分析

• 方案一: 动态规划

         第 i 个骰子向上面为 k 的方案数, 等于 第i-1个骰子向下面不与k冲突的骰子数的方案和, DP 转移方程如下:

$dp(i, k) = \sum_{j = 1}^{6}dp(i - 1, j), k的对面不与j 冲突$

        三个骰子, 且规定 1与 2 不对面的动态规划过程如下图 :

面临的问题:

        骰子数量可以达到1e9, 动态规划的迭代会造成超时, 因此需要想办法让这个次数变少到logn即可解决超时问题, 因此可以考虑矩阵快速幂。

• 方案二: 矩阵快速幂

        由上图看出第一枚骰子6种向上面的种类次数经过一次操作即可得到选择第个二骰子时的各种情况的方案数, 依次类推, 并且此操作重复相同的。我们将第i枚骰子算出来的情况看成一个6X1的列向量, 将操作看成此列向量与一个矩阵M的乘法(等会儿再讲为什么要这个矩阵), 则如下图, 计算过程:

转换成矩阵乘法有什么好处呢?

        那好处就大大的啦, 动态规划当中的迭代必须老老实实迭代n次, 而如果这个迭代当中的操作就是为了进行乘法呢? 是不是想到了快速幂, 如果我算k的n次方, 我用迭代的话就要算n次, 如果我用快速幂就能logn次解决这个问题啦, 整数的n次方使用快速幂, 那么矩阵的n次方呢? 这就是矩阵快速幂啦。

那个矩阵是干啥玩意儿的?

        当前骰子k的i面向上的方案数能不能从k-1骰子j 面向上当中获取方案数就看M[i][j]啦, 这也是为什么矩阵当中元素是0或1(不就是能不能选的问题嘛), 比如我们的举例中, 第二个骰子当1面向上的时候, 他是不能从第一个骰子向上面为5 时哪里获得方案数的, 因此M[1][5] = 0。这样懂了嘛。

---

实现

• 动态规划

        这题使用动态规划要用滚动数组, [1e9][6] 的数组是绝对开不出来的。

#include <bits/stdc++.h>
using namespace std;
const int MODE = 1e9 + 7;
int dp[2][7] = {{1, 1, 1, 1, 1, 1, 1}, {0, 0, 0, 0, 0, 0, 0}};
int down[7] = {0, 4, 5, 6, 1, 2, 3};
bool comflict[7][7];

int quick(int a, int b)
{
	int ans = 1;
	while(b) 
    {
		if(b & 1) ans = (ans * a) % MODE;  
		b >>= 1;
		a = (a * a) % MODE;
	}
	return ans;
}

int main() 
{
#ifdef LOCAL
	freopen("I.in.cpp", "r", stdin);
#endif
	// 输入初始化 
	int n, m, x, y; cin >> n >> m;
	while(m--) 
    {
		cin >> x >> y;
		comflict[x][y] = true;
		comflict[y][x] = true;
	}
	
	// dp
	for(int i = 2; i <= n; ++i) 
    {
		int pre = i % 2, cur = (i + 1) % 2; 
		memset(dp[cur], 0, sizeof(dp[cur]));
		for(int j = 1; j <= 6; ++j) 
        {
			for(int k = 1; k <= 6; ++k) 
            {
				if(!comflict[j][down[k]])
 					dp[cur][j] = (dp[pre][k] + dp[cur][j]) % MODE;
 			 }
		}
	}
	
	// 输出结果
	int dpret = 0;
	for(int i = 1; i <= 6; ++i) dpret = (dpret + dp[(n + 1) % 2][i]) % MODE;
	int qret = quick(4, n);
	cout << (dpret * qret) % MODE << endl;
	return 0;
}

• 矩阵快速幂

#include <bits/stdc++.h>
using namespace std;

const int MODE = 1e9 + 7; 
int down[7] = {0, 4, 5, 6, 1, 2, 3};
int col_vec[7] = {1, 1, 1, 1, 1, 1, 1};
int ret_vec[7];

typedef struct Matrix
{
	int M[7][7];
	Matrix() 
	{
		memset(M, 0, sizeof(M));	
	}	
}M;

void init(Matrix &m) 
{
	for(int i = 1; i <= 6; ++i)
	for(int j = 1; j <= 6; ++j)
		m.M[i][j] = 1;		
}

// 矩阵乘法 
M matrix_mutiply(const Matrix &lhs, const Matrix &rhs)
{
	M ret;
	for(int i = 1; i <= 6; ++i)
	{
		for(int j = 1; j <= 6; ++j)
		{
			for(int k = 1; k <= 6; ++k)
			{
				ret.M[i][j]  = (ret.M[i][j] + lhs.M[i][k] * rhs.M[k][j]) % MODE;	
			}
		}
	}
	return ret;
}

// 快速幂 
int quick(int a, int b)
{
	int ans = 1;
	while(b) {
		if(b & 1) ans = (ans * a) % MODE;  
		b >>= 1;
		a = (a * a) % MODE;
	}
	return ans;
}

// 矩阵快速幂 
M matrix_quick(M m, int k)
{
	
	M ret;
	
	// 初始化为单位矩阵 
	for(int i = 1; i <= 6; ++i)
	for(int j = 1; j <= 6; ++j)
		if(i == j) ret.M[i][j] = 1;
		else ret.M[i][j] = 0;
	
	while(k)
	{
		if(k & 1) ret = matrix_mutiply(ret, m);
		k >>= 1;
		m = matrix_mutiply(m, m);
	}
	return ret;
}

int get_ans(int n, M m)
{
	int ans = 0;
	
	// 先算初始矩阵的 n - 1 次幂
	M ret = matrix_quick(m, n - 1);
	
	// 列向量 X ret
	for(int i = 1; i <= 6; ++i)
	{
		for(int j = 1; j <= 6; ++j)
		{
			ret_vec[i]  = (ret_vec[i] + col_vec[i] * ret.M[i][j]) % MODE;
		}	
		ans = (ans + ret_vec[i]) % MODE;
	} 
	
	int t = quick(4, n);
	ans = (ans * t) % MODE;
	return ans;
}

int main() 
{
#ifdef LOCAL
	freopen("I.in.cpp", "r", stdin);
#endif
	int n, m, x, y; cin >> n >> m;
	M mm;
	init(mm);
	
	while(m--)
	{
		cin >> 	x >> y;
		mm.M[x][down[y]] = 0;
		mm.M[y][down[x]] = 0;
	}

	int ans = get_ans(n, mm);
	cout << ans << endl;
	return 0;
}