problem_id
stringlengths 6
6
| language
stringclasses 2
values | original_status
stringclasses 3
values | original_src
stringlengths 19
243k
| changed_src
stringlengths 19
243k
| change
stringclasses 3
values | i1
int64 0
8.44k
| i2
int64 0
8.44k
| j1
int64 0
8.44k
| j2
int64 0
8.44k
| error
stringclasses 270
values | stderr
stringlengths 0
226k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <stdio.h>
#include <string.h>
int N, W, dp[100][10005], v[105], w[105], i;
int dfs(int d, int nw) {
int r;
if (dp[d][nw] >= 0)
return dp[d][nw];
if (d == N)
r = 0;
else if (w[d] > nw)
r = dfs(d + 1, nw);
else
r = std::max(dfs(d + 1, nw), dfs(d + 1, nw - w[d]) + v[d]);
return dp[d][nw] = r;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d%d", &N, &W);
for (i = 0; i < N; i++)
scanf("%d%d", &v[i], &w[i]);
printf("%d\n", dfs(0, W));
return 0;
}
|
#include <algorithm>
#include <stdio.h>
#include <string.h>
int N, W, dp[105][20005], v[105], w[105], i;
int dfs(int d, int nw) {
int r;
if (dp[d][nw] >= 0)
return dp[d][nw];
if (d == N)
r = 0;
else if (w[d] > nw)
r = dfs(d + 1, nw);
else
r = std::max(dfs(d + 1, nw), dfs(d + 1, nw - w[d]) + v[d]);
return dp[d][nw] = r;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d%d", &N, &W);
for (i = 0; i < N; i++)
scanf("%d%d", &v[i], &w[i]);
printf("%d\n", dfs(0, W));
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int n, W, a, b;
vector<int> v;
vector<int> w;
int memo[100][10000];
int fun(int i, int sw) {
int temp;
if (memo[i][sw] >= 0)
return memo[i][sw];
if (i == n) {
temp = 0;
} else if (w[i] > sw) {
temp = fun(i + 1, sw);
} else {
temp = max(fun(i + 1, sw), fun(i + 1, sw - w[i]) + v[i]);
}
return memo[i][sw] = temp;
}
int main() {
cin >> n >> W;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
w.push_back(b);
v.push_back(a);
}
for (int i = 0; i < n + 1; ++i) {
for (int j = 0; j < W + 1; ++j) {
memo[i][j] = -1;
}
}
cout << fun(0, W) << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int n, W, a, b;
vector<int> v;
vector<int> w;
int memo[101][10001];
int fun(int i, int sw) {
int temp;
if (memo[i][sw] >= 0)
return memo[i][sw];
if (i == n) {
temp = 0;
} else if (w[i] > sw) {
temp = fun(i + 1, sw);
} else {
temp = max(fun(i + 1, sw), fun(i + 1, sw - w[i]) + v[i]);
}
return memo[i][sw] = temp;
}
int main() {
cin >> n >> W;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
w.push_back(b);
v.push_back(a);
}
for (int i = 0; i < n + 1; ++i) {
for (int j = 0; j < W + 1; ++j) {
memo[i][j] = -1;
}
}
cout << fun(0, W) << endl;
return 0;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
vector<int> v(N);
vector<int> w(W + 1);
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
vector<vector<int>> DP(N);
for (int i = 0; i < N; i++) {
DP[i].resize(W + 1);
fill(DP[i].begin(), DP[i].end(), 0);
}
DP[0][w[0]] = v[0];
for (int i = 1; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i]) {
DP[i][j] = DP[i - 1][j];
} else {
DP[i][j] = max(DP[i - 1][j - w[i]] + v[i], DP[i - 1][j]);
}
}
}
int maxVal = 0;
for (int i = 0; i <= W; i++) {
maxVal = max(DP[N - 1][i], maxVal);
}
cout << maxVal << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
vector<int> v(N);
vector<int> w(N);
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
vector<vector<int>> DP(N);
for (int i = 0; i < N; i++) {
DP[i].resize(W + 1);
fill(DP[i].begin(), DP[i].end(), 0);
}
DP[0][w[0]] = v[0];
for (int i = 1; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i]) {
DP[i][j] = DP[i - 1][j];
} else {
DP[i][j] = max(DP[i - 1][j - w[i]] + v[i], DP[i - 1][j]);
}
}
}
int maxVal = 0;
for (int i = 0; i <= W; i++) {
maxVal = max(DP[N - 1][i], maxVal);
}
cout << maxVal << endl;
return 0;
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
long long N, W, K, v[300], w[300];
long long dp[100][10100];
int main() {
cin >> N >> W;
for (int i = 1; i <= N; i++) {
cin >> v[i] >> w[i];
}
for (int i = 1; i <= W; i++)
dp[N + 1][i] = 0;
for (int i = N; i >= 1; i--) {
for (int j = 0; j <= W; j++) {
if (j < w[i])
dp[i][j] = dp[i + 1][j];
else
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i]);
}
}
/*
for(int i=1;i<=N;i++){
for(int j=0;j<=W;j++){
printf("%4d",dp[i][j]);
}
cout<<endl;
}
*/
cout << dp[1][W] << endl;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
long long N, W, K, v[300], w[300];
long long dp[1000][10100];
int main() {
cin >> N >> W;
for (int i = 1; i <= N; i++) {
cin >> v[i] >> w[i];
}
for (int i = 1; i <= W; i++)
dp[N + 1][i] = 0;
for (int i = N; i >= 1; i--) {
for (int j = 0; j <= W; j++) {
if (j < w[i])
dp[i][j] = dp[i + 1][j];
else
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i]);
}
}
/*
for(int i=1;i<=N;i++){
for(int j=0;j<=W;j++){
printf("%4d",dp[i][j]);
}
cout<<endl;
}
*/
cout << dp[1][W] << endl;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p02315
|
C++
|
Runtime Error
|
/**
* @brief 0-1ナップサック問題(0-1 knapsack problem)は次の問題である
*
* 泥棒がある店に盗みに入ってn個の品物を見つけた.
* i番目の品物はviドルの価値があり、重さはwiポンドである
* ただし、viとwiは整数である.
* 彼はできるだけ高価な品物を盗りたいが、彼のナップサックでは高々Wポンド(Wは整数)の荷物しか運べない
*
* 各品物は盗るか残すかのどちらかなので、この問題は0-1ナップサック問題と呼ばれる
* この泥棒は品物の一部だけを盗ったり、同じものを複数回盗ることはできない
*
* @note
* n個の各品物について、「盗る」か「残す」かの組み合わせをすべて調べるアルゴリズムの計算効率はΟ(2^n)となってしまい、
* 大きな入力nに対して解くことができないが、品物の大きさw,
* ナップサックの大きさWがともに整数であれば、
* 0-1ナップサック問題は動的計画法によりΟ(nW)の計算効率で厳密解を求めることができる
*
* @note 次のような変数を用意する
*
* v[n+1] i番目の品物の価値が記録されている1次元配列
* w[n+1] i番目の品物の重さが記録されている1次元配列
* C[n+1][W+1]
* i個目までの品物を考慮して大きさjのナップサックに入れる場合の価値の合計の最大値をC[i][j]とする2次元配列
*
* 考慮する品物の数i,
* 各iにおけるナップサックの重さjを増やしていき、C[i][j]を変更していく.
* C[i][j]の値は、
*
* 1. C[i - 1][j - 品物iの重さ] + 品物iの価値
* 2. C[i - 1][j]
*
* の大きい方となる.
* ここで1.はこの時点で品物iを盗る、2.はこの時点で品物iを残す、という処理に対応する
* ただし、1.の場合は、品物iの重さがjを超えない場合に限る
*
* @date 2016/05/05
*/
//********************************************************************************
// 必要なヘッダファイルのインクルード
//********************************************************************************
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <vector>
//********************************************************************************
// 型シノニム
//********************************************************************************
using index_t = int;
using value_t = int;
using weight_t = int;
using indices_t = std::vector<index_t>;
using values_t = std::vector<value_t>;
using weights_t = std::vector<weight_t>;
using dptbl_t = std::vector<values_t>;
//********************************************************************************
// 関数の定義
//********************************************************************************
/**
* @brief 動的計画法を用いて0-1ナップサック問題(0-1 knapsack problem)を解きます
*
* @param const value_t& v i番目の品物の価値が記録されている1次元配列v
* @param const value_t& w i番目の品物の重さが記録されている1次元配列w
* @param weight_t W ナップサックに詰めこめる最大の重さW
*/
value_t __01_knapsack__(const values_t &v, const weights_t &w, weight_t W) {
index_t n = v.size(); // n = v.length
dptbl_t C(n + 1, values_t(W + 1, 0)); // Cを(n+1) x (W+1)型の新しい行列とする
for (index_t i = 1; i <= n; i++) {
for (weight_t j = 1; j <= W; j++) {
if (w[i] <= j) {
C[i][j] = std::max(C[i - 1][j - w[i]] + v[i], C[i - 1][j]);
} else {
C[i][j] = C[i - 1][j];
}
}
}
return C[n][W];
}
//********************************************************************************
// エントリポイント
//********************************************************************************
int main() {
using namespace std;
int n, W;
cin >> n >> W;
values_t v(n);
weights_t w(n);
for (int i = 1; i <= n; i++) {
cin >> v[i] >> w[i];
}
cout << __01_knapsack__(v, w, W) << endl;
return 0;
}
|
/**
* @brief 0-1ナップサック問題(0-1 knapsack problem)は次の問題である
*
* 泥棒がある店に盗みに入ってn個の品物を見つけた.
* i番目の品物はviドルの価値があり、重さはwiポンドである
* ただし、viとwiは整数である.
* 彼はできるだけ高価な品物を盗りたいが、彼のナップサックでは高々Wポンド(Wは整数)の荷物しか運べない
*
* 各品物は盗るか残すかのどちらかなので、この問題は0-1ナップサック問題と呼ばれる
* この泥棒は品物の一部だけを盗ったり、同じものを複数回盗ることはできない
*
* @note
* n個の各品物について、「盗る」か「残す」かの組み合わせをすべて調べるアルゴリズムの計算効率はΟ(2^n)となってしまい、
* 大きな入力nに対して解くことができないが、品物の大きさw,
* ナップサックの大きさWがともに整数であれば、
* 0-1ナップサック問題は動的計画法によりΟ(nW)の計算効率で厳密解を求めることができる
*
* @note 次のような変数を用意する
*
* v[n+1] i番目の品物の価値が記録されている1次元配列
* w[n+1] i番目の品物の重さが記録されている1次元配列
* C[n+1][W+1]
* i個目までの品物を考慮して大きさjのナップサックに入れる場合の価値の合計の最大値をC[i][j]とする2次元配列
*
* 考慮する品物の数i,
* 各iにおけるナップサックの重さjを増やしていき、C[i][j]を変更していく.
* C[i][j]の値は、
*
* 1. C[i - 1][j - 品物iの重さ] + 品物iの価値
* 2. C[i - 1][j]
*
* の大きい方となる.
* ここで1.はこの時点で品物iを盗る、2.はこの時点で品物iを残す、という処理に対応する
* ただし、1.の場合は、品物iの重さがjを超えない場合に限る
*
* @date 2016/05/05
*/
//********************************************************************************
// 必要なヘッダファイルのインクルード
//********************************************************************************
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <vector>
//********************************************************************************
// 型シノニム
//********************************************************************************
using index_t = int;
using value_t = int;
using weight_t = int;
using indices_t = std::vector<index_t>;
using values_t = std::vector<value_t>;
using weights_t = std::vector<weight_t>;
using dptbl_t = std::vector<values_t>;
//********************************************************************************
// 関数の定義
//********************************************************************************
/**
* @brief 動的計画法を用いて0-1ナップサック問題(0-1 knapsack problem)を解きます
*
* @param const value_t& v i番目の品物の価値が記録されている1次元配列v
* @param const value_t& w i番目の品物の重さが記録されている1次元配列w
* @param weight_t W ナップサックに詰めこめる最大の重さW
*/
value_t __01_knapsack__(const values_t &v, const weights_t &w, weight_t W) {
index_t n = v.size(); // n = v.length
dptbl_t C(n + 1, values_t(W + 1, 0)); // Cを(n+1) x (W+1)型の新しい行列とする
for (index_t i = 1; i <= n; i++) {
for (weight_t j = 1; j <= W; j++) {
if (w[i] <= j) {
C[i][j] = std::max(C[i - 1][j - w[i]] + v[i], C[i - 1][j]);
} else {
C[i][j] = C[i - 1][j];
}
}
}
return C[n][W];
}
//********************************************************************************
// エントリポイント
//********************************************************************************
int main() {
using namespace std;
int n, W;
cin >> n >> W;
values_t v(n + 1);
weights_t w(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i] >> w[i];
}
cout << __01_knapsack__(v, w, W) << endl;
return 0;
}
|
replace
| 101 | 103 | 101 | 103 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repc(i, s, e) for (int i = (s); i < (e); i++)
#define pb(n) push_back((n))
#define mp(n, m) make_pair((n), (m))
#define all(r) r.begin(), r.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<ll> vl;
typedef vector<vl> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const int MAX_N = 110, MAX_W = 1010;
int dp[MAX_W];
int main() {
int n, W;
cin >> n >> W;
vi v(n, 0), w(n, 0);
rep(i, n) cin >> v[i] >> w[i];
for (int i = 0; i < n; i++) {
for (int j = W; j >= w[i]; j--) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
cout << dp[W] << endl;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repc(i, s, e) for (int i = (s); i < (e); i++)
#define pb(n) push_back((n))
#define mp(n, m) make_pair((n), (m))
#define all(r) r.begin(), r.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<ll> vl;
typedef vector<vl> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const int MAX_N = 110, MAX_W = 10010;
int dp[MAX_W];
int main() {
int n, W;
cin >> n >> W;
vi v(n, 0), w(n, 0);
rep(i, n) cin >> v[i] >> w[i];
for (int i = 0; i < n; i++) {
for (int j = W; j >= w[i]; j--) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
cout << dp[W] << endl;
}
|
replace
| 37 | 38 | 37 | 38 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define all(a) a.begin(), a.end()
typedef long long ll;
using P = pair<ll, ll>;
#define v first
#define w second
// v高い順（vが同じならw軽い方優先）
bool comp(P a, P b) { return a.v == b.v ? a.w < b.w : a.v > b.v; }
int main(void) {
int N, W;
cin >> N >> W;
vector<P> a(N);
rep(i, N) {
ll v, w;
cin >> v >> w;
a[i] = {v, w};
}
vector<P> dp = {{0, 0}};
rep(i, N) {
vector<P> tmp;
for (auto &s : dp) {
tmp.push_back(s);
tmp.push_back({s.v + a[i].v, s.w + a[i].w});
}
sort(all(tmp), comp);
dp.clear();
ll w_border = W + 1;
for (auto &s : tmp) {
if (w_border > s.w) {
w_border = s.w;
dp.push_back(s);
}
}
assert(dp.size() <= N * N);
}
cout << dp[0].v << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define all(a) a.begin(), a.end()
typedef long long ll;
using P = pair<ll, ll>;
#define v first
#define w second
// v高い順（vが同じならw軽い方優先）
bool comp(P a, P b) { return a.v == b.v ? a.w < b.w : a.v > b.v; }
int main(void) {
int N, W;
cin >> N >> W;
vector<P> a(N);
rep(i, N) {
ll v, w;
cin >> v >> w;
a[i] = {v, w};
}
vector<P> dp = {{0, 0}};
rep(i, N) {
vector<P> tmp;
for (auto &s : dp) {
tmp.push_back(s);
tmp.push_back({s.v + a[i].v, s.w + a[i].w});
}
sort(all(tmp), comp);
dp.clear();
ll w_border = W + 1;
for (auto &s : tmp) {
if (w_border > s.w) {
w_border = s.w;
dp.push_back(s);
}
}
}
cout << dp[0].v << endl;
return 0;
}
|
delete
| 40 | 41 | 40 | 40 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define all(a) a.begin(), a.end()
typedef long long ll;
using P = pair<ll, ll>;
#define v first
#define w second
// v高い順（vが同じならw軽い方優先）
bool comp(P a, P b) { return a.v == b.v ? a.w < b.w : a.v > b.v; }
int main(void) {
ll N, W;
cin >> N >> W;
vector<P> a(N);
rep(i, N) {
ll v, w;
cin >> v >> w;
a[i] = {v, w};
}
vector<P> dp = {{0, 0}};
rep(i, N) {
vector<P> tmp;
for (P s : dp) {
tmp.push_back(s);
tmp.push_back({s.v + a[i].v, s.w + a[i].w});
}
sort(all(tmp), comp);
dp.clear();
ll w_border = W + 1;
for (P s : tmp) {
if (w_border > s.w) {
w_border = s.w;
dp.push_back(s);
}
}
assert((ll)dp.size() <= N * N + 1);
}
cout << dp[0].v << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define all(a) a.begin(), a.end()
typedef long long ll;
using P = pair<ll, ll>;
#define v first
#define w second
// v高い順（vが同じならw軽い方優先）
bool comp(P a, P b) { return a.v == b.v ? a.w < b.w : a.v > b.v; }
int main(void) {
ll N, W;
cin >> N >> W;
vector<P> a(N);
rep(i, N) {
ll v, w;
cin >> v >> w;
a[i] = {v, w};
}
vector<P> dp = {{0, 0}};
rep(i, N) {
vector<P> tmp;
for (P s : dp) {
tmp.push_back(s);
tmp.push_back({s.v + a[i].v, s.w + a[i].w});
}
sort(all(tmp), comp);
dp.clear();
ll w_border = W + 1;
for (P s : tmp) {
if (w_border > s.w) {
w_border = s.w;
dp.push_back(s);
}
}
assert((ll)dp.size() <= N * N * 2);
}
cout << dp[0].v << endl;
return 0;
}
|
replace
| 40 | 41 | 40 | 41 |
0
| |
p02315
|
C++
|
Runtime Error
|
// #define USE_CPP11
// #define USE_PRINTF
#include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#ifdef USE_CPP11
#include <functional>
#include <unordered_map>
#include <unordered_set>
#endif
#define PRINT(obj) cout << obj << endl
#define REP(i, n) for (int(i) = 0; (i) < (n); i++)
#define SPACE " "
typedef long long ll;
using namespace std;
const int INF = 1e9;
namespace Scanner {
#ifdef USE_PRINTF
int nextInt() {
int d;
scanf("%d", &d);
return d;
}
float nextFloat() {
float f;
scanf("%f", &f);
return f;
}
double nextDouble() {
double f;
scanf("%lf", &f);
return f;
}
string nextString() {
string s;
scanf("%s", &s);
return s;
}
ll nextll() {
ll l;
scanf("%ll", &l);
return l;
}
#else
int nextInt() {
int d;
cin >> d;
return d;
}
float nextFloat() {
float f;
cin >> f;
return f;
}
double nextDouble() {
double f;
cin >> f;
return f;
}
string nextString() {
string s;
cin >> s;
return s;
}
ll nextll() {
ll l;
cin >> l;
return l;
}
#endif
string getLine() {
string input;
getline(cin, input);
return input;
}
}; // namespace Scanner
namespace myLibrary {
vector<string> split(const string &str, char delim) {
vector<string> ret;
size_t current = 0, found;
while ((found = str.find_first_of(delim, current)) != string::npos) {
ret.push_back(string(str, current, found - current));
current = found + 1;
}
ret.push_back(string(str, current, str.size() - current));
return ret;
}
#ifdef USE_CPP11
///
/// higher-order functional
/// This is something like map in haskell, python, etc.
/// Sample usage:
/// vector<int> a = {1, 2, 3, 4, 5};
/// vector<int> b = myLibrary::_Map<int, int>(a, [](int n){
/// return n * n;
/// });
/// Result:
/// b = 1, 4, 9, 16, 25
///
template <typename T_IN, typename T_OUT, class Functor>
vector<T_OUT> _Map(vector<T_IN> src, Functor func) {
vector<T_OUT> ret;
for (int i = 0; i < src.size(); i++) {
ret.push_back(func(src[i]));
}
return ret;
}
#endif
}; // namespace myLibrary
/// BEGIN //////////////////////////////////////////////////////////
struct Item {
public:
bool isUsed;
int v, w;
Item() {}
Item(int v, int w) : isUsed(false), v(v), w(w) {}
};
int main() {
int N = Scanner::nextInt();
int W = Scanner::nextInt();
Item items[101];
REP(i, N) {
int v = Scanner::nextInt();
int w = Scanner::nextInt();
items[i] = Item(v, w);
}
static int dp[101][10001];
REP(i, N + 1) {
REP(j, W + 1) {
if (j < items[i].w) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - items[i].w] + items[i].v);
}
}
}
PRINT(dp[N][W]);
return 0;
}
/// END //////////////////////////////////////////////////////////
|
// #define USE_CPP11
// #define USE_PRINTF
#include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#ifdef USE_CPP11
#include <functional>
#include <unordered_map>
#include <unordered_set>
#endif
#define PRINT(obj) cout << obj << endl
#define REP(i, n) for (int(i) = 0; (i) < (n); i++)
#define SPACE " "
typedef long long ll;
using namespace std;
const int INF = 1e9;
namespace Scanner {
#ifdef USE_PRINTF
int nextInt() {
int d;
scanf("%d", &d);
return d;
}
float nextFloat() {
float f;
scanf("%f", &f);
return f;
}
double nextDouble() {
double f;
scanf("%lf", &f);
return f;
}
string nextString() {
string s;
scanf("%s", &s);
return s;
}
ll nextll() {
ll l;
scanf("%ll", &l);
return l;
}
#else
int nextInt() {
int d;
cin >> d;
return d;
}
float nextFloat() {
float f;
cin >> f;
return f;
}
double nextDouble() {
double f;
cin >> f;
return f;
}
string nextString() {
string s;
cin >> s;
return s;
}
ll nextll() {
ll l;
cin >> l;
return l;
}
#endif
string getLine() {
string input;
getline(cin, input);
return input;
}
}; // namespace Scanner
namespace myLibrary {
vector<string> split(const string &str, char delim) {
vector<string> ret;
size_t current = 0, found;
while ((found = str.find_first_of(delim, current)) != string::npos) {
ret.push_back(string(str, current, found - current));
current = found + 1;
}
ret.push_back(string(str, current, str.size() - current));
return ret;
}
#ifdef USE_CPP11
///
/// higher-order functional
/// This is something like map in haskell, python, etc.
/// Sample usage:
/// vector<int> a = {1, 2, 3, 4, 5};
/// vector<int> b = myLibrary::_Map<int, int>(a, [](int n){
/// return n * n;
/// });
/// Result:
/// b = 1, 4, 9, 16, 25
///
template <typename T_IN, typename T_OUT, class Functor>
vector<T_OUT> _Map(vector<T_IN> src, Functor func) {
vector<T_OUT> ret;
for (int i = 0; i < src.size(); i++) {
ret.push_back(func(src[i]));
}
return ret;
}
#endif
}; // namespace myLibrary
/// BEGIN //////////////////////////////////////////////////////////
struct Item {
public:
bool isUsed;
int v, w;
Item() {}
Item(int v, int w) : isUsed(false), v(v), w(w) {}
};
int main() {
int N = Scanner::nextInt();
int W = Scanner::nextInt();
Item items[101];
REP(i, N) {
int v = Scanner::nextInt();
int w = Scanner::nextInt();
items[i] = Item(v, w);
}
static int dp[102][10002];
REP(i, N + 1) {
REP(j, W + 1) {
if (j < items[i].w) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - items[i].w] + items[i].v);
}
}
}
PRINT(dp[N][W]);
return 0;
}
/// END //////////////////////////////////////////////////////////
|
replace
| 160 | 161 | 160 | 161 |
-11
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#define MAX_N 100
#define MAX_W 1000
int N, W, v[MAX_N], w[MAX_N];
int dp[MAX_N + 1][MAX_W + 1];
void solve();
int main() {
std::cin >> N >> W;
for (int i = 0; i < N; ++i)
std::cin >> v[i] >> w[i];
solve();
return 0;
}
void solve() {
for (int i = N - 1; i >= 0; --i) {
for (int j = 0; j <= W; ++j) {
if (j < w[i])
dp[i][j] = dp[i + 1][j];
else
dp[i][j] = std::max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i]);
}
}
std::cout << dp[0][W] << std::endl;
return;
}
|
#include <algorithm>
#include <iostream>
#define MAX_N 100
#define MAX_W 10000
int N, W, v[MAX_N], w[MAX_N];
int dp[MAX_N + 1][MAX_W + 1];
void solve();
int main() {
std::cin >> N >> W;
for (int i = 0; i < N; ++i)
std::cin >> v[i] >> w[i];
solve();
return 0;
}
void solve() {
for (int i = N - 1; i >= 0; --i) {
for (int j = 0; j <= W; ++j) {
if (j < w[i])
dp[i][j] = dp[i + 1][j];
else
dp[i][j] = std::max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i]);
}
}
std::cout << dp[0][W] << std::endl;
return;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02315
|
C++
|
Runtime Error
|
// ------------------------------------
// Date:2018/ 3/ 2
// Problem:AOJ DPL 0-1 Knapsack Problem 1_b.cpp
//
// ------------------------------------
#include <bits/stdc++.h>
using namespace std;
#define EACH(i, a) for (auto &&i : a)
#define FOR(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define RFOR(i, a, b) for (int i = (int)b - 1; i >= (int)a; --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
#define debug(x) cerr << #x << ":" << x << endl
typedef long long ll;
// static const int MOD = 1000000007;
// dp[今見てる品物の個数][まだ詰め込める量]
int dp[101][10101];
// v:value / w:weight
int v[1010];
int w[1010];
// N:品物の個数 / W:ナップサックの容量
int N, W;
int main() {
// 初期化
memset(dp, 0, sizeof(dp));
memset(v, 0, sizeof(v));
memset(w, 0, sizeof(w));
scanf("%d %d", &N, &W);
REP(i, N) { scanf("%d %d", &v[i], &w[i]); }
RREP(num, N + 1) {
REP(weight, W + 1) {
if (weight < w[num]) {
// 見ている品物の重さが、まだ詰め込める量より多いとき
dp[num][weight] = dp[num + 1][weight];
} else {
// 詰め込むことが可能な状態で、max(詰め込まない or 詰め込む
dp[num][weight] =
max(dp[num + 1][weight], dp[num + 1][weight - w[num]] + v[num]);
}
}
}
int ans = dp[0][W];
printf("%d\n", ans);
return 0;
}
|
// ------------------------------------
// Date:2018/ 3/ 2
// Problem:AOJ DPL 0-1 Knapsack Problem 1_b.cpp
//
// ------------------------------------
#include <bits/stdc++.h>
using namespace std;
#define EACH(i, a) for (auto &&i : a)
#define FOR(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define RFOR(i, a, b) for (int i = (int)b - 1; i >= (int)a; --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
#define debug(x) cerr << #x << ":" << x << endl
typedef long long ll;
// static const int MOD = 1000000007;
// dp[今見てる品物の個数][まだ詰め込める量]
int dp[101][10101];
// v:value / w:weight
int v[1010];
int w[1010];
// N:品物の個数 / W:ナップサックの容量
int N, W;
int main() {
// 初期化
memset(dp, 0, sizeof(dp));
memset(v, 0, sizeof(v));
memset(w, 0, sizeof(w));
scanf("%d %d", &N, &W);
REP(i, N) { scanf("%d %d", &v[i], &w[i]); }
RREP(num, N) {
REP(weight, W + 1) {
if (weight < w[num]) {
// 見ている品物の重さが、まだ詰め込める量より多いとき
dp[num][weight] = dp[num + 1][weight];
} else {
// 詰め込むことが可能な状態で、max(詰め込まない or 詰め込む
dp[num][weight] =
max(dp[num + 1][weight], dp[num + 1][weight - w[num]] + v[num]);
}
}
}
int ans = dp[0][W];
printf("%d\n", ans);
return 0;
}
|
replace
| 40 | 41 | 40 | 41 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
vector<int> dp(100000);
int main() {
int N, W;
int v[2000];
int w[2000];
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
for (int j = 0; j < N; j++) {
for (int i = W; i >= 0; i--) {
if (i - w[i] > -1) {
dp[i] = max(dp[i], dp[i - w[j]] + v[j]);
}
}
}
int res = 0;
for (int i = 0; i <= W; i++) {
res = max(res, dp[i]);
}
cout << res << endl;
dp.clear();
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
vector<int> dp(100000);
int main() {
int N, W;
int v[2000];
int w[2000];
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
for (int j = 0; j < N; j++) {
for (int i = W; i >= 0; i--) {
if (i - w[j] > -1) {
dp[i] = max(dp[i], dp[i - w[j]] + v[j]);
}
}
}
int res = 0;
for (int i = 0; i <= W; i++) {
res = max(res, dp[i]);
}
cout << res << endl;
dp.clear();
return 0;
}
|
replace
| 21 | 22 | 21 | 22 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <iostream>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, W;
cin >> N >> W;
int value[N];
int weight[N];
REP(n, N) {
cin >> value[n];
cin >> weight[n];
}
int dp[100][10000] = {{}};
REP(n, N) {
REP(w, W + 1) {
weight[n] > w
? dp[n + 1][w] = dp[n][w]
: dp[n + 1][w] = max(dp[n][w], dp[n][w - weight[n]] + value[n]);
}
}
cout << dp[N][W] << endl;
return 0;
}
|
#include <iostream>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, W;
cin >> N >> W;
int value[N];
int weight[N];
REP(n, N) {
cin >> value[n];
cin >> weight[n];
}
int dp[110][11000] = {{}};
REP(n, N) {
REP(w, W + 1) {
weight[n] > w
? dp[n + 1][w] = dp[n][w]
: dp[n + 1][w] = max(dp[n][w], dp[n][w - weight[n]] + value[n]);
}
}
cout << dp[N][W] << endl;
return 0;
}
|
replace
| 16 | 17 | 16 | 17 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <stdio.h>
int i, j, a, b, c[101], d[101], e[101][10001], f = -1;
int main(void) {
scanf("%d %d", &a, &b);
for (i = 0; i <= a; i++) {
for (j = 0; j <= b; j++) {
e[i][j] = -1;
}
}
for (i = 0; i < a; i++) {
scanf("%d %d", &c[i], &d[i]);
}
e[0][0] = 0;
for (i = 0; i < a; i++) {
for (j = 0; j <= b; j++) {
if (e[i][j] != -1) {
if (e[i][j] + c[i] > e[i + 1][j + d[i]] && j + d[i] <= b) {
e[i + 1][j + d[i]] = e[i][j] + c[i];
}
if (e[i][j] > e[i + 1][j]) {
e[i + 1][j] = e[i][j];
}
}
}
}
for (i = 0; i <= a; i++) {
for (j = 0; j <= b; j++) {
if (f < e[i][j]) {
f = e[i][j];
}
}
}
printf("%d\n", f);
return 0;
}
|
#include <stdio.h>
int i, j, a, b, c[101], d[101], e[102][10001], f = -1;
int main(void) {
scanf("%d %d", &a, &b);
for (i = 0; i <= a; i++) {
for (j = 0; j <= b; j++) {
e[i][j] = -1;
}
}
for (i = 0; i < a; i++) {
scanf("%d %d", &c[i], &d[i]);
}
e[0][0] = 0;
for (i = 0; i < a; i++) {
for (j = 0; j <= b; j++) {
if (e[i][j] != -1) {
if (e[i][j] + c[i] > e[i + 1][j + d[i]] && j + d[i] <= b) {
e[i + 1][j + d[i]] = e[i][j] + c[i];
}
if (e[i][j] > e[i + 1][j]) {
e[i + 1][j] = e[i][j];
}
}
}
}
for (i = 0; i <= a; i++) {
for (j = 0; j <= b; j++) {
if (f < e[i][j]) {
f = e[i][j];
}
}
}
printf("%d\n", f);
return 0;
}
|
replace
| 1 | 2 | 1 | 2 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <iostream>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define MP make_pair
typedef unsigned long long ULL;
// dp[i+][j]
// i番目まで使って重さj以下になるように選んだ時の最大価値
long dp[100][10001];
int main() {
int N, W;
cin >> N >> W;
vector<int> v(N), w(N);
for (int i = 0; i < N; i++)
cin >> v[i] >> w[i];
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i])
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
cout << dp[N][W] << endl;
return 0;
}
|
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <iostream>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define MP make_pair
typedef unsigned long long ULL;
// dp[i+][j]
// i番目まで使って重さj以下になるように選んだ時の最大価値
long dp[101][10001];
int main() {
int N, W;
cin >> N >> W;
vector<int> v(N), w(N);
for (int i = 0; i < N; i++)
cin >> v[i] >> w[i];
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i])
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
cout << dp[N][W] << endl;
return 0;
}
|
replace
| 20 | 21 | 20 | 21 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int dp[105][10005] = {};
int n;
cin >> n;
int W;
cin >> W;
int w[n], v[n];
for (int i = 0; i < n; i++) {
cin >> v[i] >> w[i];
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
}
cout << dp[n][W] << endl;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int dp[105][10005] = {};
int n;
cin >> n;
int W;
cin >> W;
int w[105], v[105];
for (int i = 0; i < n; i++) {
cin >> v[i] >> w[i];
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
}
cout << dp[n][W] << endl;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int dp[105][10005] = {};
int n;
cin >> n;
int W;
cin >> W;
int w[n], v[n];
for (int i = 0; i < n; i++) {
cin >> v[i] >> w[i];
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
}
cout << dp[n][W] << endl;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int dp[105][10005] = {};
int n;
cin >> n;
int W;
cin >> W;
int v[105], w[105];
for (int i = 0; i < n; i++) {
cin >> v[i] >> w[i];
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
}
cout << dp[n][W] << endl;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#include <cstdio>
#define REP(i, n) for (int i = 0; (i) < (n); (i)++)
#define FOR_IN(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define IN(x, a, b) ((x) >= (a) && (x) <= (b))
using namespace std;
typedef long long int ll;
/*
N W
vi wi
N 100
W 10000
*/
int N, W;
int w[100], v[100];
ll dp[100][10000];
int main() {
cin >> N >> W;
REP(i, N) { cin >> v[i] >> w[i]; }
REP(i, N) {
REP(j, W + 1) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
}
cout << dp[N][W] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <cstdio>
#define REP(i, n) for (int i = 0; (i) < (n); (i)++)
#define FOR_IN(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define IN(x, a, b) ((x) >= (a) && (x) <= (b))
using namespace std;
typedef long long int ll;
/*
N W
vi wi
N 100
W 10000
*/
int N, W;
int w[100], v[100];
ll dp[101][10001];
int main() {
cin >> N >> W;
REP(i, N) { cin >> v[i] >> w[i]; }
REP(i, N) {
REP(j, W + 1) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
}
cout << dp[N][W] << endl;
return 0;
}
|
replace
| 20 | 21 | 20 | 21 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
typedef long long ll;
#define max_i 100
#define max_j 10000
int dp[max_i][max_j];
void solve() {
int n, m;
int v[max_i + 1], w[max_i + 1];
std::cin >> n >> m;
for (int i = 0; i < n; i++) {
/* code */
std::cin >> v[i] >> w[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= m; j++) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j - w[i]] + v[i], dp[i][j]);
}
}
}
std::cout << dp[n][m] << '\n';
}
int main() {
solve();
return 0;
}
|
#include <iostream>
using namespace std;
typedef long long ll;
#define max_i 100
#define max_j 10000
int dp[max_i + 1][max_j + 1];
void solve() {
int n, m;
int v[max_i + 1], w[max_i + 1];
std::cin >> n >> m;
for (int i = 0; i < n; i++) {
/* code */
std::cin >> v[i] >> w[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= m; j++) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j - w[i]] + v[i], dp[i][j]);
}
}
}
std::cout << dp[n][m] << '\n';
}
int main() {
solve();
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define int long long
const int inf = 999999999999999999;
typedef long long ll;
typedef long double ld;
struct A {
int v, w;
};
A a[100];
int dp[10001];
signed main() {
int n, w, ans = 0;
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> a[i].v >> a[i].w;
fill(dp, dp + 10001, -1);
dp[0] = 0;
for (int i = 0; i < n; i++)
for (int j = 10000; j >= 0; j--)
if (dp[j] != -1)
dp[j + a[i].w] = max(dp[j + a[i].w], dp[j] + a[i].v);
for (int i = 0; i <= w; i++)
ans = max(ans, dp[i]);
cout << ans << endl;
getchar();
getchar();
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define int long long
const int inf = 999999999999999999;
typedef long long ll;
typedef long double ld;
struct A {
int v, w;
};
A a[100];
int dp[10001];
signed main() {
int n, w, ans = 0;
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> a[i].v >> a[i].w;
fill(dp, dp + 10001, -1);
dp[0] = 0;
for (int i = 0; i < n; i++)
for (int j = 10000; j >= 0; j--)
if (dp[j] != -1 && j + a[i].w <= 10000)
dp[j + a[i].w] = max(dp[j + a[i].w], dp[j] + a[i].v);
for (int i = 0; i <= w; i++)
ans = max(ans, dp[i]);
cout << ans << endl;
getchar();
getchar();
}
|
replace
| 32 | 33 | 32 | 33 |
0
| |
p02315
|
C++
|
Memory Limit Exceeded
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int N, W;
int dp[10010][10010];
vector<int> v(1100);
vector<int> w(1100);
int rec(int i, int j) {
if (dp[i][j] >= 0)
return dp[i][j];
int res;
if (i == N)
res = 0;
else if (j < w[i])
res = rec(i + 1, j);
else
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
return dp[i][j] = res;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> N >> W;
rep(i, N) { cin >> v[i] >> w[i]; }
cout << rec(0, W) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int N, W;
int dp[110][10010];
vector<int> v(1100);
vector<int> w(1100);
int rec(int i, int j) {
if (dp[i][j] >= 0)
return dp[i][j];
int res;
if (i == N)
res = 0;
else if (j < w[i])
res = rec(i + 1, j);
else
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
return dp[i][j] = res;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> N >> W;
rep(i, N) { cin >> v[i] >> w[i]; }
cout << rec(0, W) << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
MLE
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
int gcd(int a, int b) {
while (b) {
int m = a % b;
a = b;
b = m;
}
return a;
}
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
int isPrim(int a) {
if (a == 1) {
return 0;
}
for (int i = 2; i <= (a + 1) / 2; i++) {
if (a % i == 0) {
return 0;
}
}
return 1;
}
long long mod_pow(long long x, long long n, long long mod) {
// x???n???????¨????????????????n??????2?????¨?¨???????????¨????
// x^22 = x^16 + x^4 + x^2
long long ret = 1;
while (n > 0) {
if (n % 2 == 1) {
ret = (ret * x) % mod; //???????????????
}
x = (x * x) % mod; // 2???
n = n / 2;
}
return ret;
}
struct VV {
int x;
int y;
int z;
};
class LessInt {
public:
bool operator()(const VV &riLeft, const VV &riRight) const {
if (riLeft.x == riRight.x) {
return riLeft.y > riRight.y;
}
return riLeft.x > riRight.x;
}
};
class indInt {
public:
bool operator()(const VV &riLeft, const VV &riRight) const {
return riLeft.x < riRight.x;
}
};
struct XX {
int zenbu = 0;
int kidoku = 0;
};
class xxIntu {
public:
bool operator()(const VV &riLeft, const VV &riRight) const {
//?¬¬1?????¶
if (riLeft.z != riRight.z) {
return riLeft.z >
riRight.z; //<:??????(?°??????????)???>:??????(??§?????????)
}
//?¬¬2?????¶
return riLeft.y < riRight.y;
}
};
bool operator<(const VV &riLeft, const VV &riRight) {
return riLeft.z < riRight.z;
};
/*bool operator> (const XX &riLeft, const XX &riRight){
return riLeft.a > riRight.a;
};*/
int main(int argc, const char *argv[]) {
// std::ios::sync_with_stdio(false);
// scanf("%s",S);
// scanf("%d",&N);
// getline(cin, target);
// cin >> x >> y;
//????????????
int N, W;
cin >> N >> W;
int v[100];
int w[100];
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
int dp[100][10001]; // i???????????§??§j?????????????????????????????§
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j - w[i] >= 0) {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
} else {
dp[i + 1][j] = dp[i][j];
}
}
}
cout << dp[N][W] << endl;
//???????????§
// cout << "ans" << endl;????????????
// printf("%.0f\n",ans);//?°???°?????\?????¨?????????
// printf("%.7f\n",p);
// printf("%f\n",pow(2,ans.size()));
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
int gcd(int a, int b) {
while (b) {
int m = a % b;
a = b;
b = m;
}
return a;
}
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
int isPrim(int a) {
if (a == 1) {
return 0;
}
for (int i = 2; i <= (a + 1) / 2; i++) {
if (a % i == 0) {
return 0;
}
}
return 1;
}
long long mod_pow(long long x, long long n, long long mod) {
// x???n???????¨????????????????n??????2?????¨?¨???????????¨????
// x^22 = x^16 + x^4 + x^2
long long ret = 1;
while (n > 0) {
if (n % 2 == 1) {
ret = (ret * x) % mod; //???????????????
}
x = (x * x) % mod; // 2???
n = n / 2;
}
return ret;
}
struct VV {
int x;
int y;
int z;
};
class LessInt {
public:
bool operator()(const VV &riLeft, const VV &riRight) const {
if (riLeft.x == riRight.x) {
return riLeft.y > riRight.y;
}
return riLeft.x > riRight.x;
}
};
class indInt {
public:
bool operator()(const VV &riLeft, const VV &riRight) const {
return riLeft.x < riRight.x;
}
};
struct XX {
int zenbu = 0;
int kidoku = 0;
};
class xxIntu {
public:
bool operator()(const VV &riLeft, const VV &riRight) const {
//?¬¬1?????¶
if (riLeft.z != riRight.z) {
return riLeft.z >
riRight.z; //<:??????(?°??????????)???>:??????(??§?????????)
}
//?¬¬2?????¶
return riLeft.y < riRight.y;
}
};
bool operator<(const VV &riLeft, const VV &riRight) {
return riLeft.z < riRight.z;
};
/*bool operator> (const XX &riLeft, const XX &riRight){
return riLeft.a > riRight.a;
};*/
int main(int argc, const char *argv[]) {
// std::ios::sync_with_stdio(false);
// scanf("%s",S);
// scanf("%d",&N);
// getline(cin, target);
// cin >> x >> y;
//????????????
int N, W;
cin >> N >> W;
int v[100];
int w[100];
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
int dp[101][10001]; // i???????????§??§j?????????????????????????????§
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j - w[i] >= 0) {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
} else {
dp[i + 1][j] = dp[i][j];
}
}
}
cout << dp[N][W] << endl;
//???????????§
// cout << "ans" << endl;????????????
// printf("%.0f\n",ans);//?°???°?????\?????¨?????????
// printf("%.7f\n",p);
// printf("%f\n",pow(2,ans.size()));
return 0;
}
|
replace
| 118 | 119 | 118 | 119 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <set>
#include <sstream>
#include <typeinfo>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define pyfor(j, s, n, i) for (int j = s; j < n; j += i)
using namespace std;
typedef long long ll;
const int INF = INT_MAX;
const int max_n = 100;
const int max_w = 10000;
int pack_hist[max_n + 1][max_w + 1];
int v_s[max_n];
int w_s[max_n];
int N, W;
int pack(int ni, int wl) {
if (ni >= N)
return 0;
if (pack_hist[ni][wl] != -1)
return pack_hist[ni][wl];
int ans;
if (wl >= w_s[ni]) {
ans = max(v_s[ni] + pack(ni + 1, wl - w_s[ni]), pack(ni + 1, wl));
} else {
ans = pack(ni + 1, wl);
}
pack_hist[ni][wl] = ans;
cerr << "pack(" << ni << " " << wl << "): " << ans << "\n";
return ans;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> W;
REP(i, N) { cin >> v_s[i] >> w_s[i]; }
REP(i, N + 1) REP(j, W + 1) pack_hist[i][j] = -1;
cout << pack(0, W) << "\n";
return 0;
}
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <set>
#include <sstream>
#include <typeinfo>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define pyfor(j, s, n, i) for (int j = s; j < n; j += i)
using namespace std;
typedef long long ll;
const int INF = INT_MAX;
const int max_n = 100;
const int max_w = 10000;
int pack_hist[max_n + 1][max_w + 1];
int v_s[max_n];
int w_s[max_n];
int N, W;
int pack(int ni, int wl) {
if (ni >= N)
return 0;
if (pack_hist[ni][wl] != -1)
return pack_hist[ni][wl];
int ans;
if (wl >= w_s[ni]) {
ans = max(v_s[ni] + pack(ni + 1, wl - w_s[ni]), pack(ni + 1, wl));
} else {
ans = pack(ni + 1, wl);
}
pack_hist[ni][wl] = ans;
// cerr << "pack(" << ni << " " << wl << "): " << ans << "\n";
return ans;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> W;
REP(i, N) { cin >> v_s[i] >> w_s[i]; }
REP(i, N + 1) REP(j, W + 1) pack_hist[i][j] = -1;
cout << pack(0, W) << "\n";
return 0;
}
|
replace
| 40 | 41 | 40 | 41 |
0
|
pack(3 5): 8
pack(3 4): 8
pack(2 5): 10
pack(3 3): 8
pack(3 2): 0
pack(2 3): 8
pack(1 5): 13
pack(3 1): 0
pack(3 0): 0
pack(2 1): 2
pack(1 3): 8
pack(0 5): 13
|
p02315
|
C++
|
Memory Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define ll long long
#define LL long long
#define ULL unsigned long long
#define ull unsigned long long
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
const ll INF = -10000000000;
using namespace std;
ll dp[10001][10001] = {};
int N, W;
int v[1000], w[1000];
int main() {
cin >> N >> W;
REP(i, N) cin >> v[i] >> w[i];
for (int i = 0; i <= W; i++) { //??\??????????????§??????
for (int j = 0; j < N; j++) { // j????????\????????????
if (i == 0)
dp[i][j] = 0;
else if (i >= w[j])
dp[i][j] = max(dp[i][j - 1], dp[i - w[j]][j - 1] + v[j]);
else
dp[i][j] = dp[i][j - 1];
}
}
/*
REP(i, W+1) {
REP(j, N) {
cout << dp[i][j] << " ";
}
cout << endl;
}
*/
cout << dp[W][N - 1] << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define ll long long
#define LL long long
#define ULL unsigned long long
#define ull unsigned long long
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
const ll INF = -10000000000;
using namespace std;
ll dp[10001][101] = {};
int N, W;
int v[1000], w[1000];
int main() {
cin >> N >> W;
REP(i, N) cin >> v[i] >> w[i];
for (int i = 0; i <= W; i++) { //??\??????????????§??????
for (int j = 0; j < N; j++) { // j????????\????????????
if (i == 0)
dp[i][j] = 0;
else if (i >= w[j])
dp[i][j] = max(dp[i][j - 1], dp[i - w[j]][j - 1] + v[j]);
else
dp[i][j] = dp[i][j - 1];
}
}
/*
REP(i, W+1) {
REP(j, N) {
cout << dp[i][j] << " ";
}
cout << endl;
}
*/
cout << dp[W][N - 1] << endl;
return 0;
}
|
replace
| 24 | 25 | 24 | 25 |
MLE
| |
p02315
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int n, m, v[1100], w[1100];
bool done[100][11000];
int memo[100][11000];
int search(int i, int h) {
if (done[i][h])
return memo[i][h];
int res;
if (i == n)
res = 0;
else if (w[i] > h)
res = search(i + 1, h);
else if (w[i] <= h) {
int res1 = search(i + 1, h);
int res2 = search(i + 1, h - w[i]) + v[i];
res = max(res1, res2);
}
done[i][h] = true;
return memo[i][h] = res;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> v[i] >> w[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j <= m; j++) {
done[i][j] = false;
}
}
cout << search(0, m) << endl;
}
|
#include <iostream>
using namespace std;
int n, m, v[1100], w[1100];
bool done[110][11000];
int memo[110][11000];
int search(int i, int h) {
if (done[i][h])
return memo[i][h];
int res;
if (i == n)
res = 0;
else if (w[i] > h)
res = search(i + 1, h);
else if (w[i] <= h) {
int res1 = search(i + 1, h);
int res2 = search(i + 1, h - w[i]) + v[i];
res = max(res1, res2);
}
done[i][h] = true;
return memo[i][h] = res;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> v[i] >> w[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j <= m; j++) {
done[i][j] = false;
}
}
cout << search(0, m) << endl;
}
|
replace
| 4 | 6 | 4 | 6 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <stack>
#include <vector>
using namespace std;
const int maxn = 1010;
int dp[maxn], v[maxn], w[maxn];
int main() {
memset(dp, 0, sizeof(dp));
int n, W;
cin >> n >> W;
for (int i = 1; i <= n; i++)
cin >> v[i] >> w[i];
for (int i = 1; i <= n; i++)
for (int j = W; j >= w[i]; j--)
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
cout << dp[W] << endl;
}
|
#include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <stack>
#include <vector>
using namespace std;
const int maxn = 10500;
int dp[maxn], v[maxn], w[maxn];
int main() {
memset(dp, 0, sizeof(dp));
int n, W;
cin >> n >> W;
for (int i = 1; i <= n; i++)
cin >> v[i] >> w[i];
for (int i = 1; i <= n; i++)
for (int j = W; j >= w[i]; j--)
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
cout << dp[W] << endl;
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define CI cin >>
#define CO cout <<
#define E << endl;
using namespace std;
typedef pair<int, int> P;
typedef pair<long, long> LP;
typedef pair<int, P> PP;
typedef pair<long, LP> LPP;
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
int A = 0, B = 0, K = 0, T = 0, W = 0, N = 0, H = 0;
int n = 0;
double L = 0;
double S = 0;
double ar = 0, br = 0, cr = 0;
int answer = 0;
string C;
string sA, strB;
vector<vector<char>> map;
vector<double> num;
vector<string> str;
int sum = 0;
vector<int> value;
vector<int> weight;
int dp[100][10000];
void input() {
CI N >> W;
int temp;
for (int i = 0; i < N; i++) {
CI temp;
value.push_back(temp);
CI temp;
weight.push_back(temp);
}
return;
}
int main(void) {
input();
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (weight[i] > j) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], value[i] + dp[i][j - weight[i]]);
}
}
}
CO dp[N][W] E
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define CI cin >>
#define CO cout <<
#define E << endl;
using namespace std;
typedef pair<int, int> P;
typedef pair<long, long> LP;
typedef pair<int, P> PP;
typedef pair<long, LP> LPP;
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
int A = 0, B = 0, K = 0, T = 0, W = 0, N = 0, H = 0;
int n = 0;
double L = 0;
double S = 0;
double ar = 0, br = 0, cr = 0;
int answer = 0;
string C;
string sA, strB;
vector<vector<char>> map;
vector<double> num;
vector<string> str;
int sum = 0;
vector<int> value;
vector<int> weight;
int dp[110][10010];
void input() {
CI N >> W;
int temp;
for (int i = 0; i < N; i++) {
CI temp;
value.push_back(temp);
CI temp;
weight.push_back(temp);
}
return;
}
int main(void) {
input();
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (weight[i] > j) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], value[i] + dp[i][j - weight[i]]);
}
}
}
CO dp[N][W] E
return 0;
}
|
replace
| 48 | 49 | 48 | 49 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define PII pair<int, int>
int dp[100][10001];
PII p[101];
int main() {
int N, W;
cin >> N >> W;
REP(i, N) cin >> p[i].first >> p[i].second;
REP(i, N + 1) REP(j, W + 1) dp[i][j] = -1;
REP(i, N) dp[i][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (dp[i][j] != -1) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
int temp = j + p[i].second;
if (temp <= W) {
dp[i + 1][temp] = max(dp[i + 1][temp], dp[i][j] + p[i].first);
}
}
}
}
int ans = 0;
for (int i = W; i >= 0; i--) {
if (ans < dp[N][i]) {
ans = dp[N][i];
}
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define PII pair<int, int>
int dp[101][10001];
PII p[101];
int main() {
int N, W;
cin >> N >> W;
REP(i, N) cin >> p[i].first >> p[i].second;
REP(i, N + 1) REP(j, W + 1) dp[i][j] = -1;
REP(i, N) dp[i][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (dp[i][j] != -1) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
int temp = j + p[i].second;
if (temp <= W) {
dp[i + 1][temp] = max(dp[i + 1][temp], dp[i][j] + p[i].first);
}
}
}
}
int ans = 0;
for (int i = W; i >= 0; i--) {
if (ans < dp[N][i]) {
ans = dp[N][i];
}
}
cout << ans << endl;
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define MAX_N 100
#define MAX_W 100001
long long dp[MAX_N][MAX_W];
int main() {
long long N;
cin >> N;
long long W;
cin >> W;
vector<vector<long long>> v(N, vector<long long>(2));
for (long long i = 0; i < N; i++) {
cin >> v[i][0] >> v[i][1];
}
for (long long i = 0; i <= W; i++) {
dp[0][i] = 0;
}
for (long long i = 0; i < N; i++) {
for (long long j = 0; j <= W; j++) {
if (j < v[i][1]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - v[i][1]] + v[i][0]);
}
}
}
cout << dp[N][W] << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define MAX_N 101
#define MAX_W 100001
long long dp[MAX_N][MAX_W];
int main() {
long long N;
cin >> N;
long long W;
cin >> W;
vector<vector<long long>> v(N, vector<long long>(2));
for (long long i = 0; i < N; i++) {
cin >> v[i][0] >> v[i][1];
}
for (long long i = 0; i <= W; i++) {
dp[0][i] = 0;
}
for (long long i = 0; i < N; i++) {
for (long long j = 0; j <= W; j++) {
if (j < v[i][1]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - v[i][1]] + v[i][0]);
}
}
}
cout << dp[N][W] << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02315
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int n, W, w[100], v[100], memo[101][10001];
int rec(int i, int j) {
if (memo[i][j] != -1)
return memo[i][j];
int res;
if (i == n)
res = 0;
else if (j < w[i])
res = rec(i + 1, j);
else
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
return res;
}
int main() {
cin >> n >> W;
for (int i = 0; i < n; ++i) {
cin >> v[i] >> w[i];
}
memset(memo, -1, sizeof(memo));
cout << rec(0, W) << endl;
}
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int n, W, w[100], v[100], memo[101][10001];
int rec(int i, int j) {
if (memo[i][j] != -1)
return memo[i][j];
int res;
if (i == n)
res = 0;
else if (j < w[i])
res = rec(i + 1, j);
else
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
return memo[i][j] = res;
}
int main() {
cin >> n >> W;
for (int i = 0; i < n; ++i) {
cin >> v[i] >> w[i];
}
memset(memo, -1, sizeof(memo));
cout << rec(0, W) << endl;
}
|
replace
| 17 | 18 | 17 | 18 |
TLE
| |
p02315
|
C++
|
Memory Limit Exceeded
|
#include <algorithm>
#include <cstring>
#include <iostream>
#define nMAX 1000
#define vMAX 10000
#define wMAX 10000
#define WMAX 100000
int n, W;
int v[nMAX], w[nMAX];
int dp[nMAX][WMAX];
using namespace std;
int rec(int i, int j) {
if (dp[i][j] >= 0)
return dp[i][j];
int res;
if (i == n)
res = 0;
else if (j < w[i])
res = rec(i + 1, j);
else
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
return dp[i][j] = res;
}
int main(void) {
std::ios_base::sync_with_stdio();
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin >> v[i];
cin >> w[i];
}
memset(dp, -1, sizeof(dp));
cout << rec(0, W) << endl;
return 0;
}
|
#include <algorithm>
#include <cstring>
#include <iostream>
#define nMAX 200
#define vMAX 2000
#define wMAX 2000
#define WMAX 20000
int n, W;
int v[nMAX], w[nMAX];
int dp[nMAX][WMAX];
using namespace std;
int rec(int i, int j) {
if (dp[i][j] >= 0)
return dp[i][j];
int res;
if (i == n)
res = 0;
else if (j < w[i])
res = rec(i + 1, j);
else
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
return dp[i][j] = res;
}
int main(void) {
std::ios_base::sync_with_stdio();
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin >> v[i];
cin >> w[i];
}
memset(dp, -1, sizeof(dp));
cout << rec(0, W) << endl;
return 0;
}
|
replace
| 4 | 8 | 4 | 8 |
MLE
| |
p02315
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define INF 2000000000
#define int long long int
#define MOD 1000000007
#define pb push_back
#define cin1(n) (cin >> n)
#define cin2(a, b) (cin >> a >> b)
#define cin3(a, b, c) (cin >> a >> b >> c)
#define cout(n) (cout << n << endl)
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define fr first
#define sc second
#define EPS (1e-10)
using namespace std;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<pair<int, int>> vpii;
typedef vector<string> vs;
typedef vector<vector<string>> vss;
typedef pair<int, int> pii;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int n, m;
int a, b;
int p, q;
signed main() {
int N, W;
cin2(N, W);
vi v(N + 1, 0), w(W + 1, 0);
rep(i, 1, N + 1) { cin2(v[i], w[i]); }
vvi dp(N + 1, vi(W + 1, 0));
rep(i, 1, N + 1) {
rep(j, 1, W + 1) {
if (j - w[i] >= 0) {
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout(dp[N][W]);
return 0;
}
|
#include <bits/stdc++.h>
#define INF 2000000000
#define int long long int
#define MOD 1000000007
#define pb push_back
#define cin1(n) (cin >> n)
#define cin2(a, b) (cin >> a >> b)
#define cin3(a, b, c) (cin >> a >> b >> c)
#define cout(n) (cout << n << endl)
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define fr first
#define sc second
#define EPS (1e-10)
using namespace std;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<pair<int, int>> vpii;
typedef vector<string> vs;
typedef vector<vector<string>> vss;
typedef pair<int, int> pii;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int n, m;
int a, b;
int p, q;
signed main() {
int N, W;
cin2(N, W);
vi v(N + 1, 0), w(N + 1, 0);
rep(i, 1, N + 1) { cin2(v[i], w[i]); }
vvi dp(N + 1, vi(W + 1, 0));
rep(i, 1, N + 1) {
rep(j, 1, W + 1) {
if (j - w[i] >= 0) {
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout(dp[N][W]);
return 0;
}
|
replace
| 33 | 34 | 33 | 34 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ll long long
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ROF(i, a, b) for (int i = b - 1; i >= a; i--)
using namespace std;
//
const int inf = 1e9 + 7;
const int mod = 1e9 + 7;
//
struct poi {
int X;
int Y;
int Z;
bool operator<(const poi &R) const {
return X == R.X ? Y == R.Y ? Z < R.Z : Y < R.Y : X < R.X;
}
};
//
ll GCD(ll a, ll b) { return (b == 0) ? (a) : (GCD(b, a % b)); }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
//
int DP[101][10001];
int main() {
int N, W;
int v[100], w[100];
cin >> N >> W;
FOR(i, 0, N) { cin >> v[i] >> w[i]; }
FOR(i, 0, N) {
FOR(j, 0, W + 1) {
DP[i + 1][j] = max(DP[i + 1][j], DP[i][j]);
if (W - j >= w[i]) {
DP[i + 1][j + w[i]] = max(DP[i + 1][j + w[i]], DP[i][j] + v[i]);
} else {
DP[i + 1][j + w[i]] = DP[i][j + w[i]];
}
}
}
cout << DP[N][W] << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ll long long
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ROF(i, a, b) for (int i = b - 1; i >= a; i--)
using namespace std;
//
const int inf = 1e9 + 7;
const int mod = 1e9 + 7;
//
struct poi {
int X;
int Y;
int Z;
bool operator<(const poi &R) const {
return X == R.X ? Y == R.Y ? Z < R.Z : Y < R.Y : X < R.X;
}
};
//
ll GCD(ll a, ll b) { return (b == 0) ? (a) : (GCD(b, a % b)); }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
//
int DP[101][10001];
int main() {
int N, W;
int v[100], w[100];
cin >> N >> W;
FOR(i, 0, N) { cin >> v[i] >> w[i]; }
FOR(i, 0, N) {
FOR(j, 0, W + 1) {
DP[i + 1][j] = max(DP[i + 1][j], DP[i][j]);
if (W - j >= w[i]) {
DP[i + 1][j + w[i]] = max(DP[i + 1][j + w[i]], DP[i][j] + v[i]);
}
}
}
cout << DP[N][W] << endl;
return 0;
}
|
delete
| 39 | 41 | 39 | 39 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
constexpr int INF = (1 << 30) - 1;
constexpr int MOD = 1000000000 + 7;
int N, W;
vector<int> v, w;
int dp[100][10001];
int main() {
cin >> N >> W;
v.resize(N);
w.resize(N);
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
for (int i = 0; i <= W; i++) {
for (int j = 0; j < N; j++) {
if (i < w[j]) {
dp[j + 1][i] = dp[j][i];
} else {
dp[j + 1][i] = max(dp[j][i], dp[j][i - w[j]] + v[j]);
}
}
}
cout << dp[N][W] << endl;
}
|
#include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
constexpr int INF = (1 << 30) - 1;
constexpr int MOD = 1000000000 + 7;
int N, W;
vector<int> v, w;
int dp[101][10001];
int main() {
cin >> N >> W;
v.resize(N);
w.resize(N);
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
for (int i = 0; i <= W; i++) {
for (int j = 0; j < N; j++) {
if (i < w[j]) {
dp[j + 1][i] = dp[j][i];
} else {
dp[j + 1][i] = max(dp[j][i], dp[j][i - w[j]] + v[j]);
}
}
}
cout << dp[N][W] << endl;
}
|
replace
| 17 | 18 | 17 | 18 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int main() {
int dp[1000][10010] = {0}, w[10000] = {0}, k[10000] = {0}, N, M, i, j;
cin >> N >> M;
for (i = 1; i <= N; i++) {
cin >> k[i] >> w[i];
}
for (i = 1; i <= N; i++) {
for (j = 1; j <= M; j++) {
if (i == 1) {
if (j >= w[i]) {
dp[i][j] = k[i];
if (dp[i][j] <= dp[i - 1][j]) {
dp[i][j] = dp[i - 1][j];
}
}
} else {
if (dp[i][j] <= dp[i - 1][j]) {
dp[i][j] = dp[i - 1][j];
}
if (j >= w[i]) {
if (k[i] + dp[i - 1][j - w[i]] > dp[i][j]) {
dp[i][j] = k[i] + dp[i - 1][j - w[i]];
}
}
}
}
}
cout << dp[N][M] << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int dp[120][10001] = {0}, w[1000] = {0}, k[1000] = {0}, N, M, i, j;
cin >> N >> M;
for (i = 1; i <= N; i++) {
cin >> k[i] >> w[i];
}
for (i = 1; i <= N; i++) {
for (j = 1; j <= M; j++) {
if (i == 1) {
if (j >= w[i]) {
dp[i][j] = k[i];
if (dp[i][j] <= dp[i - 1][j]) {
dp[i][j] = dp[i - 1][j];
}
}
} else {
if (dp[i][j] <= dp[i - 1][j]) {
dp[i][j] = dp[i - 1][j];
}
if (j >= w[i]) {
if (k[i] + dp[i - 1][j - w[i]] > dp[i][j]) {
dp[i][j] = k[i] + dp[i - 1][j - w[i]];
}
}
}
}
}
cout << dp[N][M] << endl;
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
-11
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef pair<int, int> PI;
const double EPS = 1e-9;
#define rep(i, s, n) for (int i = (s); i < int(n); ++i)
const int N = 101;
const int V = 1e5 + 1;
int v[N], w[N];
int n, wlim;
int tv[N];
int dp[N][V];
const int INF = 0x2fffffff;
const int DEBUG = 0;
int solve(void) {
dp[0][0] = 0;
int total_v = 1;
rep(i, 0, n) { total_v += v[i]; }
rep(j, 1, total_v) { dp[0][j] = INF; }
rep(i, 1, n + 1) {
rep(j, 0, total_v) {
int res = dp[i - 1][j];
int val = v[i - 1];
int wei = w[i - 1];
if (val <= j) {
res = min(res, dp[i - 1][j - val] + wei);
} else {
res = min(res, wei);
}
if (DEBUG) {
cout << "dp[" << i << "][" << j << "] = " << res << endl;
}
dp[i][j] = res;
}
}
int q = 0;
rep(i, 0, total_v) {
if (dp[n][i] <= wlim) {
q = i;
}
}
if (DEBUG) {
cout << "q = " << q << endl;
}
int rem = q;
int sum = 0;
for (int i = n; i > 0; --i) {
int val = v[i - 1];
int wei = w[i - 1];
if (dp[i][rem] - wei == dp[i - 1][rem - val]) {
// output (i - 1)
sum += tv[i - 1];
rem -= val;
}
}
return sum;
}
int main(void) {
cin >> n >> wlim;
double max_v = 0.0;
rep(i, 0, n) {
cin >> tv[i] >> w[i];
max_v = max(max_v, (double)tv[i]);
}
double k = 200;
double scale = max(1.0, max_v / (k + 1) / n);
rep(i, 0, n) { v[i] = (int)floor(tv[i] / scale); }
cout << solve() << endl;
}
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef pair<int, int> PI;
const double EPS = 1e-9;
#define rep(i, s, n) for (int i = (s); i < int(n); ++i)
const int N = 101;
const int V = 1e5 + 1;
int v[N], w[N];
int n, wlim;
int tv[N];
int dp[N][V];
const int INF = 0x2fffffff;
const int DEBUG = 0;
int solve(void) {
dp[0][0] = 0;
int total_v = 1;
rep(i, 0, n) { total_v += v[i]; }
rep(j, 1, total_v) { dp[0][j] = INF; }
rep(i, 1, n + 1) {
rep(j, 0, total_v) {
int res = dp[i - 1][j];
int val = v[i - 1];
int wei = w[i - 1];
if (val <= j) {
res = min(res, dp[i - 1][j - val] + wei);
} else {
res = min(res, wei);
}
if (DEBUG) {
cout << "dp[" << i << "][" << j << "] = " << res << endl;
}
dp[i][j] = res;
}
}
int q = 0;
rep(i, 0, total_v) {
if (dp[n][i] <= wlim) {
q = i;
}
}
if (DEBUG) {
cout << "q = " << q << endl;
}
int rem = q;
int sum = 0;
for (int i = n; i > 0; --i) {
int val = v[i - 1];
int wei = w[i - 1];
if (val <= rem && dp[i][rem] - wei == dp[i - 1][rem - val]) {
// output (i - 1)
sum += tv[i - 1];
rem -= val;
}
}
return sum;
}
int main(void) {
cin >> n >> wlim;
double max_v = 0.0;
rep(i, 0, n) {
cin >> tv[i] >> w[i];
max_v = max(max_v, (double)tv[i]);
}
double k = 200;
double scale = max(1.0, max_v / (k + 1) / n);
rep(i, 0, n) { v[i] = (int)floor(tv[i] / scale); }
cout << solve() << endl;
}
|
replace
| 75 | 76 | 75 | 76 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <cstdlib>
#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
int larger(int x, int y) {
if (x > y) {
return x;
} else {
return y;
}
}
int main() {
int N, W;
cin >> N >> W;
int values[N];
int weight[N];
for (int i = 0; i < N; i++) {
cin >> values[i] >> weight[i];
}
int dp[N + 1][W + 1];
for (int i = 0; i < N + 1; i++) {
for (int j = 0; j < W + 1; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < N + 1; i++) {
for (int j = 0; j < W + 1; j++) {
if (j < weight[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = larger(dp[i][j - weight[i]] + values[i], dp[i][j]);
}
}
}
cout << dp[N][W] << "\n";
}
|
#include <cstdlib>
#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
int larger(int x, int y) {
if (x > y) {
return x;
} else {
return y;
}
}
int main() {
int N, W;
cin >> N >> W;
int values[N];
int weight[N];
for (int i = 0; i < N; i++) {
cin >> values[i] >> weight[i];
}
int dp[N + 1][W + 1];
for (int i = 0; i < N + 1; i++) {
for (int j = 0; j < W + 1; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < W + 1; j++) {
if (j < weight[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = larger(dp[i][j - weight[i]] + values[i], dp[i][j]);
}
}
}
cout << dp[N][W] << "\n";
}
|
replace
| 29 | 30 | 29 | 30 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int N = 0;
int W = 0;
int max = 0;
int a[1000] = {0};
int w[1000] = {0};
int v[1000] = {0};
int dp[1000][1000] = {0};
int main(void) {
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
for (int i = 1; i < W + 1; i++) {
for (int j = 0; j < N; j++) {
if (i >= w[j] && dp[i][j] == 0) {
for (int B = i; B < W + 1; B++) {
dp[B][j] = v[j];
}
}
if (i - w[j] > 0 && j > 0) {
dp[i][j] += dp[i - w[j]][j - 1];
}
if (dp[i][j] < dp[i][j - 1] && j > 0) {
dp[i][j] = dp[i][j - 1];
}
}
}
if (dp[W][N - 1] < dp[W][N - 2]) {
dp[W][N - 1] = dp[W][N - 2];
}
cout << dp[W][N - 1] << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int N = 0;
int W = 0;
int max = 0;
int a[1000] = {0};
int w[1000] = {0};
int v[1000] = {0};
int dp[10000][1000] = {0};
int main(void) {
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
for (int i = 1; i < W + 1; i++) {
for (int j = 0; j < N; j++) {
if (i >= w[j] && dp[i][j] == 0) {
for (int B = i; B < W + 1; B++) {
dp[B][j] = v[j];
}
}
if (i - w[j] > 0 && j > 0) {
dp[i][j] += dp[i - w[j]][j - 1];
}
if (dp[i][j] < dp[i][j - 1] && j > 0) {
dp[i][j] = dp[i][j - 1];
}
}
}
if (dp[W][N - 1] < dp[W][N - 2]) {
dp[W][N - 1] = dp[W][N - 2];
}
cout << dp[W][N - 1] << endl;
return 0;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p02315
|
C++
|
Memory Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
template <class T> void vin(vector<T> &v, int n) {
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
}
int N, W;
int w[1010], v[1010];
int dp[101][1010101];
int rec(int i, int j) {
if (dp[i][j] >= 0)
return dp[i][j];
int res;
if (i >= N) {
res = 0;
} else if (j < w[i]) {
res = rec(i + 1, j);
} else {
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
}
return (dp[i][j] = res);
}
int main() {
cin >> N >> W;
rep(i, N) { cin >> v[i] >> w[i]; }
fill(dp[0], dp[N], -1);
cout << rec(0, W) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
template <class T> void vin(vector<T> &v, int n) {
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
}
int N, W;
int w[1010], v[1010];
int dp[101][101010];
int rec(int i, int j) {
if (dp[i][j] >= 0)
return dp[i][j];
int res;
if (i >= N) {
res = 0;
} else if (j < w[i]) {
res = rec(i + 1, j);
} else {
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
}
return (dp[i][j] = res);
}
int main() {
cin >> N >> W;
rep(i, N) { cin >> v[i] >> w[i]; }
fill(dp[0], dp[N], -1);
cout << rec(0, W) << endl;
return 0;
}
|
replace
| 16 | 17 | 16 | 17 |
MLE
| |
p02315
|
C++
|
Runtime Error
|
#include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, m;
cin >> n >> m;
int item_v[100], item_w[100];
rep(i, n) { cin >> item_v[i] >> item_w[i]; }
int dp[101][10100] = {};
for (int i = 1; i <= n; i++) {
rep(j, 100001) {
dp[i][j] = dp[i - 1][j];
if (j - item_w[i - 1] >= 0) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - item_w[i - 1]] + item_v[i - 1]);
}
}
}
int maximum = -1;
rep(j, m + 1) { maximum = max(maximum, dp[n][j]); }
cout << maximum << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, m;
cin >> n >> m;
int item_v[100], item_w[100];
rep(i, n) { cin >> item_v[i] >> item_w[i]; }
int dp[101][10100] = {};
for (int i = 1; i <= n; i++) {
rep(j, 10001) {
dp[i][j] = dp[i - 1][j];
if (j - item_w[i - 1] >= 0) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - item_w[i - 1]] + item_v[i - 1]);
}
}
}
int maximum = -1;
rep(j, m + 1) { maximum = max(maximum, dp[n][j]); }
cout << maximum << endl;
}
|
replace
| 12 | 13 | 12 | 13 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int main() {
int N, W;
int v[N], w[N];
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
int DP[N + 1][W + 1];
for (int j = 0; j <= W; j++)
DP[0][j] = 0;
for (int i = 1; i <= N; i++)
for (int j = 0; j <= W; j++)
if (j < w[i - 1])
DP[i][j] = DP[i - 1][j];
else {
if (DP[i - 1][j] > DP[i - 1][j - w[i - 1]] + v[i - 1])
DP[i][j] = DP[i - 1][j];
else
DP[i][j] = DP[i - 1][j - w[i - 1]] + v[i - 1];
}
cout << DP[N][W] << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int N, W;
int v[101], w[101];
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
int DP[N + 1][W + 1];
for (int j = 0; j <= W; j++)
DP[0][j] = 0;
for (int i = 1; i <= N; i++)
for (int j = 0; j <= W; j++)
if (j < w[i - 1])
DP[i][j] = DP[i - 1][j];
else {
if (DP[i - 1][j] > DP[i - 1][j - w[i - 1]] + v[i - 1])
DP[i][j] = DP[i - 1][j];
else
DP[i][j] = DP[i - 1][j - w[i - 1]] + v[i - 1];
}
cout << DP[N][W] << endl;
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
-11
| |
p02315
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
#define INF 10000000;
int partition(int A[], int p, int r) {
int x = A[r];
int i = p - 1;
for (int j = p; j < r; j++) {
if (x >= A[j]) {
i = i + 1;
swap(A[i], A[j]);
}
}
swap(A[i + 1], A[r]);
return i + 1;
}
void quicksort(int A[], int p, int r) {
if (p < r) {
int q = partition(A, p, r);
quicksort(A, p, q - 1);
quicksort(A, q + 1, r);
}
}
int getNumberOfCoin(int C[], int n, int m) {
int T[50000];
for (int j = 0; j <= n; j++) {
T[j] = INF;
}
T[0] = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j <= n; j++) {
if (j - C[i] >= 0) {
T[j] = min(T[j], T[j - C[i]] + 1);
}
}
}
return T[n];
}
int knapsack(int w, int n, int v[], int ww[]) {
int W[100][10000];
for (int j = 0; j <= w; j++) {
W[0][j] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= w; j++) {
if (j - ww[i] < 0) {
W[i + 1][j] = W[i][j];
}
if (j - ww[i] >= 0) {
W[i + 1][j] = max(W[i][j], W[i][j - ww[i]] + v[i]);
}
}
}
return W[n][w];
}
int main() {
int N, W;
cin >> N >> W;
int v[100];
int w[100];
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
cout << knapsack(W, N, v, w) << endl;
}
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
#define INF 10000000;
int partition(int A[], int p, int r) {
int x = A[r];
int i = p - 1;
for (int j = p; j < r; j++) {
if (x >= A[j]) {
i = i + 1;
swap(A[i], A[j]);
}
}
swap(A[i + 1], A[r]);
return i + 1;
}
void quicksort(int A[], int p, int r) {
if (p < r) {
int q = partition(A, p, r);
quicksort(A, p, q - 1);
quicksort(A, q + 1, r);
}
}
int getNumberOfCoin(int C[], int n, int m) {
int T[50000];
for (int j = 0; j <= n; j++) {
T[j] = INF;
}
T[0] = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j <= n; j++) {
if (j - C[i] >= 0) {
T[j] = min(T[j], T[j - C[i]] + 1);
}
}
}
return T[n];
}
int knapsack(int w, int n, int v[], int ww[]) {
int W[101][10001];
for (int j = 0; j <= w; j++) {
W[0][j] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= w; j++) {
if (j - ww[i] < 0) {
W[i + 1][j] = W[i][j];
}
if (j - ww[i] >= 0) {
W[i + 1][j] = max(W[i][j], W[i][j - ww[i]] + v[i]);
}
}
}
return W[n][w];
}
int main() {
int N, W;
cin >> N >> W;
int v[100];
int w[100];
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i];
}
cout << knapsack(W, N, v, w) << endl;
}
|
replace
| 44 | 45 | 44 | 45 |
0
| |
p02315
|
C++
|
Runtime Error
|
#include <iostream>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, W;
cin >> N >> W;
int value[N];
int weight[N];
REP(n, N) {
cin >> value[n];
cin >> weight[n];
}
int dp[100][10001] = {{}};
REP(n, N) {
REP(w, W + 1) {
weight[n] > w
? dp[n + 1][w] = dp[n][w]
: dp[n + 1][w] = max(dp[n][w], dp[n][w - weight[n]] + value[n]);
}
}
cout << dp[N][W] << endl;
return 0;
}
|
#include <iostream>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, W;
cin >> N >> W;
int value[N];
int weight[N];
REP(n, N) {
cin >> value[n];
cin >> weight[n];
}
int dp[101][10002] = {{}};
REP(n, N) {
REP(w, W + 1) {
weight[n] > w
? dp[n + 1][w] = dp[n][w]
: dp[n + 1][w] = max(dp[n][w], dp[n][w - weight[n]] + value[n]);
}
}
cout << dp[N][W] << endl;
return 0;
}
|
replace
| 16 | 17 | 16 | 17 |
0
| |
p02316
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
using namespace std;
#define repeat(i, n) for (int i = 0; i < (n); ++i)
#define repeat_rev(i, n) for (int i = (n)-1; 0 <= i; ++i)
#define MAX_N 100
#define MAX_W 10000
struct item {
int v, w;
};
int N, W;
item t[MAX_N];
int dp[2][MAX_W + 1];
int main() {
cin >> N >> W;
repeat(i, N) cin >> t[i].v >> t[i].w;
int *cur = dp[0];
fill(cur, cur + W + 1, 0);
int *prv = dp[1];
repeat(n, N) {
swap(cur, prv);
repeat(w, W + 1) cur[w] =
max(prv[w], (0 <= w - t[n].w ? cur[w - t[n].w] + t[n].v : 0));
repeat(w, W + 1) cerr << cur[w] << ' ';
cerr << endl;
}
repeat_rev(i, W + 1) if (cur[i]) {
cout << cur[i] << endl;
break;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
#define repeat(i, n) for (int i = 0; i < (n); ++i)
#define repeat_rev(i, n) for (int i = (n)-1; 0 <= i; ++i)
#define MAX_N 100
#define MAX_W 10000
struct item {
int v, w;
};
int N, W;
item t[MAX_N];
int dp[2][MAX_W + 1];
int main() {
cin >> N >> W;
repeat(i, N) cin >> t[i].v >> t[i].w;
int *cur = dp[0];
fill(cur, cur + W + 1, 0);
int *prv = dp[1];
repeat(n, N) {
swap(cur, prv);
repeat(w, W + 1) cur[w] =
max(prv[w], (0 <= w - t[n].w ? cur[w - t[n].w] + t[n].v : 0));
}
repeat_rev(i, W + 1) if (cur[i]) {
cout << cur[i] << endl;
break;
}
return 0;
}
|
delete
| 27 | 29 | 27 | 27 |
0
|
0 0 4 4 8 8 12 12 16
0 0 5 5 10 10 15 15 20
0 2 5 7 10 12 15 17 20
0 2 5 8 10 13 16 18 21
|
p02316
|
C++
|
Runtime Error
|
#include <stdio.h>
int i, j, k, a, b, c[1001], d[1001], e[10001], f = -1;
int main(void) {
scanf("%d %d", &a, &b);
for (i = 0; i <= a; i++) {
for (j = 0; j <= b; j++) {
e[i] = -1;
}
}
for (i = 0; i < a; i++) {
scanf("%d %d", &c[i], &d[i]);
}
e[0] = 0;
for (i = 0; i <= b; i++) {
if (e[i] != -1) {
for (j = 0; j <= a; j++) {
if (e[i + d[j]] < e[i] + c[j]) {
e[i + d[j]] = e[i] + c[j];
}
}
}
}
for (i = 0; i <= b; i++) {
if (f < e[i]) {
f = e[i];
}
}
printf("%d\n", f);
return 0;
}
|
#include <stdio.h>
int i, j, k, a, b, c[1001], d[1001], e[10001], f = -1;
int main(void) {
scanf("%d %d", &a, &b);
for (i = 0; i <= a; i++) {
for (j = 0; j <= b; j++) {
e[i] = -1;
}
}
for (i = 0; i < a; i++) {
scanf("%d %d", &c[i], &d[i]);
}
e[0] = 0;
for (i = 0; i <= b; i++) {
if (e[i] != -1) {
for (j = 0; j <= a; j++) {
if (e[i + d[j]] < e[i] + c[j] && i + d[j] <= b) {
e[i + d[j]] = e[i] + c[j];
}
}
}
}
for (i = 0; i <= b; i++) {
if (f < e[i]) {
f = e[i];
}
}
printf("%d\n", f);
return 0;
}
|
replace
| 16 | 17 | 16 | 17 |
0
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int N, W, value[101], weight[101], dp[101][10001];
int main() {
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> value[i] >> weight[i];
}
for (int i = 0; i < N; ++i) {
for (int w = 0; w <= W; ++w) {
for (int k = 0; k * weight[i] <= w; ++k) {
dp[i + 1][w] =
max(dp[i + 1][w], dp[i][w - k * weight[i]] + k * value[i]);
}
}
}
cout << dp[N][W] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, W, value[101], weight[101], dp[101][10001];
int main() {
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> value[i] >> weight[i];
}
for (int i = 0; i < N; ++i) {
for (int w = 0; w <= W; ++w) {
if (w >= weight[i]) {
dp[i + 1][w] = max(dp[i][w], dp[i + 1][w - weight[i]] + value[i]);
} else {
dp[i + 1][w] = dp[i][w];
}
}
}
cout << dp[N][W] << endl;
}
|
replace
| 13 | 16 | 13 | 17 |
TLE
| |
p02316
|
C++
|
Time Limit Exceeded
|
#if 0
#endif
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int N, W;
int v[110];
int w[110];
int V[110][10010];
int main() {
cin >> N >> W;
for (int i = 1; i <= N; i++)
cin >> v[i] >> w[i];
for (int i = 0; i <= N; i++) {
for (int c = 0; c <= W; c++) {
if (i == 0 || c == 0)
V[i][c] = 0;
else if (c - w[i] < 0)
V[i][c] = V[i - 1][c];
else {
int n = 1;
int t = 0;
while (c - w[i] * n >= 0) {
t = max(t, v[i] * n + V[i - 1][c - w[i] * n]);
n++;
}
V[i][c] = max(t, V[i - 1][c]);
}
}
}
cout << V[N][W] << endl;
}
|
#if 0
#endif
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int N, W;
int v[110];
int w[110];
int V[110][10010];
int main() {
cin >> N >> W;
for (int i = 1; i <= N; i++)
cin >> v[i] >> w[i];
for (int i = 0; i <= N; i++) {
for (int c = 0; c <= W; c++) {
if (i == 0 || c == 0)
V[i][c] = 0;
else if (c - w[i] < 0)
V[i][c] = V[i - 1][c];
else {
int a[3] = {v[i] + V[i][c - w[i]], v[i] + V[i - 1][c - w[i]],
V[i - 1][c]};
V[i][c] = *max_element(a, a + 3);
}
}
}
cout << V[N][W] << endl;
}
|
replace
| 24 | 31 | 24 | 27 |
TLE
| |
p02316
|
C++
|
Runtime Error
|
/*
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_1_C&lang=jp
*/
#include <iostream>
using namespace std;
int v[1001], w[1001];
int n, k;
int dp[101][10001];
/*
ナップサック
iは品物の番号、jはその時の重さ
*/
void knapsack() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= k; j++) {
if (w[i] > j) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j - w[i]] + v[i]);
}
}
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> v[i] >> w[i];
}
knapsack();
cout << dp[n][k] << "\n";
}
|
/*
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_1_C&lang=jp
*/
#include <iostream>
using namespace std;
int v[1001], w[1001];
int n, k;
int dp[101][10001];
/*
ナップサック
iは品物の番号、jはその時の重さ
*/
void knapsack() {
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
if (w[i] > j) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j - w[i]] + v[i]);
}
}
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> v[i] >> w[i];
}
knapsack();
cout << dp[n][k] << "\n";
}
|
replace
| 14 | 15 | 14 | 15 |
0
| |
p02316
|
C++
|
Runtime Error
|
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int n, w_max;
int dp[100][10000];
bool f[100][100000];
vector<pair<int, int>> item(101);
int saiki(int i, int j) {
if (f[i][j]) {
return dp[i][j];
}
int res;
if (i == n) {
res = 0;
} else if (j < item[i].second) {
res = saiki(i + 1, j);
} else {
res = max(saiki(i + 1, j), saiki(i, j - item[i].second) + item[i].first);
}
dp[i][j] = res;
f[i][j] = true;
return res;
}
int main() {
cin >> n >> w_max;
for (int i = 0; i < n; i++) {
cin >> item[i].first >> item[i].second;
}
cout << saiki(0, w_max) << endl;
return 0;
}
|
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int n, w_max;
int dp[101][10001];
bool f[101][100001];
vector<pair<int, int>> item(101);
int saiki(int i, int j) {
if (f[i][j]) {
return dp[i][j];
}
int res;
if (i == n) {
res = 0;
} else if (j < item[i].second) {
res = saiki(i + 1, j);
} else {
res = max(saiki(i + 1, j), saiki(i, j - item[i].second) + item[i].first);
}
dp[i][j] = res;
f[i][j] = true;
return res;
}
int main() {
cin >> n >> w_max;
for (int i = 0; i < n; i++) {
cin >> item[i].first >> item[i].second;
}
cout << saiki(0, w_max) << endl;
return 0;
}
|
replace
| 7 | 9 | 7 | 9 |
0
| |
p02316
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
signed main() {
int a, b;
cin >> a >> b;
int dp[1001]{};
for (int c = 0; c < a; c++) {
int d, e;
cin >> d >> e;
for (int f = e; f <= b; f++) {
dp[f] = max(dp[f], dp[f - e] + d);
}
}
cout << dp[b] << endl;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
signed main() {
int a, b;
cin >> a >> b;
int dp[10001]{};
for (int c = 0; c < a; c++) {
int d, e;
cin >> d >> e;
for (int f = e; f <= b; f++) {
dp[f] = max(dp[f], dp[f - e] + d);
}
}
cout << dp[b] << endl;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <iomanip>
#include <iostream>
using namespace std;
int value[100], weight[100];
int table[101][10001] = {};
int main() {
int N, W;
cin >> N >> W;
for (int i = 0; i < N; ++i) {
cin >> value[i] >> weight[i];
}
for (int i = 1; i <= N; ++i) {
for (int w = 0; w <= W; ++w) {
table[i][w] = table[i - 1][w];
for (int n = 1; w >= n * weight[i - 1]; ++n) {
table[i][w] = max(table[i][w], n * value[i - 1] +
table[i - 1][w - n * weight[i - 1]]);
}
}
}
cout << table[N][W] << endl;
return 0;
}
|
#include <iomanip>
#include <iostream>
using namespace std;
int value[100], weight[100];
int table[101][10001] = {};
int main() {
int N, W;
cin >> N >> W;
for (int i = 0; i < N; ++i) {
cin >> value[i] >> weight[i];
}
for (int i = 1; i <= N; ++i) {
for (int w = 0; w <= W; ++w) {
if (w >= weight[i - 1])
table[i][w] =
max(table[i - 1][w], value[i - 1] + table[i][w - weight[i - 1]]);
else
table[i][w] = table[i - 1][w];
}
}
cout << table[N][W] << endl;
return 0;
}
|
replace
| 17 | 22 | 17 | 22 |
TLE
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cstdio>
int dp[101][10001];
int main() {
int n, w;
scanf("%d %d\n", &n, &w);
int val[n], wei[n];
for (int i = 1; i <= n; i++) {
scanf("%d %d\n", &val[i], &wei[i]);
}
// init. dp table
for (int i = 0; i <= n; i++) {
dp[i][0] = 0;
}
for (int j = 0; j <= w; j++) {
dp[0][j] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= w; j++) {
if (wei[i] <= j) {
dp[i][j] = std::max(dp[i - 1][j - wei[i]] + val[i], dp[i - 1][j]);
for (int k = 2;; k++) {
if (k * wei[i] <= j) {
dp[i][j] =
std::max(dp[i - 1][j - k * wei[i]] + k * val[i], dp[i][j]);
} else {
break;
}
}
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
printf("%d\n", dp[n][w]);
/*
for(int i=0; i<=n; i++){
for(int j=0; j<=w; j++){
printf("%d ",dp[i][j]);
}
printf("\n");
}
*/
return 0;
}
|
#include <algorithm>
#include <cstdio>
int dp[101][10001];
int main() {
int n, w;
scanf("%d %d\n", &n, &w);
int val[n], wei[n];
for (int i = 1; i <= n; i++) {
scanf("%d %d\n", &val[i], &wei[i]);
}
// init. dp table
for (int i = 0; i <= n; i++) {
dp[i][0] = 0;
}
for (int j = 0; j <= w; j++) {
dp[0][j] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= w; j++) {
if (wei[i] <= j) {
dp[i][j] = std::max(dp[i][j - wei[i]] + val[i], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
printf("%d\n", dp[n][w]);
/*
for(int i=0; i<=n; i++){
for(int j=0; j<=w; j++){
printf("%d ",dp[i][j]);
}
printf("\n");
}
*/
return 0;
}
|
replace
| 23 | 32 | 23 | 24 |
TLE
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
int item[101][2];
item[0][0] = 0;
item[0][1] = 0;
for (int i = 1; i < N + 1; ++i) {
int v, w;
cin >> v >> w;
item[i][0] = v;
item[i][1] = w;
}
int c[101][10001];
for (int i = 0; i < W + 1; i++) {
c[0][i] = 0;
}
for (int j = 0; j < N + 1; j++) {
c[j][0] = 0;
}
for (int i = 1; i < N + 1; ++i) {
int v = item[i][0];
int w = item[i][1];
for (int j = 1; j < W + 1; ++j) {
if (j < w) {
c[i][j] = c[i - 1][j];
} else {
int tmp = c[i - 1][j];
int max_n = j / w;
for (int k = 1; k < max_n + 1; ++k) {
if (tmp < c[i - 1][j - w * k] + v * k) {
tmp = c[i - 1][j - w * k] + v * k;
}
}
c[i][j] = tmp;
}
}
}
cout << c[N][W] << endl;
}
|
#include <iostream>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
int item[101][2];
item[0][0] = 0;
item[0][1] = 0;
for (int i = 1; i < N + 1; ++i) {
int v, w;
cin >> v >> w;
item[i][0] = v;
item[i][1] = w;
}
int c[101][10001];
for (int i = 0; i < W + 1; i++) {
c[0][i] = 0;
}
for (int j = 0; j < N + 1; j++) {
c[j][0] = 0;
}
for (int i = 1; i < N + 1; ++i) {
int v = item[i][0];
int w = item[i][1];
for (int j = 1; j < W + 1; ++j) {
if (j < w) {
c[i][j] = c[i - 1][j];
} else {
c[i][j] = max(c[i - 1][j], c[i][j - w] + v);
}
}
}
cout << c[N][W] << endl;
}
|
replace
| 30 | 38 | 30 | 31 |
TLE
| |
p02316
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int val[110], weight[10010];
int res[110][10010];
int main() {
int N, W;
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> val[i] >> weight[i];
}
// res[number][weight]
for (int i = 0; i < N + 1; i++) {
res[i][0] = 0;
}
for (int i = 0; i < W + 1; i++) {
res[0][i] = 0;
}
for (int i = 1; i < N + 1; i++) {
for (int j = 1; j < W + 1; j++) {
if (weight[i - 1] > j) {
res[i][j] = res[i - 1][j];
} else {
int resmax = 0;
for (int l = 1; weight[i - 1] * l < j + 1; l++)
if (resmax < max((val[i - 1] * l + res[i - l][j - weight[i - 1] * l]),
res[i - 1][j])) {
resmax = max((val[i - 1] * l + res[i - l][j - weight[i - 1] * l]),
res[i - 1][j]);
}
res[i][j] = resmax;
}
}
}
// for(int j=1;j<W+1;j++) {
// cout << endl;
// for(int i=1;i<N+1;i++) {
// cout << res[i][j] << " ";
// }
// }
cout << res[N][W] << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int val[110], weight[10010];
int res[110][10010];
int main() {
int N, W;
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> val[i] >> weight[i];
}
// res[number][weight]
for (int i = 0; i < N + 1; i++) {
res[i][0] = 0;
}
for (int i = 0; i < W + 1; i++) {
res[0][i] = 0;
}
for (int i = 1; i < N + 1; i++) {
for (int j = 1; j < W + 1; j++) {
if (weight[i - 1] > j) {
res[i][j] = res[i - 1][j];
} else {
res[i][j] = max(res[i - 1][j], val[i - 1] + res[i][j - weight[i - 1]]);
}
}
}
// for(int j=1;j<W+1;j++) {
// cout << endl;
// for(int i=1;i<N+1;i++) {
// cout << res[i][j] << " ";
// }
// }
cout << res[N][W] << endl;
return 0;
}
|
replace
| 31 | 40 | 31 | 32 |
-11
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <climits>
#include <iostream>
using namespace std;
int main() {
int n, ws;
cin >> n >> ws;
int v[n + 1], w[n + 1];
for (int i = 1; i <= n; i++)
cin >> v[i] >> w[i];
int dp[n + 1][ws + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= ws; j++)
dp[i][j] = 0;
}
for (int k = 1; k <= n; k++) {
for (int i = 0; i <= ws; i++) {
int temp = 0, j = 0;
while (i >= w[k] * j) {
dp[k][i] = max(dp[k][i], dp[k - 1][i - w[k] * j] + v[k] * j);
j++;
}
}
}
cout << dp[n][ws] << endl;
return 0;
}
|
#include <algorithm>
#include <climits>
#include <iostream>
using namespace std;
int main() {
int n, ws;
cin >> n >> ws;
int v[n + 1], w[n + 1];
for (int i = 1; i <= n; i++)
cin >> v[i] >> w[i];
int dp[n + 1][ws + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= ws; j++)
dp[i][j] = 0;
}
for (int k = 1; k <= n; k++) {
for (int i = 0; i <= ws; i++) {
if (i < w[k])
dp[k][i] = dp[k - 1][i];
else
dp[k][i] = max(dp[k - 1][i], dp[k][i - w[k]] + v[k]);
}
}
cout << dp[n][ws] << endl;
return 0;
}
|
replace
| 20 | 25 | 20 | 24 |
TLE
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef unsigned int ui;
// using ui = unsigned int;
int main(void) {
string line;
ui max_n, max_w;
cin >> max_n >> max_w;
ui v, w;
vector<ui> table(max_w + 1, 0);
for (int i = 1; i <= max_n; ++i) {
cin >> v >> w;
ui dv = v, dw = w;
for (; w <= max_w; v += dv, w += dw) {
for (int j = max_w - w; j >= 1; --j) {
if (table[j] != 0 && table[w + j] < table[j] + v)
table[w + j] = table[j] + v;
}
if (w <= max_w && table[w] < v)
table[w] = v;
}
}
cout << *(max_element(begin(table), end(table))) << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef unsigned int ui;
// using ui = unsigned int;
int main(void) {
string line;
ui max_n, max_w;
cin >> max_n >> max_w;
ui v, w;
vector<ui> table(max_w + 1, 0);
for (int i = 1; i <= max_n; ++i) {
cin >> v >> w;
if (w <= max_w && table[w] < v)
table[w] = v;
for (int j = 1; j <= max_w - w; j++) {
if (table[j] != 0 && table[w + j] < table[j] + v)
table[w + j] = table[j] + v;
}
}
cout << *(max_element(begin(table), end(table))) << endl;
return 0;
}
|
replace
| 19 | 27 | 19 | 24 |
TLE
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> int_pair;
typedef pair<ll, ll> ll_pair;
#define FOR(I, A, B) for (int I = (A); I < (B); ++I)
const int N = 100;
const int W = 10000;
int n, w, v[N], wi[N];
int dp[N + 1][W + 1];
int rec(int i, int j) {
if (dp[i][j] != -1) {
return dp[i][j];
}
int res;
if (i == n) {
res = 0;
} else if (j < wi[i]) {
res = rec(i + 1, j);
} else {
int a = rec(i + 1, j);
int b = rec(i + 1, j - wi[i]) + v[i];
int k = 2;
while (j - wi[i] * k >= 0) {
int c = rec(i + 1, j - wi[i] * k) + v[i] * k;
if (c > b) {
b = c;
}
k++;
}
res = max(a, b);
}
return dp[i][j] = res;
}
int main() {
FOR(i, 0, N + 1) FOR(j, 0, W + 1) dp[i][j] = -1;
cin >> n >> w;
FOR(i, 0, n) { cin >> v[i] >> wi[i]; }
cout << rec(0, w) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> int_pair;
typedef pair<ll, ll> ll_pair;
#define FOR(I, A, B) for (int I = (A); I < (B); ++I)
const int N = 100;
const int W = 10000;
int n, w, v[N], wi[N];
int dp[N + 1][W + 1];
int rec(int i, int j) {
if (dp[i][j] != -1) {
return dp[i][j];
}
int res;
if (i == n) {
res = 0;
} else if (j < wi[i]) {
res = rec(i + 1, j);
} else {
int a = rec(i + 1, j);
int b = rec(i, j - wi[i]) + v[i];
res = max(a, b);
}
return dp[i][j] = res;
}
int main() {
FOR(i, 0, N + 1) FOR(j, 0, W + 1) dp[i][j] = -1;
cin >> n >> w;
FOR(i, 0, n) { cin >> v[i] >> wi[i]; }
cout << rec(0, w) << endl;
return 0;
}
|
replace
| 22 | 31 | 22 | 23 |
TLE
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long calc(int i, int c, const vector<int> &v, const vector<int> &w,
vector<vector<long long>> &ans) {
if (i <= -1 || c < 0) {
return 0;
} else if (c == 0) {
ans[i][c] = 0;
} else if (ans[i][c] >= 0) {
return ans[i][c];
} else if (c - w[i] < 0) {
ans[i][c] = calc(i - 1, c, v, w, ans);
} else {
int p = 1;
long long q = -1;
while (c - p * w[i] >= 0) {
q = max(q, p * v[i] + calc(i - 1, c - p * w[i], v, w, ans));
p++;
}
ans[i][c] = max(q, calc(i - 1, c, v, w, ans));
// ans[i][c] = max(
// v[i] + calc(i-1, c - w[i], v, w, ans),
// calc(i-1, c, v, w, ans)
// );
}
return ans[i][c];
}
int main() {
int n, c;
cin >> n >> c;
vector<int> v(n), w(n);
for (int i = 0; i < n; i++)
cin >> v[i] >> w[i];
vector<vector<long long>> ans(n, vector<long long>(c + 1, -1));
cout << calc(n - 1, c, v, w, ans) << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long calc(int i, int c, const vector<int> &v, const vector<int> &w,
vector<vector<long long>> &ans) {
if (i <= -1 || c < 0) {
return 0;
} else if (c == 0) {
ans[i][c] = 0;
} else if (ans[i][c] >= 0) {
return ans[i][c];
} else if (c - w[i] < 0) {
ans[i][c] = calc(i - 1, c, v, w, ans);
} else {
// int p = 1;
// long long q = -1;
// while(c - p*w[i] >= 0){
// q = max(
// q,
// p*v[i] + calc(i-1, c - p*w[i], v, w, ans)
// );
// p++;
// }
ans[i][c] =
max(v[i] + calc(i, c - w[i], v, w, ans), calc(i - 1, c, v, w, ans));
// ans[i][c] = max(
// v[i] + calc(i-1, c - w[i], v, w, ans),
// calc(i-1, c, v, w, ans)
// );
}
return ans[i][c];
}
int main() {
int n, c;
cin >> n >> c;
vector<int> v(n), w(n);
for (int i = 0; i < n; i++)
cin >> v[i] >> w[i];
vector<vector<long long>> ans(n, vector<long long>(c + 1, -1));
cout << calc(n - 1, c, v, w, ans) << endl;
return 0;
}
|
replace
| 16 | 23 | 16 | 27 |
TLE
| |
p02316
|
C++
|
Runtime Error
|
#include <stdio.h>
int dp[10100];
int main(void) {
int n, w;
scanf("%d %d", &n, &w);
int i, j;
for (i = 0; i <= w; i++) {
dp[i] = -1;
}
dp[0] = 0;
for (i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
for (j = 0; j <= w; j++) {
if (dp[j] >= 0 && dp[j + b] < dp[j] + a && j + b <= w) {
dp[j + b] = dp[j] + a;
}
}
}
int max = 0;
for (i = 0; i <= w; i++) {
if (dp[i] > max) {
max = dp[i];
}
}
printf("%d\n", max);
return 0;
}
|
#include <stdio.h>
int dp[20100];
int main(void) {
int n, w;
scanf("%d %d", &n, &w);
int i, j;
for (i = 0; i <= w; i++) {
dp[i] = -1;
}
dp[0] = 0;
for (i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
for (j = 0; j <= w; j++) {
if (dp[j] >= 0 && dp[j + b] < dp[j] + a && j + b <= w) {
dp[j + b] = dp[j] + a;
}
}
}
int max = 0;
for (i = 0; i <= w; i++) {
if (dp[i] > max) {
max = dp[i];
}
}
printf("%d\n", max);
return 0;
}
|
replace
| 1 | 2 | 1 | 2 |
0
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cstring>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ll long long
#define INF 1000000001
#define mod 1000000007
#define p pair<int, int>
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
using namespace std;
int POW(int x, int y) { return int(pow(double(x), double(y))); }
int main() {
int n;
cin >> n;
int weight;
cin >> weight;
vector<int> w(n), v(n);
rep(i, n) { cin >> v[i] >> w[i]; }
vector<vector<int>> a(n);
rep(i, n) {
a[i].resize(weight + 1);
rep(j, weight + 1) {
if (i == 0) {
a[0][j] = (j / w[0]) * v[0];
/*
if(j>=w[0])a[0][j]=v[0];
else a[0][j]=0;
*/
} else {
int k = 0;
int m = a[i - 1][j];
while (j - k * w[i] >= 0) {
m = max(m, a[i - 1][j - k * w[i]] + k * v[i]);
k++;
}
a[i][j] = m;
/*
if(j<w[i]) a[i][j]=a[i-1][j];
else a[i][j]=max(a[i-1][j],a[i-1][j-w[i]]+v[i]);
*/
}
}
}
cout << a[n - 1][weight] << endl;
}
|
#include <algorithm>
#include <cstring>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ll long long
#define INF 1000000001
#define mod 1000000007
#define p pair<int, int>
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
using namespace std;
int POW(int x, int y) { return int(pow(double(x), double(y))); }
int main() {
int n;
cin >> n;
int weight;
cin >> weight;
vector<int> w(n), v(n);
rep(i, n) { cin >> v[i] >> w[i]; }
vector<vector<int>> a(n);
rep(i, n) {
a[i].resize(weight + 1);
rep(j, weight + 1) {
if (i == 0) {
a[0][j] = (j / w[0]) * v[0];
/*
if(j>=w[0])a[0][j]=v[0];
else a[0][j]=0;
*/
} else {
if (j < w[i])
a[i][j] = a[i - 1][j];
else
a[i][j] = max(a[i - 1][j],
max(a[i - 1][j - w[i]] + v[i], a[i][j - w[i]] + v[i]));
}
}
}
cout << a[n - 1][weight] << endl;
}
|
replace
| 46 | 57 | 46 | 51 |
TLE
| |
p02316
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
int main() {
int n, w;
struct {
int v, w;
} item[101];
cin >> n >> w;
for (int i = 0; i <= n; i++)
cin >> item[i].v >> item[i].w;
int dp[101][10001] = {};
for (int i = 0; i <= n; i++)
for (int j = 1; j <= w; j++)
if (item[i].w <= j)
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j - item[i].w] + item[i].v);
else
dp[i + 1][j] = dp[i][j];
cout << dp[n][w] << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
int main() {
int n, w;
struct {
int v, w;
} item[101];
cin >> n >> w;
for (int i = 0; i <= n; i++)
cin >> item[i].v >> item[i].w;
int dp[101][10001] = {};
for (int i = 0; i < n; i++)
for (int j = 0; j <= w; j++)
if (item[i].w <= j)
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j - item[i].w] + item[i].v);
else
dp[i + 1][j] = dp[i][j];
cout << dp[n][w] << endl;
return 0;
}
|
replace
| 25 | 27 | 25 | 27 |
0
| |
p02316
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <string>
#include <utility>
using namespace std;
#define REP(var, count) for (int var = 0; var < count; var++)
int DP[110][10010]; // N???????????§????????????????¨?w
int main(void) {
int N, W;
cin >> N >> W;
REP(i, N) {
int v, w;
cin >> v >> w;
REP(c, W + 1) {
DP[i + 1][c] = DP[i][c];
for (int cnt = 1; cnt <= c / w; cnt++) {
DP[i + 1][c] = max(DP[i][c - w * cnt] + v * cnt, DP[i + 1][c]);
}
}
}
int ret = 0;
REP(c, W + 1) { ret = max(ret, DP[N][c]); }
cout << ret << endl;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <utility>
using namespace std;
#define REP(var, count) for (int var = 0; var < count; var++)
int DP[110][10010]; // N???????????§????????????????¨?w
int main(void) {
int N, W;
cin >> N >> W;
REP(i, N) {
int v, w;
cin >> v >> w;
REP(c, W + 1) {
if (c < w) {
// ????????????????????????
DP[i + 1][c] = DP[i][c];
} else {
DP[i + 1][c] = max({DP[i][c - w] + v, DP[i + 1][c - w] + v, DP[i][c]});
}
}
}
int ret = 0;
REP(c, W + 1) { ret = max(ret, DP[N][c]); }
cout << ret << endl;
}
|
replace
| 21 | 24 | 21 | 26 |
TLE
| |
p02316
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define inf 1e9
#define ll long long
#define ull unsigned long long
#define M 1000000007
#define P pair<int, int>
#define PLL pair<ll, ll>
#define FOR(i, m, n) for (int i = (int)m; i < (int)n; i++)
#define RFOR(i, m, n) for (int i = (int)m; i >= (int)n; i--)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) RFOR(i, n, 0)
#define all(a) a.begin(), a.end()
#define IN(n, a) \
rep(i, n) { cin >> a[i]; }
const int vx[4] = {0, 1, 0, -1};
const int vy[4] = {1, 0, -1, 0};
#define PI 3.14159265
int N, W;
int dp[1100] = {};
int v[1000], w[1000];
int main() {
cin >> N >> W;
rep(i, N) { cin >> v[i] >> w[i]; }
int ans = 0;
rep(i, W + 1) {
rep(j, N) {
if (i - w[j] < 0)
continue;
dp[i] = max(dp[i], dp[i - w[j]] + v[j]);
ans = max(ans, dp[i]);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define inf 1e9
#define ll long long
#define ull unsigned long long
#define M 1000000007
#define P pair<int, int>
#define PLL pair<ll, ll>
#define FOR(i, m, n) for (int i = (int)m; i < (int)n; i++)
#define RFOR(i, m, n) for (int i = (int)m; i >= (int)n; i--)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) RFOR(i, n, 0)
#define all(a) a.begin(), a.end()
#define IN(n, a) \
rep(i, n) { cin >> a[i]; }
const int vx[4] = {0, 1, 0, -1};
const int vy[4] = {1, 0, -1, 0};
#define PI 3.14159265
int N, W;
int dp[110000] = {};
int v[1000], w[1000];
int main() {
cin >> N >> W;
rep(i, N) { cin >> v[i] >> w[i]; }
int ans = 0;
rep(i, W + 1) {
rep(j, N) {
if (i - w[j] < 0)
continue;
dp[i] = max(dp[i], dp[i - w[j]] + v[j]);
ans = max(ans, dp[i]);
}
}
cout << ans << endl;
}
|
replace
| 20 | 21 | 20 | 21 |
0
| |
p02317
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
int b[10001];
int main() {
int n, temp;
vector<int> a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> temp;
a.push_back(temp);
}
fill(b, b + n, 1 << 30);
for (int i = 0; i < n; i++) {
*lower_bound(b, b + n, a[i]) = a[i];
}
int res = 0;
res = lower_bound(b, b + n, 1 << 30) - b;
cout << res << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
int b[100001];
int main() {
int n, temp;
vector<int> a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> temp;
a.push_back(temp);
}
fill(b, b + n, 1 << 30);
for (int i = 0; i < n; i++) {
*lower_bound(b, b + n, a[i]) = a[i];
}
int res = 0;
res = lower_bound(b, b + n, 1 << 30) - b;
cout << res << endl;
return 0;
}
|
replace
| 8 | 9 | 8 | 9 |
0
| |
p02317
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define MAX_N 100010
int n, dat[2 * (MAX_N)-1];
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
for (int i = 0; i < 2 * n - 1; i++)
dat[i] = 0;
}
void update(int k, int a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
//[a,b)
int query(int a, int b, int k = 0, int l = 0, int r = n) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
int main() {
cin >> n;
int tn = n;
vector<int> a(100010), b;
for (int i = 0; i < n; i++) {
cin >> a[i];
b.push_back(a[i]);
}
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) {
a[i] = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
}
init(n);
for (int i = 0; i < tn; i++) {
int t = query(0, a[i]);
if (dat[a[i] + n - 1] >= t + 1)
continue;
update(a[i], t + 1);
}
cout << query(0, tn) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MAX_N 1000100
int n, dat[2 * (MAX_N)-1];
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
for (int i = 0; i < 2 * n - 1; i++)
dat[i] = 0;
}
void update(int k, int a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
//[a,b)
int query(int a, int b, int k = 0, int l = 0, int r = n) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
int main() {
cin >> n;
int tn = n;
vector<int> a(100010), b;
for (int i = 0; i < n; i++) {
cin >> a[i];
b.push_back(a[i]);
}
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) {
a[i] = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
}
init(n);
for (int i = 0; i < tn; i++) {
int t = query(0, a[i]);
if (dat[a[i] + n - 1] >= t + 1)
continue;
update(a[i], t + 1);
}
cout << query(0, tn) << endl;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02317
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <vector>
#define F first
#define S second
using namespace std;
typedef pair<int, int> P;
const int INF = 1 << 30, Array = 0x1e6;
int main() {
int n;
int seq[Array], dp[Array];
scanf("%d", &n);
fill(dp, dp + n, INF);
for (int i = 0; i < n; i++)
scanf("%d", &seq[i]);
for (int i = 0; i < n; i++)
*lower_bound(dp, dp + n, seq[i]) = seq[i];
cout << lower_bound(dp, dp + n, INF) - dp << endl;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <vector>
#define F first
#define S second
using namespace std;
typedef pair<int, int> P;
const int INF = 1 << 30, Array = int(1e5);
int main() {
int n;
int seq[Array], dp[Array];
scanf("%d", &n);
fill(dp, dp + n, INF);
for (int i = 0; i < n; i++)
scanf("%d", &seq[i]);
for (int i = 0; i < n; i++)
*lower_bound(dp, dp + n, seq[i]) = seq[i];
cout << lower_bound(dp, dp + n, INF) - dp << endl;
return 0;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p02317
|
C++
|
Runtime Error
|
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
typedef long long i64;
int CeilIndex(const vector<i64> &tail, int l, int r, i64 key) {
while (r - l > 1) {
int m = (l + r) / 2;
if (tail[m] >= key)
r = m;
else
l = m;
}
return r;
}
vector<i64> LIS(const vector<i64> &vec) {
vector<i64> tail;
tail.push_back(vec[0]);
for (int i = 1; i < vec.size(); ++i) {
if (vec[i] < tail[0])
tail[0] = vec[i];
else if (vec[i] > tail.back())
tail.push_back(vec[i]);
else {
tail[CeilIndex(tail, 0, vec.size(), vec[i])] = vec[i];
}
}
return tail;
}
#include <iostream>
int main() {
int n;
cin >> n;
vector<i64> a;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
a.push_back(t);
}
cout << LIS(a).size() << endl;
}
|
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
typedef long long i64;
int CeilIndex(const vector<i64> &tail, int l, int r, i64 key) {
while (r - l > 1) {
int m = (l + r) / 2;
if (tail[m] >= key)
r = m;
else
l = m;
}
return r;
}
vector<i64> LIS(const vector<i64> &vec) {
vector<i64> tail;
tail.push_back(vec[0]);
for (int i = 1; i < vec.size(); ++i) {
if (vec[i] < tail[0])
tail[0] = vec[i];
else if (vec[i] > tail.back())
tail.push_back(vec[i]);
else {
tail[CeilIndex(tail, -1, tail.size() - 1, vec[i])] = vec[i];
}
}
return tail;
}
#include <iostream>
int main() {
int n;
cin >> n;
vector<i64> a;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
a.push_back(t);
}
cout << LIS(a).size() << endl;
}
|
replace
| 27 | 28 | 27 | 28 |
0
| |
p02317
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n + 1, -1);
int l = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (v[l] < a) {
v[l + 1] = a;
l++;
} else {
*lower_bound(v.begin(), v.end(), a) = a;
}
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n + 1, -1);
int l = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (v[l] < a) {
v[l + 1] = a;
l++;
} else {
*lower_bound(v.begin(), v.begin() + l, a) = a;
}
}
cout << l << endl;
return 0;
}
|
replace
| 16 | 17 | 16 | 17 |
-6
|
Fatal glibc error: malloc assertion failure in sysmalloc: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)
|
p02317
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
vector<long long int> dp(N + 1, LLONG_MAX / 6);
dp[0] = LLONG_MIN;
for (size_t i = 0; i < N; i++) {
long long int a;
cin >> a;
for (size_t j = 0; j < N; j++) {
if (dp[j] < a) {
dp[j + 1] = min(dp[j + 1], a);
} else {
break;
}
}
}
long long int ans = 0;
for (size_t i = 0; i < N + 1; i++) {
if (dp[i] != LLONG_MAX / 6) {
ans = i;
} else {
break;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
vector<long long int> dp(N + 1, LLONG_MAX / 6);
dp[0] = LLONG_MIN;
for (size_t i = 0; i < N; i++) {
long long int a;
cin >> a;
for (size_t j = lower_bound(dp.begin(), dp.end(), a) - dp.begin() - 1;
j < N; j++) {
if (dp[j] < a) {
dp[j + 1] = min(dp[j + 1], a);
} else {
break;
}
}
}
long long int ans = 0;
for (size_t i = 0; i < N + 1; i++) {
if (dp[i] != LLONG_MAX / 6) {
ans = i;
} else {
break;
}
}
cout << ans << endl;
}
|
replace
| 11 | 12 | 11 | 13 |
TLE
| |
p02317
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define MAX 100000
#define INF 1000000001
int a[MAX];
int l[MAX];
int main() {
int n;
cin >> n;
REP(i, n) {
cin >> a[i];
l[i] = INF;
}
int length = 0;
l[length] = a[0];
length++;
FOR(i, 1, n) {
if (l[length - 1] < a[i]) {
l[length] = a[i];
length++;
} else {
int j = length;
while (1) {
j--;
if (l[j] > a[i]) {
l[j] = a[i];
break;
}
}
}
}
cout << length << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define MAX 100000
#define INF 1000000001
int a[MAX];
int l[MAX];
int main() {
int n;
cin >> n;
REP(i, n) {
cin >> a[i];
l[i] = INF;
}
int length = 0;
l[length] = a[0];
length++;
FOR(i, 1, n) {
if (l[length - 1] < a[i]) {
l[length] = a[i];
length++;
} else {
REP(j, length) {
if (j == 0 && l[0] > a[i]) {
l[0] = a[i];
break;
} else if (l[j] < a[i] && l[j + 1] > a[i]) {
l[j + 1] = a[i];
break;
}
}
}
}
cout << length << endl;
return 0;
}
|
replace
| 24 | 29 | 24 | 30 |
0
| |
p02317
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
int main(void) {
int n, input;
cin >> n;
vector<int> dp(n + 1, INF);
dp[0] = -INF;
for (int i = 0; i < n; i++) {
cin >> input;
vector<int>::iterator it = upper_bound(dp.begin(), dp.end(), input);
if (*(it - 1) < input)
*it = input;
}
int ans = 0;
while (dp[ans + 1] < INF) {
++ans;
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
int main(void) {
int n, input;
cin >> n;
vector<int> dp(n + 2, INF);
dp[0] = -INF;
for (int i = 0; i < n; i++) {
cin >> input;
vector<int>::iterator it = upper_bound(dp.begin(), dp.end(), input);
if (*(it - 1) < input)
*it = input;
}
int ans = 0;
while (dp[ans + 1] < INF) {
++ans;
}
cout << ans << endl;
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02317
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define repr(i, j) for (int i = j; i >= 0; --i)
#define INF (1 << 30)
#define MOD 1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
int N, a[100000];
int dp[100000];
int main() {
scanf("%d", &N);
rep(i, N) scanf("%d", &a[i]);
int ans = 0;
rep(i, N) {
dp[i] = 1;
FOR(j, 0, i) if (a[j] < a[i]) { dp[i] = max(dp[i], dp[j] + 1); }
ans = max(ans, dp[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define repr(i, j) for (int i = j; i >= 0; --i)
#define INF (1 << 30)
#define MOD 1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
int N, a[100000];
int dp[100000];
int main() {
scanf("%d", &N);
rep(i, N) scanf("%d", &a[i]);
fill(dp, dp + N, INF);
rep(i, N) { *lower_bound(dp, dp + N, a[i]) = a[i]; }
printf("%d\n", lower_bound(dp, dp + N, INF) - dp);
return 0;
}
|
replace
| 20 | 27 | 20 | 23 |
TLE
| |
p02318
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
using namespace std;
int L[1000][1000];
int main() {
string a, b;
cin >> a;
cin >> b;
for (int i = 0; i <= a.size(); ++i)
L[i][0] = i;
for (int i = 0; i <= b.size(); ++i)
L[0][i] = i;
for (int i = 1; i <= a.size(); ++i) {
for (int j = 1; j <= b.size(); ++j) {
int k = 0;
if (a[i - 1] == b[j - 1])
k = 0;
else
k = 1;
L[i][j] = min(L[i - 1][j] + 1, min(L[i][j - 1] + 1, L[i - 1][j - 1] + k));
}
}
cout << L[a.size()][b.size()] << endl;
}
|
#include <iostream>
#include <string>
using namespace std;
int L[1001][1001];
int main() {
string a, b;
cin >> a;
cin >> b;
for (int i = 0; i <= a.size(); ++i)
L[i][0] = i;
for (int i = 0; i <= b.size(); ++i)
L[0][i] = i;
for (int i = 1; i <= a.size(); ++i) {
for (int j = 1; j <= b.size(); ++j) {
int k = 0;
if (a[i - 1] == b[j - 1])
k = 0;
else
k = 1;
L[i][j] = min(L[i - 1][j] + 1, min(L[i][j - 1] + 1, L[i - 1][j - 1] + k));
}
}
cout << L[a.size()][b.size()] << endl;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p02318
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int dp[1000][1000]; // minimum edit distance
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s1;
string s2;
cin >> s1;
cin >> s2;
// init. dp table
for (int i = 0; i <= s1.length(); i++) {
dp[i][0] = i;
}
for (int j = 0; j <= s2.length(); j++) {
dp[0][j] = j;
}
for (int i = 1; i <= s1.length(); i++) {
for (int j = 1; j <= s2.length(); j++) {
int RepCost = s1[i - 1] == s2[j - 1] ? 0 : 1;
dp[i][j] = min(min(dp[i][j - 1] + 1, // insertion
dp[i - 1][j] + 1), // deletion
dp[i - 1][j - 1] + RepCost // replacement
);
}
}
/*
for(int i=0; i<=s1.length(); i++){
for(int j=0; j<=s2.length(); j++){
cout << dp[i][j] << " ";
}
cout << "\n";
}
*/
cout << dp[s1.length()][s2.length()] << "\n";
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int dp[1001][1001]; // minimum edit distance
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s1;
string s2;
cin >> s1;
cin >> s2;
// init. dp table
for (int i = 0; i <= s1.length(); i++) {
dp[i][0] = i;
}
for (int j = 0; j <= s2.length(); j++) {
dp[0][j] = j;
}
for (int i = 1; i <= s1.length(); i++) {
for (int j = 1; j <= s2.length(); j++) {
int RepCost = s1[i - 1] == s2[j - 1] ? 0 : 1;
dp[i][j] = min(min(dp[i][j - 1] + 1, // insertion
dp[i - 1][j] + 1), // deletion
dp[i - 1][j - 1] + RepCost // replacement
);
}
}
/*
for(int i=0; i<=s1.length(); i++){
for(int j=0; j<=s2.length(); j++){
cout << dp[i][j] << " ";
}
cout << "\n";
}
*/
cout << dp[s1.length()][s2.length()] << "\n";
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p02318
|
C++
|
Runtime Error
|
class _in {
struct my_iterator {
int it;
const bool rev;
explicit constexpr my_iterator(int it_, bool rev = false)
: it(it_), rev(rev) {}
constexpr int operator*() { return it; }
constexpr bool operator!=(my_iterator &r) { return it != r.it; }
void operator++() { rev ? --it : ++it; }
};
const my_iterator i, n;
public:
explicit constexpr _in(int n) : i(0), n(n) {}
explicit constexpr _in(int i, int n) : i(i, n < i), n(n) {}
constexpr const my_iterator &begin() { return i; }
constexpr const my_iterator &end() { return n; }
};
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int N = s1.size(), M = s2.size();
vector<vector<int>> dp(N + 1, vector<int>(M + 1, 0));
for (int i : _in(N + 1))
dp[i][0] = i;
for (int j : _in(N + 1))
dp[0][j] = j;
for (int i : _in(N))
for (int j : _in(M)) {
dp[i + 1][j + 1] = dp[i][j];
if (s1[i] != s2[j])
++dp[i + 1][j + 1];
int temp = min(dp[i][j + 1] + 1, dp[i + 1][j] + 1);
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], temp);
}
cout << dp[N][M] << endl;
}
|
class _in {
struct my_iterator {
int it;
const bool rev;
explicit constexpr my_iterator(int it_, bool rev = false)
: it(it_), rev(rev) {}
constexpr int operator*() { return it; }
constexpr bool operator!=(my_iterator &r) { return it != r.it; }
void operator++() { rev ? --it : ++it; }
};
const my_iterator i, n;
public:
explicit constexpr _in(int n) : i(0), n(n) {}
explicit constexpr _in(int i, int n) : i(i, n < i), n(n) {}
constexpr const my_iterator &begin() { return i; }
constexpr const my_iterator &end() { return n; }
};
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int N = s1.size(), M = s2.size();
vector<vector<int>> dp(N + 1, vector<int>(M + 1, 0));
for (int i : _in(N + 1))
dp[i][0] = i;
for (int j : _in(M + 1))
dp[0][j] = j;
for (int i : _in(N))
for (int j : _in(M)) {
dp[i + 1][j + 1] = dp[i][j];
if (s1[i] != s2[j])
++dp[i + 1][j + 1];
int temp = min(dp[i][j + 1] + 1, dp[i + 1][j] + 1);
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], temp);
}
cout << dp[N][M] << endl;
}
|
replace
| 29 | 30 | 29 | 30 |
0
| |
p02318
|
C++
|
Runtime Error
|
#include <algorithm> // require sort next_permutation count __gcd reverse etc.
#include <cctype> // require tolower, toupper
#include <cfloat>
#include <climits>
#include <cmath> // require fabs
#include <cstdio> // require scanf printf
#include <cstdlib> // require abs exit atof atoi
#include <cstring> // require memset
#include <ctime> // require srand
#include <deque>
#include <fstream> // require freopen
#include <functional>
#include <iomanip> // require setw
#include <iostream>
#include <limits>
#include <map>
#include <numeric> // require accumulate
#include <queue>
#include <set>
#include <sstream> // require stringstream
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(A) A.begin(), A.end()
#define INF 1 << 10
/*
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_1_E&lang=jp
編集距離(Edit Distance)
I: 1文字をカーソル位置に挿入する
D: カーソル位置の1文字を削除する
S: カーソル位置の1文字を置き換える
M: 文字が等しい場合はそのままカーソル位置を1文字分移動する
s: 変更前の文字列（文字列先頭にスペース' ' を入れる）
t: 変更後の文字列（文字列先頭にスペース' ' を入れる）
dp[0..N][0..M] = INF
dp[0][0] = 0
dp[i][0] = dp[i-1][0] + cost['D'];
dp[0][j] = dp[0][j-1] + cost['I'];
Iの場合 dp[i][j] = min (dp[i][j], dp[i][j-1] + cost['I'] );
Dの場合 dp[i][j] = min (dp[i][j], dp[i-1][j] + cost['D'] );
Sの場合 dp[i][j] = min (dp[i][j], dp[i-1][j-1] + cost['S'] );
Mの場合 dp[i][j] = min (dp[i][j], (s[i] == t[j] のとき | dp[i-1][j-1] +
cost['M'] ) );
*/
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_N = 1001;
const int MAX_M = 1001;
const char com[] = {'I', 'D', 'S', 'M'};
const int cost[] = {1, 1, 1, 0};
int N, M;
int dp[MAX_N][MAX_M];
char ope[MAX_N][MAX_M];
/*
void disp_ope(void ){
rep (i, N+1 ){
rep (j, M+1 ){
if (i == 0 && j == 0 ) cerr << '_';
else
cerr << ope[i][j];
} // end rep
cerr << endl;
} // end rep
}
*/
int solve(string s, string t) {
map<char, int> c;
c.clear();
rep(i, sizeof(com) / sizeof(com[0])) c[com[i]] = cost[i];
rep(i, N + 1) rep(j, M + 1) dp[i][j] = INF;
dp[0][0] = 0;
for (int j = 1; j <= M; j++) {
ope[0][j] = 'I';
dp[0][j] = dp[0][j - 1] + c['I'];
} // end for
for (int i = 1; i <= N; i++) {
ope[i][0] = 'D';
dp[i][0] = dp[i - 1][0] + c['D'];
} // end for
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
int k = INF;
int nop = 0;
int pre = -1;
map<char, int>::iterator it = c.begin();
for (; it != c.end(); it++) {
char cc = (*it).first;
int ct = (*it).second;
switch (cc) {
case 'I':
pre = dp[i][j - 1] + ct;
if (k > pre)
k = pre, nop = cc;
break;
case 'D':
pre = dp[i - 1][j] + ct;
if (k > pre)
k = pre, nop = cc;
break;
case 'S':
pre = dp[i - 1][j - 1] + ct;
if (k > pre)
k = pre, nop = cc;
break;
case 'M':
pre = dp[i - 1][j - 1] + ct;
if (s[i] == t[j] && k > pre)
k = pre, nop = cc;
break;
} // end switch
} // end for
dp[i][j] = k;
ope[i][j] = nop;
} // end for
} // end for
// disp_ope();
return dp[N][M];
}
int main() {
memset(ope, 0, sizeof(ope));
ios_base::sync_with_stdio(0);
string s, t;
cin >> s >> t;
s = ' ' + s;
t = ' ' + t;
N = s.length();
M = t.length();
int res = solve(s, t);
cout << res << endl;
return 0;
}
|
#include <algorithm> // require sort next_permutation count __gcd reverse etc.
#include <cctype> // require tolower, toupper
#include <cfloat>
#include <climits>
#include <cmath> // require fabs
#include <cstdio> // require scanf printf
#include <cstdlib> // require abs exit atof atoi
#include <cstring> // require memset
#include <ctime> // require srand
#include <deque>
#include <fstream> // require freopen
#include <functional>
#include <iomanip> // require setw
#include <iostream>
#include <limits>
#include <map>
#include <numeric> // require accumulate
#include <queue>
#include <set>
#include <sstream> // require stringstream
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(A) A.begin(), A.end()
#define INF 1 << 10
/*
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_1_E&lang=jp
編集距離(Edit Distance)
I: 1文字をカーソル位置に挿入する
D: カーソル位置の1文字を削除する
S: カーソル位置の1文字を置き換える
M: 文字が等しい場合はそのままカーソル位置を1文字分移動する
s: 変更前の文字列（文字列先頭にスペース' ' を入れる）
t: 変更後の文字列（文字列先頭にスペース' ' を入れる）
dp[0..N][0..M] = INF
dp[0][0] = 0
dp[i][0] = dp[i-1][0] + cost['D'];
dp[0][j] = dp[0][j-1] + cost['I'];
Iの場合 dp[i][j] = min (dp[i][j], dp[i][j-1] + cost['I'] );
Dの場合 dp[i][j] = min (dp[i][j], dp[i-1][j] + cost['D'] );
Sの場合 dp[i][j] = min (dp[i][j], dp[i-1][j-1] + cost['S'] );
Mの場合 dp[i][j] = min (dp[i][j], (s[i] == t[j] のとき | dp[i-1][j-1] +
cost['M'] ) );
*/
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_N = 1002;
const int MAX_M = 1002;
const char com[] = {'I', 'D', 'S', 'M'};
const int cost[] = {1, 1, 1, 0};
int N, M;
int dp[MAX_N][MAX_M];
char ope[MAX_N][MAX_M];
/*
void disp_ope(void ){
rep (i, N+1 ){
rep (j, M+1 ){
if (i == 0 && j == 0 ) cerr << '_';
else
cerr << ope[i][j];
} // end rep
cerr << endl;
} // end rep
}
*/
int solve(string s, string t) {
map<char, int> c;
c.clear();
rep(i, sizeof(com) / sizeof(com[0])) c[com[i]] = cost[i];
rep(i, N + 1) rep(j, M + 1) dp[i][j] = INF;
dp[0][0] = 0;
for (int j = 1; j <= M; j++) {
ope[0][j] = 'I';
dp[0][j] = dp[0][j - 1] + c['I'];
} // end for
for (int i = 1; i <= N; i++) {
ope[i][0] = 'D';
dp[i][0] = dp[i - 1][0] + c['D'];
} // end for
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
int k = INF;
int nop = 0;
int pre = -1;
map<char, int>::iterator it = c.begin();
for (; it != c.end(); it++) {
char cc = (*it).first;
int ct = (*it).second;
switch (cc) {
case 'I':
pre = dp[i][j - 1] + ct;
if (k > pre)
k = pre, nop = cc;
break;
case 'D':
pre = dp[i - 1][j] + ct;
if (k > pre)
k = pre, nop = cc;
break;
case 'S':
pre = dp[i - 1][j - 1] + ct;
if (k > pre)
k = pre, nop = cc;
break;
case 'M':
pre = dp[i - 1][j - 1] + ct;
if (s[i] == t[j] && k > pre)
k = pre, nop = cc;
break;
} // end switch
} // end for
dp[i][j] = k;
ope[i][j] = nop;
} // end for
} // end for
// disp_ope();
return dp[N][M];
}
int main() {
memset(ope, 0, sizeof(ope));
ios_base::sync_with_stdio(0);
string s, t;
cin >> s >> t;
s = ' ' + s;
t = ' ' + t;
N = s.length();
M = t.length();
int res = solve(s, t);
cout << res << endl;
return 0;
}
|
replace
| 56 | 58 | 56 | 58 |
0
| |
p02318
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
using namespace std;
int A[1000][1000];
int main() {
string s1, s2;
cin >> s1;
cin >> s2;
for (int i = 0; i <= s1.size(); ++i) {
for (int j = 0; j <= s2.size(); ++j) {
if (i == 0) {
A[0][j] = j;
continue;
}
if (j == 0) {
A[i][0] = i;
continue;
} else {
if (s1[i - 1] == s2[j - 1]) {
A[i][j] = A[i - 1][j - 1];
} else {
A[i][j] = min(A[i][j - 1], A[i - 1][j]) + 1;
A[i][j] = min(A[i][j], A[i - 1][j - 1] + 1);
}
}
// cout<<A[i][j]<<" ";
}
// cout<<endl;
}
cout << A[s1.size()][s2.size()] << endl;
}
|
#include <iostream>
#include <string>
using namespace std;
int A[1001][1001];
int main() {
string s1, s2;
cin >> s1;
cin >> s2;
for (int i = 0; i <= s1.size(); ++i) {
for (int j = 0; j <= s2.size(); ++j) {
if (i == 0) {
A[0][j] = j;
continue;
}
if (j == 0) {
A[i][0] = i;
continue;
} else {
if (s1[i - 1] == s2[j - 1]) {
A[i][j] = A[i - 1][j - 1];
} else {
A[i][j] = min(A[i][j - 1], A[i - 1][j]) + 1;
A[i][j] = min(A[i][j], A[i - 1][j - 1] + 1);
}
}
// cout<<A[i][j]<<" ";
}
// cout<<endl;
}
cout << A[s1.size()][s2.size()] << endl;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02318
|
C++
|
Runtime Error
|
#include <iostream>
int main() { return 2; }
|
#include <iostream>
#include <string>
int main() {
int i, j;
std::string x, y;
int a[1001][1001];
int knum;
for (i = 0; i < 1001; i++) {
for (j = 0; j < 1001; j++) {
if (j == 0)
a[i][j] = i;
else if (i == 0)
a[i][j] = j;
else
a[i][j] = 0;
}
}
std::cin >> x;
std::cin >> y;
int vx, vy, vz;
for (i = 1; i < x.size() + 1; i++) {
for (j = 1; j < y.size() + 1; j++) {
vx = a[i - 1][j] + 1;
vy = a[i][j - 1] + 1;
vz = a[i - 1][j - 1];
if (x[i - 1] == y[j - 1]) {
if (vx <= vy && vx <= vz) {
a[i][j] = vx;
} else if (vy <= vx && vy <= vz) {
a[i][j] = vy;
} else {
a[i][j] = vz;
}
} else {
if (vx <= vy && vx <= vz + 1) {
a[i][j] = vx;
} else if (vy <= vx && vy <= vz + 1) {
a[i][j] = vy;
} else {
a[i][j] = vz + 1;
}
}
}
knum = a[x.size()][y.size()];
}
std::cout << knum << "\n";
return 0;
}
|
replace
| 1 | 2 | 1 | 49 |
2
| |
p02318
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#define ll long long
#define inf 1999999999
#define pa pair<int, int>
using namespace std;
int main() {
// cout<<"1"<<endl;
string s, t;
cin >> s >> t;
int ls = s.length(), lt = t.length();
// cout<<ls<<endl;
// cout<<s<<endl;
int dp[101][101];
for (int i = 0; i <= max(ls, lt); i++) {
dp[i][0] = i;
dp[0][i] = i;
}
for (int i = 1; i <= ls; i++) {
for (int j = 1; j <= lt; j++) {
if (s[i - 1] == t[j - 1])
dp[i][j] =
min(min(dp[i - 1][j] + 1, dp[i][j - 1] + 1), dp[i - 1][j - 1]);
else
dp[i][j] =
min(min(dp[i - 1][j] + 1, dp[i][j - 1] + 1), dp[i - 1][j - 1] + 1);
// cout<<dp[i][j]<<endl;
}
}
cout << dp[ls][lt] << endl;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#define ll long long
#define inf 1999999999
#define pa pair<int, int>
using namespace std;
int main() {
// cout<<"1"<<endl;
string s, t;
cin >> s >> t;
int ls = s.length(), lt = t.length();
// cout<<ls<<endl;
// cout<<s<<endl;
int dp[1010][1010];
for (int i = 0; i <= max(ls, lt); i++) {
dp[i][0] = i;
dp[0][i] = i;
}
for (int i = 1; i <= ls; i++) {
for (int j = 1; j <= lt; j++) {
if (s[i - 1] == t[j - 1])
dp[i][j] =
min(min(dp[i - 1][j] + 1, dp[i][j - 1] + 1), dp[i - 1][j - 1]);
else
dp[i][j] =
min(min(dp[i - 1][j] + 1, dp[i][j - 1] + 1), dp[i - 1][j - 1] + 1);
// cout<<dp[i][j]<<endl;
}
}
cout << dp[ls][lt] << endl;
return 0;
}
|
replace
| 21 | 22 | 21 | 22 |
0
| |
p02318
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string A, B;
cin >> A >> B;
int a = A.length(), b = B.length();
vector<vector<int>> Dist(a + 1, vector<int>(b, 0));
for (int i = 0; i <= a; i++)
Dist[i][0] = i;
for (int i = 0; i <= b; i++)
Dist[0][i] = i;
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
Dist[i + 1][j + 1] = min({Dist[i + 1][j] + 1, Dist[i][j + 1] + 1,
Dist[i][j] + (A[i] != B[j])});
}
}
cout << Dist[a][b] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string A, B;
cin >> A >> B;
int a = A.length(), b = B.length();
vector<vector<int>> Dist(a + 1, vector<int>(b + 1, 0));
for (int i = 0; i <= a; i++)
Dist[i][0] = i;
for (int i = 0; i <= b; i++)
Dist[0][i] = i;
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
Dist[i + 1][j + 1] = min({Dist[i + 1][j] + 1, Dist[i][j + 1] + 1,
Dist[i][j] + (A[i] != B[j])});
}
}
cout << Dist[a][b] << "\n";
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p02318
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int dist[1000][1000];
for (int i = 0; i <= s1.size(); ++i) {
for (int j = 0; j <= s2.size(); ++j) {
if (i == 0) {
dist[i][j] = j;
} else if (j == 0) {
dist[i][j] = i;
} else {
int cost = (s1[i - 1] == s2[j - 1] ? 0 : 1);
int add = dist[i - 1][j] + 1;
int dlt = dist[i][j - 1] + 1;
int exch = dist[i - 1][j - 1] + cost; // why * is necessary
if (add <= dlt && add <= exch) {
dist[i][j] = add;
} else if (dlt <= add && dlt <= exch) {
dist[i][j] = dlt;
} else {
dist[i][j] = exch;
}
}
}
}
cout << dist[s1.size()][s2.size()] << "\n";
}
|
#include <iostream>
#include <string>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int dist[1001][1001];
for (int i = 0; i <= s1.size(); ++i) {
for (int j = 0; j <= s2.size(); ++j) {
if (i == 0) {
dist[i][j] = j;
} else if (j == 0) {
dist[i][j] = i;
} else {
int cost = (s1[i - 1] == s2[j - 1] ? 0 : 1);
int add = dist[i - 1][j] + 1;
int dlt = dist[i][j - 1] + 1;
int exch = dist[i - 1][j - 1] + cost; // why * is necessary
if (add <= dlt && add <= exch) {
dist[i][j] = add;
} else if (dlt <= add && dlt <= exch) {
dist[i][j] = dlt;
} else {
dist[i][j] = exch;
}
}
}
}
cout << dist[s1.size()][s2.size()] << "\n";
}
|
replace
| 8 | 9 | 8 | 9 |
0
| |
p02318
|
C++
|
Time Limit Exceeded
|
#include <fstream>
#include <iostream>
#include <list>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <string>
using namespace std;
const int M = 1003;
const int INIT = (M * M + 1);
int C[M][M]; // = { 0 };
int countmatchstring(const char *p1, const char *p2, int length1, int length2,
int x, int y, int i, int j, int cost) {
int w = (i - 1 > j - 1) ? i - 1 : j - 1;
if (p1[x + i] == p2[y + j]) {
x = x + i;
y = y + j;
if (x == length1 - 1 && y == length2 - 1) {
C[x][y] = 0;
return w;
}
if (x == length1 - 1 || y == length2 - 1) {
while (1)
;
}
C[x][y] = countmatchstring(p1, p2, length1, length2, x, y, 1, 1, w + cost);
return w + C[x][y];
}
// if (C[x + i][y + j] == INIT)
{
int c1 = INIT, c2 = INIT, c3 = INIT;
if (x + i + 1 < length1) {
for (int p = 1; x + i + p < length1; ++p) {
if (p1[x + i + p] == p2[y + j]) {
c1 = countmatchstring(p1, p2, length1, length2, x, y, i + p, j, cost);
break;
}
}
}
if (y + j + 1 < length2) {
for (int q = 1; y + j + q < length2; ++q) {
if (p1[x + i] == p2[y + j + q]) {
c2 = countmatchstring(p1, p2, length1, length2, x, y, i, j + q, cost);
break;
}
}
}
if ((x + i + 1 < length1) && (y + j + 1 < length2)) {
c3 = countmatchstring(p1, p2, length1, length2, x, y, i + 1, j + 1, cost);
}
int c = (c1 < c2 ? c1 : c2);
c = (c < c3 ? c : c3);
C[x + i][y + j] = c;
}
return C[x + i][y + j];
}
int main() {
std::istream &c_in = cin;
for (int i = 0; i < M; ++i) {
for (int j = 0; j < M; ++j) {
C[i][j] = INIT;
}
}
string s1, s2;
getline(c_in, s1);
getline(c_in, s2);
s1 = "A" + s1 + "B";
s2 = "A" + s2 + "B";
const char *p1 = s1.c_str();
const char *p2 = s2.c_str();
countmatchstring(p1, p2, s1.length(), s2.length(), 0, 0, 1, 1, 0);
printf("%d\n", C[1][1]);
return 0;
}
|
#include <fstream>
#include <iostream>
#include <list>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <string>
using namespace std;
const int M = 1003;
const int INIT = (M * M + 1);
int C[M][M]; // = { 0 };
int countmatchstring(const char *p1, const char *p2, int length1, int length2,
int x, int y, int i, int j, int cost) {
int w = (i - 1 > j - 1) ? i - 1 : j - 1;
if (p1[x + i] == p2[y + j]) {
x = x + i;
y = y + j;
if (x == length1 - 1 && y == length2 - 1) {
C[x][y] = 0;
return w;
}
if (x == length1 - 1 || y == length2 - 1) {
while (1)
;
}
C[x][y] = countmatchstring(p1, p2, length1, length2, x, y, 1, 1, w + cost);
return w + C[x][y];
}
if (C[x + i][y + j] == INIT) {
int c1 = INIT, c2 = INIT, c3 = INIT;
if (x + i + 1 < length1) {
for (int p = 1; x + i + p < length1; ++p) {
if (p1[x + i + p] == p2[y + j]) {
c1 = countmatchstring(p1, p2, length1, length2, x, y, i + p, j, cost);
break;
}
}
}
if (y + j + 1 < length2) {
for (int q = 1; y + j + q < length2; ++q) {
if (p1[x + i] == p2[y + j + q]) {
c2 = countmatchstring(p1, p2, length1, length2, x, y, i, j + q, cost);
break;
}
}
}
if ((x + i + 1 < length1) && (y + j + 1 < length2)) {
c3 = countmatchstring(p1, p2, length1, length2, x, y, i + 1, j + 1, cost);
}
int c = (c1 < c2 ? c1 : c2);
c = (c < c3 ? c : c3);
C[x + i][y + j] = c;
}
return C[x + i][y + j];
}
int main() {
std::istream &c_in = cin;
for (int i = 0; i < M; ++i) {
for (int j = 0; j < M; ++j) {
C[i][j] = INIT;
}
}
string s1, s2;
getline(c_in, s1);
getline(c_in, s2);
s1 = "A" + s1 + "B";
s2 = "A" + s2 + "B";
const char *p1 = s1.c_str();
const char *p2 = s2.c_str();
countmatchstring(p1, p2, s1.length(), s2.length(), 0, 0, 1, 1, 0);
printf("%d\n", C[1][1]);
return 0;
}
|
replace
| 30 | 32 | 30 | 31 |
TLE
| |
p02318
|
C++
|
Runtime Error
|
/*
* Contents : AOJ DPL 1 E
* Author : KitauraHiromi
* LastUpdate : 20180614
* Since : 20180614
*/
#include <iostream>
#include <math.h>
#include <string>
using namespace std;
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
string S, T;
int INF = 1e9 + 1;
int dp[1001][1001];
int main(void) {
cin >> S >> T;
Fill(dp, INF);
dp[0][0] = 0;
for (int i = -1; i <= (int)S.size(); ++i) {
for (int j = -1; j <= (int)T.size(); ++j) {
if (i == -1 && j == -1)
continue;
// 変更
if (i >= 0 && j >= 0) {
if (S[i] == T[j])
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j]);
else
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + 1);
}
// 削除
if (i >= 0)
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j + 1] + 1);
// 追加
if (j >= 0)
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i + 1][j] + 1);
}
}
cout << dp[S.size()][T.size()] << endl;
return 0;
}
|
/*
* Contents : AOJ DPL 1 E
* Author : KitauraHiromi
* LastUpdate : 20180614
* Since : 20180614
*/
#include <iostream>
#include <math.h>
#include <string>
using namespace std;
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
string S, T;
int INF = 1e9 + 1;
int dp[1010][1010];
int main(void) {
cin >> S >> T;
Fill(dp, INF);
dp[0][0] = 0;
for (int i = -1; i <= (int)S.size(); ++i) {
for (int j = -1; j <= (int)T.size(); ++j) {
if (i == -1 && j == -1)
continue;
// 変更
if (i >= 0 && j >= 0) {
if (S[i] == T[j])
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j]);
else
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + 1);
}
// 削除
if (i >= 0)
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j + 1] + 1);
// 追加
if (j >= 0)
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i + 1][j] + 1);
}
}
cout << dp[S.size()][T.size()] << endl;
return 0;
}
|
replace
| 18 | 19 | 18 | 19 |
0
| |
p02318
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
int main() {
std::string str1;
std::string str2;
std::cin >> str1;
std::cin >> str2;
int A[1000][1000] = {0};
for (int i = 0; i <= str1.size(); i++) {
A[i][0] = i;
}
for (int j = 0; j <= str2.size(); j++) {
A[0][j] = j;
}
for (int i = 1; i <= str1.size(); i++) {
for (int j = 1; j <= str2.size(); j++) {
if (str1[i - 1] == str2[j - 1]) {
A[i][j] = A[i - 1][j - 1];
} else {
A[i][j] = std::min(std::min(A[i - 1][j] + 1, A[i][j - 1] + 1),
A[i - 1][j - 1] + 1);
}
}
}
std::cout << A[str1.size()][str2.size()] << "\n";
return 0;
}
|
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
int main() {
std::string str1;
std::string str2;
std::cin >> str1;
std::cin >> str2;
int A[1001][1001] = {0};
for (int i = 0; i <= str1.size(); i++) {
A[i][0] = i;
}
for (int j = 0; j <= str2.size(); j++) {
A[0][j] = j;
}
for (int i = 1; i <= str1.size(); i++) {
for (int j = 1; j <= str2.size(); j++) {
if (str1[i - 1] == str2[j - 1]) {
A[i][j] = A[i - 1][j - 1];
} else {
A[i][j] = std::min(std::min(A[i - 1][j] + 1, A[i][j - 1] + 1),
A[i - 1][j - 1] + 1);
}
}
}
std::cout << A[str1.size()][str2.size()] << "\n";
return 0;
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p02318
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int min(int a, int b, int c) {
int t = a < b ? a : b;
return t < c ? t : c;
}
int main() {
string s1, s2;
int d[1000][1000];
cin >> s1 >> s2;
int n = s1.length();
int m = s2.length();
if (n == 0) {
return n;
}
if (m == 0) {
return m;
}
for (int i = 0; i <= n; i++) {
d[i][0] = i;
}
for (int j = 0; j <= m; j++) {
d[0][j] = j;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s1[i - 1] == s2[j - 1]) {
d[i][j] = d[i - 1][j - 1];
} else {
d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + 1);
}
}
}
cout << d[n][m] << endl;
}
|
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int min(int a, int b, int c) {
int t = a < b ? a : b;
return t < c ? t : c;
}
int main() {
string s1, s2;
int d[1010][1010];
cin >> s1 >> s2;
int n = s1.length();
int m = s2.length();
if (n == 0) {
return n;
}
if (m == 0) {
return m;
}
for (int i = 0; i <= n; i++) {
d[i][0] = i;
}
for (int j = 0; j <= m; j++) {
d[0][j] = j;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s1[i - 1] == s2[j - 1]) {
d[i][j] = d[i - 1][j - 1];
} else {
d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + 1);
}
}
}
cout << d[n][m] << endl;
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p02319
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
int main() {
int n, w = 0;
std::cin >> n >> w;
std::vector<std::vector<long>> dp(n + 1, std::vector<long>(n * 100 + 1, 0));
dp[0][0] = 0;
for (int i = 1; i < dp[0].size(); ++i) {
dp[0][i] = LONG_MAX;
}
std::vector<int> iv;
std::vector<long> iw;
for (int i = 0; i < n; ++i) {
int a, b = 0;
std::cin >> a >> b;
iv.emplace_back(a);
iw.emplace_back(b);
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= dp[0].size(); ++j) {
if (j < iv[i - 1]) {
dp[i][j] = dp[i - 1][j];
} else {
dp[i][j] = std::min(dp[i - 1][j], dp[i - 1][j - iv[i - 1]] + iw[i - 1]);
}
}
}
int ans = 0;
for (int i = 0; i < dp[0].size(); ++i) {
if (dp[n][i] <= w)
ans = i;
}
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, w = 0;
std::cin >> n >> w;
std::vector<std::vector<long>> dp(n + 1, std::vector<long>(n * 100 + 1, 0));
dp[0][0] = 0;
for (int i = 1; i < dp[0].size(); ++i) {
dp[0][i] = 1000000001;
}
std::vector<int> iv;
std::vector<long> iw;
for (int i = 0; i < n; ++i) {
int a, b = 0;
std::cin >> a >> b;
iv.emplace_back(a);
iw.emplace_back(b);
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= dp[0].size(); ++j) {
if (j < iv[i - 1]) {
dp[i][j] = dp[i - 1][j];
} else {
dp[i][j] = std::min(dp[i - 1][j], dp[i - 1][j - iv[i - 1]] + iw[i - 1]);
}
}
}
int ans = 0;
for (int i = 0; i < dp[0].size(); ++i) {
if (dp[n][i] <= w)
ans = i;
}
std::cout << ans << std::endl;
return 0;
}
|
replace
| 8 | 9 | 8 | 9 |
-6
|
malloc(): corrupted top size
|
p02319
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define all(a) a.begin(), a.end()
typedef long long ll;
using P = pair<ll, ll>;
#define v first
#define w second
// v/w 高い順
bool comp1(P a, P b) { return a.v * b.w > b.v * a.w; }
// v高い順（vが同じならw軽い方優先）
bool comp(P a, P b) { return a.v == b.v ? a.w < b.w : a.v > b.v; }
int main(void) {
ll N, W;
cin >> N >> W;
vector<P> a(N);
rep(i, N) {
ll v, w;
cin >> v >> w;
a[i] = {v, w};
}
sort(all(a), comp1);
vector<P> dp = {{0, 0}};
rep(i, N) {
vector<P> tmp;
for (auto &s : dp) {
tmp.push_back(s);
tmp.push_back({s.v + a[i].v, s.w + a[i].w});
}
sort(all(tmp), comp);
dp.clear();
ll w_border = W + 1;
for (auto &s : tmp) {
if (w_border > s.w) {
w_border = s.w;
dp.push_back(s);
}
}
assert(dp.size() <= N * N);
}
cout << dp[0].v << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define all(a) a.begin(), a.end()
typedef long long ll;
using P = pair<ll, ll>;
#define v first
#define w second
// v/w 高い順
bool comp1(P a, P b) { return a.v * b.w > b.v * a.w; }
// v高い順（vが同じならw軽い方優先）
bool comp(P a, P b) { return a.v == b.v ? a.w < b.w : a.v > b.v; }
int main(void) {
ll N, W;
cin >> N >> W;
vector<P> a(N);
rep(i, N) {
ll v, w;
cin >> v >> w;
a[i] = {v, w};
}
sort(all(a), comp1);
vector<P> dp = {{0, 0}};
rep(i, N) {
vector<P> tmp;
for (auto &s : dp) {
tmp.push_back(s);
tmp.push_back({s.v + a[i].v, s.w + a[i].w});
}
sort(all(tmp), comp);
dp.clear();
ll w_border = W + 1;
for (auto &s : tmp) {
if (w_border > s.w) {
w_border = s.w;
dp.push_back(s);
}
}
assert(dp.size() <= N * N * 2);
}
cout << dp[0].v << endl;
return 0;
}
|
replace
| 44 | 45 | 44 | 45 |
0
| |
p02320
|
C++
|
Runtime Error
|
#include <cstdio>
#include <vector>
using namespace std;
int main() {
int N, W, v_, w, m, x = 0;
scanf("%d%d", &N, &W);
vector<pair<int, int>> v;
for (; N--;) {
scanf("%d%d%d", &v_, &w, &m);
for (int i = 1; i < m; m -= i, i *= 2)
v.emplace_back(v_ * i, w * i);
if (m)
v.emplace_back(v_ * m, w * m);
}
vector<int> bag(W + 1);
bag[0] = 1;
for (auto &e : v) {
x += e.second;
for (int j = x; j >= e.second; j--)
if (bag[j - e.second] && bag[j] < bag[j - e.second] + e.first)
bag[j] = bag[j - e.second] + e.first;
}
for (int i = 0; i < W; i++)
bag[i + 1] = max(bag[i + 1], bag[i]);
printf("%d\n", bag[W] - 1);
}
|
#include <cstdio>
#include <vector>
using namespace std;
int main() {
int N, W, v_, w, m, x = 0;
scanf("%d%d", &N, &W);
vector<pair<int, int>> v;
for (; N--;) {
scanf("%d%d%d", &v_, &w, &m);
for (int i = 1; i < m; m -= i, i *= 2)
v.emplace_back(v_ * i, w * i);
if (m)
v.emplace_back(v_ * m, w * m);
}
vector<int> bag(W + 1);
bag[0] = 1;
for (auto &e : v) {
x += e.second;
if (x > W)
x = W;
for (int j = x; j >= e.second; j--)
if (bag[j - e.second] && bag[j] < bag[j - e.second] + e.first)
bag[j] = bag[j - e.second] + e.first;
}
for (int i = 0; i < W; i++)
bag[i + 1] = max(bag[i + 1], bag[i]);
printf("%d\n", bag[W] - 1);
}
|
insert
| 19 | 19 | 19 | 21 |
-6
|
double free or corruption (out)
|
p02320
|
C++
|
Runtime Error
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int INF = INT_MAX / 3;
void slidingMinimum(vector<int> &inputList, vector<int> &outputList,
int slideSize) {
deque<int> dq;
for (int i = 0; i < inputList.size(); i++) {
while (!dq.empty()) {
if (inputList[dq.back()] >= inputList[i]) {
dq.pop_back();
} else {
break;
}
}
dq.push_back(i);
outputList.push_back(inputList[dq.front()]);
if (dq.front() == i - slideSize + 1) {
dq.pop_front();
}
}
return;
}
int knapsackProblemWithLimitations(int W, vector<int> &v, vector<int> &w,
vector<int> &m) {
int N = v.size();
int DP[W + 1][N];
for (int i = 0; i < W + 1; i++) {
for (int j = 0; j < N; j++) {
DP[i][j] = 0;
}
}
for (int i = 1; i < m[0] + 1; i++) {
DP[w[0] * i][0] = v[0] * i;
}
for (int j = 1; j < N; j++) {
for (int t = 0; t < w[j]; t++) {
vector<int> b, c;
for (int k = 0; (w[j] * k + t) < W + 1; k++) {
b.push_back(DP[w[j] * k + t][j - 1] - k * v[j]);
}
//??¢??°???????°????????±???????????????§???????±???????????????§??\???
for (int i = 0; i < b.size(); i++) {
b[i] = -b[i];
}
slidingMinimum(b, c, m[j] + 1);
for (int i = 0; i < c.size(); i++) {
c[i] = -c[i];
}
/*
cout << endl;
for (int p=0;p<b.size();p++){
cout << b[p] << " ";
}
cout << endl <<endl;
cout << endl;
for (int p=0;p<c.size();p++){
cout << c[p] << " ";
}
cout << endl <<endl;
*/
for (int k = 0; k < c.size(); k++) {
DP[w[j] * k + t][j] = c[k] + k * v[j];
}
}
}
/*
cout << endl;
for (int i=0;i<W+1;i++){
for (int j=0;j<N;j++){
cout << DP[i][j] << " ";
}
cout << endl;
}
cout << endl;
*/
int S = 0;
for (int i = 0; i < W + 1; i++) {
S = max(S, DP[i][N - 1]);
}
return S;
}
int main() {
int N, W;
cin >> N >> W;
vector<int> v(N);
vector<int> w(N);
vector<int> m(N);
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i] >> m[i];
}
cout << knapsackProblemWithLimitations(W, v, w, m) << endl;
return 0;
}
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int INF = INT_MAX / 3;
void slidingMinimum(vector<int> &inputList, vector<int> &outputList,
int slideSize) {
deque<int> dq;
for (int i = 0; i < inputList.size(); i++) {
while (!dq.empty()) {
if (inputList[dq.back()] >= inputList[i]) {
dq.pop_back();
} else {
break;
}
}
dq.push_back(i);
outputList.push_back(inputList[dq.front()]);
if (dq.front() == i - slideSize + 1) {
dq.pop_front();
}
}
return;
}
int knapsackProblemWithLimitations(int W, vector<int> &v, vector<int> &w,
vector<int> &m) {
int N = v.size();
int DP[W + 1][N];
for (int i = 0; i < W + 1; i++) {
for (int j = 0; j < N; j++) {
DP[i][j] = 0;
}
}
for (int i = 1; i < min(m[0], W / w[0]) + 1; i++) {
DP[w[0] * i][0] = v[0] * i;
}
for (int j = 1; j < N; j++) {
for (int t = 0; t < w[j]; t++) {
vector<int> b, c;
for (int k = 0; (w[j] * k + t) < W + 1; k++) {
b.push_back(DP[w[j] * k + t][j - 1] - k * v[j]);
}
//??¢??°???????°????????±???????????????§???????±???????????????§??\???
for (int i = 0; i < b.size(); i++) {
b[i] = -b[i];
}
slidingMinimum(b, c, m[j] + 1);
for (int i = 0; i < c.size(); i++) {
c[i] = -c[i];
}
/*
cout << endl;
for (int p=0;p<b.size();p++){
cout << b[p] << " ";
}
cout << endl <<endl;
cout << endl;
for (int p=0;p<c.size();p++){
cout << c[p] << " ";
}
cout << endl <<endl;
*/
for (int k = 0; k < c.size(); k++) {
DP[w[j] * k + t][j] = c[k] + k * v[j];
}
}
}
/*
cout << endl;
for (int i=0;i<W+1;i++){
for (int j=0;j<N;j++){
cout << DP[i][j] << " ";
}
cout << endl;
}
cout << endl;
*/
int S = 0;
for (int i = 0; i < W + 1; i++) {
S = max(S, DP[i][N - 1]);
}
return S;
}
int main() {
int N, W;
cin >> N >> W;
vector<int> v(N);
vector<int> w(N);
vector<int> m(N);
for (int i = 0; i < N; i++) {
cin >> v[i] >> w[i] >> m[i];
}
cout << knapsackProblemWithLimitations(W, v, w, m) << endl;
return 0;
}
|
replace
| 46 | 47 | 46 | 47 |
0
| |
p02320
|
C++
|
Runtime Error
|
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
// #define int long long
#define DBG 1
#define dump(o) \
if (DBG) { \
cerr << #o << " " << o << endl; \
}
#define dumpc(o) \
if (DBG) { \
cerr << #o; \
for (auto &e : (o)) \
cerr << " " << e; \
cerr << endl; \
}
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define each(it, c) for (auto it = (c).begin(); it != (c).end(); it++)
#define all(c) c.begin(), c.end()
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
const double EPS = 1e-10;
signed main() {
int N, W;
cin >> N >> W;
vector<int> v, w;
v.push_back(0), w.push_back(0);
rep(i, 0, N) {
int a, b, m;
cin >> a >> b >> m;
for (int x = 1; x <= m; x++) {
v.push_back(x * a);
w.push_back(x * b);
m -= x;
}
if (m > 0)
v.push_back(m * a), w.push_back(m * b);
}
dumpc(v);
dumpc(w);
vector<int> dp(W + 1, 0);
rep(i, 1, v.size()) rrep(j, w[i], W + 1) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
cout << dp[W] << endl;
return 0;
}
|
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
// #define int long long
#define DBG 1
#define dump(o) \
if (DBG) { \
cerr << #o << " " << o << endl; \
}
#define dumpc(o) \
if (DBG) { \
cerr << #o; \
for (auto &e : (o)) \
cerr << " " << e; \
cerr << endl; \
}
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define each(it, c) for (auto it = (c).begin(); it != (c).end(); it++)
#define all(c) c.begin(), c.end()
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
const double EPS = 1e-10;
signed main() {
int N, W;
cin >> N >> W;
vector<int> v, w;
v.push_back(0), w.push_back(0);
rep(i, 0, N) {
int a, b, m;
cin >> a >> b >> m;
for (int x = 1; x <= m; x++) {
v.push_back(x * a);
w.push_back(x * b);
m -= x;
}
if (m > 0)
v.push_back(m * a), w.push_back(m * b);
}
vector<int> dp(W + 1, 0);
rep(i, 1, v.size()) rrep(j, w[i], W + 1) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
cout << dp[W] << endl;
return 0;
}
|
replace
| 43 | 45 | 43 | 44 |
0
|
v 0 4 4 2 1 2 1 3 3
w 0 3 3 1 2 4 2 2 2
|
p02323
|
C++
|
Memory Limit Exceeded
|
#include <bits/stdc++.h>
#include <cmath>
#include <string.h>
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define max3(A, B, C) max((A), max((B), (C)))
#define lb lower_bound
#define ub upper_bound
using namespace std;
const int N = 16;
const int INF = 0x3f3f3f3f;
int pd[1 << N][N][N];
int main(void) {
int n, m;
int adj[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
adj[i][j] = (i == j ? 0 : INF);
}
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
pd[0][i][j] = 0;
for (int i = 1; i < 1 << N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
pd[i][j][k] = INF;
}
}
}
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
adj[a][b] = c;
}
for (int i = 1; i < 1 << n; i++) {
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) == 0)
continue;
for (int w = 0; w < n; w++) {
if ((i & (1 << w)) == 0)
continue;
for (int k = 0; k < n; k++) {
if (i & (1 << k)) {
if (i - k != 0 || k == w) {
pd[i][j][w] =
min(pd[i][j][w], pd[i ^ (1 << j)][k][w] + adj[k][j]);
}
}
}
}
}
}
int minn = INF;
int idx = (1 << n) - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
minn = min(minn, pd[idx][i][j] + adj[i][j]);
}
}
if (minn == INF)
puts("-1");
else
printf("%d\n", minn);
return 0;
}
|
#include <bits/stdc++.h>
#include <cmath>
#include <string.h>
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define max3(A, B, C) max((A), max((B), (C)))
#define lb lower_bound
#define ub upper_bound
using namespace std;
const int N = 15;
const int INF = 0x3f3f3f3f;
int pd[1 << N][N][N];
int main(void) {
int n, m;
int adj[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
adj[i][j] = (i == j ? 0 : INF);
}
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
pd[0][i][j] = 0;
for (int i = 1; i < 1 << N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
pd[i][j][k] = INF;
}
}
}
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
adj[a][b] = c;
}
for (int i = 1; i < 1 << n; i++) {
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) == 0)
continue;
for (int w = 0; w < n; w++) {
if ((i & (1 << w)) == 0)
continue;
for (int k = 0; k < n; k++) {
if (i & (1 << k)) {
if (i - k != 0 || k == w) {
pd[i][j][w] =
min(pd[i][j][w], pd[i ^ (1 << j)][k][w] + adj[k][j]);
}
}
}
}
}
}
int minn = INF;
int idx = (1 << n) - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
minn = min(minn, pd[idx][i][j] + adj[i][j]);
}
}
if (minn == INF)
puts("-1");
else
printf("%d\n", minn);
return 0;
}
|
replace
| 13 | 14 | 13 | 14 |
MLE
| |
p02323
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
using namespace std;
int v, n, dis[15][15];
int dp[(1 << 15)][15];
const int INF = 100000000;
int main() {
cin >> v >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
dis[i][j] = INF;
for (int i = 0; i < (1 << v); i++)
for (int j = 0; j < v; j++)
dp[i][j] = INF;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
dis[a][b] = c;
}
dp[0][0] = 0;
for (int i = 0; i < (1 << v) - 1; i++) {
for (int j = 0; j < v; j++) {
if (i && !(i & (1 << j)))
continue;
for (int k = 0; k < v; k++) {
if (j == k)
continue;
if (!(i & (1 << k))) {
dp[i | (1 << k)][k] = min(dp[i | (1 << k)][k], dp[i][j] + dis[j][k]);
}
}
}
}
if (dp[(1 << v) - 1][0] == INF)
cout << -1 << endl;
else
cout << dp[(1 << v) - 1][0] << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int v, n, dis[15][15];
int dp[(1 << 15)][15];
const int INF = 100000000;
int main() {
cin >> v >> n;
for (int i = 0; i < v; i++)
for (int j = 0; j < v; j++)
dis[i][j] = INF;
for (int i = 0; i < (1 << v); i++)
for (int j = 0; j < v; j++)
dp[i][j] = INF;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
dis[a][b] = c;
}
dp[0][0] = 0;
for (int i = 0; i < (1 << v) - 1; i++) {
for (int j = 0; j < v; j++) {
if (i && !(i & (1 << j)))
continue;
for (int k = 0; k < v; k++) {
if (j == k)
continue;
if (!(i & (1 << k))) {
dp[i | (1 << k)][k] = min(dp[i | (1 << k)][k], dp[i][j] + dis[j][k]);
}
}
}
}
if (dp[(1 << v) - 1][0] == INF)
cout << -1 << endl;
else
cout << dp[(1 << v) - 1][0] << endl;
return 0;
}
|
replace
| 11 | 13 | 11 | 13 |
0
| |
p02323
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cstdio>
using namespace std;
const int V_MAX = 15;
const int INF = 10000000;
int n, e;
int g[V_MAX][V_MAX];
int dp[1 << V_MAX][V_MAX];
int tsp(int visited, int v) {
if (dp[visited][v] != -1)
return dp[visited][v];
if (visited == (1 << n) - 1 && v == 0)
return 0;
int res = INF;
for (int u = 0; u < n; ++u) {
if (!(visited & (1 << u)) && g[v][u] != INF) {
res = min(res, tsp(visited | (1 << u), u) + g[v][u]);
}
}
return res;
}
int main() {
scanf("%d %d", &n, &e);
fill(&g[0][0], &g[n][0], INF);
for (int i = 0; i < e; ++i) {
int s, t, d;
scanf("%d %d %d", &s, &t, &d);
g[s][t] = d;
}
fill(&dp[0][0], &dp[1 << V_MAX][0], -1);
int d = tsp(0, 0);
if (d == INF)
printf("-1\n");
else
printf("%d\n", d);
return 0;
}
|
#include <algorithm>
#include <cstdio>
using namespace std;
const int V_MAX = 15;
const int INF = 10000000;
int n, e;
int g[V_MAX][V_MAX];
int dp[1 << V_MAX][V_MAX];
int tsp(int visited, int v) {
if (dp[visited][v] != -1)
return dp[visited][v];
if (visited == (1 << n) - 1 && v == 0)
return 0;
int res = INF;
for (int u = 0; u < n; ++u) {
if (!(visited & (1 << u)) && g[v][u] != INF) {
res = min(res, tsp(visited | (1 << u), u) + g[v][u]);
}
}
return dp[visited][v] = res;
}
int main() {
scanf("%d %d", &n, &e);
fill(&g[0][0], &g[n][0], INF);
for (int i = 0; i < e; ++i) {
int s, t, d;
scanf("%d %d %d", &s, &t, &d);
g[s][t] = d;
}
fill(&dp[0][0], &dp[1 << V_MAX][0], -1);
int d = tsp(0, 0);
if (d == INF)
printf("-1\n");
else
printf("%d\n", d);
return 0;
}
|
replace
| 25 | 26 | 25 | 26 |
TLE
| |
p02323
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define SIZE 200005
#define MAX_N 15
#define INF 10000005
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int V, E;
ll K;
int d[MAX_N][MAX_N];
int dp[1 << MAX_N][MAX_N];
int color[MAX_N];
void solve() {
for (int S = 0; S < 1 << V; S++) {
fill(dp[S], dp[S] + V, INF);
}
dp[(1 << V) - 1][0] = 0;
for (int S = (1 << V) - 2; S >= 0; S--) {
for (int v = 0; v < V; v++) {
for (int u = 0; u < V; u++) {
if (!(S >> u & 1)) {
dp[S][v] = min(dp[S][v], dp[S | 1 << u][u] + d[v][u]);
}
}
}
}
if (dp[0][0] >= INF)
printf("-1\n");
else
printf("%d\n", dp[0][0]);
}
// dfsで塗る
int dfs(int v, int a) {
color[v] = 1;
a++;
for (int i = 0; i < V; i++) {
if (d[v][i] != INF && color[i] == 0) {
a = dfs(i, a);
}
}
return a;
}
int main() {
int s, t, dd;
scanf("%d %d", &V, &E);
if (E == 0) {
printf("-1\n");
return 0;
}
for (int i = 0; i <= V; i++) {
fill(d[i], d[i] + V + 1, INF);
}
for (int i = 0; i < E; i++) {
scanf("%d%d%d", &s, &t, &dd);
d[s][t] = dd;
}
// printf("%d\n",dfs(0,0));
solve();
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define SIZE 200005
#define MAX_N 16
#define INF 10000005
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int V, E;
ll K;
int d[MAX_N][MAX_N];
int dp[1 << MAX_N][MAX_N];
int color[MAX_N];
void solve() {
for (int S = 0; S < 1 << V; S++) {
fill(dp[S], dp[S] + V, INF);
}
dp[(1 << V) - 1][0] = 0;
for (int S = (1 << V) - 2; S >= 0; S--) {
for (int v = 0; v < V; v++) {
for (int u = 0; u < V; u++) {
if (!(S >> u & 1)) {
dp[S][v] = min(dp[S][v], dp[S | 1 << u][u] + d[v][u]);
}
}
}
}
if (dp[0][0] >= INF)
printf("-1\n");
else
printf("%d\n", dp[0][0]);
}
// dfsで塗る
int dfs(int v, int a) {
color[v] = 1;
a++;
for (int i = 0; i < V; i++) {
if (d[v][i] != INF && color[i] == 0) {
a = dfs(i, a);
}
}
return a;
}
int main() {
int s, t, dd;
scanf("%d %d", &V, &E);
if (E == 0) {
printf("-1\n");
return 0;
}
for (int i = 0; i <= V; i++) {
fill(d[i], d[i] + V + 1, INF);
}
for (int i = 0; i < E; i++) {
scanf("%d%d%d", &s, &t, &dd);
d[s][t] = dd;
}
// printf("%d\n",dfs(0,0));
solve();
return 0;
}
|
replace
| 12 | 13 | 12 | 13 |
0
| |
p02323
|
C++
|
Time Limit Exceeded
|
// suhan lee,saitama university
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define repn(i, n) for (int i = 0; i < n; i++)
#define EACH(t, i, c) for (t::iterator i = (c).begin(); i != (c).end(); ++i)
#define pb push_back
#define pf push_front
const int INF = 10000000;
bool checked(int chouten, int i) {
if (((1 << i) & chouten)) {
return true;
} else
return false;
}
int pluscheck(int chouten, int i) { return (chouten | (1 << i)); }
int graph[16][16];
int dynamic[((1 << 16) - 1)][16];
int V, E;
int roop(int chouten, int genzai) {
// cout<<"hehe"<<chouten<<' '<<genzai<<' '<<len<<endl;;
if (dynamic[chouten][genzai] != -1)
return dynamic[chouten][genzai];
if (chouten == (1 << (V)) - 1) {
if (genzai == 0)
return 0;
else
return INF;
} else {
int newlen, out;
out = INF;
for (int i = 0; i < 16; i++) {
if (checked(chouten, i))
continue;
if (graph[genzai][i] != INF) {
// newlen=len+graph[genzai][i];
out = min(out, roop(pluscheck(chouten, i), i) + graph[genzai][i]);
}
}
return out;
}
}
int main() {
cin >> V >> E;
int s, t, d;
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 16; j++) {
graph[i][j] = INF;
}
}
for (int i = 0; i < E; i++) {
cin >> s >> t >> d;
graph[s][t] = d;
}
for (int i = 0; i < ((1 << 16) - 1); i++) {
for (int j = 0; j < 16; j++) {
dynamic[i][j] = -1;
}
}
int rinzi = roop(0, 0);
if (rinzi < INF)
cout << rinzi << endl;
else
cout << -1 << endl;
return 0;
}
|
// suhan lee,saitama university
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define repn(i, n) for (int i = 0; i < n; i++)
#define EACH(t, i, c) for (t::iterator i = (c).begin(); i != (c).end(); ++i)
#define pb push_back
#define pf push_front
const int INF = 10000000;
bool checked(int chouten, int i) {
if (((1 << i) & chouten)) {
return true;
} else
return false;
}
int pluscheck(int chouten, int i) { return (chouten | (1 << i)); }
int graph[16][16];
int dynamic[((1 << 16) - 1)][16];
int V, E;
int roop(int chouten, int genzai) {
// cout<<"hehe"<<chouten<<' '<<genzai<<' '<<len<<endl;;
if (dynamic[chouten][genzai] != -1)
return dynamic[chouten][genzai];
if (chouten == (1 << (V)) - 1) {
if (genzai == 0)
return 0;
else
return INF;
} else {
int newlen, out;
out = INF;
for (int i = 0; i < 16; i++) {
if (checked(chouten, i))
continue;
if (graph[genzai][i] != INF) {
// newlen=len+graph[genzai][i];
out = min(out, roop(pluscheck(chouten, i), i) + graph[genzai][i]);
}
}
return dynamic[chouten][genzai] = out;
}
}
int main() {
cin >> V >> E;
int s, t, d;
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 16; j++) {
graph[i][j] = INF;
}
}
for (int i = 0; i < E; i++) {
cin >> s >> t >> d;
graph[s][t] = d;
}
for (int i = 0; i < ((1 << 16) - 1); i++) {
for (int j = 0; j < 16; j++) {
dynamic[i][j] = -1;
}
}
int rinzi = roop(0, 0);
if (rinzi < INF)
cout << rinzi << endl;
else
cout << -1 << endl;
return 0;
}
|
replace
| 83 | 84 | 83 | 84 |
TLE
| |
p02323
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int inf = 987654321;
int n, m;
vector<vector<int>> G;
vector<vector<int>> dp;
int rec(int visited, int now) {
if (dp[visited][now] != -1)
return dp[visited][now];
if (visited == (1 << n) - 1 && now == 0)
return dp[visited][now] = 0;
int res = inf;
for (int i = 0; i < n; i++) {
if (visited >> i & 1)
continue; /* ??¢????¨??????? */
res = min(res, rec(visited | (1 << i), i) + G[now][i]);
}
return dp[visited][now] = res;
}
int main(void) {
cin >> n >> m;
G.assign(n, vector<int>(m, inf));
for (int i = 0; i < m; i++) {
int p, q, c;
cin >> p >> q >> c;
G[p][q] = c;
}
dp.assign(1 << n, vector<int>(n, -1));
int res = rec(0, 0);
if (res != inf)
cout << res << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int inf = 987654321;
int n, m;
vector<vector<int>> G;
vector<vector<int>> dp;
int rec(int visited, int now) {
if (dp[visited][now] != -1)
return dp[visited][now];
if (visited == (1 << n) - 1 && now == 0)
return dp[visited][now] = 0;
int res = inf;
for (int i = 0; i < n; i++) {
if (visited >> i & 1)
continue; /* ??¢????¨??????? */
res = min(res, rec(visited | (1 << i), i) + G[now][i]);
}
return dp[visited][now] = res;
}
int main(void) {
cin >> n >> m;
G.assign(n, vector<int>(n, inf));
for (int i = 0; i < m; i++) {
int p, q, c;
cin >> p >> q >> c;
G[p][q] = c;
}
dp.assign(1 << n, vector<int>(n, -1));
int res = rec(0, 0);
if (res != inf)
cout << res << endl;
else
cout << -1 << endl;
return 0;
}
|
replace
| 26 | 27 | 26 | 27 |
0
| |
p02323
|
C++
|
Time Limit Exceeded
|
/*
f(v, v', k):- min f(v, v',k - 1) + e(v, v'),
*/
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) - 1;
const int mxv = 16;
int V, E;
int adj[mxv][mxv], dp[(1 << mxv)][mxv], a, b, c;
int tsp(int v, int bitmask) {
if (bitmask == (1 << V) - 1)
return adj[v][0];
if (dp[bitmask][v] < INF)
return dp[bitmask][v];
for (int i = 0; i < V; ++i)
if (!(bitmask & (1 << i)))
dp[bitmask][v] =
min(dp[bitmask][v], adj[v][i] + tsp(i, bitmask | (1 << i)));
return dp[bitmask][v];
}
int main(void) {
// freopen("input.in", "r", stdin);
scanf("%d%d", &V, &E);
for (int i = 0; i < V; ++i)
for (int j = 0; j < V; ++j)
adj[i][j] = INF;
for (int i = 0; i < (1 << V); ++i)
for (int j = 0; j < V; ++j)
dp[i][j] = INF;
for (int i = 0; i < E; ++i)
scanf("%d%d%d", &a, &b, &c), adj[a][b] = c;
int sol = tsp(0, 1);
printf("%d\n", (sol == INF) ? -1 : sol);
return 0;
}
|
/*
f(v, v', k):- min f(v, v',k - 1) + e(v, v'),
*/
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) - 1;
const int mxv = 16;
int V, E;
int adj[mxv][mxv], dp[(1 << mxv)][mxv], a, b, c;
int tsp(int v, int bitmask) {
if (bitmask == (1 << V) - 1)
return adj[v][0];
if (dp[bitmask][v] < INF)
return dp[bitmask][v];
for (int i = 0; i < V; ++i)
if (!(bitmask & (1 << i)))
dp[bitmask][v] =
min(dp[bitmask][v], adj[v][i] + tsp(i, bitmask | (1 << i)));
return dp[bitmask][v];
}
int main(void) {
// freopen("input.in", "r", stdin);
scanf("%d%d", &V, &E);
for (int i = 0; i < V; ++i)
for (int j = 0; j < V; ++j)
adj[i][j] = INF;
for (int i = 0; i < (1 << V); ++i)
for (int j = 0; j < V; ++j)
dp[i][j] = INF;
for (int i = 0; i < E; ++i)
scanf("%d%d%d", &a, &b, &c), adj[a][b] = c;
dp[1][0] = 0;
for (int i = 1; i < (1 << V); ++i)
for (int j = 0; j < V; ++j) {
if (!(i & (1 << j)))
continue;
for (int k = 0; k < V; ++k) {
if (i & (1 << k))
continue;
dp[i | (1 << k)][k] = min(dp[i | (1 << k)][k], dp[i][j] + adj[j][k]);
}
}
int solve = INF;
for (int i = 1; i < V; ++i)
solve = min(solve, dp[(1 << V) - 1][i] + adj[i][0]);
printf("%d\n", (solve == INF) ? -1 : solve);
return 0;
}
|
replace
| 44 | 46 | 44 | 61 |
TLE
| |
p02323
|
C++
|
Memory Limit Exceeded
|
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = a; i >= n; i--)
#define INF 99999999
#define INF_M 2147483647
#define pb(a) push_back(a)
using namespace std;
typedef pair<int, int> pii;
typedef long long int ll;
typedef vector<pii> VP;
int dy[] = {0, 0, 1, -1};
int dx[] = {1, -1, 0, 0};
int dist[20][20];
int dp[1 << 20][20];
int V, E;
int s, t, d;
int rec(int S, int v) {
if (dp[S][v] >= 0)
return dp[S][v];
if (S == (1 << V) - 1 && v == 0)
return dp[S][v] = 0;
int res = INF;
for (int r = 0; r < V; r++) {
if (!(S & 1 << r)) {
res = min(res, rec(S | 1 << r, r) + dist[v][r]);
}
}
return dp[S][v] = res;
}
int main() {
cin >> V >> E;
rep(i, 0, 20) rep(j, 0, 20) dist[i][j] = INF;
rep(i, 0, E) {
cin >> s >> t >> d;
dist[s][t] = d;
}
memset(dp, -1, sizeof(dp));
int ans = rec(0, 0);
if (ans == INF)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = a; i >= n; i--)
#define INF 99999999
#define INF_M 2147483647
#define pb(a) push_back(a)
using namespace std;
typedef pair<int, int> pii;
typedef long long int ll;
typedef vector<pii> VP;
int dy[] = {0, 0, 1, -1};
int dx[] = {1, -1, 0, 0};
int dist[15][15];
int dp[1 << 15][15];
int V, E;
int s, t, d;
int rec(int S, int v) {
if (dp[S][v] >= 0)
return dp[S][v];
if (S == (1 << V) - 1 && v == 0)
return dp[S][v] = 0;
int res = INF;
for (int r = 0; r < V; r++) {
if (!(S & 1 << r)) {
res = min(res, rec(S | 1 << r, r) + dist[v][r]);
}
}
return dp[S][v] = res;
}
int main() {
cin >> V >> E;
rep(i, 0, 20) rep(j, 0, 20) dist[i][j] = INF;
rep(i, 0, E) {
cin >> s >> t >> d;
dist[s][t] = d;
}
memset(dp, -1, sizeof(dp));
int ans = rec(0, 0);
if (ans == INF)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
replace
| 15 | 17 | 15 | 17 |
MLE
| |
p02323
|
C++
|
Memory Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef pair<long, long> PLL;
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 SZ(a) int((a).size())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (LL 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);
const int INF = INT_MAX / 10;
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
#define MAX_N 20
int n;
int d[MAX_N][MAX_N];
int dp[1 << MAX_N][MAX_N];
int rec(int S, int v) { //??¢????????£??????????????????S??¨???????????????v
if (dp[S][v] >=
0) { //??¢?????????S????????????v??????????????????????????????
return dp[S][v];
}
if (S == (1 << n) - 1 &&
v ==
0) { // S?????¨??????????????????????????¶?????§???????????????????????£?????????
dp[S][v] = 0;
return 0;
}
int res = INF;
for (int u = 0; u < n; u++) {
if (!(S >> u & 1)) { //??????u??????????????£??????????????¨???
res = min(
res,
rec(S | 1 << u, u) +
d[v]
[u]); //??????u???S???????????????u->v????????????????????????????????´?????¨????????¨???res????????????
}
}
dp[S][v] = res;
// cout<<res<<endl;
return res;
}
int main() {
memset(dp, -1, sizeof(dp));
int V, E;
cin >> V >> E;
n = V;
REP(i, n) REP(j, n) d[i][j] = INF;
REP(i, E) {
int s, t, cost;
cin >> s >> t >> cost;
d[s][t] = cost;
}
int res = rec(0, 0);
if (res < INF)
cout << res << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef pair<long, long> PLL;
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 SZ(a) int((a).size())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (LL 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);
const int INF = INT_MAX / 10;
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
#define MAX_N 16
int n;
int d[MAX_N][MAX_N];
int dp[1 << MAX_N][MAX_N];
int rec(int S, int v) { //??¢????????£??????????????????S??¨???????????????v
if (dp[S][v] >=
0) { //??¢?????????S????????????v??????????????????????????????
return dp[S][v];
}
if (S == (1 << n) - 1 &&
v ==
0) { // S?????¨??????????????????????????¶?????§???????????????????????£?????????
dp[S][v] = 0;
return 0;
}
int res = INF;
for (int u = 0; u < n; u++) {
if (!(S >> u & 1)) { //??????u??????????????£??????????????¨???
res = min(
res,
rec(S | 1 << u, u) +
d[v]
[u]); //??????u???S???????????????u->v????????????????????????????????´?????¨????????¨???res????????????
}
}
dp[S][v] = res;
// cout<<res<<endl;
return res;
}
int main() {
memset(dp, -1, sizeof(dp));
int V, E;
cin >> V >> E;
n = V;
REP(i, n) REP(j, n) d[i][j] = INF;
REP(i, E) {
int s, t, cost;
cin >> s >> t >> cost;
d[s][t] = cost;
}
int res = rec(0, 0);
if (res < INF)
cout << res << endl;
else
cout << -1 << endl;
return 0;
}
|
replace
| 49 | 50 | 49 | 50 |
MLE
| |
p02323
|
C++
|
Memory Limit Exceeded
|
#define _CRT_SECURE_NO_WARNINGS 1
#define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <forward_list>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define INF ((int)(1 << 25))
#define REP(i, n) for (int i = 0; i < (int)n; i++)
#define FOR(i, n) REP(i, n)
#define FORI(i, k, n) for (int i = k; i < (int)n; i++)
#define TORAD 2.0 * M_PI / 360.0
#define INT(x) \
int x; \
cin >> x;
#define STR(x) \
string x; \
cin >> x;
#define ALL(x) begin(x), end(x)
#define RALL(x) (x).rbegin(), (x).rend()
#define DEBUG(x) cout << #x << ":" << x << endl;
#define EPS 1e-12
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
typedef long long lint;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<int> vi;
typedef vector<lint> vl;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
template <class T> void debug(T a) {
for (auto i : a)
cout << i << endl;
}
int v, e;
int cost[20][20];
int memo[1 << 16][16][16];
int dp(const int bit, const int now, const int goal) {
if (__builtin_popcount(bit) == v)
return cost[now][goal];
if (memo[bit][now][goal] != -1)
return memo[bit][now][goal];
int ans = INF;
FOR(i, v) {
if (bit & 1 << i || cost[now][i] < 0)
continue;
ans = min(ans, dp(bit | 1 << i, i, goal) + cost[now][i]);
}
return memo[bit][now][goal] = ans;
}
int main() {
cin >> v >> e;
FOR(i, 20) FOR(j, 20) cost[i][j] = INF;
memset(memo, -1, sizeof memo);
FOR(i, e) {
int s, t, d;
cin >> s >> t >> d;
cost[s][t] = d;
}
int ans = INF;
FOR(i, v) { ans = min(ans, dp(1 << i, i, i)); }
if (ans <= (v + 1) * 1000)
cout << ans << endl;
else
cout << -1 << endl;
}
|
#define _CRT_SECURE_NO_WARNINGS 1
#define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <forward_list>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define INF ((int)(1 << 25))
#define REP(i, n) for (int i = 0; i < (int)n; i++)
#define FOR(i, n) REP(i, n)
#define FORI(i, k, n) for (int i = k; i < (int)n; i++)
#define TORAD 2.0 * M_PI / 360.0
#define INT(x) \
int x; \
cin >> x;
#define STR(x) \
string x; \
cin >> x;
#define ALL(x) begin(x), end(x)
#define RALL(x) (x).rbegin(), (x).rend()
#define DEBUG(x) cout << #x << ":" << x << endl;
#define EPS 1e-12
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
typedef long long lint;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<int> vi;
typedef vector<lint> vl;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
template <class T> void debug(T a) {
for (auto i : a)
cout << i << endl;
}
int v, e;
int cost[20][20];
int memo[1 << 16][15][15];
int dp(const int bit, const int now, const int goal) {
if (__builtin_popcount(bit) == v)
return cost[now][goal];
if (memo[bit][now][goal] != -1)
return memo[bit][now][goal];
int ans = INF;
FOR(i, v) {
if (bit & 1 << i || cost[now][i] < 0)
continue;
ans = min(ans, dp(bit | 1 << i, i, goal) + cost[now][i]);
}
return memo[bit][now][goal] = ans;
}
int main() {
cin >> v >> e;
FOR(i, 20) FOR(j, 20) cost[i][j] = INF;
memset(memo, -1, sizeof memo);
FOR(i, e) {
int s, t, d;
cin >> s >> t >> d;
cost[s][t] = d;
}
int ans = INF;
FOR(i, v) { ans = min(ans, dp(1 << i, i, i)); }
if (ans <= (v + 1) * 1000)
cout << ans << endl;
else
cout << -1 << endl;
}
|
replace
| 62 | 63 | 62 | 63 |
MLE
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.