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++14 (GCC 5.4.1) (judge verdict: Accepted)

#include "bits/stdc++.h"
using namespace std;

#define ASC(vec) vec.begin(), vec.end()		// 昇順ソート 例：sort(ASC(vec));
#define DESC(vec) vec.rbegin(), vec.rend()	// 降順ソート 例:sort(DESC(vec));
#define rep(i, n) for(int i = 0; i < (n); i++)
#define Rep(i, n) for(int i = 1; i < n; i++)
#define REP(i, vec) for(auto i = vec.begin(); i != vec.end(); ++i)

const int mod = 1000000007;
const int inf = (1 << 21);
const long long INF = 1LL << 60;

using ii = pair<int, int>;
using ll = long long;
using vi = vector<int>;
using vd = vector<double>;
using vb = vector<bool>;
using vl = vector<ll>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
using vvb = vector<vector<bool>>;
using vii = vector<pair<int, int>>;
using vll = vector<pair<ll, ll>>;

template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline T GCD(T a, T b) { return b ? GCD(b, a % b) : a; }
template<class T> inline T LCM(T a, T b) { return (a + (b - 1)) / b; }

int round_int(int a, int b) { return (a + (b - 1)) / b; }

constexpr array<int, 9> dx = { 0, 1, 0, -1, -1, 1, 1, -1, 0 };
constexpr array<int, 9> dy = { 1, 0, -1, 0, 1, 1, -1, -1, 0 };

// ──────────────────────────────────────────────────────────────────

constexpr array<int, 10> cost = { -1,2,5,5,4,5,6,3,7,6 };

int calc_cost(deque<int> d) {
	int res = 0;
	while (!d.empty()) {
		int v = d.front(); d.pop_front();
		res += cost[v];
	}
	return res;
}

int main() {
	int n, m;
	cin >> n >> m;

	vi a(m);
	rep(i, m) cin >> a[i];

	vector<vector<deque<int>>> dp(n + 1, vector<deque<int>>(m));

	for (int i = 0; i <= n; ++i) {
		for (int j = 0; j < m; ++j) {
			int c = cost[a[j]];
			//cout << i << " " << j << endl;
			if (i - c >= 0 && calc_cost(dp[i - c][j]) + c == i) {
				deque<int> pre = dp[i - c][j];
				if (pre.size() == 0) pre.push_back(a[j]);
				else if (pre.front() > a[j]) pre.push_back(a[j]);
				else pre.push_front(a[j]);
				dp[i][j] = pre;
			}

			if (j != 0) {
				deque<int> pre = dp[i][j - 1];

				if (pre.size() < dp[i][j].size()) continue;
				else if (pre.size() > dp[i][j].size()) dp[i][j] = pre;
				else if (pre.size() == dp[i][j].size()) {
					if (pre.size() == 0) continue;

					deque<int> tmp1 = pre, tmp2 = dp[i][j];
					for (int k = 0; k < pre.size(); ++k) {
						int l = tmp1.front(), r = tmp2.front();
						tmp1.pop_front(), tmp2.pop_front();

						if (l > r) {
							dp[i][j] = pre;
							break;
						}
						else if (l < r) {
							break;
						}
					}
				}
			}
		}
	}

	int mx = dp[n][m - 1].size();
	rep(i, mx) {
		int v = dp[n][m - 1].front(); dp[n][m - 1].pop_front();
		cout << v;
	}
}