Problem:
Score : 700 points

Problem Statement

Find the smallest possible sum of the digits in the decimal notation of a positive multiple of K.

Constraints

2 \leq K \leq 10^5

K is an integer.

Input

Input is given from Standard Input in the following format:

K

Output

Print the smallest possible sum of the digits in the decimal notation of a positive multiple of K.

Sample Input 1

6

Sample Output 1

3

12=6×2 yields the smallest sum.

Sample Input 2

41

Sample Output 2

5

11111=41×271 yields the smallest sum.

Sample Input 3

79992

Sample Output 3

36

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

use std::io::*;
use std::str::FromStr;
use std::collections::BinaryHeap;

#[allow(dead_code)]
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn digits(mut v: usize) -> usize {
    let mut ret = 0;
    while v > 0 {
        ret += v % 10;
        v /= 10;
    }
    ret
}
fn main() {
    let n: usize = read();
    let mut que = BinaryHeap::<(i32, usize)>::new();
    let mut visit = vec![false; n];
    let mut dists = vec![i32::max_value(); n];
    que.push((0, 0));
    let mut ans = digits(n);
    while let Some((cost, v)) = que.pop() {
        let cost = -cost;
        if visit[v] {
            continue;
        }
        visit[v] = true;
        for i in 0..10 {
            let nv = (v + i * n) / 10;
            let ncost = cost as usize + (v + i * n) % 10;
            let ncost = ncost as i32;
            if visit[nv] || dists[nv] <= ncost {
                continue;
            }
            dists[nv] = ncost;
            que.push((-ncost, nv));
            ans = std::cmp::min(ans, digits(nv) + ncost as usize);
        }
    }
    println!("{}", ans);
}