【垒骰子】蓝桥杯

题目描述
赌圣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

需要采用动态规划思想分析：

#include <iostream>
using namespace std;
const long long mod=1e9+7;
const long long maxn=1e9;
int dp[maxn][7];
int op[7];
int conflict[7][7];
int main()
{
    int n,m;
    cin>>n>>m;
    int i,j,k;
    int a,b;
    for(i=0;i<m;i++)
    {
        cin>>a>>b;
        conflict[a][b]=conflict[b][a]=1;//构造冲突数组
    }
    op[1]=4;op[2]=5;op[3]=6;op[4]=1;op[5]=2;op[6]=3;
    for(j=1;j<=6;j++)
    {
        dp[0][j]=1;//初始化条件
    }
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=6;j++)
        {
            for(k=1;k<=6;k++)
            {
                if(!conflict[op[j]][k])
                {
                    dp[i][j]+=dp[i-1][k]%mod;
                    dp[i][j]%=mod;
                }
            }
        }
    }
    long long x=1;
    for(i=0;i<n;i++)
    {
        x*=4;
        x=x%mod;
    }
    long long y=0;
    for(j=1;j<=6;j++)
    {
        y+=dp[n-1][j];
        y=y%mod;
    }
    cout<<x*y;
    return 0;
}

但是dp数组过大，不能通过编译，并且时间复杂度过大为O(n^3)。并不能在实际中通过测试，理论是可行的。所以将采用矩阵快速幂的做法来进行优化操作。

矩阵快速幂的动态规划：
快速幂算法
矩阵快速幂

#include <iostream>
using namespace std;
const long long mod=1e9+7;
//构造冲突矩阵
struct matrix{
    int mat[6][6];
};
//初始为单位矩阵
void init1(matrix& a)
{
    int i,j;
    for(i=0;i<6;i++)
    {
        for(j=0;j<6;j++)
        {
            if(i==j)
            {
                a.mat[i][j]=1;
            }
            else
            {
                a.mat[i][j]=0;
            }
        }
    }
}
//初始化冲突矩阵：mat[i][j]=1时为不冲突，mat[i][j]=0时为冲突
void init2(matrix& a)
{
    int i,j;//初始化为全不冲突
    for(i=0;i<6;i++)
    {
        for(j=0;j<6;j++)
        {
            a.mat[i][j]=1;
        }
    }
}
//初始化为0
void init3(matrix& a)
{
    int i,j;
    for(i=0;i<6;i++)
    {
        for(j=0;j<6;j++)
        {
            a.mat[i][j]=0;
        }
    }
}
//6*6的方阵的乘法
matrix multi(matrix a,matrix b)
{
    matrix c;
    int i,j,k;
    init3(c);
    for(i=0;i<6;i++)
    {
        for(j=0;j<6;j++)
        {
            for(k=0;k<6;k++)
            {   //实际矩阵乘法不需要mod，mod是参照题意，防止过大，存储不下。
                c.mat[i][j]+=((a.mat[i][k]%mod)*(b.mat[k][j]%mod))%mod;
                c.mat[i][j]%=mod;
            }
        }
    }
    return c;
}
//矩阵快速幂算法
matrix fastPower1(matrix a,long long n)
{
    matrix c;
    init1(c);
    while(n)
    {
        if(n&1)
        {
            c=multi(c,a);
        }
        a=multi(a,a);
        n>>=1;
    }
    return c;
}
//4^n的快速幂
long long fastPower2(long long base,long long power)
{
    long long result=1;
    while(power)
    {
        if(power&1)
        {
            result=result*base%mod;
        }
        base=base*base%mod;
        power>>=1;
    }
    return result;
}
int main()
{
    int m,a,b;
    long long n;
    matrix matr;
    cin>>n>>m;
    init2(matr);//初始化为1：即不冲突
    for(int i=0;i<m;i++)
    {   //构建冲突矩阵
        cin>>a>>b;
        //mart.mat中的行和列都是指某一面朝上，所以matr.mat[a-1][b-1]这种写法是错的
        matr.mat[a-1][(b+2)%6]=matr.mat[b-1][(a+2)%6]=0;//为什么啊？
        //相当于conflict[op[i]][j]
    }
    matr=fastPower1(matr,n-1);//这里为什么是n-1呢？
    long long pow=fastPower2(4,n);
    long long ans=0;

    //最后算列向量：第一层骰子乘冲突矩阵即直接矩阵中的数相加
    for(int i=0;i<6;i++)
    {
        for(int j=0;j<6;j++)
        {
            ans+=matr.mat[i][j]%mod;
            ans%=mod;
        }
    }
    cout<<(ans*pow)%mod<<endl;
    return 0;
}