Problem:
Problem A: Yu-kun Likes an Integer
Background
会津大学付属幼稚園はプログラミングが大好きな子供が集まる幼稚園である。園児の一人であるゆう君は、プログラミングと同じくらい数字が大好きだ。そんなゆう君は最近、表に0から9までのいずれかの数字の書かかれたプレートを
n
枚購入して
n
桁の数を作る遊びに熱中している。
今月もゆう君は貰ったお小遣いで
n
枚のプレートを買いに行こうと考えていた。
Problem
プレートは表に書かれている数字によって値段が異なる。
それらを使って作れる
n
桁の数をできる限り小さくしたい。
ゆう君の所持金額と各プレートの値段、購入するプレートの枚数が与えられるので、そこから作ることのできる数の最小値を求めよ。
購入するプレートの値段の総和が所持金額を超えなければ自由にプレートを購入できる。
同じ数字の書かれたプレートを複数枚購入しても良い。
プレートは必ず
n
枚購入しなければならない。
n
枚購入できない場合は "NA" と出力すること。
購入後は
n
枚のプレートを任意の順番で一直線上に並べる。
そうしてできる数字の列を10進数の数とし、その値が最小になるようにしたい。
先頭に1つ以上の0が連続していても良い。 ( 例えば 0019 なら 19 となり, 0000 なら 0 として考える )
図１は０、１、９のプレートを購入した場合についての説明である。
図1 : 0,1,9のプレートを購入した場合
Hint
この問題を解くに当たって、以下のことを参考にしても良い。
整数値を文字列に変換する方法を示す。
value を文字列として str に代入する。
Cの場合
#include<stdio.h>

int main(){
  int value = 123; // この値を文字列に変換する
  char str[6];     // この変数に value を文字列にしたものが入る
  sprintf(str,"%d",value);
  return 0;
}
C++の場合
#include<sstream>

using namespace std;

int main(){
  int value = 123; // この値を文字列に変換する
  string str;      // この変数に value を文字列にしたものが入る
  stringstream ss;
  ss << value;
  ss >> str;
  return 0;
}
JAVAの場合
class Main {
    public static void main(String args[]){
        int value = 123;           // この値を文字列に変換する
        String str = new Integer(value).toString(); // この変数に value を文字列にしたものが入る
    }
}
Input
n
m
c
0
c
1
c
2
...
c
9
１行目に２つの整数
n
,
m
が空白区切りで与えられる。
n
は購入するプレートの枚数,
m
はゆう君の所持金額を表す。
２行目には10個の整数が空白区切りで与えられる。
c
i
(
i
は0以上9以下 ) は表に
i
が書かれたプレートの値段を表す。
Constraints
入力は以下の条件を満たす。
1 ≤
n
≤ 5
0 ≤
m
≤ 500
1 ≤
c
i
≤ 1000 ( 0 ≤
i
≤ 9 )
Output
n
枚のプレートを購入し、それらを任意の順番で並べることでできる数の値の最小値を出力せよ。
先頭にいくつかの０を含む場合はそのまま出力すること。 ( 例えば答えが 0019 の場合は先頭の０を取り除いて 19 とするのではなく、そのまま 0019 と出力すること )
所持金額では
n
枚プレートを購入できない場合は "NA" と出力すること。
Sample Input 1
1 10
1 2 3 4 5 6 7 8 9 10
Sample Output 1
0
Sample Input 2
3 10
8 4 5 3 5 6 9 10 11 2
Sample Output 2
119
Sample Input 3
5 30
25 51 32 9 2 1 10 2 5 10
Sample Output 3
04555
Sample Input 4
5 100
101 101 101 101 101 101 101 101 101 101
Sample Output 4
NA

Submitted solutions:

code_snippet: #include<bits/stdc++.h>

using namespace std;

vector<vector<int> > combinations;

void gen(int idx, vector<int> &comb) {
    if (idx == 0) {
        combinations.push_back(comb);
        return;
    }
    for (int i = 0; i < 10; i++) {
        comb.push_back(i);
        gen(idx - 1, comb);
        comb.pop_back();
    }
}
void acc() {
    int n, m;
    cin >> n >> m;
    vector<int> cost(10);
    for (int i = 0; i < 10; i++) {
        cin >> cost[i];
    }
    vector<int>comb ; 
    gen(n, comb);
    std::sort(combinations.begin(), combinations.end());
    for (vector<int> comb: combinations) {
        int sum = 0;
        for (int digit: comb) {
            sum += cost[digit];
        }
        if (sum <= m) {
            for (int digit: comb) {
                cout << digit;
            }
            cout <<'\n';
            return;
        }
    }
    cout << "NA"<<'\n';
}

int main() {
    acc();
}
accuracy: 1
time_ms: 10
memory_kb: 9700
final_rank: 8

