Problem:
D - Disciple Life is Hard / 弟子はつらいよ
Story
Dのひとはドーナツを愛してやまない。常にドーナツを欲している。しかし、師匠であるぶなしめじたんに体を鍛えることを命じられたDのひとは、摂取カロリーを制限しなければならない。そこでDのひとは基礎代謝も考慮し、その日トレーニングによって消費したカロリーの分までドーナツを食べてもよいことにした。Dのひとはドーナツを愛してやまないとはいえ、好みはあるので、食べるドーナツによって得られる幸福感は変わる。また、その日の体力によって行えるトレーニングも変わってくるため、トレーニングの種類、ドーナツの種類、体力を考慮し、
D
日間で得られる幸福を最大化することを試みた。
Problem
T
種類のトレーニングと
N
種類のドーナツのデータが与えられる。
i
番目のトレーニングに必要な体力は
e_i
、消費カロリーは
c_i
である。トレーニングは
1
日にちょうど
U
種類だけ行わなければならず、同じトレーニングは
1
日に
1
度しか行えない。トレーニングに必要な体力の総和はその日の体力以下でなければならない。その日の体力からトレーニングに必要な体力の総和を引いた差分は残った体力となり、翌日に引き継がれる。
j
番目のドーナツで得られる幸福度は
h_j
、摂取カロリーは
a_j
である。
1
日に同じドーナツを複数個食べてもよい。
1
日に得られる幸福は食べたドーナツの幸福度の和である。摂取カロリーの総和はその日のトレーニングによる消費カロリーの総和以下でなければならない。その日のトレーニングによる消費カロリーの総和から摂取カロリーの総和を引いた差分が余った消費カロリーとなるが、これは翌日に引き継がない。
体力の上限は
S
であり、毎日体力は
O
だけ回復する。初日の始めの体力は
S
である。
D
日間で得られる幸福の和の最大値を求めよ。どうやってもトレーニングをちょうど
U
回行えない日が生じる場合、-
1
と出力せよ。
Input
入力は以下の形式からなる。
S
T
U
N
O
D
e_1
c_1
...
e_T
c_T
h_1
a_1
...
h_N
a_N
1
行目は
6
つの整数からなり、それぞれ体力の上限
S
、トレーニングの種類
T
、
1
日に行うトレーニングの種類数
U
、ドーナツの種類
N
、
1
日に回復する体力量
O
、日数
D
が空白
1
文字区切りで並んでいる。 続く
T
行はトレーニングの情報を表す。
i+1
行目(
1 \leq i \leq T
)は
2
つの整数からなり、それぞれトレーニングに必要な体力
e_i
、消費カロリー
c_i
が空白
1
文字区切りで並んでいる。 続く
N
行はドーナツの情報を表す。
j+T+1
行目(
1 \leq j \leq N
)は
2
つの整数からなり、それぞれ得られる幸福度
h_j
、摂取カロリー
a_j
が空白
1
文字区切りで並んでいる。
制約:
1 \leq O \leq S \leq 100
1 \leq U \leq T \leq 100
1 \leq N \leq 100
1 \leq D \leq 100
1 \leq e_i, c_i, h_j, a_j \leq 100
Output
D
日間で得られる幸福の総和の最大値を
1
行に出力せよ。 ただし、どうやってもトレーニングをちょうど
U
回行えない日が生じる場合、-
1
と出力せよ。 行の最後では必ず改行を行うこと。
Sample Input 1
10 1 1 1 4 3
6 10
5 8
Sample Output 1
15
1日目は1番目のトレーニングを行い1番目のドーナツを食べることで、体力が残り4、幸福度5を得る。 2日目はまず体力が4回復し、8となる。 1番目のトレーニングを行い1番目のドーナツを食べることで、体力が残り2、幸福度5を得る。 3日目はまず体力が4回復し、6となる。 1番目のトレーニングを行い1番目のドーナツを食べることで、体力が残り0、幸福度5を得る。 よって、3日間合計で幸福15を得る。
Sample Input 2
10 3 2 3 3 2
4 10
3 4
3 5
3 4
4 5
5 7
Sample Output 2
19
1日目に1,3番目とのトレーニングを行うと、体力が残り3、消費カロリーが15となる。 2番目のドーナツを3個食べることで、摂取カロリーが15で幸福が12得られる。 2日目にはまず体力が3回復し、6となる。 2,3番目とのトレーニングを行うと、体力が残り0、消費カロリーが9となる。 1番目のトレーニングだけ行った方が多くのカロリーを消費でき、体力も多く残るが、1日には必ず2種類のトレーニングを行う必要があるため、これはできない。 1,2番目のドーナツを1個ずつ食べると摂取カロリーが9で幸福が7得られる。 2日間の幸福の合計は19となり、これが最大である。
Sample Input 3
10 3 2 3 5 3
4 10
2 2
3 5
4 3
5 4
7 5
Sample Output 3
58
Sample Input 4
10 1 1 1 1 1
13 13
13 13
Sample Output 4
-1
体力の上限が10しかないため、体力が13必要なトレーニングを行うことができない。 よって、1日に行うべきトレーニングの種類数を満たすことができないため、-1を出力する。

