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 Scala (2.11.7) (judge verdict: Accepted)

object Main extends App {
  import scala.io.StdIn._

  val usage = Array(2, 5, 5, 4, 5, 6, 3, 7, 6)
  val Array(n, m) = readLine.trim.split(' ').map(_.toInt)
  val a = readLine.trim.split(' ').map(_.toInt)
  println(solve(n, a).mkString)
  def solve(n: Int, canUse: Array[Int]): List[Int] = {
    val minUse = canUse.map(i ⇒ usage(i - 1)).min
    val maxDigit = n / minUse
    val numbers = canUse.sorted(Ordering.Int.reverse)
    val memo = Array.tabulate(n + 1){_ ⇒ State(-1, 0)}
    memo(0).length = 0
    for (i ← 0 to n if memo(i).length != -1){
      for (number ← numbers if i + usage(number - 1) <= n){
        if (memo(i + usage(number - 1)).length < memo(i).length + 1) {
          memo(i + usage(number - 1)).length = memo(i).length + 1
          memo(i + usage(number - 1)).head = number
        }else if (memo(i + usage(number - 1)).length == memo(i).length + 1 && memo(i + usage(number - 1)).head < number){
          memo(i + usage(number - 1)).head = number
        }
      }
    }
    var using = n
    var result = Nil: List[Int]
    while (using != 0){
      result ::= memo(using).head
      using -= usage(memo(using).head - 1)
    }
    result.reverse
  }
  case class State(var length: Int, var head: Int)
  implicit class Scope[T](val value: T) extends AnyVal {
    @inline def also(@inline func: T ⇒ Unit): T = {
      func(value)
      value
    }
    @inline def let[A](@inline func: T ⇒ A): A = func(value)
  }

}