Problem:
Score : 500 points

Problem Statement

Find the number of integers between 1 and N (inclusive) that contains exactly K non-zero digits when written in base ten.

Constraints

1 \leq N < 10^{100}

1 \leq K \leq 3

Input

Input is given from Standard Input in the following format:

N
K

Output

Print the count.

Sample Input 1

100
1

Sample Output 1

19

The following 19 integers satisfy the condition:

1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100

Sample Input 2

25
2

Sample Output 2

14

The following 14 integers satisfy the condition:

11,12,13,14,15,16,17,18,19,21,22,23,24,25

Sample Input 3

314159
2

Sample Output 3

937

Sample Input 4

9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
3

Sample Output 4

117879300

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::vec::Vec;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}

fn read_touple<T: std::str::FromStr + Copy>() -> (T, T) {
  let v: Vec<T> = read_vec();
  assert_eq!(v.len(), 2);
  (v[0], v[1])
}

fn main() {
    let N: Vec<char> = read::<String>().chars().collect();
    let n = N.len();
    let K: usize = read();
    let mut dp: Vec<Vec<Vec<usize>>> = vec![vec![vec![0; K+1]; 2]; n+1];

    // init
    dp[0][0][0] = 1;



    for i in 0..n {
      let n = N[i] as usize - '0' as usize;
      for k in 0..K+1 {
        dp[i+1][1][k] += dp[i][1][k];
        if n != 0 {
           dp[i+1][1][k] += dp[i][0][k];
        }

        if k > 0 {
          for _ in 1..10 {
            dp[i+1][1][k] += dp[i][1][k-1];
          }
          for _ in 1..n {
            dp[i+1][1][k] += dp[i][0][k-1];
          }
        }
        if n == 0 {
           dp[i+1][0][k] = dp[i][0][k];
        } else {
           if k > 0 {
              dp[i+1][0][k] = dp[i][0][k-1];
           }
        }
      }
    }
    println!("{}", dp[n][0][K] + dp[n][1][K]);
}