风之守护 URAL - 1009 URAL - 1012 URAL - 1013

DP URAL - 1009 URAL - 1012 URAL - 1013

题目链接：https://cn.vjudge.net/contest/190727#problem/B（简单）
https://cn.vjudge.net/contest/190727#problem/H（大数）
https://cn.vjudge.net/contest/190727#problem/K（矩阵快速幂）
题目大意：N位K进制的数，不允许出现连续的两个0，问这种数有多少个。2 ≤ K ≤ 10; N ≥ 2; N + K ≤ 18.

• 1010230 is a valid 7-digit number;
• 1000198 is not a valid number;

• 0001235 is not a 7-digit number, it is a 4-digit number.

  input ：2 10
  output 90 // 10-99 共90个
  题目分析：这个题目，可以用数位dp来做，也可以用简单的dp来做。数位dp的做法不写了。

   #include <bits/stdc++.h>
   using namespace std;

  const int maxn = 50;
  typedef long long ll;
  ll dp[maxn][2];
  //dp[i][j] i表示第i位，j有两种状态，一种是为0，表示当前位放0；另一种是为1, 表示当前位不放置0（即放置1~k-1)

  int main()
  {
      int n, k;
      cin >> n >> k;
      dp[1][0] = 0;
      dp[1][1] = k - 1;


      for(int i = 2; i <= n; i++) {
         dp[i][0] = dp[i - 1][1];
         dp[i][1] = (dp[i - 1][0] + dp[i - 1][1]) * (k - 1);
       }
       printf("%lld\n", dp[n][0] + dp[n][1]);
  }

这个是一开始自己推的，后来看了别人的发现直接用一维数组即可。
代码如下：

#include <bits/stdc++.h>
using namespace std;

const int maxn = 1e3 + 100;
int dp[maxn];

int main()
{
    int n, k;
    cin >> n >> k;
    dp[1] = k - 1;
    dp[2] = (k - 1) * k;
    for(int i = 3; i <= n; i++)
        dp[i] = (k - 1) * (dp[i - 1] + dp[i - 2]);
    printf("%d\n", dp[n]);
}
//dp[i - 1] * (k - 1) 是说当前位不放零，有k - 1个数（1~k-1）可以放，因为不放零，所以它的前一位放什么都无所谓了，直接dp[i - 1] * (k - 1)；
//dp[i - 2] * (k - 1)是说当前位放零，那么它的前一位必定不是零，可以是（1~k-1）有k-1中放法，乘以它的前前一位的放法数dp[j - 2]
//虽然都是乘以k - 1, 但是意义却不一样。

第二个就是数据范围变大。2 ≤ K ≤ 10; N ≥ 2; N + K ≤ 1800.涉及大数，需要用Java

//package test;
import java.io.*;
import java.util.*;
import java.math.*;

public class Main{
    static BigInteger[][] dp = new BigInteger[2010][20];
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int K = cin.nextInt();
        int i, j, k;
        for(i = 0; i < 2010; i++)
        {
            for(j = 0; j < 20; j++)
            {
                dp[i][j] = new BigInteger("0");
            }

        }
        if(n == 1) dp[1][0] = new BigInteger("1");

        for(i = 1; i < K; i++)
            dp[1][i] = new BigInteger("1");

        for(i = 2; i <= n; i++)
        {
            for(j = 0; j < K; j++)
            {
                for(k = 0; k < K; k++)
                {
                    if(j == 0 && k == 0) continue;
                    dp[i][j] = dp[i][j].add(dp[i - 1][k]);
                }
            }
        }

        BigInteger sum = BigInteger.ZERO;
        for(i = 0; i < K; i++)
            sum = sum.add(dp[n][i]);
        System.out.println(sum);
    }
}

这种做法是自己一开始想的做法，原理跟之前那个一样。
第三种：2 ≤ N, K, M ≤ 1e18. 数据范围进一步扩大，需要用矩阵快速幂，我的代码是在第一个问题的一维的代码上写的矩阵快速幂。

import java.math.BigInteger;  
import java.util.Scanner;  

class Matrix {
    BigInteger dp[][] = new BigInteger [3][3];
    BigInteger mod;

    public Matrix(Boolean flag, BigInteger _mod) {
        for(int i = 0; i < 2; i++)
            for(int j = 0; j < 2; j++)
                dp[i][j] = BigInteger.ZERO;

        if(flag) {
            dp[0][0] = dp[1][1] = BigInteger.ONE;
        }
        mod = _mod;
    }

     Matrix mul (Matrix b) {
        Matrix a = new Matrix (false, mod); 
        for(int i = 0; i < 2; i++) {
            for(int j = 0; j < 2; j++) {
                for(int k = 0; k < 2; k++) {
                    a.dp[i][j] = a.dp[i][j].add(dp[i][k].multiply(b.dp[k][j]).mod(mod)).mod(mod);
                //  System.out.println(a.dp[i][j] + "###");
                }
            }
        }
        return a;
    }

     Matrix pow_mod(long b) {
        Matrix ans = new Matrix(true, mod);
        Matrix a = this;

        while(b != 0) {
            if((b % 2) != 0) {
                ans = ans.mul(a);
            }

            a = a.mul(a);
            b >>= 1;
        }
        return ans;
    }

}

public class Main{
    static Scanner cin = new Scanner(System.in);
    public static void main(String[] args) {
        long n = cin.nextLong();
        BigInteger k = cin.nextBigInteger();
        BigInteger mod = cin.nextBigInteger();

        Matrix a = new Matrix(false, mod);
        a.dp[0][0] = k.subtract(BigInteger.ONE);
        a.dp[0][1] = k.subtract(BigInteger.ONE);
        a.dp[1][0] = BigInteger.ONE;
        a.dp[1][1] = BigInteger.ZERO;

        a = a.pow_mod(n - 1);

        BigInteger ans1 = k.subtract(BigInteger.ONE).multiply(a.dp[0][0]).mod(mod);
        BigInteger ans2 = k.subtract(BigInteger.ONE).multiply(a.dp[1][0]).mod(mod);
        BigInteger ans = ans1.add(ans2).mod(mod);

        System.out.println(ans);
    }
}