Submitted solutions:

code_snippet: #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int S,T,U,N,O,D; cin >> S >> T >> U >> N >> O >> D;
    vector<int> e(T),c(T);
    for (int i = 0; i < T; ++i) {
        cin >> e[i] >> c[i];
    }
    vector<int> h(N),a(N);
    for (int i = 0; i < N; ++i) {
        cin >> h[i] >> a[i];
    }

    const int MX = 10001;
    // dp1[i]: i消費カロリーの時の幸福度の総和
    vector<int> dp1(MX);
    for (int i = 0; i < N; ++i) {
        for (int j = a[i]; j < MX; ++j) {
            dp1[j] = max(dp1[j], dp1[j-a[i]] + h[i]);
        }
    }
    // dp2[i]: 体力をi消化した時の消費カロリーの最大値
    // そもそも達成できない時は-1
    vector<int> dp2(MX);
    {
        vector<vector<int>> dp(U+1, vector<int>(MX,-1));
        dp[0][0] = 0;
        for (int i = 0; i < T; ++i) {
            for (int j = min(i, U-1); j >= 0; --j) {
                for (int k = e[i]; k < MX; ++k) {
                    if (dp[j][k-e[i]] == -1) continue;
                    dp[j+1][k] = max(dp[j+1][k], dp[j][k-e[i]] + c[i]);
                }
            }
        }
        dp2 = dp[U];
    }
    vector<int> dp(S+1, -1);
    dp[S] = 0;
    for (int i = 0; i < D; ++i) {
        vector<int> ndp(S+1, -1);
        for (int j = 0; j < S + 1; ++j) {
            if (dp[j] == -1) continue;
            for (int k = 0; k < j + 1; ++k) {
                if (dp2[k] == -1) continue;
                int nxt = min(S, j-k+O);
                ndp[nxt] = max(ndp[nxt], dp[j] + dp1[dp2[k]]);
            }
        }
        swap(dp, ndp);
    }
    sort(dp.begin(), dp.end());
    cout << dp.back() << endl;
}
accuracy: 1
time_ms: 30
memory_kb: 6928
final_rank: 2

code_snippet: #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>

using namespace std;

