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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

//AtCoder Beginner Contest 118
//D	Match Matching
public class Main {

	//                                  1, 2 ,3 ,4 ,5, 6 ,7 ,8 ,9
	static int[] NEEDS = new int[] { 2, 5, 5, 4, 5, 6, 3, 7, 6 };
	// matchNum, MaxFigure
	static Map<Integer, Integer> cache = new HashMap<Integer, Integer>();

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int M = sc.nextInt();

		List<Integer> inList = new ArrayList<>();
		for (int i = 0; i < M; i++) {
				inList.add(sc.nextInt());
		}
		sc.close();

		boolean[] isUsables = new boolean[] { false, false, false, false, false, false, false, false, false };
		for (Integer in : inList) {
			isUsables[in - 1] = true;
		}

		cache.put(0, 0);
		for (int i = 0; i < N; i++) {
			getMaxFigure(i, isUsables);
		}
		int maxFigure = getMaxFigure(N, isUsables);

		List<Integer> ret = new ArrayList<>();
		int restMatch = N;
		for (int i = maxFigure; i > 0; i--) {
			for (int j = NEEDS.length - 1; j >= 0; j--) {
				if (!isUsables[j]) {
					continue;
				}

				int need = NEEDS[j];
				if (!cache.containsKey(restMatch - need)) {
					continue;
				}

				if (cache.get(restMatch - need) == i - 1) {
					ret.add(j + 1);
					restMatch -= need;
					break;
				}
			}
		}

		for (Integer i : ret) {
			System.out.print(i);
		}
	}

	private static int getMaxFigure(int matchNum, boolean[] isUsables) {
		if (cache.containsKey(matchNum)) {
			return cache.get(matchNum);
		}
		if (matchNum < 0) {
			return Integer.MIN_VALUE;
		}
		if (matchNum == 0) {
			return 0;
		}
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < isUsables.length; i++) {
			if (!isUsables[i]) {
				continue;
			}

			int need = NEEDS[i];
			int maxFigure = getMaxFigure(matchNum - need, isUsables);
			if (max < maxFigure + 1) {
				max = maxFigure + 1;
			}
		}
		if (max < 0) {
			max = 0;
		}
		cache.put(matchNum, max);
		return max;
	}
}