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)

fn get_line() -> String {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().to_string()
}

fn readln<T>() -> T
    where
        T: std::str::FromStr,
        <T as std::str::FromStr>::Err: std::fmt::Debug {
    get_line().parse().unwrap()
}

use std::collections::BinaryHeap;
use std::cmp::Ordering;

#[derive(Clone, Copy, Eq, PartialEq)]
struct E {
    d: usize,
    v: usize,
}

impl Ord for E {
    fn cmp(&self, other: &Self) -> Ordering {
        other.d.cmp(&self.d)
    }
}

impl PartialOrd for E {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

fn main() {
    let k = readln();
    
    let mut xs = vec![vec![]; k];

    for i in 0..k {
        let j = (i + 1) % k;
        let h = (i * 10) % k;

        xs[i].push((j, 1));
        xs[i].push((h, 0));
    }

    let mut q = BinaryHeap::new();
    let mut ds = vec![None; k];
    ds[1] = Some(1);
    q.push(E {
        d: 1,
        v: 1,
    });

    while let Some(e) = q.pop() {
        if let Some(d) = ds[e.v] {
            if d < e.d {
                continue;
            }
        }

        for &(v, w) in &xs[e.v] {
            if let Some(d) = ds[v] {
                if e.d + w < d {
                    ds[v] = Some(e.d + w);
                    q.push(E {
                        d: e.d + w,
                        v: v,
                    });
                }
            }
            else {
                ds[v] = Some(e.d + w);
                q.push(E {
                    d: e.d + w,
                    v: v,
                });
            }
        }
    }

    println!("{}", ds[0].unwrap());
}