Problem:
Score : 400 points

Problem Statement

Find the largest integer that can be formed with exactly N matchsticks, under the following conditions:

Every digit in the integer must be one of the digits A_1, A_2, ..., A_M (1 \leq A_i \leq 9).

The number of matchsticks used to form digits 1, 2, 3, 4, 5, 6, 7, 8, 9 should be 2, 5, 5, 4, 5, 6, 3, 7, 6, respectively.

Constraints

All values in input are integers.

2 \leq N \leq 10^4

1 \leq M \leq 9

1 \leq A_i \leq 9

A_i are all different.

There exists an integer that can be formed by exactly N matchsticks under the conditions.

Input

Input is given from Standard Input in the following format:

N M
A_1 A_2 ... A_M

Output

Print the largest integer that can be formed with exactly N matchsticks under the conditions in the problem statement.

Sample Input 1

20 4
3 7 8 4

Sample Output 1

777773

The integer 777773 can be formed with 3 + 3 + 3 + 3 + 3 + 5 = 20 matchsticks, and this is the largest integer that can be formed by 20 matchsticks under the conditions.

Sample Input 2

101 9
9 8 7 6 5 4 3 2 1

Sample Output 2

71111111111111111111111111111111111111111111111111

The output may not fit into a 64-bit integer type.

Sample Input 3

15 3
5 4 6

Sample Output 3

654

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

// Practice AtCoder
// author: Leonardone @ NEETSDKASU

fn main() {
    let mut stdin = String::new();
    std::io::Read::read_to_string(
        &mut std::io::stdin(),
        &mut stdin).unwrap();
    let mut stdin = stdin.split_whitespace();
    let mut get = || stdin.next().unwrap();
    macro_rules! get {
    	($t:ty) => (get().parse::<$t>().unwrap());
        () => (get!(i64));
    }
    
    let n = get!(usize);
    let m = get!();
    let mut xs = vec![];
    for _ in 0..m {
    	let x = get!(usize);
        xs.push(x);
    }
    let tb = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6];
    
    let mut ys: Vec<(usize, usize)> = vec![];
    for &x in xs.iter() {
    	let mut ok = true;
    	for i in 0..ys.len() {
        	if ys[i].0 == tb[x] {
            	if x > ys[i].1 {
                	ys[i].1 = x;
                    ok = false;
                    break;
                }
            }
        }
        if !ok { continue; }
    	ys.push((tb[x], x));
    }
    
    // println!("{:?}", ys);
    
    let mut dp = vec![vec![(0, 0, 0, 0); 10]; n+1];
    for &y in ys.iter() {
    	if n < y.0 { continue; }
        dp[n-y.0][y.1] = (1, y.1, 0, 0);
    }
    for i in 0..n {
    	let i = n - i;
        for &z in ys.iter() {
         	let x = z.1;
        	let t = dp[i][x];
            if t.0 == 0 { continue; }
            for y in ys.iter() {
            	if i < y.0 { continue; }
                let e = dp[i - y.0][y.1];
                if t.0 + 1 < e.0 {
                	continue;
                }
                if t.0 + 1 == e.0 {
                	if t.1+y.1 <= e.1 {
                    	continue;
                    }
                }
                dp[i-y.0][y.1] = (t.0+1, t.1+y.1, i, x);
            }
        }
    }
    
    // println!("{:?}", dp[0]);
    
    let ans = dp[0]
    	.iter()
        .enumerate()
        .max_by(|x,y| {
        	if (x.1).0 == (y.1).0 {
            	(x.1).1.cmp(&(y.1).1)
            } else {
            	(x.1).0.cmp(&(y.1).0)
            }
        })
        .unwrap();
    
    let mut i = ans.0;
    let mut t = ans.1;
    let mut zs = vec![];
    while i > 0 {
    	zs.push(i);
        i = t.3;
        t = &dp[t.2][i];
    }
    
    zs.sort();
    zs.reverse();
    for &z in zs.iter() {
    	print!("{}", z);
    }
    println!();
}