K-based Numbers. Version 3(DP+快速乘+矩阵快速幂)

题目链接：K-based Numbers. Version 3

Step 1 Problem:

题意：
给你限制长度为n，必须是k进制，让你求长度为n的正整数且 中间不能有连续的两个零 的个数 取模 MOD。
数据范围：
2 <= n, k, MOD <= 1e18.

Step 2 Involving algorithms:

DP 矩阵快速幂 快速乘

Step 3 Ideas:

最开始想到的求法就是 设置一个二维dp[i][j]。
dp[i][0] 代表 长度为i, 满足k进制 最后一位是0有多少个
dp[i][1] 代表 长度为i, 满足k进制 最后一位是1-(k-1)有多少个
状态转移方程就是：
dp[i][0] = dp[i-1][1];
dp[i][1] = (dp[i-1][0] + dp[i-1][1]) * (k-1);
结果就是dp[n][0] + dp[n][1];
但是题目给你的n范围高达1e18你这样暴力是肯定会超时的，所以我们想到矩阵快速幂。在我的认知里面想用矩阵快速幂的话，就需要把上面两条状态转移方程合成一条。
所以我们可以推导出：
因为 dp[i][1] = (dp[i-1][0] + dp[i-1][1]) * (k-1); dp[i-1][0] = dp[i-2][1];
所以 dp[i][1] = (dp[i-2][1] + dp[i-1][1]) * (k-1);
状态转移方程就诞生了 dp[i] = (dp[i-2] + dp[i-1]) * (k-1);
结果就是 dp[n] + dp[n-1]。
dp[i] ———— = k-1 k-1 * dp[i-1]
dp[i-1] ———— 1 0 ——- dp[i-2]
中间矩阵如上，接着就是矩阵快速幂 和 快速乘(为了让乘法不溢出long long 所使用)就可以了

转载自【DP && 矩阵快速幂 && 快速乘】URAL - 1013 K-based Numbers. Version 3
感谢学长

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<queue>
#include<stack>
#include<vector>
using namespace std;

typedef long long ll;

struct mat
{
    ll jz[5][5];
} tep,in;
ll n,m,mod;

ll qmul(ll a,ll b,ll mod)//快速乘
{
    ll sum = 0;
    a %= mod;
    b %= mod;
    while(b)
    {
        if(b&1) sum = (sum+a)%mod;
        b >>= 1;
        a = (a+a)%mod;
    }
    return sum;
}

mat matmul(mat a,mat b,ll mod)
{
    mat c;
    memset(c.jz,0,sizeof(c.jz));
    for(int k = 0; k < 2; k++)
    for(int i = 0; i < 2; i++)
    if(a.jz[i][k])
    for(int j = 0; j < 2; j++)
    {
        c.jz[i][j] += qmul(a.jz[i][k],b.jz[k][j],mod);
        c.jz[i][j] %= mod;
    }
    return c;
}

mat matpow(mat a,ll n,ll mod)
{
    mat ans;
    memset(ans.jz,0,sizeof(ans.jz));
    for(int i = 0; i <= 2; i++)
    {
        ans.jz[i][i] = 1;
    }
    while(n)
    {
        if(n&1) ans = matmul(ans,a,mod);
        a = matmul(a,a,mod);
        n >>= 1;
    }
    return ans;
}

void init()//初始化一波，这里初始化的两个结构体记得在之前就要定义
{
    memset(in.jz,0,sizeof(in.jz));
    tep.jz[0][0] = tep.jz[0][1] = m-1;
    tep.jz[1][0] = 1,tep.jz[1][1] = 0;
    in.jz[0][0] = m-1;
}

int main()
{
    while(cin >> n >> m >> mod)
    {
        init();
        mat t = matpow(tep,n-1,mod);//矩阵快速幂
        t = matmul(t,in,mod);
        cout << (t.jz[0][0]+t.jz[1][0])%mod << endl;
    }
    return 0;
}