URAL 1009. K-based Numbers(简单递推)

每个有两种情况：1.上一次是0这次就有k-1种；2.上一次非零这次有k种。

1009. K-based Numbers

Time limit: 1.0 second
Memory limit: 64 MB

Let’s consider  K-based numbers, containing exactly  N digits. We define a number to be valid if its K-based notation doesn’t contain two successive zeros. For example:

• 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.

Given two numbers  N and  K, you are to calculate an amount of valid  K based numbers, containing  Ndigits.

You may assume that 2 ≤  K ≤ 10;  N ≥ 2;  N +  K ≤ 18.

Input

The numbers  N and  K in decimal notation separated by the line break.

Output

The result in decimal notation.

Sample

input	output
2 10	90

#include <algorithm>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <iomanip>
#include <stdio.h>
#include <string>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#define eps 1e-8
#define M 1000100
//#define LL __int64
#define LL long long
#define INF 0x3f3f3f3f
#define PI 3.1415926535898

const int maxn = 110;
using namespace std;

int dp[maxn];
int num[maxn];

int main()
{
    int n, k;
    while(cin >>n>>k)
    {
       dp[0] = k-1;
       for(int i = 1; i < n; i++)
       {
           num[i] = dp[i-1];
           dp[i] = (num[i-1]+dp[i-1])*(k-1);
       }
       cout<<dp[n-1]+num[n-1]<<endl;
    }
}

import java.util.*;  
import java.io.*;  
import java.math.*;
  
public class Main  
{  
    public static void main(String args[])  
    {  
    	Scanner cin = new Scanner(System.in);
    	BigInteger []dp = new BigInteger[2000];
    	BigInteger []num = new BigInteger[2000];
        while(cin.hasNext()){
        	int n, k;
        	n = cin.nextInt();
        	k = cin.nextInt();
        	dp[0] = BigInteger.valueOf(k-1);
        	num[0] = BigInteger.ZERO;
        	for(int i = 1; i < n; ++i){
        		num[i] = dp[i-1];
        		//System.out.println(dp[i-1]);
        		BigInteger t = num[i-1].add(dp[i-1]);
        		//System.out.println(t);
        		dp[i] = t.multiply(BigInteger.valueOf(k-1));
        	}
        	System.out.println(dp[n-1].add(num[n-1]));
        }
    }
}