蓝桥杯垒骰子java_蓝桥杯第六届javaA组 垒骰子（矩阵快速幂）

一、题目

垒骰子

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

for(int j=0;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

{

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

for(int j=0;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

{

for(int j=0;j

{

for(int k=0;k

{

ans.ma[i][j]+=(A.ma[i][k]*B.ma[k][j])%mod;

}

}

}

return ans;

}

}