problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9
values |
|---|---|---|---|---|---|---|---|
p03162 | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdint>
#include <iostream>
#include <vector>
enum Act { A, B, C };
using arr3 = std::array<int64_t, 3>;
int main(int argc, char *argv[]) {
int64_t N;
std::cin >> N;
std::vector<arr3> h(N + 1);
for (int64_t i = 1; i <= N; ++i) {
std::cin >> h[i][A] >> h[i][B] >> h[i][C];
}
std::vector<arr3> dp(N + 1, {0, 0, 0});
for (size_t i = 1; i <= N; ++i) {
const auto j{i - 1};
dp[i][A] = std::max(dp[j][B], dp[j][C]) + h[i][A];
dp[i][B] = std::max(dp[j][C], dp[j][B]) + h[i][B];
dp[i][C] = std::max(dp[j][A], dp[j][A]) + h[i][C];
}
std::cout << std::max({dp[N][A], dp[N][B], dp[N][C]}) << std::endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <cstdint>
#include <iostream>
#include <vector>
enum Act { A, B, C };
using arr3 = std::array<int64_t, 3>;
int main(int argc, char *argv[]) {
int64_t N;
std::cin >> N;
std::vector<arr3> h(N + 1);
for (int64_t i = 1; i <= N; ++i) {
std::cin >> h[i][A] >> h[i][B] >> h[i][C];
}
std::vector<arr3> dp(N + 1, {0, 0, 0});
for (size_t i = 1; i <= N; ++i) {
const auto j{i - 1};
dp[i][A] = std::max(dp[j][B], dp[j][C]) + h[i][A];
dp[i][B] = std::max(dp[j][C], dp[j][A]) + h[i][B];
dp[i][C] = std::max(dp[j][A], dp[j][B]) + h[i][C];
}
std::cout << std::max({dp[N][A], dp[N][B], dp[N][C]}) << std::endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 964,646 | 964,647 | u854760708 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pll pair<ll, ll>
#define ff first
#define ss second
#define se set<ll>
#define inf 10000000000000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifdef APNA_IO
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll n;
cin >> n;
ll h[n][3];
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < 3; j++) {
cin >> h[i][j];
}
}
pll d[3];
d[0].ff = 1;
d[0].ss = 2;
d[1].ff = 0;
d[1].ss = 2;
d[2].ss = 1;
d[2].ff = 0;
for (int i = 1; i < n; i++) {
for (int j = 0; j < n; j++) {
h[i][j] += max(h[i - 1][d[j].ss], h[i - 1][d[j].ff]);
}
}
cout << max(max(h[n - 1][0], h[n - 1][1]), h[n - 1][2]);
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pll pair<ll, ll>
#define ff first
#define ss second
#define se set<ll>
#define inf 10000000000000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifdef APNA_IO
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll n;
cin >> n;
ll h[n][3];
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < 3; j++) {
cin >> h[i][j];
}
}
pll d[3];
d[0].ff = 1;
d[0].ss = 2;
d[1].ff = 0;
d[1].ss = 2;
d[2].ss = 1;
d[2].ff = 0;
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
h[i][j] += max(h[i - 1][d[j].ss], h[i - 1][d[j].ff]);
}
}
cout << max(max(h[n - 1][0], h[n - 1][1]), h[n - 1][2]);
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 964,650 | 964,651 | u511137896 | cpp |
p03162 | #include <iostream>
using namespace std;
typedef long long int ll;
ll max(ll a, ll b) { return (a > b ? a : b); }
ll max3(ll a, ll b, ll c) { return max(max(a, b), c); }
// recursive solution
ll vacation(ll *a, ll *b, ll *c, ll n, ll choice) {
if (n == 1 && choice == 0)
return a[0];
else if (n == 1 && choice == 1)
return b[0];
else if (n == 1 && choice == 2)
return c[0];
else if (choice == 0) {
ll case1 = vacation(a, b, c, n - 1, 1) +
a[n - 1]; // 1: 'a' of previous and 'b' of current
ll case2 = vacation(a, b, c, n - 1, 2) + a[n - 1];
return max(case1, case2);
} else if (choice == 1) {
ll case3 = vacation(a, b, c, n - 1, 0) + b[n - 1];
ll case4 = vacation(a, b, c, n - 1, 2) + b[n - 1];
return max(case3, case4);
}
else {
// choose current ka 'c'
ll case5 = vacation(a, b, c, n - 1, 0) + c[n - 1];
ll case6 = vacation(a, b, c, n - 1, 1) + c[n - 1];
return max(case5, case6);
}
}
// dp solution
ll vacation_dp(ll *a, ll *b, ll *c, ll n) {
ll dp[n + 1][3];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
if (i == 1 && j == 0)
dp[i][j] = a[0];
else if (i == 1 && j == 1)
dp[i][j] = b[0];
else if (i == 1 && j == 2)
dp[i][j] = c[0];
else if (j == 0) {
ll case1 =
dp[i - 1][1] + a[i - 1]; // 1: 'a' of previous and 'b' of current
ll case2 = dp[i - 1][2] + a[i - 1];
dp[i][j] = max(case1, case2);
}
else if (j == 1) {
ll case1 =
dp[i - 1][0] + b[i - 1]; // 1: 'a' of previous and 'b' of current
ll case2 = dp[i - 1][2] + b[i - 1];
dp[i][j] = max(case1, case2);
}
else {
ll case1 =
dp[i - 1][0] + c[i - 1]; // 1: 'a' of previous and 'b' of current
ll case2 = dp[i - 1][1] + c[i - 1];
dp[i][j] = max(case1, case2);
}
}
}
return max3(dp[n][0], dp[n][1], dp[2][2]);
}
int main() {
ll N;
cin >> N;
ll a[N], b[N], c[N];
for (int i = 0; i < N; i++)
cin >> a[i] >> b[i] >> c[i];
cout << vacation_dp(a, b, c, N) << endl;
} | #include <iostream>
using namespace std;
typedef long long int ll;
ll max(ll a, ll b) { return (a > b ? a : b); }
ll max3(ll a, ll b, ll c) { return max(max(a, b), c); }
// recursive solution
ll vacation(ll *a, ll *b, ll *c, ll n, ll choice) {
if (n == 1 && choice == 0)
return a[0];
else if (n == 1 && choice == 1)
return b[0];
else if (n == 1 && choice == 2)
return c[0];
else if (choice == 0) {
ll case1 = vacation(a, b, c, n - 1, 1) +
a[n - 1]; // 1: 'a' of previous and 'b' of current
ll case2 = vacation(a, b, c, n - 1, 2) + a[n - 1];
return max(case1, case2);
} else if (choice == 1) {
ll case3 = vacation(a, b, c, n - 1, 0) + b[n - 1];
ll case4 = vacation(a, b, c, n - 1, 2) + b[n - 1];
return max(case3, case4);
}
else {
// choose current ka 'c'
ll case5 = vacation(a, b, c, n - 1, 0) + c[n - 1];
ll case6 = vacation(a, b, c, n - 1, 1) + c[n - 1];
return max(case5, case6);
}
}
// dp solution
ll vacation_dp(ll *a, ll *b, ll *c, ll n) {
ll dp[n + 1][3];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
if (i == 1 && j == 0)
dp[i][j] = a[0];
else if (i == 1 && j == 1)
dp[i][j] = b[0];
else if (i == 1 && j == 2)
dp[i][j] = c[0];
else if (j == 0) {
ll case1 =
dp[i - 1][1] + a[i - 1]; // 1: 'a' of previous and 'b' of current
ll case2 = dp[i - 1][2] + a[i - 1];
dp[i][j] = max(case1, case2);
}
else if (j == 1) {
ll case1 =
dp[i - 1][0] + b[i - 1]; // 1: 'a' of previous and 'b' of current
ll case2 = dp[i - 1][2] + b[i - 1];
dp[i][j] = max(case1, case2);
}
else {
ll case1 =
dp[i - 1][0] + c[i - 1]; // 1: 'a' of previous and 'b' of current
ll case2 = dp[i - 1][1] + c[i - 1];
dp[i][j] = max(case1, case2);
}
}
}
return max3(dp[n][0], dp[n][1], dp[n][2]);
}
int main() {
ll N;
cin >> N;
ll a[N], b[N], c[N];
for (int i = 0; i < N; i++)
cin >> a[i] >> b[i] >> c[i];
cout << vacation_dp(a, b, c, N) << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"function.return_value.change"
] | 964,654 | 964,655 | u644828064 | cpp |
p03162 | // VIVEK UPADHYAY
// MANIT, BHOPAL(M.P)
/**********************************************************************************************/
/**********************************************************************************************/
// $$ JAB-TAK TODEGA NHI,
// TAB -TAK CHODEGA NHI :D
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unistd.h>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define F first
#define S second
#define mk(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define LINE cout << "\n";
#define ok cout << "ok\n";
#define dbg(x) cout << #x << " = " << (x) << "\n";
typedef long long ll;
const int MAXN = 2 * 1e3 + 10;
const int MAX = 1e7 + 1;
double pi = 3.1415926535897932384626433832795;
const ll inf = 1e18;
ll mod = 1e9 + 7;
ll powr(ll a, ll b) {
if (b == 0)
return 1LL;
ll x = powr(a, b / 2);
x = (x * x) % mod;
if (b % 2)
return ((a % mod) * x) % mod;
return x;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
int main() {
int N;
cin >> N;
int a[N][3];
for (int i = 0; i < N; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
int dp[N][3];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < N; i++) {
dp[i][0] = a[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << min(dp[N - 1][0], min(dp[N - 1][1], dp[N - 1][2])) << endl;
return 0;
}
| // VIVEK UPADHYAY
// MANIT, BHOPAL(M.P)
/**********************************************************************************************/
/**********************************************************************************************/
// $$ JAB-TAK TODEGA NHI,
// TAB -TAK CHODEGA NHI :D
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unistd.h>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define F first
#define S second
#define mk(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define LINE cout << "\n";
#define ok cout << "ok\n";
#define dbg(x) cout << #x << " = " << (x) << "\n";
typedef long long ll;
const int MAXN = 2 * 1e3 + 10;
const int MAX = 1e7 + 1;
double pi = 3.1415926535897932384626433832795;
const ll inf = 1e18;
ll mod = 1e9 + 7;
ll powr(ll a, ll b) {
if (b == 0)
return 1LL;
ll x = powr(a, b / 2);
x = (x * x) % mod;
if (b % 2)
return ((a % mod) * x) % mod;
return x;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
int main() {
int N;
cin >> N;
int a[N][3];
for (int i = 0; i < N; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
int dp[N][3];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < N; i++) {
dp[i][0] = a[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[N - 1][0], max(dp[N - 1][1], dp[N - 1][2])) << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 964,659 | 964,660 | u753615145 | cpp |
p03162 | // VIVEK UPADHYAY
// MANIT, BHOPAL(M.P)
/**********************************************************************************************/
/**********************************************************************************************/
// $$ JAB-TAK TODEGA NHI,
// TAB -TAK CHODEGA NHI :D
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unistd.h>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define F first
#define S second
#define mk(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define LINE cout << "\n";
#define ok cout << "ok\n";
#define dbg(x) cout << #x << " = " << (x) << "\n";
typedef long long ll;
const int MAXN = 2 * 1e3 + 10;
const int MAX = 1e7 + 1;
double pi = 3.1415926535897932384626433832795;
const ll inf = 1e18;
ll mod = 1e9 + 7;
ll powr(ll a, ll b) {
if (b == 0)
return 1LL;
ll x = powr(a, b / 2);
x = (x * x) % mod;
if (b % 2)
return ((a % mod) * x) % mod;
return x;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
int main() {
int N;
cin >> N;
int a[N][3];
for (int i = 0; i < N; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
int dp[N][3];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < N; i++) {
dp[i][0] = a[i][0] + min(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + min(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + min(dp[i - 1][0], dp[i - 1][1]);
}
cout << min(dp[N - 1][0], min(dp[N - 1][1], dp[N - 1][2])) << endl;
return 0;
}
| // VIVEK UPADHYAY
// MANIT, BHOPAL(M.P)
/**********************************************************************************************/
/**********************************************************************************************/
// $$ JAB-TAK TODEGA NHI,
// TAB -TAK CHODEGA NHI :D
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unistd.h>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define F first
#define S second
#define mk(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define LINE cout << "\n";
#define ok cout << "ok\n";
#define dbg(x) cout << #x << " = " << (x) << "\n";
typedef long long ll;
const int MAXN = 2 * 1e3 + 10;
const int MAX = 1e7 + 1;
double pi = 3.1415926535897932384626433832795;
const ll inf = 1e18;
ll mod = 1e9 + 7;
ll powr(ll a, ll b) {
if (b == 0)
return 1LL;
ll x = powr(a, b / 2);
x = (x * x) % mod;
if (b % 2)
return ((a % mod) * x) % mod;
return x;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
int main() {
int N;
cin >> N;
int a[N][3];
for (int i = 0; i < N; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
int dp[N][3];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < N; i++) {
dp[i][0] = a[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[N - 1][0], max(dp[N - 1][1], dp[N - 1][2])) << endl;
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"expression.operation.binary.change",
"io.output.change"
] | 964,661 | 964,660 | u753615145 | cpp |
p03162 | #include <iostream>
#include <string>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define INT_MAX 0x7FFFFFFF
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define ABS(a) ((a) < 0 ? (-(a)) : (a))
using namespace std;
typedef long long int LL;
int main() {
int N, Ha = 0, Hb = 0, Hc = 0;
cin >> N;
REP(i, N) {
int a, b, c;
cin >> a >> b >> c;
int tHa = a + MAX(Hb, Hc);
int tHb = b + MAX(Ha, Hc);
int tHc = c + MAX(Hb, Hc);
Ha = tHa, Hb = tHb, Hc = tHc;
}
int ret = MAX(Ha, MAX(Hb, Hc));
cout << ret << endl;
} | #include <iostream>
#include <string>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define INT_MAX 0x7FFFFFFF
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define ABS(a) ((a) < 0 ? (-(a)) : (a))
using namespace std;
typedef long long int LL;
int main() {
int N, Ha = 0, Hb = 0, Hc = 0;
cin >> N;
REP(i, N) {
int a, b, c;
cin >> a >> b >> c;
int tHa = a + MAX(Hb, Hc);
int tHb = b + MAX(Ha, Hc);
int tHc = c + MAX(Ha, Hb);
Ha = tHa;
Hb = tHb;
Hc = tHc;
}
int ret = MAX(Ha, MAX(Hb, Hc));
cout << ret << endl;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 964,664 | 964,665 | u597940868 | cpp |
p03162 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <bits/stdc++.h>
#define rep(i, n) Rep(i, 0, n)
#define Rep(i, k, n) for (int i = k; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define vi vector<int>
#define vii vector<vector<int>>
#define mii map<int, int>
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define ALL(a) (a).begin(), (a).end()
#define pb push_back
//#define int ll
typedef long long ll;
const int md = 1000000007;
const int INF = 1 << 30;
using namespace std;
string yn(bool x) { return x ? "Yes" : "No"; }
int abs(int x) { return x >= 0 ? x : -x; }
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
rep(i, n) { cin >> a[i] >> b[i] >> c[i]; }
int da[n], db[n], dc[n];
int check = 0;
da[0] = a[0];
db[0] = b[0];
dc[0] = c[0];
for (int i = 1; i < n; i++) {
da[i] = db[i] = dc[i] = 0;
da[i] = a[i] + max(db[i - 1], dc[i - 1]);
db[i] = b[i] + max(da[i - 1], dc[i - 1]);
dc[i] = c[i] + max(db[i - 1], da[i - 1]);
}
int ans = min(da[n - 1], min(db[n - 1], dc[n - 1]));
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <bits/stdc++.h>
#define rep(i, n) Rep(i, 0, n)
#define Rep(i, k, n) for (int i = k; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define vi vector<int>
#define vii vector<vector<int>>
#define mii map<int, int>
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define ALL(a) (a).begin(), (a).end()
#define pb push_back
//#define int ll
typedef long long ll;
const int md = 1000000007;
const int INF = 1 << 30;
using namespace std;
string yn(bool x) { return x ? "Yes" : "No"; }
int abs(int x) { return x >= 0 ? x : -x; }
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
rep(i, n) { cin >> a[i] >> b[i] >> c[i]; }
int da[n], db[n], dc[n];
int check = 0;
da[0] = a[0];
db[0] = b[0];
dc[0] = c[0];
for (int i = 1; i < n; i++) {
da[i] = db[i] = dc[i] = 0;
da[i] = a[i] + max(db[i - 1], dc[i - 1]);
db[i] = b[i] + max(da[i - 1], dc[i - 1]);
dc[i] = c[i] + max(db[i - 1], da[i - 1]);
}
int ans = max(da[n - 1], max(db[n - 1], dc[n - 1]));
cout << ans << endl;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 964,666 | 964,667 | u381585104 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], c[100005];
long long int dp[200000][3];
int main() {
int N, d, e, f;
cin >> N;
for (int i = 1; i <= N; i++)
cin >> a[i] >> b[i] >> c[i];
dp[1][0] = a[1];
dp[1][2] = b[1];
dp[1][2] = c[1];
for (int i = 2; i <= N; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[N][0], max(dp[N][1], dp[N][2]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], c[100005];
long long int dp[200000][3];
int main() {
int N, d, e, f;
cin >> N;
for (int i = 1; i <= N; i++)
cin >> a[i] >> b[i] >> c[i];
dp[1][0] = a[1];
dp[1][1] = b[1];
dp[1][2] = c[1];
for (int i = 2; i <= N; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[N][0], max(dp[N][1], dp[N][2]));
return 0;
}
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 964,670 | 964,671 | u292217769 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int a[100000], b[100000], c[100000];
int dp[200000][3];
int main() {
int N, d, e, f;
cin >> N;
for (int i = 1; i <= N; i++)
cin >> a[i] >> b[i] >> c[i];
dp[1][0] = a[1];
dp[1][2] = b[1];
dp[1][2] = c[1];
for (int i = 2; i <= N; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[N][0], max(dp[N][1], dp[N][2]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], c[100005];
long long int dp[200000][3];
int main() {
int N, d, e, f;
cin >> N;
for (int i = 1; i <= N; i++)
cin >> a[i] >> b[i] >> c[i];
dp[1][0] = a[1];
dp[1][1] = b[1];
dp[1][2] = c[1];
for (int i = 2; i <= N; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[N][0], max(dp[N][1], dp[N][2]));
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 964,672 | 964,671 | u292217769 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define N 100004
int memo[N][3];
int A[N];
int B[N];
int C[N];
int n;
int m3(int a, int b, int c) { return max(c, max(a, b)); }
int dp(int pos, int l) {
if (pos >= n) {
return 0;
}
if (memo[pos][l] != -1)
return memo[pos][l];
if (l == 0)
return memo[pos][l] = max(B[pos] + dp(pos + 1, 0), C[pos] + dp(pos + 1, 0));
if (l == 1)
return memo[pos][l] = max(A[pos] + dp(pos + 1, 1), C[pos] + dp(pos + 1, 1));
if (l == 2)
return memo[pos][l] = max(A[pos] + dp(pos + 1, 2), B[pos] + dp(pos + 1, 2));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", A + i, B + i, C + i);
}
memset(memo, -1, sizeof memo);
printf("%d\n", m3(A[0] + dp(1, 0), B[0] + dp(1, 1), C[0] + dp(1, 2)));
}
| #include <bits/stdc++.h>
using namespace std;
#define N 100004
int memo[N][3];
int A[N];
int B[N];
int C[N];
int n;
int m3(int a, int b, int c) { return max(c, max(a, b)); }
int dp(int pos, int l) {
if (pos >= n) {
return 0;
}
if (memo[pos][l] != -1)
return memo[pos][l];
if (l == 0)
return memo[pos][l] = max(B[pos] + dp(pos + 1, 1), C[pos] + dp(pos + 1, 2));
if (l == 1)
return memo[pos][l] = max(A[pos] + dp(pos + 1, 0), C[pos] + dp(pos + 1, 2));
if (l == 2)
return memo[pos][l] = max(A[pos] + dp(pos + 1, 0), B[pos] + dp(pos + 1, 1));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", A + i, B + i, C + i);
}
memset(memo, -1, sizeof memo);
printf("%d\n", m3(A[0] + dp(1, 0), B[0] + dp(1, 1), C[0] + dp(1, 2)));
} | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 964,673 | 964,674 | u928468768 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// #define int ll
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec) {
is >> x;
}
return is;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
for (T i : a) {
out << i << ',';
}
out << ']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0}; // DRUL
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const int MOD = 1000000007;
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> a(n), b(n), c(n);
REP(i, n) cin >> a[i] >> b[i] >> c[i];
auto dp = make_v<ll>(n, 3);
dp[0][0] = a[0], dp[0][1] = b[0], dp[0][2] = c[0];
FOR(i, 1, n) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + b[i];
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + c[i];
}
cout << max({dp[n - 1][0], dp[n - 1][2], dp[n - 1][2]}) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// #define int ll
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec) {
is >> x;
}
return is;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
for (T i : a) {
out << i << ',';
}
out << ']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0}; // DRUL
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const int MOD = 1000000007;
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> a(n), b(n), c(n);
REP(i, n) cin >> a[i] >> b[i] >> c[i];
auto dp = make_v<ll>(n, 3);
dp[0][0] = a[0], dp[0][1] = b[0], dp[0][2] = c[0];
FOR(i, 1, n) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + b[i];
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + c[i];
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << endl;
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 964,677 | 964,678 | u333917945 | cpp |
p03162 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
int n;
cin >> n;
ll dp[n + 1][3] = {};
rep(i, n) {
int a, b, c;
cin >> a >> b >> c;
dp[i + 1][0] = max(dp[i][1] + a, dp[i][2] + a);
dp[i + 1][1] = max(dp[i][0] + b, dp[i][2] + b);
dp[i + 1][2] = max(dp[i][1] + c, dp[i][2] + c);
}
cout << max({dp[n][0], dp[n][1], dp[n][2]}) << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
int n;
cin >> n;
ll dp[n + 1][3] = {};
rep(i, n) {
int a, b, c;
cin >> a >> b >> c;
dp[i + 1][0] = max(dp[i][1] + a, dp[i][2] + a);
dp[i + 1][1] = max(dp[i][0] + b, dp[i][2] + b);
dp[i + 1][2] = max(dp[i][0] + c, dp[i][1] + c);
}
cout << max({dp[n][0], dp[n][1], dp[n][2]}) << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 964,679 | 964,680 | u174404613 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
//#define int ll
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<short> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<ld> vld;
typedef vector<vld> vvld;
typedef vector<vvld> vvvld;
typedef vector<string> vst;
typedef vector<vst> vvst;
typedef pair<ld, ld> pld;
typedef complex<double> base;
#define inmin(a, b) a = min(a, (b))
#define inmax(a, b) a = max(a, (b))
#define mp(a, b) make_pair(a, b)
#define modsum(a, b) ((a) + (b) >= M ? (a) + (b)-M : (a) + (b))
#define modsubtract(a, b) ((a) - (b) < 0 ? (a) - (b) + M : (a) - (b))
#define modmultiply(a, b) (((a) * (b)) % M)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define sqr(x) ((x) * (x))
#define fori(i, n) for (int i = 0; i < int(n); ++i)
#define cint const int &
#define SZ(a) ((int)((a).size()))
#define watch(x) cout << (#x) << " = " << (x) << endl;
const double PI = 2 * acos(0.0);
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
inline void transpose(vector<string> &a) {
int n = a.size();
if (n == 0)
return;
int m = a[0].size();
vector<string> b(m, string(n, ' '));
fori(i, n) fori(j, m) b[j][i] = a[i][j];
a = b;
}
template <class T> inline ostream &operator<<(ostream &out, vector<T> &a) {
out << "{";
fori(i, SZ(a)) out << a[i] << vector<string>{", ", "}"}[i + 1 == SZ(a)];
return out;
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef MAX_HOME
freopen("input.txt", "r", stdin);
clock_t start = clock();
#define cerr cout
#endif
cout << setprecision(12) << fixed;
smain();
#ifdef MAX_HOME
cout << "\n\n\n\n";
cout << "TOTAL EXECUTION TIME: " << float(clock() - start) / CLOCKS_PER_SEC
<< endl;
#endif
}
const int N = 1e5 + 9;
const int L = 1e4 + 9;
const ll oo = 1e18;
void smain() {
int n;
cin >> n;
vl h(n + 1, 0);
vvl dp(n + 1, vl(3, -oo));
vvl a(n + 1, vl(3, -oo));
fori(i, n) cin >> a[i + 1][0] >> a[i + 1][1] >> a[i + 1][2];
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 1; i <= n; ++i) {
for (int z : {0, 1, 2}) {
for (int step : {1, 2}) {
if (i - step < 0)
continue;
ll cur = a[i][z] + (step == 2 ? a[i - 1][z] : 0);
inmax(dp[i][z], dp[i - step][(z + 1) % 3] + cur);
inmax(dp[i][z], dp[i - step][(z + 2) % 3] + cur);
}
}
}
cout << *max_element(ALL(dp[n]));
} | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
//#define int ll
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<short> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<ld> vld;
typedef vector<vld> vvld;
typedef vector<vvld> vvvld;
typedef vector<string> vst;
typedef vector<vst> vvst;
typedef pair<ld, ld> pld;
typedef complex<double> base;
#define inmin(a, b) a = min(a, (b))
#define inmax(a, b) a = max(a, (b))
#define mp(a, b) make_pair(a, b)
#define modsum(a, b) ((a) + (b) >= M ? (a) + (b)-M : (a) + (b))
#define modsubtract(a, b) ((a) - (b) < 0 ? (a) - (b) + M : (a) - (b))
#define modmultiply(a, b) (((a) * (b)) % M)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define sqr(x) ((x) * (x))
#define fori(i, n) for (int i = 0; i < int(n); ++i)
#define cint const int &
#define SZ(a) ((int)((a).size()))
#define watch(x) cout << (#x) << " = " << (x) << endl;
const double PI = 2 * acos(0.0);
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
inline void transpose(vector<string> &a) {
int n = a.size();
if (n == 0)
return;
int m = a[0].size();
vector<string> b(m, string(n, ' '));
fori(i, n) fori(j, m) b[j][i] = a[i][j];
a = b;
}
template <class T> inline ostream &operator<<(ostream &out, vector<T> &a) {
out << "{";
fori(i, SZ(a)) out << a[i] << vector<string>{", ", "}"}[i + 1 == SZ(a)];
return out;
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef MAX_HOME
freopen("input.txt", "r", stdin);
clock_t start = clock();
#define cerr cout
#endif
cout << setprecision(12) << fixed;
smain();
#ifdef MAX_HOME
cout << "\n\n\n\n";
cout << "TOTAL EXECUTION TIME: " << float(clock() - start) / CLOCKS_PER_SEC
<< endl;
#endif
}
const int N = 1e5 + 9;
const int L = 1e4 + 9;
const ll oo = 1e18;
void smain() {
int n;
cin >> n;
vl h(n + 1, 0);
vvl dp(n + 1, vl(3, -oo));
vvl a(n + 1, vl(3, -oo));
fori(i, n) cin >> a[i + 1][0] >> a[i + 1][1] >> a[i + 1][2];
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 1; i <= n; ++i) {
for (int z : {0, 1, 2}) {
for (int step : {1}) {
if (i - step < 0)
continue;
ll cur = a[i][z] + (step == 2 ? a[i - 1][z] : 0);
inmax(dp[i][z], dp[i - step][(z + 1) % 3] + cur);
inmax(dp[i][z], dp[i - step][(z + 2) % 3] + cur);
}
}
}
cout << *max_element(ALL(dp[n]));
} | [] | 964,681 | 964,682 | u443685186 | cpp |
p03162 | #include <algorithm>
#include <cstdio>
using namespace std;
int N;
int a[100000];
int b[100000];
int c[100000];
int dp[100000][3];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d %d %d", &a[i], &b[i], &c[i]);
}
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < N; i++) {
int temp0 = max(dp[i - 1][1], dp[i - 1][2]);
int temp1 = max(dp[i - 1][2], dp[i - 1][0]);
int temp2 = max(dp[i - 1][0], dp[i - 1][1]);
dp[i][0] = temp0 + a[i];
dp[i][1] = temp1 + b[i];
dp[i][2] = temp2 + c[i];
}
int ans = 1000000000;
for (int i = 0; i < 3; i++) {
if (dp[N - 1][i] > ans) {
ans = dp[N - 1][i];
}
}
printf("%d\n", ans);
return 0;
} | #include <algorithm>
#include <cstdio>
using namespace std;
int N;
int a[100000];
int b[100000];
int c[100000];
int dp[100000][3];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d %d %d", &a[i], &b[i], &c[i]);
}
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < N; i++) {
int temp0 = max(dp[i - 1][1], dp[i - 1][2]);
int temp1 = max(dp[i - 1][2], dp[i - 1][0]);
int temp2 = max(dp[i - 1][0], dp[i - 1][1]);
dp[i][0] = temp0 + a[i];
dp[i][1] = temp1 + b[i];
dp[i][2] = temp2 + c[i];
}
int ans = 0;
for (int i = 0; i < 3; i++) {
if (dp[N - 1][i] > ans) {
ans = dp[N - 1][i];
}
}
printf("%d\n", ans);
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 964,698 | 964,699 | u048945791 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
typedef long long int lo;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fio() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define FOR for (int i = 1; i <= n; i++)
#define mid (bas + son) / 2
const lo MAX = -1000000000000000000;
const lo MIN = 1000000000000000000;
const lo inf = 1000000000;
const lo KOK = 100000;
const lo LOG = 30;
const lo li = 100005;
const lo mod = 1000000007;
lo n, m, cev, b[li], a[li], c[li], dp[li][5];
string s;
vector<int> v;
lo f(lo sira, lo hangi) {
lo mx = MAX;
if (sira > 3)
return 0;
if (~dp[sira][hangi])
return dp[sira][hangi];
if (hangi == 0) {
mx = max(mx, f(sira + 1, 1) + a[sira]);
mx = max(mx, f(sira + 1, 2) + b[sira]);
mx = max(mx, f(sira + 1, 3) + c[sira]);
}
if (hangi == 1) {
mx = max(mx, f(sira + 1, 2) + b[sira]);
mx = max(mx, f(sira + 1, 3) + c[sira]);
}
if (hangi == 2) {
mx = max(mx, f(sira + 1, 1) + a[sira]);
mx = max(mx, f(sira + 1, 3) + c[sira]);
}
if (hangi == 3) {
mx = max(mx, f(sira + 1, 2) + b[sira]);
mx = max(mx, f(sira + 1, 1) + a[sira]);
}
return dp[sira][hangi] = mx;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%lld", &n);
FOR { scanf("%lld %lld %lld", &a[i], &b[i], &c[i]); }
//~ FOR{
//~ scanf("%d",&b[i]);
//~ }
//~ FOR{
//~ scanf("%d",&c[i]);
//~ }
//~ sort(a+1,a+n+1);
//~ sort(b+1,b+n+1);
//~ sort(c+1,c+n+1);
printf("%lld", f(1, 0));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
typedef long long int lo;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fio() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define FOR for (int i = 1; i <= n; i++)
#define mid (bas + son) / 2
const lo MAX = -1000000000000000000;
const lo MIN = 1000000000000000000;
const lo inf = 1000000000;
const lo KOK = 100000;
const lo LOG = 30;
const lo li = 100005;
const lo mod = 1000000007;
lo n, m, cev, b[li], a[li], c[li], dp[li][5];
string s;
vector<int> v;
lo f(lo sira, lo hangi) {
lo mx = MAX;
if (sira > n)
return 0;
if (~dp[sira][hangi])
return dp[sira][hangi];
if (hangi == 0) {
mx = max(mx, f(sira + 1, 1) + a[sira]);
mx = max(mx, f(sira + 1, 2) + b[sira]);
mx = max(mx, f(sira + 1, 3) + c[sira]);
}
if (hangi == 1) {
mx = max(mx, f(sira + 1, 2) + b[sira]);
mx = max(mx, f(sira + 1, 3) + c[sira]);
}
if (hangi == 2) {
mx = max(mx, f(sira + 1, 1) + a[sira]);
mx = max(mx, f(sira + 1, 3) + c[sira]);
}
if (hangi == 3) {
mx = max(mx, f(sira + 1, 2) + b[sira]);
mx = max(mx, f(sira + 1, 1) + a[sira]);
}
return dp[sira][hangi] = mx;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%lld", &n);
FOR { scanf("%lld %lld %lld", &a[i], &b[i], &c[i]); }
//~ FOR{
//~ scanf("%d",&b[i]);
//~ }
//~ FOR{
//~ scanf("%d",&c[i]);
//~ }
//~ sort(a+1,a+n+1);
//~ sort(b+1,b+n+1);
//~ sort(c+1,c+n+1);
printf("%lld", f(1, 0));
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 964,700 | 964,701 | u050607149 | cpp |
p03162 | #include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define max(a, b) ((a > b) ? (a) : (b))
#define min(a, b) ((a < b) ? (a) : (b))
#define abs(x) (((x) < 0) ? (-(x)) : (x))
using namespace std;
int main() {
int N;
long *a, *b, *c;
cin >> N;
a = new long[N];
b = new long[N];
c = new long[N];
for (int i = 0; i < N; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int i = 1; i < N; i++) {
a[i] += min(b[i - 1], c[i - 1]);
b[i] += min(c[i - 1], a[i - 1]);
c[i] += min(a[i - 1], b[i - 1]);
}
cout << min(a[N - 1], min(b[N - 1], c[N - 1]));
delete[] a;
delete[] b;
delete[] c;
return 0;
}
| #include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define max(a, b) ((a > b) ? (a) : (b))
#define min(a, b) ((a < b) ? (a) : (b))
#define abs(x) (((x) < 0) ? (-(x)) : (x))
using namespace std;
int main() {
int N;
long *a, *b, *c;
cin >> N;
a = new long[N];
b = new long[N];
c = new long[N];
for (int i = 0; i < N; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int i = 1; i < N; i++) {
a[i] += max(b[i - 1], c[i - 1]);
b[i] += max(c[i - 1], a[i - 1]);
c[i] += max(a[i - 1], b[i - 1]);
}
cout << max(a[N - 1], max(b[N - 1], c[N - 1]));
delete[] a;
delete[] b;
delete[] c;
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"io.output.change"
] | 964,708 | 964,709 | u793275002 | cpp |
p03163 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
typedef vector<vector<P>> vvP;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 100010;
int main() {
ll n, W;
cin >> n >> W;
vl weight(n), value(n);
rep(i, n) { cin >> weight[i] >> value[i]; }
vvl dp(n + 1,
vl(W + 1)); // dp[i+1][j] :
// i番目までの品物で重さj以下のときの価値の総和の最大値
rep(i, n) {
rep(j, W + 1) {
chmin(dp[i + 1][j], dp[i][j]);
if (j >= weight[i]) {
chmin(dp[i + 1][j], dp[i][j - weight[i]] + value[i]);
}
}
}
out(dp[n][W]);
re0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
typedef vector<vector<P>> vvP;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 100010;
int main() {
ll n, W;
cin >> n >> W;
vl weight(n), value(n);
rep(i, n) { cin >> weight[i] >> value[i]; }
vvl dp(n + 1,
vl(W + 1)); // dp[i+1][j] :
// i番目までの品物で重さj以下のときの価値の総和の最大値
rep(i, n) {
rep(j, W + 1) {
chmax(dp[i + 1][j], dp[i][j]);
if (j >= weight[i]) {
chmax(dp[i + 1][j], dp[i][j - weight[i]] + value[i]);
}
}
}
out(dp[n][W]);
re0;
} | [
"identifier.change",
"call.function.change"
] | 964,719 | 964,720 | u828388155 | cpp |
p03163 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int n, W;
cin >> n >> W;
int w[n], v[n];
rep(i, n) { cin >> w[i] >> v[i]; }
int dp[n + 1][W + 1];
rep(i, n + 1) {
rep(j, W + 1) { dp[i][j] = 0; }
}
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 <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int n, W;
cin >> n >> W;
ll w[n], v[n];
rep(i, n) { cin >> w[i] >> v[i]; }
ll dp[n + 1][W + 1];
rep(i, n + 1) {
rep(j, W + 1) { dp[i][j] = 0; }
}
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;
} | [
"variable_declaration.type.change"
] | 964,721 | 964,722 | u828388155 | cpp |
p03163 | #include <bits/stdc++.h>
//#define int long long
#define FAST_IO ios_base::sync_with_stdio(false), cin.tie(nullptr)
using namespace std;
signed main() {
FAST_IO;
int N, W;
cin >> N >> W;
int t = N;
vector<int> wt;
vector<int> val;
while (t--) {
int a, b;
cin >> a >> b;
wt.push_back(a);
val.push_back(b);
}
vector<vector<int>> dp(N + 1, vector<int>(W + 1, 0));
// int t[N + 1][W + 1];
for (int i = 1; i < N + 1; i++) {
for (int j = 1; j < W + 1; j++) {
if (wt[i - 1] <= j) {
dp[i][j] = max(dp[i - 1][j], val[i - 1] + dp[i - 1][j - wt[i - 1]]);
}
else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout << dp[N][W];
return 0;
} | #include <bits/stdc++.h>
//#define int long long
#define FAST_IO ios_base::sync_with_stdio(false), cin.tie(nullptr)
using namespace std;
signed main() {
FAST_IO;
int N, W;
cin >> N >> W;
int t = N;
vector<int> wt;
vector<int> val;
while (t--) {
int a, b;
cin >> a >> b;
wt.push_back(a);
val.push_back(b);
}
vector<vector<long int>> dp(N + 1, vector<long int>(W + 1, 0));
// int t[N + 1][W + 1];
for (int i = 1; i < N + 1; i++) {
for (int j = 1; j < W + 1; j++) {
if (wt[i - 1] <= j) {
dp[i][j] = max(dp[i - 1][j], val[i - 1] + dp[i - 1][j - wt[i - 1]]);
}
else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout << dp[N][W];
return 0;
} | [
"variable_declaration.type.widen.change"
] | 964,723 | 964,724 | u437254737 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int knapsack(vector<int> w, vector<int> v, int W) {
int n = w.size();
vector<vector<int>> vec(n + 1, vector<int>(W + 1));
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= W; j++) {
if (i == 0 || j == 0)
vec[i][j] = 0;
else if (j < w[i - 1])
vec[i][j] = vec[i - 1][j];
else {
vec[i][j] = max(v[i - 1] + vec[i - 1][j - w[i - 1]], vec[i - 1][j]);
}
}
}
return vec[n][W];
}
int main() {
int n, W;
cin >> n >> W;
vector<int> w(n), v(n);
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
cout << knapsack(w, v, W);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long knapsack(vector<int> w, vector<int> v, int W) {
int n = w.size();
vector<vector<long long>> vec(n + 1, vector<long long>(W + 1));
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= W; j++) {
if (i == 0 || j == 0)
vec[i][j] = 0;
else if (j < w[i - 1])
vec[i][j] = vec[i - 1][j];
else {
vec[i][j] = max(v[i - 1] + vec[i - 1][j - w[i - 1]], vec[i - 1][j]);
}
}
}
return vec[n][W];
}
int main() {
int n, W;
cin >> n >> W;
vector<int> w(n), v(n);
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
cout << knapsack(w, v, W);
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 964,725 | 964,726 | u635291249 | cpp |
p03163 | // A Dynamic Programming based
// solution for 0-1 Knapsack problem
#include <iostream>
using namespace std;
// A utility function that returns
// maximum of two integers
int max(int a, int b) { return (a > b) ? a : b; }
// Returns the maximum value that
// can be put in a knapsack of capacity W
int knapSack(int W, int wt[], int val[], int n) {
int i, w;
int K[n + 1][W + 1];
// Build table K[][] in bottom up manner
for (i = 0; i <= n; i++) {
for (w = 0; w <= W; w++) {
if (i == 0 || w == 0)
K[i][w] = 0;
else if (wt[i - 1] <= w)
K[i][w] = max(val[i - 1] + K[i - 1][w - wt[i - 1]], K[i - 1][w]);
else
K[i][w] = K[i - 1][w];
}
}
return K[n][W];
}
int main() {
int W, N;
cin >> N >> W;
int val[N];
int wt[N];
for (int i = 0; i < N; i++) {
int w, v;
cin >> w >> v;
val[i] = v;
wt[i] = w;
}
cout << knapSack(W, wt, val, N);
return 0;
} | // A Dynamic Programming based
// solution for 0-1 Knapsack problem
#include <iostream>
using namespace std;
// A utility function that returns
// maximum of two integers
int max(int a, int b) { return (a > b) ? a : b; }
// Returns the maximum value that
// can be put in a knapsack of capacity W
long long knapSack(int W, int wt[], int val[], int n) {
int i, w;
long long K[n + 1][W + 1];
// Build table K[][] in bottom up manner
for (i = 0; i <= n; i++) {
for (w = 0; w <= W; w++) {
if (i == 0 || w == 0)
K[i][w] = 0;
else if (wt[i - 1] <= w)
K[i][w] = max(val[i - 1] + K[i - 1][w - wt[i - 1]], K[i - 1][w]);
else
K[i][w] = K[i - 1][w];
}
}
return K[n][W];
}
int main() {
int W, N;
cin >> N >> W;
int val[N];
int wt[N];
for (int i = 0; i < N; i++) {
int w, v;
cin >> w >> v;
val[i] = v;
wt[i] = w;
}
cout << knapSack(W, wt, val, N);
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 964,728 | 964,729 | u772913903 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, W;
cin >> n >> W;
int v[n], w[n], dp[n + 1][W + 1];
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 (i == 0 || j == 0)
dp[i][j] = 0;
else if (j >= w[i - 1])
dp[i][j] = max(v[i - 1] + dp[i - 1][j - w[i - 1]], dp[i - 1][j]);
else
dp[i][j] = dp[i - 1][j];
}
cout << dp[n][W] << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, W;
cin >> n >> W;
long long v[n], w[n], dp[n + 1][W + 1];
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
for (int i = 0; i <= n; i++)
for (int j = 0; j <= W; j++) {
if (i == 0 || j == 0)
dp[i][j] = 0;
else if (j >= w[i - 1])
dp[i][j] = max(v[i - 1] + dp[i - 1][j - w[i - 1]], dp[i - 1][j]);
else
dp[i][j] = dp[i - 1][j];
}
cout << dp[n][W] << "\n";
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"identifier.change",
"expression.operation.binary.change"
] | 964,732 | 964,733 | u972747689 | cpp |
p03163 | #include <bits/stdc++.h>
#define int long long
#define quickie \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rep1(i, a, b) for (int i = a; i <= b; i++)
#define repp(i, a, b) for (int i = b - 1; i >= a; i--)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define db double
#define mi map<int, int>
#define mc map<char, int>
#define ms map<string, int>
#define vi vector<int>
#define qi queue<int>
#define MI(x) power(x, mod - 2)
#define test \
int t; \
cin >> t;
#define mod 1000000007LL
//#define mod 998244353
using namespace std;
int power(int x, int y);
int gcd(int a, int b);
signed main() {
quickie int n, k;
cin >> n >> k;
int v[n], w[n], dp[k] = {0};
rep(i, 0, n) cin >> v[i] >> w[i];
for (int i = 0; i < n; i++) {
for (int j = k; j - w[i] >= 0; j--) {
dp[j] = max(v[i] + dp[j - w[i]], dp[j]);
}
}
cout << *max_element(dp, dp + k) << endl;
}
int power(int x, int y) {
int res = 1;
x %= mod;
while (y > 0) {
if (y & 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res % mod;
}
int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
} | #include <bits/stdc++.h>
#define int long long
#define quickie \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rep1(i, a, b) for (int i = a; i <= b; i++)
#define repp(i, a, b) for (int i = b - 1; i >= a; i--)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define db double
#define mi map<int, int>
#define mc map<char, int>
#define ms map<string, int>
#define vi vector<int>
#define qi queue<int>
#define MI(x) power(x, mod - 2)
#define test \
int t; \
cin >> t;
#define mod 1000000007LL
//#define mod 998244353
using namespace std;
int power(int x, int y);
int gcd(int a, int b);
signed main() {
quickie int n, k;
cin >> n >> k;
int v[n], w[n], dp[k + 1] = {0};
rep(i, 0, n) cin >> w[i] >> v[i];
for (int i = 0; i < n; i++) {
for (int j = k; j - w[i] >= 0; j--) {
dp[j] = max(v[i] + dp[j - w[i]], dp[j]);
}
}
cout << *max_element(dp, dp + k + 1) << endl;
}
int power(int x, int y) {
int res = 1;
x %= mod;
while (y > 0) {
if (y & 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res % mod;
}
int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
} | [
"identifier.change",
"expression.operation.binary.change"
] | 964,734 | 964,735 | u185295955 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define count_bits __builtin_popcount
const int N = 1e5 + 7;
int dp[100001][101];
int main() {
fast;
int n, w;
cin >> n >> w;
int val[n + 1], wt[n + 1];
for (int i = 1; i <= n; i++) {
cin >> wt[i] >> val[i];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= w; j++) {
if (wt[i] > j)
dp[i][j] = dp[i - 1][j];
else {
dp[i][j] = max(val[i] + dp[i - 1][j - wt[i]], dp[i - 1][j]);
}
}
cout << dp[n][w];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define count_bits __builtin_popcount
const int N = 1e5 + 7;
ll dp[101][N];
int main() {
fast;
ll n, w;
cin >> n >> w;
ll val[n + 1], wt[n + 1];
for (int i = 1; i <= n; i++) {
cin >> wt[i] >> val[i];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= w; j++) {
if (wt[i] > j)
dp[i][j] = dp[i - 1][j];
else {
dp[i][j] = max(val[i] + dp[i - 1][j - wt[i]], dp[i - 1][j]);
}
}
cout << dp[n][w];
} | [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.replace.add",
"literal.replace.remove"
] | 964,738 | 964,737 | u443962092 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define count_bits __builtin_popcount
const int N = 1e5 + 7;
int dp[100001][101];
int main() {
fast;
int n, w;
cin >> n >> w;
int val[n + 1], wt[n + 1];
for (int i = 1; i <= n; i++) {
cin >> wt[i] >> val[i];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= w; j++) {
if (wt[i] > w)
dp[i][j] = dp[i - 1][j];
else {
dp[i][j] = max(val[i] + dp[i - 1][j - wt[i]], dp[i - 1][j]);
}
}
cout << dp[n][w];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define count_bits __builtin_popcount
const int N = 1e5 + 7;
ll dp[101][N];
int main() {
fast;
ll n, w;
cin >> n >> w;
ll val[n + 1], wt[n + 1];
for (int i = 1; i <= n; i++) {
cin >> wt[i] >> val[i];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= w; j++) {
if (wt[i] > j)
dp[i][j] = dp[i - 1][j];
else {
dp[i][j] = max(val[i] + dp[i - 1][j - wt[i]], dp[i - 1][j]);
}
}
cout << dp[n][w];
} | [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.replace.add",
"literal.replace.remove",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 964,739 | 964,737 | u443962092 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define count_bits __builtin_popcount
const int N = 1e5 + 7;
ll dp[100001][101];
int main() {
fast;
int n, w;
cin >> n >> w;
ll val[n + 1], wt[n + 1];
for (int i = 1; i <= n; i++) {
cin >> wt[i] >> val[i];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= w; j++) {
if (wt[i] > w)
dp[i][j] = dp[i - 1][j];
else {
dp[i][j] = max(val[i] + dp[i - 1][j - wt[i]], dp[i - 1][j]);
}
}
cout << dp[n][w];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define count_bits __builtin_popcount
const int N = 1e5 + 7;
ll dp[101][N];
int main() {
fast;
ll n, w;
cin >> n >> w;
ll val[n + 1], wt[n + 1];
for (int i = 1; i <= n; i++) {
cin >> wt[i] >> val[i];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= w; j++) {
if (wt[i] > j)
dp[i][j] = dp[i - 1][j];
else {
dp[i][j] = max(val[i] + dp[i - 1][j - wt[i]], dp[i - 1][j]);
}
}
cout << dp[n][w];
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_declaration.type.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 964,740 | 964,737 | u443962092 | cpp |
p03163 | #pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
int cost[101], cap[101], n;
long long dp[101][100005];
int knap(int i, int c) {
if (dp[i][c] != -1)
return dp[i][c];
long long res;
if (i == 0 || c == 0)
res = 0;
else if (cap[i] > c)
res = knap(i - 1, c);
else {
long long t1, t2;
t1 = knap(i - 1, c);
t2 = cost[i] + knap(i - 1, c - cap[i]);
res = max(t1, t2);
}
dp[i][c] = res;
return res;
}
int main() {
memset(dp, -1, sizeof(dp));
int c;
cin >> n >> c;
// cout << n << c << endl;
for (int i = 1; i <= n; i++) {
cin >> cap[i] >> cost[i];
}
cout << knap(n, c) << endl;
} | #pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
long long cost[101], cap[101], n;
long long dp[101][100005];
long long knap(int i, int c) {
if (dp[i][c] != -1)
return dp[i][c];
long long res;
if (i == 0 || c == 0)
res = 0;
else if (cap[i] > c)
res = knap(i - 1, c);
else {
long long t1, t2;
t1 = knap(i - 1, c);
t2 = cost[i] + knap(i - 1, c - cap[i]);
// if(t2<0) cout << cost[i] << " " << knap(i-1,c-cap[i]) << " " <<
// cost[i]+knap(i-1,c-cap[i]) << endl;
// cout << t1 << " " << t2 << endl;
res = max(t1, t2);
}
// cout << i << " " << c << " " << res << endl;
dp[i][c] = res;
return res;
}
int main() {
memset(dp, -1, sizeof(dp));
long long c;
cin >> n >> c;
// cout << n << c << endl;
for (int i = 1; i <= n; i++) {
cin >> cap[i] >> cost[i];
// cout << cap[i] << " " << cost[i] << endl;
}
cout << knap(n, c) << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 964,741 | 964,742 | u510741562 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int W;
cin >> W;
int w[n];
int v[n];
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
int dp[n + 1][W + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= W; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else if (w[i - 1] <= j) {
dp[i][j] = max(v[i - 1] + dp[i - 1][j - w[i - 1]], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout << dp[n][W];
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n;
cin >> n;
int W;
cin >> W;
int w[n];
int v[n];
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
ll dp[n + 1][W + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= W; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else if (w[i - 1] <= j) {
dp[i][j] = max(v[i - 1] + dp[i - 1][j - w[i - 1]], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout << dp[n][W];
} | [
"variable_declaration.type.change"
] | 964,743 | 964,744 | u345267444 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 1; i <= (n); i++)
using ll = long long;
typedef pair<int, int> P;
const int INF = 1e9;
const int MOD = 1000000007;
int main() {
ll N, W;
cin >> N >> W;
vector<ll> w(N + 1), v(N + 1);
rep(i, N) cin >> w[i] >> v[i];
vector<vector<ll>> dat(N + 1, vector<ll>(W + 1));
rep(i, N) {
rep(j, W + 1) {
if (w[i] <= j) {
dat[i][j] = max(dat[i - 1][j], dat[i - 1][j - w[i]] + v[i]);
} else
dat[i][j] = dat[i - 1][j];
}
}
cout << dat[N][W];
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 1; i <= (n); i++)
using ll = long long;
typedef pair<int, int> P;
const int INF = 1e9;
const int MOD = 1000000007;
int main() {
ll N, W;
cin >> N >> W;
vector<ll> w(N + 1), v(N + 1);
rep(i, N) cin >> w[i] >> v[i];
vector<vector<ll>> dat(N + 1, vector<ll>(W + 1));
rep(i, N) {
rep(j, W) {
if (w[i] <= j) {
dat[i][j] = max(dat[i - 1][j], dat[i - 1][j - w[i]] + v[i]);
} else
dat[i][j] = dat[i - 1][j];
}
}
cout << dat[N][W];
} | [
"expression.operation.binary.remove"
] | 964,745 | 964,746 | u713574885 | cpp |
p03163 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define ll long long int
#define skip cin >> ws;
#define vll vector<ll>
#define vb vector<bool>
#define vpll vector<pair<ll, ll>>
#define vvll vector<vector<ll>>
#define pll pair<ll, ll>
#define vs vector<string>
#define vvpll vector<vector<pair<ll, ll>>>
#define pb push_back
#define pob pop_back()
#define MOD (ll)(1e9 + 7)
#define test \
ll t; \
cin >> t; \
while (t--)
using namespace std;
void enter(vll &ar) {
ll n = ar.size();
for (ll i = 0; i < n; i++) {
cin >> ar[i];
}
}
void show(vll &a) {
ll n = a.size();
for (ll i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
void SieveOfErat1sthenes(int n, vll &pri) {
vb prime(n + 1, true);
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
pri.pb(p);
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
}
ll mo(ll a) { return a % MOD; }
bool compare(pll a, pll b) { return a.first > b.first; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, W;
cin >> n >> W;
vll w(n), v(n);
for (ll i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
vvll mat(W + 1, vll(n + 1));
for (ll i = 1; i <= W; i++) {
for (ll j = 1; j <= n; j++) {
if (w[j - 1] > i)
mat[i][j] = mat[i][j - 1];
else {
mat[i][j] = max(mat[i][j - 1], v[j - 1] + mat[i - v[j - 1]][j - 1]);
}
}
}
cout << mat[W][n] << "\n";
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define ll long long int
#define skip cin >> ws;
#define vll vector<ll>
#define vb vector<bool>
#define vpll vector<pair<ll, ll>>
#define vvll vector<vector<ll>>
#define pll pair<ll, ll>
#define vs vector<string>
#define vvpll vector<vector<pair<ll, ll>>>
#define pb push_back
#define pob pop_back()
#define MOD (ll)(1e9 + 7)
#define test \
ll t; \
cin >> t; \
while (t--)
using namespace std;
void enter(vll &ar) {
ll n = ar.size();
for (ll i = 0; i < n; i++) {
cin >> ar[i];
}
}
void show(vll &a) {
ll n = a.size();
for (ll i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
void SieveOfErat1sthenes(int n, vll &pri) {
vb prime(n + 1, true);
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
pri.pb(p);
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
}
ll mo(ll a) { return a % MOD; }
bool compare(pll a, pll b) { return a.first > b.first; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, W;
cin >> n >> W;
vll w(n), v(n);
for (ll i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
vvll mat(W + 1, vll(n + 1));
for (ll i = 1; i <= W; i++) {
for (ll j = 1; j <= n; j++) {
if (w[j - 1] > i)
mat[i][j] = mat[i][j - 1];
else {
mat[i][j] = max(mat[i][j - 1], v[j - 1] + mat[i - w[j - 1]][j - 1]);
}
}
}
cout << mat[W][n] << "\n";
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 964,747 | 964,748 | u345866226 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define itn int
int main(void) {
int n, x;
cin >> n >> x;
int w[n], v[n];
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
int dp[n + 1][x + 1];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
for (int j = 0; j <= x; j++) {
if (j >= w[i]) {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
} else
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
}
}
cout << dp[n][x] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define itn int
int main(void) {
int n, x;
cin >> n >> x;
int w[n], v[n];
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
ll dp[n + 1][x + 1];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
for (int j = 0; j <= x; j++) {
if (j >= w[i]) {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
} else
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
}
}
cout << dp[n][x] << endl;
} | [
"variable_declaration.type.change"
] | 964,753 | 964,754 | u512624048 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define inf INT_MAX
int solve() {
int N, W;
cin >> N >> W;
int w[N], v[N];
int i;
for (i = 0; i < N; i++)
cin >> w[i] >> v[i];
int dp[N + 1][W + 1];
for (i = 0; i <= N; i++)
dp[i][0] = 0;
for (i = 0; i <= W; i++)
dp[0][i] = 0;
int j;
for (i = 1; i <= N; i++) {
for (j = 1; j <= W; j++) {
if (j >= w[i - 1])
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
else
dp[i][j] = dp[i - 1][j];
}
}
return dp[N][W];
}
int32_t main() {
std::ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cout << solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define inf INT_MAX
#define int long long
int solve() {
int N, W;
cin >> N >> W;
int w[N], v[N];
int i;
for (i = 0; i < N; i++)
cin >> w[i] >> v[i];
int dp[N + 1][W + 1];
for (i = 0; i <= N; i++)
dp[i][0] = 0;
for (i = 0; i <= W; i++)
dp[0][i] = 0;
int j;
for (i = 1; i <= N; i++) {
for (j = 1; j <= W; j++) {
if (j >= w[i - 1])
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
else
dp[i][j] = dp[i - 1][j];
}
}
return dp[N][W];
}
int32_t main() {
std::ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cout << solve();
return 0;
} | [] | 964,757 | 964,758 | u628586011 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[110][100100] = {0};
int weight[110], value[110];
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= w; j++) {
if (j - weight[i] >= 0) {
chmax(dp[i + 1][j], dp[i][j - weight[i]] + value[i]);
} else {
chmax(dp[i + 1][j], dp[i][j]);
}
}
}
cout << dp[n][w] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[110][100100] = {0};
int weight[110], value[110];
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= w; j++) {
if (j - weight[i] >= 0) {
chmax(dp[i + 1][j], dp[i][j - weight[i]] + value[i]);
}
chmax(dp[i + 1][j], dp[i][j]);
}
}
cout << dp[n][w] << endl;
}
| [] | 964,762 | 964,763 | u962609087 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[110][100100] = {0};
int weight[110], value[110];
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n, w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= w; j++) {
if (j - weight[i] >= 0) {
chmax(dp[i + 1][j], dp[i][j - weight[i]] + value[i]);
} else {
chmax(dp[i + 1][j], dp[i][j]);
}
}
}
cout << dp[n][w] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[110][100100] = {0};
int weight[110], value[110];
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= w; j++) {
if (j - weight[i] >= 0) {
chmax(dp[i + 1][j], dp[i][j - weight[i]] + value[i]);
}
chmax(dp[i + 1][j], dp[i][j]);
}
}
cout << dp[n][w] << endl;
}
| [] | 964,764 | 964,763 | u962609087 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int weight[110], value[110];
int dp[110][100100] = {0};
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 0; i < n; i++) {
for (int sum_w = 0; sum_w <= w; sum_w++) {
if (sum_w - weight[i] >= 0) {
chmax(dp[i + 1][sum_w], dp[i][sum_w - weight[i]] + value[i]);
}
chmax(dp[i + 1][sum_w], dp[i][sum_w]);
}
}
cout << dp[n][w] << "/n";
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
int weight[110], value[110];
int dp[110][100100] = {0};
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 0; i < n; i++) {
for (int sum_w = 0; sum_w <= w; sum_w++) {
if (sum_w - weight[i] >= 0) {
chmax(dp[i + 1][sum_w], dp[i][sum_w - weight[i]] + value[i]);
}
chmax(dp[i + 1][sum_w], dp[i][sum_w]);
}
}
cout << dp[n][w] << endl;
} | [
"io.output.change"
] | 964,765 | 964,766 | u962609087 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int weight[110], value[110];
int dp[110][100100] = {0};
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 1; i < n; i++) {
for (int sum_w = 0; sum_w <= w; sum_w++) {
if (sum_w - weight[i] >= 0) {
chmax(dp[i + 1][sum_w], dp[i][sum_w - weight[i]] + value[i]);
}
chmax(dp[i + 1][sum_w], dp[i][sum_w]);
}
}
cout << dp[n][w] << "/n";
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
int weight[110], value[110];
int dp[110][100100] = {0};
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 0; i < n; i++) {
for (int sum_w = 0; sum_w <= w; sum_w++) {
if (sum_w - weight[i] >= 0) {
chmax(dp[i + 1][sum_w], dp[i][sum_w - weight[i]] + value[i]);
}
chmax(dp[i + 1][sum_w], dp[i][sum_w]);
}
}
cout << dp[n][w] << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"io.output.change"
] | 964,767 | 964,766 | u962609087 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int weight[110], value[110];
int dp[110][100010] = {0};
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 1; i < n; i++) {
for (int sum_w = 0; sum_w <= w; sum_w++) {
if (sum_w - weight[i] >= 0) {
chmax(dp[i + 1][sum_w], dp[i][sum_w - weight[i]] + value[i]);
}
chmax(dp[i + 1][sum_w], dp[i][sum_w]);
}
}
cout << dp[n][w] << "/n";
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
int weight[110], value[110];
int dp[110][100100] = {0};
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
signed main() {
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
}
for (int i = 0; i < n; i++) {
for (int sum_w = 0; sum_w <= w; sum_w++) {
if (sum_w - weight[i] >= 0) {
chmax(dp[i + 1][sum_w], dp[i][sum_w - weight[i]] + value[i]);
}
chmax(dp[i + 1][sum_w], dp[i][sum_w]);
}
}
cout << dp[n][w] << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"io.output.change"
] | 964,768 | 964,766 | u962609087 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FASTIO \
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(nullptr)
#define INF (1LL << 62) - 1
#define F first
#define S second
#define pb push_back
ll dp[102][100002];
ll dosomething(ll w, ll n, vector<ll> &wt, vector<ll> &val, ll i) {
if (i >= n || w <= 0)
return 0;
if (dp[i][w] != -1)
return dp[i][w];
if (wt[i] > w)
dp[i][w] = dosomething(w, n, wt, val, i + 1);
else
dp[i][w] = max(dosomething(w, n, wt, val, i + 1),
val[i] + dosomething(w - wt[i], n, wt, val, i + 1));
return dp[i][w];
}
int main() {
FASTIO;
for (ll i = 0; i < 1002; i++)
for (ll j = 0; j < 1002; j++)
dp[i][j] = -1;
ll n, w;
cin >> n >> w;
vector<ll> wt(n), val(n);
for (ll i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << dosomething(w, n, wt, val, 0) << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FASTIO \
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(nullptr)
#define INF (1LL << 62) - 1
#define F first
#define S second
#define pb push_back
ll dp[102][100002];
ll dosomething(ll w, ll n, vector<ll> &wt, vector<ll> &val, ll i) {
if (i >= n || w <= 0)
return 0;
if (dp[i][w] != -1)
return dp[i][w];
if (wt[i] > w)
dp[i][w] = dosomething(w, n, wt, val, i + 1);
else
dp[i][w] = max(dosomething(w, n, wt, val, i + 1),
val[i] + dosomething(w - wt[i], n, wt, val, i + 1));
return dp[i][w];
}
int main() {
FASTIO;
for (ll i = 0; i < 102; i++)
for (ll j = 0; j < 100002; j++)
dp[i][j] = -1;
ll n, w;
cin >> n >> w;
vector<ll> wt(n), val(n);
for (ll i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << dosomething(w, n, wt, val, 0) << "\n";
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 964,771 | 964,772 | u717852897 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int N, W;
cin >> N >> W;
int w[N], v[N];
for (int i = 0; i < N; i++)
cin >> w[i] >> v[i];
int dp[W + 1];
for (int i = 0; i < W + 1; i++)
dp[i] = -1;
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = W; j >= 0; j--) {
if (dp[j] == -1)
continue;
if (j + w[i] <= W) {
dp[j + w[i]] = max(dp[j + w[i]], dp[j] + v[i]);
}
}
}
int ans = 0;
for (int i = 0; i <= W; i++)
ans = max(ans, dp[i]);
cout << ans << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int N, W;
cin >> N >> W;
int w[N], v[N];
for (int i = 0; i < N; i++)
cin >> w[i] >> v[i];
ll dp[W + 1];
for (int i = 0; i < W + 1; i++)
dp[i] = -1;
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = W; j >= 0; j--) {
if (dp[j] == -1)
continue;
if (j + w[i] <= W) {
dp[j + w[i]] = max(dp[j + w[i]], dp[j] + v[i]);
}
}
}
ll ans = 0;
for (int i = 0; i <= W; i++)
ans = max(ans, dp[i]);
cout << ans << "\n";
return 0;
} | [
"variable_declaration.type.change"
] | 964,780 | 964,781 | u872581897 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, cap;
cin >> n >> cap;
vector<int> weights;
vector<int> values;
for (int i = 0; i < n; i++) {
int w, v;
cin >> w >> v;
weights.push_back(w);
values.push_back(v);
}
int dp[n + 1][cap + 1];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < cap + 1; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else if (weights[i - 1] <= j) {
dp[i][j] =
max(dp[i - 1][j], values[i - 1] + dp[i - 1][j - weights[i - 1]]);
} else
dp[i][j] = dp[i - 1][j];
}
}
cout << dp[n][cap];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, cap;
cin >> n >> cap;
vector<int> weights;
vector<long long int> values;
for (int i = 0; i < n; i++) {
int w, v;
cin >> w >> v;
weights.push_back(w);
values.push_back(v);
}
long long int dp[n + 1][cap + 1];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < cap + 1; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else if (weights[i - 1] <= j) {
dp[i][j] =
max(dp[i - 1][j], values[i - 1] + dp[i - 1][j - weights[i - 1]]);
} else {
dp[i][j] = dp[i - 1][j];
}
// cout<<dp[i][j]<<" ";
}
// cout<<endl;
}
cout << dp[n][cap];
} | [
"variable_declaration.type.widen.change"
] | 964,788 | 964,789 | u696991379 | cpp |
p03163 | #include <algorithm>
#include <iostream>
using namespace std;
int dp[101][100001];
long long int solve(int **a, int i, long long int w, int n) {
if (w == 0) {
return (0);
}
if (i == n) {
return (0);
}
if (dp[i][w] != -1) {
return (dp[i][w]);
}
long long int op1 = -1, op2 = -1;
op1 = solve(a, i + 1, w, n);
if (w - a[i][0] >= 0)
op2 = solve(a, i + 1, w - a[i][0], n) + a[i][1];
return (dp[i][w] = max(op1, op2));
}
int main() {
long long int n, w, i, j;
cin >> n >> w;
int **a = new int *[n];
for (i = 0; i < n; ++i) {
a[i] = new int[2];
}
for (i = 0; i < n; ++i) {
cin >> a[i][0] >> a[i][1];
}
for (i = 0; i < 100; i++) {
for (j = 0; j <= 100000; j++) {
dp[i][j] = -1;
}
}
cout << solve(a, 0, w, n);
} | #include <algorithm>
#include <iostream>
using namespace std;
long long int dp[101][100001];
long long int solve(int **a, int i, long long int w, int n) {
if (w == 0) {
return (0);
}
if (i == n) {
return (0);
}
if (dp[i][w] != -1) {
return (dp[i][w]);
}
long long int op1 = -1, op2 = -1;
op1 = solve(a, i + 1, w, n);
if (w - a[i][0] >= 0)
op2 = solve(a, i + 1, w - a[i][0], n) + a[i][1];
return (dp[i][w] = max(op1, op2));
}
int main() {
long long int n, w, i, j;
cin >> n >> w;
int **a = new int *[n];
for (i = 0; i < n; ++i) {
a[i] = new int[2];
}
for (i = 0; i < n; ++i) {
cin >> a[i][0] >> a[i][1];
}
for (i = 0; i < 100; i++) {
for (j = 0; j <= 100000; j++) {
dp[i][j] = -1;
}
}
cout << solve(a, 0, w, n);
} | [
"variable_declaration.type.widen.change"
] | 964,790 | 964,791 | u643355770 | cpp |
p03163 | /*
Created on Fri Aug 25 16:34:06 2020
@author: roastedcoder
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long int ull;
const int mod = 1e9 + 7;
#define endl "\n"
#define append push_back
#define roastedcoder \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
//__________________________________________________________________
int a[101];
int wt[101];
ll dp[101][100001];
int weird(int n, int w) {
if (n == 0 || w == 0)
return 0;
if (dp[n][w] != -1)
return dp[n][w];
if (wt[n - 1] <= w)
return dp[n][w] =
max(a[n - 1] + weird(n - 1, w - wt[n - 1]), weird(n - 1, w));
return dp[n][w] = weird(n - 1, w);
}
int main() {
roastedcoder memset(dp, -1, sizeof(dp));
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> wt[i] >> a[i];
}
cout << weird(n, w);
}
//__________________________________________________________________
/*
Sample Input:
500 1000 20 30
Sample Output:
Vasya
*/ | /*
Created on Fri Aug 25 16:34:06 2020
@author: roastedcoder
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long int ull;
const int mod = 1e9 + 7;
#define endl "\n"
#define append push_back
#define roastedcoder \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
//__________________________________________________________________
int a[101];
int wt[101];
ll dp[101][100001];
ll weird(int n, int w) {
if (n == 0 || w == 0)
return 0;
if (dp[n][w] != -1)
return dp[n][w];
if (wt[n - 1] <= w)
return dp[n][w] =
max(a[n - 1] + weird(n - 1, w - wt[n - 1]), weird(n - 1, w));
return dp[n][w] = weird(n - 1, w);
}
int main() {
roastedcoder memset(dp, -1, sizeof(dp));
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> wt[i] >> a[i];
}
cout << weird(n, w);
}
//__________________________________________________________________
/*
Sample Input:
500 1000 20 30
Sample Output:
Vasya
*/ | [] | 964,792 | 964,793 | u078505805 | cpp |
p03163 | /*
Created on Fri Aug 25 16:34:06 2020
@author: roastedcoder
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long int ull;
const int mod = 1e9 + 7;
#define endl "\n"
#define append push_back
#define roastedcoder \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
//__________________________________________________________________
int a[101];
int wt[101];
int dp[101][100001];
int weird(int n, int w) {
if (n == 0 || w == 0)
return 0;
if (dp[n][w] != -1)
return dp[n][w];
if (wt[n - 1] <= w)
return dp[n][w] =
max(a[n - 1] + weird(n - 1, w - wt[n - 1]), weird(n - 1, w));
return dp[n][w] = weird(n - 1, w);
}
int main() {
roastedcoder memset(dp, -1, sizeof(dp));
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> wt[i] >> a[i];
}
cout << weird(n, w);
}
//__________________________________________________________________
/*
Sample Input:
500 1000 20 30
Sample Output:
Vasya
*/
| /*
Created on Fri Aug 25 16:34:06 2020
@author: roastedcoder
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long int ull;
const int mod = 1e9 + 7;
#define endl "\n"
#define append push_back
#define roastedcoder \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
//__________________________________________________________________
int a[101];
int wt[101];
ll dp[101][100001];
ll weird(int n, int w) {
if (n == 0 || w == 0)
return 0;
if (dp[n][w] != -1)
return dp[n][w];
if (wt[n - 1] <= w)
return dp[n][w] =
max(a[n - 1] + weird(n - 1, w - wt[n - 1]), weird(n - 1, w));
return dp[n][w] = weird(n - 1, w);
}
int main() {
roastedcoder memset(dp, -1, sizeof(dp));
int n, w;
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> wt[i] >> a[i];
}
cout << weird(n, w);
}
//__________________________________________________________________
/*
Sample Input:
500 1000 20 30
Sample Output:
Vasya
*/ | [
"variable_declaration.type.change"
] | 964,794 | 964,793 | u078505805 | cpp |
p03163 | #include <bits/stdc++.h>
#define int long long
using namespace std;
int wt[100005];
int val[100005];
int ans[10005][10005];
int N, w;
int ks(int n, int c) {
if (ans[n][c] != -1)
return ans[n][c];
if (n == 0 or c == 0)
return 0;
if (wt[n - 1] > c)
return ks(n - 1, c);
int a = ks(n - 1, c);
int b = val[n - 1] + ks(n - 1, c - wt[n - 1]);
ans[n][c] = max(a, b);
return ans[n][c];
}
void solve() {
cin >> N >> w;
for (int i = 0; i < N; ++i) {
cin >> wt[i] >> val[i];
}
for (int i = 0; i < N + 1; ++i)
for (int j = 0; j < w + 1; ++j)
ans[i][j] = -1;
cout << ks(N, w);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
// cin >> t;
while (t--) {
solve();
}
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
int wt[105];
int val[105];
int ans[105][100005];
int N, w;
int ks(int n, int c) {
if (ans[n][c] != -1)
return ans[n][c];
if (n == 0 or c == 0)
return 0;
if (wt[n - 1] > c)
return ks(n - 1, c);
int a = ks(n - 1, c);
int b = val[n - 1] + ks(n - 1, c - wt[n - 1]);
ans[n][c] = max(a, b);
return ans[n][c];
}
void solve() {
cin >> N >> w;
for (int i = 0; i < N; ++i) {
cin >> wt[i] >> val[i];
}
for (int i = 0; i < N + 1; ++i)
for (int j = 0; j < w + 1; ++j)
ans[i][j] = -1;
cout << ks(N, w);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
// cin >> t;
while (t--) {
solve();
}
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 964,800 | 964,796 | u578753285 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
// freopen("input1.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, w;
cin >> n >> w;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
vector<int> dp(w + 1, 0);
for (int i = 0; i < n; i++) {
for (int j = w; j >= a[i]; j--)
dp[j] = max(dp[j], dp[j - a[i]] + b[i]);
}
cout << dp[w];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
// freopen("input1.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, w;
cin >> n >> w;
vector<long long int> a(n), b(n);
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
vector<long long int> dp(w + 1, 0);
for (int i = 0; i < n; i++) {
for (int j = w; j >= a[i]; j--)
dp[j] = max(dp[j], dp[j - a[i]] + b[i]);
}
cout << dp[w];
return 0;
} | [
"variable_declaration.type.widen.change"
] | 964,803 | 964,804 | u339560028 | cpp |
p03163 |
#include <bits/stdc++.h>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int INF = 1e9 + 5;
void max_self(ll &a, ll b) { a = max(a, b); }
int main() {
ll N, W;
cin >> N >> W;
vector<ll> dp(W + 1);
// dp[i] the maximum total value with weight exactly
for (ll item = 0; item < N; item++) {
ll weight, value;
cin >> weight >> value;
for (int weight_already = 0; weight_already >= 0; weight_already--) {
max_self(dp[weight_already + weight], dp[weight_already] + value);
}
}
ll answer = 0;
for (ll i = 0; i <= W; i++) {
max_self(answer, dp[i]);
}
cout << answer;
return 0;
}
|
#include <bits/stdc++.h>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int INF = 1e9 + 5;
void max_self(ll &a, ll b) { a = max(a, b); }
int main() {
ll N, W;
cin >> N >> W;
vector<ll> dp(W + 1);
// dp[i] the maximum total value with weight exactly
for (ll item = 0; item < N; item++) {
ll weight, value;
cin >> weight >> value;
for (int weight_already = W - weight; weight_already >= 0;
weight_already--) {
max_self(dp[weight_already + weight], dp[weight_already] + value);
}
}
ll answer = 0;
for (ll i = 0; i <= W; i++) {
max_self(answer, dp[i]);
}
cout << answer;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 964,809 | 964,808 | u772397797 | cpp |
p03163 |
#include <bits/stdc++.h>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int INF = 1e9 + 5;
void max_self(ll &a, ll b) { a = max(a, b); }
int main() {
ll N, W;
cin >> N >> W;
vector<ll> dp(W + 1, 0);
// dp[i] the maximum total value with weight exactly
for (ll item = 0; item < N; item++) {
ll weight, value;
cin >> weight >> value;
for (int weight_already = 0; weight_already >= 0; weight_already--) {
max_self(dp[weight_already + weight], dp[weight_already] + value);
}
}
ll answer = 0;
for (ll i = 0; i <= W; i++) {
max_self(answer, dp[i]);
}
cout << answer;
return 0;
}
|
#include <bits/stdc++.h>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int INF = 1e9 + 5;
void max_self(ll &a, ll b) { a = max(a, b); }
int main() {
ll N, W;
cin >> N >> W;
vector<ll> dp(W + 1);
// dp[i] the maximum total value with weight exactly
for (ll item = 0; item < N; item++) {
ll weight, value;
cin >> weight >> value;
for (int weight_already = W - weight; weight_already >= 0;
weight_already--) {
max_self(dp[weight_already + weight], dp[weight_already] + value);
}
}
ll answer = 0;
for (ll i = 0; i <= W; i++) {
max_self(answer, dp[i]);
}
cout << answer;
return 0;
}
| [
"call.arguments.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 964,810 | 964,808 | u772397797 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ALL(x) (x).begin(), (x).end()
typedef long long ll;
typedef pair<int, int> pii;
const int INF = 1e9;
const int MOD = 1000000007;
const double PI = acos(-1);
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int dp[101][100001];
int main() {
int N, W;
cin >> N >> W;
vector<int> w(N), v(N);
memset(dp, 0, sizeof(dp));
rep(i, N) cin >> w[i] >> v[i];
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;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ALL(x) (x).begin(), (x).end()
typedef long long ll;
typedef pair<int, int> pii;
const int INF = 1e9;
const int MOD = 1000000007;
const double PI = acos(-1);
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
ll dp[101][100001];
int main() {
int N, W;
cin >> N >> W;
vector<int> w(N), v(N);
memset(dp, 0, sizeof(dp));
rep(i, N) cin >> w[i] >> v[i];
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;
} | [
"variable_declaration.type.change"
] | 964,811 | 964,812 | u280175105 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
const int nxx = 1e5 + 5;
vector<pair<long long, long long>> v(101);
int dp[101][nxx];
int n, k;
long long ans(int i, int k) {
if (i == n || k == 0) {
return 0;
}
if (v[i].first > k)
return ans(i + 1, k);
if (dp[i][k] != -1)
return dp[i][k];
else {
long long value =
max(ans(i + 1, k), ans(i + 1, k - v[i].first) + v[i].second);
return dp[i][k] = value;
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
memset(dp, -1, sizeof(dp));
cout << ans(0, k);
} | #include <bits/stdc++.h>
using namespace std;
const int nxx = 1e5 + 5;
vector<pair<long long, long long>> v(101);
long long dp[101][nxx];
int n, k;
long long ans(int i, int k) {
if (i == n || k == 0) {
return 0;
}
if (v[i].first > k)
return ans(i + 1, k);
if (dp[i][k] != -1)
return dp[i][k];
else {
long long value =
max(ans(i + 1, k), ans(i + 1, k - v[i].first) + v[i].second);
return dp[i][k] = value;
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
memset(dp, -1, sizeof(dp));
cout << ans(0, k);
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 964,819 | 964,820 | u690116847 | cpp |
p03163 | /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
int fun(vector<ll> &w, vector<ll> &v, ll n, ll W) {
ll dp[n + 1][W + 1];
for (ll i = 0; i < n + 1; i++) {
for (ll j = 0; j < W + 1; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
}
}
}
for (ll i = 1; i < n + 1; i++) {
for (ll j = 1; j < W + 1; j++) {
if (w[i - 1] <= j) {
dp[i][j] = max(v[i - 1] + dp[i - 1][j - w[i - 1]], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[n][W];
}
int main() {
ll n, W;
cin >> n >> W;
vector<ll> w;
vector<ll> v;
for (ll i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
w.push_back(a);
v.push_back(b);
}
cout << fun(w, v, n, W) << endl;
return 0;
}
| /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll fun(vector<ll> &w, vector<ll> &v, ll n, ll W) {
ll dp[n + 1][W + 1];
for (ll i = 0; i < n + 1; i++) {
for (ll j = 0; j < W + 1; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
}
}
}
for (ll i = 1; i < n + 1; i++) {
for (ll j = 1; j < W + 1; j++) {
if (w[i - 1] <= j) {
dp[i][j] = max(v[i - 1] + dp[i - 1][j - w[i - 1]], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[n][W];
}
int main() {
ll n, W;
cin >> n >> W;
vector<ll> w;
vector<ll> v;
for (ll i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
w.push_back(a);
v.push_back(b);
}
cout << fun(w, v, n, W) << endl;
return 0;
}
| [] | 964,821 | 964,822 | u280982574 | cpp |
p03163 | /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
int fun(vector<ll> &w, vector<ll> &v, ll n, ll W) {
ll dp[n + 1][W + 1];
for (ll i = 0; i < n + 1; i++) {
for (ll j = 0; j < W + 1; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
}
}
}
for (ll i = 1; i < n + 1; i++) {
for (ll j = 1; j < W + 1; j++) {
if (w[i - 1] <= j) {
dp[i][j] = max(v[i - 1] + dp[i - 1][j - w[i - 1]], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[n][W];
}
int main() {
ll n, W;
cin >> n >> W;
vector<ll> w;
vector<ll> v;
for (ll i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
w.push_back(a);
v.push_back(b);
}
cout << fun(w, v, n, W) << endl;
return 0;
}
| /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
#define ll unsigned long long int
using namespace std;
ll fun(vector<ll> &w, vector<ll> &v, ll n, ll W) {
ll dp[n + 1][W + 1];
for (ll i = 0; i < n + 1; i++) {
for (ll j = 0; j < W + 1; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
}
}
}
for (ll i = 1; i < n + 1; i++) {
for (ll j = 1; j < W + 1; j++) {
if (w[i - 1] <= j) {
dp[i][j] = max(v[i - 1] + dp[i - 1][j - w[i - 1]], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[n][W];
}
int main() {
ll n, W;
cin >> n >> W;
vector<ll> w;
vector<ll> v;
for (ll i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
w.push_back(a);
v.push_back(b);
}
cout << fun(w, v, n, W) << endl;
return 0;
}
| [] | 964,821 | 964,823 | u280982574 | cpp |
p03163 | // https://atcoder.jp/contests/dp/tasks/dp_d
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define endl "\n"
#define fastio ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define mod 1000000007
#define gcd __gcd
#define inf INT_MAX
#define INF LLONG_MAX
#define minf INT_MIN
#define MINF LLONG_MIN
#define pb push_back
#define all(v) v.begin(), v.end()
#define print(v) \
for (auto x : v) \
cout << x << " "; \
cout << "\n";
#define printn(v) \
for (auto x : v) \
cout << x << "\n";
#define F first
#define S second
#define mp make_pair
ll dp[101][101];
vector<int> wt, val;
ll knapsack(int n, int w) {
if (n == 0 || w == 0 || n == 1)
return 0;
if (dp[n][w] != -1)
return dp[n][w];
if (wt[n] > w)
return dp[n][w] = knapsack(n - 1, w);
else
return dp[n][w] =
max(val[n] + knapsack(n - 1, w - wt[n]), knapsack(n - 1, w));
}
int32_t main() {
fastio;
int n, w;
cin >> n >> w;
memset(dp, -1, sizeof dp);
wt.resize(n + 1, 0);
val.resize(n + 1, 0);
for (int i = 1; i <= n; i++)
cin >> wt[i] >> val[i];
cout << knapsack(n, w) << endl;
} | // https://atcoder.jp/contests/dp/tasks/dp_d
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define endl "\n"
#define fastio ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define mod 1000000007
#define gcd __gcd
#define inf INT_MAX
#define INF LLONG_MAX
#define minf INT_MIN
#define MINF LLONG_MIN
#define pb push_back
#define all(v) v.begin(), v.end()
#define print(v) \
for (auto x : v) \
cout << x << " "; \
cout << "\n";
#define printn(v) \
for (auto x : v) \
cout << x << "\n";
#define F first
#define S second
#define mp make_pair
ll dp[101][100001];
vector<int> wt, val;
ll knapsack(int n, int w) {
if (n == 0 || w == 0)
return 0;
if (dp[n][w] != -1)
return dp[n][w];
if (wt[n] > w)
return dp[n][w] = knapsack(n - 1, w);
else
return dp[n][w] =
max(val[n] + knapsack(n - 1, w - wt[n]), knapsack(n - 1, w));
}
int32_t main() {
fastio;
int n, w;
cin >> n >> w;
memset(dp, -1, sizeof dp);
wt.resize(n + 1, 0);
val.resize(n + 1, 0);
for (int i = 1; i <= n; i++)
cin >> wt[i] >> val[i];
cout << knapsack(n, w) << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operation.binary.remove"
] | 964,826 | 964,825 | u315416184 | cpp |
p03163 | // https://atcoder.jp/contests/dp/tasks/dp_d
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define endl "\n"
#define fastio ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define mod 1000000007
#define gcd __gcd
#define inf INT_MAX
#define INF LLONG_MAX
#define minf INT_MIN
#define MINF LLONG_MIN
#define pb push_back
#define all(v) v.begin(), v.end()
#define print(v) \
for (auto x : v) \
cout << x << " "; \
cout << "\n";
#define printn(v) \
for (auto x : v) \
cout << x << "\n";
#define F first
#define S second
#define mp make_pair
int dp[101][101];
vector<int> wt, val;
int knapsack(int n, int w) {
if (n == 0 || w == 0)
return 0;
if (dp[n][w] != -1)
return dp[n][w];
if (wt[n] > w)
return dp[n][w] = knapsack(n - 1, w);
else
return dp[n][w] =
max(val[n] + knapsack(n - 1, w - wt[n]), knapsack(n - 1, w));
}
int32_t main() {
fastio;
int n, w;
cin >> n >> w;
memset(dp, -1, sizeof dp);
wt.resize(n + 1, 0);
val.resize(n + 1, 0);
for (int i = 1; i <= n; i++)
cin >> wt[i] >> val[i];
cout << knapsack(n, w) << endl;
} | // https://atcoder.jp/contests/dp/tasks/dp_d
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define endl "\n"
#define fastio ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define mod 1000000007
#define gcd __gcd
#define inf INT_MAX
#define INF LLONG_MAX
#define minf INT_MIN
#define MINF LLONG_MIN
#define pb push_back
#define all(v) v.begin(), v.end()
#define print(v) \
for (auto x : v) \
cout << x << " "; \
cout << "\n";
#define printn(v) \
for (auto x : v) \
cout << x << "\n";
#define F first
#define S second
#define mp make_pair
ll dp[101][100001];
vector<int> wt, val;
ll knapsack(int n, int w) {
if (n == 0 || w == 0)
return 0;
if (dp[n][w] != -1)
return dp[n][w];
if (wt[n] > w)
return dp[n][w] = knapsack(n - 1, w);
else
return dp[n][w] =
max(val[n] + knapsack(n - 1, w - wt[n]), knapsack(n - 1, w));
}
int32_t main() {
fastio;
int n, w;
cin >> n >> w;
memset(dp, -1, sizeof dp);
wt.resize(n + 1, 0);
val.resize(n + 1, 0);
for (int i = 1; i <= n; i++)
cin >> wt[i] >> val[i];
cout << knapsack(n, w) << endl;
} | [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 964,829 | 964,825 | u315416184 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define endl "\n"
#define inf (1e9 + 7)
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
class item {
public:
int weight;
int value;
};
ll Knapsack1(vector<item> v, int n, int w) {
ll dp[n + 1][w + 1];
for (int wt = 0; wt <= w; wt++)
dp[1][wt] = 0;
dp[1][v[1].weight] = v[1].value;
for (int i = 2; i <= n; i++) {
for (int wt = 0; wt <= w; wt++) {
dp[i][wt] = dp[i - 1][wt];
if (v[i].weight > w)
continue;
dp[i][wt] = max(dp[i][wt], v[i].value + dp[i - 1][w - v[i].weight]);
}
}
return *max_element(dp[n], dp[n] + w + 1); // Works in O(w)
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, w;
cin >> n >> w;
vector<item> v(n + 1); // 1 based indexing
for (int i = 0; i < n; i++)
cin >> v[i].weight >> v[i].value;
cout << Knapsack1(v, n, w) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define endl "\n"
#define inf (1e9 + 7)
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
class item {
public:
int weight;
int value;
};
ll Knapsack1(vector<item> v, int n, int w) {
ll dp[n + 1][w + 1];
for (int wt = 0; wt <= w; wt++)
dp[1][wt] = 0;
dp[1][v[1].weight] = v[1].value;
for (int i = 2; i <= n; i++) {
for (int wt = 0; wt <= w; wt++) {
dp[i][wt] = dp[i - 1][wt];
if (v[i].weight > wt)
continue;
dp[i][wt] = max(dp[i][wt], v[i].value + dp[i - 1][wt - v[i].weight]);
}
}
return *max_element(dp[n], dp[n] + w + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, w;
cin >> n >> w;
vector<item> v(n + 1); // 1 based indexing
for (int i = 1; i <= n; i++)
cin >> v[i].weight >> v[i].value;
cout << Knapsack1(v, n, w) << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"... | 964,830 | 964,831 | u315416184 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define vlli vector<ll>
#define vi vector<int>
#define vs vector<string>
#define vplli vector<pair<ll, ll>>
#define plli pair<ll, ll>
#define vps vector<pair<string, string>>
#define vpi vector<pair<int, int>>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define fast \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define forn(i, a, n) for (ll i = a; i < n; i++)
#define forr(i, n, a) for (ll i = n - 1; i >= a; i--)
#define scan(arr, a, n) \
for (int i = (a); i < (n); i++) \
cin >> (arr)[i];
#define print(arr, a, n) \
for (int i = (a); i < (n); i++) \
cout << (arr)[i] << ' ';
const ll inf = 1e18;
ll add(ll x, ll y) {
ll res = x + y;
return (res >= mod ? res - mod : res);
}
ll mul(ll x, ll y) {
ll res = x * y;
return (res >= mod ? res % mod : res);
}
ll sub(ll x, ll y) {
ll res = x - y;
return (res < 0 ? res + mod : res);
}
ll power(ll x, ll y) {
ll res = 1;
x %= mod;
while (y) {
if (y & 1)
res = mul(res, x);
y >>= 1;
x = mul(x, x);
}
return res;
}
ll mod_inv(ll x) { return power(x, mod - 2); }
int main() {
fast;
ll n, w;
cin >> n >> w;
ll x, y;
vplli v(n + 1);
ll dp[n + 1][w + 1] = {};
forn(i, 1, n + 1) {
cin >> x >> y;
v[i] = mp(x, y);
}
forn(i, 1, n + 1) {
forn(j, 1, w + 1) {
if (j - v[i].F >= 0) {
dp[i][j] = max(v[i].S + dp[i - 1][j - v[i].F], dp[i - 1][w]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout << dp[n][w] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define vlli vector<ll>
#define vi vector<int>
#define vs vector<string>
#define vplli vector<pair<ll, ll>>
#define plli pair<ll, ll>
#define vps vector<pair<string, string>>
#define vpi vector<pair<int, int>>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define fast \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define forn(i, a, n) for (ll i = a; i < n; i++)
#define forr(i, n, a) for (ll i = n - 1; i >= a; i--)
#define scan(arr, a, n) \
for (int i = (a); i < (n); i++) \
cin >> (arr)[i];
#define print(arr, a, n) \
for (int i = (a); i < (n); i++) \
cout << (arr)[i] << ' ';
const ll inf = 1e18;
ll add(ll x, ll y) {
ll res = x + y;
return (res >= mod ? res - mod : res);
}
ll mul(ll x, ll y) {
ll res = x * y;
return (res >= mod ? res % mod : res);
}
ll sub(ll x, ll y) {
ll res = x - y;
return (res < 0 ? res + mod : res);
}
ll power(ll x, ll y) {
ll res = 1;
x %= mod;
while (y) {
if (y & 1)
res = mul(res, x);
y >>= 1;
x = mul(x, x);
}
return res;
}
ll mod_inv(ll x) { return power(x, mod - 2); }
int main() {
fast;
ll n, w;
cin >> n >> w;
ll x, y;
vplli v(n + 1);
ll dp[n + 1][w + 1] = {};
forn(i, 1, n + 1) {
cin >> x >> y;
v[i] = mp(x, y);
}
forn(i, 1, n + 1) {
forn(j, 1, w + 1) {
if (j - v[i].F >= 0) {
dp[i][j] = max(v[i].S + dp[i - 1][j - v[i].F], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout << dp[n][w] << endl;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 964,836 | 964,837 | u029912106 | cpp |
p03163 | #include <bits/stdc++.h>
#define fly \
ios::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr)
using namespace std;
int main() {
fly;
int n, w;
cin >> n >> w;
int weight[n + 1];
int val[n + 1];
weight[0] = 0;
val[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> weight[i] >> val[i];
}
vector<vector<int>> dp(n + 1, vector<int>(w + 1, 0));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= w; j++) {
long long int op1 = dp[i - 1][j];
long long int op2 =
(j < weight[i]) ? 0 : val[i] + dp[i - 1][j - weight[i]];
dp[i][j] = max(op1, op2);
}
}
cout << dp[n][w];
return 0;
} | #include <bits/stdc++.h>
#define fly \
ios::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr)
using namespace std;
int main() {
fly;
int n, w;
cin >> n >> w;
int weight[n + 1];
int val[n + 1];
weight[0] = 0;
val[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> weight[i] >> val[i];
}
vector<vector<long long>> dp(n + 1, vector<long long>(w + 1, 0));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= w; j++) {
long long int op1 = dp[i - 1][j];
long long int op2 =
(j < weight[i]) ? 0 : val[i] + dp[i - 1][j - weight[i]];
dp[i][j] = max(op1, op2);
}
}
cout << dp[n][w];
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 964,838 | 964,839 | u477700362 | cpp |
p03163 | #include <bits/stdc++.h>
#define int long long
using namespace std;
int n, w;
int dp[100001][1001];
int v[100001][1001];
int w1[100001];
int v1[100001];
int s1(int wr, int i) {
if (wr < 0) {
return INT_MIN;
}
if (i == n + 1) {
return 0;
}
if (v[wr][i]) {
return dp[wr][i];
}
v[wr][i] = 1;
dp[wr][i] = max(v1[i] + s1(wr - w1[i], i + 1), s1(wr, i + 1));
return dp[wr][i];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin>>t;
// int k=1;
while (t--) {
cin >> n >> w;
for (int i = 1; i <= n; i++) {
cin >> w1[i] >> v1[i];
}
cout << s1(w, 1) << '\n';
}
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
int n, w;
int dp[100001][101];
int v[100001][101];
int w1[101];
int v1[101];
int s1(int wr, int i) {
if (wr < 0) {
return INT_MIN;
}
if (i == n + 1) {
return 0;
}
if (v[wr][i]) {
return dp[wr][i];
}
v[wr][i] = 1;
dp[wr][i] = max(v1[i] + s1(wr - w1[i], i + 1), s1(wr, i + 1));
return dp[wr][i];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin>>t;
// int k=1;
while (t--) {
cin >> n >> w;
for (int i = 1; i <= n; i++) {
cin >> w1[i] >> v1[i];
}
cout << s1(w, 1) << '\n';
}
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 964,843 | 964,844 | u976563729 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define ld long double
#define pi pair<ll, ll>
#define pii vector<pair<ll, ll>>
#define v vector
#define vi vector<ll>
#define f(a, i, n) for (int i = a; i < n; i++)
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define MAX 1000001
#define all(x) x.begin(), x.end()
const ll inf = (ll)1e18;
ll gcd(ll a, ll b) {
ll r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll fpow(ll n, ll k, int p = MOD) {
ll r = 1;
for (; k; k >>= 1) {
if (k & 1)
r = r * n % p;
n = n * n % p;
}
return r;
}
int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
ll spf[MAX + 1];
void sieve() // complexity = approx 3*10^6
{
f(1, i, MAX) { spf[i] = i; }
for (ll i = 2; i < MAX; i += 2) {
spf[i] = 2;
}
for (ll i = 3; i < MAX; i += 2) {
if (spf[i] == i) // if i is prime mark its multiples with spf as i
{
for (ll j = i * i; j < MAX; j += i) {
spf[j] = min(i, (ll)spf[j]);
}
}
}
}
int main() {
ll n, w;
cin >> n >> w;
vi items(n), weight(n);
f(0, i, n) cin >> weight[i] >> items[i];
v<vi> dp(n + 1, vi(w + 1, 0));
f(0, i, n + 1) {
f(0, j, w + 1) {
if (j == 0 or i == 0)
dp[i][j] = 0;
else if (j >= weight[i - 1])
dp[i][j] = max(dp[i][j], dp[i - 1][j - weight[i - 1]] + items[i - 1]);
else
dp[i][j] = dp[i - 1][j];
}
}
cout << dp[n][w] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define ld long double
#define pi pair<ll, ll>
#define pii vector<pair<ll, ll>>
#define v vector
#define vi vector<ll>
#define f(a, i, n) for (int i = a; i < n; i++)
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define MAX 1000001
#define all(x) x.begin(), x.end()
const ll inf = (ll)1e18;
ll gcd(ll a, ll b) {
ll r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll fpow(ll n, ll k, int p = MOD) {
ll r = 1;
for (; k; k >>= 1) {
if (k & 1)
r = r * n % p;
n = n * n % p;
}
return r;
}
int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
ll spf[MAX + 1];
void sieve() // complexity = approx 3*10^6
{
f(1, i, MAX) { spf[i] = i; }
for (ll i = 2; i < MAX; i += 2) {
spf[i] = 2;
}
for (ll i = 3; i < MAX; i += 2) {
if (spf[i] == i) // if i is prime mark its multiples with spf as i
{
for (ll j = i * i; j < MAX; j += i) {
spf[j] = min(i, (ll)spf[j]);
}
}
}
}
int main() {
ll n, w;
cin >> n >> w;
vi items(n), weight(n);
f(0, i, n) cin >> weight[i] >> items[i];
v<vi> dp(n + 1, vi(w + 1, 0));
f(0, i, n + 1) {
f(0, j, w + 1) {
if (j == 0 or i == 0)
dp[i][j] = 0;
else if (j >= weight[i - 1])
dp[i][j] =
max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + items[i - 1]);
else
dp[i][j] = dp[i - 1][j];
}
}
cout << dp[n][w] << endl;
} | [
"assignment.change"
] | 964,845 | 964,846 | u540062470 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> price(n), pages(n);
for (int i = 0; i < n; i++) {
cin >> price[i] >> pages[i];
}
vector<int> dp(x + 1, 0);
for (int i = 0; i < n; i++) {
for (int j = x; j >= price[i]; j--)
dp[j] = max(dp[j], pages[i] + dp[j - price[i]]);
}
cout << dp[x] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<long long> price(n), pages(n);
for (int i = 0; i < n; i++) {
cin >> price[i] >> pages[i];
}
vector<long long> dp(x + 1, 0);
for (int i = 0; i < n; i++) {
for (int j = x; j >= price[i]; j--)
dp[j] = max(dp[j], pages[i] + dp[j - price[i]]);
}
cout << dp[x] << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 964,849 | 964,850 | u193037962 | cpp |
p03163 | #include <bits/stdc++.h>
#define pb push_back
#define ll long long
#define mp make_pair
#define ff first
#define ss second
#define inf 9e18
#define pii pair<int, int>
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
using namespace std;
vector<pair<int, int>> v;
int n, W;
int dp[102][100005];
int solve(int i, int w) {
if (i == n)
return 0;
if (dp[i][w] != -1)
return dp[i][w];
int ans = 0;
if (v[i].ff <= w)
ans = v[i].ss + solve(i + 1, w - v[i].ff);
ans = max(ans, solve(i + 1, w));
return dp[i][w] = ans;
}
int32_t main() {
fastio
cin >>
n >> W;
for (int i = 0; i < n; i++) {
pii p;
cin >> p.ff >> p.ss;
v.pb(p);
}
// ans = max(v[i] + dp[i+1][W-w[i]],dp[i+1][W]);
memset(dp, -1, sizeof(dp));
cout << solve(0, W);
return 0;
} | #include <bits/stdc++.h>
#define pb push_back
#define int long long
#define mp make_pair
#define ff first
#define ss second
#define inf 9e18
#define pii pair<int, int>
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
using namespace std;
vector<pair<int, int>> v;
int n, W;
int dp[102][100005];
int solve(int i, int w) {
if (i == n)
return 0;
if (dp[i][w] != -1)
return dp[i][w];
int ans = 0;
if (v[i].ff <= w)
ans = v[i].ss + solve(i + 1, w - v[i].ff);
ans = max(ans, solve(i + 1, w));
return dp[i][w] = ans;
}
int32_t main() {
fastio
cin >>
n >> W;
for (int i = 0; i < n; i++) {
pii p;
cin >> p.ff >> p.ss;
v.pb(p);
}
// ans = max(v[i] + dp[i+1][W-w[i]],dp[i+1][W]);
memset(dp, -1, sizeof(dp));
cout << solve(0, W);
return 0;
} | [
"identifier.change"
] | 964,856 | 964,857 | u660479949 | cpp |
p03163 | #include "bits/stdc++.h"
using namespace std;
int main() {
int n, c;
cin >> n >> c;
long long val[n], wt[n];
for (int i = 0; i < n; i++) {
cin >> wt[i] >> val[i];
}
long long dp[c + 1];
for (int i = 0; i <= n; i++) {
for (int j = c; j <= 0; j--) {
if (i == 0 || j == 0)
dp[j] = 0;
else if (wt[i - 1] <= j) {
dp[j] = max(val[i - 1] + dp[j - wt[i - 1]], dp[j]);
}
}
}
cout << dp[c];
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
int main() {
int n, c;
cin >> n >> c;
long long val[n], wt[n];
for (int i = 0; i < n; i++) {
cin >> wt[i] >> val[i];
}
long long dp[c + 1];
for (int i = 0; i <= n; i++) {
for (int j = c; j >= 0; j--) {
if (i == 0 || j == 0)
dp[j] = 0;
else if (wt[i - 1] <= j) {
dp[j] = max(val[i - 1] + dp[j - wt[i - 1]], dp[j]);
}
}
}
cout << dp[c];
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 964,858 | 964,859 | u707252821 | cpp |
p03163 | #include "bits/stdc++.h"
using namespace std;
int main() {
int n, c;
cin >> n >> c;
long long val[n], wt[n];
for (int i = 0; i < n; i++) {
cin >> wt[i] >> val[i];
}
long long dp[n + 1][c + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= c; j++) {
if (i == 0 || j == 0)
dp[i][j] = 0;
else if (wt[i - 1] <= j) {
dp[i][j] = max(val[i - 1] + dp[i - 1][j - wt[i - 1]], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[n][c];
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
int main() {
int n, c;
cin >> n >> c;
long long val[n], wt[n];
for (int i = 0; i < n; i++) {
cin >> wt[i] >> val[i];
}
long long dp[n + 1][c + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= c; j++) {
if (i == 0 || j == 0)
dp[i][j] = 0;
else if (wt[i - 1] <= j) {
dp[i][j] = max(val[i - 1] + dp[i - 1][j - wt[i - 1]], dp[i - 1][j]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout << dp[n][c];
return 0;
}
| [
"io.output.change"
] | 964,860 | 964,861 | u707252821 | cpp |
p03163 | #include <iostream>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
int w[N], v[N];
for (int i = 0; i < N; ++i) {
cin >> w[i] >> v[i];
}
int dp[N + 1][W + 1];
for (int i = 0; i <= W; ++i) {
dp[0][i] = 0;
}
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 <iostream>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
int w[N], v[N];
for (int i = 0; i < N; ++i) {
cin >> w[i] >> v[i];
}
long long dp[N + 1][W + 1];
for (int i = 0; i <= W; ++i) {
dp[0][i] = 0;
}
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;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 964,880 | 964,881 | u321492259 | cpp |
p03163 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repk(i, k, n) for (int i = k; i < n; i++)
#define all(vec) vec.begin(), vec.end()
#define ll long long
#define debug(x) cout << "debug: " << x << endl
#define MOD 1e9 + 7
#define INF 1e9
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int n, w;
cin >> n >> w;
vector<vector<int>> v(n, vector<int>(2));
rep(i, n) rep(j, 2) cin >> v[i][j];
vector<vector<ll>> dp(n + 1, vector<ll>(w + 1, -INF));
rep(i, n) {
rep(j, w + 1) {
if (j - v[i][0] >= 0)
chmax(dp[i + 1][j], dp[i][j - v[i][0]] + v[i][1]);
chmax(dp[i + 1][j], dp[i][j]);
}
}
cout << dp[n][w] << endl;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repk(i, k, n) for (int i = k; i < n; i++)
#define all(vec) vec.begin(), vec.end()
#define ll long long
#define debug(x) cout << "debug: " << x << endl
#define MOD 1e9 + 7
#define INF 1e9
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int n, w;
cin >> n >> w;
vector<vector<int>> v(n, vector<int>(2));
rep(i, n) rep(j, 2) cin >> v[i][j];
vector<vector<ll>> dp(n + 1, vector<ll>(w + 1, 0));
rep(i, n) {
rep(j, w + 1) {
if (j - v[i][0] >= 0)
chmax(dp[i + 1][j], dp[i][j - v[i][0]] + v[i][1]);
chmax(dp[i + 1][j], dp[i][j]);
}
}
cout << dp[n][w] << endl;
} | [
"call.arguments.change",
"expression.operation.unary.remove"
] | 964,884 | 964,885 | u296160120 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// knapsack
struct item {
int wt, val;
};
ll solve(vector<item> ar, int n, int W) {
int dp[n + 1][W + 1];
for (int w = 0; w <= W; w++) {
dp[1][w] = 0;
}
dp[1][ar[1].wt] = ar[1].val;
for (int i = 2; i <= n; i++) {
for (int w = 0; w <= W; w++) {
dp[i][w] = dp[i - 1][w];
if (ar[i].wt > w) {
continue;
}
dp[i][w] = max(dp[i][w], ar[i].val + dp[i - 1][w - ar[i].wt]);
}
}
return *max_element(dp[n], dp[n] + W + 1);
}
int main() {
int n, w;
cin >> n >> w;
vector<item> ar(n + 1);
for (int i = 1; i <= n; i++) {
cin >> ar[i].wt >> ar[i].val;
}
cout << solve(ar, n, w);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
// knapsack
struct item {
int wt, val;
};
ll solve(vector<item> ar, int n, int W) {
ll dp[n + 1][W + 1];
for (ll w = 0; w <= W; w++) {
dp[1][w] = 0;
}
dp[1][ar[1].wt] = ar[1].val;
for (ll i = 2; i <= n; i++) {
for (ll w = 0; w <= W; w++) {
dp[i][w] = dp[i - 1][w];
if (ar[i].wt > w) {
continue;
}
dp[i][w] = max(dp[i][w], ar[i].val + dp[i - 1][w - ar[i].wt]);
}
}
return *max_element(dp[n], dp[n] + W + 1);
}
int main() {
ll n, w;
cin >> n >> w;
vector<item> ar(n + 1);
for (ll i = 1; i <= n; i++) {
cin >> ar[i].wt >> ar[i].val;
}
cout << solve(ar, n, w);
return 0;
}
| [
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change"
] | 964,956 | 964,957 | u411727360 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n, capacity;
cin >> n >> capacity;
vector<ll> weights(n), values(n);
for (int i = 0; i < n; i++)
cin >> weights[i] >> values[i];
vector<vector<ll>> dp(n, vector<ll>(capacity + 1));
for (int i = 0; i < n; i++)
dp[i][0] = 0;
for (int i = 0; i <= capacity; i++) {
if (weights[0] <= capacity)
dp[0][i] = values[0];
}
for (int i = 1; i < n; i++) {
for (int w = 1; w <= capacity; w++) {
if (weights[i] > w)
dp[i][w] = dp[i - 1][w];
else
dp[i][w] = max(dp[i - 1][w], values[i] + dp[i - 1][w - weights[i]]);
}
}
cout << dp[n - 1][capacity];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n, capacity;
cin >> n >> capacity;
vector<ll> weights(n), values(n);
for (int i = 0; i < n; i++)
cin >> weights[i] >> values[i];
vector<vector<ll>> dp(n, vector<ll>(capacity + 1));
for (int i = 0; i < n; i++)
dp[i][0] = 0;
for (int i = 0; i <= capacity; i++) {
if (weights[0] <= i)
dp[0][i] = values[0];
}
for (int i = 1; i < n; i++) {
for (int w = 1; w <= capacity; w++) {
if (weights[i] > w)
dp[i][w] = dp[i - 1][w];
else
dp[i][w] = max(dp[i - 1][w], values[i] + dp[i - 1][w - weights[i]]);
}
}
cout << dp[n - 1][capacity];
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 964,962 | 964,963 | u712474804 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[10001][101];
int knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[100001][101];
ll knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 964,964 | 964,965 | u043995126 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[100001][101];
int knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[100001][101];
ll knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| [] | 964,966 | 964,965 | u043995126 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[1000001][101];
int knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[100001][101];
ll knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 964,967 | 964,965 | u043995126 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[100002][102];
int knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[100001][101];
ll knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 964,968 | 964,965 | u043995126 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[1002][102];
int knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll t[100001][101];
ll knapsackdpTab(ll val[], ll wt[], ll w, ll n) // Tabulation
{
for (int i = 0; i < w + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
t[i][j] = 0;
}
}
for (int i = 1; i < w + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (wt[j - 1] <= i)
t[i][j] = max(val[j - 1] + t[i - wt[j - 1]][j - 1], t[i][j - 1]);
else
t[i][j] = t[i][j - 1];
}
}
return t[w][n];
}
int main() {
memset(t, -1, sizeof(t));
ll n, w;
cin >> n >> w;
ll wt[n];
ll val[n];
for (int i = 0; i < n; i++)
cin >> wt[i] >> val[i];
cout << knapsackdpTab(val, wt, w, n);
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 964,969 | 964,965 | u043995126 | cpp |
p03163 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int LIM = 105;
int n, w;
int q[LIM];
long long ans = 0, sum[100005], v[LIM];
int main() {
cin >> n >> w;
for (int i = 1; i <= n; ++i)
cin >> q[i] >> v[i];
vector<int> s; // vector cu greutatile multimilor
for (int j = 1; j <= n; ++j) {
vector<pair<int, long long>>
modificari; // vector cu greutate/capacitate a noi multimi create
ans = max(ans, v[j]);
int lg = s.size();
if (sum[q[j]] == 0)
s.push_back(
q[j]); // daca greutatea elementului nu este in sirul de multimi
for (int k = 0; k < lg; ++k)
if (s[k] + q[j] <=
w) { // daca greutatea [multime + element nou] se incadreaza in w
if (sum[s[k] + q[j]] == 0) { // daca multimea nu este in sir
s.push_back(s[k] + q[j]);
modificari.push_back(make_pair(s[k] + q[j], sum[s[k]] + v[j]));
ans = max(ans, sum[s[k]] + v[j]);
}
}
sum[q[j]] = max(sum[q[j]], v[j]);
for (size_t i = 0; i < modificari.size();
++i) // fiecare greutate are cea mai mare suma posibila
sum[modificari[i].first] =
max(sum[modificari[i].first], modificari[i].second);
}
cout << ans;
return 0;
}
| #include <algorithm>
#include <fstream>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int LIM = 105;
int n, w;
int q[LIM];
long long ans = 0, sum[100005], v[LIM];
int main() {
cin >> n >> w;
for (int i = 1; i <= n; ++i)
cin >> q[i] >> v[i];
vector<int> s;
for (int j = 1; j <= n; ++j) {
vector<pair<int, long long>> modificari;
ans = max(ans, v[j]);
int lg = s.size();
if (sum[q[j]] == 0) // daca nu exista o multime cu a j greutate, o punem in
// sirul de multimi
s.push_back(q[j]);
for (int k = 0; k < lg; ++k) {
if (s[k] + q[j] <= w) { // daca greutatea se incadreaza in W
if (sum[s[k] + q[j]] ==
0) // daca nu am greutatea multime + element nou in sir
s.push_back(s[k] + q[j]);
modificari.push_back(make_pair(s[k] + q[j], sum[s[k]] + v[j]));
ans = max(ans, sum[s[k]] + v[j]);
}
}
sum[q[j]] = max(sum[q[j]], v[j]);
for (size_t i = 0; i < modificari.size(); ++i)
sum[modificari[i].first] =
max(sum[modificari[i].first], modificari[i].second);
}
cout << ans;
return 0;
}
| [] | 964,971 | 964,972 | u841608305 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
int MAX = 1e9;
int MAXEST = 1e18;
int MOD = 1e9 + 7;
int n, w;
int v[105], s[105];
int dp[2][100005];
in main() {
int tc = 1;
// cin>>tc;
while (tc--) {
cin >> n >> w;
for (int i = 1; i <= n; i++) {
cin >> s[i] >> v[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= w; j++) {
dp[i & 1][j] = dp[(i - 1) & 1][j];
if (j >= s[i])
dp[i & 1][j] = max(dp[i & 1][j], dp[(i - 1) & 1][j - s[i]] + v[i]);
}
}
cout << dp[n][w] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
int MAX = 1e9;
int MAXEST = 1e18;
int MOD = 1e9 + 7;
int n, w;
int v[105], s[105];
int dp[2][100005];
in main() {
int tc = 1;
// cin>>tc;
while (tc--) {
cin >> n >> w;
for (int i = 1; i <= n; i++) {
cin >> s[i] >> v[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= w; j++) {
dp[i & 1][j] = dp[(i - 1) & 1][j];
if (j >= s[i])
dp[i & 1][j] = max(dp[i & 1][j], dp[(i - 1) & 1][j - s[i]] + v[i]);
}
}
cout << dp[n & 1][w] << endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 964,973 | 964,974 | u727767116 | cpp |
p03163 | //インクルード(アルファベット順)
#include <algorithm> //sort,二分探索,など
#include <bitset> //固定長bit集合
#include <chrono> //実行時間計測
#include <cmath> //pow,logなど
#include <complex> //複素数
#include <deque> //両端アクセスのキュー
#include <functional> //sortのgreater
#include <iomanip> //setprecision(浮動小数点の出力の誤差)
#include <iostream> //入出力
#include <iterator> //集合演算(積集合,和集合,差集合など)
#include <map> //map(辞書)
#include <numeric> //iota(整数列の生成),gcdとlcm,accumulate
#include <queue> //キュー
#include <set> //集合
#include <stack> //スタック
#include <stdio.h>
#include <string> //文字列
#include <unordered_map> //順序保持しないmap
#include <unordered_set> //順序保持しないset
#include <utility> //pair
#include <vector> //可変長配列
using namespace std;
typedef long long ll;
//マクロ
// forループ
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= ll(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= ll(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) x.begin(), x.end()
#define SIZE(x) ll(x.size())
//定数
#define INF 1000000000000 // 10^12:∞
#define MOD 1000000007 // 10^9+7:合同式の法
#define MAXR 100000 // 10^5:配列の最大のrange
//略記
#define PB push_back //挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define PI 3.14159265358979323846264338327950L
#define YESNO(T) \
if (T) { \
cout << "YES" << endl; \
} else { \
cout << "NO" << endl; \
}
#define yesno(T) \
if (T) { \
cout << "yes" << endl; \
} else { \
cout << "no" << endl; \
}
#define YesNo(T) \
if (T) { \
cout << "Yes" << endl; \
} else { \
cout << "No" << endl; \
}
#define int long long
#define Graph vector<vector<int>>
#define PII pair<int, int>
#define VI vector<int>
#define VVI vector<vector<int>>
#define VPII vector<pair<int, int>>
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
long long powmod(long long x, long long n) {
long long ret = 1;
while (n > 0) {
if (n & 1)
ret = ret * x %
MOD; // n の最下位bitが1ならば(nが奇数ならば) x^(2^i) をかける
x = x * x % MOD;
n >>= 1; // n を1bit 左にずらす
}
return ret;
}
int ctoi(char c) {
switch (c) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return 0;
}
}
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
}
else {
return (gcd(b, a % b));
}
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
bool isPrime(int x) {
int i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1; //素数だった時の
return ret;
}
long long nCr(long long n, long long r) {
long long x = 1, y = 1;
for (int i = 0; i < r; i++) {
x = x * (n - i) % MOD;
y = y * (i + 1) % MOD;
}
return x * powmod(y, MOD - 2) % MOD;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ここにグローバル変数宣言
int dhh[4] = {1, 0, -1, 0};
int dww[4] = {0, 1, 0, -1}; // BFS関連
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ここに関数宣言
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
signed main() {
//入力の高速化用のコード
ios::sync_with_stdio(false);
cin.tie(nullptr);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int N, W;
cin >> N >> W;
VI w(N + 1), v(N + 1);
FOR(i, 1, N) { cin >> w[i] >> v[i]; }
w[0] = v[0] = 0;
vector<VI> dp(N + 5, VI(W + 5, 0));
FOR(i, 1, N) FOR(j, 1, W) {
if (j >= w[i + 1]) {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i + 1]] + v[i + 1]);
} else {
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[N][W] << endl;
return 0;
}
| //インクルード(アルファベット順)
#include <algorithm> //sort,二分探索,など
#include <bitset> //固定長bit集合
#include <chrono> //実行時間計測
#include <cmath> //pow,logなど
#include <complex> //複素数
#include <deque> //両端アクセスのキュー
#include <functional> //sortのgreater
#include <iomanip> //setprecision(浮動小数点の出力の誤差)
#include <iostream> //入出力
#include <iterator> //集合演算(積集合,和集合,差集合など)
#include <map> //map(辞書)
#include <numeric> //iota(整数列の生成),gcdとlcm,accumulate
#include <queue> //キュー
#include <set> //集合
#include <stack> //スタック
#include <stdio.h>
#include <string> //文字列
#include <unordered_map> //順序保持しないmap
#include <unordered_set> //順序保持しないset
#include <utility> //pair
#include <vector> //可変長配列
using namespace std;
typedef long long ll;
//マクロ
// forループ
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= ll(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= ll(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) x.begin(), x.end()
#define SIZE(x) ll(x.size())
//定数
#define INF 1000000000000 // 10^12:∞
#define MOD 1000000007 // 10^9+7:合同式の法
#define MAXR 100000 // 10^5:配列の最大のrange
//略記
#define PB push_back //挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define PI 3.14159265358979323846264338327950L
#define YESNO(T) \
if (T) { \
cout << "YES" << endl; \
} else { \
cout << "NO" << endl; \
}
#define yesno(T) \
if (T) { \
cout << "yes" << endl; \
} else { \
cout << "no" << endl; \
}
#define YesNo(T) \
if (T) { \
cout << "Yes" << endl; \
} else { \
cout << "No" << endl; \
}
#define int long long
#define Graph vector<vector<int>>
#define PII pair<int, int>
#define VI vector<int>
#define VVI vector<vector<int>>
#define VPII vector<pair<int, int>>
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
long long powmod(long long x, long long n) {
long long ret = 1;
while (n > 0) {
if (n & 1)
ret = ret * x %
MOD; // n の最下位bitが1ならば(nが奇数ならば) x^(2^i) をかける
x = x * x % MOD;
n >>= 1; // n を1bit 左にずらす
}
return ret;
}
int ctoi(char c) {
switch (c) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return 0;
}
}
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
}
else {
return (gcd(b, a % b));
}
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
bool isPrime(int x) {
int i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1; //素数だった時の
return ret;
}
long long nCr(long long n, long long r) {
long long x = 1, y = 1;
for (int i = 0; i < r; i++) {
x = x * (n - i) % MOD;
y = y * (i + 1) % MOD;
}
return x * powmod(y, MOD - 2) % MOD;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ここにグローバル変数宣言
int dhh[4] = {1, 0, -1, 0};
int dww[4] = {0, 1, 0, -1}; // BFS関連
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ここに関数宣言
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
signed main() {
//入力の高速化用のコード
ios::sync_with_stdio(false);
cin.tie(nullptr);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int N, W;
cin >> N >> W;
VI w(N + 1), v(N + 1);
FOR(i, 1, N) { cin >> w[i] >> v[i]; }
w[0] = v[0] = 0;
vector<VI> dp(N + 5, VI(W + 5, 0));
FOR(i, 0, N) FOR(j, 0, W) {
if (j >= w[i + 1]) {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i + 1]] + v[i + 1]);
} else {
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[N][W] << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 964,976 | 964,977 | u345693891 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int W;
cin >> N >> W;
vector<int> weight(110);
vector<int> value(110);
for (int i = 0; i < N; i++) {
cin >> weight.at(i) >> value.at(i);
}
vector<vector<int>> dp(110, vector<int>(100100, 0));
//ちょうどWのときの最大の価値を計算
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j - weight.at(i) >= 0) {
dp.at(i + 1).at(j) = max(dp.at(i).at(j - weight.at(i)) + value.at(i),
dp.at(i + 1).at(j));
}
dp.at(i + 1).at(j) = max(dp.at(i + 1).at(j), dp.at(i).at(j));
}
}
cout << dp.at(N).at(W) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int W;
cin >> N >> W;
vector<int> weight(110);
vector<int> value(110);
for (int i = 0; i < N; i++) {
cin >> weight.at(i) >> value.at(i);
}
vector<vector<long long int>> dp(110, vector<long long int>(100100, 0));
//ちょうどWのときの最大の価値を計算
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j - weight.at(i) >= 0) {
dp.at(i + 1).at(j) = max(dp.at(i).at(j - weight.at(i)) + value.at(i),
dp.at(i + 1).at(j));
}
dp.at(i + 1).at(j) = max(dp.at(i + 1).at(j), dp.at(i).at(j));
}
}
cout << dp.at(N).at(W) << endl;
} | [
"variable_declaration.type.widen.change"
] | 964,980 | 964,981 | u120586196 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
long long int W;
cin >> N >> W;
vector<long long int> weight(110);
vector<long long int> value(110);
for (int i = 0; i < N; i++) {
cin >> weight.at(i) >> value.at(i);
}
vector<vector<long long int>> dp(110, vector<long long int>(100000, 0));
//ちょうどWのときの最大の価値を計算
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j - weight.at(i) >= 0) {
dp.at(i + 1).at(j) = max(dp.at(i).at(j - weight.at(i)) + value.at(i),
dp.at(i + 1).at(j));
} else {
dp.at(i + 1).at(j) = max(dp.at(i + 1).at(j), dp.at(i).at(j));
}
}
}
cout << dp.at(N).at(W) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int W;
cin >> N >> W;
vector<long long int> weight(110);
vector<long long int> value(110);
for (int i = 0; i < N; i++) {
cin >> weight.at(i) >> value.at(i);
}
vector<vector<long long int>> dp(110, vector<long long int>(100100, 0));
//ちょうどWのときの最大の価値を計算
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j - weight.at(i) >= 0) {
dp.at(i + 1).at(j) = max(dp.at(i).at(j - weight.at(i)) + value.at(i),
dp.at(i + 1).at(j));
}
dp.at(i + 1).at(j) = max(dp.at(i + 1).at(j), dp.at(i).at(j));
}
}
cout << dp.at(N).at(W) << endl;
} | [
"literal.number.change",
"call.arguments.change"
] | 964,986 | 964,983 | u120586196 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
long long int W;
cin >> N >> W;
vector<long long int> weight(110);
vector<long long int> value(110);
for (int i = 0; i < N; i++) {
cin >> weight.at(i) >> value.at(i);
}
vector<vector<long long int>> dp(110, vector<long long int>(100000));
//ちょうどWのときの最大の価値を計算
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j - weight.at(i) >= 0) {
dp.at(i + 1).at(j) = max(dp.at(i).at(j - weight.at(i)) + value.at(i),
dp.at(i + 1).at(j));
} else {
dp.at(i + 1).at(j) = max(dp.at(i + 1).at(j), dp.at(i).at(j));
}
}
}
cout << dp.at(N).at(W) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
long long int W;
cin >> N >> W;
vector<long long int> weight(110);
vector<long long int> value(110);
for (int i = 0; i < N; i++) {
cin >> weight.at(i) >> value.at(i);
}
vector<vector<long long int>> dp(110, vector<long long int>(100100, 0));
//ちょうどWのときの最大の価値を計算
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j - weight.at(i) >= 0) {
dp.at(i + 1).at(j) = max(dp.at(i).at(j - weight.at(i)) + value.at(i),
dp.at(i + 1).at(j));
}
dp.at(i + 1).at(j) = max(dp.at(i + 1).at(j), dp.at(i).at(j));
}
}
cout << dp.at(N).at(W) << endl;
} | [
"literal.number.change",
"call.arguments.change",
"call.arguments.add"
] | 964,988 | 964,987 | u120586196 | cpp |
p03163 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define in long long int
int dp[101][100001];
in knapsack(vector<in> &w, vector<in> &v, in n, in cap) {
if (n == 0 || cap == 0)
return 0;
if (dp[n][cap] != -1)
return dp[n][cap];
if (w[n - 1] <= cap)
dp[n][cap] = max(v[n - 1] + knapsack(w, v, n - 1, cap - w[n - 1]),
knapsack(w, v, n - 1, cap));
else
dp[n][cap] = knapsack(w, v, n - 1, cap);
return dp[n][cap];
}
int main() {
memset(dp, -1, sizeof(dp));
in n, cap;
cin >> n >> cap;
vector<in> w(n), v(n);
for (in i = 0; i < n; i++) {
cin >> w[i];
cin >> v[i];
}
cout << knapsack(w, v, n, cap);
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define in long long int
in dp[101][100001];
in knapsack(vector<in> &w, vector<in> &v, in n, in cap) {
if (n == 0 || cap == 0)
return 0;
if (dp[n][cap] != -1)
return dp[n][cap];
if (w[n - 1] <= cap)
dp[n][cap] = max(v[n - 1] + knapsack(w, v, n - 1, cap - w[n - 1]),
knapsack(w, v, n - 1, cap));
else
dp[n][cap] = knapsack(w, v, n - 1, cap);
return dp[n][cap];
}
int main() {
memset(dp, -1, sizeof(dp));
in n, cap;
cin >> n >> cap;
vector<in> w(n), v(n);
for (in i = 0; i < n; i++) {
cin >> w[i];
cin >> v[i];
}
cout << knapsack(w, v, n, cap);
return 0;
} | [
"variable_declaration.type.change"
] | 964,994 | 964,995 | u848144297 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, w;
cin >> n >> w;
vector<int> dp(w + 1);
while (n--) {
int we, va;
cin >> we >> va;
for (int j = w - we; j >= 0; --j) {
dp[j + we] = max(dp[j + we], dp[j] + va);
}
}
cout << *max_element(dp.begin(), dp.end()) << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, w;
cin >> n >> w;
vector<long long> dp(w + 1);
while (n--) {
int we, va;
cin >> we >> va;
for (int j = w - we; j >= 0; --j) {
dp[j + we] = max(dp[j + we], dp[j] + va);
}
}
cout << *max_element(dp.begin(), dp.end()) << '\n';
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 965,011 | 965,012 | u049708565 | cpp |
p03163 | #include <iostream>
using namespace std;
int main(int argc, const char *argv[]) {
long long n, m;
cin >> n >> m;
long long arr[n][2];
for (long long i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1];
}
long long dp[n + 1][m + 1];
for (long long j = 0; j < m + 1; j++) {
for (long long i = 0; i < n + 1; i++) {
dp[i][j] = 0;
}
}
for (long long i = 1; i < n + 1; i++) {
for (long long j = 0; j < m + 1; j++) {
if (arr[i - 1][0] > j) {
dp[i][j] = dp[i - 1][j];
} else {
dp[i][j] =
max(dp[i - 1][j], arr[i - 1][1] + dp[i - 1][j - arr[i - 1][0]]);
}
}
}
cout << arr[n][m];
return 0;
}
| #include <iostream>
using namespace std;
int main(int argc, const char *argv[]) {
long long n, m;
cin >> n >> m;
long long arr[n][2];
for (long long i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1];
}
long long dp[n + 1][m + 1];
for (long long j = 0; j < m + 1; j++) {
for (long long i = 0; i < n + 1; i++) {
dp[i][j] = 0;
}
}
for (long long i = 1; i < n + 1; i++) {
for (long long j = 0; j < m + 1; j++) {
if (arr[i - 1][0] > j) {
dp[i][j] = dp[i - 1][j];
} else {
dp[i][j] =
max(dp[i - 1][j], arr[i - 1][1] + dp[i - 1][j - arr[i - 1][0]]);
}
}
}
cout << dp[n][m] << endl;
return 0;
} | [
"identifier.change",
"io.output.change",
"io.output.newline.add"
] | 965,015 | 965,016 | u407743105 | cpp |
p03163 |
#include <algorithm>
#include <iostream>
using namespace std;
const int MAXN = 100;
const int MAXW = 100000;
unsigned long long dp[MAXN + 1][MAXW + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, W;
cin >> n >> W;
int v[n], w[n];
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
for (int i = 0; i <= n; i++) {
dp[i][0] = 0;
}
for (int i = 1; i <= W; i++) {
dp[0][i] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= W; j++) {
if (w[i] <= j) {
dp[i][j] = max(dp[i - 1][j], v[i] + dp[i - 1][j - w[i]]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout << dp[n][W];
return 0;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
const int MAXN = 100;
const int MAXW = 100000;
unsigned long long dp[MAXN + 1][MAXW + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, W;
cin >> n >> W;
int v[n + 1], w[n + 1];
for (int i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
}
for (int i = 0; i <= n; i++) {
dp[i][0] = 0;
}
for (int i = 1; i <= W; i++) {
dp[0][i] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= W; j++) {
if (w[i] <= j) {
dp[i][j] = max(dp[i - 1][j], v[i] + dp[i - 1][j - w[i]]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
cout << dp[n][W];
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 965,021 | 965,022 | u278097351 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define fastii \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define endl "\n"
#define f0(i, n) for (int i = 0; i < n; i++)
#define f1(i, n) for (int i = 1; i <= n; i++)
#define mp make_pair
#define pb push_back
#define F first
#define S second
#define ll long long int
#define pi pair<int, int>
#define ai(v) v.begin(), v.end()
#define air(v) v.rbegin(), v.rend()
#define pii 3.14159265358979323
#define inf LLONG_MAX
#define fill(a, b) memset(a, b, sizeof(a))
#define mod 1000000007
ll static t[10001][10001];
ll mod_pow(ll a, ll b, ll m) {
ll res = 1;
while (b) {
if (b & 1) {
res = (res * a) % m;
}
a = (a * a) % m;
b >>= 1;
}
return res;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return (a % b, b);
}
void sieveofEratosthenes(ll n) {
bool prime[n + 1];
fill(prime, true);
for (int i = 2; i * i <= n; i++) {
if (prime[i] == true) {
for (int j = i * i; j <= n; j += i)
prime[j] = false;
}
}
for (int i = 2; i <= n; i++) {
if (prime[i])
cout << i << " ";
}
}
ll mod_inverse(ll a) { return mod_pow(a, mod - 2, mod); }
ll knapsack(ll wt[], ll val[], ll W, ll n) {
if (n == 0 || W == 0)
return 0;
if (t[n][W] != -1)
return t[n][W];
if (wt[n - 1] <= W)
return t[n][W] = max(val[n - 1] + knapsack(wt, val, W - wt[n - 1], n - 1),
knapsack(wt, val, W, n - 1));
else if (wt[n - 1] > W)
return (t[n][W] = knapsack(wt, val, W, n - 1));
}
void solve() {
ll n, W;
cin >> n >> W;
ll wt[n], val[n];
f0(i, n) {
fill(t, -1);
cin >> wt[i];
cin >> val[i];
}
cout << knapsack(wt, val, W, n) << endl;
;
}
signed main() {
fastii;
int T = 1;
while (T--) {
solve();
}
return 0;
}
/*Author :- Ankit Raj
*Site:-
*Topic:-
* Competative Programming
*email :-
*Technocrats Institute Of Technology
*5th Sem
*/ | #include <bits/stdc++.h>
using namespace std;
#define fastii \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define endl "\n"
#define f0(i, n) for (int i = 0; i < n; i++)
#define f1(i, n) for (int i = 1; i <= n; i++)
#define mp make_pair
#define pb push_back
#define F first
#define S second
#define ll long long int
#define pi pair<int, int>
#define ai(v) v.begin(), v.end()
#define air(v) v.rbegin(), v.rend()
#define pii 3.14159265358979323
#define inf LLONG_MAX
#define fill(a, b) memset(a, b, sizeof(a))
#define mod 1000000007
ll static t[101][100001];
ll mod_pow(ll a, ll b, ll m) {
ll res = 1;
while (b) {
if (b & 1) {
res = (res * a) % m;
}
a = (a * a) % m;
b >>= 1;
}
return res;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return (a % b, b);
}
void sieveofEratosthenes(ll n) {
bool prime[n + 1];
fill(prime, true);
for (int i = 2; i * i <= n; i++) {
if (prime[i] == true) {
for (int j = i * i; j <= n; j += i)
prime[j] = false;
}
}
for (int i = 2; i <= n; i++) {
if (prime[i])
cout << i << " ";
}
}
ll mod_inverse(ll a) { return mod_pow(a, mod - 2, mod); }
ll knapsack(ll wt[], ll val[], ll W, ll n) {
if (n == 0 || W == 0)
return 0;
if (t[n][W] != -1)
return t[n][W];
if (wt[n - 1] <= W)
return t[n][W] = max(val[n - 1] + knapsack(wt, val, W - wt[n - 1], n - 1),
knapsack(wt, val, W, n - 1));
else if (wt[n - 1] > W)
return (t[n][W] = knapsack(wt, val, W, n - 1));
}
void solve() {
ll n, W;
cin >> n >> W;
ll wt[n], val[n];
f0(i, n) {
fill(t, -1);
cin >> wt[i];
cin >> val[i];
}
cout << knapsack(wt, val, W, n) << endl;
;
}
signed main() {
fastii;
int T = 1;
while (T--) {
solve();
}
return 0;
}
/*Author :- Ankit Raj
*Site:-
*Topic:-
* Competative Programming
*email :-
*Technocrats Institute Of Technology
*5th Sem
*/
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 965,030 | 965,029 | u970254260 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, maxw;
int w[111], v[111];
int f[111111];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> maxw;
for (int i = 1; i <= n; ++i)
cin >> w[i] >> v[i];
for (int i = 1; i <= n; ++i) {
for (int j = maxw; j >= w[i]; --j) {
f[j] = max(f[j], f[j - w[i]] + v[i]);
}
}
cout << f[maxw];
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, maxw;
int w[111], v[111];
ll f[111111];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> maxw;
for (int i = 1; i <= n; ++i)
cin >> w[i] >> v[i];
for (int i = 1; i <= n; ++i) {
for (int j = maxw; j >= w[i]; --j) {
f[j] = max(f[j], f[j - w[i]] + v[i]);
}
}
cout << f[maxw];
} | [
"variable_declaration.type.change"
] | 965,037 | 965,038 | u448205469 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, maxw;
int w[111], v[111];
int f[111][111111];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> maxw;
for (int i = 1; i <= n; ++i)
cin >> w[i] >> v[i];
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= maxw; ++j) {
if (j >= w[i])
f[i][j] = max(f[i - 1][j], f[i - 1][j - w[i]] + v[i]);
else
f[i][j] = f[i - 1][j];
}
}
cout << f[n][maxw];
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, maxw;
int w[111], v[111];
ll f[111][111111];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> maxw;
for (int i = 1; i <= n; ++i)
cin >> w[i] >> v[i];
// for(int i = 1; i <= maxw; ++i) f[1][i] = i >= w[1] ? v[1] : 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= maxw; ++j) {
if (j >= w[i])
f[i][j] = max(f[i - 1][j], f[i - 1][j - w[i]] + v[i]);
else
f[i][j] = f[i - 1][j];
}
}
cout << f[n][maxw];
} | [
"variable_declaration.type.change"
] | 965,039 | 965,040 | u448205469 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
int w[N], v[N];
for (int i = 0; i < N; i++)
cin >> w[i] >> v[i];
int dp[N + 1][W + 1];
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= W; j++) {
if (i == 0 || j == 0)
dp[i][j] = 0;
else {
dp[i][j] = dp[i - 1][j];
if (j - w[i - 1] >= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
}
// cout << dp[i][j] << " ";
} // cout << endl;
}
cout << dp[N][W];
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int N, W;
cin >> N >> W;
int w[N], v[N];
for (int i = 0; i < N; i++)
cin >> w[i] >> v[i];
ll dp[N + 1][W + 1];
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= W; j++) {
if (i == 0 || j == 0)
dp[i][j] = 0;
else {
dp[i][j] = dp[i - 1][j];
if (j - w[i - 1] >= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
}
// cout << dp[i][j] << " ";
} // cout << endl;
}
cout << dp[N][W];
}
| [
"variable_declaration.type.change"
] | 965,041 | 965,042 | u448570453 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using namespace std;
ll dp[101][101010];
int main() {
int N, W;
cin >> N >> W;
vector<ll> w(N), v(N);
rep(i, N) cin >> w[i + 1] >> v[i + 1];
for (int i = 1; i <= N; ++i) {
for (int j = W; j >= 0; --j) {
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];
}
}
}
ll ans = 0;
for (int i = 0; i <= W; ++i)
ans = max(ans, dp[N][i]);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using namespace std;
ll dp[101][101010];
int main() {
int N, W;
cin >> N >> W;
vector<ll> w(N + 1), v(N + 1);
rep(i, N) cin >> w[i + 1] >> v[i + 1];
for (int i = 1; i <= N; ++i) {
for (int j = W; j >= 0; --j) {
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];
}
}
}
ll ans = 0;
for (int i = 0; i <= W; ++i)
ans = max(ans, dp[N][i]);
cout << ans << endl;
}
| [
"assignment.change"
] | 965,043 | 965,044 | u482544950 | cpp |
p03163 | /*"Everything in the universe is balanced. Every disappointment
you face in life will be balanced by something good for you!
Keep going, never give up." */
#include "bits/stdc++.h"
using namespace std;
#define ll long long
const ll N = 1e6 + 9;
const ll mod = 1e9 + 7;
ll a[N];
void solve() {
ll n, m, W;
cin >> n >> W;
vector<pair<int, int>> item(n);
for (int i = 0; i < n; i++) {
cin >> item[i].first >> item[i].second;
}
sort(item.begin(), item.end());
vector<vector<int>> dp(n, vector<int>(W + 1, 0));
for (int i = item[0].first; i <= W; i++) {
dp[0][i] = item[0].second;
}
for (int i = 1; i < n; i++) {
for (int j = 1; j <= W; j++) {
dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
if (j >= item[i].first) {
dp[i][j] =
max({dp[i][j], dp[i - 1][j - item[i].first] + item[i].second});
}
// cout<<i<<j<<" " <<dp[i][j]<<"\n";
}
}
cout << dp[n - 1][W];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll t = 1;
// pre();
// cin>>t;
while (t--) {
solve();
}
}
// Xorawar | /*"Everything in the universe is balanced. Every disappointment
you face in life will be balanced by something good for you!
Keep going, never give up." */
#include "bits/stdc++.h"
using namespace std;
#define ll long long
const ll N = 1e6 + 9;
const ll mod = 1e9 + 7;
ll a[N];
void solve() {
ll n, m, W;
cin >> n >> W;
vector<pair<int, int>> item(n);
for (int i = 0; i < n; i++) {
cin >> item[i].first >> item[i].second;
}
sort(item.begin(), item.end());
vector<vector<long long int>> dp(n, vector<long long int>(W + 1, 0));
for (int i = item[0].first; i <= W; i++) {
dp[0][i] = item[0].second;
}
for (int i = 1; i < n; i++) {
for (int j = 1; j <= W; j++) {
dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
if (j >= item[i].first) {
dp[i][j] =
max({dp[i][j], dp[i - 1][j - item[i].first] + item[i].second});
// cout<<i<<j<<" " <<dp[i][j]<<"
// "<<dp[i-1][j-item[i].first]<<"."<<item[i].second<<"..";
}
// cout<<i<<j<<" " <<dp[i][j]<<"\n";
}
}
cout << dp[n - 1][W];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll t = 1;
// pre();
// cin>>t;
while (t--) {
solve();
}
}
// Xorawar | [
"variable_declaration.type.widen.change"
] | 965,045 | 965,046 | u947134954 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int n, wt;
cin >> n >> wt;
vector<int> w(n + 1), v(n + 1);
for (int i = 1; i <= n; i++)
cin >> w[i] >> v[i];
vector<vector<int>> dp(n, vector<int>(wt + 1));
for (int i = 1; i <= n; i++)
for (int j = 0; j < wt + 1; j++)
dp[i][j] =
max(dp[i - 1][j], (j >= w[i] ? dp[i - 1][j - w[i]] + v[i] : -1));
cout << dp[n][wt];
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int n, wt;
cin >> n >> wt;
vector<int> w(n + 1), v(n + 1);
for (int i = 1; i <= n; i++)
cin >> w[i] >> v[i];
vector<vector<int>> dp(n + 1, vector<int>(wt + 1));
for (int i = 1; i <= n; i++)
for (int j = 0; j < wt + 1; j++)
dp[i][j] =
max(dp[i - 1][j], (j >= w[i] ? dp[i - 1][j - w[i]] + v[i] : -1));
cout << dp[n][wt];
}
| [
"assignment.change"
] | 965,051 | 965,052 | u389500770 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int n, wt;
cin >> n >> wt;
vector<int> w(n + 1), v(n + 1);
for (int i = 1; i <= n; i++)
cin >> w[i] >> v[i];
vector<vector<int>> dp(n, vector<int>(wt + 1));
for (int i = 1; i < n; i++)
for (int j = 0; j < wt + 1; j++)
dp[i][j] =
max(dp[i - 1][j], (j >= w[i] ? dp[i - 1][j - w[i]] + v[i] : -1));
cout << dp[n - 1][wt];
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int n, wt;
cin >> n >> wt;
vector<int> w(n + 1), v(n + 1);
for (int i = 1; i <= n; i++)
cin >> w[i] >> v[i];
vector<vector<int>> dp(n + 1, vector<int>(wt + 1));
for (int i = 1; i <= n; i++)
for (int j = 0; j < wt + 1; j++)
dp[i][j] =
max(dp[i - 1][j], (j >= w[i] ? dp[i - 1][j - w[i]] + v[i] : -1));
cout << dp[n][wt];
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 965,053 | 965,052 | u389500770 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
signed main() {
int n, wt;
cin >> n >> wt;
vector<int> w(n), v(n);
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
vector<vector<int>> dp(n, vector<int>(wt + 1));
// dp[i][j]->max value with j weight after processing 1st i wts.
// dp[i][j]=max(dp[i-1][j-w[i]]+v[i],dp[i-1][j])
for (int i = 0; i < wt + 1; i++)
dp[0][i] = (i >= w[0] ? v[0] : 0);
for (int i = 1; i < n; i++)
for (int j = 0; j < wt + 1; j++)
dp[i][j] =
max(dp[i - 1][j], (j >= w[i] ? dp[i - 1][j - w[i]] + v[i] : -1));
cout << dp[n - 1][wt];
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int n, wt;
cin >> n >> wt;
vector<int> w(n), v(n);
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
vector<vector<int>> dp(n, vector<int>(wt + 1));
// dp[i][j]->max value with j weight after processing 1st i wts.
// dp[i][j]=max(dp[i-1][j-w[i]]+v[i],dp[i-1][j])
for (int i = 0; i < wt + 1; i++)
dp[0][i] = (i >= w[0] ? v[0] : 0);
for (int i = 1; i < n; i++)
for (int j = 0; j < wt + 1; j++)
dp[i][j] =
max(dp[i - 1][j], (j >= w[i] ? dp[i - 1][j - w[i]] + v[i] : -1));
cout << dp[n - 1][wt];
} | [] | 965,054 | 965,055 | u389500770 | cpp |
p03163 | #include <bits/stdc++.h>
#include <iostream>
#define rep(i, n) for (i = 0; i < n; i++)
#define pb push_back
#define lli long long int
#define all(v) (v.begin(), v.end())
#define fr first
#define sc second
#define mp make_pair
using namespace std;
int wt[100], val[100];
lli dp[10000][10000];
lli rec(int n, int s) {
if (n == 0 || s == 0)
return dp[n][s] = 0;
if (dp[n][s] != -1)
return dp[n][s];
if (wt[n - 1] > s)
return dp[n][s] = rec(n - 1, s);
return dp[n][s] = max(rec(n - 1, s), val[n - 1] + rec(n - 1, s - wt[n - 1]));
}
int main() {
int n, s, i;
cin >> n >> s;
memset(dp, -1, sizeof(dp));
rep(i, n) cin >> wt[i] >> val[i];
cout << rec(n, s);
}
| #include <bits/stdc++.h>
#include <iostream>
#define rep(i, n) for (i = 0; i < n; i++)
#define pb push_back
#define lli long long int
#define all(v) (v.begin(), v.end())
#define fr first
#define sc second
#define mp make_pair
using namespace std;
int wt[100], val[100];
lli dp[105][100005];
lli rec(int n, int s) {
if (n == 0 || s == 0)
return dp[n][s] = 0;
if (dp[n][s] != -1)
return dp[n][s];
if (wt[n - 1] > s)
return dp[n][s] = rec(n - 1, s);
return dp[n][s] = max(rec(n - 1, s), val[n - 1] + rec(n - 1, s - wt[n - 1]));
}
int main() {
int n, s, i;
cin >> n >> s;
memset(dp, -1, sizeof(dp));
rep(i, n) cin >> wt[i] >> val[i];
cout << rec(n, s);
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 965,062 | 965,063 | u431403516 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
// int dp[1000][1000]={-1};
ll solve(ll i, ll j, ll weig, vector<ll> &weight, vector<ll> &value,
vector<vector<ll>> &dp) {
if (i >= j)
return 0;
if (weig <= 0)
return 0;
if (dp[i][weig] != -1) {
return dp[i][weig];
}
if (weight[i] > weig) {
dp[i][weig] = solve(i + 1, j, weig, weight, value, dp);
} else {
dp[i][weig] =
max(value[i] + solve(i + 1, j, weig - weight[i], weight, value, dp),
solve(i + 1, j, weig, weight, value, dp));
}
// dp[i][weig]=max(value[i] +
// solve(i+1,j,weig-weight[i],weight,value,dp),solve(i+1,j,weig,weight,value,dp));
// cout<<"weight "<<weig<<" dp[i][weig] "<<dp[i][weig]<<endl;
return dp[i][weig];
}
int main() {
ll n, w;
cin >> n >> w;
vector<ll> weight;
vector<ll> value;
// value.push_back(0);
vector<vector<ll>> dp(1000, vector<ll>(1000, -1));
for (ll i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
weight.push_back(a);
value.push_back(b);
}
cout << solve(0, n - 1, w, weight, value, dp) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
ll solve(ll i, ll j, ll weig, vector<ll> &weight, vector<ll> &value,
vector<vector<ll>> &dp) {
if (i > j)
return 0;
if (weig <= 0)
return 0;
if (dp[i][weig] != -1) {
return dp[i][weig];
}
if (weight[i] > weig) {
dp[i][weig] = solve(i + 1, j, weig, weight, value, dp);
} else {
dp[i][weig] =
max(value[i] + solve(i + 1, j, weig - weight[i], weight, value, dp),
solve(i + 1, j, weig, weight, value, dp));
}
return dp[i][weig];
}
int main() {
ll n, w;
cin >> n >> w;
vector<ll> weight;
vector<ll> value;
vector<vector<ll>> dp(101, vector<ll>(100001, -1));
for (ll i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
weight.push_back(a);
value.push_back(b);
}
cout << solve(0, n - 1, w, weight, value, dp) << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.change",
"call.arguments.change"
] | 965,068 | 965,069 | u309322226 | cpp |
p03163 |
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) {
if (a > b)
return a;
return b;
}
int main() {
int N, W;
cin >> N >> W;
int i;
int VW[N][2];
for (i = 0; i < N; i++) {
cin >> VW[i][0] >> VW[i][1];
}
int KS[N + 1][W + 1];
for (int n = 0; n < N + 1; n++) {
for (int w = 0; w < W + 1; w++) {
if (n == 0 || w == 0)
KS[n][w] = 0;
else if (VW[n - 1][0] <= w) {
KS[n][w] =
max(VW[n - 1][1] + KS[n - 1][w - VW[n - 1][0]], KS[n - 1][w]);
} else {
KS[n][w] = KS[n - 1][w];
}
}
}
cout << KS[N][W];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) {
if (a > b)
return a;
return b;
}
int main() {
int N, W;
cin >> N >> W;
int i;
long long int VW[N][2];
for (i = 0; i < N; i++) {
cin >> VW[i][0] >> VW[i][1];
}
long long int KS[N + 1][W + 1];
for (int n = 0; n < N + 1; n++) {
for (int w = 0; w < W + 1; w++) {
if (n == 0 || w == 0)
KS[n][w] = 0;
else if (VW[n - 1][0] <= w) {
KS[n][w] =
max(VW[n - 1][1] + KS[n - 1][w - VW[n - 1][0]], KS[n - 1][w]);
} else {
KS[n][w] = KS[n - 1][w];
}
}
}
cout << KS[N][W];
return 0;
} | [
"variable_declaration.type.widen.change"
] | 965,074 | 965,075 | u245521778 | cpp |
p03163 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FORN(i, j, k) for (int i = j; i < k; i++)
#define FORR(i, j, k) for (int i = j; i >= k; i--)
#define REP(i, n) FORN(i, 0, n)
#define int long long
#define pii pair<int, int>
#define vi vector<int>
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define endl '\n'
const int MODO = 1e+9 + 7;
int N, W;
void solve() {
int w[N], v[N];
REP(i, N) { cin >> w[i] >> v[i]; }
int dp[N + 1][W + 1];
REP(i, N + 1) {
REP(j, W + 1) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else {
dp[i][j] = dp[i - 1][j];
if (j >= w[i]) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i]] + v[i]);
}
}
}
}
cout << dp[N][W] << endl;
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> W;
solve();
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FORN(i, j, k) for (int i = j; i < k; i++)
#define FORR(i, j, k) for (int i = j; i >= k; i--)
#define REP(i, n) FORN(i, 0, n)
#define int long long
#define pii pair<int, int>
#define vi vector<int>
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define endl '\n'
const int MODO = 1e+9 + 7;
int N, W;
void solve() {
int w[N], v[N];
REP(i, N) { cin >> w[i] >> v[i]; }
int dp[N + 1][W + 1];
REP(i, N + 1) {
REP(j, W + 1) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else {
dp[i][j] = dp[i - 1][j];
if (j >= w[i - 1]) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
}
}
}
}
cout << dp[N][W] << endl;
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> W;
solve();
return 0;
}
| [
"control_flow.branch.if.condition.change",
"assignment.change"
] | 965,087 | 965,088 | u426335391 | cpp |
p03163 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator> // std::back_inserter
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
const double PI = acos(-1);
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const int mod = 1000000007;
const ll inf = 1e18 + 1;
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
ll gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); };
// fixed << setprecision(2)
bool Array_check(ll y, ll x, ll d, ll w) {
if (x < 0 || x >= w || y < 0 || y >= d) {
return false;
} else {
return true;
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
//小文字=大文字+32
int main() {
int N, W;
cin >> N >> W;
vector<int> w(N), v(N);
vector<vector<int>> dp(N + 1, vector<int>(W + 1, 0));
rep(i, N) { cin >> w[i] >> v[i]; }
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j >= w[i]) {
chmax(dp[i + 1][j], dp[i][j - w[i]] + v[i]);
chmax(dp[i + 1][j], dp[i][j]);
} else {
chmax(dp[i + 1][j], dp[i][j]);
}
}
}
cout << dp[N][W];
}
| #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator> // std::back_inserter
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
const double PI = acos(-1);
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const int mod = 1000000007;
const ll inf = 1e18 + 1;
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
ll gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); };
// fixed << setprecision(2)
bool Array_check(ll y, ll x, ll d, ll w) {
if (x < 0 || x >= w || y < 0 || y >= d) {
return false;
} else {
return true;
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
//小文字=大文字+32
int main() {
int N, W;
cin >> N >> W;
vector<ll> w(N), v(N);
vector<vector<ll>> dp(N + 1, vector<ll>(W + 1, 0));
rep(i, N) { cin >> w[i] >> v[i]; }
for (int i = 0; i < N; i++) {
for (int j = 0; j <= W; j++) {
if (j >= w[i]) {
chmax(dp[i + 1][j], dp[i][j - w[i]] + v[i]);
chmax(dp[i + 1][j], dp[i][j]);
} else {
chmax(dp[i + 1][j], dp[i][j]);
}
}
}
cout << dp[N][W];
}
| [
"call.arguments.change"
] | 965,095 | 965,096 | u272628953 | cpp |
p03163 | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define Rep(i, n) for (ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll Len(ll n) {
ll s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
ll Sint(ll n) {
ll m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (ll i = s - 1; i >= 0; i--)
m += n / ((ll)pow(10, i)) - (n / ((ll)pow(10, i + 1))) * 10;
return m;
}
ll Svec(vector<ll> v) {
ll n = 0;
for (ll i = 0; i < v.size(); i++)
n += v[i];
return n;
}
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
ll Factorial(ll n) {
ll m = 1;
while (n >= 1)
m *= n, n--;
return m;
}
void runlength(string s, vector<pair<char, ll>> &p) {
ll x = 1;
if (s.size() == 1) {
p.push_back(pair<char, ll>(s[0], 1));
}
for (ll i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) {
x++;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[i], x));
}
} else {
p.push_back(pair<char, ll>(s[i], x));
x = 1;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[s.size() - 1], x));
}
}
}
}
ll COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
const int MAX_N = 100010;
vector<bool> sieve_of_eratosthenes() {
vector<bool> isPrime(MAX_N + 1, true);
for (int i = 2; i <= MAX_N; i++) {
if (isPrime[i]) {
for (int j = 2 * i; j <= MAX_N; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n) {
vector<pint> ans;
for (ll p = 2; p <= sqrt(n); p++) {
if (n % p != 0)
continue;
ll cnt = 0;
while (n % p == 0) {
n /= p;
cnt++;
}
ans.push_back(make_pair(p, cnt));
}
if (n != 1)
ans.push_back(make_pair(n, 1));
return ans;
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
int main() {
IOS;
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
rep(i, n) cin >> weight[i] >> value[i];
ll dp[n + 1][w + 1];
rep(i, w + 1) dp[0][i] = 0;
rep(i, n) {
rep(j, w + 1) {
if (j - weight[i])
dp[i + 1][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[n][w] << endl;
} | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define Rep(i, n) for (ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll Len(ll n) {
ll s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
ll Sint(ll n) {
ll m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (ll i = s - 1; i >= 0; i--)
m += n / ((ll)pow(10, i)) - (n / ((ll)pow(10, i + 1))) * 10;
return m;
}
ll Svec(vector<ll> v) {
ll n = 0;
for (ll i = 0; i < v.size(); i++)
n += v[i];
return n;
}
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
ll Factorial(ll n) {
ll m = 1;
while (n >= 1)
m *= n, n--;
return m;
}
void runlength(string s, vector<pair<char, ll>> &p) {
ll x = 1;
if (s.size() == 1) {
p.push_back(pair<char, ll>(s[0], 1));
}
for (ll i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) {
x++;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[i], x));
}
} else {
p.push_back(pair<char, ll>(s[i], x));
x = 1;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[s.size() - 1], x));
}
}
}
}
ll COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
const int MAX_N = 100010;
vector<bool> sieve_of_eratosthenes() {
vector<bool> isPrime(MAX_N + 1, true);
for (int i = 2; i <= MAX_N; i++) {
if (isPrime[i]) {
for (int j = 2 * i; j <= MAX_N; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n) {
vector<pint> ans;
for (ll p = 2; p <= sqrt(n); p++) {
if (n % p != 0)
continue;
ll cnt = 0;
while (n % p == 0) {
n /= p;
cnt++;
}
ans.push_back(make_pair(p, cnt));
}
if (n != 1)
ans.push_back(make_pair(n, 1));
return ans;
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
int main() {
IOS;
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
rep(i, n) cin >> weight[i] >> value[i];
ll dp[n + 1][w + 1];
rep(i, w + 1) dp[0][i] = 0;
rep(i, n) {
rep(j, w + 1) {
if (j >= weight[i])
dp[i + 1][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[n][w] << endl;
} | [
"control_flow.branch.if.condition.change"
] | 965,109 | 965,110 | u264265458 | cpp |
p03163 | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define Rep(i, n) for (ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll Len(ll n) {
ll s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
ll Sint(ll n) {
ll m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (ll i = s - 1; i >= 0; i--)
m += n / ((ll)pow(10, i)) - (n / ((ll)pow(10, i + 1))) * 10;
return m;
}
ll Svec(vector<ll> v) {
ll n = 0;
for (ll i = 0; i < v.size(); i++)
n += v[i];
return n;
}
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
ll Factorial(ll n) {
ll m = 1;
while (n >= 1)
m *= n, n--;
return m;
}
void runlength(string s, vector<pair<char, ll>> &p) {
ll x = 1;
if (s.size() == 1) {
p.push_back(pair<char, ll>(s[0], 1));
}
for (ll i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) {
x++;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[i], x));
}
} else {
p.push_back(pair<char, ll>(s[i], x));
x = 1;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[s.size() - 1], x));
}
}
}
}
ll COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
const int MAX_N = 100010;
vector<bool> sieve_of_eratosthenes() {
vector<bool> isPrime(MAX_N + 1, true);
for (int i = 2; i <= MAX_N; i++) {
if (isPrime[i]) {
for (int j = 2 * i; j <= MAX_N; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n) {
vector<pint> ans;
for (ll p = 2; p <= sqrt(n); p++) {
if (n % p != 0)
continue;
ll cnt = 0;
while (n % p == 0) {
n /= p;
cnt++;
}
ans.push_back(make_pair(p, cnt));
}
if (n != 1)
ans.push_back(make_pair(n, 1));
return ans;
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
int main() {
IOS;
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
rep(i, n) cin >> weight[i] >> value[i];
ll dp[n + 1][w + 1];
rep(i, w + 1) dp[0][i] = 0;
rep(i, n) {
rep(j, w + 1) {
if (j - weight[i])
dp[i + 1][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[n][w] << endl;
} | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define Rep(i, n) for (ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll Len(ll n) {
ll s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
ll Sint(ll n) {
ll m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (ll i = s - 1; i >= 0; i--)
m += n / ((ll)pow(10, i)) - (n / ((ll)pow(10, i + 1))) * 10;
return m;
}
ll Svec(vector<ll> v) {
ll n = 0;
for (ll i = 0; i < v.size(); i++)
n += v[i];
return n;
}
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
ll Factorial(ll n) {
ll m = 1;
while (n >= 1)
m *= n, n--;
return m;
}
void runlength(string s, vector<pair<char, ll>> &p) {
ll x = 1;
if (s.size() == 1) {
p.push_back(pair<char, ll>(s[0], 1));
}
for (ll i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) {
x++;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[i], x));
}
} else {
p.push_back(pair<char, ll>(s[i], x));
x = 1;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[s.size() - 1], x));
}
}
}
}
ll COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
const int MAX_N = 100010;
vector<bool> sieve_of_eratosthenes() {
vector<bool> isPrime(MAX_N + 1, true);
for (int i = 2; i <= MAX_N; i++) {
if (isPrime[i]) {
for (int j = 2 * i; j <= MAX_N; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n) {
vector<pint> ans;
for (ll p = 2; p <= sqrt(n); p++) {
if (n % p != 0)
continue;
ll cnt = 0;
while (n % p == 0) {
n /= p;
cnt++;
}
ans.push_back(make_pair(p, cnt));
}
if (n != 1)
ans.push_back(make_pair(n, 1));
return ans;
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
int main() {
IOS;
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
rep(i, n) cin >> weight[i] >> value[i];
ll dp[n + 1][w + 1];
rep(i, w + 1) dp[0][i] = 0;
rep(i, n) {
rep(j, w + 1) {
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[n][w] << endl;
} | [
"control_flow.branch.if.condition.change"
] | 965,109 | 965,111 | u264265458 | cpp |
p03163 | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define Rep(i, n) for (ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll Len(ll n) {
ll s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
ll Sint(ll n) {
ll m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (ll i = s - 1; i >= 0; i--)
m += n / ((ll)pow(10, i)) - (n / ((ll)pow(10, i + 1))) * 10;
return m;
}
ll Svec(vector<ll> v) {
ll n = 0;
for (ll i = 0; i < v.size(); i++)
n += v[i];
return n;
}
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
ll Factorial(ll n) {
ll m = 1;
while (n >= 1)
m *= n, n--;
return m;
}
void runlength(string s, vector<pair<char, ll>> &p) {
ll x = 1;
if (s.size() == 1) {
p.push_back(pair<char, ll>(s[0], 1));
}
for (ll i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) {
x++;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[i], x));
}
} else {
p.push_back(pair<char, ll>(s[i], x));
x = 1;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[s.size() - 1], x));
}
}
}
}
ll COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
const int MAX_N = 100010;
vector<bool> sieve_of_eratosthenes() {
vector<bool> isPrime(MAX_N + 1, true);
for (int i = 2; i <= MAX_N; i++) {
if (isPrime[i]) {
for (int j = 2 * i; j <= MAX_N; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n) {
vector<pint> ans;
for (ll p = 2; p <= sqrt(n); p++) {
if (n % p != 0)
continue;
ll cnt = 0;
while (n % p == 0) {
n /= p;
cnt++;
}
ans.push_back(make_pair(p, cnt));
}
if (n != 1)
ans.push_back(make_pair(n, 1));
return ans;
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
int main() {
IOS;
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
rep(i, n) cin >> weight[i] >> value[i];
ll dp[n + 1][w + 1];
rep(i, w) dp[0][i] = 0;
rep(i, n) {
rep(j, w + 1) {
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i][j - weight[i]] + value[i], dp[i][j]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[n][w] << endl;
} | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define Rep(i, n) for (ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll Len(ll n) {
ll s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
ll Sint(ll n) {
ll m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (ll i = s - 1; i >= 0; i--)
m += n / ((ll)pow(10, i)) - (n / ((ll)pow(10, i + 1))) * 10;
return m;
}
ll Svec(vector<ll> v) {
ll n = 0;
for (ll i = 0; i < v.size(); i++)
n += v[i];
return n;
}
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
ll Factorial(ll n) {
ll m = 1;
while (n >= 1)
m *= n, n--;
return m;
}
void runlength(string s, vector<pair<char, ll>> &p) {
ll x = 1;
if (s.size() == 1) {
p.push_back(pair<char, ll>(s[0], 1));
}
for (ll i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) {
x++;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[i], x));
}
} else {
p.push_back(pair<char, ll>(s[i], x));
x = 1;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[s.size() - 1], x));
}
}
}
}
ll COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
const int MAX_N = 100010;
vector<bool> sieve_of_eratosthenes() {
vector<bool> isPrime(MAX_N + 1, true);
for (int i = 2; i <= MAX_N; i++) {
if (isPrime[i]) {
for (int j = 2 * i; j <= MAX_N; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n) {
vector<pint> ans;
for (ll p = 2; p <= sqrt(n); p++) {
if (n % p != 0)
continue;
ll cnt = 0;
while (n % p == 0) {
n /= p;
cnt++;
}
ans.push_back(make_pair(p, cnt));
}
if (n != 1)
ans.push_back(make_pair(n, 1));
return ans;
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
int main() {
IOS;
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
rep(i, n) cin >> weight[i] >> value[i];
ll dp[n + 1][w + 1];
rep(j, w + 1) dp[0][j] = 0;
rep(i, n) {
rep(j, w + 1) {
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i][j - weight[i]] + value[i], dp[i][j]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[n][w] << endl;
} | [
"assignment.variable.change",
"identifier.change",
"call.arguments.change",
"assignment.change",
"variable_access.subscript.index.change"
] | 965,112 | 965,113 | u264265458 | cpp |
p03163 | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define Rep(i, n) for (ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll Len(ll n) {
ll s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
ll Sint(ll n) {
ll m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (ll i = s - 1; i >= 0; i--)
m += n / ((ll)pow(10, i)) - (n / ((ll)pow(10, i + 1))) * 10;
return m;
}
ll Svec(vector<ll> v) {
ll n = 0;
for (ll i = 0; i < v.size(); i++)
n += v[i];
return n;
}
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
ll Factorial(ll n) {
ll m = 1;
while (n >= 1)
m *= n, n--;
return m;
}
void runlength(string s, vector<pair<char, ll>> &p) {
ll x = 1;
if (s.size() == 1) {
p.push_back(pair<char, ll>(s[0], 1));
}
for (ll i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) {
x++;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[i], x));
}
} else {
p.push_back(pair<char, ll>(s[i], x));
x = 1;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[s.size() - 1], x));
}
}
}
}
ll COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
const int MAX_N = 100010;
vector<bool> sieve_of_eratosthenes() {
vector<bool> isPrime(MAX_N + 1, true);
for (int i = 2; i <= MAX_N; i++) {
if (isPrime[i]) {
for (int j = 2 * i; j <= MAX_N; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n) {
vector<pint> ans;
for (ll p = 2; p <= sqrt(n); p++) {
if (n % p != 0)
continue;
ll cnt = 0;
while (n % p == 0) {
n /= p;
cnt++;
}
ans.push_back(make_pair(p, cnt));
}
if (n != 1)
ans.push_back(make_pair(n, 1));
return ans;
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
int main() {
IOS;
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
rep(i, n) cin >> weight[i] >> value[i];
ll dp[n + 1][w + 1];
rep(i, w) dp[0][i] = 0;
rep(i, n) {
rep(j, w + 1) {
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i][j - weight[i]] + value[i], dp[i][j]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[n][w] << endl;
} | /*Function Template*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define Rep(i, n) for (ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll Len(ll n) {
ll s = 0;
while (n != 0)
s++, n /= 10;
return s;
}
ll Sint(ll n) {
ll m = 0, s = 0, a = n;
while (a != 0)
s++, a /= 10;
for (ll i = s - 1; i >= 0; i--)
m += n / ((ll)pow(10, i)) - (n / ((ll)pow(10, i + 1))) * 10;
return m;
}
ll Svec(vector<ll> v) {
ll n = 0;
for (ll i = 0; i < v.size(); i++)
n += v[i];
return n;
}
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
ll Factorial(ll n) {
ll m = 1;
while (n >= 1)
m *= n, n--;
return m;
}
void runlength(string s, vector<pair<char, ll>> &p) {
ll x = 1;
if (s.size() == 1) {
p.push_back(pair<char, ll>(s[0], 1));
}
for (ll i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) {
x++;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[i], x));
}
} else {
p.push_back(pair<char, ll>(s[i], x));
x = 1;
if (i == s.size() - 2) {
p.push_back(pair<char, ll>(s[s.size() - 1], x));
}
}
}
}
ll COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
const int MAX_N = 100010;
vector<bool> sieve_of_eratosthenes() {
vector<bool> isPrime(MAX_N + 1, true);
for (int i = 2; i <= MAX_N; i++) {
if (isPrime[i]) {
for (int j = 2 * i; j <= MAX_N; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n) {
vector<pint> ans;
for (ll p = 2; p <= sqrt(n); p++) {
if (n % p != 0)
continue;
ll cnt = 0;
while (n % p == 0) {
n /= p;
cnt++;
}
ans.push_back(make_pair(p, cnt));
}
if (n != 1)
ans.push_back(make_pair(n, 1));
return ans;
}
/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
int main() {
IOS;
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
rep(i, n) cin >> weight[i] >> value[i];
ll dp[n + 1][w + 1];
rep(i, w + 1) dp[0][i] = 0;
rep(i, n) {
rep(j, w + 1) {
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i][j - weight[i]] + value[i], dp[i][j]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[n][w] << endl;
} | [
"assignment.change"
] | 965,112 | 965,114 | u264265458 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ll long long int
#define mp make_pair
#define S second
#define F first
ll mod = 1e9 + 7;
#define input_from_file freopen("input.txt", "r", stdin);
int main() {
// input_from_file;
ll n, k, sum = 0;
;
cin >> n >> k;
vector<ll> wt(n + 1, 0), cost(n + 1, 0), dp(k + 1, 0);
ll ans = 0;
for (ll i = 1; i < n; i++) {
cin >> wt[i] >> cost[i];
sum += cost[i];
}
for (ll i = 1; i <= n; i++) {
for (ll j = k; j >= 1; j--) {
if (wt[i] > j)
continue;
dp[j] = max(dp[j], dp[j - wt[i]] + cost[i]);
ans = max(ans, dp[j]);
}
}
// for(ll i=0;i<=k;i++) cout<<dp[i]<<" ";cout<<endl;
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ll long long int
#define mp make_pair
#define S second
#define F first
ll mod = 1e9 + 7;
#define input_from_file freopen("input.txt", "r", stdin);
int main() {
// input_from_file;
ll n, k, sum = 0;
;
cin >> n >> k;
vector<ll> wt(n + 1, 0), cost(n + 1, 0), dp(k + 1, 0);
ll ans = 0;
for (ll i = 1; i <= n; i++) {
cin >> wt[i] >> cost[i];
sum += cost[i];
}
for (ll i = 1; i <= n; i++) {
for (ll j = k; j >= 1; j--) {
if (wt[i] > j)
continue;
dp[j] = max(dp[j], dp[j - wt[i]] + cost[i]);
ans = max(ans, dp[j]);
}
}
// for(ll i=0;i<=k;i++) cout<<dp[i]<<" ";cout<<endl;
cout << ans;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 965,117 | 965,118 | u066630187 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.