蓝桥杯 15省赛 C10 垒骰子(dp数组)
垒骰子
赌圣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
=========================
思路:
经典动态规划,马上想到dp数组
总结:
向热心大佬学习了一波 快速幂
public class Main{
static int n;
static BigInteger MOD =new BigInteger(1000000007 +"");
static BigInteger[][] dp =new BigInteger[2][7];
static boolean[][] a =new boolean[7][7];
public static void main(String[] args) {
init();
//初始第一层🎲
for(int i =1 ;i <=6 ;i ++) dp[0][i] =BigInteger.ONE;
int lev =0; //dp滚动数组滚动层指针
for(int i =2 ;i <=n ;i ++) { //遍历2-n层🎲
lev =1 -lev; //切换到另一层
for(int j =1 ;j <=6 ;j ++) { //遍历第一层骰子
dp[lev][j] =BigInteger.ZERO;
for(int k =1 ;k <=6 ;k ++) { //遍历第二层骰子
if(a[j][k]) continue;
dp[lev][j] =dp[lev][j].add(dp[1 -lev][k].mod(MOD));
}
}
}
for(int i =2 ;i <=6 ;i ++) dp[lev][1] =dp[lev][1].add(dp[lev][i]).mod(MOD);
System.out.println(dp[lev][1].multiply(quickPow(4 ,n)).mod(MOD));
}
//快速幂
private static BigInteger quickPow(int base ,int pow) {
BigInteger quan =new BigInteger(base +""); //当前权值
BigInteger val =BigInteger.ONE;
while(true) {
if(pow ==0) break;
if((pow &1) ==1) val =val.multiply(quan).mod(MOD); //pow的二进制最后一位是否为'1'->为'1'则值乘上当前权值的当前幂
quan =quan.multiply(quan).mod(MOD); //权值进位(幂的二进制+1=>权值平方)
pow >>=1; //幂做二进制右移=>移除其二进制末尾一位
}
return val;
}
private static void init() {
Scanner sc = new Scanner(System.in);
n =sc.nextInt();
int m =sc.nextInt();
int t1 =0 ,t2 =0;
for(int i =0 ;i <m ;i ++) {
t1 =sc.nextInt();
t2 =sc.nextInt();
a[t1][t2] =a[t2][t1] =true;
}
sc.close();
}
}