signed main(){
    
    int S, T, U, N, O, D; cin >> S >> T >> U >> N >> O >> D;
    vector<int> e(T);   
    vector<int> c(T);
    for(int i = 0; i < T; i++) cin >> e[i] >> c[i];

    vector<int> h(N);   
    vector<int> a(N);
    for(int i = 0; i < N; i++) cin >> h[i] >> a[i];
    
    
    vector<vector<vector<int>>> dp1(T + 1, vector<vector<int>> (U + 1, vector<int> (S + 1, -1)));
    dp1[0][0][0] = 0;

    vector<vector<int>> dp2(N + 1, vector<int> (1000005, 0));
    dp2[0][0] = 0;

    // 1
    for(int i = 0; i < T; i++){
        for(int j = 0; j <= U; j++){
            for(int k = 0; k <= S; k++){
                if(dp1[i][j][k] == -1) continue;
                // しない
                dp1[i + 1][j][k] = max(dp1[i + 1][j][k], dp1[i][j][k]);

                // 運動する
                if(j + 1 <= U && k + e[i] <= S)  dp1[i + 1][j + 1][k + e[i]] = max(dp1[i + 1][j + 1][k + e[i]], dp1[i][j][k] + c[i]);
            }
        }
    }
    
    /*
    for(int i = 0; i <= T; i++){
        for(int j = 0; j <= U; j++){
            for(int k = 0; k <= S; k++){
                cout << i << " " << j << " " << k << " " << dp1[i][j][k] << endl;
           }
        }
    }
    */

    for(int i = 0; i < N; i++){
        for(int j = 0; j <= 100000; j++){
            if(j < a[i]){
                dp2[i + 1][j] = dp2[i][j];
            }else{
                dp2[i + 1][j] = max(dp2[i][j], dp2[i + 1][j - a[i]] + h[i]);
            }
        }
    }
    
    for(int j = 1; j <= 100000; j++) dp2[N][j] = max(dp2[N][j], dp2[N][j - 1]);

    /*
    cout << endl;
    cout << endl;
    for(int i = 0; i <= N; i++){
        for(int j = 0; j <= 20; j++){
            cout << dp2[i][j] << " ";
        }
        cout << endl;
    }

    cout << endl;
    */
    
    vector<vector<int>> dp(D + 1, vector<int> (S + 1, -1));
    dp[0][S] = 0;
    
    for(int i = 0; i < D; i++){
        for(int j = 0; j <= S; j++){
            if(dp[i][j] == -1) continue;
            int cur = min(S, j + O);
            
            for(int use = 0; use <= cur; use++){
//                cout << i << " " << j << " " << use << endl;
                int nxt = cur - use;
                int cal = dp1[T][U][use];
                if(cal == -1) continue;
                int add = dp2[N][cal];
                dp[i + 1][nxt] = max(dp[i + 1][nxt], dp[i][j] + add);
            }
        }
    }
    

    int ans = -1;
    for(int i = 0; i <= S; i++) ans = max(ans, dp[D][i]);
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 405748
final_rank: 7

code_snippet: #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>

using namespace std;
#define int long long int

signed main(){
    
    int S, T, U, N, O, D; cin >> S >> T >> U >> N >> O >> D;
    vector<int> e(T);   
    vector<int> c(T);
    for(int i = 0; i < T; i++) cin >> e[i] >> c[i];

    vector<int> h(N);   
    vector<int> a(N);
    for(int i = 0; i < N; i++) cin >> h[i] >> a[i];
    

    vector<vector<vector<int>>> dp1(T + 1, vector<vector<int>> (U + 1, vector<int> (S + 1, -1)));
    dp1[0][0][0] = 0;

    vector<vector<int>> dp2(N + 1, vector<int> (1000005, 0));
    dp2[0][0] = 0;

    // 1
    for(int i = 0; i < T; i++){
        for(int j = 0; j <= U; j++){
            for(int k = 0; k <= S; k++){
                if(dp1[i][j][k] == -1) continue;
                // しない
                dp1[i + 1][j][k] = max(dp1[i + 1][j][k], dp1[i][j][k]);

                // 運動する
                if(j + 1 <= U && k + e[i] <= S)  dp1[i + 1][j + 1][k + e[i]] = max(dp1[i + 1][j + 1][k + e[i]], dp1[i][j][k] + c[i]);
            }
        }
    }
    
    /*
    for(int i = 0; i <= T; i++){
        for(int j = 0; j <= U; j++){
            for(int k = 0; k <= S; k++){
                cout << i << " " << j << " " << k << " " << dp1[i][j][k] << endl;
           }
        }
    }
    */

    for(int i = 0; i < N; i++){
        for(int j = 0; j <= 100000; j++){
            if(j < a[i]){
                dp2[i + 1][j] = dp2[i][j];
            }else{
                dp2[i + 1][j] = max(dp2[i][j], dp2[i + 1][j - a[i]] + h[i]);
            }
        }
    }
    
    for(int j = 1; j <= 100000; j++) dp2[N][j] = max(dp2[N][j], dp2[N][j - 1]);

    /*
    cout << endl;
    cout << endl;
    for(int i = 0; i <= N; i++){
        for(int j = 0; j <= 20; j++){
            cout << dp2[i][j] << " ";
        }
        cout << endl;
    }

    cout << endl;
    */
    
    vector<vector<int>> dp(D + 1, vector<int> (S + 1, -1));
    dp[0][S] = 0;
    
    for(int i = 0; i < D; i++){
        for(int j = 0; j <= S; j++){
            if(dp[i][j] == -1) continue;
            int cur = min(S, j + O);
            
            for(int use = 0; use <= cur; use++){
//                cout << i << " " << j << " " << use << endl;
                int nxt = cur - use;
                int cal = dp1[T][U][use];
                if(cal == -1) continue;
                int add = dp2[N][cal];
                dp[i + 1][nxt] = max(dp[i + 1][nxt], dp[i][j] + add);
            }
        }
    }
    

    int ans = 0;
    for(int i = 0; i <= S; i++) ans = max(ans, dp[D][i]);
    cout << ans << endl;
    return 0;
}
accuracy: 0.03571428571428571
time_ms: 10
memory_kb: 41880
final_rank: 13

code_snippet: #include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;

struct Info{
	int need,value;
};

struct Data{
	int happiness,cost;
};

struct LOC{
	LOC(int arg_num,int arg_HP){
		num = arg_num;
		HP = arg_HP;
	}
	int num,HP;
};

int dp[101][10001],next_dp[101][10001];
int max_hp[101],next_max_hp[101];
int dp_2[10001];
int dp_3[10001];
int dp_4[101][101];

int main(){

	int S,T,U,N,O,D;
	scanf("%d %d %d %d %d %d",&S,&T,&U,&N,&O,&D);

	Info info[T];
	for(int i = 0; i < T; i++){
		scanf("%d %d",&info[i].need,&info[i].value);
	}

	Data data[N];
	for(int i = 0; i < N; i++){
		scanf("%d %d",&data[i].happiness,&data[i].cost);
	}

	for(int i = 0; i <= U; i++){
		for(int k = 0; k <= 10000; k++){
			dp[i][k] = -1;
			next_dp[i][k] = -1;
		}
	}

	for(int i = 0; i <= U; i++){
		max_hp[i] = 0;
		next_max_hp[i] = 0;
	}

	dp[0][0] = 0;
	next_dp[0][0] = 0;

	vector<LOC> Updated;
	int max_num = 0,next_max_num = 0;

	for(int i = 0; i < T; i++){
		for(int k = 0; k <= min(U-1,max_num); k++){
			for(int hp = 0; hp <= min(10000-info[i].need,max_hp[k]); hp++){
				if(dp[k][hp] == -1)continue;

				if(next_dp[k+1][hp+info[i].need] < dp[k][hp]+info[i].value){
					next_dp[k+1][hp+info[i].need] = dp[k][hp]+info[i].value;
					next_max_hp[k+1] = max(next_max_hp[k+1],hp+info[i].need);
					Updated.push_back(LOC(k+1,hp+info[i].need));
					next_max_num = max(next_max_num,k+1);
				}
			}
		}
		for(int k = 0; k < Updated.size(); k++){
			dp[Updated[k].num][Updated[k].HP] = next_dp[Updated[k].num][Updated[k].HP];
		}
		Updated.clear();
		for(int k = 0; k <= U; k++){
			max_hp[k] = next_max_hp[k];
		}
		max_num = next_max_num;
	}

	for(int i = 0; i <= 10000; i++){
		dp_2[i] = -1;
	}

	dp_2[0] = 0;
	for(int i = 0; i < N; i++){
		for(int k = 0; k <= 10000-data[i].cost; k++){
			if(dp_2[k] == -1)continue;
			dp_2[k+data[i].cost] = max(dp_2[k+data[i].cost],dp_2[k]+data[i].happiness);
		}
	}

	for(int i = 1; i <= 10000; i++){
		if(dp_2[i-1] > dp_2[i])dp_2[i] = dp_2[i-1];
	}

	for(int i = 0; i <= 10000; i++)dp_3[i] = 0;

	for(int i = 0; i <= 10000; i++){
		if(dp[U][i] != -1){
			dp_3[i] = max(dp_3[i],dp_2[dp[U][i]]);
		}
	}

	for(int day = 0; day <= D; day++){
		for(int hp = 0; hp <= S; hp++)dp[day][hp] = -1;
	}

	dp[0][S] = 0 ;
	int next_HP;

	for(int day = 0; day < D; day++){
		for(int hp = 1; hp <= S; hp++){
			if(dp[day][hp] == -1)continue;

			for(int use = 0; use <= hp; use++){
				if(dp_3[use] > 0){
					next_HP = min(S,hp-use+O);
					dp[day+1][next_HP] = max(dp[day+1][next_HP],dp[day][hp]+dp_3[use]);
				}
			}
		}
	}

	int maximum = -1;
	for(int hp = 0; hp <= S; hp++){
		maximum = max(maximum,dp[D][hp]);
	}

	printf("%d\n",maximum);

	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 12672
final_rank: 3

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

int d[111][111],dp[111][111],dd[1111111];
int main() {
  int s,n,u,m,o,t;
  cin >> s >> n >> u >> m >> o >> t;
  memset(d,-1,sizeof(d));
  d[0][0]=0;
  for(int i=0; i<n; i++) {
    int x,y;
    cin >> x >> y;
    for(int k=u-1; k>=0; k--) {
      for(int j=s-1; j>=0; j--) {
        if(j+x<=s&&d[j][k]!=-1) d[j+x][k+1]=max(d[j+x][k+1],d[j][k]+y);
      }
    }
  }
  fill(dd,dd+1111111,-(1<<29));
  dd[0]=0;
  for(int i=0; i<m; i++) {
    int x,y;
    cin >> x >> y;
    for(int j=0; j<1111111; j++) {
      if(j+x<1111111) dd[j+y]=max(dd[j+y],dd[j]+x);
    }
  }
  for(int i=1; i<1111111; i++) dd[i]=max(dd[i],dd[i-1]);
  memset(dp,-1,sizeof(dp));
  dp[0][s]=0;
  for(int i=0; i<t; i++) {
    for(int j=0; j<=s; j++) {
      if(dp[i][j]==-1) continue;
      int r=min(s,j+o);
      for(int k=0; k<=s; k++) {
        if(r-k<0) break;
        if(d[k][u]==-1) continue;
        dp[i+1][r-k]=max(dp[i+1][r-k],dp[i][j]+dd[d[k][u]]);
      }
    }
  }
  int ans=-1;
  for(int i=0; i<=s; i++) ans=max(ans,dp[t][i]);
  cout << ans << endl;
  return 0;
}
accuracy: 1
time_ms: 110
memory_kb: 7536
final_rank: 4

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
int S, N, U, M, V, D;//?????????HP, ?????¬???????????°?????°, ?????\??????????????°, ?????????????????°, ?????\????????????????????????
int e[200], c[200], h[200], a[200];
int dp[200][200][600], dp2[100000], dp3[600], dp4[200][200];
int main() {
	cin >> S >> N >> U >> M >> V >> D;
	for (int i = 0; i < N; i++)cin >> e[i] >> c[i];
	for (int i = 0; i < M; i++)cin >> h[i] >> a[i];
	for (int i = 0; i < 200; i++) { for (int j = 0; j < 200; j++) { for (int k = 0; k < 200; k++) { dp[i][j][k] = -999999999; } } }
	dp[0][0][0] = 0;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			for (int k = 0; k < 600; k++) {
				if (dp[i][j][k] < 0 || k + e[i] >= 600)continue;
				dp[i + 1][j + 1][k + e[i]] = max(dp[i + 1][j + 1][k + e[i]], dp[i][j][k] + c[i]);
				dp[i + 1][j][k] = max(dp[i + 1][j][k], dp[i][j][k]);
			}
		}
	}
	for (int i = 0; i < 600; i++)dp3[i] = dp[N][U][i];
	for (int i = 1; i < 600; i++)dp3[i] = max(dp3[i], dp3[i - 1]);
	for (int i = 0; i < M; i++) {
		for (int j = 0; j < 100000; j++) {
			if (j + a[i] >= 100000)continue;
			dp2[j + a[i]] = max(dp2[j + a[i]], dp2[j] + h[i]);
		}
	}
	for (int i = 0; i < 200; i++) { for (int j = 0; j < 200; j++)dp4[i][j] = -999999999; }
	dp4[0][S] = 0;
	for (int i = 0; i < D; i++) {
		for (int j = 0; j <= S; j++) {
			for (int k = 0; k <= j; k++) {
				if (dp3[k] < 0)continue;
				int HP = min(S, j - k + V);
				dp4[i + 1][HP] = max(dp4[i + 1][HP], dp4[i][j] + dp2[dp3[k]]);
			}
		}
	}
	int maxn = -999999999; for (int i = 0; i <= S; i++)maxn = max(maxn, dp4[D][i]);
	if (maxn < 0)maxn = -1;
	cout << maxn << endl;
	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 97432
final_rank: 5

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
int S, N, U, M, V, D;//?????????HP, ?????¬???????????°?????°, ?????\??????????????°, ?????????????????°, ?????\????????????????????????
int e[200], c[200], h[200], a[200];
int dp[200][200][200], dp2[100000], dp3[200], dp4[200][200];
int main() {
	cin >> S >> N >> U >> M >> V >> D;
	for (int i = 0; i < N; i++)cin >> e[i] >> c[i];
	for (int i = 0; i < M; i++)cin >> h[i] >> a[i];
	for (int i = 0; i < 200; i++) { for (int j = 0; j < 200; j++) { for (int k = 0; k < 200; k++) { dp[i][j][k] = -999999999; } } }
	dp[0][0][0] = 0;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			for (int k = 0; k < 200; k++) {
				if (dp[i][j][k] < 0 || k + e[i] >= 200)continue;
				dp[i + 1][j + 1][k + e[i]] = max(dp[i + 1][j + 1][k + e[i]], dp[i][j][k] + c[i]);
				dp[i + 1][j][k] = max(dp[i + 1][j][k], dp[i][j][k]);
			}
		}
	}
	for (int i = 0; i < 200; i++)dp3[i] = dp[N][U][i];
	for (int i = 0; i < M; i++) {
		for (int j = 0; j < 100000; j++) {
			if (j + a[i] >= 100000)continue;
			dp2[j + a[i]] = max(dp2[j + a[i]], dp2[j] + h[i]);
		}
	}
	for (int i = 0; i < 200; i++) { for (int j = 0; j < 200; j++)dp4[i][j] = -999999999; }
	dp4[0][S] = 0;
	for (int i = 0; i < D; i++) {
		for (int j = 0; j <= S; j++) {
			for (int k = 0; k <= j; k++) {
				if (dp3[k] < 0)continue;
				int HP = min(S, j - k + V);
				dp4[i + 1][HP] = max(dp4[i + 1][HP], dp4[i][j] + dp2[dp3[k]]);
			}
		}
	}
	int maxn = -999999999; for (int i = 0; i <= S; i++)maxn = max(maxn, dp4[D][i]);
	if (maxn < 0)maxn = -1;
	cout << maxn << endl;
	return 0;
}
accuracy: 0.9523809523809523
time_ms: 20
memory_kb: 34932
final_rank: 9

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
int S, N, U, M, V, D;//?????????HP, ?????¬???????????°?????°, ?????\??????????????°, ?????????????????°, ?????\????????????????????????
int e[200], c[200], h[200], a[200];
int dp[200][200][200], dp2[100000], dp3[200], dp4[200][200];
int main() {
	cin >> S >> N >> U >> M >> V >> D;
	for (int i = 0; i < N; i++)cin >> e[i] >> c[i];
	for (int i = 0; i < M; i++)cin >> h[i] >> a[i];
	for (int i = 0; i < 200; i++) { for (int j = 0; j < 200; j++) { for (int k = 0; k < 200; k++) { dp[i][j][k] = -999999999; } } }
	dp[0][0][0] = 0;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			for (int k = 0; k < 200; k++) {
				if (dp[i][j][k] < 0 || k + e[i] >= 200)continue;
				dp[i + 1][j + 1][k + e[i]] = max(dp[i + 1][j + 1][k + e[i]], dp[i][j][k] + c[i]);
				dp[i + 1][j][k] = max(dp[i + 1][j][k], dp[i][j][k]);
			}
		}
	}
	for (int i = 0; i < 200; i++)dp3[i] = dp[N][U][i];
	for (int i = 0; i < M; i++) {
		for (int j = 0; j < 100000; j++) {
			if (j + a[i] >= 100000)continue;
			dp2[j + a[i]] = max(dp2[j + a[i]], dp2[j] + h[i]);
		}
	}
	for (int i = 0; i < 200; i++) { for (int j = 0; j < 200; j++)dp4[i][j] = -999999999; }
	dp4[0][S] = 0;
	for (int i = 0; i < D; i++) {
		for (int j = 0; j <= S; j++) {
			for (int k = 0; k <= j; k++) {
				if (dp3[k] < 0)continue;
				int HP = min(S, j - k + V);
				dp4[i + 1][HP] = max(dp4[i + 1][HP], dp4[i][j] + dp2[dp3[k]]);
			}
		}
	}
	int maxn = 0; for (int i = 0; i <= S; i++)maxn = max(maxn, dp4[D][i]);
	cout << maxn << endl;
	return 0;
}
accuracy: 0.03571428571428571
time_ms: 10
memory_kb: 34908
final_rank: 12