code_snippet: #include<bits/stdc++.h>

using namespace std;

vector<vector<int>> combinations;

void gen(int idx, vector<int> comb) {
    if (idx == 0) {
        combinations.push_back(comb);
        return;
    }
    for (int i = 0; i < 10; i++) {
        comb.push_back(i);
        gen(idx - 1, comb);
        comb.pop_back();
    }
}
void acc() {
    int n, m;
    cin >> n >> m;
    vector<int> cost(10);
    for (int i = 0; i < 10; i++) {
        cin >> cost[i];
    }
    gen(n, {});
    std::sort(combinations.begin(), combinations.end());
    for (auto comb: combinations) {
        int sum = 0;
        for (auto digit: comb) {
            sum += cost[digit];
        }
        if (sum <= m) {
            for (auto digit: comb) {
                cout << digit;
            }
            cout <<'\n';
            return;
        }
    }
    cout << "NA" << '\n';
}

int main() {
    acc();
}
accuracy: 1
time_ms: 10
memory_kb: 9436
final_rank: 6

code_snippet: #include<bits/stdc++.h>

using namespace std;
vector<vector<int>> combinations;

void gen(int idx, vector<int> comb) {
    if (idx == 0) {
        combinations.push_back(comb);
        return;
    }
    for (int i = 0; i < 10; i++) {
        comb.push_back(i);
        gen(idx - 1, comb);
        comb.pop_back();
    }
}

void acc() {
    int n, m;
    cin >> n >> m;
    vector<int> cost(10);
    for (int i = 0; i < 10; i++) {
        cin >> cost[i];
    }
    gen(n, {});
    std::sort(combinations.begin(), combinations.end());
    for (auto comb: combinations) {
        int sum = 0;
        for (auto digit: comb) {
            sum += cost[digit];
        }
        if (sum <= m) {
            for (auto digit: comb) {
                cout << digit;
            }
            cout <<'\n';
            return;
        }
    }
    cout << "NA" << '\n';
}

int main() {
    acc();
}
accuracy: 1
time_ms: 10
memory_kb: 9464
final_rank: 7

code_snippet: #include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <tuple>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>

typedef long long LL;

//container util
//------------------------------------------
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define DECIM8  fixed<<setprecision(8) 
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())

//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

//constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI  = acos(-1.0);

//clear memory
#define CLR(a) memset((a), 0 ,sizeof(a))

