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 Kotlin (1.0.0) (judge verdict: Time Limit Exceeded)

fun cmp(now : MutableList<Int>, next: MutableList<Int>) : Boolean{
    if(now.size < next.size) return true
    if(now.size > next.size) return false
    for(i in (now.size - 1).downTo(0)){
        if(now[i] < next[i]) return true
        if(now[i] > next[i]) return false
    }
    return false
}

fun addMatch(n : Int, i : Int, lx : MutableList<MutableList<Int>>, la : MutableList<Boolean>){
    val remain = n - i
    if(i > 0 && lx[i].size == 0) return
    if(la[1] && remain >= 2){
        val lNow = lx[i + 2]
        var lNext = lx[i].toMutableList()
        lNext.add(1)
        if(cmp(lNow, lNext)) lx[i + 2] = lNext
    }
    if(la[2] && remain >= 5){
        val lNow = lx[i + 5]
        var lNext = lx[i].toMutableList()
        lNext.add(2)
        if(cmp(lNow, lNext)) lx[i + 5] = lNext
    }
    if(la[3] && remain >= 5){
        val lNow = lx[i + 5]
        var lNext = lx[i].toMutableList()
        lNext.add(3)
        if(cmp(lNow, lNext)) lx[i + 5] = lNext
    }
    if(la[4] && remain >= 4){
        val lNow = lx[i + 4]
        var lNext = lx[i].toMutableList()
        lNext.add(4)
        if(cmp(lNow, lNext)) lx[i + 4] = lNext
    }
    if(la[5] && remain >= 5){
        val lNow = lx[i + 5]
        var lNext = lx[i].toMutableList()
        lNext.add(5)
        if(cmp(lNow, lNext)) lx[i + 5] = lNext
    }
    if(la[6] && remain >= 6){
        val lNow = lx[i + 6]
        var lNext = lx[i].toMutableList()
        lNext.add(6)
        if(cmp(lNow, lNext)) lx[i + 6] = lNext
    }
    if(la[7] && remain >= 3){
        val lNow = lx[i + 3]
        var lNext = lx[i].toMutableList()
        lNext.add(7)
        if(cmp(lNow, lNext)) lx[i + 3] = lNext
    }
    if(la[8] && remain >= 7){
        val lNow = lx[i + 7]
        var lNext = lx[i].toMutableList()
        lNext.add(8)
        if(cmp(lNow, lNext)) lx[i + 7] = lNext
    }
    if(la[9] && remain >= 6){
        val lNow = lx[i + 6]
        var lNext = lx[i].toMutableList()
        lNext.add(9)
        if(cmp(lNow, lNext)) lx[i + 6] = lNext
    }
}

fun main(args: Array<String>){
    var (n, m) = readLine()!!.split(" ").map(String::toInt)
    val l = readLine()!!.split(" ").map(String::toInt)
    var la = mutableListOf<Boolean>()
    for(i in 0..9) {
        la.add(false)
    }
    l.forEach{
        la[it] = true
    }
    var lx : MutableList<MutableList<Int>> = mutableListOf()
    for(i in 0..n){
        lx.add(mutableListOf())
    }
    for(i in 0..n){
        addMatch(n, i, lx, la)
    }

    for(i in (lx[n].size - 1).downTo(0)){
        print(lx[n][i])
    }
    println()
}