code_snippet: /*
 * 2578.cc: Disciple Life is Hard
 */

#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_S = 100;
const int MAX_T = 100;
const int MAX_U = 100;
const int MAX_N = 100;
const int MAX_O = 100;
const int MAX_D = 100;

/* typedef */

/* global variables */

int es[MAX_T], cs[MAX_T], hs[MAX_N], as[MAX_N];
int ems[MAX_S + 1], hms[MAX_S + 1];
int dpc[MAX_T + 1][MAX_S + 1], dph[2][MAX_S * MAX_N + 1], dp[2][MAX_S + 1];

/* subroutines */

/* main */

int main() {
  int s, t, u, n, o, d;
  cin >> s >> t >> u >> n >> o >> d;

  for (int i = 0; i < t; i++) cin >> es[i] >> cs[i];
  for (int i = 0; i < n; i++) cin >> hs[i] >> as[i];

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

  for (int i = 0; i < t; i++)
    for (int j = u - 1; j >= 0; j--)
      for (int k = s - es[i]; k >= 0; k--)
	if (dpc[j][k] >= 0) {
	  int j0 = j + 1;
	  int k0 = k + es[i];
	  int dp0 = dpc[j][k] + cs[i];
	  if (dpc[j0][k0] < dp0) dpc[j0][k0] = dp0;
	}

  int pmax = 0;
  for (int i = 1; i <= s; i++) {
    if (dpc[u][i] < pmax) dpc[u][i] = -1;
    else pmax = dpc[u][i];
  }
  //for (int i = 0; i <= s; i++) printf("%d ", dpc[u][i]); putchar('\n');

  memset(dph, -1, sizeof(dph));
  dph[0][0] = 0;
  int sn = s * n;
  int cur = 0, nxt = 1;
  
  for (int i = 0; i < n; i++) {
    memcpy(dph[nxt], dph[cur], sizeof(dph[cur]));
    int a = as[i], h = hs[i];

    while (a <= sn) {
      for (int j = sn - a; j >= 0; j--)
	if (dph[cur][j] >= 0) {
	  int j0 = j + a;
	  int dp0 = dph[cur][j] + h;
	  if (dph[nxt][j0] < dp0) dph[nxt][j0] = dp0;
	}
      a += as[i], h += hs[i];
    }

    cur ^= 1, nxt ^= 1;
  }

  for (int i = 1; i <= sn; i++)
    if (dph[cur][i] < dph[cur][i - 1]) dph[cur][i] = dph[cur][i - 1];

  //for (int i = 0; i <= sn; i++) printf("%d ", dph[cur][i]); putchar('\n');

  int m = 0;
  for (int i = 0; i <= s; i++)
    if (dpc[u][i] > 0) ems[m] = i, hms[m] = dph[cur][dpc[u][i]], m++;
  //for (int i = 0; i < m; i++) printf("%d %d\n", ems[i], hms[i]);

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

  for (int i = 0; i < d; i++) {
    memset(dp[nxt], -1, sizeof(dp[nxt]));

    for (int j = s; j >= 0; j--)
      if (dp[cur][j] >= 0)
	for (int k = 0; k < m; k++)
	  if (j >= ems[k]) {
	    int j0 = min(j - ems[k] + o, s);
	    int dp0 = dp[cur][j] + hms[k];
	    if (dp[nxt][j0] < dp0) dp[nxt][j0] = dp0;
	  }

    cur ^= 1, nxt ^= 1;
  }
  //for (int i = 0; i <= s; i++) printf("%d ", dp[cur][i]); putchar('\n');

  int maxh = -1;
  for (int i = 0; i <= s; i++)
    if (maxh < dp[cur][i]) maxh = dp[cur][i];
  printf("%d\n", maxh);
  return 0;
}
accuracy: 1
time_ms: 360
memory_kb: 1292
final_rank: 6

