垒骰子 （动态规划+矩阵乘法优化）

试题 历届真题 垒骰子【第六届】【省赛】【A组】
     
资源限制
内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s
　　赌圣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


　　请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

　　所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

　　注意: main函数需要返回0
　　注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
　　注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。

　　提交时，注意选择所期望的编译器类型。

思路： 

在没有直接的正确的时间复杂度的算法时，就找规律，找不到，就放弃，想想增加时间复杂度的算法，在考虑如何优化，

o（n）的复杂度，很容易想到  DP， 这个dp的更行，可以转化为矩阵乘法，

DP【i】【j】, i 表示上一个 骰子的顶面数字，j 表示这个骰子的顶面数字，整体表示他是否合法不。

小注意：

• 用矩阵乘法，常用结构体表示，方便赋值。
• 遇到取模，所有的变量类型一定要去 longlong， 特别是快速n的 a。
• 用矩阵时，记得初始化，矩阵运算法则记住咯

#include <bits/stdc++.h>
using namespace std;
#define ri register int
#define  M 105

const int mod = 1e9+7;
template <class G > void read(G &x)
{
    x=0;int f=0;char ch=getchar();
    while(ch<'0'||ch>'9'){f|=ch=='-';ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x=f?-x:x;
    return ;
}

struct node{
    long long  arr[M][M];// 定义变量很大小 
}a;

node xx(node a,node b)
{
    node t;
    for(ri i=1;i<=6;i++)
    {
        for(ri j=1;j<=6;j++)
        {
            t.arr[i][j]=0;
            for(ri k=1;k<=6;k++)
            {
                t.arr[i][j]=(t.arr[i][j]+a.arr[i][k]*b.arr[k][j]%mod)%mod;
            }
        }
    }
    return t;
}
node x(node a,node b)
{
    node t;
    for(ri i=1;i<=1;i++)
    {
        for(ri j=1;j<=6;j++)
        {
            t.arr[i][j]=0;
            for(ri k=1;k<=6;k++)
            {
                t.arr[i][j]=(t.arr[i][j]+b.arr[i][k]*a.arr[k][j]%mod)%mod;
            }
        }
    }
    return t;
}
node ksn(node a,int n)
{
    node t;
    for(ri i=1;i<=6;i++)
    {
        for(ri j=1;j<=6;j++)
        {
            if(i==j) t.arr[i][j]=1;
            else t.arr[i][j]=0;
        }
    }
    while(n)
    {
        if(n&1) t=xx(t,a);
        n>>=1;a=xx(a,a);
    }
    return t;
}
long long  ksnn(long long a,int n)
{
    long long  ans=1;
    while(n)
    {
        if(n&1) ans=ans*a%mod;
        n>>=1;a=a*a%mod;
    }
//    cout<<ans<<endl;
    return ans;
}
int n,m;
const int  to[10] = 
{
    0,4,5,6,1,2,3
};

int op[5];
int main(){
    
    read(n);read(m);
    for(ri i=1;i<=6;i++)
    for(ri j=1;j<=6;j++)
    a.arr[i][j]=1;
    for(ri i=1;i<=m;i++)
    {
        read(op[1]);read(op[2]);
        a.arr[to[op[1]]][op[2]]=0;
        a.arr[to[op[2]]][op[1]]=0;
    }
    
    node ans=ksn(a,n-1);
    node tmp;
    for(ri i=1;i<=6;i++) tmp.arr[1][i]=1;
    ans=x(ans,tmp);
    long long anss=0;
    for(ri i=1;i<=6;i++)
    {
        anss=(anss+ans.arr[1][i])%mod;
    }
//    cout<<anss<<endl;
    anss=anss*ksnn(4,n)%mod;
    printf("%lld",anss);
    
}