Problem:
Coin Changing Problem

Find the minimum number of coins to make change for n cents using coins of denominations d1, d2,.., dm. The coins can be used any number of times.

Input

n m
d1 d2 ... dm

Two integers n and m are given in the first line. The available denominations are given in the second line.

Output

Print the minimum number of coins in a line.

Constraints

1 ≤ n ≤ 50000

1 ≤ m ≤ 20

1 ≤ denomination ≤ 10000

The denominations are all different and contain 1.

Sample Input 1

55 4
1 5 10 50

Sample Output 1

2

Sample Input 2

15 6
1 2 7 8 12 50

Sample Output 2

2

Sample Input 3

65 6
1 2 7 8 12 50

Sample Output 3

3

Solution in Rust (judge verdict: Time Limit Exceeded)

mod utils {
    use std::error::Error;
    use std::io::stdin;
    use std::str::FromStr;

    #[allow(dead_code)]
    pub fn read_line<T>() -> Result<Vec<T>, Box<Error>>
    where
        T: FromStr,
        T::Err: 'static + Error,
    {
        let mut line = String::new();
        let _ = stdin().read_line(&mut line)?;
        let parsed_line = line.split_whitespace()
            .map(|x| x.parse::<T>())
            .collect::<Result<Vec<T>, T::Err>>()?;

        Ok(parsed_line)
    }

    #[allow(dead_code)]
    pub fn read_lines<T>(n: usize) -> Result<Vec<Vec<T>>, Box<Error>>
    where
        T: FromStr,
        T::Err: 'static + Error,
    {
        (0..n).map(|_| read_line()).collect()
    }
}

fn solve() -> Result<(), Box<std::error::Error>> {
    let header = utils::read_line::<usize>()?;
    let amount = header[0];
    let n_coins = header[1];
    let coins = utils::read_line::<usize>()?;

    let mut dp = vec![vec![None; amount + 1]; n_coins];

    for j in 1..(amount + 1) {
        if j % coins[0] == 0 {
            dp[0][j] = Some(j / coins[0]);
        }
    }

    for i in 1..n_coins {
        for j in 1..(amount + 1) {
            dp[i][j] = dp[i - 1][j];
            for k in 1..(j / coins[i] + 1) {
                let m = j - k * coins[i];
                let prev = dp[i - 1][m].unwrap_or(0);

                dp[i][j] = Some(std::cmp::min(dp[i][j].unwrap(), prev + k));
            }
        }
    }

    println!("{:?}", dp[n_coins - 1][amount].unwrap());

    Ok(())
}

fn main() {
    match solve() {
        Err(err) => panic!("{}", err),
        _ => (),
    };
}