code_snippet: /*
 * 2578.cc: Disciple Life is Hard
 */

#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_S = 100;
const int MAX_T = 100;
const int MAX_U = 100;
const int MAX_N = 100;
const int MAX_O = 100;
const int MAX_D = 100;

/* typedef */

/* global variables */

int es[MAX_T], cs[MAX_T], hs[MAX_N], as[MAX_N];
int ems[MAX_S + 1], hms[MAX_S + 1];
int dpc[MAX_T + 1][MAX_S + 1], dph[2][MAX_S * MAX_N + 1], dp[2][MAX_S + 1];

/* subroutines */

/* main */

int main() {
  int s, t, u, n, o, d;
  cin >> s >> t >> u >> n >> o >> d;

  for (int i = 0; i < t; i++) cin >> es[i] >> cs[i];
  for (int i = 0; i < n; i++) cin >> hs[i] >> as[i];

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

  for (int i = 0; i < n; i++)
    for (int j = u - 1; j >= 0; j--)
      for (int k = s - es[i]; k >= 0; k--)
	if (dpc[j][k] >= 0) {
	  int j0 = j + 1;
	  int k0 = k + es[i];
	  int dp0 = dpc[j][k] + cs[i];
	  if (dpc[j0][k0] < dp0) dpc[j0][k0] = dp0;
	}

  int pmax = 0;
  for (int i = 1; i <= s; i++) {
    if (dpc[u][i] < pmax) dpc[u][i] = -1;
    else pmax = dpc[u][i];
  }
  //for (int i = 0; i <= s; i++) printf("%d ", dpc[u][i]); putchar('\n');

  memset(dph, -1, sizeof(dph));
  dph[0][0] = 0;
  int sn = s * n;
  int cur = 0, nxt = 1;
  
  for (int i = 0; i < n; i++) {
    memcpy(dph[nxt], dph[cur], sizeof(dph[cur]));
    int a = as[i], h = hs[i];

    while (a <= sn) {
      for (int j = sn - a; j >= 0; j--)
	if (dph[cur][j] >= 0) {
	  int j0 = j + a;
	  int dp0 = dph[cur][j] + h;
	  if (dph[nxt][j0] < dp0) dph[nxt][j0] = dp0;
	}
      a += as[i], h += hs[i];
    }

    cur ^= 1, nxt ^= 1;
  }

  for (int i = 1; i <= sn; i++)
    if (dph[cur][i] < dph[cur][i - 1]) dph[cur][i] = dph[cur][i - 1];

  //for (int i = 0; i <= sn; i++) printf("%d ", dph[cur][i]); putchar('\n');

  int m = 0;
  for (int i = 0; i <= s; i++)
    if (dpc[u][i] > 0) ems[m] = i, hms[m] = dph[cur][dpc[u][i]], m++;
  //for (int i = 0; i < m; i++) printf("%d %d\n", ems[i], hms[i]);

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

  for (int i = 0; i < d; i++) {
    memset(dp[nxt], -1, sizeof(dp[nxt]));

    for (int j = s; j >= 0; j--)
      if (dp[cur][j] >= 0)
	for (int k = 0; k < m; k++)
	  if (j >= ems[k]) {
	    int j0 = min(j - ems[k] + o, s);
	    int dp0 = dp[cur][j] + hms[k];
	    if (dp[nxt][j0] < dp0) dp[nxt][j0] = dp0;
	  }

    cur ^= 1, nxt ^= 1;
  }
  //for (int i = 0; i <= s; i++) printf("%d ", dp[cur][i]); putchar('\n');

  int maxh = -1;
  for (int i = 0; i <= s; i++)
    if (maxh < dp[cur][i]) maxh = dp[cur][i];
  printf("%d\n", maxh);
  return 0;
}
accuracy: 0.11904761904761904
time_ms: 70
memory_kb: 1292
final_rank: 11

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

