Problem:
Problem B: Potatoes
Problem
がっちょ君は
N
面の畑と
M
個の芋を所有している。各畑にはそれぞれ1から
N
までの番号が付けられている。がっちょ君は畑に芋を植え収穫することで、芋の数を増やしたいと考えている。
がっちょ君は一人暮らしであり、1人では
K
面までの畑しか管理することができない。また、各畑の土の状態や面積は様々で、芋の収穫数や植えることのできる芋の数も様々である。芋を畑
i
に植えた場合、1年後には畑
i
に植えた芋1つにつき
a
i
個の芋を収穫することができる。ただし、畑
i
には最大でも
b
i
個の芋しか植えることができない。
がっちょ君が
K
面以内の畑に
M
個以内の芋を植えた時、1年後に所有することができる芋の数の最大値を求めてほしい。
Input
入力は以下の形式で与えられる。
N
M
K
a
1
a
2
...
a
N
b
1
b
2
...
b
N
1行目に3個の整数
N
,
M
,
K
が空白区切りで与えられる。
2行目に
N
個の整数
a
i
が空白区切りで与えられる。
3行目に
N
個の整数
b
i
が空白区切りで与えられる。
Constraints
1 ≤
N
≤ 15
1 ≤
M
≤ 10
4
1 ≤
K
≤ min(
N
,3)
1 ≤
a
i
≤ 10
3
1 ≤
b
i
≤ 10
4
Output
芋の数の最大値を1行で出力せよ。
Sample Input 1
5 100 3
2 3 4 5 6
50 40 20 10 5
Sample Output 1
280
畑1に40個、畑2に40個、畑3に20個植えることで収穫後に280個の芋を所有することができる。
Sample Input 2
5 100 3
2 3 4 5 100
50 40 20 10 1
Sample Output 2
339
畑2に40個、畑3に20個、畑5に1個植えることで300個の芋を収穫することができ、植えなかった芋と合わせて答えは339になる。

Submitted solutions:

code_snippet: /*  -*- coding: utf-8 -*-
 *
 * 1588.cc: Potatoes
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MAX_N = 15;
const int MAX_M = 10000;
const int MAX_K = 3;

/* typedef */

/* global variables */

int as[MAX_N], bs[MAX_N];
int dp[MAX_N + 1][MAX_K + 1][MAX_M + 1];

/* subroutines */

inline void setmax(int &a, int b) { if (a < b) a = b; }

/* main */

int main() {
  int n, m, k;
  scanf("%d%d%d", &n, &m, &k);

  for (int i = 0; i < n; i++) scanf("%d", as + i);
  for (int i = 0; i < n; i++) scanf("%d", bs + i);

  memset(dp, -1, sizeof(dp));
  dp[0][0][0] = 0;

  for (int i = 0; i < n; i++) {
    int ai = as[i], bi = bs[i];
    memcpy(dp[i + 1], dp[i], sizeof(dp[i]));

    for (int j = 0; j < k; j++)
      for (int l = 0; l < m; l++)
	if (dp[i][j][l] >= 0) {
	  for (int c = 1; c <= bi && l + c <= m; c++)
	    setmax(dp[i + 1][j + 1][l + c], dp[i][j][l] + c * ai);
	}
  }

  int maxd = 0;
  for (int l = 0; l <= m; l++)
    setmax(maxd, dp[n][k][l] + (m - l));

  printf("%d\n", maxd);
  return 0;
}
accuracy: 0.13636363636363635
time_ms: 1000
memory_kb: 5792
final_rank: 7

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

#define int long long
#define pb push_back 
#define pf push_front 
#define mp make_pair
#define fr first
#define sc second
#define Rep(i,n) for(int i=0;i<(n);i++)
#define All(v) v.begin(),v.end()

typedef pair<int, int> Pii; typedef pair<int, Pii> Pip;
const int INF = 1107110711071107;

int N, M, K;
vector<Pii> ab;
int a[16], b[16];
int dp[16][10001][16];

int dfs(int n, int m, int k) {
  if ( n == N || k == K || m == 0 ) return m;
  if ( dp[n][m][k] >= 0 ) return dp[n][m][k];

  int a = ab[n].fr, b = ab[n].sc;
  return dp[n][m][k] = max(dfs(n+1, max(0LL, m-b), k+1) + min(m, b)*a, dfs(n+1, m, k));
}

