蓝桥杯：垒骰子【快速幂+矩阵乘法解决动态规划问题】

先看题：

【说实话，这道题是本菜写过最有数学味道的题目，虽然是是简单的矩阵运算和快速幂】

这道题目如果数据范围小的话，那么就是一个简单的dp，为了方便理解，我们先看不考虑时间复杂度的问题，先来看下怎么用dp来写；

（1）找状态集合的定义：我们最后的状态是有n个骰子，且最后一个骰子最上面的数有6种不同的朝向，所以我们可以定义集合f[i][j]为有i个骰子，且最后一个骰子上面的数为j的方案数；

（2）状态转移方程：因为有考虑一些数字不能接触，所以有

【其中t~m为j这个数可以与其接触的数】

上面就是dp的写法，但是n太大了，dp的时间复杂度显然是不支持的；

所以我们就要想一些性质出来，用来简化时间复杂度；

这里我们可以将上面的状态转移方程展开出来

其中a1~a6有两个取值，一个是0，一个是4，当j与k不可以接触时，ak为0，当可以接触时，ak为4【为什么为4呢？因为j与k接触时【k为第i-1个骰子的上面的数，j为i个骰子的下面的数】，可以通过横向旋转使第i个骰子下面的数不变，但第i个骰子变化了其他方向的数字，这样旋转，可以造成第i个骰子有4种不同的状态】

要注意，上面的式子是在所有状态转移方程不变的，即方程的系数不变，所以我们就可以用抽象出一个系数矩阵A；

记

所以有F[i]=A*F[i-1]，由这个可以推出

其中F[1]={4,4,4,4,4,4};

那么我们只要用快速幂算得A^(n-1)然后与F[1]相乘即可

那么下面是代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#define ll long long
using namespace std;

const int N=10,M=6,mod=1e9+7;

ll a[N][N];//a[i][j]表示当k个骰子上位i，第k-1个骰子位j时可以将状态转移为a[i][j]
int n,m;
ll bakp[N][N];//bakp存储着A^(n-1)
ll init[N][N];//F[1]

void mul(ll a[][N],ll b[][N],ll c[][N]){//这个函数的意思是a=b*c
    
    ll t[N][N];
    
    memset(t,0,sizeof t);
    
    for(int i=1;i<=M;i++){
        
        for(int j=1;j<=M;j++){
            
            for(int k=1;k<=M;k++){
                
                t[i][j]+=(b[i][k]*c[k][j])%mod;
                t[i][j]%=mod;
                
            }
        }
    }
    
    memcpy(a,t,sizeof t);
    
}

int get(int x){
    if(x>3) return x-3;
    else return x+3;
} 

int main(){
    
    cin>>n>>m;
    
    for(int i=1;i<=M;i++)
        for(int j=1;j<=M;j++)
            a[i][j]=4;
            
    for(int i=0;i<m;i++){
        
        int x,y; cin>>x>>y;
        a[x][get(y)]=0;
        a[y][get(x)]=0;
    }
    for(int i=1;i<=M;i++){//将bakp初始化为单位矩阵
        bakp[i][i]=1; init[1][i]=4;
    }
    
    for(int i=n-1;i;i>>=1){
        if(i%2) mul(bakp,bakp,a);
        mul(a,a,a);
    }
    
    mul(init,init,bakp);
    ll res=0;
    
    for(int i=1;i<=M;i++) res+=init[1][i],res%=mod;
    
    cout<<res;
    
}

最后说一下个人感悟，用矩阵乘法和快速幂可以解决用矩阵表示状态转移的动态规划问题