int dp1[110][110];
int dp2[110][110][110];
int dp3[110][110*110];
int e[100],c[100],h[100],a[100];
int N;
int S;
int U;
int T;
int O;
int D;

int dfs(int t,int hp,int u){
	if( u < 0 ) return -1e9;
	if( hp < 0 ) return -1e9;
	if( t == -1 ) return u==0?0:-1e9;
	if( ~dp2[t][hp][u] ) return dp2[t][hp][u];
	int ans = -1e9;
	ans = max(ans,dfs(t-1,hp,u));
	ans = max(ans,dfs(t-1,hp-e[t],u-1)+c[t]);
	return dp2[t][hp][u] = ans;
}
int dfs3(int n,int hp){
	if( hp < 0 ) return -1e9;
	if( n < 0 ) return 0;
	if( ~dp3[n][hp] ) return dp3[n][hp];
	int ans = -1e9;
	ans = max(ans,dfs3(n,hp-a[n])+h[n]);
	ans = max(ans,dfs3(n-1,hp));
	return dp3[n][hp] = ans;
}
int dfs2(int d,int hp){
	if( hp < 0 ) return -1e9;
	if( d < 0 ) return 0;
	hp = min(S,hp+O);
	if( ~dp1[d][hp] ) return dp1[d][hp];

	int ans = -1e9;
	for(int i = 0 ; i <= hp ; i++)
		ans = max(ans,dfs2(d-1,hp-i) + dfs3(N-1,dfs(T-1,i,U)));
	return dp1[d][hp] = ans;
}

