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 OCaml (4.02.3) (judge verdict: Accepted)

let rec seq a b = if a > b then [] else a :: seq (a+1) b
let (>>=) x f = List.map f x |> List.concat

let len = 50
let costs = [|0;2;5;5;4;5;6;3;7;6|]

let cmp xs ys =
  let lx = List.fold_left (fun s (x, i) -> s+i) 0 xs in
  let ly = List.fold_left (fun s (y, i) -> s+i) 0 ys in
  if lx <> ly then lx - ly
  else
  let rec f xs ys =
    match xs, ys with
    | [], [] -> 0
    | _::_, [] -> -1
    | [], _::_ -> 1
    | ((x,i)::xs), ((y,j)::ys) ->
        if x <> y then x - y
        else if i <> j then i - j
        else f xs ys
  in f xs ys

let () =
  Scanf.scanf "%d %d" @@ fun n m ->
  let a = Array.init m (fun _ ->
    Scanf.scanf " %d" (fun x -> (costs.(x), -x, x)))
  |> Array.to_list
  |> List.sort compare
  in
  let ca, _, va = List.hd a in
  let la = max 0 (n - len) / ca in
  let ma = la * ca in

  let rec f th = function
    | [] -> if th = 0 then [[]] else []
    | (c, _, x) :: xs ->
        seq 0 (th / c) >>= fun i ->
          List.map (fun y -> (x, i) :: y) (f (th - i * c) xs)
  in

  let be =
    f (n - ma) a |> List.fold_left (fun ans xs ->
      let xs = List.sort (fun x y -> compare y x) xs in
      if cmp ans xs >= 0 then ans else xs) []
  in
  ((va, la) :: be) |> List.sort (fun x y -> compare y x)
  |> List.iter (fun (x, i) -> for n = 1 to i do Printf.printf "%d" x done);
  print_newline ()