一、题目
垒骰子
赌圣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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
二、分析
这种求方案数量的题目，第一反应就是深搜，但是看了以下数据规模，用深搜应该只能通过不到30%的数据，后来看了以下网上的方法，学习到了使用矩阵快速幂可以方便求解。
1.矩阵快速幂
先了解以下快速幂，假如我们要求x^21 的值，普通方法直接xxxxxx…x，这样做了20次乘法。如果使用快速幂方法，21=16+4+1 ， x^21 =x^16 * x^4 * x。 我们可以先算x^2 ,再算 x^4 ,再算 x^8 ，再算x^16 ，这样一共做了3次乘法 ，再将x^21 算出来需要再做3次乘法，总共6次乘法，相比于直接运算节省了不少时间。
快速幂代码：
private static int pow(int x,int n) //求x的n次幂
{
int ans = 1;
int pos = x;
while(n!=0)
{
if((1&n)==1)
{
ans = ans * pos;
}
pos = pos*pos;
n >>=1;
}
return ans;
}
对于矩阵快速幂，只需要把初始的ans=1换成单位矩阵即可，代码如下：
private static Matrix pow(Matrix T,int n) //求矩阵T(方阵)的n次幂
{
Matrix ans = new Matrix(T.m,T.m);
for(int i=0;i<T.m;i++)
for(int j=0;j<T.m;j++)
{
if(i==j)
ans.ma[i][j]=1;
else ans.ma[i][j]=0;
} //建立一个单位阵
while(n!=0)
{
if((1&n)==1)
{
ans = mul(ans,T);
}
T = mul(T,T);
n >>=1;
}
return ans;
}
矩阵快速幂一般可以用于求矩阵的等比递推式，对于这个题，我们首先需要从题目分析出递推关系。
显然，在垒骰子的过程中，前n个的骰子的垒法是和前n-1个骰子的垒法密切相关的，且和第n-1的骰子朝上面的数字也相关的，这样我们可以得到一个二维的状态转移方程，设d[i][j]表示第i个骰子j面朝上的垒法，则d[i][j]=d[i-1][1]+d[i-1][2]+…+d[i-1][6].
且d[1][j]=1+1+1+1+1+1.可以用一个列向量矩阵Ai来表示d.
现在考虑面的互斥问题，某些面之间是不能贴在一起放的，同样可以用一个66的矩阵T来表示这个互斥关系,Tij表示第i面和第j面互斥。于是可以得到矩阵递推关系，A2=TA1 ， A3=TA2 , … ,An=TAn-1
所以An = T^n-1 * A1 ，利用矩阵快速幂求出T^n-1 即可。
最后，题目说了，两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同，每一个筛子在确定了朝上面后，可以旋转4次，有4种放法，那么总的方法就要乘上一个4^n。
三、代码
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
class Matrix{ //n行m列矩阵
int n;
int m;
int[][] ma;
public Matrix(int n,int m)
{
this.n=n;
this.m=m;
ma = new int[n][m];
}
}
public class Main {
static double mod = Math.pow(10, 9)-7; //取余数
static int count = 0;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n,m;
n=in.nextInt();
m=in.nextInt();
Matrix T = new Matrix(6,6); //T为骰子面的互斥情况，T[i][j]=0表示i,j面互斥
for(int i=0;i<6;i++)
for(int j=0;j<6;j++)
T.ma[i][j]=1; //初始化T
for(int i=0;i<m;i++)
{
int a,b;
a=in.nextInt();
b=in.nextInt();
T.ma[a-1][b-1]=0;
T.ma[b-1][a-1]=0;
}
Matrix Tn1 = pow(T,n-1);
Matrix A1 = new Matrix(6,1);
for(int i=0;i<6;i++)
A1.ma[i][0]=1; //初始化A0;
Matrix An = mul(Tn1,A1);
for(int i=0;i<6;i++)
count+=(An.ma[i][0]%mod);
count*=Math.pow(4, n)%mod;
System.out.print(count);
}
private static Matrix pow(Matrix T,int n) //求矩阵T(方阵)的n次幂
{
Matrix ans = new Matrix(T.m,T.m);
for(int i=0;i<T.m;i++)
for(int j=0;j<T.m;j++)
{
if(i==j)
ans.ma[i][j]=1;
else ans.ma[i][j]=0;
} //建立一个单位阵
while(n!=0)
{
if((1&n)==1)
{
ans = mul(ans,T);
}
T = mul(T,T);
n >>=1;
}
return ans;
}
private static Matrix mul(Matrix A,Matrix B) //矩阵乘法，AB必须可相乘
{
Matrix ans = new Matrix(A.n,B.m);
for(int i=0;i<A.n;i++)
{
for(int j=0;j<B.m;j++)
{
for(int k=0;k<A.m;k++)
{
ans.ma[i][j]+=(A.ma[i][k]*B.ma[k][j])%mod;
}
}
}
return ans;
}
}