int main(){
	memset(dp1,-1,sizeof(dp1));
	memset(dp2,-1,sizeof(dp2));
	memset(dp3,-1,sizeof(dp3));
	cin >> S >> T >> U >> N >> O >> D;
	for(int i = 0 ; i < T ; i++){
		cin >> e[i] >> c[i];
	}
	for(int i = 0 ; i < N ; i++)
		cin >> h[i] >> a[i];
	cout << max(-1,dfs2(D-1,S)) << endl;
};
accuracy: 1
time_ms: 10
memory_kb: 11628
final_rank: 1

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

int dp1[110][110];
int dp2[110][110][110];
int dp3[110][110];
int e[100],c[100],h[100],a[100];
int N;
int S;
int U;
int T;
int O;
int D;

int dfs(int t,int hp,int u){
	if( u < 0 ) return -1e9;
	if( hp < 0 ) return -1e9;
	if( t == -1 ) return u==0?0:-1e9;
	if( ~dp2[t][hp][u] ) return dp2[t][hp][u];
	int ans = -1e9;
	ans = max(ans,dfs(t-1,hp,u));
	ans = max(ans,dfs(t-1,hp-e[t],u-1)+c[t]);
	return dp2[t][hp][u] = ans;
}
int dfs3(int n,int hp){
	if( hp < 0 ) return -1e9;
	if( n < 0 ) return 0;
	if( ~dp3[n][hp] ) return dp3[n][hp];
	int ans = -1e9;
	ans = max(ans,dfs3(n,hp-a[n])+h[n]);
	ans = max(ans,dfs3(n-1,hp));
	return dp3[n][hp] = ans;
}
int dfs2(int d,int hp){
	if( hp < 0 ) return -1e9;
	if( d < 0 ) return 0;
	hp = min(S,hp+O);
	if( ~dp1[d][hp] ) return dp1[d][hp];

	int ans = -1e9;
	for(int i = 0 ; i <= hp ; i++)
		ans = max(ans,dfs2(d-1,hp-i) + dfs3(N-1,dfs(T-1,i,U)));
	return dp1[d][hp] = ans;
}

