第六屆藍橋 - 壘骰子(第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;
}