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 |
|---|---|---|---|---|---|---|---|
p03164 | #include "bits/stdc++.h"
using namespace std;
////////////// Prewritten code follows. Look down for solution. ////////////////
#define fs first
#define sc second
#define pb push_back
#define len(x) ((int)(x).size())
#define fastio ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long long ll;
const ll LINF = 1e18;
const int INF = 1e9;
const int MOD = 1e9 + 7;
/// command for char arrays with spaces -> scanf(" %[^\n]", text);
////////////////////////// Solution starts below. //////////////////////////////
int main() {
fastio;
int n;
ll p;
cin >> n >> p;
int max_value = 0;
vector<int> valor(n);
vector<ll> peso(n);
for (int i = 1; i <= n; i++) {
cin >> peso[i] >> valor[i];
max_value += valor[i];
}
vector<ll> dp(max_value + 1, LINF);
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = max_value - valor[i]; j >= 0; j--) {
dp[j + valor[i]] = min(dp[j + valor[i]], dp[j] + peso[i]);
}
}
int ans = 0;
for (int i = max_value; i >= 0; i--) {
if (dp[i] <= p) {
ans = i;
break;
}
}
cout << ans << '\n';
return 0;
} | #include "bits/stdc++.h"
using namespace std;
////////////// Prewritten code follows. Look down for solution. ////////////////
#define fs first
#define sc second
#define pb push_back
#define len(x) ((int)(x).size())
#define fastio ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long long ll;
const ll LINF = 1e18;
const int INF = 1e9;
const int MOD = 1e9 + 7;
/// command for char arrays with spaces -> scanf(" %[^\n]", text);
////////////////////////// Solution starts below. //////////////////////////////
int main() {
fastio;
int n;
ll p;
cin >> n >> p;
int max_value = 0;
vector<int> valor(n + 1);
vector<ll> peso(n + 1);
for (int i = 1; i <= n; i++) {
cin >> peso[i] >> valor[i];
max_value += valor[i];
}
vector<ll> dp(max_value + 1, LINF);
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = max_value - valor[i]; j >= 0; j--) {
dp[j + valor[i]] = min(dp[j + valor[i]], dp[j] + peso[i]);
}
}
int ans = 0;
for (int i = max_value; i >= 0; i--) {
if (dp[i] <= p) {
ans = i;
break;
}
}
cout << ans << '\n';
return 0;
} | [
"assignment.change"
] | 970,215 | 970,216 | u567661286 | cpp |
p03164 | // Author: Ishaan Gupta
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1000000007;
#define endl '\n'
#define pb push_back
#define DEB(x) cout << '>' << #x << ':' << x << endl;
inline ll add(ll a, ll b) { return (a % MOD + b % MOD) % MOD; }
inline ll sub(ll a, ll b) { return (a % MOD - b % MOD + MOD) % MOD; }
inline ll mult(ll a, ll b) { return ((a % MOD) * (b % MOD)) % MOD; }
inline ll power(ll a, ll b) {
a %= MOD;
ll r = 1;
while (b) {
if (b & 1)
r = mult(r, a);
a = mult(a, a);
b >>= 1;
}
return r;
}
void min_self(ll &a, ll b) { a = min(a, b); }
const ll INF = 1e18l + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed;
#ifdef IG_PC
freopen("input", "r", stdin);
freopen("output", "w", stdout);
#endif
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
for (ll i = 0; i < n; ++i) {
cin >> weight[i] >> value[i];
}
ll sum_value = 0;
for (ll i : value) {
sum_value += i;
}
vector<ll> dp(sum_value + 1, INF);
dp[0] = 0;
for (ll items = 0; items < n; ++items) {
for (ll value_already = sum_value; value_already >= value[items];
--value_already) {
min_self(dp[value_already],
dp[value_already - value[items]] + weight[items]);
}
}
ll ans = 0;
for (ll i = 0; i < sum_value; ++i) {
if (dp[i] <= w) {
ans = max(ans, i);
}
}
cout << ans;
return 0;
} | // Author: Ishaan Gupta
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1000000007;
#define endl '\n'
#define pb push_back
#define DEB(x) cout << '>' << #x << ':' << x << endl;
inline ll add(ll a, ll b) { return (a % MOD + b % MOD) % MOD; }
inline ll sub(ll a, ll b) { return (a % MOD - b % MOD + MOD) % MOD; }
inline ll mult(ll a, ll b) { return ((a % MOD) * (b % MOD)) % MOD; }
inline ll power(ll a, ll b) {
a %= MOD;
ll r = 1;
while (b) {
if (b & 1)
r = mult(r, a);
a = mult(a, a);
b >>= 1;
}
return r;
}
void min_self(ll &a, ll b) { a = min(a, b); }
const ll INF = 1e18l + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed;
#ifdef IG_PC
freopen("input", "r", stdin);
freopen("output", "w", stdout);
#endif
ll n, w;
cin >> n >> w;
vector<ll> weight(n), value(n);
for (ll i = 0; i < n; ++i) {
cin >> weight[i] >> value[i];
}
ll sum_value = 0;
for (ll i : value) {
sum_value += i;
}
vector<ll> dp(sum_value + 1, INF);
dp[0] = 0;
for (ll items = 0; items < n; ++items) {
for (ll value_already = sum_value; value_already >= value[items];
--value_already) {
min_self(dp[value_already],
dp[value_already - value[items]] + weight[items]);
}
}
ll ans = 0;
for (ll i = 0; i <= sum_value; ++i) {
if (dp[i] <= w) {
ans = max(ans, i);
}
}
cout << ans;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 970,217 | 970,218 | u090137556 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, w;
cin >> n >> w;
int v = 1e5;
vector<long long> dp(v + 1, INT_MAX);
dp[0] = 0;
int weight, value;
for (int i = 0; i < n; i++) {
cin >> weight >> value;
for (int j = v - value; j <= 0; j--) {
dp[j + value] = min(dp[j + value], dp[j] + weight);
}
}
for (int i = v; i >= 0; i--) {
if (dp[i] <= w) {
cout << i << endl;
break;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, w;
cin >> n >> w;
int v = 1e5;
vector<long long> dp(v + 1, INT_MAX);
dp[0] = 0;
int weight, value;
for (int i = 0; i < n; i++) {
cin >> weight >> value;
for (int j = v - value; j >= 0; j--) {
dp[j + value] = min(dp[j + value], dp[j] + weight);
}
}
for (int i = v; i >= 0; i--) {
if (dp[i] <= w) {
cout << i << endl;
break;
}
}
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 970,227 | 970,228 | u499126356 | cpp |
p03164 | #include <algorithm>
#include <bits/stdc++.h>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<pii, pii> piiii;
typedef vector<pii> vii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef queue<char> qc;
typedef queue<string> qs;
typedef vector<char> vc;
typedef vector<string> vs;
typedef map<char, int> mpci;
typedef map<int, int> mpii;
typedef map<string, int> mpsi;
typedef set<int> sei;
typedef set<char> sec;
typedef set<string> ses;
typedef stack<ll> si;
typedef stack<char> sc;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef vector<pll> vpll;
typedef vector<pdd> vdd;
typedef unsigned int uint;
typedef long double ld;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vii> vvii;
/*=====================================================================*/
#define pb push_back
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define sz(a) (int)(a.size())
#define len(a) (int)(a.length())
#define all(s) (s).begin(), (s).end()
#define fi first
#define se second
#define be begin
#define en end
#define m_p make_pair
#define repd(i, n) for (int i = n - 1; i >= 0; i--)
#define forn(i, p, n) for (int i = p; i <= n; i++)
#define ford(i, p, n) for (int i = n - 1; i >= p; i--)
#define foreach(i, c) \
for (__typeof(c.begin()) i = (c.begin()); i != (c).end(); ++i)
#define zero(a) memset(a, 0, sizeof(a))
#define number(a, num) memeset(a, num, sizeof(a))
/*=====================================================================*/
inline void read(int &x) {
short negative = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
negative = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
x *= negative;
}
inline void write(long long x) {
static long long sta[35];
long long top = 0;
do {
sta[top++] = x % 10, x /= 10;
} while (x);
while (top)
putchar(sta[--top] + 48);
puts("");
}
/*======================================================================*/
bool prime(int n) {
if (n == 0 || n == 1)
return false;
for (int i = 2; i * i <= n; i++)
if (n % i == 0)
return false;
return true;
}
const ll power(int n, int k) {
ll t = 1;
rep(i, k) t *= n;
return t;
}
const string turn2(int n) {
string s = "";
while (n != 0) {
s += (char)(n % 2 + '0');
n /= 2;
}
reverse(s.begin(), s.end());
return s;
}
const string turn16(int n) {
string s = "";
while (n != 0) {
if (n % 16 > 9)
s += (char)('A' + n % 16 - 10);
else
s += (char)('0' + n % 16);
n /= 16;
}
reverse(s.begin(), s.end());
return s;
}
const ll quickpower(int n, int k) {
if (k == 1)
return n;
if (k % 2 == 1)
return n * quickpower(n, k / 2) * quickpower(n, k / 2);
else
return quickpower(n, k / 2) * (quickpower(n, k / 2));
}
/*
void merge(int a[],int left,int mid,int right)
{
int n1=mid-left;
int n2=right-mid;
for(int i=0;i<n1;i++)
{
l[i]=a[i+left];
}
for(int i=0;i<n2;i++)
{
r[i]=a[mid+i];
}
r[n2]=l[n1]=INF;
int i=0;
int j=0;
for(int k=left;k<right;k++)
{
if(l[i]<=r[j])
{
a[k]=l[i++];
}
else
{
a[k]=r[j++];
}
}
}
void mergesort(int a[],int left,int right)
{
if(left+1<right)
{
int mid=(left+right)/2;
mergesort(a,left,mid);
mergesort(a,mid,right);
merge(a,left,mid,right);
}
}
int binsearch(int x,int v[],int n)
{
int low=0,high=n-1;
int mid;
while(low<=high)
{
mid=(low+high)/2;
if(x<v[mid])
high=mid-1;
else
if(x>v[mid])
low=mid+1;
else
return mid+1;
}
return -1;
}
int partition(int a[],int left,int right)
{
int p=a[left];
int i=left;
int j=right+1;
for(;;)
{
while(a[++i]<p)
if(i>=right)
break;
while(a[j--]>p)
if(j<=left)
break;
if(i>=j)
break;
else
swap(a[i],a[j]);
}
if(j>=left)
return j;
swap(a[left],a[j]);
return j;
}
void quicksort(int a[],int left,int right)
{
int q;
while(right>left)
{
q=partition(a,left,right);
if(n-q+1==k)
{
cout<<a[q];
exit(0);
}
quicksort(a,left,q-1);
quicksort(a,q+1,right);
}
}
void dfs(int n)
{
if(use[n])
return;
use[n]=true;
cout<<n<<endl;
for(int i=0;i<v[n].size();i++)
dfs(v[n][i]);
}*/
/*======================================================================*/
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
ll h[110], v[110], dp[100010];
/*======================================================================*/
int main() {
/*
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
*/
/*====================================================================*/
ll n, w;
cin >> n >> w;
rep(i, n) { cin >> h[i] >> v[i]; }
rep(i, 100001) { dp[i] = 1e9; }
dp[0] = 0;
rep(i, n) {
for (int j = 100000; j >= 0; j--) {
if (j - v[i] < 0) {
continue;
}
dp[j] = min(dp[j], dp[j - v[i]] + h[i]);
}
}
/*rep(i,100000)
{
cout<<dp[i]<<endl;
}*/
ll ans = 0;
rep(i, 100001) {
if (dp[i] <= w) {
ans = i;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<pii, pii> piiii;
typedef vector<pii> vii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef queue<char> qc;
typedef queue<string> qs;
typedef vector<char> vc;
typedef vector<string> vs;
typedef map<char, int> mpci;
typedef map<int, int> mpii;
typedef map<string, int> mpsi;
typedef set<int> sei;
typedef set<char> sec;
typedef set<string> ses;
typedef stack<ll> si;
typedef stack<char> sc;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef vector<pll> vpll;
typedef vector<pdd> vdd;
typedef unsigned int uint;
typedef long double ld;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vii> vvii;
/*=====================================================================*/
#define pb push_back
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define sz(a) (int)(a.size())
#define len(a) (int)(a.length())
#define all(s) (s).begin(), (s).end()
#define fi first
#define se second
#define be begin
#define en end
#define m_p make_pair
#define repd(i, n) for (int i = n - 1; i >= 0; i--)
#define forn(i, p, n) for (int i = p; i <= n; i++)
#define ford(i, p, n) for (int i = n - 1; i >= p; i--)
#define foreach(i, c) \
for (__typeof(c.begin()) i = (c.begin()); i != (c).end(); ++i)
#define zero(a) memset(a, 0, sizeof(a))
#define number(a, num) memeset(a, num, sizeof(a))
/*=====================================================================*/
inline void read(int &x) {
short negative = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
negative = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
x *= negative;
}
inline void write(long long x) {
static long long sta[35];
long long top = 0;
do {
sta[top++] = x % 10, x /= 10;
} while (x);
while (top)
putchar(sta[--top] + 48);
puts("");
}
/*======================================================================*/
bool prime(int n) {
if (n == 0 || n == 1)
return false;
for (int i = 2; i * i <= n; i++)
if (n % i == 0)
return false;
return true;
}
const ll power(int n, int k) {
ll t = 1;
rep(i, k) t *= n;
return t;
}
const string turn2(int n) {
string s = "";
while (n != 0) {
s += (char)(n % 2 + '0');
n /= 2;
}
reverse(s.begin(), s.end());
return s;
}
const string turn16(int n) {
string s = "";
while (n != 0) {
if (n % 16 > 9)
s += (char)('A' + n % 16 - 10);
else
s += (char)('0' + n % 16);
n /= 16;
}
reverse(s.begin(), s.end());
return s;
}
const ll quickpower(int n, int k) {
if (k == 1)
return n;
if (k % 2 == 1)
return n * quickpower(n, k / 2) * quickpower(n, k / 2);
else
return quickpower(n, k / 2) * (quickpower(n, k / 2));
}
/*
void merge(int a[],int left,int mid,int right)
{
int n1=mid-left;
int n2=right-mid;
for(int i=0;i<n1;i++)
{
l[i]=a[i+left];
}
for(int i=0;i<n2;i++)
{
r[i]=a[mid+i];
}
r[n2]=l[n1]=INF;
int i=0;
int j=0;
for(int k=left;k<right;k++)
{
if(l[i]<=r[j])
{
a[k]=l[i++];
}
else
{
a[k]=r[j++];
}
}
}
void mergesort(int a[],int left,int right)
{
if(left+1<right)
{
int mid=(left+right)/2;
mergesort(a,left,mid);
mergesort(a,mid,right);
merge(a,left,mid,right);
}
}
int binsearch(int x,int v[],int n)
{
int low=0,high=n-1;
int mid;
while(low<=high)
{
mid=(low+high)/2;
if(x<v[mid])
high=mid-1;
else
if(x>v[mid])
low=mid+1;
else
return mid+1;
}
return -1;
}
int partition(int a[],int left,int right)
{
int p=a[left];
int i=left;
int j=right+1;
for(;;)
{
while(a[++i]<p)
if(i>=right)
break;
while(a[j--]>p)
if(j<=left)
break;
if(i>=j)
break;
else
swap(a[i],a[j]);
}
if(j>=left)
return j;
swap(a[left],a[j]);
return j;
}
void quicksort(int a[],int left,int right)
{
int q;
while(right>left)
{
q=partition(a,left,right);
if(n-q+1==k)
{
cout<<a[q];
exit(0);
}
quicksort(a,left,q-1);
quicksort(a,q+1,right);
}
}
void dfs(int n)
{
if(use[n])
return;
use[n]=true;
cout<<n<<endl;
for(int i=0;i<v[n].size();i++)
dfs(v[n][i]);
}*/
/*======================================================================*/
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
ll h[110], v[110], dp[100010];
/*======================================================================*/
int main() {
/*
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
*/
/*====================================================================*/
ll n, w;
cin >> n >> w;
rep(i, n) { cin >> h[i] >> v[i]; }
rep(i, 100001) { dp[i] = 1e10; }
dp[0] = 0;
rep(i, n) {
for (int j = 100000; j >= 0; j--) {
if (j - v[i] < 0) {
continue;
}
dp[j] = min(dp[j], dp[j - v[i]] + h[i]);
}
}
/*rep(i,100000)
{
cout<<dp[i]<<endl;
}*/
ll ans = 0;
rep(i, 100001) {
if (dp[i] <= w) {
ans = i;
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 970,250 | 970,251 | u265392294 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long n, W, w, v;
long long d[N], use[N];
int main() {
cin >> n >> W;
use[0] = 1;
for (int i = 1; i <= N; i++) {
d[i] = 1e12;
}
for (int i = 1; i <= n; i++) {
cin >> w >> v;
for (int u = 1e5 + 10; u >= 0; u--) {
if (use[u] == 1) {
d[u + v] = min(d[u + v], d[u] + w);
use[u + v] = 1;
}
}
}
for (int i = N; i >= 0; i--) {
if (use[i] == 1) {
if (d[i] <= W) {
cout << d[i] << endl;
return 0;
}
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long n, W, w, v;
long long d[N], use[N];
int main() {
cin >> n >> W;
use[0] = 1;
for (int i = 1; i <= N; i++) {
d[i] = 1e12;
}
for (int i = 1; i <= n; i++) {
cin >> w >> v;
for (int u = 1e5 + 10; u >= 0; u--) {
if (use[u] == 1) {
d[u + v] = min(d[u + v], d[u] + w);
use[u + v] = 1;
}
}
}
for (int i = N; i >= 0; i--) {
if (use[i] == 1) {
if (d[i] <= W) {
cout << i;
return 0;
}
}
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 970,258 | 970,259 | u561495734 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <numeric>
#include <queue>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define rep(i, n) for (lint i = 0; i < n; i++)
#define repb(i, start, end) for (lint i = start; i <= end; i++)
#define repbr(i, start, end) for (lint i = end; i >= start; i--)
namespace {
using lint = long long;
using ulint = unsigned long long;
using ld = long double;
lint gcd(lint a, lint b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
const ulint mod = 1000000007;
const double pi = 3.141592653589793238462;
const lint intmax = 9223372036854775807;
lint FactMod(lint n) {
if (n == 0) {
return 1;
}
lint ans = 1;
while (n > 1) {
ans *= n;
n--;
ans %= mod;
}
return ans;
}
lint _PowMod(lint x, lint y, lint _mod) {
if (x <= 1) {
return x;
}
if (y == 0) {
return 1;
} else if (y == 1) {
return x % _mod;
} else if (y % 2 == 0) {
lint tmp = _PowMod(x, y / 2, _mod);
return tmp * tmp % _mod;
} else {
lint tmp = _PowMod(x, y / 2, _mod);
return (tmp * tmp % _mod) * x % _mod;
}
}
lint PowMod(lint x, lint y) { return _PowMod(x, y, mod); }
auto getModInv(lint N) { return PowMod(N, mod - 2); }
lint nCrMod(lint n, lint r, lint start) {
if (n < r || n < 0 || r < 0) {
return 0;
}
r = min(r, n - r);
lint a = start;
for (lint i = n; i >= n - r + 1; i--) {
a *= i;
a %= mod;
}
a *= getModInv(FactMod(r));
a %= mod;
return a;
}
lint nHrMod(lint n, lint r, lint start) { return nCrMod(n + r - 1, r, start); }
auto lcmMod(lint a, lint b) {
return (((a * getModInv(gcd(a, b))) % mod) * b) % mod;
}
template <class T> constexpr auto modK_belowN(T k, T MOD, T n) {
return (n + MOD - k - 1) / MOD;
}
struct uf {
vector<lint> p;
uf(lint n) : p(n) { rep(i, n) p[i] = i; }
lint rt(lint n) { return p[n] == n ? n : p[n] = rt(p[n]); }
void un(lint n, lint m) { p[rt(n)] = p[rt(m)]; }
bool eq(lint n, lint m) { return rt(n) == rt(m); }
};
template <class T>
bool lineCol(T a1x, T a1y, T a2x, T a2y, T b1x, T b1y, T b2x, T b2y) {
auto ta = (b1x - b2x) * (a1y - b1y) + (b1y - b2y) * (b1x - a1x);
auto tb = (b1x - b2x) * (a2y - b1y) + (b1y - b2y) * (b1x - a2x);
auto tc = (a1x - a2x) * (b1y - a1y) + (a1y - a2y) * (a1x - b1x);
auto td = (a1x - a2x) * (b2y - a1y) + (a1y - a2y) * (a1x - b2x);
return tc * td < 0 && ta * tb < 0;
}
lint powInt(lint a, lint b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
lint tmp = powInt(a, b / 2);
return (b % 2 == 1 ? a * tmp * tmp : tmp * tmp);
}
lint _sMod(string n, lint mod) {
lint k = (n[0] - '0') % mod;
for (lint i = 1; i < n.length(); i++) {
k *= 10;
k += (n[i] - '0');
k %= mod;
}
return k;
}
#define vec(name, n) vector<lint> name(n)
#define vec_(name, n, init) vector<lint> name(n, init)
#define vecs(name, n) vector<string> name(n)
#define vect(t, name, n) vector<t> name(n)
#define vec2(name, n, m) vector<vector<lint>> name(n, vector<lint>(m))
#define vec2_(name, n, m, init) \
vector<vector<lint>> name(n, vector<lint>(m, init))
template <class T> constexpr auto msum(T arg0) { return arg0; }
template <class T, class... Types> constexpr auto msum(T arg0, Types... args) {
static_assert(sizeof...(args) > 0, "arg err");
return arg0 + msum(args...);
}
template <class T> constexpr auto mmax(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmax(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return max(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmax(args...)));
}
template <class T> constexpr auto mmin(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmin(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return min(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmin(args...)));
}
constexpr auto clamp(lint val, lint left, lint right) {
return mmax(mmin(val, right), left);
}
lint div2(lint p, lint q) { return (p + q - 1) / q; }
struct xy {
lint x, y;
xy() : x(0), y(0) {}
xy(lint _x, lint _y) : x(_x), y(_y) {}
};
struct xyd {
long double x, y;
xyd() : x(0), y(0) {}
xyd(long double _x, long double _y) : x(_x), y(_y) {}
};
template <class It, class T> bool exist(It begin, It end, const T &val) {
return find(begin, end, val) != end;
}
template <class It, class Pr> bool exist_if(It begin, It end, Pr pred) {
return find_if(begin, end, pred) != end;
}
lint ndig(lint n) {
lint ans = 0;
while (n > 0) {
n /= 10;
ans++;
}
return ans;
}
const lint alpn = 'z' - 'a' + 1;
template <class T> T sgn(T val) {
if (val == T(0))
return T(0);
if (val < 0)
return T(-1);
if (val > 0)
return T(1);
}
template <class T> bool between(T val, T l, T r) {
return (val >= l) && (val <= r);
}
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
template <class It> vector<lint> carr(It begin, It end) {
vec(c, 0);
c.push_back(1);
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(0);
before = *it;
}
c.back()++;
}
return c;
}
template <class T> struct nval {
lint n;
T val;
nval() : n(0){};
nval(lint _n, T _val) : n(_n), val(_val){};
};
template <class It> auto carr2(It begin, It end) {
using T = nval<remove_reference_t<decltype(*begin)>>;
vect(T, c, 0);
c.push_back(T(1, *begin));
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(T(0, *it));
before = *it;
}
c.back().n++;
}
return c;
}
template <class It, class... T> void sort2(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p...](val_t a, val_t b) {
bool neq[] = {(a.*p != b.*p)...};
bool sg[] = {(a.*p < b.*p)...};
rep(i, sizeof...(p)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <size_t _K, size_t _N, class... Types, size_t... indices>
auto constexpr __ModKtuple_Impl(index_sequence<indices...>,
tuple<Types...> args) {
return make_tuple(get<indices * _N + _K>(args)...);
}
template <size_t K, size_t N, class... Types>
auto constexpr ModKtuple(Types... args) {
return __ModKtuple_Impl<K, N>(
make_index_sequence<modK_belowN(K, N, sizeof...(args))>{},
forward_as_tuple(args...));
}
template <class It, class... T, class... Tsg, size_t... indices>
void __sort3_Impl(It begin, It end, tuple<T...> p, tuple<Tsg...> sgf,
index_sequence<indices...>) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p, sgf](val_t a, val_t b) {
bool neq[] = {(a.*(get<indices>(p)) != b.*(get<indices>(p)))...};
bool sg[] = {((a.*(get<indices>(p)) < b.*(get<indices>(p))) !=
(get<indices>(sgf)))...};
rep(i, sizeof...(indices)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <class It, class... T> void sort3(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
auto p_forward = ModKtuple<0, 2>(p...);
auto sgf_forward = ModKtuple<1, 2>(p...);
constexpr auto p_sz = tuple_size<decltype(p_forward)>::value;
constexpr auto sgf_sz = tuple_size<decltype(sgf_forward)>::value;
static_assert(p_sz == sgf_sz, "arg err");
__sort3_Impl(begin, end, p_forward, sgf_forward, make_index_sequence<p_sz>{});
}
auto parr(lint n) {
vector<nval<lint>> d;
lint n_ = n;
for (lint i = 2; i * i <= n; i++) {
if (n_ % i == 0) {
d.push_back(nval<lint>(1, i));
n_ /= i;
while (n_ % i == 0) {
n_ /= i;
d.back().n++;
}
}
}
if (n_ > 1) {
d.push_back(nval<lint>(1, n_));
}
return d;
}
auto dist_1(xy p, xy q) { return abs(p.x - q.x) + abs(p.y - q.y); }
auto dist_2(xy p, xy q) {
return sqrt((p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y));
}
auto dist_2(xyd p, xyd q) {
return sqrt((p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y));
}
auto dist_inf(xy p, xy q) { return mmax(abs(p.x - q.x), abs(p.y - q.y)); }
xyd center3p(xyd p[]) {
xyd ans;
long double a = p[0].x, b = p[0].y, c = p[1].x, d = p[1].y, e = p[2].x,
f = p[2].y;
long double aa = a * a, bb = b * b, cc = c * c, dd = d * d, ee = e * e,
ff = f * f;
ans.y = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee - ff)) /
(2 * (e - a) * (b - d) - 2 * (c - a) * (b - f));
if (c == a) {
ans.x = (2 * (b - f) * ans.y - aa - bb + ee + ff) / (2 * (e - a));
} else {
ans.x = (2 * (b - d) * ans.y - aa - bb + cc + dd) / (2 * (c - a));
}
return ans;
}
lint factr(lint n) {
if (n == 0) {
return 1;
}
lint ans = 1;
while (n > 1) {
ans *= n;
n--;
}
return ans;
}
lint mod0(lint n, lint mod) {
lint tmp = n % mod;
if (tmp == 0)
return mod;
return tmp;
}
char caesar(char s, lint key) {
if (between(s, 'A', 'Z')) {
return (s - 'A' + key) % alpn + 'A';
}
if (between(s, 'a', 'z')) {
return (s - 'a' + key) % alpn + 'a';
}
return s;
}
string caesar(string s, lint key) {
rep(i, s.length()) s[i] = caesar(s[i], key);
return s;
}
#define ret return 0;
template <class It> auto spacel(It i, It end) {
if (i + 1 == end) {
return '\n';
} else {
return ' ';
}
}
template <bool f> auto make_ptbl(lint n) {
vec_(a, n + 1, 0);
vec(p, 0);
repb(i, 2, n) {
if (a[i] == 1) {
continue;
}
p.push_back(i);
for (lint j = i * 2; j <= n; j += i) {
a[j] = 1;
}
}
if (f) {
return a;
} else {
return p;
}
}
template <class It> bool next_comb(lint n, It begin, It end) {
auto rend = make_reverse_iterator(begin);
auto rbegin = make_reverse_iterator(end);
auto rit = rbegin;
for (; rit != rend; rit++) {
if ((rit == rbegin && (*rit) + 1 != n) ||
(rit != rbegin && (*rit) + 1 != *(rit - 1))) {
goto found;
}
}
return false;
found:;
(*rit)++;
for (auto it = rit.base(); it != end; it++) {
(*it) = (*(it - 1)) + 1;
}
return true;
}
struct maze {
const char Wall = '#';
const char Road = '.';
vector<string> s;
lint h, w;
maze(lint _h, lint _w) : h(_h), w(_w), s(_h + 2) {}
void input() {
s[0] = string(w + 2, Wall);
s[h + 1] = string(w + 2, Wall);
rep(i, h) {
cin >> s[i + 1];
s[i + 1] = Wall + s[i + 1] + Wall;
}
}
bool isWall(lint x, lint y) { return s[y + 1][x + 1] == Wall; }
bool isWall(xy pos) { return s[pos.y + 1][pos.x + 1] == Wall; }
auto d_bfs(lint sx, lint sy) {
queue<xy> q;
q.push(xy(sx, sy));
vec2_(d, h, w, intmax);
d[sy][sx] = 0;
const xy dir[] = {xy(0, -1), xy(0, +1), xy(-1, 0), xy(+1, 0)};
while (q.size() > 0) {
auto pos = q.front();
q.pop();
lint dd = d[pos.y][pos.x];
rep(i, 4) {
xy next = xy(pos.x + dir[i].x, pos.y + dir[i].y);
if (!isWall(next.x, next.y) && d[next.y][next.x] > dd + 1) {
d[next.y][next.x] = dd + 1;
q.push(next);
}
}
}
return d;
}
};
struct graph_w {
struct road {
lint to;
lint w;
};
vector<vector<road>> gr;
lint n;
graph_w(lint _n) : gr(_n), n(_n){};
void input(lint m) {
rep(i, m) {
lint a, b, w;
cin >> a >> b >> w;
a--;
b--;
road atob, btoa;
atob.to = b;
atob.w = w;
btoa.to = a;
btoa.w = w;
gr[a].push_back(atob);
gr[b].push_back(btoa);
}
}
void d_dfs_impl(lint pos, vector<lint> &d) {
lint dd = d[pos];
rep(i, gr[pos].size()) {
lint child = gr[pos][i].to;
lint w = gr[pos][i].w;
if (d[child] > dd + w) {
d[child] = dd + w;
d_dfs_impl(child, d);
}
}
}
auto d_dfs(lint start) {
vector<lint> d(n, intmax);
d[start] = 0;
d_dfs_impl(start, d);
return d;
}
auto d_bfs(lint start) {
vector<lint> d(n, intmax);
d[start] = 0;
queue<lint> q;
q.push(start);
while (q.size() > 0) {
lint pos = q.front();
q.pop();
lint dd = d[pos];
rep(i, gr[pos].size()) {
lint child = gr[pos][i].to;
lint w = gr[pos][i].w;
if (d[child] > dd + w) {
d[child] = dd + w;
q.push(child);
}
}
}
return d;
}
};
const auto setp = setprecision(20);
#ifdef ATCODER_LOCAL
auto &lcout = cout;
#else
class dummy_cout : public ostream {
class dummy_stream : public streambuf {
public:
virtual int_type overflow(int_type iChar = EOF) { return iChar; }
};
unique_ptr<dummy_stream> stream;
public:
dummy_cout() : ostream((stream.reset(new dummy_stream), stream.get())) {}
} lcout;
#endif
} // namespace
lint dp[110][100010];
int main() {
lint n, w;
cin >> n >> w;
struct A {
lint w, v;
};
vect(A, a, n);
rep(i, n) cin >> a[i].w >> a[i].v;
rep(i, n + 1) {
rep(vv, 100010) {
if (vv != 0) {
dp[i][vv] = intmax;
}
}
}
rep(i, n) {
repbr(vv, 0, 100005) { dp[i][vv] = mmin(dp[i][vv], dp[i][vv + 1]); }
rep(vv, 99005) {
if (dp[i][vv] != intmax) {
dp[i + 1][vv] = mmin(dp[i + 1][vv], dp[i][vv]);
dp[i + 1][vv + a[i].v] =
mmin(dp[i + 1][vv + a[i].v], dp[i][vv] + a[i].w);
}
}
}
repbr(vv, 0, 100005) { dp[n][vv] = mmin(dp[n][vv], dp[n][vv + 1]); }
auto it = upper_bound(dp[n], dp[n] + 100010, w);
lcout << it - dp[n] - 1 << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <numeric>
#include <queue>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define rep(i, n) for (lint i = 0; i < n; i++)
#define repb(i, start, end) for (lint i = start; i <= end; i++)
#define repbr(i, start, end) for (lint i = end; i >= start; i--)
namespace {
using lint = long long;
using ulint = unsigned long long;
using ld = long double;
lint gcd(lint a, lint b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
const ulint mod = 1000000007;
const double pi = 3.141592653589793238462;
const lint intmax = 9223372036854775807;
lint FactMod(lint n) {
if (n == 0) {
return 1;
}
lint ans = 1;
while (n > 1) {
ans *= n;
n--;
ans %= mod;
}
return ans;
}
lint _PowMod(lint x, lint y, lint _mod) {
if (x <= 1) {
return x;
}
if (y == 0) {
return 1;
} else if (y == 1) {
return x % _mod;
} else if (y % 2 == 0) {
lint tmp = _PowMod(x, y / 2, _mod);
return tmp * tmp % _mod;
} else {
lint tmp = _PowMod(x, y / 2, _mod);
return (tmp * tmp % _mod) * x % _mod;
}
}
lint PowMod(lint x, lint y) { return _PowMod(x, y, mod); }
auto getModInv(lint N) { return PowMod(N, mod - 2); }
lint nCrMod(lint n, lint r, lint start) {
if (n < r || n < 0 || r < 0) {
return 0;
}
r = min(r, n - r);
lint a = start;
for (lint i = n; i >= n - r + 1; i--) {
a *= i;
a %= mod;
}
a *= getModInv(FactMod(r));
a %= mod;
return a;
}
lint nHrMod(lint n, lint r, lint start) { return nCrMod(n + r - 1, r, start); }
auto lcmMod(lint a, lint b) {
return (((a * getModInv(gcd(a, b))) % mod) * b) % mod;
}
template <class T> constexpr auto modK_belowN(T k, T MOD, T n) {
return (n + MOD - k - 1) / MOD;
}
struct uf {
vector<lint> p;
uf(lint n) : p(n) { rep(i, n) p[i] = i; }
lint rt(lint n) { return p[n] == n ? n : p[n] = rt(p[n]); }
void un(lint n, lint m) { p[rt(n)] = p[rt(m)]; }
bool eq(lint n, lint m) { return rt(n) == rt(m); }
};
template <class T>
bool lineCol(T a1x, T a1y, T a2x, T a2y, T b1x, T b1y, T b2x, T b2y) {
auto ta = (b1x - b2x) * (a1y - b1y) + (b1y - b2y) * (b1x - a1x);
auto tb = (b1x - b2x) * (a2y - b1y) + (b1y - b2y) * (b1x - a2x);
auto tc = (a1x - a2x) * (b1y - a1y) + (a1y - a2y) * (a1x - b1x);
auto td = (a1x - a2x) * (b2y - a1y) + (a1y - a2y) * (a1x - b2x);
return tc * td < 0 && ta * tb < 0;
}
lint powInt(lint a, lint b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
lint tmp = powInt(a, b / 2);
return (b % 2 == 1 ? a * tmp * tmp : tmp * tmp);
}
lint _sMod(string n, lint mod) {
lint k = (n[0] - '0') % mod;
for (lint i = 1; i < n.length(); i++) {
k *= 10;
k += (n[i] - '0');
k %= mod;
}
return k;
}
#define vec(name, n) vector<lint> name(n)
#define vec_(name, n, init) vector<lint> name(n, init)
#define vecs(name, n) vector<string> name(n)
#define vect(t, name, n) vector<t> name(n)
#define vec2(name, n, m) vector<vector<lint>> name(n, vector<lint>(m))
#define vec2_(name, n, m, init) \
vector<vector<lint>> name(n, vector<lint>(m, init))
template <class T> constexpr auto msum(T arg0) { return arg0; }
template <class T, class... Types> constexpr auto msum(T arg0, Types... args) {
static_assert(sizeof...(args) > 0, "arg err");
return arg0 + msum(args...);
}
template <class T> constexpr auto mmax(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmax(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return max(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmax(args...)));
}
template <class T> constexpr auto mmin(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmin(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return min(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmin(args...)));
}
constexpr auto clamp(lint val, lint left, lint right) {
return mmax(mmin(val, right), left);
}
lint div2(lint p, lint q) { return (p + q - 1) / q; }
struct xy {
lint x, y;
xy() : x(0), y(0) {}
xy(lint _x, lint _y) : x(_x), y(_y) {}
};
struct xyd {
long double x, y;
xyd() : x(0), y(0) {}
xyd(long double _x, long double _y) : x(_x), y(_y) {}
};
template <class It, class T> bool exist(It begin, It end, const T &val) {
return find(begin, end, val) != end;
}
template <class It, class Pr> bool exist_if(It begin, It end, Pr pred) {
return find_if(begin, end, pred) != end;
}
lint ndig(lint n) {
lint ans = 0;
while (n > 0) {
n /= 10;
ans++;
}
return ans;
}
const lint alpn = 'z' - 'a' + 1;
template <class T> T sgn(T val) {
if (val == T(0))
return T(0);
if (val < 0)
return T(-1);
if (val > 0)
return T(1);
}
template <class T> bool between(T val, T l, T r) {
return (val >= l) && (val <= r);
}
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
template <class It> vector<lint> carr(It begin, It end) {
vec(c, 0);
c.push_back(1);
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(0);
before = *it;
}
c.back()++;
}
return c;
}
template <class T> struct nval {
lint n;
T val;
nval() : n(0){};
nval(lint _n, T _val) : n(_n), val(_val){};
};
template <class It> auto carr2(It begin, It end) {
using T = nval<remove_reference_t<decltype(*begin)>>;
vect(T, c, 0);
c.push_back(T(1, *begin));
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(T(0, *it));
before = *it;
}
c.back().n++;
}
return c;
}
template <class It, class... T> void sort2(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p...](val_t a, val_t b) {
bool neq[] = {(a.*p != b.*p)...};
bool sg[] = {(a.*p < b.*p)...};
rep(i, sizeof...(p)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <size_t _K, size_t _N, class... Types, size_t... indices>
auto constexpr __ModKtuple_Impl(index_sequence<indices...>,
tuple<Types...> args) {
return make_tuple(get<indices * _N + _K>(args)...);
}
template <size_t K, size_t N, class... Types>
auto constexpr ModKtuple(Types... args) {
return __ModKtuple_Impl<K, N>(
make_index_sequence<modK_belowN(K, N, sizeof...(args))>{},
forward_as_tuple(args...));
}
template <class It, class... T, class... Tsg, size_t... indices>
void __sort3_Impl(It begin, It end, tuple<T...> p, tuple<Tsg...> sgf,
index_sequence<indices...>) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p, sgf](val_t a, val_t b) {
bool neq[] = {(a.*(get<indices>(p)) != b.*(get<indices>(p)))...};
bool sg[] = {((a.*(get<indices>(p)) < b.*(get<indices>(p))) !=
(get<indices>(sgf)))...};
rep(i, sizeof...(indices)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <class It, class... T> void sort3(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
auto p_forward = ModKtuple<0, 2>(p...);
auto sgf_forward = ModKtuple<1, 2>(p...);
constexpr auto p_sz = tuple_size<decltype(p_forward)>::value;
constexpr auto sgf_sz = tuple_size<decltype(sgf_forward)>::value;
static_assert(p_sz == sgf_sz, "arg err");
__sort3_Impl(begin, end, p_forward, sgf_forward, make_index_sequence<p_sz>{});
}
auto parr(lint n) {
vector<nval<lint>> d;
lint n_ = n;
for (lint i = 2; i * i <= n; i++) {
if (n_ % i == 0) {
d.push_back(nval<lint>(1, i));
n_ /= i;
while (n_ % i == 0) {
n_ /= i;
d.back().n++;
}
}
}
if (n_ > 1) {
d.push_back(nval<lint>(1, n_));
}
return d;
}
auto dist_1(xy p, xy q) { return abs(p.x - q.x) + abs(p.y - q.y); }
auto dist_2(xy p, xy q) {
return sqrt((p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y));
}
auto dist_2(xyd p, xyd q) {
return sqrt((p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y));
}
auto dist_inf(xy p, xy q) { return mmax(abs(p.x - q.x), abs(p.y - q.y)); }
xyd center3p(xyd p[]) {
xyd ans;
long double a = p[0].x, b = p[0].y, c = p[1].x, d = p[1].y, e = p[2].x,
f = p[2].y;
long double aa = a * a, bb = b * b, cc = c * c, dd = d * d, ee = e * e,
ff = f * f;
ans.y = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee - ff)) /
(2 * (e - a) * (b - d) - 2 * (c - a) * (b - f));
if (c == a) {
ans.x = (2 * (b - f) * ans.y - aa - bb + ee + ff) / (2 * (e - a));
} else {
ans.x = (2 * (b - d) * ans.y - aa - bb + cc + dd) / (2 * (c - a));
}
return ans;
}
lint factr(lint n) {
if (n == 0) {
return 1;
}
lint ans = 1;
while (n > 1) {
ans *= n;
n--;
}
return ans;
}
lint mod0(lint n, lint mod) {
lint tmp = n % mod;
if (tmp == 0)
return mod;
return tmp;
}
char caesar(char s, lint key) {
if (between(s, 'A', 'Z')) {
return (s - 'A' + key) % alpn + 'A';
}
if (between(s, 'a', 'z')) {
return (s - 'a' + key) % alpn + 'a';
}
return s;
}
string caesar(string s, lint key) {
rep(i, s.length()) s[i] = caesar(s[i], key);
return s;
}
#define ret return 0;
template <class It> auto spacel(It i, It end) {
if (i + 1 == end) {
return '\n';
} else {
return ' ';
}
}
template <bool f> auto make_ptbl(lint n) {
vec_(a, n + 1, 0);
vec(p, 0);
repb(i, 2, n) {
if (a[i] == 1) {
continue;
}
p.push_back(i);
for (lint j = i * 2; j <= n; j += i) {
a[j] = 1;
}
}
if (f) {
return a;
} else {
return p;
}
}
template <class It> bool next_comb(lint n, It begin, It end) {
auto rend = make_reverse_iterator(begin);
auto rbegin = make_reverse_iterator(end);
auto rit = rbegin;
for (; rit != rend; rit++) {
if ((rit == rbegin && (*rit) + 1 != n) ||
(rit != rbegin && (*rit) + 1 != *(rit - 1))) {
goto found;
}
}
return false;
found:;
(*rit)++;
for (auto it = rit.base(); it != end; it++) {
(*it) = (*(it - 1)) + 1;
}
return true;
}
struct maze {
const char Wall = '#';
const char Road = '.';
vector<string> s;
lint h, w;
maze(lint _h, lint _w) : h(_h), w(_w), s(_h + 2) {}
void input() {
s[0] = string(w + 2, Wall);
s[h + 1] = string(w + 2, Wall);
rep(i, h) {
cin >> s[i + 1];
s[i + 1] = Wall + s[i + 1] + Wall;
}
}
bool isWall(lint x, lint y) { return s[y + 1][x + 1] == Wall; }
bool isWall(xy pos) { return s[pos.y + 1][pos.x + 1] == Wall; }
auto d_bfs(lint sx, lint sy) {
queue<xy> q;
q.push(xy(sx, sy));
vec2_(d, h, w, intmax);
d[sy][sx] = 0;
const xy dir[] = {xy(0, -1), xy(0, +1), xy(-1, 0), xy(+1, 0)};
while (q.size() > 0) {
auto pos = q.front();
q.pop();
lint dd = d[pos.y][pos.x];
rep(i, 4) {
xy next = xy(pos.x + dir[i].x, pos.y + dir[i].y);
if (!isWall(next.x, next.y) && d[next.y][next.x] > dd + 1) {
d[next.y][next.x] = dd + 1;
q.push(next);
}
}
}
return d;
}
};
struct graph_w {
struct road {
lint to;
lint w;
};
vector<vector<road>> gr;
lint n;
graph_w(lint _n) : gr(_n), n(_n){};
void input(lint m) {
rep(i, m) {
lint a, b, w;
cin >> a >> b >> w;
a--;
b--;
road atob, btoa;
atob.to = b;
atob.w = w;
btoa.to = a;
btoa.w = w;
gr[a].push_back(atob);
gr[b].push_back(btoa);
}
}
void d_dfs_impl(lint pos, vector<lint> &d) {
lint dd = d[pos];
rep(i, gr[pos].size()) {
lint child = gr[pos][i].to;
lint w = gr[pos][i].w;
if (d[child] > dd + w) {
d[child] = dd + w;
d_dfs_impl(child, d);
}
}
}
auto d_dfs(lint start) {
vector<lint> d(n, intmax);
d[start] = 0;
d_dfs_impl(start, d);
return d;
}
auto d_bfs(lint start) {
vector<lint> d(n, intmax);
d[start] = 0;
queue<lint> q;
q.push(start);
while (q.size() > 0) {
lint pos = q.front();
q.pop();
lint dd = d[pos];
rep(i, gr[pos].size()) {
lint child = gr[pos][i].to;
lint w = gr[pos][i].w;
if (d[child] > dd + w) {
d[child] = dd + w;
q.push(child);
}
}
}
return d;
}
};
const auto setp = setprecision(20);
#ifdef ATCODER_LOCAL
auto &lcout = cout;
#else
class dummy_cout : public ostream {
class dummy_stream : public streambuf {
public:
virtual int_type overflow(int_type iChar = EOF) { return iChar; }
};
unique_ptr<dummy_stream> stream;
public:
dummy_cout() : ostream((stream.reset(new dummy_stream), stream.get())) {}
} lcout;
#endif
} // namespace
lint dp[110][100010];
int main() {
lint n, w;
cin >> n >> w;
struct A {
lint w, v;
};
vect(A, a, n);
rep(i, n) cin >> a[i].w >> a[i].v;
rep(i, n + 1) {
rep(vv, 100010) {
if (vv != 0) {
dp[i][vv] = intmax;
}
}
}
rep(i, n) {
repbr(vv, 0, 100005) { dp[i][vv] = mmin(dp[i][vv], dp[i][vv + 1]); }
rep(vv, 99005) {
if (dp[i][vv] != intmax) {
dp[i + 1][vv] = mmin(dp[i + 1][vv], dp[i][vv]);
dp[i + 1][vv + a[i].v] =
mmin(dp[i + 1][vv + a[i].v], dp[i][vv] + a[i].w);
}
}
}
repbr(vv, 0, 100005) { dp[n][vv] = mmin(dp[n][vv], dp[n][vv + 1]); }
auto it = upper_bound(dp[n], dp[n] + 100010, w);
cout << it - dp[n] - 1 << endl;
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 970,260 | 970,261 | u275797573 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[100100], value[100100];
ll dp[110][100100];
int main() {
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 < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[100100], value[100100];
ll dp[110][100100];
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> weight[i] >> value[i];
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 970,273 | 970,274 | u195054737 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110];
ll dp[110][100100];
int main() {
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 < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[100100], value[100100];
ll dp[110][100100];
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> weight[i] >> value[i];
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 970,275 | 970,274 | u195054737 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[100100], value[100100];
ll dp[110][100100];
int main() {
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 < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[100100], value[100100];
ll dp[110][100100];
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> weight[i] >> value[i];
for (int i = 0; i < 110; i++)
for (int j = 0; j < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 970,273 | 970,277 | u195054737 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110];
ll dp[110][100100];
int main() {
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 < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[100100], value[100100];
ll dp[110][100100];
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> weight[i] >> value[i];
for (int i = 0; i < 110; i++)
for (int j = 0; j < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 970,275 | 970,277 | u195054737 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110];
ll dp[110][100100];
int main() {
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 < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = inf;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[100100], value[100100];
ll dp[110][100100];
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> weight[i] >> value[i];
for (int i = 0; i < 110; i++)
for (int j = 0; j < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.value.change"
] | 970,278 | 970,277 | u195054737 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110];
ll dp[110][100100];
int main() {
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 < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110], dp[110][100100];
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> weight[i] >> value[i];
for (int i = 0; i < 110; i++)
for (int j = 0; j < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 970,275 | 970,279 | u195054737 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110];
ll dp[110][100100];
int main() {
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 < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = inf;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110], dp[110][100100];
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> weight[i] >> value[i];
for (int i = 0; i < 110; i++)
for (int j = 0; j < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.value.change"
] | 970,278 | 970,279 | u195054737 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110];
ll dp[110][100100];
int main() {
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 < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110];
ll dp[110][100100];
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> weight[i] >> value[i];
for (int i = 0; i < 110; i++)
for (int j = 0; j < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 970,275 | 970,280 | u195054737 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110];
ll dp[110][100100];
int main() {
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 < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = inf;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, w, weight[110], value[110];
ll dp[110][100100];
int main() {
cin >> n >> w;
for (int i = 0; i < n; i++)
cin >> weight[i] >> value[i];
for (int i = 0; i < 110; i++)
for (int j = 0; j < 100100; j++)
dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100100; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll res = 0;
for (int i = 0; i < 100100; i++) {
if (dp[n][i] <= w)
res = i;
}
cout << res << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.value.change"
] | 970,278 | 970,280 | u195054737 | cpp |
p03164 | #include <bits/stdc++.h>
#include <cmath>
#include <string>
using namespace std;
#define f first
#define s second
#define MOD 1000000007
#define fast ios::sync_with_stdio(0), cout.tie(0), cin.tie(0)
#define pb push_back
#define fo(i, a, b) for (i = a; i < b; i++)
#define foe(i, a, b) for (i = a; i <= b; i++)
#define mp make_pair
#define mkt make_tuple
#define deb(x) cerr << #x << " " << x << "\n"
#define debi cerr << "wait\n"
#define INF (ll)1e18 + 5
typedef long long ll;
typedef unsigned long long ull;
class solution {
public:
void solve() {
ll n, w;
cin >> n >> w;
vector<pair<ll, ll>> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].f >> v[i].s;
}
vector<ll> dp((int)(1e5 + 1), INF);
vector<ll> newdp((int)(1e5 + 1), INF);
ll poss = (int)(1e5 + 1);
// deb(poss);
dp[0] = 0;
newdp[0] = 0;
for (int i = 0; i < n; i++) {
for (int value = 0; value < poss; value++) {
if (value + v[i].s < poss) {
ll a = dp[value] + v[i].f;
ll val = dp[value + v[i].s];
newdp[value + v[i].s] = min(val, a);
}
}
dp = newdp;
}
ll ma = 0;
for (int i = 0; i <= poss; i++) {
// deb(dp[i]);
if (dp[i] <= w) {
ma = i;
}
}
cout << ma;
}
};
int main() {
fast;
ll i = 0;
solution s;
s.solve();
return 0;
}
| #include <bits/stdc++.h>
#include <cmath>
#include <string>
using namespace std;
#define f first
#define s second
#define MOD 1000000007
#define fast ios::sync_with_stdio(0), cout.tie(0), cin.tie(0)
#define pb push_back
#define fo(i, a, b) for (i = a; i < b; i++)
#define foe(i, a, b) for (i = a; i <= b; i++)
#define mp make_pair
#define mkt make_tuple
#define deb(x) cerr << #x << " " << x << "\n"
#define debi cerr << "wait\n"
#define INF (ll)1e18 + 5
typedef long long ll;
typedef unsigned long long ull;
class solution {
public:
void solve() {
ll n, w;
cin >> n >> w;
vector<pair<ll, ll>> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].f >> v[i].s;
}
vector<ll> dp((int)(1e5 + 1), INF);
vector<ll> newdp((int)(1e5 + 1), INF);
ll poss = (int)(1e5 + 1);
// deb(poss);
dp[0] = 0;
newdp[0] = 0;
for (int i = 0; i < n; i++) {
for (int value = 0; value < poss; value++) {
if (value + v[i].s < poss) {
ll a = dp[value] + v[i].f;
ll val = dp[value + v[i].s];
newdp[value + v[i].s] = min(val, a);
}
}
dp = newdp;
}
ll ma = 0;
for (int i = 0; i < poss; i++) {
// deb(dp[i]);
if (dp[i] <= w) {
ma = i;
}
}
cout << ma;
}
};
int main() {
fast;
ll i = 0;
solution s;
s.solve();
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 970,302 | 970,303 | u972597110 | cpp |
p03164 | #include "bits/stdc++.h"
#include <math.h>
#include <time.h>
using namespace std;
const long long mod = 1000000007;
#define ll long long
#define dump(x) \
if (dbg) { \
cout << #x << " = " << (x) << endl; \
}
bool dbg = false;
long long gcd(long long a, long long b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
//---------------------------------------------------------------------------------------------------
/*ここからいじる*/
//---------------------------------------------------------------------------------------------------
void solve() {}
int main() {
ll INF = 1e9;
ll n, w;
cin >> n >> w;
vector<vector<ll>> data(n + 1, vector<ll>(2));
for (int i = 1; i <= n; i++) {
cin >> data.at(i).at(0) >> data.at(i).at(1);
}
ll sum = 0;
ll V = 100010;
vector<vector<ll>> dp(n + 1, vector<ll>(V + 1));
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= V; j++) {
dp.at(i).at(j) = INF;
}
}
dp.at(0).at(0) = 0;
for (int i = 1; i <= n; i++) {
sum += data.at(i).at(1);
for (int j = 0; j <= V; j++) {
if (data.at(i).at(1) >= j)
dp.at(i).at(j) =
min(dp.at(i - 1).at(j), dp.at(i - 1).at(0) + data.at(i).at(1));
else
dp.at(i).at(j) =
min(dp.at(i - 1).at(j),
dp.at(i - 1).at(j - data.at(i).at(1)) + data.at(i).at(0));
if (dp.at(i).at(j) > w)
dp.at(i).at(j) = INF;
if (j == sum)
break;
}
}
for (int i = V; i >= 0; i--) {
if (dp.at(n).at(i) != INF) {
cout << i << endl;
break;
}
}
return 0;
}
| #include "bits/stdc++.h"
#include <math.h>
#include <time.h>
using namespace std;
const long long mod = 1000000007;
#define ll long long
#define dump(x) \
if (dbg) { \
cout << #x << " = " << (x) << endl; \
}
bool dbg = false;
long long gcd(long long a, long long b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
//---------------------------------------------------------------------------------------------------
/*ここからいじる*/
//---------------------------------------------------------------------------------------------------
void solve() {}
int main() {
ll INF = 1e10;
ll n, w;
cin >> n >> w;
vector<vector<ll>> data(n + 1, vector<ll>(2));
for (int i = 1; i <= n; i++) {
cin >> data.at(i).at(0) >> data.at(i).at(1);
}
ll sum = 0;
ll V = 100010;
vector<vector<ll>> dp(n + 1, vector<ll>(V + 1));
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= V; j++) {
dp.at(i).at(j) = INF;
}
}
dp.at(0).at(0) = 0;
for (int i = 1; i <= n; i++) {
sum += data.at(i).at(1);
for (int j = 0; j <= V; j++) {
if (data.at(i).at(1) >= j)
dp.at(i).at(j) =
min(dp.at(i - 1).at(j), dp.at(i - 1).at(0) + data.at(i).at(0));
else
dp.at(i).at(j) =
min(dp.at(i - 1).at(j),
dp.at(i - 1).at(j - data.at(i).at(1)) + data.at(i).at(0));
if (dp.at(i).at(j) > w)
dp.at(i).at(j) = INF;
if (j == sum)
break;
}
}
for (int i = V; i >= 0; i--) {
if (dp.at(n).at(i) != INF) {
cout << i << endl;
break;
}
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 970,307 | 970,308 | u938841444 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
int main() {
int n;
long long int W;
cin >> n >> W;
vector<long long int> w(n), v(n);
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
// dp[i][j] = max_value among realization of value <= j, using up to i-th
// item)
vector<vector<long long int>> dp(n + 1,
vector<long long int>(1000 * n + 1, INF));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 1000 * n + 1; j++) {
if (j >= v[i])
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - v[i]] + w[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
int ans = 0;
for (int j = 0; j <= 1000 * n + 1; j++) {
if (dp[n][j] <= W)
ans = j;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
int main() {
int n;
long long int W;
cin >> n >> W;
vector<long long int> w(n), v(n);
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
// dp[i][j] = max_value among realization of value <= j, using up to i-th
// item)
vector<vector<long long int>> dp(n + 1,
vector<long long int>(1000 * n + 1, INF));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 1000 * n; j++) {
if (j >= v[i])
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - v[i]] + w[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
long long int ans = 0;
for (int j = 0; j <= 1000 * n; j++) {
if (dp[n][j] <= W)
ans = j;
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 970,317 | 970,318 | u180716041 | cpp |
p03164 | #include <algorithm>
#include <iostream>
using namespace std;
const long long INF = 100000000;
int w[110], v[110];
long long dp[110][100010];
int main() {
int n, W;
long long res = 0;
cin >> n >> W;
for (int i = 0; i < n; ++i) {
cin >> w[i] >> v[i];
}
for (int i = 0; i < 110; ++i)
for (int j = 0; j < 100010; ++j)
dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 100010; ++j) {
if (v[i] <= j)
dp[i + 1][j] = dp[i][j - v[i]] + w[i];
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
for (int i = 100010 - 1; i >= 0; --i)
if (dp[n][i] <= W) {
res = i;
break;
}
cout << res << endl;
}
| #include <algorithm>
#include <iostream>
using namespace std;
const long long INF = 1000000100;
int w[110], v[110];
long long dp[110][100010];
int main() {
int n, W;
long long res = 0;
cin >> n >> W;
for (int i = 0; i < n; ++i) {
cin >> w[i] >> v[i];
}
for (int i = 0; i < 110; ++i)
for (int j = 0; j < 100010; ++j)
dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 100010; ++j) {
if (v[i] <= j)
dp[i + 1][j] = dp[i][j - v[i]] + w[i];
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
for (int i = 100010 - 1; i >= 0; --i)
if (dp[n][i] <= W) {
res = i;
break;
}
cout << res << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 970,325 | 970,326 | u590427200 | cpp |
p03164 | #include <algorithm>
#include <iostream>
using namespace std;
const long long INF = 100000000;
int w[110], v[110];
long long dp[110][100010];
int main() {
int n, W, res = 0;
cin >> n >> W;
for (int i = 0; i < n; ++i) {
cin >> w[i] >> v[i];
}
for (int i = 0; i < 110; ++i)
for (int j = 0; j < 100010; ++j)
dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 100010; ++j) {
if (v[i] <= j)
dp[i + 1][j] = dp[i][j - v[i]] + w[i];
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
for (int i = 100010 - 1; i >= 0; --i)
if (dp[n][i] <= W) {
res = i;
break;
}
cout << res << endl;
}
| #include <algorithm>
#include <iostream>
using namespace std;
const long long INF = 1000000100;
int w[110], v[110];
long long dp[110][100010];
int main() {
int n, W;
long long res = 0;
cin >> n >> W;
for (int i = 0; i < n; ++i) {
cin >> w[i] >> v[i];
}
for (int i = 0; i < 110; ++i)
for (int j = 0; j < 100010; ++j)
dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 100010; ++j) {
if (v[i] <= j)
dp[i + 1][j] = dp[i][j - v[i]] + w[i];
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
for (int i = 100010 - 1; i >= 0; --i)
if (dp[n][i] <= W) {
res = i;
break;
}
cout << res << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 970,327 | 970,326 | u590427200 | cpp |
p03164 | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define print(x) cout << (x) << endl;
#define printa(x, n) \
for (ll i = 0; i < n; i++) { \
cout << (x[i]) << " "; \
} \
cout << endl;
using namespace std;
using ll = long long;
const int INF = 1e9 + 7;
vector<vector<ll>> dp(105, vector<ll>(100005, INF));
// dp[i][j] := 品物をi個まで見終わった後での価値jを作るための最小の重さ
int main(void) {
ll n, W;
cin >> n >> W;
ll w[n + 1], v[n + 1];
rep(i, n) cin >> w[i + 1] >> v[i + 1];
for (int i = 0; i <= n; i++)
dp[i][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 100005; j++) {
dp[i][j] = min(dp[i][j], dp[i - 1][j]);
if (j - v[i] >= 0) {
dp[i][j] = min(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
}
}
}
// cout << dp[n][10] << endl;
ll ans = 0;
for (int i = 1; i <= 100003; i++) {
if (dp[n][i] == INF)
continue;
if (dp[n][i] > W)
break;
// cout << i << endl;
ans = max(ans, (ll)i);
}
// rep (i, 11) cout << i <<" "<<dp[n][i] << endl;
// cout << dp[n][100005] << endl;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define print(x) cout << (x) << endl;
#define printa(x, n) \
for (ll i = 0; i < n; i++) { \
cout << (x[i]) << " "; \
} \
cout << endl;
using namespace std;
using ll = long long;
const int INF = 1e9 + 7;
vector<vector<ll>> dp(105, vector<ll>(100005, INF));
// dp[i][j] := 品物をi個まで見終わった後での価値jを作るための最小の重さ
int main(void) {
ll n, W;
cin >> n >> W;
ll w[n + 1], v[n + 1];
rep(i, n) cin >> w[i + 1] >> v[i + 1];
for (int i = 0; i <= n; i++)
dp[i][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 100005; j++) {
dp[i][j] = min(dp[i][j], dp[i - 1][j]);
if (j - v[i] >= 0) {
dp[i][j] = min(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
}
}
}
// cout << dp[n][10] << endl;
int ans = 0;
for (int i = 1; i <= 100003; i++) {
if (dp[n][i] == INF)
continue;
if (dp[n][i] > W)
continue;
// cout << i << endl;
ans = max(ans, i);
}
// rep (i, 11) cout << i <<" "<<dp[n][i] << endl;
// cout << dp[n][100005] << endl;
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change",
"control_flow.break.remove",
"control_flow.continue.add"
] | 970,344 | 970,345 | u174509352 | cpp |
p03164 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
typedef long long ll;
long long MOD = 1e9 + 7;
const long long INF = 1LL << 60;
using namespace std;
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;
}
// dp[i][j] := i番目までの商品から価値がv以上になるように選んだ時の重さの最小値
ll dp[110][100001];
int main() {
int n, w_limit;
cin >> n >> w_limit;
repi(i, 0, n + 1) repi(j, 0, 100001) dp[i][j] = INF;
dp[0][0] = 0;
int w[n + 1], v[n + 1];
repi(i, 1, n + 1) { cin >> w[i] >> v[i]; }
repi(i, 1, n + 1) {
repi(j, 0, 100001) {
if (j - v[i] >= 0) {
// i番目の商品を選べる
chmin(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
} else {
// i番目の商品を選べない
chmin(dp[i][j], dp[i - 1][j]);
}
}
}
ll ans = 100000;
while (dp[n][ans] > w_limit)
ans--;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
typedef long long ll;
long long MOD = 1e9 + 7;
const long long INF = 1LL << 60;
using namespace std;
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;
}
// dp[i][j] := i番目までの商品から価値がv以上になるように選んだ時の重さの最小値
ll dp[110][100001];
int main() {
int n, w_limit;
cin >> n >> w_limit;
repi(i, 0, n + 1) repi(j, 0, 100001) dp[i][j] = INF;
dp[0][0] = 0;
int w[n + 1], v[n + 1];
repi(i, 1, n + 1) { cin >> w[i] >> v[i]; }
repi(i, 1, n + 1) {
repi(j, 0, 100001) {
// i番目の商品を選ぶ
if (j - v[i] >= 0) {
chmin(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
}
// i番目の商品を選ばない
chmin(dp[i][j], dp[i - 1][j]);
}
}
ll ans = 100000;
while (dp[n][ans] > w_limit)
ans--;
cout << ans << endl;
return 0;
} | [] | 970,346 | 970,347 | u138597672 | cpp |
p03164 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
typedef long long ll;
long long MOD = 1e9 + 7;
const long long INF = 1LL << 60;
using namespace std;
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;
}
// dp[i][j] := i番目までの商品から価値がv以上になるように選んだ時の重さの最小値
ll dp[110][100001];
int main() {
int n, w_limit;
cin >> n >> w_limit;
repi(i, 0, n + 1) repi(j, 0, 100001) dp[i][j] = INF;
dp[0][0] = 0;
int w[n + 1], v[n + 1];
repi(i, 1, n + 1) { cin >> w[i] >> v[i]; }
repi(i, 1, n + 1) {
repi(j, 0, 100001) {
if (j - v[i] >= 0) {
// i番目の商品を選べる
chmin(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
chmin(dp[i][j], dp[i - 1][j - 1]);
} else {
// i番目の商品を選べない
chmin(dp[i][j], dp[i - 1][j]);
}
}
}
ll ans = 100000;
while (dp[n][ans] > w_limit)
ans--;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
typedef long long ll;
long long MOD = 1e9 + 7;
const long long INF = 1LL << 60;
using namespace std;
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;
}
// dp[i][j] := i番目までの商品から価値がv以上になるように選んだ時の重さの最小値
ll dp[110][100001];
int main() {
int n, w_limit;
cin >> n >> w_limit;
repi(i, 0, n + 1) repi(j, 0, 100001) dp[i][j] = INF;
dp[0][0] = 0;
int w[n + 1], v[n + 1];
repi(i, 1, n + 1) { cin >> w[i] >> v[i]; }
repi(i, 1, n + 1) {
repi(j, 0, 100001) {
if (j - v[i] >= 0) {
// i番目の商品を選べる
chmin(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
chmin(dp[i][j], dp[i - 1][j]);
} else {
// i番目の商品を選べない
chmin(dp[i][j], dp[i - 1][j]);
}
}
}
ll ans = 100000;
while (dp[n][ans] > w_limit)
ans--;
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 970,348 | 970,349 | u138597672 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define pf push_front
#define speed_up ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
#define debug cerr << "OK\n";
#define ub upper_bound
#define lb lower_bound
#define treap_pair pair<treap *, treap *>
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef set<int> si;
typedef set<ll> sll;
typedef multiset<int> msi;
typedef multiset<ll> msll;
typedef map<int, int> mi;
typedef map<ll, ll> mll;
const int N = 2e5 + 2;
const int M = 1e5 + 2;
const int mod = 1e9 + 7;
const int inf = 1e9;
const ll INF = 1e18 + 100;
void data() {
#ifdef PC
freopen("main.in", "r", stdin);
freopen("main.out", "w", stdout);
#endif
}
template <typename T> void scerr(T nums) {
for (auto it : nums)
cerr << it << " | ";
cerr << "\n";
}
ll n, c, w[N], v[N], dp[N];
int ans = -inf;
int main() {
data();
scanf("%lld %lld", &n, &c);
for (int i = 1; i <= n; ++i)
scanf("%lld %lld", &w[i], &v[i]);
for (int i = 0; i < N; ++i)
dp[i] = INF;
dp[0] = INF;
for (int i = 1; i <= n; ++i)
for (int j = N - 1; j >= v[i]; --j)
dp[j] = min(dp[j - v[i]] + w[i], dp[j]);
for (int i = N - 1; i >= 0; --i) {
if (dp[i] <= c)
ans = max(ans, i);
}
printf("%d", ans + 1);
}
/*
Timus: 288481RF
CodeForces: fractal
*/
| #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define pf push_front
#define speed_up ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
#define debug cerr << "OK\n";
#define ub upper_bound
#define lb lower_bound
#define treap_pair pair<treap *, treap *>
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef set<int> si;
typedef set<ll> sll;
typedef multiset<int> msi;
typedef multiset<ll> msll;
typedef map<int, int> mi;
typedef map<ll, ll> mll;
const int N = 2e5 + 2;
const int M = 1e5 + 2;
const int mod = 1e9 + 7;
const int inf = 1e9;
const ll INF = 1e18 + 100;
void data() {
#ifdef PC
freopen("main.in", "r", stdin);
freopen("main.out", "w", stdout);
#endif
}
template <typename T> void scerr(T nums) {
for (auto it : nums)
cerr << it << " | ";
cerr << "\n";
}
ll n, c, w[N], v[N], dp[N];
int ans = -inf;
int main() {
data();
scanf("%lld %lld", &n, &c);
for (int i = 1; i <= n; ++i)
scanf("%lld %lld", &w[i], &v[i]);
for (int i = 0; i < N; ++i)
dp[i] = INF;
dp[0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = N - 1; j >= v[i]; --j)
dp[j] = min(dp[j - v[i]] + w[i], dp[j]);
for (int i = N - 1; i >= 0; --i)
if (dp[i] <= c)
ans = max(ans, i);
printf("%d", ans);
}
/*
Timus: 288481RF
CodeForces: fractal
*/
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.remove"
] | 970,355 | 970,356 | u426777622 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define pf push_front
#define speed_up ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
#define debug cerr << "OK\n";
#define ub upper_bound
#define lb lower_bound
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef set<int> si;
typedef set<ll> sll;
typedef multiset<int> msi;
typedef multiset<ll> msll;
typedef map<int, int> mi;
typedef map<ll, int> mll;
const int N = 1e5 + 2;
const int M = 1e5 + 2;
const int mod = 1e9 + 7;
const int inf = 1e9;
const ll INF = 1e16;
void data() {
#ifdef PC
freopen("main.in", "r", stdin);
freopen("main.out", "w", stdout);
#endif
}
void scerr(vi nums) {
for (auto it : nums)
cerr << it << " | ";
cerr << "\n";
}
int n;
ll w, dp[N], arr[N], brr[N];
int main() {
data();
for (int i = 0; i < N; ++i)
dp[i] = inf;
dp[0] = 0;
scanf("%d %lld", &n, &w);
for (int i = 1; i <= n; ++i)
scanf("%lld %d", &arr[i], &brr[i]);
for (int i = 1; i <= n; ++i)
for (int j = N - 1; j >= brr[i]; --j)
dp[j] = min(dp[j], dp[j - brr[i]] + arr[i]);
for (int i = N - 1; i >= 0; --i)
if (dp[i] <= w) {
printf("%d", i);
return 0;
}
return 0;
}
/*
Timus: 288481RF
CodeForces: __fractal
*/ | #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define pf push_front
#define speed_up ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
#define debug cerr << "OK\n";
#define ub upper_bound
#define lb lower_bound
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef set<int> si;
typedef set<ll> sll;
typedef multiset<int> msi;
typedef multiset<ll> msll;
typedef map<int, int> mi;
typedef map<ll, int> mll;
const int N = 1e5 + 2;
const int M = 1e5 + 2;
const int mod = 1e9 + 7;
const int inf = 1e9;
const ll INF = 1e16;
void data() {
#ifdef PC
freopen("main.in", "r", stdin);
freopen("main.out", "w", stdout);
#endif
}
void scerr(vi nums) {
for (auto it : nums)
cerr << it << " | ";
cerr << "\n";
}
int n;
ll w, dp[N], arr[N], brr[N];
int main() {
data();
for (int i = 0; i < N; ++i)
dp[i] = INF;
dp[0] = 0;
scanf("%d %lld", &n, &w);
for (int i = 1; i <= n; ++i)
scanf("%lld %d", &arr[i], &brr[i]);
for (int i = 1; i <= n; ++i)
for (int j = N - 1; j >= brr[i]; --j)
dp[j] = min(dp[j], dp[j - brr[i]] + arr[i]);
for (int i = N - 1; i >= 0; --i)
if (dp[i] <= w) {
printf("%d", i);
return 0;
}
return 0;
}
/*
Timus: 288481RF
CodeForces: __fractal
*/
| [
"assignment.value.change",
"identifier.change"
] | 970,357 | 970,358 | u426777622 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
long long w[n + 1], v[n + 1];
for (int i = 1; i <= n; i++)
cin >> w[i] >> v[i];
long long dp[n + 1][1000005];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 1000000; j++) {
if (j == 0) {
dp[i][j] = 0;
continue;
}
if (i == 0) {
dp[i][j] = 1000000000001;
continue;
}
dp[i][j] = dp[i - 1][j];
if (v[i] <= j && dp[i - 1][j - v[i]] != 1000000000001)
dp[i][j] = min(dp[i][j], w[i] + dp[i - 1][j - v[i]]);
}
}
int ans = 0;
for (int i = 0; i <= 1000000; i++)
if (dp[n][i] <= c)
ans = i;
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
long long w[n + 1], v[n + 1];
for (int i = 1; i <= n; i++)
cin >> w[i] >> v[i];
long long dp[n + 1][100005];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 100000; j++) {
if (j == 0) {
dp[i][j] = 0;
continue;
}
if (i == 0) {
dp[i][j] = 1000000000001;
continue;
}
dp[i][j] = dp[i - 1][j];
if (v[i] <= j && dp[i - 1][j - v[i]] != 1000000000001)
dp[i][j] = min(dp[i][j], w[i] + dp[i - 1][j - v[i]]);
}
}
int ans = 0;
for (int i = 0; i <= 100000; i++)
if (dp[n][i] <= c)
ans = i;
cout << ans;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 970,373 | 970,374 | u658960571 | cpp |
p03164 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit32(x) (1 << (x))
#define bit64(x) (1ll << (x))
using namespace std;
using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vu64 = vector<u64>;
using vf80 = vector<f80>;
using vstr = vector<string>;
inline void yes() {
cout << "Yes" << '\n';
exit(0);
}
inline void no() {
cout << "No" << '\n';
exit(0);
}
inline i64 gcd(i64 a, i64 b) {
if (min(a, b) == 0)
return max(a, b);
if (a % b == 0)
return b;
return gcd(b, a % b);
}
inline i64 lcm(i64 a, i64 b) {
if (min(a, b) == 0)
return max(a, b);
return a / gcd(a, b) * b;
}
inline u64 xorshift() {
static u64 x = 88172645463325252ull;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
template <typename T>
class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T>
class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) {
if (x < y)
x = y;
}
template <typename T> inline void amin(T &x, T y) {
if (x > y)
x = y;
}
template <typename T> inline T exp(T x, i64 n, T e = 1) {
T r = e;
while (n > 0) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
template <typename T> inline T bis(T ok, T ng, function<bool(T)> f, T eps = 1) {
while (abs(ok - ng) > eps) {
T mi = (ok + ng) / 2;
(f(mi) ? ok : ng) = mi;
}
return ok;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
each(x, v) is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
rep(i, v.size()) {
if (i)
os << ' ';
os << v[i];
}
return os;
}
void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(16);
solve();
return 0;
}
i64 dp[101][100001];
void solve() {
int N, W;
cin >> N >> W;
rep(i, 101) rep(j, 100001) dp[i][j] = 1e9;
dp[0][0] = 0;
rep(i, N) {
int w, v;
cin >> w >> v;
rep(j, 100001) {
if (dp[i][j] == 1e9)
continue;
amin(dp[i + 1][j], dp[i][j]);
amin(dp[i + 1][j + v], dp[i][j] + w);
}
}
int ans = -1e9;
repc(j, 100000) if (dp[N][j] <= W) { amax(ans, j); }
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit32(x) (1 << (x))
#define bit64(x) (1ll << (x))
using namespace std;
using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vu64 = vector<u64>;
using vf80 = vector<f80>;
using vstr = vector<string>;
inline void yes() {
cout << "Yes" << '\n';
exit(0);
}
inline void no() {
cout << "No" << '\n';
exit(0);
}
inline i64 gcd(i64 a, i64 b) {
if (min(a, b) == 0)
return max(a, b);
if (a % b == 0)
return b;
return gcd(b, a % b);
}
inline i64 lcm(i64 a, i64 b) {
if (min(a, b) == 0)
return max(a, b);
return a / gcd(a, b) * b;
}
inline u64 xorshift() {
static u64 x = 88172645463325252ull;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
template <typename T>
class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T>
class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) {
if (x < y)
x = y;
}
template <typename T> inline void amin(T &x, T y) {
if (x > y)
x = y;
}
template <typename T> inline T exp(T x, i64 n, T e = 1) {
T r = e;
while (n > 0) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
template <typename T> inline T bis(T ok, T ng, function<bool(T)> f, T eps = 1) {
while (abs(ok - ng) > eps) {
T mi = (ok + ng) / 2;
(f(mi) ? ok : ng) = mi;
}
return ok;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
each(x, v) is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
rep(i, v.size()) {
if (i)
os << ' ';
os << v[i];
}
return os;
}
void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(16);
solve();
return 0;
}
i64 dp[101][100001];
void solve() {
int N, W;
cin >> N >> W;
rep(i, 101) rep(j, 100001) dp[i][j] = 2e9;
dp[0][0] = 0;
rep(i, N) {
int w, v;
cin >> w >> v;
rep(j, 100001) {
if (dp[i][j] == 2e9)
continue;
amin(dp[i + 1][j], dp[i][j]);
amin(dp[i + 1][j + v], dp[i][j] + w);
}
}
int ans = -1e9;
repc(j, 100000) if (dp[N][j] <= W) { amax(ans, j); }
cout << ans << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"control_flow.branch.if.condition.change"
] | 970,381 | 970,382 | u908318580 | cpp |
p03164 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
ll W;
cin >> N >> W;
vector<ll> w(N, 0);
vector<ll> v(N, 0);
REP(i, N) { cin >> w[i] >> v[i]; }
ll INF = 1e18;
vector<vector<ll>> dp(N + 1, vector<ll>(1e5 + 1, INF));
dp[0][0] = 0;
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= 1e5; j++) {
if (j - v[i] >= 0) {
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
ll ans = 0;
for (int j = 1e5; j > 0; j--) {
if (dp[N][j] <= W) {
ans = j;
break;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
ll W;
cin >> N >> W;
vector<ll> w(N, 0);
vector<ll> v(N, 0);
REP(i, N) { cin >> w[i] >> v[i]; }
ll INF = 1e18;
vector<vector<ll>> dp(N + 1, vector<ll>(1e5 + 1, INF));
dp[0][0] = 0;
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= 1e5; j++) {
if (j - v[i - 1] >= 0) {
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i - 1]] + w[i - 1]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
ll ans = 0;
for (int j = 1e5; j > 0; j--) {
if (dp[N][j] <= W) {
ans = j;
break;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"assignment.change"
] | 970,392 | 970,393 | u318042557 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const long INF = LONG_MAX / 2;
int main() {
long N, W;
cin >> N >> W;
vector<vector<long>> dp(N + 1, vector<long>(100001, INF));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
int w, v;
cin >> w >> v;
for (int j = 0; j < 100001; j++) {
if (j - v >= 0)
dp[i + 1][j] = min(dp[i][j], dp[i][j - v] + w);
else
dp[i + 1][j] = min(dp[i][j], dp[i][0]);
}
}
long result = 0;
for (int j = 0; j < 100001; j++) {
if (dp[N][j] <= W)
result = j;
}
cout << result << endl;
} | #include <bits/stdc++.h>
using namespace std;
const long INF = LONG_MAX / 2;
int main() {
long N, W;
cin >> N >> W;
vector<vector<long>> dp(N + 1, vector<long>(100001, INF));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
long w, v;
cin >> w >> v;
for (int j = 0; j < 100001; j++) {
if (j - v >= 0)
dp[i + 1][j] = min(dp[i][j], dp[i][j - v] + w);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
long result = 0;
for (int j = 0; j < 100001; j++) {
if (dp[N][j] <= W)
result = j;
}
cout << result << endl;
} | [
"variable_declaration.type.primitive.change",
"control_flow.branch.else.remove",
"assignment.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 970,394 | 970,395 | u777258731 | cpp |
p03164 | #include <bits/stdc++.h>
long long int dp[100001][100] = {};
bool tf[100001][100] = {};
long int dpcalc(long int v, int i, long int a[][2], long int n) {
if (v <= 0)
return 0;
if (i == 0)
return 100000000001;
if (tf[v][i])
return dp[v][i];
tf[v][i] = 1;
dp[v][i] = std::min(dpcalc(v, i - 1, a, n),
dpcalc(v - a[i][1], i - 1, a, n) + a[i][0]);
return dp[v][i];
}
long int knapsack(long int a[][2], long int n, long int w) {
for (long int v = 100001; v >= 0; v--) {
long long int ans = dpcalc(v, n - 1, a, n);
if (ans <= w)
return v;
}
return 0;
}
int main() {
long int n, w;
std::cin >> n >> w;
long int a[n][2];
for (int i = 0; i < n; i++)
std::cin >> a[i][0] >> a[i][1];
std::cout << knapsack(a, n, w);
return 0;
} | #include <bits/stdc++.h>
long long int dp[100001][100] = {};
bool tf[100001][100] = {};
long int dpcalc(long int v, int i, long int a[][2], long int n) {
if (v <= 0)
return 0;
if (i == -1)
return 100000000001;
if (tf[v][i])
return dp[v][i];
tf[v][i] = 1;
dp[v][i] = std::min(dpcalc(v, i - 1, a, n),
dpcalc(v - a[i][1], i - 1, a, n) + a[i][0]);
return dp[v][i];
}
long int knapsack(long int a[][2], long int n, long int w) {
for (long int v = 100001; v >= 0; v--) {
long long int ans = dpcalc(v, n - 1, a, n);
if (ans <= w)
return v;
}
return 0;
}
int main() {
long int n, w;
std::cin >> n >> w;
long int a[n][2];
for (int i = 0; i < n; i++)
std::cin >> a[i][0] >> a[i][1];
std::cout << knapsack(a, n, w);
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 970,398 | 970,399 | u125115181 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define xxx int32_t
#define fuck_u return 0;
const int inf = 1e18L + 5;
xxx main() {
int n, w;
scanf("%lld%lld", &n, &w);
vector<int> weight(n), value(n);
for (int i = 0; i < n; ++i) {
scanf("%lld%lld", &weight[i], &value[i]);
}
int sum_val = 0;
for (int i : value) {
sum_val += i;
}
vector<int> dp(sum_val + 1, inf);
// int dp[sum_val+1];
// memset(dp, inf, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = sum_val - value[i]; j >= 0; --j) {
dp[value[i] + j] = min(dp[value[i] + j], dp[value[j]] + weight[i]);
}
}
int result = 0;
for (int i = 0; i < sum_val + 1; ++i) {
if (dp[i] <= w)
result = i;
}
printf("%lld\n", result);
fuck_u
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define xxx int32_t
#define fuck_u return 0;
const int inf = 1e18L + 5;
xxx main() {
int n, w;
scanf("%lld %lld", &n, &w);
vector<int> weight(n), value(n);
for (int i = 0; i < n; ++i) {
scanf("%lld %lld", &weight[i], &value[i]);
}
int sum_val = 0;
for (int i : value) {
sum_val += i;
}
vector<int> dp(sum_val + 1, inf);
// int dp[sum_val+1];
// memset(dp, inf, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = sum_val - value[i]; j >= 0; --j) {
dp[value[i] + j] = min(dp[value[i] + j], dp[j] + weight[i]);
}
}
int result = 0;
for (int i = 0; i < sum_val + 1; ++i) {
if (dp[i] <= w)
result = i;
}
printf("%lld\n", result);
fuck_u
}
| [
"literal.string.change",
"call.arguments.change"
] | 970,405 | 970,406 | u395200313 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define ld long double
#define si(x) (ll)((x).size())
#define pb push_back
#define F first
#define S second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define rep1(i, n) for (ll i = 1; i <= n; i++)
#define per1(i, n) for (ll i = n; i >= 1; i--)
#define all(x) (x).begin(), (x).end()
#define make_unique(x) (x).resize(unique(all(x)) - (x).begin())
#define pr_vec(v) \
for (ll _ = 0; _ < v.size(); _++) \
cout << v[_] << " ";
const int N = 1e6 + 7;
ll m = 998244353;
void solve() {
ll n, w, x, y;
cin >> n >> w;
std::vector<ll> wt(N + 1, 1e2);
wt[0] = 0;
rep(_, n) {
std::vector<ll> n_wt = wt;
cin >> x >> y;
for (ll i = 0; i + y < N; i++)
n_wt[i + y] = min(n_wt[i + y], wt[i] + x);
// pr_vec(n_wt);
// cout<<endl;
swap(wt, n_wt);
}
ll ans = 0;
rep(i, N) if (wt[i] <= w) ans = max(ans, i);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll t = 1;
// cin >> t;
rep1(i, t) {
// cout << "Case #" << i << ": ";
solve();
cout << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define ld long double
#define si(x) (ll)((x).size())
#define pb push_back
#define F first
#define S second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define rep1(i, n) for (ll i = 1; i <= n; i++)
#define per1(i, n) for (ll i = n; i >= 1; i--)
#define all(x) (x).begin(), (x).end()
#define make_unique(x) (x).resize(unique(all(x)) - (x).begin())
#define pr_vec(v) \
for (ll _ = 0; _ < v.size(); _++) \
cout << v[_] << " ";
const int N = 1e6 + 7;
ll m = 998244353;
void solve() {
ll n, w, x, y;
cin >> n >> w;
std::vector<ll> wt(N + 1, 1e16);
wt[0] = 0;
rep(_, n) {
std::vector<ll> n_wt = wt;
cin >> x >> y;
for (ll i = 0; i + y < N; i++)
n_wt[i + y] = min(n_wt[i + y], wt[i] + x);
// pr_vec(n_wt);
// cout<<endl;
swap(wt, n_wt);
}
ll ans = 0;
rep(i, N) if (wt[i] <= w) ans = max(ans, i);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll t = 1;
// cin >> t;
rep1(i, t) {
// cout << "Case #" << i << ": ";
solve();
cout << endl;
}
} | [
"literal.number.change",
"call.arguments.change"
] | 970,407 | 970,408 | u149999193 | cpp |
p03164 | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
const ll INF = 1e18L + 5;
int main() {
ll n, W, sum = 0;
cin >> n >> W;
vector<ll> wt(n), v(n);
for (ll i = 1; i <= n; i++) {
cin >> wt[i] >> v[i];
sum += v[i];
}
vector<ll> dp(sum + 1, INF);
dp[0] = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = sum; j >= v[i]; j--) {
dp[j] = min(dp[j], wt[i] + dp[j - v[i]]);
}
}
ll ans = 0;
ll i;
for (i = sum; i >= 0; i--) {
if (dp[i] <= W) {
cout << i << endl;
break;
}
}
}
| #include <bits/stdc++.h>
#define ll long long int
using namespace std;
const ll INF = 1e18L + 5;
int main() {
ll n, W, sum = 0;
cin >> n >> W;
vector<ll> wt(n + 1), v(n + 1);
for (ll i = 1; i <= n; i++) {
cin >> wt[i] >> v[i];
sum += v[i];
}
vector<ll> dp(sum + 1, INF);
dp[0] = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = sum; j >= v[i]; j--) {
dp[j] = min(dp[j], wt[i] + dp[j - v[i]]);
}
}
ll ans = 0;
ll i;
for (i = sum; i >= 0; i--) {
if (dp[i] <= W) {
cout << i << endl;
break;
}
}
}
| [
"assignment.change"
] | 970,412 | 970,413 | u051784225 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef long double ld;
long long INF = LLONG_MAX;
ll n, W, mxV = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
// freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);
cin >> n >> W;
ll w[n], v[n];
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
mxV += v[i];
}
ll dp[mxV];
for (ll i = 0; i < mxV; i++)
dp[i] = 1e18;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (ll j = mxV; j >= v[i]; j--) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
// cout << i << ' ' << j << ' ' << dp[j] << endl;
}
}
for (ll i = mxV; i >= 0; i--) {
if (dp[i] <= W) {
cout << i << endl;
break;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef long double ld;
long long INF = LLONG_MAX;
ll n, W, mxV = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
// freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);
cin >> n >> W;
ll w[n], v[n];
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
mxV += v[i];
}
ll dp[mxV + 1];
for (ll i = 0; i <= mxV; i++)
dp[i] = 1e18;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (ll j = mxV; j >= v[i]; j--) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
// cout << i << ' ' << j << ' ' << dp[j] << endl;
}
}
for (ll i = mxV; i >= 0; i--) {
if (dp[i] <= W) {
cout << i << endl;
break;
}
}
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 970,416 | 970,417 | u034671639 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = INT64_MAX;
int main() {
ll n, W;
cin >> n >> W;
vector<ll> w(n), v(n);
for (ll i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
ll v_sum = 0;
for (ll i = 0; i < n; i++)
v_sum += v[i];
vector<ll> dp(v_sum + 1, INF);
dp[0] = 0;
for (ll i = 0; i < n; i++) {
for (ll v_already = v_sum - v[i]; v_already >= 0; --v_already) {
dp[v_already + v[i]] = min(dp[v_already + v[i]], dp[v_already] + w[i]);
}
}
ll ans = 0;
for (ll i = 0; i < v_sum + 1; i++) {
if (dp[i] <= W && i > ans)
ans = i;
}
cout << ans << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = INT32_MAX;
int main() {
ll n, W;
cin >> n >> W;
vector<ll> w(n), v(n);
for (ll i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
ll v_sum = 0;
for (ll i = 0; i < n; i++)
v_sum += v[i];
vector<ll> dp(v_sum + 1, INF);
dp[0] = 0;
for (ll i = 0; i < n; i++) {
for (ll v_already = v_sum - v[i]; v_already >= 0; --v_already) {
dp[v_already + v[i]] = min(dp[v_already + v[i]], dp[v_already] + w[i]);
}
}
ll ans = 0;
for (ll i = 0; i < v_sum + 1; i++) {
if (dp[i] <= W && i > ans)
ans = i;
}
cout << ans << "\n";
return 0;
} | [
"variable_declaration.value.change",
"identifier.change"
] | 970,427 | 970,428 | u151251720 | cpp |
p03164 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (ll i = a; i < b; i++)
ll N, W, V = 1000;
int main() {
scanf("%lld%lld", &N, &W);
vector<ll> w(N), v(N);
ll max_v = 100000;
vector<ll> dp(max_v, 1e13);
rep(i, 0, N) scanf("%lld%lld", &w[i], &v[i]);
dp[0] = 0;
rep(i, 0, N) {
for (ll i2 = max_v; i2 >= 0; i2--) {
if (i2 >= v[i])
dp[i2] = min(dp[i2 - v[i]] + w[i], dp[i2]);
}
}
ll ans = 0;
rep(i2, 0, max_v + 1) {
if (dp[i2] <= W)
ans = max(i2, ans);
}
printf("%lld", ans);
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (ll i = a; i < b; i++)
ll N, W, V = 1000;
int main() {
scanf("%lld%lld", &N, &W);
vector<ll> w(N), v(N);
ll max_v = 100000;
vector<ll> dp(max_v + 1, 1e13);
rep(i, 0, N) scanf("%lld%lld", &w[i], &v[i]);
dp[0] = 0;
rep(i, 0, N) {
for (ll i2 = max_v; i2 >= 0; i2--) {
if (i2 >= v[i])
dp[i2] = min(dp[i2 - v[i]] + w[i], dp[i2]);
}
}
ll ans = 0;
rep(i2, 0, max_v + 1) {
if (dp[i2] <= W)
ans = max(i2, ans);
}
printf("%lld", ans);
return 0;
} | [
"assignment.change"
] | 970,429 | 970,430 | u128572736 | cpp |
p03164 | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define all(v) ((v).begin()), ((v).end())
#define sz(v) ((int)((v).size()))
#define clr(v, d) memset(v, d, sizeof(v))
#define rep(i, v) for (int i = 0; i < sz(v); ++i)
#define lp(i, n) for (int i = 0; i < (int)(n); ++i)
typedef long long ll;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
#define pb push_back
#define P(x) cout << #x << " = { " << x << " }\n"
clock_t T;
#define ctime cerr << "Time : " << double(clock() - T) / CLOCKS_PER_SEC << endl
void GOAT() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("output.txt", "w ", stdout);
#else
#endif
}
const ll oo = 1e10;
ll v[100007], w[100007], we, n, mxwe;
ll mem[105][190005];
ll knap(int i, ll rem) {
if (i == n && !rem) {
return 0;
}
if (i == n) {
return 1e10;
}
ll &ret = mem[i][rem];
if (~ret)
return ret;
ret = oo;
ret = min(ret, knap(i + 1, rem));
if (rem >= w[i])
ret = min(ret, knap(i + 1, rem - v[i]) + w[i]);
return ret;
}
int main() {
// GOAT();
clr(mem, -1);
cin >> n >> we;
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
// cout << knap(0, we) << endl;
for (int i = 100000; i >= 0; i--) {
ll ans = knap(0, i);
if (ans <= we) {
cout << i << endl;
break;
}
}
} | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define all(v) ((v).begin()), ((v).end())
#define sz(v) ((int)((v).size()))
#define clr(v, d) memset(v, d, sizeof(v))
#define rep(i, v) for (int i = 0; i < sz(v); ++i)
#define lp(i, n) for (int i = 0; i < (int)(n); ++i)
typedef long long ll;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
#define pb push_back
#define P(x) cout << #x << " = { " << x << " }\n"
clock_t T;
#define ctime cerr << "Time : " << double(clock() - T) / CLOCKS_PER_SEC << endl
void GOAT() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("output.txt", "w ", stdout);
#else
#endif
}
const ll oo = 1e10;
ll v[100007], w[100007], we, n, mxwe;
ll mem[105][100005];
ll knap(int i, int rem) {
if (i == n && !rem) {
return 0;
}
if (i == n) {
return 1e10;
}
ll &ret = mem[i][rem];
if (~ret)
return ret;
ret = oo;
ret = min(ret, knap(i + 1, rem));
if (rem >= v[i])
ret = min(ret, knap(i + 1, rem - v[i]) + w[i]);
return ret;
}
int main() {
// GOAT();
clr(mem, -1);
cin >> n >> we;
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
// cout << knap(0, we) << endl;
for (int i = 100000; i >= 0; i--) {
ll ans = knap(0, i);
if (ans <= we) {
cout << i << endl;
break;
}
}
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 970,447 | 970,448 | u708568341 | cpp |
p03164 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ull unsigned long long
#define mod 1000000007
#define do double
#define loop(i, n) for (int i = 0; i < n; i++)
#define lop(a, b) for (int i = a; i <= b; i++)
#define pb push_back
#define mkp make_pair
typedef vector<int> vi;
typedef map<int, int> mii;
typedef set<int> si;
typedef pair<int, int> pii;
typedef unordered_map<int, int> um;
typedef unordered_set<int> us;
typedef multiset<int> ms;
typedef vector<pair<int, int>> vpii;
// Driver code
int main() {
ll n, W, V = 20;
cin >> n >> W;
ll val[n + 1], w[n + 1];
vector<vector<ll>> dp(101, vector<ll>(100005, INT_MAX));
loop(i, n) cin >> w[i + 1] >> val[i + 1];
dp[0][0] = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = 0; j <= V; j++) {
if (j < val[i])
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = min(dp[i - 1][j], w[i] + dp[i - 1][j - val[i]]);
}
}
for (ll j = V; j >= 0; j--) {
if (dp[n][j] <= W) {
cout << j << "\n";
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ull unsigned long long
#define mod 1000000007
#define do double
#define loop(i, n) for (int i = 0; i < n; i++)
#define lop(a, b) for (int i = a; i <= b; i++)
#define pb push_back
#define mkp make_pair
typedef vector<int> vi;
typedef map<int, int> mii;
typedef set<int> si;
typedef pair<int, int> pii;
typedef unordered_map<int, int> um;
typedef unordered_set<int> us;
typedef multiset<int> ms;
typedef vector<pair<int, int>> vpii;
// Driver code
int main() {
ll n, W, V = 100000;
cin >> n >> W;
ll val[n + 1], w[n + 1];
vector<vector<ll>> dp(101, vector<ll>(100005, INT_MAX));
loop(i, n) cin >> w[i + 1] >> val[i + 1];
dp[0][0] = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = 0; j <= V; j++) {
if (j < val[i])
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = min(dp[i - 1][j], w[i] + dp[i - 1][j - val[i]]);
}
}
for (ll j = V; j >= 0; j--) {
if (dp[n][j] <= W) {
cout << j << "\n";
break;
}
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 970,453 | 970,454 | u580376304 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
long long int dp[100001][101], vmax = 0;
long long int sol(long long int j, long long int i, long long int w[],
long long int v[], long long int n) {
if (j == 0)
return 0;
if (i == n)
return 1000000009;
if (dp[j][i] != -1)
return dp[j][i];
dp[j][i] = min(sol(j, i + 1, w, v, n), w[i] + sol(j - v[i], i + 1, w, v, n));
return dp[j][i];
}
long long int wt(long long int w[], long long int v[], long long int n,
long long int c) {
for (long long int j = vmax; j >= 0; j--) {
if (sol(j, 0, w, v, n) <= c)
return j;
}
}
int main() {
memset(dp, -1, sizeof(dp));
long long int n, c;
cin >> n >> c;
long long int w[n], v[n];
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
vmax += v[i];
}
cout << wt(w, v, n, c);
} | #include <bits/stdc++.h>
using namespace std;
long long int dp[100005][105], vmax = 0;
long long int sol(long long int j, long long int i, long long int w[],
long long int v[], long long int n) {
if (j <= 0)
return 0;
if (i == n)
return 10000000009;
if (dp[j][i] != -1)
return dp[j][i];
dp[j][i] = min(sol(j, i + 1, w, v, n), w[i] + sol(j - v[i], i + 1, w, v, n));
return dp[j][i];
}
long long int wt(long long int w[], long long int v[], long long int n,
long long int c) {
for (long long int j = vmax; j >= 0; j--) {
if (sol(j, 0, w, v, n) <= c)
return j;
}
}
int main() {
memset(dp, -1, sizeof(dp));
long long int n, c;
cin >> n >> c;
long long int w[n], v[n];
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
vmax += v[i];
}
cout << wt(w, v, n, c);
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"function.return_value.change"
] | 970,455 | 970,456 | u373316701 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define test() \
ll t; \
cin >> t; \
while (t--)
#define MOD 1000000007
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
int main() {
SPEED;
// CODE
ll n, W;
cin >> n >> W;
ll w[n], v[n];
ll ans = 0;
for (ll i = 0; i < n; i++)
cin >> w[i] >> v[i];
ll dp[2][100001];
for (ll i = 0; i < 2; i++) {
for (ll j = 0; j < 100001; j++) {
dp[i][j] = 1e9;
}
}
dp[0][0] = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = 0; j < 100001; j++) {
if (dp[0][j] != 10e9) {
dp[1][j] = min(dp[1][j], dp[0][j]);
dp[1][j + v[i - 1]] = min(dp[1][j + v[i - 1]], dp[0][j] + w[i - 1]);
}
}
for (ll j = 0; j < 100001; j++) {
dp[0][j] = dp[1][j];
}
}
for (ll i = 0; i < 100001; i++) {
if (dp[1][i] <= W) {
ans = i;
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define test() \
ll t; \
cin >> t; \
while (t--)
#define MOD 1000000007
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
int main() {
SPEED;
// CODE
ll n, W;
cin >> n >> W;
ll w[n], v[n];
ll ans = 0;
for (ll i = 0; i < n; i++)
cin >> w[i] >> v[i];
ll dp[2][100001];
for (ll i = 0; i < 2; i++) {
for (ll j = 0; j < 100001; j++) {
dp[i][j] = 10e9;
}
}
dp[0][0] = 0;
for (ll i = 1; i <= n; i++) {
for (ll j = 0; j < 100001; j++) {
if (dp[0][j] != 10e9) {
dp[1][j] = min(dp[1][j], dp[0][j]);
dp[1][j + v[i - 1]] = min(dp[1][j + v[i - 1]], dp[0][j] + w[i - 1]);
}
}
for (ll j = 0; j < 100001; j++) {
dp[0][j] = dp[1][j];
}
}
for (ll i = 0; i < 100001; i++) {
if (dp[1][i] <= W) {
ans = i;
}
}
cout << ans;
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 970,457 | 970,458 | u573901279 | cpp |
p03164 | #include <bits/stdc++.h>
#define ll long long
#define ss second
#define ff first
#define pb push_back
using namespace std;
const int N = 1e6 + 69;
ll n, answer, w;
ll dp[N], W[N], V[N];
int main() {
ios ::sync_with_stdio(0);
cin >> n >> w;
for (int i = 0; i <= 1e5; i++) {
dp[i] = 1e9;
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> W[i] >> V[i];
for (ll j = 1e5; j >= 0; j--) {
if (j - V[i] >= 0 && dp[j - V[i]] != -1) {
dp[j] = min(dp[j - V[i]] + W[i], dp[j]);
if (dp[j] <= w) {
answer = max(answer, j);
}
}
}
}
cout << answer << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define ss second
#define ff first
#define pb push_back
using namespace std;
const int N = 1e6 + 69;
ll n, answer, w;
ll dp[N], W[N], V[N];
int main() {
ios ::sync_with_stdio(0);
cin >> n >> w;
for (int i = 0; i <= 1e5; i++) {
dp[i] = 1e9;
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> W[i] >> V[i];
for (ll j = 1e5; j >= 0; j--) {
if (j - V[i] >= 0 && dp[j - V[i]] != 1e9) {
dp[j] = min(dp[j - V[i]] + W[i], dp[j]);
if (dp[j] <= w) {
answer = max(answer, j);
}
}
}
}
cout << answer << endl;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 970,471 | 970,472 | u954494895 | cpp |
p03164 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long
#define ld long double
typedef vector<ll> vi; // Vector of long long
typedef vector<vi> vvi; // Vector of vi
typedef vector<pair<ll, ll>> ii; // Vector of pairs
#define ff first // For pairs
#define ss second // For pairs
#define sz(a) int((a).size()) // Function to determine size of any container
#define pb push_back // Pushback to vector
#define mp make_pair // Makes pairs to be stored as pair
#define all(c) (c).begin(), (c).end() // Mainly used by me in sorting
// ordered_set adds two new functions to set - (set).find_by_order([kth element
// based on zero indexing]) and order_of_key() order_of_key returns number of
// elements less that parameter. If element exists, that order is its index
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
#define MAXV (ll)(1e5 + 5)
#define INF (ll)(1e12)
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, w;
cin >> n >> w;
ll mg[n], val[n];
for (int i = 0; i < n; i++)
cin >> mg[i] >> val[i];
ll dp[n + 1][MAXV];
for (int i = 1; i < MAXV; i++)
dp[0][i] = INF;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < MAXV; j++) {
ll ans = INF;
if (j - val[i - 1] >= 0)
ans = dp[i - 1][j - val[i - 1]] + mg[i - 1];
ans = min(ans, dp[i - 1][j]);
dp[i][j] = ans;
}
}
/* for (int i = 0; i <= n; i++)
for (int j = 0; j < MAX; j++)
cout << dp[i][j] << " \n"[j == MAX - 1]; */
for (int i = MAXV; i >= 0; i--) {
if (dp[n][i] <= w) {
cout << i << "\n";
break;
}
}
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long
#define ld long double
typedef vector<ll> vi; // Vector of long long
typedef vector<vi> vvi; // Vector of vi
typedef vector<pair<ll, ll>> ii; // Vector of pairs
#define ff first // For pairs
#define ss second // For pairs
#define sz(a) int((a).size()) // Function to determine size of any container
#define pb push_back // Pushback to vector
#define mp make_pair // Makes pairs to be stored as pair
#define all(c) (c).begin(), (c).end() // Mainly used by me in sorting
// ordered_set adds two new functions to set - (set).find_by_order([kth element
// based on zero indexing]) and order_of_key() order_of_key returns number of
// elements less that parameter. If element exists, that order is its index
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
#define MAXV (ll)(1e5 + 5)
#define INF (ll)(1e12)
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, w;
cin >> n >> w;
ll mg[n], val[n];
for (int i = 0; i < n; i++)
cin >> mg[i] >> val[i];
ll dp[n + 1][MAXV];
for (int i = 1; i < MAXV; i++)
dp[0][i] = INF;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < MAXV; j++) {
ll ans = INF;
if (j - val[i - 1] >= 0)
ans = dp[i - 1][j - val[i - 1]] + mg[i - 1];
ans = min(ans, dp[i - 1][j]);
dp[i][j] = ans;
}
}
/* for (int i = 0; i <= n; i++)
for (int j = 0; j < MAX; j++)
cout << dp[i][j] << " \n"[j == MAX - 1]; */
for (int i = MAXV - 1; i >= 0; i--) {
if (dp[n][i] <= w) {
cout << i << "\n";
break;
}
}
}
| [
"control_flow.loop.for.initializer.change"
] | 970,478 | 970,479 | u584989818 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
using P = pair<int, int>;
ll dp[110000];
const ll INF = 10010010010;
int main() {
int n;
ll W;
cin >> n >> W;
rep(i, 1100) dp[i] = INF;
dp[0] = 0;
rep(i, n) {
int w, v;
cin >> w >> v;
for (int j = 110000; j >= 0; --j) {
if (j - v >= 0)
dp[j] = min(dp[j - v] + w, dp[j]);
}
}
int ans = 0;
rep(i, 110000) {
if (dp[i] <= W) {
ans = i;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
using P = pair<int, int>;
ll dp[110005];
const ll INF = 10010010010;
int main() {
int n;
ll W;
cin >> n >> W;
rep(i, 110000) dp[i] = INF;
dp[0] = 0;
rep(i, n) {
int w, v;
cin >> w >> v;
for (int j = 110000; j >= 0; --j) {
if (j - v >= 0)
dp[j] = min(dp[j - v] + w, dp[j]);
}
}
int ans = 0;
rep(i, 110000) {
if (dp[i] <= W) {
ans = i;
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.variable.change",
"call.arguments.change"
] | 970,486 | 970,487 | u818349438 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e12 + 7;
long long dp[103][100004];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, w;
cin >> n >> w;
int a[103], b[103];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < 100004; j++)
dp[i][j] = mod;
dp[0][0] = 0;
for (int i = 0; i < n; i++)
for (int j = 1; j < 100004; j++) {
if (j >= b[i])
dp[i + 1][j] = min(dp[i][j], dp[i][j - b[i]] + a[i]);
else
dp[i + 1][j] = dp[i][j];
}
long long res = 0;
for (int j = 0; j < 100004; j++)
if (dp[n][j] <= w)
res = j;
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e11 + 7;
long long dp[103][100004];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, w;
cin >> n >> w;
int a[103], b[103];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < 100004; j++)
dp[i][j] = mod;
dp[0][0] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < 100004; j++) {
if (j >= b[i])
dp[i + 1][j] = min(dp[i][j], dp[i][j - b[i]] + a[i]);
else
dp[i + 1][j] = dp[i][j];
}
long long res = 0;
for (int j = 0; j < 100004; j++)
if (dp[n][j] <= w)
res = j;
cout << res << endl;
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 970,497 | 970,498 | u986025116 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
long long w[105], v[105];
long long dp[105][100005];
int main() {
int N, W;
cin >> N >> W;
for (int i = 1; i <= N; i++)
cin >> w[i] >> v[i];
for (int i = 0; i <= N; i++)
for (int j = 1; j <= 100000; j++)
dp[i][j] = 1e18;
dp[0][0] = 0;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= 100000; j++) {
if (j < v[i])
dp[i][j] = dp[i - 1][j];
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
}
}
for (int i = 100000; i > 0; i--)
if (dp[N][i] <= W) {
cout << i;
break;
}
}
| #include <bits/stdc++.h>
using namespace std;
long long w[105], v[105];
long long dp[105][100005];
int main() {
int N;
long long W;
cin >> N >> W;
for (int i = 1; i <= N; i++)
cin >> w[i] >> v[i];
for (int i = 0; i <= N; i++)
for (int j = 1; j <= 100000; j++)
dp[i][j] = 1e18;
dp[0][0] = 0;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= 100000; j++) {
if (j < v[i])
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
}
}
for (int i = 100000; i >= 0; i--)
if (dp[N][i] <= W) {
cout << i;
break;
}
}
| [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 970,501 | 970,500 | u953180133 | cpp |
p03164 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
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;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
ll dp[110][100010];
int main() {
ll n, W;
cin >> n >> W;
vector<ll> w(n);
vector<int> v(n);
rep(i, n) { cin >> w[i] >> v[i]; }
rep(i, n + 1) rep(j, 100010) dp[i][j] = inf;
dp[0][0] = 0;
rep(i, n) {
rep(j, 100010) {
chmin(dp[i + 1][j + v[i]], dp[i][j] + w[i]);
chmin(dp[i + 1][j], dp[i][j]);
}
}
int ans = 0;
rep(j, 100010) {
if (dp[n][j] < W)
ans = j;
}
cout << ans << endl;
}
| #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
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;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int dp[110][100010];
int main() {
int n, W;
cin >> n >> W;
vector<int> w(n);
vector<int> v(n);
rep(i, n) { cin >> w[i] >> v[i]; }
rep(i, n + 1) rep(j, 100010) dp[i][j] = inf;
dp[0][0] = 0;
rep(i, n) {
rep(j, 100010) {
chmin(dp[i + 1][j + v[i]], dp[i][j] + w[i]);
chmin(dp[i + 1][j], dp[i][j]);
}
}
int ans = 0;
rep(j, 100010) {
if (dp[n][j] <= W)
ans = j;
}
cout << ans << endl;
}
| [
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 970,508 | 970,509 | u136342563 | cpp |
p03164 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
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;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
ll dp[110][100010];
int main() {
ll n, W;
cin >> n >> W;
vector<int> w(n);
vector<int> v(n);
rep(i, n) { cin >> w[i] >> v[i]; }
rep(i, n + 1) rep(j, 100010) dp[i][j] = inf;
dp[0][0] = 0;
rep(i, n) {
rep(j, 100010) {
chmin(dp[i + 1][j + v[i]], dp[i][j] + w[i]);
chmin(dp[i + 1][j], dp[i][j]);
}
}
int ans = 0;
rep(j, 100010) {
if (dp[n][j] < W)
ans = j;
}
cout << ans << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
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;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int dp[110][100010];
int main() {
int n, W;
cin >> n >> W;
vector<int> w(n);
vector<int> v(n);
rep(i, n) { cin >> w[i] >> v[i]; }
rep(i, n + 1) rep(j, 100010) dp[i][j] = inf;
dp[0][0] = 0;
rep(i, n) {
rep(j, 100010) {
chmin(dp[i + 1][j + v[i]], dp[i][j] + w[i]);
chmin(dp[i + 1][j], dp[i][j]);
}
}
int ans = 0;
rep(j, 100010) {
if (dp[n][j] <= W)
ans = j;
}
cout << ans << endl;
}
| [
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 970,510 | 970,509 | u136342563 | cpp |
p03164 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
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;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int dp[110][100010];
int main() {
int n, W;
cin >> n >> W;
vector<int> w(n);
vector<int> v(n);
rep(i, n) { cin >> w[i] >> v[i]; }
rep(i, n + 1) rep(j, 100010) dp[i][j] = inf;
dp[0][0] = 0;
rep(i, n) {
rep(j, 100010) {
chmin(dp[i + 1][j + v[i]], dp[i][j] + w[i]);
chmin(dp[i + 1][j], dp[i][j]);
}
}
int ans = 0;
rep(j, 100010) {
if (dp[n][j] < W)
ans = j;
}
cout << ans << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
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;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int dp[110][100010];
int main() {
int n, W;
cin >> n >> W;
vector<int> w(n);
vector<int> v(n);
rep(i, n) { cin >> w[i] >> v[i]; }
rep(i, n + 1) rep(j, 100010) dp[i][j] = inf;
dp[0][0] = 0;
rep(i, n) {
rep(j, 100010) {
chmin(dp[i + 1][j + v[i]], dp[i][j] + w[i]);
chmin(dp[i + 1][j], dp[i][j]);
}
}
int ans = 0;
rep(j, 100010) {
if (dp[n][j] <= W)
ans = j;
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 970,511 | 970,509 | u136342563 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ll n, k, mx = -1;
cin >> n >> k;
ll a[n][2];
ll ts = 0;
for (ll i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1];
ts += a[i][1];
}
ll dp[ts + 1];
for (ll i = 0; i <= ts; i++)
dp[i] = LLONG_MAX;
dp[0] = 0;
for (ll i = 0; i < n; i++) {
for (ll j = ts; j >= a[i][1]; j--) {
dp[j] = min(dp[j], dp[j - a[i][1]] + a[i][0]);
}
}
ll ans = 0;
for (ll i = 0; i <= ts; i++)
if (dp[i] <= k)
ans = i;
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ll n, k, mx = -1;
cin >> n >> k;
ll a[n][2];
ll ts = 0;
for (ll i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1];
ts += a[i][1];
}
ll dp[ts + 1];
for (ll i = 0; i <= ts; i++)
dp[i] = INT_MAX;
dp[0] = 0;
for (ll i = 0; i < n; i++) {
for (ll j = ts; j >= a[i][1]; j--) {
dp[j] = min(dp[j], dp[j - a[i][1]] + a[i][0]);
}
}
ll ans = 0;
for (ll i = 0; i <= ts; i++)
if (dp[i] <= k)
ans = i;
cout << ans;
} | [
"assignment.value.change",
"identifier.change"
] | 970,514 | 970,515 | u674523856 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
ll W;
cin >> N >> W;
vector<ll> w(N), v(N);
for (int i = 0; i < N; i++) {
cin >> w[i] >> v[i];
}
// dp[i][j]はi番目までの品物から選択し、価値がj以下の時の最小のw
vector<vector<ll>> dp(110, vector<ll>(100100, 1000000000));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 100100; j++) {
if (j >= v[i])
dp[i + 1][j] =
min(dp[i][j],
dp[i][j - v[i]] + w[i]); // i番目の商品を選ぶかどうかの判断
else
dp[i + 1][j] = dp[i][j];
}
}
ll ans = 0;
for (int i = 0; i < 100100; i++) {
if (dp[N][i] <= W)
ans = max(ans, (ll)i);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
ll W;
cin >> N >> W;
vector<ll> w(N), v(N);
for (int i = 0; i < N; i++) {
cin >> w[i] >> v[i];
}
// dp[i][j]はi番目までの品物から選択し、価値がj以下の時の最小のw
vector<vector<ll>> dp(110, vector<ll>(100100, 1000000000000000));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 100100; j++) {
if (j >= v[i])
dp[i + 1][j] =
min(dp[i][j],
dp[i][j - v[i]] + w[i]); // i番目の商品を選ぶかどうかの判断
else
dp[i + 1][j] = dp[i][j];
}
}
ll ans = 0;
for (int i = 0; i < 100100; i++) {
if (dp[N][i] <= W)
ans = max(ans, (ll)i);
}
cout << ans << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 970,521 | 970,522 | u964763428 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
ll W;
cin >> N >> W;
vector<ll> w(N), v(N);
for (int i = 0; i < N; i++) {
cin >> w[i] >> v[i];
}
// dp[i][j]はi番目までの品物から選択し、価値がj以下の時の最小のw
vector<vector<ll>> dp(110, vector<ll>(100100, 1000000000));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= 100000; j++) {
if (j >= v[i])
dp[i + 1][j] =
min(dp[i][j],
dp[i][j - v[i]] + w[i]); // i番目の商品を選ぶかどうかの判断
else
dp[i + 1][j] = dp[i][j];
}
}
ll ans = 0;
for (int i = 0; i < 100100; i++) {
if (dp[N][i] <= W)
ans = max(ans, (ll)i);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
ll W;
cin >> N >> W;
vector<ll> w(N), v(N);
for (int i = 0; i < N; i++) {
cin >> w[i] >> v[i];
}
// dp[i][j]はi番目までの品物から選択し、価値がj以下の時の最小のw
vector<vector<ll>> dp(110, vector<ll>(100100, 1000000000000000));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 100100; j++) {
if (j >= v[i])
dp[i + 1][j] =
min(dp[i][j],
dp[i][j - v[i]] + w[i]); // i番目の商品を選ぶかどうかの判断
else
dp[i + 1][j] = dp[i][j];
}
}
ll ans = 0;
for (int i = 0; i < 100100; i++) {
if (dp[N][i] <= W)
ans = max(ans, (ll)i);
}
cout << ans << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"control_flow.loop.for.condition.change"
] | 970,523 | 970,522 | u964763428 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repr(i, n) for (int(i) = (n); (i) >= 0; (i)--)
const ll MOD = 1e9 + 7;
const int INF = (int)1e9 + 7;
// vector<tuple<long,long>> items; // (value, weight)
// auto item = items[i];
// long v = get<0>(item);
// long w = get<1>(item);
// long v, w;
// for( int i = 0; i < N; i++ ){
// cin >> v >> w;
// items.push_back( make_tuple(v, w) ); // item : (value, weight)
// }
ll dp[101][100001];
int main() {
ll N, W;
cin >> N >> W;
ll w, v;
rep(i, N) {
rep(j, 100001) { dp[i][j] = INF; }
}
cin >> w >> v;
dp[0][v] = w;
cout << endl;
for (int i = 1; i < N; i++) {
cin >> w >> v;
rep(j, 100001) {
dp[i][j] = dp[i - 1][j];
if (j - v >= 0)
dp[i][j] = min(dp[i][j], dp[i - 1][j - v] + w);
}
dp[i][v] = min(dp[i][v], w);
}
ll ans = 0;
for (ll j = 0; j < 100; j++) {
if (dp[N - 1][j] <= W) {
ans = max(ans, j);
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repr(i, n) for (int(i) = (n); (i) >= 0; (i)--)
const ll MOD = 1e9 + 7;
const int INF = (int)1e9 + 7;
// vector<tuple<long,long>> items; // (value, weight)
// auto item = items[i];
// long v = get<0>(item);
// long w = get<1>(item);
// long v, w;
// for( int i = 0; i < N; i++ ){
// cin >> v >> w;
// items.push_back( make_tuple(v, w) ); // item : (value, weight)
// }
ll dp[101][100001];
int main() {
ll N, W;
cin >> N >> W;
ll w, v;
rep(i, N) {
rep(j, 100001) { dp[i][j] = INF; }
}
cin >> w >> v;
dp[0][v] = w;
cout << endl;
for (int i = 1; i < N; i++) {
cin >> w >> v;
rep(j, 100001) {
dp[i][j] = dp[i - 1][j];
if (j - v >= 0)
dp[i][j] = min(dp[i][j], dp[i - 1][j - v] + w);
}
dp[i][v] = min(dp[i][v], w);
}
ll ans = 0;
for (ll j = 0; j < 100001; j++) {
if (dp[N - 1][j] <= W) {
ans = max(ans, j);
}
}
cout << ans;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 970,534 | 970,535 | u068277996 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int n, w, a[100][2], dp[100][100001];
int f(int i, int v) {
int &d = dp[i][v];
if (v == 0)
return 0;
if (i == n)
return 1e9;
if (d != -1)
return d;
return d = min(f(i + 1, v), f(i + 1, v - a[i][1]) + a[i][0]);
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> w;
for (int i = 0; i < n; ++i)
cin >> a[i][0] >> a[i][1];
for (int i = 1e5; i >= 0; --i) {
int wi = f(0, i);
if (wi <= w) {
cout << i;
return 0;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, w, a[100][2], dp[100][100001];
int f(int i, int v) {
int &d = dp[i][v];
if (v == 0)
return 0;
if (i == n)
return 1e9 + 1;
if (d != -1)
return d;
return d = min(f(i + 1, v), f(i + 1, v - a[i][1]) + a[i][0]);
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> w;
for (int i = 0; i < n; ++i)
cin >> a[i][0] >> a[i][1];
for (int i = 1e5; i >= 0; --i) {
int wi = f(0, i);
if (wi <= w) {
cout << i;
return 0;
}
}
return 0;
} | [
"expression.operation.binary.add"
] | 970,542 | 970,543 | u148496542 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const int N = 110, V = 1e5 + 10;
long long n, W, i, j, ans;
long long w[N], v[N];
long long dp[N][V];
main() {
cin >> n >> W;
for (i = 1; i <= n; i++)
cin >> w[i] >> v[i];
for (i = 0; i <= n; i++) {
for (j = 0; j <= 100001; j++)
dp[i][j] = 1e9;
}
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j <= 100001; j++) {
if (j >= v[i])
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
else
dp[i][j] = dp[i - 1][j];
}
}
for (i = 1; i <= 100001; i++) {
if (dp[n][i] <= W)
ans = i;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 110, V = 1e5 + 10;
long long n, W, i, j, ans;
long long w[N], v[N];
long long dp[N][V];
main() {
cin >> n >> W;
for (i = 1; i <= n; i++)
cin >> w[i] >> v[i];
for (i = 0; i <= n; i++) {
for (j = 0; j <= 100001; j++)
dp[i][j] = 1e18;
}
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j <= 100001; j++) {
if (j >= v[i])
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
else
dp[i][j] = dp[i - 1][j];
}
}
for (i = 1; i <= 100001; i++) {
if (dp[n][i] <= W)
ans = i;
}
cout << ans << endl;
} | [
"literal.number.change",
"assignment.value.change"
] | 970,547 | 970,548 | u049755721 | cpp |
p03164 | #include <bits/stdc++.h>
#define INF 1000000000
using namespace std;
int main() {
int N, W;
int64_t ans = 0;
cin >> N >> W;
vector<pair<int, int>> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i].first >> A[i].second;
}
vector<vector<int64_t>> dp(N + 1, vector<int64_t>(1e5 + 1));
// for(int i=0;i<=N;i++){
for (int j = 0; j <= 1e5; j++) {
dp[0][j] = INF;
}
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= 1e5; j++) {
if (A[i].second > j)
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = min(dp[i][j], dp[i][j - A[i].second] + A[i].first);
}
}
for (int j = 0; j < 1e5 + 1; j++) {
if (dp[N][j] <= W && j > ans)
ans = j;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define INF 1000000000000
using namespace std;
int main() {
int N, W;
int64_t ans = 0;
cin >> N >> W;
vector<pair<int, int>> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i].first >> A[i].second;
}
vector<vector<int64_t>> dp(N + 1, vector<int64_t>(1e5 + 1));
// for(int i=0;i<=N;i++){
for (int j = 0; j <= 1e5; j++) {
dp[0][j] = INF;
}
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= 1e5; j++) {
if (A[i].second > j)
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = min(dp[i][j], dp[i][j - A[i].second] + A[i].first);
}
}
for (int j = 0; j < 1e5 + 1; j++) {
if (dp[N][j] <= W && j > ans)
ans = j;
}
cout << ans << endl;
} | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 970,551 | 970,552 | u207948013 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
ll N, W;
cin >> N >> W;
vector<ll> w(N), v(N);
rep(i, N) cin >> w[i] >> v[i];
vector<vector<ll>> dp(N + 1, vector<ll>(1e5 + 1, 1e9));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= 1e5; j++) {
if (j - v[i] >= 0)
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i]);
else
dp[i + 1][j] = dp[i][j];
}
}
// for (auto v : dp) {
// for (ll a : v) {
// cout << a << " ";
// }
// cout << endl;
// }
ll ans = 0;
rep(i, 1e5 + 1) {
if (dp[N][i] <= W) {
ans = max(ans, (ll)i);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
ll N, W;
cin >> N >> W;
vector<ll> w(N), v(N);
rep(i, N) cin >> w[i] >> v[i];
vector<vector<ll>> dp(N + 1, vector<ll>(1e5 + 1, 1e18));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= 1e5; j++) {
if (j - v[i] >= 0)
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i]);
else
dp[i + 1][j] = dp[i][j];
}
}
// for (auto v : dp) {
// for (ll a : v) {
// cout << a << " ";
// }
// cout << endl;
// }
ll ans = 0;
rep(i, 1e5 + 1) {
if (dp[N][i] <= W) {
ans = max(ans, (ll)i);
}
}
cout << ans << endl;
} | [
"literal.number.change",
"call.arguments.change"
] | 970,557 | 970,558 | u923105140 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using v = vector<ll>;
void dpA() {
int n;
cin >> n;
auto h = vector<ll>(n, 0);
for (ll i = 0; i < n; i++)
cin >> h[i];
auto dp = vector<ll>(n + 2, 1e9);
dp[0] = 0;
dp[1] = 0;
for (ll i = 1; i < n; i++) {
if (i >= 2)
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]),
dp[i - 2] + abs(h[i] - h[i - 2]));
else if (i >= 1)
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
}
cout << dp[n - 1];
}
void dpB() {
ll n, k;
cin >> n >> k;
auto h = vector<ll>(n + 1, 0);
for (ll i = 0; i < n; i++)
cin >> h[i];
auto dp = vector<ll>(100000, 1e9);
dp[0] = 0;
for (ll i = 0; i < n; i++) {
for (ll j = 1; j <= k; j++) {
if (i + j <= n)
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i + j] - h[i]));
}
}
cout << dp[n - 1];
}
void dpC() {
ll n;
cin >> n;
vector<v> a(n, v(3, 0));
for (ll i = 0; i < n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
auto dp = vector<v>(n + 1, v(3, 0));
for (ll i = 0; i < n; i++)
for (ll today = 0; today < 3; today++)
for (ll oday = 0; oday < 3; oday++)
if (today != oday)
dp[i + 1][today] = max(dp[i + 1][today], dp[i][oday] + a[i][today]);
cout << max(dp[n][0], max(dp[n][1], dp[n][2]));
}
void dpD() {
ll N, W;
cin >> N >> W;
auto ww = v(N, 0);
auto vv = v(N, 0);
for (ll i = 0; i < N; i++)
cin >> ww[i] >> vv[i];
auto dp = vector<v>(N + 1, v(W + 1, 0));
for (ll i = 0; i < N; i++) {
for (ll j = 0; j <= W; j++) {
if (j - ww[i] >= 0)
dp[i + 1][j] = max(dp[i][j], dp[i][j - ww[i]] + vv[i]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[N][W];
}
void dpE() {
ll N, W;
cin >> N >> W;
auto ww = v(N, 0);
auto vv = v(N, 0);
for (ll i = 0; i < N; i++)
cin >> ww[i] >> vv[i];
auto dp = vector<v>(N + 1, v(1e5 + 100, 1LL << 60));
dp[0][0] = 0;
for (ll i = 0; i < N; i++) {
for (ll j = 0; j <= 1e5; j++) {
if (j + vv[i] <= 1e5)
dp[i + 1][j] = min(dp[i + 1][j + vv[i]], dp[i][j] + ww[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll ans = 0;
for (auto i = 0; i <= 1e5; i++) {
if (dp[N][i] <= W) {
ans = i;
}
}
cout << ans;
}
int main() {
dpE();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using v = vector<ll>;
void dpA() {
int n;
cin >> n;
auto h = vector<ll>(n, 0);
for (ll i = 0; i < n; i++)
cin >> h[i];
auto dp = vector<ll>(n + 2, 1e9);
dp[0] = 0;
dp[1] = 0;
for (ll i = 1; i < n; i++) {
if (i >= 2)
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]),
dp[i - 2] + abs(h[i] - h[i - 2]));
else if (i >= 1)
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
}
cout << dp[n - 1];
}
void dpB() {
ll n, k;
cin >> n >> k;
auto h = vector<ll>(n + 1, 0);
for (ll i = 0; i < n; i++)
cin >> h[i];
auto dp = vector<ll>(100000, 1e9);
dp[0] = 0;
for (ll i = 0; i < n; i++) {
for (ll j = 1; j <= k; j++) {
if (i + j <= n)
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i + j] - h[i]));
}
}
cout << dp[n - 1];
}
void dpC() {
ll n;
cin >> n;
vector<v> a(n, v(3, 0));
for (ll i = 0; i < n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
auto dp = vector<v>(n + 1, v(3, 0));
for (ll i = 0; i < n; i++)
for (ll today = 0; today < 3; today++)
for (ll oday = 0; oday < 3; oday++)
if (today != oday)
dp[i + 1][today] = max(dp[i + 1][today], dp[i][oday] + a[i][today]);
cout << max(dp[n][0], max(dp[n][1], dp[n][2]));
}
void dpD() {
ll N, W;
cin >> N >> W;
auto ww = v(N, 0);
auto vv = v(N, 0);
for (ll i = 0; i < N; i++)
cin >> ww[i] >> vv[i];
auto dp = vector<v>(N + 1, v(W + 1, 0));
for (ll i = 0; i < N; i++) {
for (ll j = 0; j <= W; j++) {
if (j - ww[i] >= 0)
dp[i + 1][j] = max(dp[i][j], dp[i][j - ww[i]] + vv[i]);
else
dp[i + 1][j] = dp[i][j];
}
}
cout << dp[N][W];
}
void dpE() {
ll N, W;
cin >> N >> W;
auto ww = v(N, 0);
auto vv = v(N, 0);
for (ll i = 0; i < N; i++)
cin >> ww[i] >> vv[i];
auto dp = vector<v>(N + 1, v(1e5 + 100, 1LL << 60));
dp[0][0] = 0;
for (ll i = 0; i < N; i++) {
for (ll j = 0; j <= 1e5; j++) {
if (j + vv[i] <= 1e5)
dp[i + 1][j + vv[i]] = min(dp[i + 1][j + vv[i]], dp[i][j] + ww[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
ll ans = 0;
for (auto i = 0; i <= 1e5; i++) {
if (dp[N][i] <= W) {
ans = i;
}
}
cout << ans;
}
int main() {
dpE();
return 0;
} | [
"assignment.change"
] | 970,566 | 970,567 | u533749093 | cpp |
p03164 | #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]; }
const ll MAX_VALUE = 1010;
vvl dp(n + 1,
vl(MAX_VALUE,
INF)); // dp[i+1][j] :
// i番目までの品物で価値の総和がjのときの重さの総和の最小値
dp[0][0] = 0;
rep(i, n) {
rep(j, MAX_VALUE) {
chmax(dp[i + 1][j], dp[i][j]);
if (j >= value[i]) {
chmin(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
}
}
ll ans = 0;
rep(j, MAX_VALUE) {
if (dp[n][j] <= W) {
ans = j;
}
}
out(ans);
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]; }
const ll MAX_VALUE = 100010;
vvl dp(n + 1,
vl(MAX_VALUE,
INF)); // dp[i+1][j] :
// i番目までの品物で価値の総和がjのときの重さの総和の最小値
dp[0][0] = 0;
rep(i, n) {
rep(j, MAX_VALUE) {
chmin(dp[i + 1][j], dp[i][j]);
if (j >= value[i]) {
chmin(dp[i + 1][j], dp[i][j - value[i]] + weight[i]);
}
}
}
ll ans = 0;
rep(j, MAX_VALUE) {
if (dp[n][j] <= W) {
ans = j;
}
}
out(ans);
re0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"call.function.change"
] | 970,584 | 970,583 | u828388155 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#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;
}
return 0;
}
const ll INF = 1LL << 60;
const int MAX_N = 110;
const int MAX_V = 100100;
int N;
ll W, weight[MAX_N], value[MAX_N];
ll dp[MAX_N][MAX_V];
int main() {
cin >> N >> W;
rep(i, N) { cin >> weight[i] >> value[i]; }
rep(i, MAX_N) {
rep(j, MAX_V) { dp[i][j] = INF; }
}
dp[0][0] = 0;
rep(i, N) {
for (int sum_v = 0; sum_v < MAX_V; sum_v++) {
if (sum_v - value[i] >= 0) {
chmin(dp[i + 1][sum_v], dp[i][sum_v - value[i]] + weight[i]);
}
chmax(dp[i + 1][sum_v], dp[i][sum_v]);
}
}
ll ans = 0;
for (int sum_v = 0; sum_v < MAX_V; sum_v++) {
if (dp[N][sum_v] <= W) {
ans = sum_v;
}
}
cout << ans;
cout << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#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;
}
return 0;
}
const ll INF = 1LL << 60;
const int MAX_N = 110;
const int MAX_V = 100100;
int N;
ll W, weight[MAX_N], value[MAX_N];
ll dp[MAX_N][MAX_V];
int main() {
cin >> N >> W;
rep(i, N) { cin >> weight[i] >> value[i]; }
rep(i, MAX_N) {
rep(j, MAX_V) { dp[i][j] = INF; }
}
dp[0][0] = 0;
rep(i, N) {
for (int sum_v = 0; sum_v < MAX_V; sum_v++) {
if (sum_v - value[i] >= 0) {
chmin(dp[i + 1][sum_v], dp[i][sum_v - value[i]] + weight[i]);
}
chmin(dp[i + 1][sum_v], dp[i][sum_v]);
}
}
ll ans = 0;
for (int sum_v = 0; sum_v < MAX_V; sum_v++) {
if (dp[N][sum_v] <= W) {
ans = sum_v;
}
}
cout << ans;
cout << endl;
return 0;
} | [
"identifier.change",
"call.function.change"
] | 970,585 | 970,586 | u828388155 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <set>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define sze 1000005
#define ld long double
#define ll long long
#define endl "\n"
#define pb push_back
#define mkp make_pair
#define mod 1000000007
#define ff first
#define ss second
#define F(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define RF(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)
using namespace std;
int main(int argc, const char *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, w;
cin >> n >> w;
ll v[n + 1], w1[n + 1];
for (ll i = 0; i < n; i++) {
cin >> w1[i];
cin >> v[i];
}
ll mx = 100005;
ll dp[mx + 5];
memset(dp, mx, sizeof(dp));
dp[0] = 0;
for (ll i = 0; i < n; i++) {
for (ll val = mx; val >= 0; val--) {
dp[val] = min(dp[val], (val >= v[i]) ? dp[val - v[i]] + w1[i] : INT_MAX);
}
}
ll fin = 0;
for (ll i = 0; i <= mx; i++) {
if (dp[i] <= w)
fin = i;
}
cout << fin << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <set>
#include <stdlib.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define sze 1000005
#define ld long double
#define ll long long
#define endl "\n"
#define pb push_back
#define mkp make_pair
#define mod 1000000007
#define ff first
#define ss second
#define F(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define RF(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)
using namespace std;
int main(int argc, const char *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, w;
cin >> n >> w;
ll v[n + 1], w1[n + 1];
for (ll i = 0; i < n; i++) {
cin >> w1[i];
cin >> v[i];
}
ll mx = 500005;
ll dp[mx + 5];
memset(dp, mx, sizeof(dp));
dp[0] = 0;
for (ll i = 0; i < n; i++) {
for (ll val = mx; val >= 0; val--) {
dp[val] = min(dp[val], (val >= v[i]) ? dp[val - v[i]] + w1[i] : INT_MAX);
}
}
ll fin = 0;
for (ll i = 0; i <= mx; i++) {
if (dp[i] <= w)
fin = i;
}
cout << fin << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 970,593 | 970,594 | u770316523 | cpp |
p03164 | #include <bits/stdc++.h>
typedef long long int ll;
using namespace std;
#define INF 1e9
int main() {
ll n, w;
cin >> n >> w;
ll v[n], wt[n];
for (ll i = 0; i < n; i++)
cin >> wt[i] >> v[i];
ll sum = 0;
for (int i = 1; i < n; i++)
sum += v[i];
ll dp[n + 5][sum + 5];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= sum; j++)
dp[i][j] = INF;
}
for (int i = 0; i <= n; i++)
dp[i][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= sum; j++) {
dp[i][j] = dp[i - 1][j];
if (j >= v[i - 1])
dp[i][j] = min(dp[i][j], dp[i - 1][j - v[i - 1]] + wt[i - 1]);
}
}
for (int i = sum; i >= 0; i--) {
if (dp[n][i] <= w) {
cout << i << "\n";
return 0;
}
}
return 0;
}
| #include <bits/stdc++.h>
typedef long long int ll;
using namespace std;
#define INF 1e9
int main() {
ll n, w;
cin >> n >> w;
ll v[n], wt[n];
for (ll i = 0; i < n; i++)
cin >> wt[i] >> v[i];
ll sum = 0;
for (int i = 0; i < n; i++)
sum += v[i];
ll dp[n + 5][sum + 5];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= sum; j++)
dp[i][j] = INF;
}
for (int i = 0; i <= n; i++)
dp[i][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= sum; j++) {
dp[i][j] = dp[i - 1][j];
if (j >= v[i - 1])
dp[i][j] = min(dp[i][j], dp[i - 1][j - v[i - 1]] + wt[i - 1]);
}
}
for (int i = sum; i >= 0; i--) {
if (dp[n][i] <= w) {
cout << i << "\n";
return 0;
}
// cout << dp[n][i] << " " << i << "\n";
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 970,610 | 970,611 | u370388551 | cpp |
p03164 | // #pragma GCC optimize("O3")
// #pragma GCC target("sse4")
#include <bits/stdc++.h>
using namespace std;
#define GET_MACRO(_1, _2, _3, _4, NAME, ...) NAME
#define __FOR3(i, a, n, inc) \
for (int i = (a); (inc) > 0 ? i < (n) : i >= (n); i += (inc))
#define __FOR2(i, a, n) __FOR3(i, a, n, 1)
#define __FOR1(i, n) __FOR2(i, 0, n)
#define FOR(...) GET_MACRO(__VA_ARGS__, __FOR3, __FOR2, __FOR1)(__VA_ARGS__)
#define BOOST \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ELO exit(0)
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) (int)(a).size()
#define TRAV(a, b) for (auto &a : b)
#define REV(a) reverse(ALL(a))
#define SORT(a) sort(ALL(a))
#define SORTR(a) SORT(a), REV(a)
#define PB push_back
#define F first
#define S second
using ll = long long;
using ld = long double; // 'long double' is 2.2 times slower than double
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
using vb = vector<bool>;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vld = vector<ld>;
using vpld = vector<pld>;
constexpr int MOD = 1e9 + 7; // 998244353
constexpr int INF = MOD;
constexpr ll LLINF = 1e18;
const ld PI = acos(-1);
template <class T> inline bool setmin(T &a, T b) {
if (a > b)
return a = b, 1;
return 0;
}
template <class T> inline bool setmax(T &a, T b) {
if (a < b)
return a = b, 1;
return 0;
}
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <class key, class cmp = less<key>>
using ordered_set =
tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template <class key, class cmp = less_equal<key>>
using ordered_multiset =
tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
//* find_by_order(k) - returns an iterator to the k-th largest element (counting
//from zero)
//* order_of_key(k) - the number of items in a set that are strictly smaller
//than k.
template <class key, class value, class cmp = less<key>>
using ordered_map =
tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
using pref_trie = trie<string, null_type, trie_string_access_traits<>,
pat_trie_tag, trie_prefix_search_node_update>;
// * prefix_range(s) - return iterator range, prefix equal to s
namespace input {
template <class T> istream &operator>>(istream &os, vector<T> &vec) {
for (auto &u : vec)
os >> u;
return os;
}
template <class T1, class T2>
istream &operator>>(istream &os, pair<T1, T2> &p) {
return os >> p.first >> p.second;
}
template <class T, size_t N> istream &operator>>(istream &os, array<T, N> &a) {
for (auto &u : a)
os >> u;
return os;
}
void re() {}
template <typename T, typename... args> void re(T &x, args &...tail) {
cin >> x;
re(tail...);
}
} // namespace input
using namespace input;
namespace output {
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (const auto &u : vec)
os << u << " ";
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, set<T> &con) {
for (const auto &u : con)
os << u << " ";
return os;
}
template <class T, size_t N> ostream &operator<<(ostream &os, array<T, N> &a) {
for (const auto &u : a)
os << u << " ";
return os;
}
void pr() {}
template <typename T> void pr(const T &x) { cout << x; }
template <typename T, typename... args>
void pr(const T &x, const args &...tail) {
cout << x << " ";
pr(tail...);
}
template <typename T> void prs(const T &x) { cout << x << " "; }
template <typename T, typename... args>
void prs(const T &x, const args &...tail) {
cout << x << " ";
prs(tail...);
}
template <typename... args> void prln(const args &...tail) {
pr(tail...);
cout << "\n";
}
} // namespace output
using namespace output;
namespace pair_magic {
#define PT1T2 pair<T1, T2>
#define TT1T2 template <class T1, class T2>
TT1T2 inline PT1T2 operator+(const PT1T2 &p1, const PT1T2 &p2) {
return PT1T2(p1.first + p2.first, p1.second + p2.second);
}
TT1T2 inline PT1T2 &operator+=(PT1T2 &p1, const PT1T2 &p2) {
p1.first += p2.first, p1.second += p2.second;
return p1;
}
TT1T2 inline PT1T2 operator-(const PT1T2 &p1, const PT1T2 &p2) {
return PT1T2(p1.first - p2.first, p1.second - p2.second);
}
TT1T2 inline PT1T2 &operator-=(PT1T2 &p1, const PT1T2 &p2) {
p1.first -= p2.first, p1.second -= p2.second;
return p1;
}
#undef PT1T2
#undef TT1T2
} // namespace pair_magic
using namespace pair_magic;
namespace random_nsp {
thread_local std::mt19937 gen{std::random_device{}()};
template <typename T> T random(T min, T max) {
using dist = std::conditional_t<std::is_integral<T>::value,
std::uniform_int_distribution<T>,
std::uniform_real_distribution<T>>;
return dist{min, max}(gen);
}
template <typename T> T randomINT(T min, T max) {
return std::uniform_int_distribution<T>{min, max}(gen);
}
} // namespace random_nsp
using namespace random_nsp;
namespace triple {
#define TT1T2T3 template <class T1, class T2, class T3>
#define TRT1T2T3 triple<T1, T2, T3>
TT1T2T3 struct triple {
T1 a;
T2 b;
T3 c;
triple() : a(T1()), b(T2()), c(T3()){};
triple(T1 _a, T2 _b, T3 _c) : a(_a), b(_b), c(_c) {}
};
TT1T2T3 bool operator<(const TRT1T2T3 &t1, const TRT1T2T3 &t2) {
if (t1.a != t2.a)
return t1.a < t2.a;
else if (t1.b != t2.b)
return t1.b < t2.b;
else
return t1.c < t2.c;
}
TT1T2T3 bool operator>(const TRT1T2T3 &t1, const TRT1T2T3 &t2) {
if (t1.a != t2.a)
return t1.a > t2.a;
else if (t1.b != t2.b)
return t1.b > t2.b;
else
return t1.c > t2.c;
}
TT1T2T3 bool operator==(const TRT1T2T3 &t1, const TRT1T2T3 &t2) {
return (t1.a == t2.a && t1.b == t2.b && t1.c == t2.c);
}
TT1T2T3 inline istream &operator>>(istream &os, triple<T1, T2, T3> &t) {
return os >> t.a >> t.b >> t.c;
}
TT1T2T3 ostream &operator<<(ostream &os, const triple<T1, T2, T3> &t) {
return os << t.a << " " << t.b << " " << t.c;
}
#undef TRT1T2T3
#undef TT1T2T3
using tri = triple<int, int, int>;
using trll = triple<ll, ll, ll>;
using vtri = vector<tri>;
using vtrll = vector<trll>;
} // namespace triple
using namespace triple;
template <class T> T invGeneral(T a, T b) { // 0 < a < b, gcd(a,b) = 1
a %= b;
if (a == 0)
return b == 1 ? 0 : -1;
T x = invGeneral(b, a);
return x == -1 ? -1 : ((1 - (ll)b * x) / a + b) % b;
}
template <class T, int MOD> struct modular {
T val;
explicit operator T() const { return val; }
modular() { val = 0; }
modular(const ll &v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0)
val += MOD;
}
friend ostream &operator<<(ostream &os, const modular &a) {
return os << a.val;
}
friend void pr(const modular &a) { pr(a.val); }
friend void re(modular &a) {
ll x;
re(x);
a = modular(x);
}
friend bool operator==(const modular &a, const modular &b) {
return a.val == b.val;
}
friend bool operator!=(const modular &a, const modular &b) {
return !(a == b);
}
friend bool operator<(const modular &a, const modular &b) {
return a.val < b.val;
}
modular operator-() const { return modular(-val); }
modular &operator+=(const modular &m) {
if ((val += m.val) >= MOD)
val -= MOD;
return *this;
}
modular &operator-=(const modular &m) {
if ((val -= m.val) < 0)
val += MOD;
return *this;
}
modular &operator*=(const modular &m) {
val = (ll)val * m.val % MOD;
return *this;
}
friend modular pow(modular a, ll p) {
modular ans = 1;
for (; p; p /= 2, a *= a)
if (p & 1)
ans *= a;
return ans;
}
friend modular inv(const modular &a) {
auto i = invGeneral(a.val, MOD);
assert(i != -1);
return i;
} // equivalent to return exp(b,MOD-2) if MOD is prime
modular &operator/=(const modular &m) { return (*this) *= inv(m); }
friend modular operator+(modular a, const modular &b) { return a += b; }
friend modular operator-(modular a, const modular &b) { return a -= b; }
friend modular operator*(modular a, const modular &b) { return a *= b; }
friend modular operator/(modular a, const modular &b) { return a /= b; }
};
using mi = modular<int, MOD>;
using pmi = pair<mi, mi>;
using vmi = vector<mi>;
using vpmi = vector<pmi>;
namespace debug {
template <typename _T> inline void _debug(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _debug(const char *s, _T x, args... a) {
while (*s != ',')
cerr << *s++;
cerr << " = " << x << ',';
_debug(s + 1, a...);
}
#ifdef LOCAL
#define debug(...) _debug(#__VA_ARGS__, __VA_ARGS__)
#define cerr cout
#else
#define debug(...) 1999
#define cerr \
if (0) \
cout
#endif
} // namespace debug
using namespace debug;
//////////////_________CODE_________//////////////
int main() {
BOOST;
int n, W;
re(n, W);
vll dp(1000 * n, LLINF);
dp[0] = 0;
vll w(n), v(n);
FOR(i, n) re(w[i], v[i]);
ll s = accumulate(ALL(v), 0ll);
FOR(i, n) {
FOR(j, s - v[i], 0, -1) { setmin(dp[j + v[i]], dp[j] + w[i]); }
}
ll res = 0;
FOR(i, s) if (dp[i] <= W) { res = i; }
prln(res);
} | // #pragma GCC optimize("O3")
// #pragma GCC target("sse4")
#include <bits/stdc++.h>
using namespace std;
#define GET_MACRO(_1, _2, _3, _4, NAME, ...) NAME
#define __FOR3(i, a, n, inc) \
for (int i = (a); (inc) > 0 ? i < (n) : i >= (n); i += (inc))
#define __FOR2(i, a, n) __FOR3(i, a, n, 1)
#define __FOR1(i, n) __FOR2(i, 0, n)
#define FOR(...) GET_MACRO(__VA_ARGS__, __FOR3, __FOR2, __FOR1)(__VA_ARGS__)
#define BOOST \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ELO exit(0)
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) (int)(a).size()
#define TRAV(a, b) for (auto &a : b)
#define REV(a) reverse(ALL(a))
#define SORT(a) sort(ALL(a))
#define SORTR(a) SORT(a), REV(a)
#define PB push_back
#define F first
#define S second
using ll = long long;
using ld = long double; // 'long double' is 2.2 times slower than double
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
using vb = vector<bool>;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vld = vector<ld>;
using vpld = vector<pld>;
constexpr int MOD = 1e9 + 7; // 998244353
constexpr int INF = MOD;
constexpr ll LLINF = 1e18;
const ld PI = acos(-1);
template <class T> inline bool setmin(T &a, T b) {
if (a > b)
return a = b, 1;
return 0;
}
template <class T> inline bool setmax(T &a, T b) {
if (a < b)
return a = b, 1;
return 0;
}
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <class key, class cmp = less<key>>
using ordered_set =
tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template <class key, class cmp = less_equal<key>>
using ordered_multiset =
tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
//* find_by_order(k) - returns an iterator to the k-th largest element (counting
//from zero)
//* order_of_key(k) - the number of items in a set that are strictly smaller
//than k.
template <class key, class value, class cmp = less<key>>
using ordered_map =
tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
using pref_trie = trie<string, null_type, trie_string_access_traits<>,
pat_trie_tag, trie_prefix_search_node_update>;
// * prefix_range(s) - return iterator range, prefix equal to s
namespace input {
template <class T> istream &operator>>(istream &os, vector<T> &vec) {
for (auto &u : vec)
os >> u;
return os;
}
template <class T1, class T2>
istream &operator>>(istream &os, pair<T1, T2> &p) {
return os >> p.first >> p.second;
}
template <class T, size_t N> istream &operator>>(istream &os, array<T, N> &a) {
for (auto &u : a)
os >> u;
return os;
}
void re() {}
template <typename T, typename... args> void re(T &x, args &...tail) {
cin >> x;
re(tail...);
}
} // namespace input
using namespace input;
namespace output {
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (const auto &u : vec)
os << u << " ";
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, set<T> &con) {
for (const auto &u : con)
os << u << " ";
return os;
}
template <class T, size_t N> ostream &operator<<(ostream &os, array<T, N> &a) {
for (const auto &u : a)
os << u << " ";
return os;
}
void pr() {}
template <typename T> void pr(const T &x) { cout << x; }
template <typename T, typename... args>
void pr(const T &x, const args &...tail) {
cout << x << " ";
pr(tail...);
}
template <typename T> void prs(const T &x) { cout << x << " "; }
template <typename T, typename... args>
void prs(const T &x, const args &...tail) {
cout << x << " ";
prs(tail...);
}
template <typename... args> void prln(const args &...tail) {
pr(tail...);
cout << "\n";
}
} // namespace output
using namespace output;
namespace pair_magic {
#define PT1T2 pair<T1, T2>
#define TT1T2 template <class T1, class T2>
TT1T2 inline PT1T2 operator+(const PT1T2 &p1, const PT1T2 &p2) {
return PT1T2(p1.first + p2.first, p1.second + p2.second);
}
TT1T2 inline PT1T2 &operator+=(PT1T2 &p1, const PT1T2 &p2) {
p1.first += p2.first, p1.second += p2.second;
return p1;
}
TT1T2 inline PT1T2 operator-(const PT1T2 &p1, const PT1T2 &p2) {
return PT1T2(p1.first - p2.first, p1.second - p2.second);
}
TT1T2 inline PT1T2 &operator-=(PT1T2 &p1, const PT1T2 &p2) {
p1.first -= p2.first, p1.second -= p2.second;
return p1;
}
#undef PT1T2
#undef TT1T2
} // namespace pair_magic
using namespace pair_magic;
namespace random_nsp {
thread_local std::mt19937 gen{std::random_device{}()};
template <typename T> T random(T min, T max) {
using dist = std::conditional_t<std::is_integral<T>::value,
std::uniform_int_distribution<T>,
std::uniform_real_distribution<T>>;
return dist{min, max}(gen);
}
template <typename T> T randomINT(T min, T max) {
return std::uniform_int_distribution<T>{min, max}(gen);
}
} // namespace random_nsp
using namespace random_nsp;
namespace triple {
#define TT1T2T3 template <class T1, class T2, class T3>
#define TRT1T2T3 triple<T1, T2, T3>
TT1T2T3 struct triple {
T1 a;
T2 b;
T3 c;
triple() : a(T1()), b(T2()), c(T3()){};
triple(T1 _a, T2 _b, T3 _c) : a(_a), b(_b), c(_c) {}
};
TT1T2T3 bool operator<(const TRT1T2T3 &t1, const TRT1T2T3 &t2) {
if (t1.a != t2.a)
return t1.a < t2.a;
else if (t1.b != t2.b)
return t1.b < t2.b;
else
return t1.c < t2.c;
}
TT1T2T3 bool operator>(const TRT1T2T3 &t1, const TRT1T2T3 &t2) {
if (t1.a != t2.a)
return t1.a > t2.a;
else if (t1.b != t2.b)
return t1.b > t2.b;
else
return t1.c > t2.c;
}
TT1T2T3 bool operator==(const TRT1T2T3 &t1, const TRT1T2T3 &t2) {
return (t1.a == t2.a && t1.b == t2.b && t1.c == t2.c);
}
TT1T2T3 inline istream &operator>>(istream &os, triple<T1, T2, T3> &t) {
return os >> t.a >> t.b >> t.c;
}
TT1T2T3 ostream &operator<<(ostream &os, const triple<T1, T2, T3> &t) {
return os << t.a << " " << t.b << " " << t.c;
}
#undef TRT1T2T3
#undef TT1T2T3
using tri = triple<int, int, int>;
using trll = triple<ll, ll, ll>;
using vtri = vector<tri>;
using vtrll = vector<trll>;
} // namespace triple
using namespace triple;
template <class T> T invGeneral(T a, T b) { // 0 < a < b, gcd(a,b) = 1
a %= b;
if (a == 0)
return b == 1 ? 0 : -1;
T x = invGeneral(b, a);
return x == -1 ? -1 : ((1 - (ll)b * x) / a + b) % b;
}
template <class T, int MOD> struct modular {
T val;
explicit operator T() const { return val; }
modular() { val = 0; }
modular(const ll &v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0)
val += MOD;
}
friend ostream &operator<<(ostream &os, const modular &a) {
return os << a.val;
}
friend void pr(const modular &a) { pr(a.val); }
friend void re(modular &a) {
ll x;
re(x);
a = modular(x);
}
friend bool operator==(const modular &a, const modular &b) {
return a.val == b.val;
}
friend bool operator!=(const modular &a, const modular &b) {
return !(a == b);
}
friend bool operator<(const modular &a, const modular &b) {
return a.val < b.val;
}
modular operator-() const { return modular(-val); }
modular &operator+=(const modular &m) {
if ((val += m.val) >= MOD)
val -= MOD;
return *this;
}
modular &operator-=(const modular &m) {
if ((val -= m.val) < 0)
val += MOD;
return *this;
}
modular &operator*=(const modular &m) {
val = (ll)val * m.val % MOD;
return *this;
}
friend modular pow(modular a, ll p) {
modular ans = 1;
for (; p; p /= 2, a *= a)
if (p & 1)
ans *= a;
return ans;
}
friend modular inv(const modular &a) {
auto i = invGeneral(a.val, MOD);
assert(i != -1);
return i;
} // equivalent to return exp(b,MOD-2) if MOD is prime
modular &operator/=(const modular &m) { return (*this) *= inv(m); }
friend modular operator+(modular a, const modular &b) { return a += b; }
friend modular operator-(modular a, const modular &b) { return a -= b; }
friend modular operator*(modular a, const modular &b) { return a *= b; }
friend modular operator/(modular a, const modular &b) { return a /= b; }
};
using mi = modular<int, MOD>;
using pmi = pair<mi, mi>;
using vmi = vector<mi>;
using vpmi = vector<pmi>;
namespace debug {
template <typename _T> inline void _debug(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _debug(const char *s, _T x, args... a) {
while (*s != ',')
cerr << *s++;
cerr << " = " << x << ',';
_debug(s + 1, a...);
}
#ifdef LOCAL
#define debug(...) _debug(#__VA_ARGS__, __VA_ARGS__)
#define cerr cout
#else
#define debug(...) 1999
#define cerr \
if (0) \
cout
#endif
} // namespace debug
using namespace debug;
//////////////_________CODE_________//////////////
int main() {
BOOST;
int n, W;
re(n, W);
vll dp(1000 * n, LLINF);
dp[0] = 0;
vll w(n), v(n);
FOR(i, n) re(w[i], v[i]);
ll s = accumulate(ALL(v), 0ll);
FOR(i, n) {
FOR(j, s - v[i], 0, -1) { setmin(dp[j + v[i]], dp[j] + w[i]); }
}
ll res = 0;
FOR(i, s + 1) if (dp[i] <= W) { res = i; }
prln(res);
} | [
"expression.operation.binary.add"
] | 970,650 | 970,651 | u691350599 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (int)(a); i++)
#define REP1(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
typedef long long LL;
const int MAX_N = 105, MAX_V = 105, MAX_W = 1e9 + 7;
int n, W;
int v[MAX_N], w[MAX_N];
LL dp[MAX_V];
void input() {
scanf("%d %d", &n, &W);
REP(i, n) { scanf("%d %d", &w[i], &v[i]); }
}
void solve() {
REP(i, MAX_V) dp[i] = MAX_W;
dp[0] = 0;
REP(i, n) {
for (int j = MAX_V; j >= v[i]; j--) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
}
}
for (int i = MAX_V - 1; i >= 0; i--) {
if (dp[i] <= W) {
printf("%d\n", i);
break;
}
}
}
int main() {
input();
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (int)(a); i++)
#define REP1(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
typedef long long LL;
const int MAX_N = 105, MAX_V = 100005, MAX_W = 1e9 + 7;
int n, W;
int v[MAX_N], w[MAX_N];
LL dp[MAX_V];
void input() {
scanf("%d %d", &n, &W);
REP(i, n) { scanf("%d %d", &w[i], &v[i]); }
}
void solve() {
REP(i, MAX_V) dp[i] = MAX_W;
dp[0] = 0;
REP(i, n) {
for (int j = MAX_V; j >= v[i]; j--) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
}
}
for (int i = MAX_V - 1; i >= 0; i--) {
if (dp[i] <= W) {
printf("%d\n", i);
break;
}
}
}
int main() {
input();
solve();
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 970,659 | 970,660 | u385825353 | cpp |
p03164 | #include <bits/stdc++.h>
#define INF 900000000000
#define MAXN 110
#define MAXV 1100
using namespace std;
long long N, W;
long long dp[MAXV];
int v[MAXN];
int w[MAXN];
int main() {
fill(dp, dp + MAXV, INF);
cin >> N >> W;
int maxx = 0;
for (int i = 1; i <= N; i++) {
cin >> w[i] >> v[i];
maxx = max(v[i], maxx);
}
int maxv = maxx * N;
dp[0] = 0;
for (int i = 1; i <= N; i++) {
for (int j = maxv; j >= v[i]; j--) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
}
}
for (int i = maxv; i >= 1; i--) {
if (dp[i] <= W) {
cout << i;
return 0;
}
}
} | #include <bits/stdc++.h>
#define INF 900000000000
#define MAXN 110
#define MAXV 110000
using namespace std;
long long N, W;
long long dp[MAXV];
int v[MAXN];
int w[MAXN];
int main() {
fill(dp, dp + MAXV, INF);
cin >> N >> W;
int maxx = 0;
for (int i = 1; i <= N; i++) {
cin >> w[i] >> v[i];
maxx = max(v[i], maxx);
}
int maxv = maxx * N + 1;
dp[0] = 0;
for (int i = 1; i <= N; i++) {
for (int j = maxv; j >= v[i]; j--) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
}
}
for (int i = maxv; i >= 0; i--) {
if (dp[i] <= W) {
cout << i;
return 0;
}
}
} | [
"preprocessor.define.value.change",
"literal.integer.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 970,684 | 970,685 | u393584172 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 + 4e3;
typedef long long LL;
typedef pair<int, int> II;
typedef pair<int, II> III;
int n, m;
int main() {
#define TASK "ABC"
// freopen(TASK".inp","r",stdin);
// freopen(TASK".out","w",stdout);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<long long> dp(1000 * n + 1, 1e12);
int maxval = 1000 * n + 1;
dp[0] = 0;
for (int i = 0; i < n; i++) {
long long weight, val;
cin >> weight >> val;
for (int j = maxval - val; j >= 0; j--) {
dp[j + val] = min(dp[j + val], dp[j] + weight);
}
}
for (int i = 10000; i >= 0; i--) {
if (dp[i] <= m) {
cout << i << endl;
return 0;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 + 4e3;
typedef long long LL;
typedef pair<int, int> II;
typedef pair<int, II> III;
int n, m;
int main() {
#define TASK "ABC"
// freopen(TASK".inp","r",stdin);
// freopen(TASK".out","w",stdout);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<long long> dp(1000 * n + 1, 1e12);
int maxval = 1000 * n + 1;
dp[0] = 0;
for (int i = 0; i < n; i++) {
long long weight, val;
cin >> weight >> val;
for (int j = maxval - val; j >= 0; j--) {
dp[j + val] = min(dp[j + val], dp[j] + weight);
}
}
for (int i = 1000 * n; i >= 0; i--) {
if (dp[i] <= m) {
cout << i << endl;
return 0;
}
}
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change"
] | 970,688 | 970,689 | u241126472 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 + 4e3;
typedef long long LL;
typedef pair<int, int> II;
typedef pair<int, II> III;
int n, m;
int main() {
#define TASK "ABC"
// freopen(TASK".inp","r",stdin);
// freopen(TASK".out","w",stdout);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<long long> dp(1000 * n + 1, 1e12);
int maxval = 1000 * n + 1;
dp[0] = 0;
for (int i = 0; i < n; i++) {
long long weight, val;
cin >> weight >> val;
for (int j = maxval - val; j >= 0; j--) {
dp[j + val] = min(dp[j + val], dp[j] + weight);
}
}
for (int i = maxval; i >= 0; i--) {
if (dp[i] <= m) {
cout << i << endl;
return 0;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 + 4e3;
typedef long long LL;
typedef pair<int, int> II;
typedef pair<int, II> III;
int n, m;
int main() {
#define TASK "ABC"
// freopen(TASK".inp","r",stdin);
// freopen(TASK".out","w",stdout);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<long long> dp(1000 * n + 1, 1e12);
int maxval = 1000 * n + 1;
dp[0] = 0;
for (int i = 0; i < n; i++) {
long long weight, val;
cin >> weight >> val;
for (int j = maxval - val; j >= 0; j--) {
dp[j + val] = min(dp[j + val], dp[j] + weight);
}
}
for (int i = 1000 * n; i >= 0; i--) {
if (dp[i] <= m) {
cout << i << endl;
return 0;
}
}
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.initializer.change"
] | 970,691 | 970,689 | u241126472 | cpp |
p03164 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
const int MV = 1 << 30;
int main() {
int N, W;
cin >> N >> W;
vi we(N), va(N);
rep(i, N) { cin >> we[i] >> va[i]; }
v(ll) dp(MV, LINF);
dp[0] = 0;
rep(i, N) {
v(ll) nextdp(MV);
ll w = we[i];
ll val = va[i];
rep(x, MV) {
if (x - val >= 0) {
nextdp[x] = min(dp[x], dp[x - val] + w);
} else {
nextdp[x] = dp[x];
}
}
dp = nextdp;
}
drep(i, MV) {
if (dp[i] <= W) {
cout << i << endl;
break;
}
}
return 0;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
const int MV = 100100;
int main() {
int N, W;
cin >> N >> W;
vi we(N), va(N);
rep(i, N) { cin >> we[i] >> va[i]; }
v(ll) dp(MV, LINF);
dp[0] = 0;
rep(i, N) {
v(ll) nextdp(MV);
ll w = we[i];
ll val = va[i];
rep(x, MV) {
if (x - val >= 0) {
nextdp[x] = min(dp[x], dp[x - val] + w);
} else {
nextdp[x] = dp[x];
}
}
dp = nextdp;
}
drep(i, MV) {
if (dp[i] <= W) {
cout << i << endl;
break;
}
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 970,706 | 970,704 | u340293807 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define REP(i, k, n) for (long long i = k; i < (long long)(n); i++)
#define all(a) a.begin(), a.end()
#define eb emplace_back
#define pb push_back
#define lb(v, k) lower_bound(all(v), k) - v.begin()
#define chmin(x, y) \
if (x > y) \
x = y
#define chmax(x, y) \
if (x < y) \
x = y
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> PP;
typedef priority_queue<ll> PQ;
typedef priority_queue<ll, vector<ll>, greater<ll>> SPQ;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
ll inf = 100100100100;
const int mod = 1000000007;
int main() {
int n, w;
cin >> n >> w;
vvi dp(n, vi(n * 61, inf));
vi omosa(n), kachi(n);
rep(i, n) dp[i][0] = 0;
rep(i, n) cin >> omosa[i] >> kachi[i];
rep(i, n) {
rep(j, (i + 1) * 61) {
if (j > kachi[i]) {
if (i > 0) {
chmin(dp[i][j], dp[i - 1][j - kachi[i]] + omosa[i]);
}
} else
chmin(dp[i][j], omosa[i]);
if (i > 0)
chmin(dp[i][j], dp[i - 1][j]);
}
}
for (int i = n * 61 - 1; i >= 0; i--) {
if (dp[n - 1][i] <= w) {
cout << i << endl;
return 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define REP(i, k, n) for (long long i = k; i < (long long)(n); i++)
#define all(a) a.begin(), a.end()
#define eb emplace_back
#define pb push_back
#define lb(v, k) lower_bound(all(v), k) - v.begin()
#define chmin(x, y) \
if (x > y) \
x = y
#define chmax(x, y) \
if (x < y) \
x = y
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> PP;
typedef priority_queue<ll> PQ;
typedef priority_queue<ll, vector<ll>, greater<ll>> SPQ;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
ll inf = 100100100100;
const int mod = 1000000007;
int main() {
int n, w;
cin >> n >> w;
vvi dp(n, vi(n * 1001, inf));
vi omosa(n), kachi(n);
rep(i, n) dp[i][0] = 0;
rep(i, n) cin >> omosa[i] >> kachi[i];
rep(i, n) {
rep(j, (i + 1) * 1001) {
if (j > kachi[i]) {
if (i > 0) {
chmin(dp[i][j], dp[i - 1][j - kachi[i]] + omosa[i]);
}
} else
chmin(dp[i][j], omosa[i]);
if (i > 0)
chmin(dp[i][j], dp[i - 1][j]);
}
}
for (int i = n * 1001 - 1; i >= 0; i--) {
if (dp[n - 1][i] <= w) {
cout << i << endl;
return 0;
}
}
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.for.initializer.change"
] | 970,741 | 970,742 | u422633119 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
ll dp[100005], a[105], b[105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll N, W, i, j, ans;
cin >> N >> W;
for (i = 0; i < 100005; i++)
dp[i] = 99999999;
for (i = 0; i < N; i++)
cin >> a[i] >> b[i];
dp[0] = 0;
for (i = 0; i < N; i++) {
for (j = 100004; j >= 0; j--) {
if (j + b[i] < 100005)
dp[j + b[i]] = min(dp[j + b[i]], dp[j] + a[i]);
}
}
for (i = 0; i < 100005; i++) {
if (dp[i] <= W) {
ans = i;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define inf 99999999999999
ll dp[100005], a[105], b[105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll N, W, i, j, ans;
cin >> N >> W;
for (i = 0; i < 100005; i++)
dp[i] = inf;
for (i = 0; i < N; i++)
cin >> a[i] >> b[i];
dp[0] = 0;
for (i = 0; i < N; i++) {
for (j = 100004; j >= 0; j--) {
if (j + b[i] < 100005)
dp[j + b[i]] = min(dp[j + b[i]], dp[j] + a[i]);
}
}
for (i = 0; i < 100005; i++) {
if (dp[i] <= W) {
ans = i;
}
}
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 970,752 | 970,753 | u665987027 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define INF 2e9
#define INF_LL 1LL << 60
#define ll long long
#define MOD 1e9 + 7
#define MAX_V
const double PI = 3.14159265358979323846;
#define print2D(h, w, arr) \
REP(i, h) { \
REP(j, w) cout << arr[i][j] << " "; \
cout << endl; \
}
#define print_line(vec, n) \
{ \
for (int i = 0; i < (n - 1); i++) \
cout << (vec)[i] << " "; \
cout << (vec)[(n)-1] << endl; \
}
template <class T> void print(const T &x) { cout << x << endl; }
template <class T, class... A> void print(const T &first, const A &...rest) {
cout << first << " ";
print(rest...);
}
struct PreMain {
PreMain() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} premain;
int dp[100001];
int main() {
int N, W;
cin >> N >> W;
vector<int> w(N), v(N);
REP(i, N) cin >> w[i] >> v[i];
REP(i, 100001) dp[i] = INF;
dp[0] = 0;
REP(i, N) REPN_REV(j, v[i], 100001) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
}
for (int i = 100000; i >= 0; i--) {
if (dp[i] <= W) {
cout << i << endl;
return 0;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define INF 2e9
#define INF_LL 1LL << 60
#define ll long long
#define MOD 1e9 + 7
#define MAX_V
const double PI = 3.14159265358979323846;
#define print2D(h, w, arr) \
REP(i, h) { \
REP(j, w) cout << arr[i][j] << " "; \
cout << endl; \
}
#define print_line(vec, n) \
{ \
for (int i = 0; i < (n - 1); i++) \
cout << (vec)[i] << " "; \
cout << (vec)[(n)-1] << endl; \
}
template <class T> void print(const T &x) { cout << x << endl; }
template <class T, class... A> void print(const T &first, const A &...rest) {
cout << first << " ";
print(rest...);
}
struct PreMain {
PreMain() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} premain;
ll dp[100001];
int main() {
int N, W;
cin >> N >> W;
vector<int> w(N), v(N);
REP(i, N) cin >> w[i] >> v[i];
REP(i, 100001) dp[i] = INF;
dp[0] = 0;
REP(i, N) REPN_REV(j, v[i], 100001) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
}
for (int i = 100000; i >= 0; i--) {
if (dp[i] <= W) {
cout << i << endl;
return 0;
}
}
return 0;
} | [
"variable_declaration.type.change"
] | 970,769 | 970,770 | u127768253 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb(x) push_back(x)
#define f(i, st, n) for (i = st; i < n; i++)
#define qu queue
#define ps(x) push(x)
#define vec vector
#define ft() front()
#define mst(a, b) memset(a, b, sizeof(a))
#define mod 1000000007
#define sfl(x) scanf("%lld", &x)
#define pfl(x) printf("%lld\n", x)
#define pf(x) printf("%lld", x)
#define mpr make_pair
#define fs first
#define se second
#define inf LLONG_MAX
ll gcd(ll a, ll b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
ll power(ll x, ll y) {
ll res = 1;
while (y > 0) {
if (y % 2 == 1) {
res = (res * x);
}
x = (x * x);
y = y / 2;
}
return res;
}
int main() {
/* #ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif*/
ll n, i, w, j, x, y, k;
sfl(n);
sfl(w);
vec<ll> dp(100005, inf), dp1(100005, inf);
dp[1] = 0;
dp[0] = 0;
f(i, 0, n) {
sfl(x);
sfl(y);
f(j, 1, 100005) {
if (y <= j && dp[j - y] != inf)
dp1[j] = min(dp[j], dp[j - y] + x);
}
dp = dp1;
}
for (i = 100004; i >= 0; i--) {
if (dp[i] <= w) {
cout << i;
break;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb(x) push_back(x)
#define f(i, st, n) for (i = st; i < n; i++)
#define qu queue
#define ps(x) push(x)
#define vec vector
#define ft() front()
#define mst(a, b) memset(a, b, sizeof(a))
#define mod 1000000007
#define sfl(x) scanf("%lld", &x)
#define pfl(x) printf("%lld\n", x)
#define pf(x) printf("%lld", x)
#define mpr make_pair
#define fs first
#define se second
#define inf LLONG_MAX
ll gcd(ll a, ll b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
ll power(ll x, ll y) {
ll res = 1;
while (y > 0) {
if (y % 2 == 1) {
res = (res * x);
}
x = (x * x);
y = y / 2;
}
return res;
}
int main() {
/* #ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif*/
ll n, i, w, j, x, y, k;
sfl(n);
sfl(w);
vec<ll> dp(100005, inf), dp1(100005, inf);
dp1[0] = 0;
dp[0] = 0;
f(i, 0, n) {
sfl(x);
sfl(y);
f(j, 1, 100005) {
if (y <= j && dp[j - y] != inf)
dp1[j] = min(dp[j], dp[j - y] + x);
}
dp = dp1;
}
for (i = 100004; i >= 0; i--) {
if (dp[i] <= w) {
cout << i;
break;
}
}
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"literal.number.change",
"variable_access.subscript.index.change"
] | 970,771 | 970,772 | u909791791 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long int w1;
cin >> n >> w1;
long long v[n];
long long w[n];
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
sum += v[i];
}
long long dp[n + 1][sum] = {};
for (int i = 0; i <= n; i++) {
for (long long j = 0; j < sum; j++) {
dp[i][j] = std::numeric_limits<long long>::max() >> 2;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (long long j = 0; j < sum; j++) {
// dp[i+1][j]=max(dp[i+1][j],dp[i][j]);
if (j - v[i] >= 0) {
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i]);
} else
dp[i + 1][j] = dp[i][j];
}
}
long long ans = 0;
/*for(int i=0;i<=n;i++)
{
for(long long j=0;j<sum;j++)
{
// dp[i][j]=std::numeric_limits<long long>::max();
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
for (int i = 0; i < sum; i++) {
if (dp[n][i] <= w1)
ans = i;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long int w1;
cin >> n >> w1;
long long v[n];
long long w[n];
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
sum += v[i];
}
long long dp[n + 1][sum + 1] = {};
for (int i = 0; i <= n; i++) {
for (long long j = 0; j <= sum; j++) {
dp[i][j] = std::numeric_limits<long long>::max() >> 2;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (long long j = 0; j <= sum; j++) {
// dp[i+1][j]=max(dp[i+1][j],dp[i][j]);
if (j - v[i] >= 0) {
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i]);
} else
dp[i + 1][j] = dp[i][j];
}
}
long long ans = 0;
/* for(int i=0;i<=n;i++)
{
for(long long j=0;j<sum;j++)
{
// dp[i][j]=std::numeric_limits<long long>::max();
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
for (int i = 0; i <= sum; i++) {
if (dp[n][i] <= w1)
ans = i;
}
cout << ans;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 970,775 | 970,776 | u620775604 | cpp |
p03164 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<ll> vec;
typedef vector<vec> vec2;
typedef map<ll, ll> MPll;
typedef set<ll> setl;
const ll INF = 1ll << 60;
const ld EPS = 1e-10;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mods = 1000000007;
// for文
#define FOR(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define FORE(i, a, b) for (ll i = (ll)a; i <= (ll)b; i++)
#define REP(i, size) for (ll i = (ll)0; i < size; i++)
#define REPE(i, size) for (ll i = (ll)0; i <= size; i++)
#define REPR(i, size) for (ll i = (ll)size; i >= 0; i--)
#define FOREACH(it, vec) for (auto it = vec.begin(); it != vec.end(); it++)
//ソート
#define ALL(vec) (vec).begin(), (vec).end()
#define SORT(vec) sort(ALL(vec))
#define SORTA(arr) sort(arr, arr + (sizeof(arr) / sizeof(ll)))
#define INVSORT(vec) sort((vec).rbegin(), (vec).rend())
#define REV(vec) reverse(ALL(vec))
#define REVA(arr) reverse(arr, arr + (sizeof(arr) / sizeof(ll)))
#define INVSORTA(arr) sort(arr, arr + (sizeof(arr) / sizeof(ll))), REVA(arr)
//最大値最小値
#define MAX(vec) *max_element(ALL(vec))
#define UNIQ(vec) \
SORT(vec); \
vec.erase(unique(ALL(vec)), vec.end())
#define MIN(vec) *min_element(ALL(vec))
//出力
#define printl(a) cout << a << "\n"
#define print(a) cout << a
#define OUT(a) printf("%lld\n", a)
#define OUTA(array) \
REP(i, sizeof(array) / sizeof(ll)) printf("%lld\n", array[i])
#define OUTV(vec) REP(i, vec.size()) printf("%lld\n", vec[i])
#define SP printf(" ")
//入力
#define IN(x) scanf("%lld", &x)
#define INV(vec) REP(i, vec.size()) scanf("%lld", &vec[i])
#define INA(array) REP(i, sizeof(array) / sizeof(ll)) scanf("%lld", array + i)
#define INS(x) cin >> x
#define INCH(x) scanf(" %c", &x)
//型
#define P pair
#define vp vector<P>
#define F first
#define Ssum second
//その他
#define PB push_back
#define MP make_pair
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, -1, sizeof(a))
#define INFI(a) memset(a, INF, sizeof(a))
#define MEM(a, b) memset(a, (b), sizeof(a))
//関数
template <class T> inline void amax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> inline void amin(T &a, const T &b) {
if (a > b)
a = b;
}
/*
struct structure{
ll num1,num2,string s;
bool operator<(const rest &another) const{
return this->s < another.s;
}
structure(ll a,ll b,string s){
this->num1 = a,this->num2=b,this->s=s;
}
};a
*/
//特殊
//#define int ll
#define _CRT_SECURE_NO_WARNINGS
/*
template <typename T>
struct UnionFindTree{
vector<T> par;
vector<T> num;
UnionFindTree(T n) : par(n+1),num(n+1,1ll){
for (int i = 1; i <= n; ++i) {
par[i] = i;
num[i] = 1;
}
}
T root(T x){
if(par[x] == x) return x;
else return par[x] = root(par[x]);
}
void unite(T x,T y){
x = root(x);
y = root(y);
if(!same(x,y)) {
if(num[x] < num[y]) swap(x,y);
par[y] = x;
num[x] += num[y];
num[y] = 0;
}
}
T same(T x,T y){
return root(x) == root(y);
}
T maxnodes(){
return MAX(num);
}
};
*/
//#define DEBUG
#ifdef DEBUG
#define debugl(x) cerr << #x << ":" << x << "\n"
#define debug(x) cerr << #x << ":" << x << endl;
#define debugV(V) \
REP(iiiii, V.size()) { cerr << iiiii << ":" << V[iiiii] << endl; }
#define debugA(A) \
REP(iiiiiii, sizeof(A) / sizeof(ll)) { \
cerr << iiiiiii << ":" << V[iiiiiii] << endl; \
}
#define debugVV(V) \
REP(i123, V[0].size()) { \
cerr << endl; \
REP(i1234, V.size()) { cerr << V[i1234][i123]; } \
}
#else
#define debug(x)
#define debugV(x)
#define debugA(x)
#define debugl(x)
#endif
#define ZERO(a) memset(a, 0, sizeof(a))
#define ALL(vec) (vec).begin(), (vec).end()
#define SORT(vec) sort(ALL(vec))
ll binary(ll key, vec &a) {
ll ok = a.size();
ll dame = -1;
while (abs(ok - dame) > 1) {
ll mid = (ok + dame) / 2;
if (a[mid] <= key)
ok = mid;
else
dame = mid;
}
return ok;
}
ll n;
ll m;
ll k;
ll l;
ll temp;
ll x, y;
ll H, W;
char c;
ll ddy, ddx;
signed main() {
IN(n);
IN(W);
ll w, v;
vector<P<ll, ll>> item(n);
FOR(i, 0, n) {
IN(w);
IN(v);
item[i].first = w;
item[i].second = v;
}
vec2 dp(n + 1, vec(100000, INF));
dp[0][0] = 0;
FOR(i, 0, n) FORE(v, 0, 101) {
if (v - item[i].second >= 0) {
amin(dp[i + 1][v], dp[i][v - item[i].second] + item[i].first);
}
amin(dp[i + 1][v], dp[i][v]);
}
ll ans = 0;
FOR(i, 0, 100000) {
if (dp[n][i] <= W)
ans = i;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<ll> vec;
typedef vector<vec> vec2;
typedef map<ll, ll> MPll;
typedef set<ll> setl;
const ll INF = 1ll << 60;
const ld EPS = 1e-10;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mods = 1000000007;
// for文
#define FOR(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define FORE(i, a, b) for (ll i = (ll)a; i <= (ll)b; i++)
#define REP(i, size) for (ll i = (ll)0; i < size; i++)
#define REPE(i, size) for (ll i = (ll)0; i <= size; i++)
#define REPR(i, size) for (ll i = (ll)size; i >= 0; i--)
#define FOREACH(it, vec) for (auto it = vec.begin(); it != vec.end(); it++)
//ソート
#define ALL(vec) (vec).begin(), (vec).end()
#define SORT(vec) sort(ALL(vec))
#define SORTA(arr) sort(arr, arr + (sizeof(arr) / sizeof(ll)))
#define INVSORT(vec) sort((vec).rbegin(), (vec).rend())
#define REV(vec) reverse(ALL(vec))
#define REVA(arr) reverse(arr, arr + (sizeof(arr) / sizeof(ll)))
#define INVSORTA(arr) sort(arr, arr + (sizeof(arr) / sizeof(ll))), REVA(arr)
//最大値最小値
#define MAX(vec) *max_element(ALL(vec))
#define UNIQ(vec) \
SORT(vec); \
vec.erase(unique(ALL(vec)), vec.end())
#define MIN(vec) *min_element(ALL(vec))
//出力
#define printl(a) cout << a << "\n"
#define print(a) cout << a
#define OUT(a) printf("%lld\n", a)
#define OUTA(array) \
REP(i, sizeof(array) / sizeof(ll)) printf("%lld\n", array[i])
#define OUTV(vec) REP(i, vec.size()) printf("%lld\n", vec[i])
#define SP printf(" ")
//入力
#define IN(x) scanf("%lld", &x)
#define INV(vec) REP(i, vec.size()) scanf("%lld", &vec[i])
#define INA(array) REP(i, sizeof(array) / sizeof(ll)) scanf("%lld", array + i)
#define INS(x) cin >> x
#define INCH(x) scanf(" %c", &x)
//型
#define P pair
#define vp vector<P>
#define F first
#define Ssum second
//その他
#define PB push_back
#define MP make_pair
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, -1, sizeof(a))
#define INFI(a) memset(a, INF, sizeof(a))
#define MEM(a, b) memset(a, (b), sizeof(a))
//関数
template <class T> inline void amax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> inline void amin(T &a, const T &b) {
if (a > b)
a = b;
}
/*
struct structure{
ll num1,num2,string s;
bool operator<(const rest &another) const{
return this->s < another.s;
}
structure(ll a,ll b,string s){
this->num1 = a,this->num2=b,this->s=s;
}
};a
*/
//特殊
//#define int ll
#define _CRT_SECURE_NO_WARNINGS
/*
template <typename T>
struct UnionFindTree{
vector<T> par;
vector<T> num;
UnionFindTree(T n) : par(n+1),num(n+1,1ll){
for (int i = 1; i <= n; ++i) {
par[i] = i;
num[i] = 1;
}
}
T root(T x){
if(par[x] == x) return x;
else return par[x] = root(par[x]);
}
void unite(T x,T y){
x = root(x);
y = root(y);
if(!same(x,y)) {
if(num[x] < num[y]) swap(x,y);
par[y] = x;
num[x] += num[y];
num[y] = 0;
}
}
T same(T x,T y){
return root(x) == root(y);
}
T maxnodes(){
return MAX(num);
}
};
*/
//#define DEBUG
#ifdef DEBUG
#define debugl(x) cerr << #x << ":" << x << "\n"
#define debug(x) cerr << #x << ":" << x << endl;
#define debugV(V) \
REP(iiiii, V.size()) { cerr << iiiii << ":" << V[iiiii] << endl; }
#define debugA(A) \
REP(iiiiiii, sizeof(A) / sizeof(ll)) { \
cerr << iiiiiii << ":" << V[iiiiiii] << endl; \
}
#define debugVV(V) \
REP(i123, V[0].size()) { \
cerr << endl; \
REP(i1234, V.size()) { cerr << V[i1234][i123]; } \
}
#else
#define debug(x)
#define debugV(x)
#define debugA(x)
#define debugl(x)
#endif
#define ZERO(a) memset(a, 0, sizeof(a))
#define ALL(vec) (vec).begin(), (vec).end()
#define SORT(vec) sort(ALL(vec))
ll binary(ll key, vec &a) {
ll ok = a.size();
ll dame = -1;
while (abs(ok - dame) > 1) {
ll mid = (ok + dame) / 2;
if (a[mid] <= key)
ok = mid;
else
dame = mid;
}
return ok;
}
ll n;
ll m;
ll k;
ll l;
ll temp;
ll x, y;
ll H, W;
char c;
ll ddy, ddx;
signed main() {
IN(n);
IN(W);
ll w, v;
vector<P<ll, ll>> item(n);
FOR(i, 0, n) {
IN(w);
IN(v);
item[i].first = w;
item[i].second = v;
}
vec2 dp(n + 1, vec(100100, INF));
dp[0][0] = 0;
FOR(i, 0, n) FORE(v, 0, 100100) {
if (v - item[i].second >= 0) {
amin(dp[i + 1][v], dp[i][v - item[i].second] + item[i].first);
}
amin(dp[i + 1][v], dp[i][v]);
}
ll ans = 0;
FOR(i, 0, 100100) {
if (dp[n][i] <= W)
ans = i;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 970,790 | 970,791 | u502721867 | cpp |
p03164 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<ll> vec;
typedef vector<vec> vec2;
typedef map<ll, ll> MPll;
typedef set<ll> setl;
const ll INF = 1ll << 60;
const ld EPS = 1e-10;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mods = 1000000007;
// for文
#define FOR(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define FORE(i, a, b) for (ll i = (ll)a; i <= (ll)b; i++)
#define REP(i, size) for (ll i = (ll)0; i < size; i++)
#define REPE(i, size) for (ll i = (ll)0; i <= size; i++)
#define REPR(i, size) for (ll i = (ll)size; i >= 0; i--)
#define FOREACH(it, vec) for (auto it = vec.begin(); it != vec.end(); it++)
//ソート
#define ALL(vec) (vec).begin(), (vec).end()
#define SORT(vec) sort(ALL(vec))
#define SORTA(arr) sort(arr, arr + (sizeof(arr) / sizeof(ll)))
#define INVSORT(vec) sort((vec).rbegin(), (vec).rend())
#define REV(vec) reverse(ALL(vec))
#define REVA(arr) reverse(arr, arr + (sizeof(arr) / sizeof(ll)))
#define INVSORTA(arr) sort(arr, arr + (sizeof(arr) / sizeof(ll))), REVA(arr)
//最大値最小値
#define MAX(vec) *max_element(ALL(vec))
#define UNIQ(vec) \
SORT(vec); \
vec.erase(unique(ALL(vec)), vec.end())
#define MIN(vec) *min_element(ALL(vec))
//出力
#define printl(a) cout << a << "\n"
#define print(a) cout << a
#define OUT(a) printf("%lld\n", a)
#define OUTA(array) \
REP(i, sizeof(array) / sizeof(ll)) printf("%lld\n", array[i])
#define OUTV(vec) REP(i, vec.size()) printf("%lld\n", vec[i])
#define SP printf(" ")
//入力
#define IN(x) scanf("%lld", &x)
#define INV(vec) REP(i, vec.size()) scanf("%lld", &vec[i])
#define INA(array) REP(i, sizeof(array) / sizeof(ll)) scanf("%lld", array + i)
#define INS(x) cin >> x
#define INCH(x) scanf(" %c", &x)
//型
#define P pair
#define vp vector<P>
#define F first
#define Ssum second
//その他
#define PB push_back
#define MP make_pair
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, -1, sizeof(a))
#define INFI(a) memset(a, INF, sizeof(a))
#define MEM(a, b) memset(a, (b), sizeof(a))
//関数
template <class T> inline void amax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> inline void amin(T &a, const T &b) {
if (a > b)
a = b;
}
/*
struct structure{
ll num1,num2,string s;
bool operator<(const rest &another) const{
return this->s < another.s;
}
structure(ll a,ll b,string s){
this->num1 = a,this->num2=b,this->s=s;
}
};a
*/
//特殊
//#define int ll
#define _CRT_SECURE_NO_WARNINGS
/*
template <typename T>
struct UnionFindTree{
vector<T> par;
vector<T> num;
UnionFindTree(T n) : par(n+1),num(n+1,1ll){
for (int i = 1; i <= n; ++i) {
par[i] = i;
num[i] = 1;
}
}
T root(T x){
if(par[x] == x) return x;
else return par[x] = root(par[x]);
}
void unite(T x,T y){
x = root(x);
y = root(y);
if(!same(x,y)) {
if(num[x] < num[y]) swap(x,y);
par[y] = x;
num[x] += num[y];
num[y] = 0;
}
}
T same(T x,T y){
return root(x) == root(y);
}
T maxnodes(){
return MAX(num);
}
};
*/
//#define DEBUG
#ifdef DEBUG
#define debugl(x) cerr << #x << ":" << x << "\n"
#define debug(x) cerr << #x << ":" << x << endl;
#define debugV(V) \
REP(iiiii, V.size()) { cerr << iiiii << ":" << V[iiiii] << endl; }
#define debugA(A) \
REP(iiiiiii, sizeof(A) / sizeof(ll)) { \
cerr << iiiiiii << ":" << V[iiiiiii] << endl; \
}
#define debugVV(V) \
REP(i123, V[0].size()) { \
cerr << endl; \
REP(i1234, V.size()) { cerr << V[i1234][i123]; } \
}
#else
#define debug(x)
#define debugV(x)
#define debugA(x)
#define debugl(x)
#endif
#define ZERO(a) memset(a, 0, sizeof(a))
#define ALL(vec) (vec).begin(), (vec).end()
#define SORT(vec) sort(ALL(vec))
ll binary(ll key, vec &a) {
ll ok = a.size();
ll dame = -1;
while (abs(ok - dame) > 1) {
ll mid = (ok + dame) / 2;
if (a[mid] <= key)
ok = mid;
else
dame = mid;
}
return ok;
}
ll n;
ll m;
ll k;
ll l;
ll temp;
ll x, y;
ll H, W;
char c;
ll ddy, ddx;
signed main() {
IN(n);
IN(W);
ll w, v;
vector<P<ll, ll>> item(n);
FOR(i, 0, n) {
IN(w);
IN(v);
item[i].first = w;
item[i].second = v;
}
vec2 dp(n + 1, vec(100000, INF));
dp[0][0] = 0;
FOR(i, 0, n) FORE(v, 0, 101) {
if (v - item[i].second >= 0) {
amin(dp[i + 1][v], dp[i][v - item[i].second] + item[i].first);
}
amin(dp[i + 1][v], dp[i][v]);
}
ll ans = 0;
FOR(i, 0, 10000000) {
if (dp[n][i] <= W)
ans = i;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<ll> vec;
typedef vector<vec> vec2;
typedef map<ll, ll> MPll;
typedef set<ll> setl;
const ll INF = 1ll << 60;
const ld EPS = 1e-10;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mods = 1000000007;
// for文
#define FOR(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define FORE(i, a, b) for (ll i = (ll)a; i <= (ll)b; i++)
#define REP(i, size) for (ll i = (ll)0; i < size; i++)
#define REPE(i, size) for (ll i = (ll)0; i <= size; i++)
#define REPR(i, size) for (ll i = (ll)size; i >= 0; i--)
#define FOREACH(it, vec) for (auto it = vec.begin(); it != vec.end(); it++)
//ソート
#define ALL(vec) (vec).begin(), (vec).end()
#define SORT(vec) sort(ALL(vec))
#define SORTA(arr) sort(arr, arr + (sizeof(arr) / sizeof(ll)))
#define INVSORT(vec) sort((vec).rbegin(), (vec).rend())
#define REV(vec) reverse(ALL(vec))
#define REVA(arr) reverse(arr, arr + (sizeof(arr) / sizeof(ll)))
#define INVSORTA(arr) sort(arr, arr + (sizeof(arr) / sizeof(ll))), REVA(arr)
//最大値最小値
#define MAX(vec) *max_element(ALL(vec))
#define UNIQ(vec) \
SORT(vec); \
vec.erase(unique(ALL(vec)), vec.end())
#define MIN(vec) *min_element(ALL(vec))
//出力
#define printl(a) cout << a << "\n"
#define print(a) cout << a
#define OUT(a) printf("%lld\n", a)
#define OUTA(array) \
REP(i, sizeof(array) / sizeof(ll)) printf("%lld\n", array[i])
#define OUTV(vec) REP(i, vec.size()) printf("%lld\n", vec[i])
#define SP printf(" ")
//入力
#define IN(x) scanf("%lld", &x)
#define INV(vec) REP(i, vec.size()) scanf("%lld", &vec[i])
#define INA(array) REP(i, sizeof(array) / sizeof(ll)) scanf("%lld", array + i)
#define INS(x) cin >> x
#define INCH(x) scanf(" %c", &x)
//型
#define P pair
#define vp vector<P>
#define F first
#define Ssum second
//その他
#define PB push_back
#define MP make_pair
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, -1, sizeof(a))
#define INFI(a) memset(a, INF, sizeof(a))
#define MEM(a, b) memset(a, (b), sizeof(a))
//関数
template <class T> inline void amax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> inline void amin(T &a, const T &b) {
if (a > b)
a = b;
}
/*
struct structure{
ll num1,num2,string s;
bool operator<(const rest &another) const{
return this->s < another.s;
}
structure(ll a,ll b,string s){
this->num1 = a,this->num2=b,this->s=s;
}
};a
*/
//特殊
//#define int ll
#define _CRT_SECURE_NO_WARNINGS
/*
template <typename T>
struct UnionFindTree{
vector<T> par;
vector<T> num;
UnionFindTree(T n) : par(n+1),num(n+1,1ll){
for (int i = 1; i <= n; ++i) {
par[i] = i;
num[i] = 1;
}
}
T root(T x){
if(par[x] == x) return x;
else return par[x] = root(par[x]);
}
void unite(T x,T y){
x = root(x);
y = root(y);
if(!same(x,y)) {
if(num[x] < num[y]) swap(x,y);
par[y] = x;
num[x] += num[y];
num[y] = 0;
}
}
T same(T x,T y){
return root(x) == root(y);
}
T maxnodes(){
return MAX(num);
}
};
*/
//#define DEBUG
#ifdef DEBUG
#define debugl(x) cerr << #x << ":" << x << "\n"
#define debug(x) cerr << #x << ":" << x << endl;
#define debugV(V) \
REP(iiiii, V.size()) { cerr << iiiii << ":" << V[iiiii] << endl; }
#define debugA(A) \
REP(iiiiiii, sizeof(A) / sizeof(ll)) { \
cerr << iiiiiii << ":" << V[iiiiiii] << endl; \
}
#define debugVV(V) \
REP(i123, V[0].size()) { \
cerr << endl; \
REP(i1234, V.size()) { cerr << V[i1234][i123]; } \
}
#else
#define debug(x)
#define debugV(x)
#define debugA(x)
#define debugl(x)
#endif
#define ZERO(a) memset(a, 0, sizeof(a))
#define ALL(vec) (vec).begin(), (vec).end()
#define SORT(vec) sort(ALL(vec))
ll binary(ll key, vec &a) {
ll ok = a.size();
ll dame = -1;
while (abs(ok - dame) > 1) {
ll mid = (ok + dame) / 2;
if (a[mid] <= key)
ok = mid;
else
dame = mid;
}
return ok;
}
ll n;
ll m;
ll k;
ll l;
ll temp;
ll x, y;
ll H, W;
char c;
ll ddy, ddx;
signed main() {
IN(n);
IN(W);
ll w, v;
vector<P<ll, ll>> item(n);
FOR(i, 0, n) {
IN(w);
IN(v);
item[i].first = w;
item[i].second = v;
}
vec2 dp(n + 1, vec(100100, INF));
dp[0][0] = 0;
FOR(i, 0, n) FORE(v, 0, 100100) {
if (v - item[i].second >= 0) {
amin(dp[i + 1][v], dp[i][v - item[i].second] + item[i].first);
}
amin(dp[i + 1][v], dp[i][v]);
}
ll ans = 0;
FOR(i, 0, 100100) {
if (dp[n][i] <= W)
ans = i;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 970,792 | 970,791 | u502721867 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pll = pair<ll, ll>;
using Pii = pair<int, int>;
constexpr ll MOD = 1000000007;
constexpr long double EPS = 1e-10;
constexpr int dyx[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
constexpr int V = 110;
constexpr int INF = 1 << 30;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, W;
cin >> N >> W;
vector<ll> v(N), w(N);
for (int i = 0; i < N; ++i) {
cin >> w[i] >> v[i];
}
vector<vector<ll>> dp(N + 1, vector<ll>(V + 1, INF));
dp[0][0] = 0;
for (int i = 1; i <= N; ++i) {
for (int j = 0; j <= V; ++j) {
dp[i][j] = dp[i - 1][j];
if (j >= v[i - 1])
dp[i][j] = min(dp[i][j], dp[i - 1][j - v[i - 1]] + w[i - 1]);
}
}
ll ans = 0;
for (int j = V; j >= 0; --j) {
if (dp[N][j] <= W) {
ans = j;
break;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pll = pair<ll, ll>;
using Pii = pair<int, int>;
constexpr ll MOD = 1000000007;
constexpr long double EPS = 1e-10;
constexpr int dyx[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
constexpr int V = 100000;
constexpr int INF = 1 << 30;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, W;
cin >> N >> W;
vector<ll> v(N), w(N);
for (int i = 0; i < N; ++i) {
cin >> w[i] >> v[i];
}
vector<vector<ll>> dp(N + 1, vector<ll>(V + 1, INF));
dp[0][0] = 0;
for (int i = 1; i <= N; ++i) {
for (int j = 0; j <= V; ++j) {
dp[i][j] = dp[i - 1][j];
if (j >= v[i - 1])
dp[i][j] = min(dp[i][j], dp[i - 1][j - v[i - 1]] + w[i - 1]);
}
}
ll ans = 0;
for (int j = V; j >= 0; --j) {
if (dp[N][j] <= W) {
ans = j;
break;
}
}
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 970,794 | 970,795 | u986399983 | cpp |
p03164 | #include <algorithm>
#include <iostream>
#include <vector>
#define ll long long int
#define pb push_back
#define mp make_pair
using namespace std;
int main() {
ll N, W;
cin >> N >> W;
vector<long> wight(N);
vector<long> value(N);
for (int i = 0; i < N; i++) {
cin >> wight[i] >> value[i];
}
vector<vector<ll>> dp(110, vector<ll>(100010, 1e3));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 100010; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + wight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
long ans = 0;
for (int i = 0; i < 100010; i++) {
if (dp[N][i] <= W) {
ans = i;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define ll long long int
#define pb push_back
#define mp make_pair
using namespace std;
int main() {
ll N, W;
cin >> N >> W;
vector<long> wight(N);
vector<long> value(N);
for (int i = 0; i < N; i++) {
cin >> wight[i] >> value[i];
}
vector<vector<ll>> dp(110, vector<ll>(100010, 1e10));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 100010; j++) {
if (j - value[i] >= 0) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - value[i]] + wight[i]);
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
long ans = 0;
for (int i = 0; i < 100010; i++) {
if (dp[N][i] <= W) {
ans = i;
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 970,800 | 970,801 | u468862268 | cpp |
p03164 | /*
tarun360
IIT Indore
*/
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ll_s long
#define mod 1000000007
#define forn(i, start, lim) for (ll i = start; i < lim; i++)
#define forn_d(i, start, lim) for (ll i = start; i >= lim; i--)
#define forn_s(i, start, lim) for (ll_s i = start; i < lim; i++)
#define forn_d_s(i, start, lim) for (ll_s i = start; i >= lim; i--)
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define debug1(a) cout << a << endl
#define debug2(a, b) cout << a << " " << b << endl
#define debug3(a, b, c) cout << a << " " << b << " " << c << endl
#define debug4(a) cout << "chu " << a << endl
ll w[105], v[105], dp[105][100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, W, V = 0;
cin >> n >> W;
forn(i, 1, n + 1) cin >> w[i] >> v[i];
forn(i, 1, 1e5 + 1) dp[0][i] = 1e6;
forn(i, 1, n + 1) {
forn(j, 1, 1e5 + 1) {
if (j - v[i] < 0)
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
}
}
ll ans = 0;
forn_d(i, 1e5, 0) {
if (dp[n][i] <= W) {
ans = i;
break;
}
}
cout << ans << endl;
/*forn(i,0,n+1){
cout<<endl;
forn(j,0,16){
cout<<dp[i][j]<<" ";
}
}*/
return 0;
}
| /*
tarun360
IIT Indore
*/
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ll_s long
#define mod 1000000007
#define forn(i, start, lim) for (ll i = start; i < lim; i++)
#define forn_d(i, start, lim) for (ll i = start; i >= lim; i--)
#define forn_s(i, start, lim) for (ll_s i = start; i < lim; i++)
#define forn_d_s(i, start, lim) for (ll_s i = start; i >= lim; i--)
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define debug1(a) cout << a << endl
#define debug2(a, b) cout << a << " " << b << endl
#define debug3(a, b, c) cout << a << " " << b << " " << c << endl
#define debug4(a) cout << "chu " << a << endl
ll w[105], v[105], dp[105][100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, W, V = 0;
cin >> n >> W;
forn(i, 1, n + 1) cin >> w[i] >> v[i];
forn(i, 1, 1e5 + 1) dp[0][i] = 1e9 + 5;
forn(i, 1, n + 1) {
forn(j, 1, 1e5 + 1) {
if (j - v[i] < 0)
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
}
}
ll ans = 0;
forn_d(i, 1e5, 0) {
if (dp[n][i] <= W) {
ans = i;
break;
}
}
cout << ans << endl;
/*forn(i,0,n+1){
cout<<endl;
forn(j,0,16){
cout<<dp[i][j]<<" ";
}
}*/
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"assignment.change"
] | 970,806 | 970,807 | u772514767 | cpp |
p03164 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <tuple>
#define INF INT_MAX >> 1
#define SIZE 100010
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, from, to) for (int i = (from); i < (int)(to); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define LLPair pair<ll, ll>
#define vint vector<int>
#define vll vector<ll>
typedef long long ll;
using namespace std;
int main(void) {
int N, W;
cin >> N >> W;
vint w(N), v(N);
rep(i, N) cin >> w[i] >> v[i];
static int dp[110][110000]; // dp[商品][価値] = 最小の重さ
fill(dp[0], dp[110], INF);
dp[0][0] = 0;
rep2(i, 0, N) {
rep(j, 1010 * N) {
if (dp[i][j] != INF) {
if (dp[i][j] + w[i] <= W) {
dp[i + 1][j + v[i]] = min(dp[i + 1][j + v[i]], dp[i][j] + w[i]);
}
if (dp[i + 1][j] == INF)
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
}
}
}
int ans = 0;
rep(i, 1010 * N) {
if (dp[N][i] == INF)
continue;
ans = max(ans, i);
}
cout << ans << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <tuple>
#define INF INT_MAX >> 1
#define SIZE 100010
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, from, to) for (int i = (from); i < (int)(to); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define LLPair pair<ll, ll>
#define vint vector<int>
#define vll vector<ll>
typedef long long ll;
using namespace std;
int main(void) {
int N, W;
cin >> N >> W;
vint w(N), v(N);
rep(i, N) cin >> w[i] >> v[i];
static int dp[110][110000]; // dp[商品][価値] = 最小の重さ
fill(dp[0], dp[110], INF);
dp[0][0] = 0;
rep2(i, 0, N) {
rep(j, 1010 * N) {
if (dp[i][j] != INF) {
if (dp[i][j] + w[i] <= W) {
dp[i + 1][j + v[i]] = min(dp[i + 1][j + v[i]], dp[i][j] + w[i]);
}
if (dp[i + 1][j] == INF)
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
}
int ans = 0;
rep(i, 1010 * N) {
if (dp[N][i] == INF)
continue;
ans = max(ans, i);
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 970,812 | 970,813 | u117734686 | cpp |
p03164 | #pragma GCC optimize(3, "Ofast", "inline")
#include <bits/stdc++.h>
#if __cplusplus >= 201103L
#include <chrono>
using namespace std::chrono;
#endif
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second
#ifdef LOCAL
#define prln(x) (cout << #x << ' ' << x << endl)
#define pr(x) (cout << #x << ' ' << x << ' ')
#define prv(x) (cout << x << ' ')
#else
#define prln(x)
#define pr(x)
#define prv(x)
#endif
#define clr(x) memset((x), 0, sizeof((x)))
#define clr1(x) memset((x), -1, sizeof((x)))
#define endl "\n"
#define pi acos(-1)
#define rep(i, st, ed) for (int i = (st); i <= (ed); ++i)
#define rep0(i, st, ed) for (int i = (st); i < (ed); ++i)
#define per0(i, st, ed) for (int i = (st); i > ed; --i)
#define per(i, st, ed) for (int i = (st); i >= ed; --i)
#define chmin(a, b) (a = a > b ? b : a)
#define chmax(a, b) (a = a < b ? b : a)
template <class T> void _sf(T &x) { cin >> x; }
void _sf(int &x) { scanf("%d", &x); }
void _sf(ll &x) { scanf("%lld", &x); }
void _sf(double &x) { scanf("%lf", &x); }
void _sf(char &x) { scanf(" %c", &x); }
void _sf(char *x) { scanf("%s", x); }
void sf() {}
template <class T, class... U> void sf(T &head, U &...tail) {
_sf(head);
sf(tail...);
}
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 1e6 + 6;
ll dp[maxn];
ll n, W;
ll v[maxn], w[maxn];
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#if __cplusplus >= 201103L
auto start = steady_clock::now();
#endif
#endif
memset(dp, 0x3f, sizeof(dp));
sf(n, W);
rep(i, 1, n) sf(w[i], v[i]);
ll ans = 0ll;
dp[0] = 0;
rep(i, 1, n) {
per(j, (int)1e5, v[i]) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
pr(j);
prln(dp[j]);
if (dp[j] <= W)
chmax(ans, j);
}
}
prv(ans);
#ifdef LOCAL
#if __cplusplus >= 201103L
auto end = steady_clock::now();
duration<double> time_span = duration_cast<duration<double>>(end - start);
;
printf("Total time: %.6fs\n", time_span.count());
#endif
#endif
return 0;
} | #pragma GCC optimize(3, "Ofast", "inline")
#include <bits/stdc++.h>
#if __cplusplus >= 201103L
#include <chrono>
using namespace std::chrono;
#endif
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second
#ifdef LOCAL
#define prln(x) (cout << #x << ' ' << x << endl)
#define pr(x) (cout << #x << ' ' << x << ' ')
#define prv(x) (cout << x << ' ')
#else
#define prln(x)
#define pr(x)
#define prv(x)
#endif
#define clr(x) memset((x), 0, sizeof((x)))
#define clr1(x) memset((x), -1, sizeof((x)))
#define endl "\n"
#define pi acos(-1)
#define rep(i, st, ed) for (int i = (st); i <= (ed); ++i)
#define rep0(i, st, ed) for (int i = (st); i < (ed); ++i)
#define per0(i, st, ed) for (int i = (st); i > ed; --i)
#define per(i, st, ed) for (int i = (st); i >= ed; --i)
#define chmin(a, b) (a = a > b ? b : a)
#define chmax(a, b) (a = a < b ? b : a)
template <class T> void _sf(T &x) { cin >> x; }
void _sf(int &x) { scanf("%d", &x); }
void _sf(ll &x) { scanf("%lld", &x); }
void _sf(double &x) { scanf("%lf", &x); }
void _sf(char &x) { scanf(" %c", &x); }
void _sf(char *x) { scanf("%s", x); }
void sf() {}
template <class T, class... U> void sf(T &head, U &...tail) {
_sf(head);
sf(tail...);
}
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 1e6 + 6;
ll dp[maxn];
ll n, W;
ll v[maxn], w[maxn];
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#if __cplusplus >= 201103L
auto start = steady_clock::now();
#endif
#endif
memset(dp, 0x3f, sizeof(dp));
sf(n, W);
rep(i, 1, n) sf(w[i], v[i]);
ll ans = 0ll;
dp[0] = 0;
rep(i, 1, n) {
per(j, (int)1e5, v[i]) {
dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
pr(j);
prln(dp[j]);
if (dp[j] <= W)
chmax(ans, j);
}
}
cout << ans << endl;
#ifdef LOCAL
#if __cplusplus >= 201103L
auto end = steady_clock::now();
duration<double> time_span = duration_cast<duration<double>>(end - start);
;
printf("Total time: %.6fs\n", time_span.count());
#endif
#endif
return 0;
} | [
"io.output.change"
] | 970,816 | 970,817 | u625893557 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#ifdef RED
mt19937 rnd(228);
#else
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif
const int N = (int)1e6 + 5;
const ll inf = (ll)1e18;
int n, W;
ll w[N], v[N];
ll dp[N];
int main() {
#ifdef RED
freopen("a.in", "r", stdin);
#endif
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> W;
int sum = 0;
for (int i = 1; i <= n; ++i) {
cin >> w[i] >> v[i];
sum += v[i];
}
for (int i = 0; i <= sum; ++i) {
dp[i] = inf;
}
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
vector<ll> mn(sum);
for (int j = v[i]; j <= sum; ++j) {
mn[j] = min(dp[j], dp[j - v[i]] + w[i]);
}
for (int j = v[i]; j <= sum; ++j) {
dp[j] = mn[j];
}
}
for (int i = sum; i >= 0; i--) {
if (dp[i] <= W) {
cout << i;
return 0;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#ifdef RED
mt19937 rnd(228);
#else
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif
const int N = (int)1e6 + 5;
const ll inf = (ll)1e18;
int n, W;
ll w[N], v[N];
ll dp[N];
int main() {
#ifdef RED
freopen("a.in", "r", stdin);
#endif
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> W;
int sum = 0;
for (int i = 1; i <= n; ++i) {
cin >> w[i] >> v[i];
sum += v[i];
}
for (int i = 0; i <= sum; ++i) {
dp[i] = inf;
}
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
vector<ll> mn(sum + 10);
for (int j = v[i]; j <= sum; ++j) {
mn[j] = min(dp[j], dp[j - v[i]] + w[i]);
}
for (int j = v[i]; j <= sum; ++j) {
dp[j] = mn[j];
}
}
for (int i = sum; i >= 0; i--) {
if (dp[i] <= W) {
cout << i;
return 0;
}
}
return 0;
}
| [
"assignment.change"
] | 970,831 | 970,832 | u854902988 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
int w[N + 1], v[N + 1];
for (int i = 1; i <= N; i += 1) {
cin >> w[i] >> v[i];
}
int dp[W + 1];
for (int i = 0; i <= W; i += 1) {
dp[i] = 0;
}
for (int i = 1; i <= N; i += 1) {
for (int j = W; j >= w[i]; j -= 1) {
dp[j] = max(dp[j], v[i] + dp[j - w[i]]);
}
}
cout << dp[W];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, W;
cin >> N >> W;
int w[N + 1], v[N + 1];
for (int i = 1; i <= N; i += 1) {
cin >> w[i] >> v[i];
}
long long int dp[W + 1];
for (int i = 0; i <= W; i += 1) {
dp[i] = 0;
}
for (int i = 1; i <= N; i += 1) {
for (int j = W; j >= w[i]; j -= 1) {
dp[j] = max(dp[j], v[i] + dp[j - w[i]]);
}
}
cout << dp[W] << endl;
} | [
"io.output.newline.add"
] | 970,837 | 970,838 | u054986947 | cpp |
p03163 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e5 + 5;
ll a, b, dp[N], n, m, ans = -1;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
for (int j = m - a; j >= 0; j--)
dp[j + a] = max(dp[j + a], dp[j] + b);
}
for (int i = 0; i < m; i++)
ans = max(ans, dp[i]);
cout << ans;
return 0;
}
/*
3 8
3 30
4 50
5 60
*/ | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e5 + 5;
ll a, b, dp[N], n, m, ans = -1;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
for (int j = m - a; j >= 0; j--)
dp[j + a] = max(dp[j + a], dp[j] + b);
}
for (int i = 0; i <= m; i++)
ans = max(ans, dp[i]);
cout << ans;
return 0;
}
/*
3 8
3 30
4 50
5 60
*/ | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 970,843 | 970,844 | u785897267 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
// your code goes here
long long n, W;
cin >> n >> W;
long long weight[n], values[n];
long long dp[n][W + 1];
for (int i = 0; i < n; ++i) {
cin >> weight[i] >> values[i];
}
for (int i = 0; i <= n; i++) {
for (int w = 0; w <= W; w++) {
if (i == 0 || w == 0)
dp[i][w] = 0;
else if (weight[i - 1] <= w)
dp[i][w] =
max(values[i - 1] + dp[i - 1][w - weight[i - 1]], dp[i - 1][w]);
else
dp[i][w] = dp[i - 1][w];
}
}
cout << dp[n][W] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
// your code goes here
long long n, W;
cin >> n >> W;
long long weight[n], values[n];
long long dp[n + 1][W + 1];
for (int i = 0; i < n; ++i) {
cin >> weight[i] >> values[i];
}
for (int i = 0; i <= n; i++) {
for (int w = 0; w <= W; w++) {
if (i == 0 || w == 0)
dp[i][w] = 0;
else if (weight[i - 1] <= w)
dp[i][w] =
max(values[i - 1] + dp[i - 1][w - weight[i - 1]], dp[i - 1][w]);
else
dp[i][w] = dp[i - 1][w];
}
}
cout << dp[n][W] << endl;
}
| [
"variable_declaration.array_dimensions.change",
"expression.operation.binary.add"
] | 970,851 | 970,852 | u955269787 | cpp |
p03163 | /*
For the brave souls who are here: You are the chosen ones, the valiant
knights of coding who toil away, without rest, fixing my most awful
code. To you, true saviors, kings of men, I say this:
never gonna give you up, never gonna let you down,
never gonna run around and desert you. Never gonna make you cry,
never gonna say goodbye. Never gonna tell a lie and hurt you.
*/
#include <algorithm>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <unordered_map>
#include <vector>
//#include <boost/math/common_factor.hpp>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for (int i = (b)-1; i >= (a); --i)
#define REP(i, N) FOR(i, 0, N)
#define RREP(i, N) RFOR(i, N, 0)
#define FILL(A, value) memset(A, value, sizeof(A))
#define endl '\n'
#define ALL(V) V.begin(), V.end()
#define SZ(V) (int)V.size()
#define pb push_back
#define mp make_pair
#define Pi 3.14159265358979
#define A first
#define B second
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pi;
typedef pair<ll, int> pl;
typedef pair<ll, ll> pll;
typedef pair<double, double> pd;
// change these according to prob constraints
const int INF = 1000000000;
const int MAX = 100005;
const int MAX1 = 1005;
const int MAX2 = 105;
const int LEN = 105;
const int BASE = 1000000000;
const double EPS = 1e-7;
const int MOD = 1000000007;
// g++ -std=c++11 your_file.cpp -o your_program
int wt[105], val[105], dp[MAX];
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ifstream in("");
ofstream out("");
clock_t begin = clock();
int n, w;
cin >> n >> w;
REP(i, n) { cin >> wt[i] >> val[i]; }
REP(i, n) {
RREP(j, w + 1) {
if (j < wt[i])
break;
dp[j] = max(dp[j], val[i] + dp[j - wt[i]]);
}
}
cout << dp[w] << endl;
clock_t end = clock();
double esecs = double(end - begin) / CLOCKS_PER_SEC;
// cout << esecs << " seconds" << endl;
return 0;
} | /*
For the brave souls who are here: You are the chosen ones, the valiant
knights of coding who toil away, without rest, fixing my most awful
code. To you, true saviors, kings of men, I say this:
never gonna give you up, never gonna let you down,
never gonna run around and desert you. Never gonna make you cry,
never gonna say goodbye. Never gonna tell a lie and hurt you.
*/
#include <algorithm>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <unordered_map>
#include <vector>
//#include <boost/math/common_factor.hpp>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for (int i = (b)-1; i >= (a); --i)
#define REP(i, N) FOR(i, 0, N)
#define RREP(i, N) RFOR(i, N, 0)
#define FILL(A, value) memset(A, value, sizeof(A))
#define endl '\n'
#define ALL(V) V.begin(), V.end()
#define SZ(V) (int)V.size()
#define pb push_back
#define mp make_pair
#define Pi 3.14159265358979
#define A first
#define B second
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pi;
typedef pair<ll, int> pl;
typedef pair<ll, ll> pll;
typedef pair<double, double> pd;
// change these according to prob constraints
const int INF = 1000000000;
const int MAX = 100005;
const int MAX1 = 1005;
const int MAX2 = 105;
const int LEN = 105;
const int BASE = 1000000000;
const double EPS = 1e-7;
const int MOD = 1000000007;
// g++ -std=c++11 your_file.cpp -o your_program
int wt[105], val[105];
ll dp[MAX];
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ifstream in("");
ofstream out("");
clock_t begin = clock();
int n, w;
cin >> n >> w;
REP(i, n) { cin >> wt[i] >> val[i]; }
REP(i, n) {
RREP(j, w + 1) {
if (j < wt[i])
break;
dp[j] = max(dp[j], val[i] + dp[j - wt[i]]);
}
}
cout << dp[w] << endl;
clock_t end = clock();
double esecs = double(end - begin) / CLOCKS_PER_SEC;
// cout << esecs << " seconds" << endl;
return 0;
}
| [] | 970,862 | 970,863 | u372798233 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define MAXN 100100
int n, w, a[MAXN], b[MAXN], dp[110][MAXN];
long long r;
int main() {
cin >> n >> w;
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= w; ++j) {
if (i == 0) {
if (a[i] <= j) {
dp[i][j] = b[i];
}
} else {
dp[i][j] = dp[i - 1][j];
if (a[i] <= j) {
dp[i][j] = max(dp[i][j], b[i] + dp[i - 1][j - a[i]]);
}
}
}
}
cout << dp[n - 1][w];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MAXN 100100
long long n, w, a[MAXN], b[MAXN], dp[110][MAXN];
int main() {
cin >> n >> w;
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= w; ++j) {
if (i == 0) {
if (a[i] <= j) {
dp[i][j] = b[i];
}
} else {
dp[i][j] = dp[i - 1][j];
if (a[i] <= j) {
dp[i][j] = max(dp[i][j], b[i] + dp[i - 1][j - a[i]]);
}
}
}
}
cout << dp[n - 1][w];
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"variable_declaration.remove"
] | 970,886 | 970,887 | u463720901 | cpp |
p03163 | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
long long i, j, n, w[100001], v[100001], W;
// freopen("INPUT.INP","r",stdin);
cin >> n >> W;
long long f[n + 1][W];
for (i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
}
f[0][0] = 0;
for (i = 0; i <= n; i++)
f[i][0] = 0;
for (j = 0; j <= W; j++)
f[0][j] = 0;
for (i = 1; i <= n; i++)
for (j = 1; j <= W; j++) {
if (j < w[i])
f[i][j] = f[i - 1][j];
else
f[i][j] = max(f[i - 1][j], f[i - 1][j - w[i]] + v[i]);
}
cout << f[n][W];
return 0;
}
| #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
long long i, j, n, w[100001], v[100001], W;
// freopen("INPUT.INP","r",stdin);
cin >> n >> W;
long long f[n + 1][W + 1];
for (i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
}
f[0][0] = 0;
for (i = 0; i <= n; i++)
f[i][0] = 0;
for (j = 0; j <= W; j++)
f[0][j] = 0;
for (i = 1; i <= n; i++)
for (j = 1; j <= W; j++) {
if (j < w[i])
f[i][j] = f[i - 1][j];
else
f[i][j] = max(f[i - 1][j], f[i - 1][j - w[i]] + v[i]);
}
cout << f[n][W];
return 0;
}
| [
"variable_declaration.array_dimensions.change",
"expression.operation.binary.add"
] | 970,890 | 970,891 | u290380461 | cpp |
p03163 | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int i, j, n, w[100001], v[100001], W;
// freopen("INPUT.INP","r",stdin);
cin >> n >> W;
long long f[n + 1][W];
for (i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
}
f[0][0] = 0;
for (i = 0; i <= n; i++)
f[i][0] = 0;
for (j = 0; j <= n; j++)
f[0][j] = 0;
for (i = 1; i <= n; i++)
for (j = 1; j <= W; j++) {
if (j < w[i])
f[i][j] = f[i - 1][j];
else
f[i][j] = max(f[i - 1][j], f[i - 1][j - w[i]] + v[i]);
}
cout << f[n][W];
return 0;
}
| #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
long long i, j, n, w[100001], v[100001], W;
// freopen("INPUT.INP","r",stdin);
cin >> n >> W;
long long f[n + 1][W + 1];
for (i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
}
f[0][0] = 0;
for (i = 0; i <= n; i++)
f[i][0] = 0;
for (j = 0; j <= W; j++)
f[0][j] = 0;
for (i = 1; i <= n; i++)
for (j = 1; j <= W; j++) {
if (j < w[i])
f[i][j] = f[i - 1][j];
else
f[i][j] = max(f[i - 1][j], f[i - 1][j - w[i]] + v[i]);
}
cout << f[n][W];
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 970,892 | 970,891 | u290380461 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, ll> p;
const int maxn = 100000 + 10;
ll dp[110][maxn];
int n;
vector<p> snacks;
ll dfs(int step, int restSize) {
if (step == n or restSize == 0)
return 0;
if (dp[step][restSize] != -1)
return dp[step][restSize];
ll value = 0;
if (restSize >= snacks[step].first) {
value = max(value, dfs(step + 1, restSize - snacks[step].first) +
snacks[step].second);
}
value = max(value, dfs(step + 1, restSize));
return dp[step][restSize] = value;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int w;
cin >> n >> w;
snacks.resize(n);
for (int i = 0; i < maxn; i++)
for (int j = 0; j < 110; j++)
dp[i][j] = -1;
for (int i = 0; i < n; i++)
cin >> snacks[i].first >> snacks[i].second;
cout << dfs(0, w) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, ll> p;
const int maxn = 100000 + 10;
ll dp[110][maxn];
int n;
vector<p> snacks;
ll dfs(int step, int restSize) {
if (step == n or restSize == 0)
return 0;
if (dp[step][restSize] != -1)
return dp[step][restSize];
ll value = 0;
if (restSize >= snacks[step].first) {
value = max(value, dfs(step + 1, restSize - snacks[step].first) +
snacks[step].second);
}
value = max(value, dfs(step + 1, restSize));
return dp[step][restSize] = value;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int w;
cin >> n >> w;
snacks.resize(n);
for (int i = 0; i < maxn; i++)
for (int j = 0; j < 110; j++)
dp[j][i] = -1;
for (int i = 0; i < n; i++)
cin >> snacks[i].first >> snacks[i].second;
cout << dfs(0, w) << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 970,893 | 970,894 | u418120992 | cpp |
p03163 | #include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
using namespace std;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, w;
cin >> n >> w;
vector<pair<int, int>> items;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (a > w)
continue;
items.PB({a, b});
}
int dp[w + 1];
dp[0] = 0;
for (int i = 1; i <= w; i++) {
dp[i] = INT_MIN;
}
for (int i = 0; i < n; i++) {
for (int j = w; j >= items[i].F; j--) {
if (dp[j - items[i].F] == INT_MIN)
continue;
dp[j] = max(dp[j], items[i].S + dp[j - items[i].F]);
}
}
int mmax = -1;
for (int i = 0; i <= w; i++) {
mmax = max(mmax, dp[i]);
}
cout << mmax << "\n";
return 0;
} | #include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
#define int ll
using namespace std;
typedef long long ll;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, w;
cin >> n >> w;
vector<pair<int, int>> items;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (a > w)
continue;
items.PB({a, b});
}
int dp[w + 1];
dp[0] = 0;
for (int i = 1; i <= w; i++) {
dp[i] = INT_MIN;
}
for (int i = 0; i < n; i++) {
for (int j = w; j >= items[i].F; j--) {
if (dp[j - items[i].F] == INT_MIN)
continue;
dp[j] = max(dp[j], items[i].S + dp[j - items[i].F]);
}
}
int mmax = -1;
for (int i = 0; i <= w; i++) {
mmax = max(mmax, dp[i]);
}
cout << mmax << "\n";
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 970,902 | 970,903 | u855714015 | cpp |
p03163 | /**********************************************************************/
/******** ********/
/******** Writer:孙~~ ********/
/******** Lang:C++ ********/
/******** Status:Unknow ********/
/******** ********/
/**********************************************************************/
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int SIZE = 105;
const double EPS = 1e-6;
int w[SIZE], v[SIZE];
long long dp[SIZE][100005];
int main() {
/*main function start*/
int n, W;
scanf("%d%d", &n, &W);
for (int i = 1; i <= n; i++) {
scanf("%d%d", w + i, v + i);
}
for (int i = 1; i < 100005; i++)
dp[0][i] = -1e12;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= W; j++) {
dp[i][j] = dp[i - 1][j];
if (j - w[i] >= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i]] + v[i]);
}
}
long long ans = 0;
for (int i = 0; i <= W; i++)
ans = max(ans, dp[n][i]);
printf("%I64d\n", ans);
return 0;
}
| /**********************************************************************/
/******** ********/
/******** Writer:孙~~ ********/
/******** Lang:C++ ********/
/******** Status:Unknow ********/
/******** ********/
/**********************************************************************/
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int SIZE = 105;
const double EPS = 1e-6;
int w[SIZE], v[SIZE];
long long dp[SIZE][100005];
int main() {
/*main function start*/
int n, W;
scanf("%d%d", &n, &W);
for (int i = 1; i <= n; i++) {
scanf("%d%d", w + i, v + i);
}
for (int i = 1; i < 100005; i++)
dp[0][i] = -1e12;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= W; j++) {
dp[i][j] = dp[i - 1][j];
if (j - w[i] >= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i]] + v[i]);
}
}
long long ans = 0;
for (int i = 0; i <= W; i++)
ans = max(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 970,906 | 970,907 | u190596522 | cpp |
p03163 | // Author: 23forever
#include <bits/stdc++.h>
#define pii pair<int, int>
#define mp make_pair
#define fi first
#define se second
typedef long long LL;
const int MAXN = 100;
const int MAXM = 100000;
using namespace std;
inline int read() {
int x = 0, w = 1;
char c = ' ';
while (c < '0' || c > '9') {
c = getchar();
if (c == '-')
w = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return x * w;
}
int n, m, w[MAXN + 5], v[MAXN + 5];
int dp[MAXM + 5];
void init() {
n = read();
m = read();
for (int i = 1; i <= n; ++i) {
w[i] = read();
v[i] = read();
}
}
int main() {
#ifdef forever23
freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
#endif
init();
for (int i = 1; i <= n; ++i) {
for (int j = m; j >= w[i]; --j) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
printf("%d\n", dp[m]);
return 0;
} | // Author: 23forever
#include <bits/stdc++.h>
#define pii pair<int, int>
#define mp make_pair
#define fi first
#define se second
typedef long long LL;
const int MAXN = 100;
const int MAXM = 100000;
using namespace std;
inline int read() {
int x = 0, w = 1;
char c = ' ';
while (c < '0' || c > '9') {
c = getchar();
if (c == '-')
w = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return x * w;
}
int n, m, w[MAXN + 5], v[MAXN + 5];
LL dp[MAXM + 5];
void init() {
n = read();
m = read();
for (int i = 1; i <= n; ++i) {
w[i] = read();
v[i] = read();
}
}
int main() {
#ifdef forever23
freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
#endif
init();
for (int i = 1; i <= n; ++i) {
for (int j = m; j >= w[i]; --j) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
printf("%lld\n", dp[m]);
return 0;
} | [
"variable_declaration.type.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 970,908 | 970,909 | u794477892 | cpp |
p03163 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, n) for (int i = 0; i < n; i++)
#define FORE(i, a, b) for (int i = a; i <= b; i++)
#define ll long long int
#define ii pair<int, int>
#define mp make_pair
#define pb push_back
#define iii pair<ii, int>
#define ff first
#define ss second
#define vi vector<int>
using namespace std;
int main() {
int n, W;
cin >> n >> W;
int w[n];
int v[n];
FOR(i, n) cin >> w[i] >> v[i];
int dp[n][W + 1];
FOR(i, n) FOR(j, W + 1) dp[i][j] = 0;
dp[0][w[0]] = v[0];
FOR(i, n) {
if (i == 0)
continue;
FOR(j, W + 1) {
if (j >= w[i])
dp[i][j] = max(dp[i - 1][j], v[i] + dp[i - 1][j - w[i]]);
else
dp[i][j] = dp[i - 1][j];
}
}
int mx = 0;
FOR(i, n) FOR(j, W + 1) mx = max(dp[i][j], mx);
cout << mx << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, n) for (int i = 0; i < n; i++)
#define FORE(i, a, b) for (int i = a; i <= b; i++)
#define ll long long int
#define ii pair<int, int>
#define mp make_pair
#define pb push_back
#define iii pair<ii, int>
#define ff first
#define ss second
#define vi vector<int>
using namespace std;
int main() {
int n, W;
cin >> n >> W;
int w[n];
ll v[n];
FOR(i, n) cin >> w[i] >> v[i];
ll dp[n][W + 1];
FOR(i, n) FOR(j, W + 1) dp[i][j] = 0;
dp[0][w[0]] = v[0];
FOR(i, n) {
if (i == 0)
continue;
FOR(j, W + 1) {
if (j >= w[i])
dp[i][j] = max(dp[i - 1][j], v[i] + dp[i - 1][j - w[i]]);
else
dp[i][j] = dp[i - 1][j];
}
}
ll mx = 0;
FOR(i, n) FOR(j, W + 1) mx = max(dp[i][j], mx);
cout << mx << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 970,910 | 970,911 | u191452571 | cpp |
p03163 | #include <cmath>
#include <cstring>
#include <iostream>
using namespace std;
const int maxN = 110, maxW = 1e5 + 10;
int w[maxN], v[maxN], W, n;
long long f[maxN][maxW];
// Max value chon tu i -> n with capacity weight
long long calculate(int i, int weight) {
if (i > n)
return 0;
if (f[i][weight] != -1)
return f[i][weight];
long long ret = calculate(i + 1, weight);
if (w[i] <= weight)
ret = max(ret, calculate(i + 1, weight - w[i]) + v[i]);
return f[i][weight] = ret;
}
int main() {
cin >> n >> W;
for (int i = 1; i <= n; ++i)
scanf("%d", &w[i], &v[i]);
memset(f, 255, sizeof(f));
cout << calculate(1, W);
}
| #include <cmath>
#include <cstring>
#include <iostream>
using namespace std;
const int maxN = 110, maxW = 1e5 + 10;
int w[maxN], v[maxN], W, n;
long long f[maxN][maxW];
// Max value chon tu i -> n with capacity weight
long long calculate(int i, int weight) {
if (i > n)
return 0;
if (f[i][weight] != -1)
return f[i][weight];
long long ret = calculate(i + 1, weight);
if (w[i] <= weight)
ret = max(ret, calculate(i + 1, weight - w[i]) + v[i]);
return f[i][weight] = ret;
}
int main() {
cin >> n >> W;
for (int i = 1; i <= n; ++i)
scanf("%d %d", &w[i], &v[i]);
memset(f, 255, sizeof(f));
cout << calculate(1, W);
}
| [
"literal.string.change",
"call.arguments.change"
] | 970,921 | 970,922 | u722318795 | cpp |
p03163 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
using namespace ::std;
#define int long long
vector<int> v;
signed main() {
int n, k;
cin >> n >> k;
v.resize(k + 1, -1);
v[0] = 0;
int f = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
int w;
int q;
cin >> w >> q;
for (int j = f; j >= 0; j--) {
if (v[j] == -1)
continue;
if (j + w > q)
continue;
v[w + j] = max(v[w + j], v[j] + q);
f = max(f, w + j);
ans = max(ans, v[w + j]);
}
}
cout << ans;
}
// aaaddda | #include <algorithm>
#include <fstream>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
using namespace ::std;
#define int long long
vector<int> v;
signed main() {
int n, k;
cin >> n >> k;
v.resize(k + 1, -1);
v[0] = 0;
int f = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
int w;
int q;
cin >> w >> q;
for (int j = f; j >= 0; j--) {
if (v[j] == -1)
continue;
if (j + w > k)
continue;
v[w + j] = max(v[w + j], v[j] + q);
f = max(f, w + j);
ans = max(ans, v[w + j]);
}
}
cout << ans;
}
// aaaddda | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 970,923 | 970,924 | u095384223 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, W;
cin >> n >> W;
int w[n];
long long int v[n];
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
long long int knap[W + 1];
int flag[W + 1][n];
knap[0] = 0;
for (int j = 0; j < n; j++)
flag[0][j] = 0;
for (int i = 1; i <= W; i++) {
knap[i] = 0;
int max = -1;
for (int j = 0; j < n; j++)
flag[i][j] = 0;
for (int j = 0; j < n; j++) {
if (i - w[j] >= 0 && !flag[i - w[j]][j])
if (knap[i] < knap[i - w[j]] + v[j]) {
max = j;
knap[i] = knap[i - w[j]] + v[j];
}
}
if (max != -1) {
for (int j = 0; j < n; j++)
flag[i][j] = flag[i - w[max]][j];
flag[i][max] = 1;
}
}
// cout <<endl;
// for(int i = 0; i<W+1;i++){
// for(int j = 0; j<n;j++)
// cout << flag[i][j]<< " ";
// cout << endl;
// }
// cout << endl;
// for(int i = 0; i<W;i++)
// cout << knap[i] << endl;
// cout <<endl;
long long int mx;
for (int i = 0; i <= W; i++)
mx = max(knap[i], mx);
cout << mx << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, W;
cin >> n >> W;
int w[n];
long long int v[n];
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
long long int knap[W + 1];
int flag[W + 1][n];
knap[0] = 0;
for (int j = 0; j < n; j++)
flag[0][j] = 0;
for (int i = 1; i <= W; i++) {
knap[i] = 0;
int max = -1;
for (int j = 0; j < n; j++)
flag[i][j] = 0;
for (int j = 0; j < n; j++) {
if (i - w[j] >= 0 && !flag[i - w[j]][j])
if (knap[i] < knap[i - w[j]] + v[j]) {
max = j;
knap[i] = knap[i - w[j]] + v[j];
}
}
if (max != -1) {
for (int j = 0; j < n; j++)
flag[i][j] = flag[i - w[max]][j];
flag[i][max] = 1;
}
}
// cout <<endl;
// for(int i = 0; i<W+1;i++){
// for(int j = 0; j<n;j++)
// cout << flag[i][j]<< " ";
// cout << endl;
// }
// cout << endl;
// for(int i = 0; i<W;i++)
// cout << knap[i] << endl;
// cout <<endl;
long long int mx = 0;
for (int i = 0; i <= W; i++)
mx = max(knap[i], mx);
cout << mx << endl;
return 0;
} | [
"variable_declaration.value.change"
] | 970,926 | 970,927 | u010432749 | cpp |
p03163 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long unsigned int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define ALL(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll dp[101][10001]{};
int main() {
int N, W;
cin >> N;
cin >> W;
int w[N], v[N];
REP(i, N) {
cin >> w[i];
cin >> v[i];
}
REPS(i, N) {
REP(j, W) {
if (j - w[i - 1] >= 0) {
chmax(dp[i][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
}
chmax(dp[i][j], dp[i - 1][j]);
}
}
ll res = 0;
REP(i, W + 1) { chmax(res, dp[N][i]); }
cout << res;
}
| #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long unsigned int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define ALL(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll dp[101][100001] = {};
int main() {
int N, W;
cin >> N;
cin >> W;
int w[N], v[N];
REP(i, N) {
cin >> w[i];
cin >> v[i];
}
REPS(i, N) {
REP(j, W + 1) {
if (j - w[i - 1] >= 0) {
chmax(dp[i][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
}
chmax(dp[i][j], dp[i - 1][j]);
}
}
ll res = 0;
REP(i, W + 1) { chmax(res, dp[N][i]); }
cout << res;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 970,931 | 970,929 | u054106284 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[123456];
int N, W, price[123], wt[123];
int32_t main() {
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> wt[i] >> price[i];
}
for (int i = 0; i < N; i++) {
for (int j = W - wt[i]; j >= 0; j--) {
dp[j + wt[i]] = max(dp[W + wt[i]], dp[j] + price[i]);
}
}
cout << dp[W] << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[123456];
int N, W, price[123], wt[123];
int32_t main() {
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> wt[i] >> price[i];
}
for (int i = 0; i < N; i++) {
for (int j = W - wt[i]; j >= 0; j--) {
dp[j + wt[i]] = max(dp[j + wt[i]], dp[j] + price[i]);
}
}
cout << dp[W] << "\n";
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 970,934 | 970,935 | u745631549 | cpp |
p03163 | #include <bits/stdc++.h>
#include <ext/hash_map>
#include <ext/numeric>
using namespace std;
using namespace __gnu_cxx;
#define REP(i, n) for ((i) = 0; (i) < (n); (i)++)
#define rep(i, x, n) for ((i) = (x); (i) < (n); (i)++)
#define REV(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define FORIT(it, x) for ((it) = (x).begin(); (it) != (x).end(); (it)++)
#define foreach(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define rforeach(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define foreach2d(i, j, v) \
foreach (i, v) \
foreach (j, *i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SZ(x) ((int)(x).size())
#define MMS(x, n) memset(x, n, sizeof(x))
#define mms(x, n, s) memset(x, n, sizeof(x) * s)
#define pb push_back
#define mp make_pair
#define NX next_permutation
#define UN(x) sort(all(x)), x.erase(unique(all(x)), x.end())
#define CV(x, n) count(all(x), (n))
#define FIND(x, n) find(all(x), (n)) - (x).begin()
#define ACC(x) accumulate(all(x), 0)
#define PPC(x) __builtin_popcountll(x)
#define LZ(x) __builtin_clz(x)
#define TZ(x) __builtin_ctz(x)
#define mxe(x) *max_element(all(x))
#define mne(x) *min_element(all(x))
#define low(x, i) lower_bound(all(x), i)
#define upp(x, i) upper_bound(all(x), i)
#define NXPOW2(x) (1ll << ((int)log2(x) + 1))
#define PR(x) cout << #x << " = " << (x) << endl;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pii;
const int OO = (int)2e9;
const double eps = 1e-9;
const int N = 102;
const int C = 100005;
int n, W;
int w[N], v[N];
int dp[N][C];
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
// freopen("in.txt", "rt", stdin);
// freopen("out.txt", "wt", stdout);
#endif
cin >> n >> W;
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
for (int i = n - 1; i >= 0; i--) {
for (int c = W; c >= 0; c--) {
dp[i][c] = dp[i + 1][c];
if (c + w[i] <= W)
dp[i][c] = max(dp[i][c], dp[i + 1][c + w[i]] + v[i]);
}
}
cout << dp[0][0] << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <ext/hash_map>
#include <ext/numeric>
using namespace std;
using namespace __gnu_cxx;
#define REP(i, n) for ((i) = 0; (i) < (n); (i)++)
#define rep(i, x, n) for ((i) = (x); (i) < (n); (i)++)
#define REV(i, n) for ((i) = (n); (i) >= 0; (i)--)
#define FORIT(it, x) for ((it) = (x).begin(); (it) != (x).end(); (it)++)
#define foreach(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define rforeach(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define foreach2d(i, j, v) \
foreach (i, v) \
foreach (j, *i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SZ(x) ((int)(x).size())
#define MMS(x, n) memset(x, n, sizeof(x))
#define mms(x, n, s) memset(x, n, sizeof(x) * s)
#define pb push_back
#define mp make_pair
#define NX next_permutation
#define UN(x) sort(all(x)), x.erase(unique(all(x)), x.end())
#define CV(x, n) count(all(x), (n))
#define FIND(x, n) find(all(x), (n)) - (x).begin()
#define ACC(x) accumulate(all(x), 0)
#define PPC(x) __builtin_popcountll(x)
#define LZ(x) __builtin_clz(x)
#define TZ(x) __builtin_ctz(x)
#define mxe(x) *max_element(all(x))
#define mne(x) *min_element(all(x))
#define low(x, i) lower_bound(all(x), i)
#define upp(x, i) upper_bound(all(x), i)
#define NXPOW2(x) (1ll << ((int)log2(x) + 1))
#define PR(x) cout << #x << " = " << (x) << endl;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pii;
const int OO = (int)2e9;
const double eps = 1e-9;
const int N = 102;
const int C = 100005;
int n, W;
int w[N], v[N];
ll dp[N][C];
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
// freopen("in.txt", "rt", stdin);
// freopen("out.txt", "wt", stdout);
#endif
cin >> n >> W;
for (int i = 0; i < n; i++)
cin >> w[i] >> v[i];
for (int i = n - 1; i >= 0; i--) {
for (int c = W; c >= 0; c--) {
dp[i][c] = dp[i + 1][c];
if (c + w[i] <= W)
dp[i][c] = max(dp[i][c], dp[i + 1][c + w[i]] + v[i]);
}
}
cout << dp[0][0] << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 970,947 | 970,948 | u362821344 | cpp |
p03163 | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define modulo 1000000007 // 10^9 + 7
#define MAX 1000000000 // 10^9
int w[100 + 1], v[100 + 1];
int dp[101][100001];
int main() {
int N, W;
cin >> N >> W;
for (int i = 1; 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)
dp[i][j] = 0;
else if (j - w[i] < 0)
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]);
}
}
cout << dp[N][W] << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define modulo 1000000007 // 10^9 + 7
#define MAX 1000000000 // 10^9
int w[100 + 1], v[100 + 1];
ll dp[101][100001];
int main() {
int N, W;
cin >> N >> W;
for (int i = 1; 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)
dp[i][j] = 0;
else if (j - w[i] < 0)
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]);
}
}
cout << dp[N][W] << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 970,951 | 970,952 | u774652316 | cpp |
p03163 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, w1;
cin >> n >> w1;
std::vector<int> w(n + 1);
std::vector<int> v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
}
vector<vector<int>> f(n + 1, vector<int>(w1 + 1, 0));
// for(int i=0;i<=w1;i++)f[0][i]=0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= w1; j++) {
if (w[i] + j <= w1)
f[i][j + w[i]] = f[i - 1][j] + v[i];
f[i][j] = max(f[i - 1][j], f[i][j]);
}
}
int maxi = INT_MIN;
for (int j = 0; j <= w1; j++)
maxi = max(maxi, f[n][j]);
cout << maxi;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, w1;
cin >> n >> w1;
std::vector<int> w(n + 1);
std::vector<int> v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> w[i] >> v[i];
}
vector<vector<long>> f(n + 1, vector<long>(w1 + 1, 0));
// for(int i=0;i<=w1;i++)f[0][i]=0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= w1; j++) {
if (w[i] + j <= w1)
f[i][j + w[i]] = f[i - 1][j] + v[i];
f[i][j] = max(f[i - 1][j], f[i][j]);
}
}
long maxi = -8;
for (int j = 0; j <= w1; j++)
maxi = max(maxi, f[n][j]);
cout << maxi;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 970,953 | 970,954 | u765576524 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.