【DP && 矩阵快速幂 && 快速乘】URAL - 1013 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 所使用)就可以了

Step 4 Code:

#include<bits/stdc++.h>
using namespace std;
#define ll long long
struct node
{
    ll a[2][2];
};
node c, ans;
ll n, k, MOD;
ll nmul(ll x, ll y, ll MOD)//快速乘
{
    ll sum = 0;
    x = x%MOD;
    y = y%MOD;
    while(y)
    {
        if(y&1) sum = (sum + x)%MOD;
        y >>= 1;
        x = (x+x)%MOD;
    }
    return sum;
}
node mul(node x, node y, ll MOD)//矩阵相乘
{
    node sum;
    memset(sum.a, 0, sizeof(sum.a));
    for(int k = 0; k < 2; k++)
    {
        for(int i = 0; i < 2; i++)
        {
            if(x.a[i][k])
            for(int j = 0; j < 2; j++)
            {
                sum.a[i][j] += nmul(x.a[i][k], y.a[k][j], MOD);
                sum.a[i][j] %= MOD;
            }
        }
    }
    return sum;
}
node fp(node t, ll n, ll MOD)//矩阵快速幂
{
    node sum;
    memset(sum.a, 0, sizeof(sum.a));
    for(int i = 0; i < 2; i++) sum.a[i][i] = 1;
    while(n)
    {
        if(n&1) sum = mul(sum, t, MOD);
        n >>= 1;
        t = mul(t, t, MOD);
    }
    return sum;
}
void init()//初始化
{
    c.a[0][0] = c.a[0][1] = k-1;
    c.a[1][0] = 1, c.a[1][1] = 0;
    memset(ans.a, 0, sizeof(ans.a));
    ans.a[0][0] = k-1;
}
int main()
{
    while(cin >> n >> k >> MOD)
    {
        init();
        node t = fp(c, n-1, MOD);
        t = mul(t, ans, MOD);
        cout << (t.a[0][0] + t.a[1][0]) % MOD << endl;
    }
    return 0;
}