using namespace std;
bool canbuy(int n,vector<int> cost,int x,int money)
{
  if(n==0)
    if(money<0) return false;
    else return true;
  else
    return canbuy(n-1,cost,x/10,money-cost[x%10]);
}
void printn(int x,int n)
{
  if(n==0) return;
  else{
    printn(x/10,n-1);
    cout << x%10;
  }
  return;
}
int main(void)
{
  int n,m;
  cin >> n >> m;
  vector<int> cost;
  int costmin=1000;
  REP(i,10){
    int tmp;
    cin >> tmp;
    if(costmin>tmp) costmin=tmp;
    cost.PB(tmp);
  }
  if(m<costmin*n){
    cout << "NA" << endl;
    return 0;
  }
  int answer=0;
  for(;!canbuy(n,cost,answer,m);answer++);
  printn(answer,n);
  cout << endl;
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 1216
final_rank: 4

code_snippet: #include<bits/stdc++.h>
using namespace std;

string toString(int x, int k){
  stringstream ss;
  ss << x;
  string res = ss.str();
  while((int)res.size()<k)res = "0" + res;
  return res;
}

int main(){
  int n,m;
  int c[10];

  cin >> n >> m;
  for(int i=0;i<10;i++)cin >> c[i];

  int lim = 1;
  for(int i=0;i<n;i++)lim*=10;

  string ans = "NA";
  for(int x=0;x<lim;x++){
    string s = toString(x,n);
    int sum = 0;
    for(int i=0;i<n;i++){
      sum += c[s[i]-'0'];
    }
    if(sum<=m){
      ans = s; break;
    }
  }

  cout << ans << endl;
}
accuracy: 1
time_ms: 50
memory_kb: 1224
final_rank: 5

code_snippet: #include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>	// require sort next_permutation count __gcd reverse etc.
#include <cstdlib>	// require abs exit
#include <cstdio>	// require scanf printf
#include <functional>
#include <numeric>	// require accumulate
#include <cmath>
#include <climits>
#include <limits>
#include <cfloat>
#include <iomanip>	// require setw
#include <sstream>	// require stringstream 
#include <cstring>	// require memset
#include <cctype>	// require tolower, toupper
#include <fstream>	// require freopen
#include <ctime>
#define rep(i,n) for(int i=0;i<(n);i++)
#define ALL(A) A.begin(), A.end()
#define INF 1<<29
#define EPS 1e-9
#define each(i,c) for(auto i=(c).begin();i!=(c).end();++i)
#define exist(s,e) ((s).find(e)!=(s).end())
#define clr(a) memset((a),0,sizeof(a))
#define nclr(a) memset((a),-1,sizoef(a))
#define sz(s) (int)((s).size())
#define INRANGE(x,s,e) ((s)<=(x) && (x)<(e))
#define pb push_back
#define MP(x,y) make_pair((x),(y))
#define DEBUG 0

using namespace std;

typedef long long ll;
typedef pair<int, int> P;
string FILE_NAME = "testcase.A";
string NAME;
string itos (int n )
{
	stringstream ss;
	ss << n;

	return ss.str();
}

string i2s (int n, int digit )
{
	stringstream ss;
	ss << n;
	string s = ss.str();
	while (s.length() < digit ){
		s = '0' + s;
	} // end while

	return s;
}

int c[10];

int main()
{
//	cut here before submit 
#if DEBUG
	NAME = FILE_NAME;
	int CNT = 1;
	NAME += itos (CNT );
	while (freopen (NAME.c_str() , "r", stdin ) != NULL ) {
#endif
	memset (c, 0, sizeof (c ) );
	ios_base::sync_with_stdio(0);
	int n, m; cin >> n >> m;
	rep (i, 10 ) cin >> c[i];
	string res = "";

	rep (i, pow(10, n ) ){
		string num = i2s(i, n );
		int curr = 0;
		rep (j, num.length() ){
			curr += c[(int)(num[j] - '0')];
		} // end rep
		if (num.length() == n && curr <= m ){
			res = num;
			break;
		} // end if
	} // end rep
	
	cout << (res.empty() ? "NA" : res ) << endl;

#if DEBUG
	CNT++;	// cut here before submit
	NAME = FILE_NAME;
	NAME += itos (CNT );
	} // end loop; cut here before submit
#endif			
	return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 1268
final_rank: 9

code_snippet: #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
#include <iomanip>
#include <fstream>
#include <bitset>

using namespace std;

#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
template <typename T> void print_container(ostream& os, const T& c) { const char* _s = " "; if (!c.empty()) { __typeof__(c.begin()) last = --c.end(); foreach (it, c) { os << *it; if (it != last) os << _s; } } }
template <typename T> ostream& operator<<(ostream& os, const vector<T>& c) { print_container(os, c); return os; }
template <typename T> ostream& operator<<(ostream& os, const set<T>& c) { print_container(os, c); return os; }
template <typename T> ostream& operator<<(ostream& os, const multiset<T>& c) { print_container(os, c); return os; }
template <typename T> ostream& operator<<(ostream& os, const deque<T>& c) { print_container(os, c); return os; }
template <typename T, typename U> ostream& operator<<(ostream& os, const map<T, U>& c) { print_container(os, c); return os; }
template <typename T, typename U> ostream& operator<<(ostream& os, const pair<T, U>& p) { os << "(" << p.first << ", " << p.second << ")"; return os; }

template <typename T> void print(T a, int n, const string& split = " ") { for (int i = 0; i < n; i++) { cout << a[i]; if (i + 1 != n) cout << split; } cout << endl; }
template <typename T> void print2d(T a, int w, int h, int width = -1, int br = 0) { for (int i = 0; i < h; ++i) { for (int j = 0; j < w; ++j) { if (width != -1) cout.width(width); cout << a[i][j] << ' '; } cout << endl; } while (br--) cout << endl; }
template <typename T> void input(T& a, int n) { for (int i = 0; i < n; ++i) cin >> a[i]; }
#define dump(v) (cerr << #v << ": " << v << endl)

#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define erep(i, n) for (int i = 0; i <= (int)(n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define clr(a, x) memset(a, x, sizeof(a))
#define sz(a) ((int)(a).size())
#define mp(a, b) make_pair(a, b)
#define ten(n) ((long long)(1e##n))

template <typename T, typename U> void upmin(T& a, const U& b) { a = min<T>(a, b); }
template <typename T, typename U> void upmax(T& a, const U& b) { a = max<T>(a, b); }
template <typename T> void uniq(T& a) { sort(a.begin(), a.end()); a.erase(unique(a.begin(), a.end()), a.end()); }
template <class T> string to_s(const T& a) { ostringstream os; os << a; return os.str(); }
template <class T> T to_T(const string& s) { istringstream is(s); T res; is >> res; return res; }
void fast_io() { cin.tie(0); ios::sync_with_stdio(false); }
bool in_rect(int x, int y, int w, int h) { return 0 <= x && x < w && 0 <= y && y < h; }

typedef long long ll;
typedef pair<int, int> pint;

const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };



int n, m, c[10];
int b[5];
string res;
void dfs(int depth)
{
    if (depth == n)
    {
        string num;
        int sum = 0;
        rep(i, n)
        {
            sum += c[b[i]];
            num += b[i] + '0';
        }
        if (sum <= m)
            upmin(res, num);
        return;
    }

    rep(i, 10)
    {
        b[depth] = i;
        dfs(depth + 1);
    }
}
int main()
{
    cin >> n >> m;
    input(c, 10);

    res = "@";
    dfs(0);
    cout << (res == "@" ? "NA" : res) << endl;
}
accuracy: 1
time_ms: 20
memory_kb: 1208
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
#define tpl(...) make_tuple(__VA_ARGS__)
const int INF = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1);
typedef long long ll;
typedef pair<int,int> pii;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T>ostream&operator<<(ostream &o,const vector<T>&t){o<<'[';FOR(i,t){if(i!=t.begin())o<<',';o<<*i;}return o<<']';}
template<class S,class T>ostream&operator<<(ostream &o,const pair<S,T>&t){return o<<'('<<t.first<<','<<t.second<<')';}
template<int N,class Tp>void output(ostream&,const Tp&){}
template<int N,class Tp,class,class ...Ts>void output(ostream &o,const Tp&t){if(N)o<<',';o<<get<N>(t);output<N+1,Tp,Ts...>(o,t);}
template<class ...Ts>ostream&operator<<(ostream&o,const tuple<Ts...>&t){o<<'(';output<0,tuple<Ts...>,Ts...>(o,t);return o<<')';}
template<class T>void output(T t,char z=10){if(t<0)t=-t,putchar(45);int c[20];
int k=0;while(t)c[k++]=t%10,t/=10;for(k||(c[k++]=0);k;)putchar(c[--k]^48);putchar(z);}
template<class T>void outputs(T t){output(t);}
template<class S,class ...T>void outputs(S a,T...t){output(a,32);outputs(t...);}
template<class T>void output(T *a,int n){REP(i,n)output(a[i],i!=n-1?',':10);}
template<class T>void output(T *a,int n,int m){REP(i,n)output(a[i],m);}
template<class T>bool input(T &t){int n=1,c;for(t=0;!isdigit(c=getchar())&&~c&&c-45;);
if(!~c)return 0;for(c-45&&(n=0,t=c^48);isdigit(c=getchar());)t=10*t+c-48;t=n?-t:t;return 1;}
template<class S,class ...T>bool input(S&a,T&...t){input(a);return input(t...);}