signed main() {
  memset(dp, -1, sizeof(dp));
  cin >> N >> M >> K;
  Rep(i, N) cin >> a[i];
  Rep(i, N) cin >> b[i];
 
  Rep(i, N) {
    ab.pb(Pii(a[i], b[i]));
  }
  
  sort(All(ab), greater<Pii>());

  cout << dfs(0, M, 0) << endl;
  
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 23108
final_rank: 6

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <sstream>
#include <string>
#include <complex>
#include <cstdio>
using namespace std;

pair<int,int> a[15];

int main(){
	int n,m,K;
	cin >> n >> m >> K;
	long long sum = 0;
	for(int i = 0 ; i < n ; i++) cin >> a[i].first;
	for(int i = 0 ; i < n ; i++) cin >> a[i].second;
	long long w = 0;
	for(int k = 0 ; k < (1<<n) ; k++){
		if( __builtin_popcount(k) > K ) continue;
		vector<int> v;

		for(int i = 0 ; i < n ; i++){
			if( k >> i & 1 )
				for(int j = 0 ; j < a[i].second ; j++)
					v.push_back(a[i].first);
		}
		sort(v.rbegin(),v.rend());

		long long s = m - min<int>(v.size(),m);
		for(int i = 0 ; i < min<int>(v.size(),m) ; i++){
			//cout << v[i] << endl;
			s += v[i];
		}
		w = max(w,s);

	}
	cout << w << endl;
}
accuracy: 1
time_ms: 130
memory_kb: 3264
final_rank: 4

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

using namespace std;

typedef long long int64;

int main()
{
  int N, M, K, A[15], B[15], C[15];
  cin >> N >> M >> K;
  for(int i = 0; i < N; i++) {
    cin >> A[i];
  }
  for(int i = 0; i < N; i++) {
    cin >> B[i];
  }
  int ret = 0;
  for(int k = 0; k < (1 << N); k++) {
    if(__builtin_popcount(k) > K) continue;
    int cost = 0;
    for(int i = 0; i < N; i++) {
      C[i] = B[i];
    }
    int foo = M;
    while(foo > 0) {
      int curr = 0;
      for(int i = 0; i < N; i++) {
        if((k >> i) & 1 && C[i] > 0) {
          curr = max(curr, A[i]);
        }
      }
      if(curr == 0) break;
      cost += curr;
      for(int i = 0; i < N; i++) {
        if((k >> i) & 1 && C[i] > 0 && A[i] == curr) {
          --C[i];
          --foo;
          break;
        }
      }
    }
    ret = max(ret, cost + foo);
  }
  cout << ret << endl;
}
accuracy: 1
time_ms: 110
memory_kb: 1168
final_rank: 3

code_snippet: #include <iostream>
#include <algorithm>
#include <set>

using namespace std;
typedef pair<int,int> P;

int a[15];
int b[15];
int dp[16][10001]; //[????????°][????????°]->??????
set<P> S;

int main(){
    int N,M,K;
    cin>>N>>M>>K;
    for(int i=0;i<N;i++){
        cin>>a[i];
    }
    for(int i=0;i<N;i++){
        cin>>b[i];
    }

    for(int i=1;i<=N;i++){
        int ai=a[i-1],bi=b[i-1];
        for(int k=i;k>0;k--){
            S.clear();
            for(int n=0;n<bi;n++) S.insert(P(dp[k-1][10000-n]+n*ai,10000-n));
            for(int m=10000;m>=0;m--){
                S.erase(P(dp[k-1][m+1]+(10000-m-1)*ai,m+1));
                if(m-bi>=0) S.insert(P(dp[k-1][m-bi]+(10000-m+bi)*ai,m-bi));
                int maximum=(*S.rbegin()).first-(10000-((*S.rbegin()).second))*ai+(m-(*S.rbegin()).second)*ai;
                dp[k][m]=max(dp[k][m],maximum);
            }
        }
    }
    int ans=0;
    for(int m=0;m<=M;m++) ans=max(ans,dp[K][m]+M-m);
    cout<<ans<<endl;
    return 0;
}
accuracy: 1
time_ms: 180
memory_kb: 2248
final_rank: 5

code_snippet: #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <functional>

using namespace std;

#define int long long

#define fst first
#define scd second
#define PB push_back
#define MP make_pair
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define omajinai ios::sync_with_stdio(false);cin.tie(0)
#define rep(i,x) for(int i=0;i<(int)(x);++i)
#define rep1(i,x) for(int i=1;i<=(int)(x);++i)

typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;

template<typename T>T& max(T&a,T&b){if(a>=b)return a;return b;}
template<typename T>T& min(T&a,T&b){if(a<b)return a;return b;}
template<typename T>bool chmax(T&a,T b){if(a<b){a=b;return true;}return false;}
template<typename T>bool chmin(T&a,T b){if(a>b){a=b;return true;}return false;}
template<typename T>T get(){T a;cin>>a;return a;}
template<typename T>T rev(T a){reverse(all(a));return a;}
template<typename T>vector<T>&sort(vector<T>&a){sort(all(a));return a;}

const int inf = 1e9;
const ll linf = 3e18;
const double eps = 1e-9;

int a[20], b[20];

signed main()
{ // #define int long long ?????????????????§scanf???????????¨???????????????????????\?????????????????????
    int N, M, K; cin >> N >> M >> K;

    rep(i, N) cin >> a[i];
    rep(i, N) cin >> b[i];

    int ma = 0;

    rep(bit, 1<<N) {
        int cnt = 0;
        vpii choice;
        rep(i, N) {
            if (bit >> i & 1) cnt += 1, choice.PB(pii(a[i], b[i]));
        }

        if  (cnt != K) continue;

        sort(all(choice), greater<pii>());

        int sum = 0;

        int m = M;

        rep(i, K) {
            sum += choice[i].fst * min(m, choice[i].scd);
            m -= min(m, choice[i].scd);
        }

        sum += m;

        chmax(ma, sum);
    }

    cout << ma << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 1200
final_rank: 1

code_snippet: #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
const double PI  = 3.1415926535897932384626433832795028841971;
const int    INF = 100000000;
const double EPS = 1e-10;
const int    MOD = 1000000007;
using namespace std;
typedef long long ll;
typedef pair<int,int> P;

int n, m, k;
int a[15], b[15];
P c[15];

int main(){
	cin >> n >> m >> k;
    rep(i,n) cin >> a[i];
    rep(i,n) cin >> b[i];
    rep(i,n) c[i] = P(a[i],b[i]);
    int ans = 0;
    sort(c,c+n);
    rep(i,(1<<n)){
        int fl = 0, ii = i;
        vector<P> tmp;
        rep(j,n){
            if(ii&1){
                fl++;
                tmp.push_back(c[j]);
            }
            ii >>= 1;
        }
        if(fl > k) continue;
        sort(tmp.begin(),tmp.end(),greater<P>());
        int mm = m, cnt = 0;
        rep(j,tmp.size()){
            cnt += tmp[j].first*min(mm,tmp[j].second);
            mm -= tmp[j].second;
            if(mm <= 0) break;
        }
        ans = max(ans,cnt+max(mm,0));
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 1204
final_rank: 2