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::VecDeque;

#[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 main() {
    let n: usize = read();
    let mut que = VecDeque::<(usize, usize)>::new();
    let mut visit = vec![false; n];
    let mut dists = vec![usize::max_value(); n];
    que.push_back((1, 1));
    let mut ans = 0;
    while let Some((cost, v)) = que.pop_front() {
        if v == 0 {
            ans = cost;
            break;
        }
        visit[v] = true;
        for &(ncost, nv) in [(cost + 1, (v + 1) % n), (cost, v * 10 % n)].iter() {
            if visit[nv] || dists[nv] <= ncost {
                continue;
            }
            dists[nv] = ncost;
            if cost == ncost {
                que.push_front((ncost, nv));
            } else {
                que.push_back((ncost, nv));
            }
        }
    }
    println!("{}", ans);
}