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 C# (Mono 4.6.2.0) (judge verdict: Runtime Error)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Beg118D
{
    class Program
    {
        static void Main(string[] args)
        {
            var matchNum = new int[9] { 2, 5, 5, 4, 5, 6, 3, 7, 6 };

            var read = Console.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
            var N = read[0];
            var M = read[1];

            var A = Console.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
            var AWithMatchNumDict = A.ToDictionary(x => x, x => matchNum[x - 1]);
            var retDict = new Dictionary<int, int>();

            var success = MaxCombination(N, AWithMatchNumDict, ref retDict);
            if (!success) throw new ArgumentException("not successful");
            string ret = "";
            var sortedKeys = retDict.Keys.ToList();
            sortedKeys.Sort();
            foreach(var key in sortedKeys)
            {
                for(int i = retDict[key];i>0;i--)
                {
                    ret = key.ToString() + ret;
                }
            }

            Console.WriteLine(ret);
        }

        public static bool MaxCombination(int N, Dictionary<int,int> numWithMatchNumDict, ref Dictionary<int, int> retDict)
        {
            var minMatchNumVal = numWithMatchNumDict.Values.Min();
            var numMinMatchNumVals = numWithMatchNumDict.Where(x => x.Value == minMatchNumVal);
            var tempDict = new Dictionary<int, int>(numWithMatchNumDict);
            foreach(var pair in numMinMatchNumVals)
            {
                tempDict.Remove(pair.Key);
            }
            var numMinMatchNumVal = numMinMatchNumVals.Select(x => x.Key).Max();

            if (N % minMatchNumVal == 0)
            {
                retDict.Add(numMinMatchNumVal, N / minMatchNumVal);
                return true;
            }
            else if (tempDict.Count == 0)
                return false;
            else
            {
                var iMax = N / minMatchNumVal - 1;
                if (!retDict.Keys.Contains(numMinMatchNumVal)) retDict.Add(numMinMatchNumVal, iMax);
                int i = iMax;
                var result = false;
                for (; i >= 0; i--)
                {
                    retDict[numMinMatchNumVal] = i;
                    result = MaxCombination(N - i * minMatchNumVal, tempDict, ref retDict);
                    if (result)
                        break;
                    if (i == 0)
                        return false;
                }

                return result;
            }
        }
    }
}