int main(){
	memset(dp1,-1,sizeof(dp1));
	memset(dp2,-1,sizeof(dp2));
	memset(dp3,-1,sizeof(dp3));
	cin >> S >> T >> U >> N >> O >> D;
	for(int i = 0 ; i < T ; i++){
		cin >> e[i] >> c[i];
	}
	for(int i = 0 ; i < N ; i++)
		cin >> h[i] >> a[i];
	cout << max(-1,dfs2(D-1,S)) << endl;
};
accuracy: 0.9523809523809523
time_ms: 10
memory_kb: 6476
final_rank: 8

code_snippet: #include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<map>
#include<stack>
#include<cstring>
#include<cstdlib>
#include<cmath>

using namespace std;

#define reps(i,f,n) for(int i=f;i<int(n);i++)
#define rep(i,n) reps(i,0,n)

typedef pair<int,int> pii;

const int M = 111;
const int minf = -1000000000;

int dpt[10][M][M]={0};
int dp[M][M]={0};

int main(){
	
	int s,t,u,n,o,d;
	cin>>s>>t>>u>>n>>o>>d;
	
	vector<pii> train;
	rep(i,t){
		int e,c;
		cin>>e>>c;
		train.push_back(pii(e,c));
	}
	
	vector<pii> food;
	rep(i,n){
		int h,a;
		cin>>h>>a;
		food.push_back(pii(h,a));
	}
	
	int calmax = 0;
	int i1 = 0;
	int i2 = 1;
	//printf("enagy\n");
	rep(i,u+1){
		rep(j,s+1){
			rep(k,t+1){
				dpt[i2][j][k]=minf;
			}
		}
		if(i==0){
			dpt[i2][0][0]=0;
		}else{
			reps(k,1,t+1){
				rep(j,s+1){
					pii tr = train[k-1];
					int cost = tr.first;
					int value = tr.second;
					rep(p,k){
						if(j-cost<0)continue;
						dpt[i2][j][k]=max(dpt[i2][j][k], dpt[i1][j-cost][p]+value);
					}
					calmax = max(calmax, dpt[i2][j][k]);
				}
			}
		}
		
		/*rep(k,t+1){
			rep(j,s+1){
				if(dpt[i2][j][k]<0)printf(" -1 ");
				else printf("%3d ",dpt[i2][j][k]);
			}puts("");
		}puts("");
		*/swap(i1,i2);
	}
	
	//puts("happyness");
	vector<int> dpf(calmax+1);
	rep(i,calmax+1){
		rep(j,n){
			int pos = i-food[j].second;
			if(pos>=0)
				dpf[i] = max(dpf[i], dpf[pos]+food[j].first);
		}
		//printf("%3d ",dpf[i]);
	}//puts("");
	
	rep(i,M)rep(j,M)dp[i][j] = minf;
	dp[0][s]=0;
	
	
	int ans = -1;
	//printf("days\n");
	reps(i,1,d+1){
		rep(j,s+1){
			rep(k,s+1){
				reps(p,1,t+1){
					if(dpt[i1][k][p]<0)continue;
					int bef = j+k-o;
					if(j<o)continue;
					if(bef<0 || bef>s)continue;
					dp[i][j] = max(dp[i][j], dp[i-1][bef]+dpf[dpt[i1][k][p]]);
				}
			}
			ans = max(ans, dp[i][j]);
			//if(dp[i][j]<0)printf(" -1 ");
			//else printf("%3d ",dp[i][j]);
		}//puts("");
	}
	
	if(ans<0)ans=-1;
	printf("%d\n",ans);
}
accuracy: 0.11904761904761904
time_ms: 20
memory_kb: 1308
final_rank: 10