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 8
values |
|---|---|---|---|---|---|---|---|
p03163 | #include <bits/stdc++.h>
#define ll long long
#define lsb(x) (x & -x)
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("a.in", "r", stdin);
int n, w;
cin >> n >> w;
vector<int> dp(w + 1, 0);
vector<int> a(n + 1, 0);
vector<int> b(n + 1, 0);
for ... | #include <bits/stdc++.h>
#define ll long long
#define lsb(x) (x & -x)
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("a.in", "r", stdin);
int n, w;
cin >> n >> w;
vector<ll> dp(w + 1, 0);
vector<int> a(n + 1, 0);
vector<ll> b(n + 1, 0);
for (i... | [
"variable_declaration.type.change"
] | 970,957 | 970,958 | u088237968 | cpp |
p03164 | // {{{
#include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using n... | // {{{
#include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using n... | [
"literal.number.change",
"assignment.variable.change",
"call.arguments.change",
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 970,970 | 970,971 | u367602070 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const long long k = 1e11;
#define ll long long
void min_s(ll &a, ll b) { a = min(a, b); }
int main() {
ll n, m;
cin >> n >> m;
ll w[n], p[n];
ll sum = 0;
for (ll i = 0; i < n; i++) {
cin >> w[i] >> p[i];
sum += p[i];
}
vector<ll> v(sum + 1, k);
v[0... | #include <bits/stdc++.h>
using namespace std;
const long long k = 1e11;
#define ll long long
void min_s(ll &a, ll b) { a = min(a, b); }
int main() {
ll n, m;
cin >> n >> m;
ll w[n], p[n];
ll sum = 0;
for (ll i = 0; i < n; i++) {
cin >> w[i] >> p[i];
sum += p[i];
}
vector<ll> v(sum + 1, k);
v[0... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 970,974 | 970,975 | u694722603 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const long long k = 1e11;
#define ll long long
void min_s(ll &a, ll b) { a = min(a, b); }
int main() {
ll n, m;
cin >> n >> m;
ll w[n], p[n];
ll sum = 0;
for (ll i = 0; i < n; i++) {
cin >> w[i] >> p[i];
sum += p[i];
}
vector<ll> v(sum + 1, k);
v[0... | #include <bits/stdc++.h>
using namespace std;
const long long k = 1e11;
#define ll long long
void min_s(ll &a, ll b) { a = min(a, b); }
int main() {
ll n, m;
cin >> n >> m;
ll w[n], p[n];
ll sum = 0;
for (ll i = 0; i < n; i++) {
cin >> w[i] >> p[i];
sum += p[i];
}
vector<ll> v(sum + 1, k);
v[0... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 970,976 | 970,975 | u694722603 | cpp |
p03164 | #include <bits/stdc++.h>
#define ll long long int
#define pb push_back
#define s second
#define f first
#define MOD 1000000007
// #define
using namespace std;
const ll INF = 1e18L + 5;
int main() {
ll a, b, i, j, n, w, val = 0;
vector<pair<ll, ll>> v;
cin >> n >> w;
for (i = 0; i < n; i++) {
cin >> a >> b... | #include <bits/stdc++.h>
#define ll long long int
#define pb push_back
#define s second
#define f first
#define MOD 1000000007
// #define
using namespace std;
const ll INF = 1e18L + 5;
int main() {
ll a, b, i, j, n, w, val = 0;
vector<pair<ll, ll>> v;
cin >> n >> w;
for (i = 0; i < n; i++) {
cin >> a >> b... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 970,988 | 970,989 | u460223842 | cpp |
p03164 | #include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)n; ++i)
#define rfor(i, n) for (int i = n - 1; i >= 0; --i)
#define rmod(x, y) (((x % y) + y) % y)
using namespace std;
typedef vector<int>::iterator vit;
typedef unsigned int uint;
typedef unsigned short ushort;
typedef long long ll;
const int MAXN =... | #include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)n; ++i)
#define rfor(i, n) for (int i = n - 1; i >= 0; --i)
#define rmod(x, y) (((x % y) + y) % y)
using namespace std;
typedef vector<int>::iterator vit;
typedef unsigned int uint;
typedef unsigned short ushort;
typedef long long ll;
const int MAXN =... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 970,998 | 970,999 | u558825435 | cpp |
p03164 | // Subhash Suman
// Description :
#include <bits/stdc++.h>
#define ll long long int
#define pll pair<ll, ll>
#define pii pair<int, int>
using namespace std;
const int N = 105, V = 1e5 + 5, INF = 1e6;
ll n, w, dp[N][V], arr1[N], arr2[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NUL... | // Subhash Suman
// Description :
#include <bits/stdc++.h>
#define ll long long int
#define pll pair<ll, ll>
#define pii pair<int, int>
using namespace std;
const int N = 105, V = 1e5 + 5;
ll INF = 1e10;
ll n, w, dp[N][V], arr1[N], arr2[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie... | [
"literal.number.change",
"variable_declaration.value.change"
] | 971,000 | 971,001 | u680559271 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[102][100005];
int main() {
ll n, W;
cin >> n >> W;
ll va[n + 1], wt[n + 1];
for (int i = 1; i <= n; i++)
cin >> wt[i] >> va[i];
for (int i = 0; i <= n; i++)
for (int j = 1; j <= 100000; j++)
dp[i][j] = INT_MAX;
ll an... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[102][100005];
int main() {
ll n, W;
cin >> n >> W;
ll va[n + 1], wt[n + 1];
for (int i = 1; i <= n; i++)
cin >> wt[i] >> va[i];
for (int i = 0; i <= n; i++)
for (int j = 1; j <= 100000; j++)
dp[i][j] = INT_MAX;
ll an... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 971,002 | 971,003 | u109008163 | cpp |
p03164 | #include <bits/stdc++.h>
#define itn int
#define REP(i, n) for (int i = 0; i < (n); i++)
#define IREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define REPEACH(itr, k) for (autaaaaaaaaaaaaaaaaaaaaaaao && itr : k)
#define all(v) v.begin(), v.end()
using namespace std;
ty... | #include <bits/stdc++.h>
#define itn int
#define REP(i, n) for (int i = 0; i < (n); i++)
#define IREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define REPEACH(itr, k) for (autaaaaaaaaaaaaaaaaaaaaaaao && itr : k)
#define all(v) v.begin(), v.end()
using namespace std;
ty... | [
"expression.operation.binary.remove",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 971,012 | 971,013 | u118875091 | cpp |
p03164 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int f[200011], n, m, w[110], c[110], ans;
int main() {
memset(f, 0x7f, sizeof(f));
cin >> n >> m;
for (int i = 1; i <= n; i++)
cin >> w[i] >> c[i];
f[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 200010; j >= c[i]; j--) {
f... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll f[200011], n, m, w[110], c[110], ans;
int main() {
memset(f, 0x7f, sizeof(f));
cin >> n >> m;
for (int i = 1; i <= n; i++)
cin >> w[i] >> c[i];
f[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 200010; j >= c[i]; j--) {
f[... | [
"variable_declaration.type.change"
] | 971,018 | 971,019 | u247270112 | cpp |
p03164 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
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;
}
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
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;
}
... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.value.change",
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 971,022 | 971,023 | u771806944 | cpp |
p03164 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return o... | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return o... | [
"variable_declaration.type.change"
] | 971,024 | 971,025 | u171804186 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
vector<long long> dp(N * 1e3 + 1, INT_MAX / 2);
dp[0] = 0;
for (int i = 0; i < N; i++) {
int w, v;
cin >> w >> v;
vector<long long> nextdp(dp);
for (int j = 0; j < dp.size(); j++) {
if (j + v < dp.siz... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
vector<long long> dp(N * 1e3 + 1, INT_MAX / 2);
dp[0] = 0;
for (int i = 0; i < N; i++) {
int w, v;
cin >> w >> v;
vector<long long> nextdp(dp);
for (int j = 0; j < dp.size(); j++) {
if (j + v < dp.siz... | [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 971,030 | 971,031 | u544437817 | cpp |
p03164 | #include <iostream>
using namespace std;
const int maxn = 100 + 10;
const int maxnn = 1e5 + 10;
long long n, W, now = 1, pre;
long long dp[maxnn];
long long ans;
long long v[maxn], w[maxnn];
int main() {
cin >> n >> W;
for (int i = 1; i <= n; i++)
cin >> w[i] >> v[i];
for (int i = 1; i < maxnn; i++) {
... | #include <iostream>
using namespace std;
const int maxn = 100 + 10;
const int maxnn = 1e5 + 10;
long long n, W, now = 1, pre;
long long dp[maxnn];
long long ans;
long long v[maxn], w[maxnn];
int main() {
cin >> n >> W;
for (int i = 1; i <= n; i++)
cin >> w[i] >> v[i];
for (int i = 1; i < maxnn; i++) {
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,036 | 971,037 | u962571628 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pii;
void solve() {
ll n, tw;
cin >> n >> tw;
vector<ll> w(n), v(n);
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
ll total_val_possible = 0;
for (int val : v)
total_val_possible += val;
vector<ll> dp(t... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pii;
void solve() {
ll n, tw;
cin >> n >> tw;
vector<ll> w(n), v(n);
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
ll total_val_possible = 0;
for (int val : v)
total_val_possible += val;
vector<ll> dp(t... | [
"literal.number.change",
"call.arguments.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,060 | 971,061 | u958501859 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pii;
void solve() {
int n, tw;
cin >> n >> tw;
vector<int> w(n), v(n);
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
ll total_val_possible = 0;
for (int val : v)
total_val_possible += val;
vector<ll> dp... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pii;
void solve() {
ll n, tw;
cin >> n >> tw;
vector<ll> w(n), v(n);
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
ll total_val_possible = 0;
for (int val : v)
total_val_possible += val;
vector<ll> dp(t... | [
"variable_declaration.type.change",
"literal.number.change",
"call.arguments.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,062 | 971,061 | u958501859 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define INF 2000000000
typedef long long ll;
ll n, w, val[200], weight[200], dp[100010][200];
ll f(ll cur_val, ll cur_i) {
// cout << "inside with: " << cur_val << " " << cur_i << endl;
if (cur_val < 0) {
// cout << "negative!" << endl;
return INF... | #include <bits/stdc++.h>
using namespace std;
#define INF 2000000000
typedef long long ll;
ll n, w, val[200], weight[200], dp[100010][200];
ll f(ll cur_val, ll cur_i) {
// cout << "inside with: " << cur_val << " " << cur_i << endl;
if (cur_val < 0) {
// cout << "negative!" << endl;
return INF... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 971,073 | 971,074 | u509794431 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define INF 2000000000
typedef long long ll;
ll n, w, val[200], weight[200], dp[100010][200];
ll f(ll cur_val, ll cur_i) {
// cout << "inside with: " << cur_val << " " << cur_i << endl;
if (cur_val < 0) {
// cout << "negative!" << endl;
return INF... | #include <bits/stdc++.h>
using namespace std;
#define INF 2000000000
typedef long long ll;
ll n, w, val[200], weight[200], dp[100010][200];
ll f(ll cur_val, ll cur_i) {
// cout << "inside with: " << cur_val << " " << cur_i << endl;
if (cur_val < 0) {
// cout << "negative!" << endl;
return INF... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 971,075 | 971,074 | u509794431 | cpp |
p03164 | #include <iostream>
#include <vector>
using namespace std;
constexpr auto INF = 100000000;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, W;
cin >> N >> W;
vector<int> weight(N);
vector<int> value(N);
for (int i = 0; i < N; ++i)
cin >> weight[i] >> value[i];
vector<vector<long lo... | #include <iostream>
#include <vector>
using namespace std;
constexpr auto INF = 100000000001;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, W;
cin >> N >> W;
vector<int> weight(N);
vector<int> value(N);
for (int i = 0; i < N; ++i)
cin >> weight[i] >> value[i];
vector<vector<long... | [
"literal.number.change",
"variable_declaration.value.change"
] | 971,078 | 971,079 | u616522759 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int const maxsize = 100005;
int weight[maxsize], cost[maxsize];
long long int dp[103][maxsize];
int main() {
int n, w;
cin >> n >> w;
for (int x = 1; x <= n; x++)
cin >> weight[x] >> cost[x];
memset(dp, 63, sizeof(dp));
int ans = 0;
// for(int x=0;x<=100... | #include <bits/stdc++.h>
using namespace std;
int const maxsize = 100005;
int weight[maxsize], cost[maxsize];
long long int dp[103][maxsize];
int main() {
int n, w;
cin >> n >> w;
for (int x = 1; x <= n; x++)
cin >> weight[x] >> cost[x];
memset(dp, 63, sizeof(dp));
int ans = 0;
// for(int x=0;x<=100... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"assignment.change"
] | 971,083 | 971,084 | u426169581 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll INF = 1e18 + 5;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
int sumvalue = 0;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
sum... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll INF = 1e18 + 5;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
int sumvalue = 0;
for (int i = 0; i < n; i++) {
cin >> weight[i] >> value[i];
sum... | [
"assignment.change"
] | 971,105 | 971,106 | u288989709 | cpp |
p03163 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
vector<int> weight(N), value(N);
for (int i = 0; i < N; ++i) {
cin >> weight[i] >> value[i];
}
vector<int> dp(W + 1);
for (int i = 0; i < N; ++i) {
for (int j = W; j >= weight[i]; ... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
vector<int> weight(N), value(N);
for (int i = 0; i < N; ++i) {
cin >> weight[i] >> value[i];
}
vector<long long> dp(W + 1);
for (int i = 0; i < N; ++i) {
for (int j = W; j >= weigh... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 971,123 | 971,124 | u837745858 | cpp |
p03163 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utilit... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utilit... | [] | 971,125 | 971,126 | u864537413 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll, ll> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
ll n, dp[105][100005], v[105], w[105], m;
int main(void) {
scanf("%lld%lld", &n, &m);
for (int i = 1... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll, ll> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
ll n, dp[105][100005], v[105], w[105], m;
int main(void) {
scanf("%lld%lld", &n, &m);
for (int i = 1... | [] | 971,127 | 971,128 | u743900647 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll, ll> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
ll n, dp[100][100005], v[105], w[105], m;
int main(void) {
scanf("%lld%lld", &n, &m);
for (int i = 1... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll, ll> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
ll n, dp[105][100005], v[105], w[105], m;
int main(void) {
scanf("%lld%lld", &n, &m);
for (int i = 1... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 971,129 | 971,128 | u743900647 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int n, k, w[110], v[110];
ll f[100010];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &w[i], &v[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = k; j >= w[i]; j--) {
f[j] = max(f[j], f[i] + v[i]... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int n, k, w[110], v[110];
ll f[100010];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &w[i], &v[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = k; j >= w[i]; j--) {
f[j] = max(f[j], f[j - w[i]]... | [
"assignment.change",
"call.arguments.change"
] | 971,136 | 971,137 | u195756521 | cpp |
p03163 | #include <algorithm>
#include <stdio.h>
using namespace std;
int N, W;
long long D[100100];
int main() {
scanf("%d %d", &N, &W);
for (int i = 1; i <= N; i++) {
int w, v;
scanf("%d %d", &w, &v);
for (int j = W - w; j >= 0; j--)
if (D[j + w] < D[j] + v)
D[j + w] = D[j] + v;
}
printf("... | #include <algorithm>
#include <stdio.h>
using namespace std;
int N, W;
long long D[100100];
int main() {
scanf("%d %d", &N, &W);
for (int i = 1; i <= N; i++) {
int w, v;
scanf("%d %d", &w, &v);
for (int j = W - w; j >= 0; j--)
if (D[j + w] < D[j] + v)
D[j + w] = D[j] + v;
}
printf("... | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"io.output.change"
] | 971,140 | 971,141 | u233632872 | cpp |
p03163 | #include <algorithm>
#include <stdio.h>
using namespace std;
int N, W, D[100100];
int main() {
scanf("%d %d", &N, &W);
for (int i = 1; i <= N; i++) {
int w, v;
scanf("%d %d", &w, &v);
for (int j = W - w; j >= 0; j--)
if (D[j + w] < D[j] + v)
D[j + w] = D[j] + v;
}
printf("%d\n", D[N... | #include <algorithm>
#include <stdio.h>
using namespace std;
int N, W;
long long D[100100];
int main() {
scanf("%d %d", &N, &W);
for (int i = 1; i <= N; i++) {
int w, v;
scanf("%d %d", &w, &v);
for (int j = W - w; j >= 0; j--)
if (D[j + w] < D[j] + v)
D[j + w] = D[j] + v;
}
printf("... | [
"literal.string.change",
"call.arguments.change",
"io.output.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 971,142 | 971,141 | u233632872 | cpp |
p03163 | #include <iostream>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, w;
cin >> n >> w;
int dp[w + 1];
for (int i = 0; i <= w; i++)
dp[i] = 0;
for (int i = 0; i < n; i++) {
int wi, v;
cin >> wi >> v;
for (int j = w; j >= wi; j--)
dp[j] = max(dp[... | #include <iostream>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, w;
cin >> n >> w;
long long dp[w + 1];
for (int i = 0; i <= w; i++)
dp[i] = 0;
for (int i = 0; i < n; i++) {
int wi, v;
cin >> wi >> v;
for (int j = w; j >= wi; j--)
dp[j] = m... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 971,145 | 971,146 | u538129823 | cpp |
p03164 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
const int MOD = 1000000007;
const int INF_32 = 1LL << 30;
const int64_t INF_64 = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {... | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
const int MOD = 1000000007;
const int INF_32 = 1LL << 30;
const int64_t INF_64 = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,149 | 971,150 | u715366261 | cpp |
p03164 | #include <bits/stdc++.h>
#define int long long
#define fi first
#define se second
using namespace std;
const int N = 1e5 + 4;
int n, w, W[200], V[200], dp[200][N], mx;
int32_t main() {
// freopen("haybales.in", "r", stdin ) ;
// freopen("haybales.out", "w", stdout ) ;
cin >> n >> w;
for (int i = 1; i <= n; i... | #include <bits/stdc++.h>
#define int long long
#define fi first
#define se second
using namespace std;
const int N = 1e5 + 4;
int n, w, W[200], V[200], dp[200][N], mx;
int32_t main() {
// freopen("haybales.in", "r", stdin ) ;
// freopen("haybales.out", "w", stdout ) ;
cin >> n >> w;
for (int i = 1; i <= n; ... | [
"literal.number.change",
"assignment.value.change",
"assignment.change"
] | 971,161 | 971,162 | u089230684 | cpp |
p03164 | #include <bits/stdc++.h>
// freopen("transmitters.in","r",stdin);
// cout<<fixed<<setprecision(6)<<n<<endl;
// transform(s.begin(), s.end(), s.begin(), ::tolower);
// double PI=3.14159265359,c=0;
#define all(v) v.begin(), v.end()
#define endl '\n'
#define ll long long
//#define f(n) for(int i=;i<n;i++)
double PI = acos... | #include <bits/stdc++.h>
// freopen("transmitters.in","r",stdin);
// cout<<fixed<<setprecision(6)<<n<<endl;
// transform(s.begin(), s.end(), s.begin(), ::tolower);
// double PI=3.14159265359,c=0;
#define all(v) v.begin(), v.end()
#define endl '\n'
#define ll long long
//#define f(n) for(int i=;i<n;i++)
double PI = acos... | [
"function.return_value.change"
] | 971,165 | 971,166 | u089230684 | cpp |
p03164 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define _USE_MATH_DEFINES
#include <math.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define NIL = -1;
ll gcd(long long a, long long b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { a ... | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define _USE_MATH_DEFINES
#include <math.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define NIL = -1;
ll gcd(long long a, long long b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { a ... | [
"assignment.change"
] | 971,169 | 971,170 | u111600809 | cpp |
p03164 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#inclu... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#inclu... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 971,194 | 971,195 | u771710924 | cpp |
p03164 | // https://atcoder.jp/contests/dp/tasks/dp_e
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
typedef vector<ll> vi;
typedef vector<vi> vii;
#define rep(i, k, n) for (ll i = k; i < (int)(n); i++)
int main() {
ll n, w;
ll ans;
cin >> n >> w;
vi ws(n + 1);
vi vs(n + 1);
ll totalVal = 0;... | // https://atcoder.jp/contests/dp/tasks/dp_e
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
typedef vector<ll> vi;
typedef vector<vi> vii;
#define rep(i, k, n) for (ll i = k; i < (int)(n); i++)
int main() {
ll n, w;
ll ans = 0;
cin >> n >> w;
vi ws(n + 1);
vi vs(n + 1);
ll totalVal ... | [
"variable_declaration.value.change",
"literal.number.change",
"call.arguments.change"
] | 971,215 | 971,216 | u657818166 | cpp |
p03164 | // https://atcoder.jp/contests/dp/tasks/dp_e
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
typedef vector<ll> vi;
typedef vector<vi> vii;
#define rep(i, k, n) for (ll i = k; i < (int)(n); i++)
int main() {
ll n, w;
ll ans;
cin >> n >> w;
vi ws(n + 1);
vi vs(n + 1);
ll totalVal = 0;... | // https://atcoder.jp/contests/dp/tasks/dp_e
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
typedef vector<ll> vi;
typedef vector<vi> vii;
#define rep(i, k, n) for (ll i = k; i < (int)(n); i++)
int main() {
ll n, w;
ll ans = 0;
cin >> n >> w;
vi ws(n + 1);
vi vs(n + 1);
ll totalVal ... | [
"variable_declaration.value.change"
] | 971,215 | 971,217 | u657818166 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
constexpr int INF = 1 << 29;
constexpr ll MOD = ll(1e9 + 7);
constexpr int vmax = ... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
constexpr int INF = 1 << 30;
constexpr ll MOD = ll(1e9 + 7);
constexpr int vmax = ... | [
"literal.number.change",
"expression.operation.binary.change"
] | 971,222 | 971,223 | u728082661 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define ll long long
#define pb push_back
#define mk make_pair
#define pii pair<int, int>
#define vi vector<int>
#define all(x) (x).begin(), (x).end()
#define umap unordered_map
#define uset unordered_set
#define mod 1000000007
#define imax INT_MAX
#define... | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define ll long long
#define pb push_back
#define mk make_pair
#define pii pair<int, int>
#define vi vector<int>
#define all(x) (x).begin(), (x).end()
#define umap unordered_map
#define uset unordered_set
#define mod 1000000007
#define imax INT_MAX
#define... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 971,231 | 971,232 | u157659681 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
struct item {
// weight, value
ll w = 0, v = 0;
item(ll a = 0, ll b = 0) {
w = a;
v = b;
}
};
const ll INF = 1e15;
ll n, cap;
vector<item... | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
struct item {
// weight, value
ll w = 0, v = 0;
item(ll a = 0, ll b = 0) {
w = a;
v = b;
}
};
const ll INF = 1e15;
ll n, cap;
vector<item... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,241 | 971,240 | u281053019 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
struct item {
// weight, value
ll w = 0, v = 0;
item(ll a = 0, ll b = 0) {
w = a;
v = b;
}
};
const ll INF = 1e15;
ll n, cap;
vector<item... | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
struct item {
// weight, value
ll w = 0, v = 0;
item(ll a = 0, ll b = 0) {
w = a;
v = b;
}
};
const ll INF = 1e15;
ll n, cap;
vector<item... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,242 | 971,240 | u281053019 | cpp |
p03164 | #include <bits/stdc++.h>
#include <iostream>
#include <string>
#define ll long long int
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define phi 3.1415926535
#define fastio() \
ios_base::sync_with_stdio(false); ... | #include <bits/stdc++.h>
#include <iostream>
#include <string>
#define ll long long int
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define phi 3.1415926535
#define fastio() \
ios_base::sync_with_stdio(false); ... | [
"literal.number.change",
"assignment.value.change"
] | 971,263 | 971,264 | u252292568 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define all(c) c.begin(), c.end()
#define REP(i, a, b) for (int i = a; i <= b; ++i)
#define tr(container, it) \
for (auto it = container.begin(); it != container.end(); ++it)
typedef long long ll;
typedef vector<int> vi... | #include <bits/stdc++.h>
using namespace std;
#define all(c) c.begin(), c.end()
#define REP(i, a, b) for (int i = a; i <= b; ++i)
#define tr(container, it) \
for (auto it = container.begin(); it != container.end(); ++it)
typedef long long ll;
typedef vector<int> vi... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,276 | 971,277 | u488777116 | cpp |
p03164 | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
#define ll long long int
#define mp make_pair
#define pb push_back
#define vi vector<int>
using namespace std;
struct objects {
int weight, value;
};
ll solve() {
int n, w;
cin >> n >> w;
objects object[n];
int totalvalue = 0;
f... | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
#define ll long long int
#define mp make_pair
#define pb push_back
#define vi vector<int>
using namespace std;
struct objects {
int weight, value;
};
ll solve() {
int n, w;
cin >> n >> w;
objects object[n];
int totalvalue = 0;
f... | [] | 971,284 | 971,285 | u422679050 | cpp |
p03164 | /*Stay true to yourself, yet always be open to learn. Work hard, and never give
up on your dreams, even when nobody else believes they can come true but you.
These are not cliches but real tools you need no matter what you do in life to
stay focused on your path.
*/
/*Pppppppp UU UU CCCCCCCC CCCCCCCC ... | /*Stay true to yourself, yet always be open to learn. Work hard, and never give
up on your dreams, even when nobody else believes they can come true but you.
These are not cliches but real tools you need no matter what you do in life to
stay focused on your path.
*/
/*Pppppppp UU UU CCCCCCCC CCCCCCCC ... | [
"literal.number.change",
"assignment.value.change",
"control_flow.branch.if.condition.change"
] | 971,300 | 971,301 | u985702351 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pii pair<int, int>
#define pqi priority_queue<int>
#define pb push_back()
#define INF 1000000000000000000
#define float long double
#define pi acos(-1)
const int modu = (1e9) + 7;
void testCase(int ti) { cout << "Case " << ti << ": "; }
in... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pii pair<int, int>
#define pqi priority_queue<int>
#define pb push_back()
#define INF 1000000000000000000
#define float long double
#define pi acos(-1)
const int modu = (1e9) + 7;
void testCase(int ti) { cout << "Case " << ti << ": "; }
in... | [
"assignment.change"
] | 971,302 | 971,303 | u595057879 | cpp |
p03164 | /*######################################################
#########~~~~~####~~~~###~~##~~##~~##~~##~~##~~#########
#########~~##~~##~~##~~##~~~#~~##~~~#~~##~~##~~#########
#~~~~~~##~~~~~###~~~~~~##~~#~~~##~~#~~~##~~##~~##~~~~~~#
#########~~######~~##~~##~~##~~##~~##~~##~~##~~#########
#########~~######~~##~~##~~##~~##~~... | /*######################################################
#########~~~~~####~~~~###~~##~~##~~##~~##~~##~~#########
#########~~##~~##~~##~~##~~~#~~##~~~#~~##~~##~~#########
#~~~~~~##~~~~~###~~~~~~##~~#~~~##~~#~~~##~~##~~##~~~~~~#
#########~~######~~##~~##~~##~~##~~##~~##~~##~~#########
#########~~######~~##~~##~~##~~##~~... | [
"identifier.change",
"call.arguments.change"
] | 971,304 | 971,305 | u640997954 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef map<int, int> M;
typedef vector<int> V;
typedef queue<int> Q;
typedef pair<long, long> PLL;
typedef map<long, long> MLL;
typedef vector<long long> VLL;
typedef vector<pair<int, int>> VP;
typedef vector<vector<int>> VV... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef map<int, int> M;
typedef vector<int> V;
typedef queue<int> Q;
typedef pair<long, long> PLL;
typedef map<long, long> MLL;
typedef vector<long long> VLL;
typedef vector<pair<int, int>> VP;
typedef vector<vector<int>> VV... | [
"assignment.change"
] | 971,312 | 971,313 | u745562814 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef map<int, int> M;
typedef vector<int> V;
typedef pair<long, long> PLL;
typedef map<long, long> MLL;
typedef vector<long> VLL;
#define INF (int)(1e9)
#define MAXX 999999
#define EPS (1e-7)
#define MOD ((ll)1e9 + 7)
#def... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef map<int, int> M;
typedef vector<int> V;
typedef pair<long, long> PLL;
typedef map<long, long> MLL;
typedef vector<long> VLL;
#define INF (int)(1e9)
#define MAXX 999999
#define EPS (1e-7)
#define MOD ((ll)1e9 + 7)
#def... | [
"assignment.change"
] | 971,314 | 971,315 | u745562814 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef map<int, int> M;
typedef vector<int> V;
typedef pair<long, long> PLL;
typedef map<long, long> MLL;
typedef vector<long> VLL;
#define INF (int)(1e9)
#define MAXX 999999
#define EPS (1e-7)
#define MOD ((ll)1e9 + 7)
#def... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef map<int, int> M;
typedef vector<int> V;
typedef pair<long, long> PLL;
typedef map<long, long> MLL;
typedef vector<long> VLL;
#define INF (int)(1e9)
#define MAXX 999999
#define EPS (1e-7)
#define MOD ((ll)1e9 + 7)
#def... | [
"literal.number.change",
"variable_declaration.value.change",
"assignment.change"
] | 971,316 | 971,315 | u745562814 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
#define REP(i, a, n) for (int i = a; i < n; ++i)
#define REPR(i, a, n) for (int i = a; i > n; --i)
#define RUP(a, b) ((a + b - 1) / (b))
#define ALL(v) (v).begin(), (v).end()
#define pb push_back
#define mp make_pair
#define mt make_... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
#define REP(i, a, n) for (int i = a; i < n; ++i)
#define REPR(i, a, n) for (int i = a; i > n; --i)
#define RUP(a, b) ((a + b - 1) / (b))
#define ALL(v) (v).begin(), (v).end()
#define pb push_back
#define mp make_pair
#define mt make_... | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 971,341 | 971,340 | u635484372 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
typedef long long ll;
const int inf = 1e9;
const ll linf = 1e18;
const ll mod = 1e9 + 7;
ll dp[101][100001];
int main() {
int n, maxw;
cin >> n >> maxw;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 1001; j++) {... | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
typedef long long ll;
const int inf = 1e9;
const ll linf = 1e18;
const ll mod = 1e9 + 7;
ll dp[101][100001];
int main() {
int n, maxw;
cin >> n >> maxw;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 100001; j++)... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 971,344 | 971,345 | u057866967 | cpp |
p03164 | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = lo... | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = lo... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,366 | 971,367 | u997308904 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 0; i <= n; i++)
ll dp[105][100005];
int main() {
ll n, W;
cin >> n >> W;
ll v[n], w[n], sum = 0;
rep(i, n) {
cin >> w[i] >> v[i]... | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 0; i <= n; i++)
ll dp[105][100005];
int main() {
ll n, W;
cin >> n >> W;
ll v[n], w[n], sum = 0;
rep(i, n) {
cin >> w[i] >> v[i]... | [
"assignment.variable.change",
"identifier.change",
"call.function.change"
] | 971,368 | 971,369 | u160036974 | cpp |
p03164 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long weights[101];
long long values[101];
const int vMax = 100 * 1000 + 10;
long long dp[101][vMax];
long long const INF = 1LL << 60;
int main() {
int n;
long long W;
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin >> wei... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long weights[101];
long long values[101];
const int vMax = 100 * 1000 + 1;
long long dp[101][vMax + 1];
long long const INF = 1LL << 60;
int main() {
int n;
long long W;
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin >> ... | [
"literal.number.change",
"expression.operation.binary.change"
] | 971,375 | 971,376 | u100757865 | cpp |
p03164 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long weights[101];
long long values[101];
const long long vMax = 100 * 1000 + 1;
long long dp[101][vMax];
long long const INF = 1LL << 60;
int main() {
int n;
long long W;
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin >... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long weights[101];
long long values[101];
const long long vMax = 100 * 1000 + 10;
long long dp[101][vMax];
long long const INF = 1LL << 60;
int main() {
int n;
long long W;
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin ... | [
"literal.number.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one"
] | 971,377 | 971,378 | u100757865 | cpp |
p03164 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long weights[101];
long long values[101];
const long long vMax = 100 * 1000 + 1;
long long dp[101][vMax];
long long const INF = 1LL << 60;
int main() {
int n;
long long W;
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin >... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
long long weights[101];
long long values[101];
const long long vMax = 100 * 1000 + 1;
long long dp[101][vMax];
long long const INF = 1LL << 60;
int main() {
int n;
long long W;
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin >... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,377 | 971,379 | u100757865 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e2 + 2;
const int MAXV = 1e5 + 5;
const int INF = 1e9 + 7;
int val[MAXN], w[MAXN];
int dp[MAXN][MAXV];
int main() {
int n, W;
cin >> n >> W;
int V = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i] >> val[i];
V += val[i];
}
for (int i = 0;... | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e2 + 2;
const int MAXV = 1e5 + 5;
const int INF = 1e9 + 7;
int val[MAXN], w[MAXN];
int dp[MAXN][MAXV];
int main() {
int n, W;
cin >> n >> W;
int V = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i] >> val[i];
V += val[i];
}
for (int i = 0;... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 971,380 | 971,381 | u786670922 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
/*### FAST-IO ###*/
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout... | #include <bits/stdc++.h>
using namespace std;
/*### FAST-IO ###*/
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout... | [
"literal.number.change",
"expression.operation.binary.change",
"literal.number.type.widen.change"
] | 971,382 | 971,383 | u470689998 | cpp |
p03164 | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
#ifdef _debug
#define dout(i) cout << #i << ' ' << i << ' '
#else
#define dout(i) //
#endif
using ll = long long;
using ull = unsigned long long;
using ul = unsigned;
using db = double;
const int maxn = 101;
const int maxw = 100001;
const int inf ... | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
#ifdef _debug
#define dout(i) cout << #i << ' ' << i << ' '
#else
#define dout(i) //
#endif
using ll = long long;
using ull = unsigned long long;
using ul = unsigned;
using db = double;
const int maxn = 101;
const int maxw = 100001;
const int inf ... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 971,410 | 971,411 | u233690053 | cpp |
p03164 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
u... | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
u... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.variable.change",
"call.arguments.change",
"control_flow.branch.else.remove"
] | 971,417 | 971,416 | u135572611 | cpp |
p03164 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define INF 1e9 + 1
#define rep(i, n) for (int i = 0; i < n; i++)
int N, W;
int w[101], v[101];
int dp[101][100100];
int main() {
cin >> N >> W;
for (int i = 1; i <= N; i++) {
cin >> w[i] >> ... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define INF 1e9 + 1
#define rep(i, n) for (int i = 0; i < n; i++)
int N, W;
int w[101], v[101];
int dp[101][100100];
int main() {
cin >> N >> W;
for (int i = 1; i <= N; i++) {
cin >> w[i] >> ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 971,420 | 971,421 | u942850310 | cpp |
p03164 | #include <bits/stdc++.h>
#define MAXN 100005
#define inf 1000000000001
using namespace std;
int main() {
// freopen("t.txt","r",stdin);
int n, W;
long long w[111], v[111], maxv = 0;
cin >> n >> W;
for (int i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
maxv += v[i];
}
long long dp[maxv];
for (i... | #include <bits/stdc++.h>
#define MAXN 100005
#define inf 1000000000001
using namespace std;
int main() {
// freopen("t.txt","r",stdin);
int n, W;
long long w[111], v[111], maxv = 0;
cin >> n >> W;
for (int i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
maxv += v[i];
}
long long dp[100001];
for ... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 971,422 | 971,423 | u386321778 | cpp |
p03164 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
string to_string(string s) {... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
string to_string(string s) {... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 971,428 | 971,429 | u520002141 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[110][100100];
void chmin(ll &a, ll b) {
if (a > b) {
a = b;
}
return;
}
const ll inf = 1LL << 60;
int main() {
ll max_v = 0;
for (ll i = 0; i < 110; i++) {
for (ll j = 0; j < 100100; j++) {
dp[i][j] = inf;
}
}
ll... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[110][100100];
void chmin(ll &a, ll b) {
if (a > b) {
a = b;
}
return;
}
const ll inf = 1LL << 60;
int main() {
ll max_v = 0;
for (ll i = 0; i < 110; i++) {
for (ll j = 0; j < 100100; j++) {
dp[i][j] = inf;
}
}
ll... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 971,430 | 971,431 | u904123392 | cpp |
p03164 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
#define INF (1e9)
#define MOD (1e9 + 7)
#define LINF (1e18)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define ALL... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
#define INF (1e9)
#define MOD (1e9 + 7)
#define LINF (1e18)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define ALL... | [
"identifier.change",
"call.arguments.change"
] | 971,450 | 971,451 | u858107870 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll INF = 1e18L;
int main() {
ll n, w, sum_value = 0;
cin >> n >> w;
vector<ll> value(n), weight(n);
for (int i = 0; i < n; i++)
scanf("%lld %lld", &weight[i], &value[i]), sum_value += value[i];
vector<ll> dp(sum_value + 1, INF);
... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll INF = 1e18L;
int main() {
ll n, w, sum_value = 0;
cin >> n >> w;
vector<ll> value(n), weight(n);
for (int i = 0; i < n; i++)
scanf("%lld %lld", &weight[i], &value[i]), sum_value += value[i];
vector<ll> dp(sum_value + 1, INF);
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,497 | 971,498 | u234130745 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
ll dp[1001][100];
bool vis[1001][100];
ll solve(ll y, ll i, ll n, ll w[], ll v[]) {
if (y <= 0)
return 0;
if (i == n)
return 1000000001;
if (vis[y][i])
return dp[y][i];
vis[y][i] = 1;
return dp[y][i] = min(solve(y, i + 1, n... | // LARGE WEIGHTS .
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
ll dp[100001][100];
bool vis[100001][100];
ll solve(ll y, ll i, ll n, ll w[], ll v[]) {
if (y <= 0)
return 0;
if (i == n)
return 1000000001;
if (vis[y][i])
return dp[y][i];
vis[y][i] = 1;
return dp[y][i]... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 971,499 | 971,500 | u333958848 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define endl "\n";
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie... | #include <bits/stdc++.h>
using namespace std;
#define endl "\n";
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie... | [
"control_flow.return.add"
] | 971,534 | 971,535 | u271163543 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 62;
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[100001]; // dp[j] = 価値がちょうど j
// となるように選んだときの重さの最小値(配列再利用をするので
... | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 62;
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[100001]; // dp[j] = 価値がちょうど j
// となるように選んだときの重さの最小値(配列再利用をするので
... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change"
] | 971,547 | 971,548 | u657901243 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
long long dp[110][100100];
int main() {
long long n, w;
cin >> n >> w;
vector<long long> weight(n), value(n);
long long v = 100100;
for (long long i = 0; i < n; ++i) {
cin >> weight[i] >> value[i];
}
for (long long i = 0; i < 110; ++i) {
for (long lo... | #include <bits/stdc++.h>
using namespace std;
long long dp[110][100100];
int main() {
long long n, w;
cin >> n >> w;
vector<long long> weight(n), value(n);
long long v = 100100;
for (long long i = 0; i < n; ++i) {
cin >> weight[i] >> value[i];
}
for (long long i = 0; i < 110; ++i) {
for (long lo... | [
"control_flow.branch.else.remove"
] | 971,551 | 971,552 | u144029820 | cpp |
p03164 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define repi(i, a, b) for (int i = a; i <= (b); ++i)
#define rrep(i, n) for (int i = (n - 1); i >= 0; --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define repi(i, a, b) for (int i = a; i <= (b); ++i)
#define rrep(i, n) for (int i = (n - 1); i >= 0; --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()... | [
"literal.number.change",
"assignment.value.change"
] | 971,577 | 971,578 | u281168735 | cpp |
p03164 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define repi(i, a, b) for (int i = a; i <= (b); ++i)
#define rrep(i, n) for (int i = (n - 1); i >= 0; --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define repi(i, a, b) for (int i = a; i <= (b); ++i)
#define rrep(i, n) for (int i = (n - 1); i >= 0; --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()... | [
"assignment.change",
"literal.number.change",
"call.arguments.change"
] | 971,581 | 971,580 | u281168735 | cpp |
p03164 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define repi(i, a, b) for (int i = a; i <= (b); ++i)
#define rrep(i, n) for (int i = (n - 1); i >= 0; --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define repi(i, a, b) for (int i = a; i <= (b); ++i)
#define rrep(i, n) for (int i = (n - 1); i >= 0; --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()... | [
"assignment.change",
"literal.number.change",
"call.arguments.change"
] | 971,582 | 971,580 | u281168735 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll int n, w1;
cin >> n >> w1;
ll int w[n + 1], v[n + 1], sum = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
sum += v[i];
}
vector<ll int> dp(sum + 1);
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (ll i... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll int n, w1;
cin >> n >> w1;
ll int w[n + 1], v[n + 1], sum = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
sum += v[i];
}
vector<ll int> dp(sum + 1, 1000000000);
dp[0] = 0;
for (int i = 1; i <= n; i++) {
... | [
"call.arguments.add"
] | 971,589 | 971,590 | u452579095 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF (1 << 29)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
#define ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
#defin... | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 971,591 | 971,592 | u299869545 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MAX_N 100
#define MAX_V 1000
#define INF 1000000000
ll dp[MAX_N][MAX_V * MAX_N + 1];
// dp[n][v]:
// n番目までの品物を用いて価値の総和をvとした時の重さの最小値（vとならない場合は十分大きな数INF）
vector<ll> wei(MAX_N), val(MAX_N);
void knapsack(int n, ll v) {
if (v == 0)
dp[n][v] ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MAX_N 100
#define MAX_V 1000
#define INF 10000000000
ll dp[MAX_N][MAX_V * MAX_N + 1];
// dp[n][v]:
// n番目までの品物を用いて価値の総和をvとした時の重さの最小値（vとならない場合は十分大きな数INF）
vector<ll> wei(MAX_N), val(MAX_N);
void knapsack(int n, ll v) {
if (v == 0)
dp[n][v]... | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 971,595 | 971,596 | u044638697 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
vector<pair<long long int, long long int>> v;
long long int count = 0;
for (long long int i = 0; i < n; i++) {
long long int l, p;
cin >> l >> p;
v.push_back(make_pair(p, l));
count += p;
}
sort(... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
vector<pair<long long int, long long int>> v;
long long int count = 0;
for (long long int i = 0; i < n; i++) {
long long int l, p;
cin >> l >> p;
v.push_back(make_pair(p, l));
count += p;
}
sort(... | [
"assignment.value.change",
"call.arguments.change"
] | 971,622 | 971,623 | u483145617 | cpp |
p03164 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
/*
||||||||||||||||||||||||||||||||||||||||||||||||
| ||| | |||| |||| | |
| | | | | | | | | | |
| | | | | | | | | | |
... |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
/*
||||||||||||||||||||||||||||||||||||||||||||||||
| ||| | |||| |||| | |
| | | | | | | | | | |
| | | | | | | | | | |
... | [] | 971,626 | 971,627 | u980932400 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0, sum = 0;
int n, W;
int sumV = 0, maxV = 0;
cin >> n >> W;
int w[n + 1], v[n + 1];
w[0] = 0;
v[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
sumV += v[i];
}
int dp[sumV + 1][n + 1];
for (int i = 0; ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0, sum = 0;
int n, W;
int sumV = 0, maxV = 0;
cin >> n >> W;
int w[n + 1], v[n + 1];
w[0] = 0;
v[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
sumV += v[i];
}
int dp[sumV + 1][n + 1];
for (int i = 0; ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 971,632 | 971,633 | u355424600 | cpp |
p03164 |
// This code is solely the property of StarnyC
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define ld long double
#define hell 1000000007
#define hellx 998244353
#define pb push_back
#define mp make_pair
#define reset(a, b) memset(a, b, sizeof(a))
#define Go_Baby_Go ... |
// This code is solely the property of StarnyC
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define ld long double
#define hell 1000000007
#define hellx 998244353
#define pb push_back
#define mp make_pair
#define reset(a, b) memset(a, b, sizeof(a))
#define Go_Baby_Go ... | [
"assignment.change",
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 971,634 | 971,635 | u961439650 | cpp |
p03164 |
// This code is solely the property of StarnyC
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define ld long double
#define hell 1000000007
#define hellx 998244353
#define pb push_back
#define mp make_pair
#define reset(a, b) memset(a, b, sizeof(a))
#define Go_Baby_Go ... |
// This code is solely the property of StarnyC
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define ld long double
#define hell 1000000007
#define hellx 998244353
#define pb push_back
#define mp make_pair
#define reset(a, b) memset(a, b, sizeof(a))
#define Go_Baby_Go ... | [
"assignment.change"
] | 971,636 | 971,637 | u961439650 | cpp |
p03164 |
// This code is solely the property of StarnyC
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define ld long double
#define hell 1000000007
#define hellx 998244353
#define pb push_back
#define mp make_pair
#define reset(a, b) memset(a, b, sizeof(a))
#define Go_Baby_Go ... |
// This code is solely the property of StarnyC
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define ld long double
#define hell 1000000007
#define hellx 998244353
#define pb push_back
#define mp make_pair
#define reset(a, b) memset(a, b, sizeof(a))
#define Go_Baby_Go ... | [
"assignment.change",
"literal.number.change",
"assignment.value.change"
] | 971,638 | 971,637 | u961439650 | cpp |
p03164 |
// This code is solely the property of StarnyC
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define ld long double
#define hell 1000000007
#define hellx 998244353
#define pb push_back
#define mp make_pair
#define reset(a, b) memset(a, b, sizeof(a))
#define Go_Baby_Go ... |
// This code is solely the property of StarnyC
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define ld long double
#define hell 1000000007
#define hellx 998244353
#define pb push_back
#define mp make_pair
#define reset(a, b) memset(a, b, sizeof(a))
#define Go_Baby_Go ... | [
"assignment.change",
"control_flow.loop.for.condition.change",
"literal.number.change",
"assignment.value.change"
] | 971,639 | 971,637 | u961439650 | cpp |
p03164 | #include "bits/stdc++.h"
#define int long long
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
using namespace std;
const int MAX_N = 100, MAX_V = 100000;
int N, W;
v... | #include "bits/stdc++.h"
#define int long long
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
using namespace std;
const int MAX_N = 100, MAX_V = 100000;
int N, W;
v... | [
"expression.operation.binary.add"
] | 971,640 | 971,641 | u203033720 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll... | #include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll... | [] | 971,643 | 971,644 | u336011173 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll... | #include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 971,645 | 971,644 | u336011173 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll maxn = 100005;
ll dp[101][100000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll n, W;
cin >> n >> W;
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
ll w, va;
cin >> w... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll maxn = 100005;
ll dp[101][maxn + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll n, W;
cin >> n >> W;
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
ll w, va;
cin >>... | [
"identifier.replace.add",
"literal.replace.remove"
] | 971,648 | 971,649 | u673058289 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll maxn = 100005;
ll dp[101][100000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll n, W;
cin >> n >> W;
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
ll w, va;
cin >> w... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll maxn = 100005;
ll dp[101][111111];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll n, W;
cin >> n >> W;
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
ll w, va;
cin >> w... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 971,648 | 971,650 | u673058289 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, n, W, w, v, ans = 0;
cin >> n >> W;
vector<long long int> v1, v2;
for (i = 0; i < n; i++) {
cin >> w >> v;
v1.push_back(w);
v2.push_back(v);
}
long long int dp[100010];
for (i = 0; i < 100000; i++)
dp[i] = 1e... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, n, W, w, v, ans = 0;
cin >> n >> W;
vector<long long int> v1, v2;
for (i = 0; i < n; i++) {
cin >> w >> v;
v1.push_back(w);
v2.push_back(v);
}
long long int dp[100010];
for (i = 0; i <= 100000; i++)
dp[i] = 1... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 971,655 | 971,656 | u815320324 | cpp |
p03164 | #include <algorithm>
#include <bits/stdc++.h>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define INF 1LL << 40;
#define MOD 1000000007;
#define ll long long
#define REP(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) REP(i, 0, n)
... | #include <algorithm>
#include <bits/stdc++.h>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define INF 1LL << 40;
#define MOD 1000000007;
#define ll long long
#define REP(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) REP(i, 0, n)
... | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 971,659 | 971,660 | u143509139 | cpp |
p03164 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef unsigned int uint;
typedef long long llong;
typedef unsigned long long ullong;
typedef long ... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef unsigned int uint;
typedef long long llong;
typedef unsigned long long ullong;
typedef long ... | [
"assignment.value.change",
"identifier.change"
] | 971,671 | 971,672 | u392319141 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
long long dp[100005];
int v[105], w[105];
int main() {
int n, W;
scanf("%d %d", &n, &W);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &w[i], &v[i]);
}
for (int j = 0; j <= 100000; j++) {
dp[j] = 1e15;
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {... | #include <bits/stdc++.h>
using namespace std;
long long dp[100005];
int v[105], w[105];
int main() {
int n, W;
scanf("%d %d", &n, &W);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &w[i], &v[i]);
}
for (int j = 0; j <= 100000; j++) {
dp[j] = 1e15;
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 971,675 | 971,676 | u259039862 | cpp |
p03164 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define INF ((1LL << 62) - (1LL << 31))
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
long long int W[a + 1], V[a + 1], DP[a + 1][1000001];
// DP[i][j]... | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define INF ((1LL << 62) - (1LL << 31))
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
long long int W[a + 1], V[a + 1], DP[a + 1][100001];
// DP[i][j] ... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.value.change"
] | 971,716 | 971,717 | u041282550 | cpp |
p03164 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// Self set... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// Self set... | [
"assignment.change"
] | 971,718 | 971,719 | u621104964 | cpp |
p03164 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
const int MAX_N = 110;
const int MAX_V... | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
const int MAX_N = 110;
const int MAX_V... | [
"literal.number.change",
"expression.operation.binary.change",
"literal.number.type.widen.change"
] | 971,729 | 971,730 | u146594935 | cpp |
p03164 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
const int MAX_N = 110;
const int MAX_V... | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
const int MAX_N = 110;
const int MAX_V... | [
"expression.operation.binary.remove"
] | 971,731 | 971,730 | u146594935 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define SORT(x) sort(x.begin(), x.end())
#define ALL(x) x.begin(), x.end()
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(),x.end(),v)-x.begin()
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1000000000... | #include <bits/stdc++.h>
using namespace std;
#define SORT(x) sort(x.begin(), x.end())
#define ALL(x) x.begin(), x.end()
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(),x.end(),v)-x.begin()
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1000000000... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 971,734 | 971,735 | u022832318 | cpp |
p03164 | #include <bits/stdc++.h>
using LL = long long;
const LL MOD = 1e9 + 9;
using namespace std;
int main() {
int N, W;
cin >> N >> W;
vector<pair<int, int>> vec;
for (int i = 0; i < N; i++) {
int b;
cin >> b;
int c;
cin >> c;
vec.push_back({b, c});
}
vector<vector<LL>> dp(N + 1, vector<LL>(... | #include <bits/stdc++.h>
using LL = long long;
const LL MOD = 1e9 + 9;
using namespace std;
int main() {
int N, W;
cin >> N >> W;
vector<pair<int, int>> vec;
for (int i = 0; i < N; i++) {
int b;
cin >> b;
int c;
cin >> c;
vec.push_back({b, c});
}
vector<vector<LL>> dp(N + 1, vector<LL>(... | [
"literal.number.change",
"call.arguments.change",
"control_flow.branch.if.condition.change"
] | 971,745 | 971,746 | u580402951 | cpp |
p03164 | #include <bits/stdc++.h>
#define MAX ((int)(2e9))
using namespace std;
int dp[102][(int)(1e5) + 7], c[105], v[105];
int call(int n, int rem) {
if (rem <= 0)
return 0;
if (n == 0) {
return MAX;
}
if (dp[n][rem] != -1)
return dp[n][rem];
dp[n][rem] = MAX;
dp[n][rem] = min(dp[n][rem], call(n - 1,... | #include <bits/stdc++.h>
#define MAX ((int)(1e9) + 2)
using namespace std;
int dp[102][(int)(1e5) + 2], c[105], v[105];
int call(int n, int rem) {
if (rem <= 0)
return 0;
if (n == 0) {
return MAX;
}
if (dp[n][rem] != -1)
return dp[n][rem];
dp[n][rem] = MAX;
dp[n][rem] = min(dp[n][rem], call(n ... | [
"preprocessor.define.value.change",
"literal.float.change",
"literal.number.change",
"expression.operation.binary.change"
] | 971,749 | 971,750 | u518630931 | cpp |
p03164 | #include <bits/stdc++.h>
#define MAX ((int)(2e9))
using namespace std;
int dp[102][(int)(1e5) + 7], c[105], v[105];
int call(int n, int rem) {
if (rem <= 0)
return 0;
if (n == 0) {
return MAX;
}
if (dp[n][rem] != -1)
return dp[n][rem];
dp[n][rem] = MAX;
dp[n][rem] = min(dp[n][rem], call(n - 1,... | #include <bits/stdc++.h>
#define MAX ((int)(1e9) + 2)
using namespace std;
int dp[102][(int)(1e5) + 7], c[105], v[105];
int call(int n, int rem) {
if (rem <= 0)
return 0;
if (n == 0) {
return MAX;
}
if (dp[n][rem] != -1)
return dp[n][rem];
dp[n][rem] = MAX;
dp[n][rem] = min(dp[n][rem], call(n ... | [
"preprocessor.define.value.change",
"literal.float.change"
] | 971,749 | 971,751 | u518630931 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.