int a[10];
int n,m;
string anss;
ll ansv;
void dfs(int num, int cost, ll sm, string s) {
  // cout << num << " " << cost << " " << sm << " " << s << endl;
  if (num == n) {
    if (cost <= m) {
      if (chmin(ansv, sm)) {
        anss = s;
      }
    }
    return;
  }
  REP(i,10) {
    dfs(num+1, cost+a[i], sm*10+i, s+string(1,i+'0'));
  }
}

int main() {
  while(cin>>n>>m) {
    REP(i,10) input(a[i]);
    ansv = 1LL<<60;
    dfs(0, 0, 0, "");
    // cout << ansv << endl;
    if (ansv == 1LL<<60)
      puts("NA");
    else
      cout << anss << endl;
    
  }
}
accuracy: 1
time_ms: 10
memory_kb: 1208
final_rank: 1

code_snippet: #include <iostream>
#include <vector>

using namespace std;

class range {
private:
  struct Iterator {
    int val;
    int operator*() {return val;}
    bool operator!=(Iterator &itr) {return val < itr.val;}
    void operator++() {++val;}
  };
  Iterator i, n;
public:
  range(int n) : i({0}), n({n}) {}
  range(int i, int n) : i({i}), n({n}) {}
  Iterator &begin() {return i;}
  Iterator &end() {return n;}
};

template<class T> T at(vector<T> v, int i) {return v[(i % (int)v.size() + v.size()) % v.size()];}

#include <sstream>

template<class A, class B> B convert(A a) {
  stringstream ss;
  ss << a;
  B b;
  ss >> b;
  return b;
}

int n, m, c[10];

const string INF = "999999";

string solve() {
  if (n == 0) {
    if (m >= 0) return "";
    return INF;
  }
  string res = INF;
  for (int i : range(10)) if (c[i] > 0) {
    --n;
    m -= c[i];
    string r = solve();
    if (r != INF) res = min(res, convert<int, string>(i) + r);
    m += c[i];
    ++n;
  }
  return res;
}

int main() {
  cin >> n >> m;
  for (int i : range(10)) cin >> c[i];
  string res = solve();
  if (res == INF) cout << "NA" << endl;
  else cout << res << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 1236
final_rank: 2