hdu5787 数位DP

Problem Description

Alice thinks an integer x is a K-wolf number, if every K adjacent digits in decimal representation of x is pairwised different.

Given (L,R,K), please count how many K-wolf numbers in range of [L,R].

 

Input

The input contains multiple test cases. There are about 10 test cases.

Each test case contains three integers L, R and K.

1≤L≤R≤1e18
2≤K≤5

 

Output

For each test case output a line contains an integer.

 

Sample Input

1 1 2
20 100 5

 

Sample Output

1
72

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
public static void main(String[] args) {
new Task().solve();
}
}

class Task{
InputReader in = new InputReader(System.in) ;
PrintWriter out = new PrintWriter(System.out) ;

int[] bit = new int[19] ;
long[][][][][] dp = new long[19][11][11][11][11] ;
int K ;

long dfs(int pos , int one , int two , int three , int four , boolean isEnd){
if(pos == -1){
return four == 10 ? 0 : 1 ;
}
if(!isEnd && dp[pos][one][two][three][four] != -1){
return dp[pos][one][two][three][four] ;
}
int d = isEnd ? bit[pos] : 9 ;
long sum = 0 ;
for(int i = 0 ; i <= d ; i++){
if(i == 0 && four == 10){
sum += dfs(pos-1 , 10 , 10 , 10 , 10 , isEnd && i == d) ;
}
else{
boolean cango = true ;
int[] now = {one , two , three , four} ;
for(int k = 3 ; k >= 5 - K ; k--){
if(i == now[k]){
cango = false ;
break ;
}
}
if(cango){
sum += dfs(pos-1 , two, three, four, i , isEnd && i == d) ;
}
}
}
if(! isEnd){
dp[pos][one][two][three][four] = sum ;
}
return sum ;
}

long calc(long n){
int pos = 0 ;
while(n > 0){
bit[pos++] = (int) (n % 10) ;
n /= 10 ;
}
return dfs(pos-1 , 10 , 10 , 10 , 10 , true) ;
}

void fill(){
for(int a = 0 ; a < 19 ; a++){
for(int b = 0 ; b < 11 ; b++){
for(int c = 0 ; c < 11 ; c++){
for(int d = 0 ; d < 11 ; d++){
Arrays.fill(dp[a][b][c][d] ,-1) ;
}
}
}
}
}

void solve(){
while(in.hasNext()){
long l = in.nextLong() ;
long r = in.nextLong() ;
K = in.nextInt() ;
fill();
out.println(calc(r) - calc(l-1)) ;
}
out.flush();
}
}

class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;

public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = new StringTokenizer("");
}

private void eat(String s) {
tokenizer = new StringTokenizer(s);
}

public String nextLine() {
try {
return reader.readLine();
} catch (Exception e) {
return null;
}
}

public boolean hasNext() {
while (!tokenizer.hasMoreTokens()) {
String s = nextLine();
if (s == null)
return false;
eat(s);
}
return true;
}

public String next() {
hasNext();
return tokenizer.nextToken();
}

public int nextInt() {
return Integer.parseInt(next());
}

public long nextLong() {
return Long.parseLong(next());
}

public double nextDouble() {
return Double.parseDouble(next());
}

public BigInteger nextBigInteger() {
return new BigInteger(next());
}

}