problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k | fixed_code stringlengths 12 526k | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M | fixed_submission_id int64 2 1.54M | user_id stringlengths 10 10 | language stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> ii;
const int N = 1e2 + 5;
const int M = 1e3 + 5;
const ll INF = 1e15;
int n, W, h[N], v[N], w[N];
ll dp[N][N * M];
ll f(int cur, int rem) {
if (rem < 0)
return INF;
if (cur == n + 1) {
if (rem == 0)
r... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> ii;
const int N = 1e2 + 5;
const int M = 1e3 + 5;
const ll INF = 1e15;
int n, W, h[N], v[N], w[N];
ll dp[N][N * M];
ll f(int cur, int rem) {
if (rem < 0)
return INF;
if (cur == n + 1) {
if (rem == 0)
r... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 971,767 | 971,768 | u445860050 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int dp[105][100005];
int main() {
// cout.precision(10);
for (int i = 0; i <= 100000; i++) {
dp[0][i] = INF;
}
dp[0][0] = 0;
int N, W;
cin >> N >... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9 + 2)
#define PI (acos(-1))
// const ll mod = 1000000007;
int dp[105][100005];
int main() {
// cout.precision(10);
for (int i = 0; i <= 100000; i++) {
dp[0][i] = INF;
}
dp[0][0] = 0;
int N, W;
cin >>... | [] | 971,776 | 971,777 | u980655160 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
int N, W;
cin >> N >> W;
vector<LL> w(N + 1), v(N + 1);
for (int i = 1; i <= N; i++)
cin >> w[i] >> v[i];
vector<LL> dp(100 * 1000 + 1, 1000000000L);
dp[0] = 0;
int ans = 0;
for (int i = 1; i <= N; i++) {
for (int j... | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
int N, W;
cin >> N >> W;
vector<LL> w(N + 1), v(N + 1);
for (int i = 1; i <= N; i++)
cin >> w[i] >> v[i];
vector<LL> dp(100 * 1000 + 1, 10000000000L);
dp[0] = 0;
int ans = 0;
for (int i = 1; i <= N; i++) {
for (int ... | [
"literal.number.change",
"call.arguments.change"
] | 971,786 | 971,787 | u296096665 | cpp |
p03164 | #include <bits/stdc++.h>
#define fore(x, a, b) for (int x = a, qwerty = b; x < qwerty; x++)
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) ((int)(a).size())
#define pb push_back
#define FIN \
ios_base::sync_with_stdio(0); ... | #include <bits/stdc++.h>
#define fore(x, a, b) for (int x = a, qwerty = b; x < qwerty; x++)
#define ALL(a) (a).begin(), (a).end()
#define SZ(a) ((int)(a).size())
#define pb push_back
#define FIN \
ios_base::sync_with_stdio(0); ... | [
"literal.number.change",
"function.return_value.change"
] | 971,798 | 971,799 | u780156982 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e5 + 5;
const ll INF = 2e11;
ll n, w[N], v[N], W, dp[N][105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> W;
for (int i = 1; i <= n; ++i)
cin >> w[i] >> v[i];
for (int i = 0; i < N... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e5 + 5;
const ll INF = 2e11;
ll n, w[N], v[N], W, dp[N][105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> W;
for (int i = 1; i <= n; ++i)
cin >> w[i] >> v[i];
for (int i = 0; i < N... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 971,800 | 971,801 | u270946680 | cpp |
p03164 | #include <iostream>
using namespace std;
long long dp[110][100010] = {}, a[110], b[110], ans;
int main() {
int i, j, n, w;
cin >> n >> w;
for (i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
for (i = 0; i <= n; i++) {
for (j = 0; j <= 10000; j++) {
dp[i][j] = 1000000000000000;
}
}
dp[0][0]... | #include <iostream>
using namespace std;
long long dp[110][100010] = {}, a[110], b[110], ans;
int main() {
int i, j, n, w;
cin >> n >> w;
for (i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
for (i = 0; i <= n; i++) {
for (j = 0; j <= 100000; j++) {
dp[i][j] = 1000000000000000;
}
}
dp[0][0... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 971,806 | 971,807 | u621509943 | cpp |
p03164 | /*==========================================================================================*\
** _ _ _ _ _ _ _ **
** | |__ _ _/ | |_| |__ | || | _ __ | |__ **
** | '_ \| | | | | __| '_ \| || |_| '_ \| '_ \ **
** ... | /*==========================================================================================*\
** _ _ _ _ _ _ _ **
** | |__ _ _/ | |_| |__ | || | _ __ | |__ **
** | '_ \| | | | | __| '_ \| || |_| '_ \| '_ \ **
** ... | [
"assignment.variable.change",
"identifier.change",
"call.function.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 971,824 | 971,825 | u689136268 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
int n;
long long w[110], v[110];
long long dp[110][100010];
#define INF 10000000000000
#define VMAX 100010
int main() {
long long W;
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < ... | #include <bits/stdc++.h>
using namespace std;
int n;
long long w[110], v[110];
long long dp[110][100010];
#define INF 10000000000000
#define VMAX 100010
int main() {
long long W;
cin >> n >> W;
for (int i = 0; i < n; i++) {
cin >> w[i] >> v[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < ... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 971,830 | 971,831 | u221119670 | cpp |
p03164 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <string>
#include <vector>
using namespace std;
#define REP(i, b, e) for (ll i = (ll)b; i < (ll)e; i++)
#define rep0(i, n) REP(i,... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <string>
#include <vector>
using namespace std;
#define REP(i, b, e) for (ll i = (ll)b; i < (ll)e; i++)
#define rep0(i, n) REP(i,... | [
"identifier.change"
] | 971,832 | 971,833 | u297045966 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MX = 100000;
const ll INF = 1e18 + 7107;
int n, w[100005], v[100005], ans;
ll f[100005], T;
int main() {
scanf("%d%lld", &n, &T);
for (int i = 1; i <= n; i++)
scanf("%d%d", &w[i], &v[i]);
for (int i = 1; i <= MX; i++)
f[i] = INF... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MX = 100000;
const ll INF = 1e18 + 7107;
int n, w[100005], v[100005], ans;
ll f[100005], T;
int main() {
scanf("%d%lld", &n, &T);
for (int i = 1; i <= n; i++)
scanf("%d%d", &w[i], &v[i]);
for (int i = 1; i <= MX; i++)
f[i] = INF... | [
"control_flow.loop.for.condition.change",
"control_flow.branch.if.condition.change"
] | 971,856 | 971,857 | u674236668 | cpp |
p03164 | /*
Author: Sagar Gupta
E mail: sagar.june97p@gmail.com
*/
#include <bits/stdc++.h>
#define newline ("\n")
#define deb(x) cerr << (#x) << " = " << (x) << '\n'
#define FOR(x, n) for (int x = 0; x < n; x++)
#define PI (3.141592653589)
#define MOD 1000000007
using namespace std;
long long weight[101], value[101];
int ma... | /*
Author: Sagar Gupta
E mail: sagar.june97p@gmail.com
*/
#include <bits/stdc++.h>
#define newline ("\n")
#define deb(x) cerr << (#x) << " = " << (x) << '\n'
#define FOR(x, n) for (int x = 0; x < n; x++)
#define PI (3.141592653589)
#define MOD 1000000007
using namespace std;
long long weight[101], value[101];
int ma... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 971,858 | 971,859 | u612695892 | cpp |
p03164 | #include <bits/stdc++.h>
#ifdef PRAGMA
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#endif
#define fst first
#define snd second
#define fore(i, a, n) for (int i = a; i < n; i++)
#define pb push_back
#define mp make_pair
... | #include <bits/stdc++.h>
#ifdef PRAGMA
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#endif
#define fst first
#define snd second
#define fore(i, a, n) for (int i = a; i < n; i++)
#define pb push_back
#define mp make_pair
... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 971,862 | 971,863 | u654921099 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
int n, w;
ll dp[100100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> w;
for (int i = 0; i <= 100000; i++)
dp[i] = 1e9;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
int a,... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
int n, w;
ll dp[100100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> w;
for (int i = 0; i <= 100000; i++)
dp[i] = 2e9;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
int a,... | [
"literal.number.change",
"assignment.value.change"
] | 971,865 | 971,866 | u137940828 | cpp |
p03164 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef vector... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef vector... | [
"variable_declaration.type.change",
"identifier.change",
"function.return_value.change"
] | 971,870 | 971,871 | u222758739 | cpp |
p03164 | // Author:- Yatin Patel
// Mail:- yatinpatel.gt@gmail.com
#include <bits/stdc++.h>
#define FILEIN \
ifstream fin; \
fin.open("input.txt");
#define FILEOUT ... | // Author:- Yatin Patel
// Mail:- yatinpatel.gt@gmail.com
#include <bits/stdc++.h>
#define FILEIN \
ifstream fin; \
fin.open("input.txt");
#define FILEOUT ... | [
"preprocessor.define.value.change"
] | 971,880 | 971,881 | u646513066 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define endl "\n"
#define dbg(x) cout << #x << " = " << (x) << endl;
const ll MOD = 1000000007;
const ll INF = 1e18;
const int maxn = 1000;
int n, c;
int w[maxn];
int v[maxn];
vector<vector<ll>> dp(105, vector<ll>(100005, INF));
... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define endl "\n"
#define dbg(x) cout << #x << " = " << (x) << endl;
const ll MOD = 1000000007;
const ll INF = 1e18;
const int maxn = 1000;
int n, c;
int w[maxn];
int v[maxn];
vector<vector<ll>> dp(105, vector<ll>(100005, INF));
... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 971,893 | 971,894 | u075489826 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define endl "\n"
#define dbg(x) cout << #x << " = " << (x) << endl;
const ll MOD = 1000000007;
const ll INF = 1e18;
const int maxn = 1000;
int n, c;
int w[maxn];
int v[maxn];
vector<vector<ll>> dp(105, vector<ll>(100005, 100005)... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define endl "\n"
#define dbg(x) cout << #x << " = " << (x) << endl;
const ll MOD = 1000000007;
const ll INF = 1e18;
const int maxn = 1000;
int n, c;
int w[maxn];
int v[maxn];
vector<vector<ll>> dp(105, vector<ll>(100005, INF));
... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 971,896 | 971,894 | u075489826 | cpp |
p03164 | //
// main.cpp
// E - Knapsack 2
//
// Created by Nishant Dhankhar on 16/01/19.
// Copyright © 2019 Nishant Dhankhar. All rights reserved.
//
#include <bits/stdc++.h> //REMEMBER TO REMOVE '/'
#include <iostream>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define int ll
#defi... | //
// main.cpp
// E - Knapsack 2
//
// Created by Nishant Dhankhar on 16/01/19.
// Copyright © 2019 Nishant Dhankhar. All rights reserved.
//
#include <bits/stdc++.h> //REMEMBER TO REMOVE '/'
#include <iostream>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define int ll
#defi... | [
"literal.number.change",
"variable_declaration.value.change"
] | 971,897 | 971,898 | u114310424 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define endl '\n'
typedef long long ll;
const ll oo = 0x3f3f3f3f3f3f3f3f;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n, w;
cin >> n >> w;
ll N = n * 1000 + 100;
vector<ll> dp(N, oo);
dp[0] = 0;
for (ll i = 0, a, b; i < n; ++i) {
cin >>... | #include <bits/stdc++.h>
using namespace std;
#define endl '\n'
typedef long long ll;
const ll oo = 0x3f3f3f3f3f3f3f3f;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n, w;
cin >> n >> w;
ll N = n * 1000 + 100;
vector<ll> dp(N, oo);
dp[0] = 0;
for (ll i = 0, a, b; i < n; ++i) {
cin >>... | [
"control_flow.loop.for.initializer.change"
] | 971,899 | 971,900 | u122051363 | cpp |
p03164 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespa... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespa... | [
"literal.number.change",
"call.arguments.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 971,904 | 971,905 | u219786796 | cpp |
p03164 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespa... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespa... | [
"literal.number.change",
"call.arguments.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 971,906 | 971,905 | u219786796 | cpp |
p03164 | #include <bits/stdc++.h>
#define int long long int
#define mp make_pair
using namespace std;
int n, k;
vector<int> v(102), w(102);
int dp[102][100002];
int fun(int pos, int value) {
if (value == 0) {
return 0;
}
if (value < 0) {
return 1e15;
}
if (pos == n) {
return 1e15;
}
if (dp[pos][valu... | #include <bits/stdc++.h>
#define int long long int
#define mp make_pair
using namespace std;
int n, k;
vector<int> v(102), w(102);
int dp[102][100002];
int fun(int pos, int value) {
if (value == 0) {
return 0;
}
if (value < 0) {
return 1e15;
}
if (pos == n) {
return 1e15;
}
if (dp[pos][valu... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 971,909 | 971,910 | u041920892 | cpp |
p03164 | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: main.cpp
* Author: Allen
*
* Created on January 12, 2019, 5:13 PM
*/
#include <climits>
#include <cstdlib>
#include... | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: main.cpp
* Author: Allen
*
* Created on January 12, 2019, 5:13 PM
*/
#include <climits>
#include <cstdlib>
#include... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"assignment.change"
] | 971,925 | 971,926 | u381906125 | cpp |
p03164 | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: main.cpp
* Author: Allen
*
* Created on January 12, 2019, 5:13 PM
*/
#include <climits>
#include <cstdlib>
#include... | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: main.cpp
* Author: Allen
*
* Created on January 12, 2019, 5:13 PM
*/
#include <climits>
#include <cstdlib>
#include... | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 971,927 | 971,926 | u381906125 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
long long int dp[100005][105];
pair<int, int> jinis[105];
void init() { memset(dp, -1, sizeof(dp)); }
long long solve(int vleft, int cur, int n) {
if (cur == n) {
if (vleft == 0)
return 0;
return (long long)2000000000;
}
if (dp[vleft][cur] != -1)
... | #include <bits/stdc++.h>
using namespace std;
long long int dp[100005][105];
pair<int, int> jinis[105];
void init() { memset(dp, -1, sizeof(dp)); }
long long solve(int vleft, int cur, int n) {
if (cur == n) {
if (vleft == 0)
return 0;
return (long long)2000000000;
}
if (dp[vleft][cur] != -1)
... | [
"call.add"
] | 971,930 | 971,931 | u860352559 | cpp |
p03164 | #include <bits/stdc++.h>
#define ioFix \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
long long madd(long long x, long lo... | #include <bits/stdc++.h>
#define ioFix \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
long long madd(long long x, long lo... | [
"variable_declaration.type.change",
"literal.number.change",
"call.arguments.change",
"control_flow.branch.if.condition.change"
] | 971,947 | 971,948 | u805352368 | cpp |
p03164 | #pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); ... | #pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); ... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 971,980 | 971,981 | u811982971 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")"... | #include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")"... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 971,997 | 971,998 | u293764826 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
long long dp[200][200000];
int c[200], w[200];
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
int n, we;
cin >> n >> we;
for (int i = 1; i <= n; i++)
cin >> w[i] >> c[i];
for (int... | #include <bits/stdc++.h>
using namespace std;
long long dp[200][200000];
long long c[200], w[200];
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
int n, we;
cin >> n >> we;
for (int i = 0; i < n; i++)
cin >> w[i] >> c[i];
for... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"... | 972,005 | 972,006 | u933786880 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define LEN(x) (int)x.size()
#define ALL(x) x.begin(), x.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
const int MOD = 1000'000'007;
const double EPS = 0.000'000'001;
inline int fcmp(dou... | #include <bits/stdc++.h>
using namespace std;
#define LEN(x) (int)x.size()
#define ALL(x) x.begin(), x.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
const int MOD = 1000'000'007;
const double EPS = 0.000'000'001;
inline int fcmp(dou... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 972,011 | 972,012 | u932730369 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define LEN(x) (int)x.size()
#define ALL(x) x.begin(), x.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
const int MOD = 1000'000'007;
const double EPS = 0.000'000'001;
inline int fcmp(dou... | #include <bits/stdc++.h>
using namespace std;
#define LEN(x) (int)x.size()
#define ALL(x) x.begin(), x.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
const int MOD = 1000'000'007;
const double EPS = 0.000'000'001;
inline int fcmp(dou... | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 972,013 | 972,012 | u932730369 | cpp |
p03164 | #include <iostream>
using namespace std;
int w[110], v[110];
long long int dp[1100];
int INF = 1000000009;
int N, W;
int main() {
for (int i = 0; i < 100001; i++)
dp[i] = INF;
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> w[i] >> v[i];
}
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int ... | #include <iostream>
using namespace std;
int w[110], v[110];
long long int dp[110000];
int INF = 1000000009;
int N, W;
int main() {
for (int i = 0; i < 100001; i++)
dp[i] = INF;
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> w[i] >> v[i];
}
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (in... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 972,068 | 972,069 | u090967649 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
void min_self(long long &x, long long y) { x = min(x, y); }
long long inf = 1e18 + 1;
int main() {
int n;
int w;
scanf("%d %d", &n, &w);
vector<int> weight(n + 1), value(n + 1);
for (int i = 0; i < n; i++) {
scanf("%d%d", &weight[i], &value[i]);
}
int sum... | #include <bits/stdc++.h>
using namespace std;
void min_self(long long &x, long long y) { x = min(x, y); }
long long inf = 1e18 + 1;
int main() {
int n;
int w;
scanf("%d %d", &n, &w);
vector<int> weight(n + 1), value(n + 1);
for (int i = 0; i < n; i++) {
scanf("%d%d", &weight[i], &value[i]);
}
int sum... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 972,092 | 972,093 | u713008740 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
void min_self(long long &x, long long y) { x = min(x, y); }
long long inf = 1e18 + 1;
int main() {
int n;
int w;
scanf("%d %d", &n, &w);
vector<int> weight(n + 1), value(n + 1);
for (int i = 0; i < n; i++) {
scanf("%d%d", &weight[i], &value[i]);
}
int sum... | #include <bits/stdc++.h>
using namespace std;
void min_self(long long &x, long long y) { x = min(x, y); }
long long inf = 1e18 + 1;
int main() {
int n;
int w;
scanf("%d %d", &n, &w);
vector<int> weight(n + 1), value(n + 1);
for (int i = 0; i < n; i++) {
scanf("%d%d", &weight[i], &value[i]);
}
int sum... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.arguments.change"
] | 972,094 | 972,093 | u713008740 | cpp |
p03164 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <vector>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b... | // dp[i][v_sum] = w_sum
// v_sum以上になるiまでのwiの和の最小値
// dp[N][v_sum] W以下なるv_sum最大値が答え
// dp[0][any] = 0 ほんまか？ ほんまじゃない…
//むり～～～～～～～～～～～～～～
//配るDP
#include <algorithm>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <vector>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
template <cla... | [
"identifier.change",
"call.arguments.change"
] | 972,097 | 972,098 | u877476774 | cpp |
p03164 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <vector>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b... | // dp[i][v_sum] = w_sum
// v_sum以上になるiまでのwiの和の最小値
// dp[N][v_sum] W以下なるv_sum最大値が答え
// dp[0][any] = 0 ほんまか？ ほんまじゃない…
//むり～～～～～～～～～～～～～～
//配るDP
#include <algorithm>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <vector>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
template <cla... | [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"identifier.change"
] | 972,099 | 972,098 | u877476774 | cpp |
p03164 | #include <climits>
#include <cmath>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
template <typename T> void mymin(T &a, T b) {
if (a > b)
a = b;
}
int main() {
int N, W;
cin >> N >> W;
vector<int> w(N, 0);
vector<int> v(N, 0);
for (int i = 0; i < N; i++)
cin >> w.a... | #include <climits>
#include <cmath>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
template <typename T> void mymin(T &a, T b) {
if (a > b)
a = b;
}
int main() {
int N, W;
cin >> N >> W;
vector<int> w(N, 0);
vector<int> v(N, 0);
for (int i = 0; i < N; i++)
cin >> w.a... | [
"identifier.change",
"call.arguments.change"
] | 972,123 | 972,124 | u634208461 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define repn(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, a) for (int i = 0; i < (a); i++)
#define all(v) v.begin(), v.end()
#define mp make_pair
#define pb push_back
#define fi first
#defin... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define repn(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, a) for (int i = 0; i < (a); i++)
#define all(v) v.begin(), v.end()
#define mp make_pair
#define pb push_back
#define fi first
#defin... | [
"literal.number.change",
"assignment.variable.change",
"call.arguments.change"
] | 972,127 | 972,128 | u626595726 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n, w;
cin >> n >> w;
ll a[2][n], dp[n * 1000 + 1];
for (int i = 0; i < n; i++)
cin >> a[0][i] >> a[1][i];
for (int i = 0; i <= n * 100; i++)
dp[i] = INT_MAX;
ll mx = 0;
for (int i = 0; i < n; i++) {
for (ll j =... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n, w;
cin >> n >> w;
ll a[2][n], dp[n * 1000 + 1];
for (int i = 0; i < n; i++)
cin >> a[0][i] >> a[1][i];
for (int i = 0; i <= n * 1000; i++)
dp[i] = INT_MAX;
ll mx = 0;
for (int i = 0; i < n; i++) {
for (ll j ... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 972,134 | 972,135 | u025287064 | cpp |
p03164 | #include <iostream>
using namespace std;
constexpr long long INF = 10000000007LL;
int N, W;
long long dp[100005];
int main() {
cin >> N >> W;
dp[0] = 0LL;
for (int x = 1; x <= 100 * 1000; ++x)
dp[x] = INF;
int w, v;
for (int i = 1; i <= N; ++i) {
cin >> w >> v;
for (int x = 100 * 1000; x >= 0;... | #include <iostream>
using namespace std;
constexpr long long INF = 10000000007LL;
int N, W;
long long dp[100005];
int main() {
cin >> N >> W;
dp[0] = 0LL;
for (int x = 1; x <= 100 * 1000; ++x)
dp[x] = INF;
int w, v;
for (int i = 1; i <= N; ++i) {
cin >> w >> v;
for (int x = 100 * 1000; x >= 0;... | [] | 972,150 | 972,151 | u605853117 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define endl '\n'
#define fcin \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#define inf 0x3f3f3f3f
const i... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define endl '\n'
#define fcin \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#define inf 0x3f3f3f3f
const i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 972,162 | 972,163 | u189873906 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define endl '\n'
#define fcin \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#define inf 0x3f3f3f3f
const i... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define endl '\n'
#define fcin \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#define inf 0x3f3f3f3f
const i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 972,164 | 972,163 | u189873906 | cpp |
p03164 | #include <stdio.h>
const int N = 1e5 + 10;
const long long int INF = 1e16 + 10;
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a > b ? b : a; }
int main() {
int n, w, p, v, ans = 0;
long long int a[N];
scanf("%d%d", &n, &w);
for (int i = 1; i < N; i++)
a[i] = INF;
a[0] = 0;... | #include <stdio.h>
const int N = 1e5 + 10;
const long long int INF = 1e16 + 10;
int max(int a, int b) { return a > b ? a : b; }
long long int min(long long int a, long long int b) { return a > b ? b : a; }
int main() {
int n, w, p, v, ans = 0;
long long int a[N];
scanf("%d%d", &n, &w);
for (int i = 1; i < N; i+... | [
"variable_declaration.type.widen.change"
] | 972,167 | 972,168 | u241347678 | cpp |
p03164 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#... | [
"call.arguments.change"
] | 972,171 | 972,172 | u800551451 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define rrep(i, a, b) for (ll i = a; i >= b; i--)
typedef long long int ll;
typedef vector<ll> vi;
int main() {
ll n, wt;
cin >> n >> wt;
ll w[n + 5], v[n + 5];
rep(i, 0, n) cin >> w[i] >> v[i];
ll tot = 0;
for (l... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define rrep(i, a, b) for (ll i = a; i >= b; i--)
typedef long long int ll;
typedef vector<ll> vi;
int main() {
ll n, wt;
cin >> n >> wt;
ll w[n], v[n];
rep(i, 0, n) cin >> w[i] >> v[i];
ll tot = 0;
for (ll &i : v... | [
"expression.operation.binary.remove"
] | 972,173 | 972,174 | u633475329 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define MAX_N 101
#define MAX_VALUE 100001 // 10^3 * 100 is max value that sum of values can be
#define MAX 1000000000
typedef long long ll;
ll n, w;
ll V[MAX_N], W[MAX_N];
ll dp[MAX_N][MAX_VALUE]; // holds the minimum weight needed to get that value
int main() {
cin >... | #include <bits/stdc++.h>
using namespace std;
#define MAX_N 101
#define MAX_VALUE 100001 // 10^3 * 100 is max value that sum of values can be
#define MAX 1000000001
typedef long long ll;
ll n, w;
ll V[MAX_N], W[MAX_N];
ll dp[MAX_N][MAX_VALUE]; // holds the minimum weight needed to get that value
int main() {
cin >... | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 972,178 | 972,179 | u760218205 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define MAX_N 101
#define MAX_VALUE 100001 // 10^3 * 100 is max value that sum of values can be
#define MAX 99999999
typedef long long ll;
ll n, w;
ll V[MAX_N], W[MAX_N];
ll dp[MAX_N][MAX_VALUE]; // holds the minimum weight needed to get that value
int main() {
cin >> ... | #include <bits/stdc++.h>
using namespace std;
#define MAX_N 101
#define MAX_VALUE 100001 // 10^3 * 100 is max value that sum of values can be
#define MAX 1000000001
typedef long long ll;
ll n, w;
ll V[MAX_N], W[MAX_N];
ll dp[MAX_N][MAX_VALUE]; // holds the minimum weight needed to get that value
int main() {
cin >... | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 972,180 | 972,179 | u760218205 | cpp |
p03164 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stdbool.h>
#include <string>
#include <utility>
#include <vector>
typedef long long... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stdbool.h>
#include <string>
#include <utility>
#include <vector>
typedef long long... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 972,183 | 972,184 | u240303506 | cpp |
p03164 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
typedef long long llong;
using namespace std;
int main() {
int n, lim;
cin >> n >> lim;
vector<int> w(n), v(n);
llong sumw = 0;
int sumv = 0;
REP(i, n) {
cin >> w[i] >> v[i];
sumw += w[i];
sumv += v[i];
}
vector<llon... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
typedef long long llong;
using namespace std;
int main() {
int n, lim;
cin >> n >> lim;
vector<int> w(n), v(n);
llong sumw = 0;
int sumv = 0;
REP(i, n) {
cin >> w[i] >> v[i];
sumw += w[i];
sumv += v[i];
}
vector<llon... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 972,187 | 972,188 | u209767598 | cpp |
p03164 | #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 int ll;
#def... | #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 int ll;
#def... | [
"preprocessor.define.value.change",
"literal.float.change",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 972,195 | 972,196 | u815863697 | cpp |
p03164 | #include <algorithm>
#include <array>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <sstream> // istringstream buffer(myString);
#include <stack>
#include <stdio.h>
#include <string>
#... | #include <algorithm>
#include <array>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <sstream> // istringstream buffer(myString);
#include <stack>
#include <stdio.h>
#include <string>
#... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 972,204 | 972,205 | u831038161 | cpp |
p03164 | #include <algorithm>
#include <iostream>
#include <utility>
using namespace std;
#define maxW 100010
#define maxN 102
#define maxV 1000
#define INFINITY 99999999999999
typedef long long ll;
int n;
ll s;
ll cache[maxN][maxW], v[maxN], w[maxN];
ll rec(int i, int V) {
if (V == 90) {
int a = 0;
}
if (V == 0... | #include <algorithm>
#include <iostream>
#include <utility>
using namespace std;
#define maxW 100010
#define maxN 102
#define maxV 100000
#define INFINITY 99999999999999
typedef long long ll;
int n;
ll s;
ll cache[maxN][maxW], v[maxN], w[maxN];
ll rec(int i, int V) {
if (V == 90) {
int a = 0;
}
if (V ==... | [
"preprocessor.define.value.change",
"literal.integer.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove"
] | 972,210 | 972,211 | u304052848 | cpp |
p03164 |
// https://atcoder.jp/contests/dp/tasks/dp_e
#include <algorithm>
#include <bits/stdc++.h>
#include <limits.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long int ll;
const int precision = 16;
const int modulo = 1000000007; // 10^9 + 7
using ll = long lo... |
// https://atcoder.jp/contests/dp/tasks/dp_e
#include <algorithm>
#include <bits/stdc++.h>
#include <limits.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long int ll;
const int precision = 16;
const int modulo = 1000000007; // 10^9 + 7
using ll = long lo... | [
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 972,222 | 972,220 | u476450778 | cpp |
p03164 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
#define ok1 printf("ok1\n");
#define ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
#define ok1 printf("ok1\n");
#define ... | [
"literal.number.change",
"call.arguments.change"
] | 972,235 | 972,234 | u373958718 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, w, a[N], b[N], dp[N], ans;
int main() {
cin >> n >> w;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 1; i < N; i++)
dp[i] = 2e9;
for (int i = 1; i <= n; i++) {
for (int j = N - 1; j >= b[i]; j--... | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long n, w, a[N], b[N], dp[N], ans;
int main() {
cin >> n >> w;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 1; i < N; i++)
dp[i] = 2e9;
for (int i = 1; i <= n; i++) {
for (int j = N - 1; j >= b[i... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 972,244 | 972,245 | u644994661 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int n, w, a[N], b[N], dp[N];
int main() {
cin >> n >> w;
for (int i = 1; i < N; i++) {
dp[i] = 1e9;
}
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
for (int j = N - 1; j >= b[i]; j--) {
dp[j] = min(dp[j - b[i]] + ... | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int n, w, a[N], b[N];
long long dp[N];
int main() {
cin >> n >> w;
for (int i = 1; i < N; i++) {
dp[i] = 1e18;
}
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
for (int j = N - 1; j >= b[i]; j--) {
dp[j] = min(dp[j... | [
"literal.number.change",
"assignment.value.change"
] | 972,246 | 972,247 | u644994661 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__() \
for (long blockTime = NULL; \
(blockTime == NULL ? (blockTime = clock(... | #include <bits/stdc++.h>
using namespace std;
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__() \
for (long blockTime = NULL; \
(blockTime == NULL ? (blockTime = clock(... | [
"variable_declaration.type.change",
"assignment.variable.change",
"identifier.change",
"call.function.change"
] | 972,252 | 972,251 | u603846802 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")"... | #include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")"... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 972,262 | 972,263 | u127449133 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(v) v.b... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(v) v.b... | [
"variable_declaration.type.change",
"literal.number.change",
"call.arguments.change"
] | 972,274 | 972,275 | u817703858 | cpp |
p03164 | #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;
typedef pair<int, int> P;
#define modulo 1000000007 // 10^9 + 7
#define INF 1000000... | #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;
typedef pair<int, int> P;
#define modulo 1000000007 // 10^9 + 7
#define INF 1000000... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 972,278 | 972,279 | u774652316 | cpp |
p03164 | #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;
typedef pair<int, int> P;
#define modulo 1000000007 // 10^9 + 7
#define INF 1000000... | #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;
typedef pair<int, int> P;
#define modulo 1000000007 // 10^9 + 7
#define INF 1000000... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 972,278 | 972,280 | u774652316 | cpp |
p03164 | #include <stdio.h>
#include <vector>
using namespace std;
const int C = 100001, N = 101, Inf = 1000000000;
typedef long long ll;
int n, k, a, b, c, v;
ll dp[N][C], w, mw;
int main() {
int j, i;
scanf("%d %lld", &n, &mw);
for (j = 1; j < C; j++)
dp[0][j] = Inf;
for (i = 1; i <= n; i++) {
scanf("%lld %d... | #include <stdio.h>
#include <vector>
using namespace std;
const int C = 100001, N = 101, Inf = 1500000000;
typedef long long ll;
int n, k, a, b, c, v;
ll dp[N][C], w, mw;
int main() {
int j, i;
scanf("%d %lld", &n, &mw);
for (j = 1; j < C; j++)
dp[0][j] = Inf;
for (i = 1; i <= n; i++) {
scanf("%lld %d... | [
"literal.number.change",
"variable_declaration.value.change"
] | 972,301 | 972,302 | u679729810 | cpp |
p03164 | #include <iostream>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
const int MAX_N... | #include <iostream>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
const int MAX_N... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 972,317 | 972,318 | u794707792 | cpp |
p03164 | #include <iostream>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
const int MAX_N... | #include <iostream>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
const int MAX_N... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 972,319 | 972,318 | u794707792 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
#define P pair<int, int>
int main() {
int N, W;
cin >> N >> W;
vector<P> w_v(N);
int sum = 0;
for (int i = 0; i < N; i += 1) {
cin >> w_v[i].second >> w_v[i].first;
sum += w_v[i].second;
}
sort(w_v.rbegin(), w_v.rend());
int dp[sum + 1];
... | #include <bits/stdc++.h>
using namespace std;
#define P pair<int, int>
int main() {
int N, W;
cin >> N >> W;
vector<P> w_v(N);
int sum = 0;
for (int i = 0; i < N; i += 1) {
cin >> w_v[i].second >> w_v[i].first;
sum += w_v[i].first;
}
sort(w_v.rbegin(), w_v.rend());
int dp[sum + 1];
... | [
"assignment.value.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.arguments.change",
"variable_access.subscript.index.change"
] | 972,322 | 972,323 | u054986947 | cpp |
p03164 | #include <bits/stdc++.h>
using namespace std;
long long i, j, max_, f[101][100001], w[101], v[101], n, W, x = 0;
int main() {
memset(f, 0x7f, sizeof(f));
scanf("%lld %lld", &n, &W);
for (i = 1; i <= n; i++) {
scanf("%lld %lld", &w[i], &v[i]);
x += v[i];
}
f[0][0] = 0;
for (i = 1; i <= n; i++)
fo... | #include <bits/stdc++.h>
using namespace std;
long long i, j, max_, f[101][100001], w[101], v[101], n, W, x = 0;
int main() {
memset(f, 0x7f, sizeof(f));
scanf("%lld %lld", &n, &W);
for (i = 1; i <= n; i++) {
scanf("%lld %lld", &w[i], &v[i]);
x += v[i];
}
f[0][0] = 0;
for (i = 1; i <= n; i++)
fo... | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 972,344 | 972,345 | u386813869 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); i++)
#define mp(x, y) make_pair(x, y)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using vll = vector<ll>;
using P = pair<int, int>;
const int inf = 1e9 + 7;
const ll INF = 1e18;
template <type... | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); i++)
#define mp(x, y) make_pair(x, y)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using vll = vector<ll>;
using P = pair<int, int>;
const int inf = 1e9 + 7;
const ll INF = 1e18;
template <type... | [] | 972,356 | 972,357 | u531461815 | cpp |
p03165 | // atcoder.jp/contests/dp/tasks/dp_d
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define ll long long
#define rep(i, s, n) for (ll i = s; i < n; ++i)
#define repm(i, s, n) for (ll i = s; n < i; --i)
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define MOD 1000000007
using nam... | // atcoder.jp/contests/dp/tasks/dp_d
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define ll long long
#define rep(i, s, n) for (ll i = s; i < n; ++i)
#define repm(i, s, n) for (ll i = s; n < i; --i)
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define MOD 1000000007
using nam... | [] | 972,364 | 972,365 | u483187413 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
// string max(string p,string q){
// if(p.length() > q.length()){
// return p;
// }
// return q;
// }
string solve(string p, string q) {
int m = p.length();
int n = q.length();
int dp[m + 1][n + 1] = {0};
for (int i = 0; i < m + 1; i++) {
for (int j = 0... | #include <bits/stdc++.h>
using namespace std;
// string max(string p,string q){
// if(p.length() > q.length()){
// return p;
// }
// return q;
// }
string solve(string p, string q) {
int m = p.length();
int n = q.length();
int dp[m + 1][n + 1] = {0};
for (int i = 0; i < m + 1; i++) {
for (int j = 0... | [] | 972,397 | 972,398 | u086313715 | cpp |
p03165 | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using namespace std;
template <typename T> using vec = std::vector<T>;
int main() {
string s;
string t;
cin >> s >> t;
vec<vec<int>> dp(s.size() + 1, vec<int>(t.size() + 1, 0));
... | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using namespace std;
template <typename T> using vec = std::vector<T>;
int main() {
string s;
string t;
cin >> s >> t;
vec<vec<int>> dp(s.size() + 1, vec<int>(t.size() + 1, 0));
... | [
"variable_declaration.type.primitive.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 972,406 | 972,407 | u945359338 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define optimize \
ios::sync_with_stdio(0); \
cin.tie(0);
#define PI acos(-1.0)
#define pb push_back
#define YES cout << "YES" << en... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define optimize \
ios::sync_with_stdio(0); \
cin.tie(0);
#define PI acos(-1.0)
#define pb push_back
#define YES cout << "YES" << en... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 972,470 | 972,471 | u325622555 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define optimize \
ios::sync_with_stdio(0); \
cin.tie(0);
#define PI acos(-1.0)
#define pb push_back
#define YES cout << "YES" << en... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define optimize \
ios::sync_with_stdio(0); \
cin.tie(0);
#define PI acos(-1.0)
#define pb push_back
#define YES cout << "YES" << en... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove",
"literal.string.change",
"assignment.value.change"
] | 972,472 | 972,471 | u325622555 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
// DEFINE and
// TYPEDEF--------------------------------------------------------------
// For actual content check from line 85
#define FORG(i, a, n) \
for (lld i = (lld)a; a < n ? i < (lld)n : (lld)n < i; ... | #include <bits/stdc++.h>
using namespace std;
// DEFINE and
// TYPEDEF--------------------------------------------------------------
// For actual content check from line 85
#define FORG(i, a, n) \
for (lld i = (lld)a; a < n ? i < (lld)n : (lld)n < i; ... | [
"literal.number.change"
] | 972,491 | 972,492 | u531151228 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
// DEFINE and
// TYPEDEF--------------------------------------------------------------
// For actual content check from line 85
#define FORG(i, a, n) \
for (lld i = (lld)a; a < n ? i < (lld)n : (lld)n < i; ... | #include <bits/stdc++.h>
using namespace std;
// DEFINE and
// TYPEDEF--------------------------------------------------------------
// For actual content check from line 85
#define FORG(i, a, n) \
for (lld i = (lld)a; a < n ? i < (lld)n : (lld)n < i; ... | [
"literal.number.change"
] | 972,493 | 972,492 | u531151228 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(), x.end()
#define rep(i, j, n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 100... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(), x.end()
#define rep(i, j, n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 100... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 972,504 | 972,505 | u164181205 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(), x.end()
#define rep(i, j, n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 100... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(), x.end()
#define rep(i, j, n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 100... | [
"variable_declaration.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 972,506 | 972,505 | u164181205 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, start, end) for (uint64_t i = start; i < end; i++)
#define REP(i, n) FOR(i, 0, n)
// 最大公約数gcd
// 最小公倍数lcm=m*n/gcd
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0) {
temp = n;
n = m % n;
m = temp;
}
return n;
}
ui... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, start, end) for (uint64_t i = start; i < end; i++)
#define REP(i, n) FOR(i, 0, n)
// 最大公約数gcd
// 最小公倍数lcm=m*n/gcd
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0) {
temp = n;
n = m % n;
m = temp;
}
return n;
}
ui... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"misc.opposites"
] | 972,527 | 972,528 | u925478083 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e9 + 7;
int mod = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dp[4005][4005];
signed main() {
string S, T;
cin >> S >> T;
for (int i = 0; i < S.size(); i++) {
for (int j = 0; j < S.s... | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e9 + 7;
int mod = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dp[4005][4005];
signed main() {
string S, T;
cin >> S >> T;
for (int i = 0; i < S.size(); i++) {
for (int j = 0; j < T.s... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 972,541 | 972,542 | u237390401 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
struct edge {
int to; // 辺の行き先
int weight; // 辺の重み
edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<int>>;
using dou = long double;
string Yes = "Yes";
string YES = "YES";
string NO = "NO";
string No = "No";
#define rep(i, n) for (int i = 0;... | #include <bits/stdc++.h>
using namespace std;
struct edge {
int to; // 辺の行き先
int weight; // 辺の重み
edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<int>>;
using dou = long double;
string Yes = "Yes";
string YES = "YES";
string NO = "NO";
string No = "No";
#define rep(i, n) for (int i = 0;... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 972,603 | 972,604 | u539011156 | cpp |
p03165 | #include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n; i >= 0; i--)
#define REP(i, s, t) for (int i = s; i <= t; i++)
#define RREP(i, s, t) for (int i = s; i >= t; i--)
#define dump(x) cerr << #x << " = " << (x) << endl;
#d... | #include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n; i >= 0; i--)
#define REP(i, s, t) for (int i = s; i <= t; i++)
#define RREP(i, s, t) for (int i = s; i >= t; i--)
#define dump(x) cerr << #x << " = " << (x) << endl;
#d... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 972,625 | 972,626 | u965730380 | cpp |
p03165 | #include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n; i >= 0; i--)
#define REP(i, s, t) for (int i = s; i <= t; i++)
#define RREP(i, s, t) for (int i = s; i >= t; i--)
#define dump(x) cerr << #x << " = " << (x) << endl;
#d... | #include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n; i >= 0; i--)
#define REP(i, s, t) for (int i = s; i <= t; i++)
#define RREP(i, s, t) for (int i = s; i >= t; i--)
#define dump(x) cerr << #x << " = " << (x) << endl;
#d... | [
"control_flow.branch.if.condition.change"
] | 972,627 | 972,626 | u965730380 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
string s, t;
ll dp[3007][3007];
int main() {
cin >> s >> t;
s += ';';
t += '.';
for (ll i = 0; i < s.length(); ++i) {
for (ll j = 0; j < t.length(); ++j) {
if (s[i] == t[j])
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
string s, t;
ll dp[3007][3007];
int main() {
cin >> s >> t;
s += ';';
t += '.';
for (ll i = 0; i < s.length(); ++i) {
for (ll j = 0; j < t.length(); ++j) {
if (s[i] == t[j])
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i... | [
"control_flow.loop.condition.change"
] | 972,628 | 972,629 | u406910179 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1LL << 60;
const double EPS = 1e-10;
const ll mod = 1000000007;
ll dp[3010][3010] = {};
int main(void) {
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < t.size(); j... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1LL << 60;
const double EPS = 1e-10;
const ll mod = 1000000007;
ll dp[3010][3010] = {};
int main(void) {
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < t.size(); j... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 972,682 | 972,683 | u675509234 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int m = s.size(), n = t.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (s[i] == t[j])
dp[i + 1][j + 1] = dp[i][j] + 1;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int m = s.size(), n = t.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (s[i] == t[j])
dp[i + 1][j + 1] = dp[i][j] + 1;
... | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 972,712 | 972,713 | u315212004 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
#define rep(i, n) for (int i = 0; i < (n); i++)
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;
retu... | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
#define rep(i, n) for (int i = 0; i < (n); i++)
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;
retu... | [
"expression.operation.binary.add"
] | 972,716 | 972,717 | u436660228 | cpp |
p03165 | #include <bits/stdc++.h>
#define smax(a, b) ((a) < (b) ? ((a) = (b), true) : false)
#define smin(a, b) ((a) > (b) ? ((a) = (b), true) : false)
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
using namespace std;
char a[3001];
char b[3001];
int dp[3001][3001];
int dir[3001][3001];
char add[3001][30... | #include <bits/stdc++.h>
#define smax(a, b) ((a) < (b) ? ((a) = (b), true) : false)
#define smin(a, b) ((a) > (b) ? ((a) = (b), true) : false)
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
using namespace std;
char a[3001];
char b[3001];
int dp[3001][3001];
int dir[3001][3001];
char add[3001][30... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 972,757 | 972,758 | u048420094 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
vector<vector<int>> dp(n + 1, vector<int>(m + 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i] == t[j])
dp[i + 1][j + 1] = ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
vector<vector<int>> dp(n + 1, vector<int>(m + 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i] == t[j])
dp[i + 1][j + 1] =... | [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"assignment.add"
] | 972,776 | 972,777 | u543584809 | cpp |
p03165 | #include <iostream>
//#include <iomanip>
#include <algorithm>
#include <string>
#include <vector>
//#include <utility>
//#include <set>
//#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
using vll = vector... | #include <iostream>
//#include <iomanip>
#include <algorithm>
#include <string>
#include <vector>
//#include <utility>
//#include <set>
//#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
using vll = vector... | [
"variable_declaration.value.change",
"identifier.change"
] | 972,780 | 972,781 | u993074316 | cpp |
p03165 | #include <iostream>
//#include <iomanip>
#include <algorithm>
#include <string>
#include <vector>
//#include <utility>
//#include <set>
//#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
using vll = vector... | #include <iostream>
//#include <iomanip>
#include <algorithm>
#include <string>
#include <vector>
//#include <utility>
//#include <set>
//#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
using vll = vector... | [
"variable_declaration.value.change",
"identifier.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 972,782 | 972,781 | u993074316 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i > 0; i++)
using ll = long long;
int dp[3010][3010];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
rep(i, s.size()) {
rep(j, t... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i > 0; i++)
using ll = long long;
int dp[3010][3010];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
rep(i, s.size()) {
rep(j, t... | [
"expression.operation.binary.remove"
] | 972,783 | 972,784 | u297398560 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
int main() {
string x, y;
int m, n, i, j;
cin >> x >> y;
m = x.length(); // use i for x
n = y.length(); // use j for y
int dp[m + 1][n + 1]; // rows for x and coloumns for y
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (i == 0 ... | #include <bits/stdc++.h>
using namespace std;
int main() {
string x, y;
int m, n, i, j;
cin >> x >> y;
m = x.length(); // use i for x
n = y.length(); // use j for y
int dp[m + 1][n + 1]; // rows for x and coloumns for y
for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
if (i == ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 972,804 | 972,805 | u345094009 | cpp |
p03165 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
string s, t;
int dp[3009][3009];
int main() {
cin >> s >> t;
for (int i = 1; i <= s.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
if (s[i - 1] == t[i - 1])
dp... | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
string s, t;
int dp[3009][3009];
int main() {
cin >> s >> t;
for (int i = 1; i <= s.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
if (s[i - 1] == t[j - 1])
dp... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"variable_declaration.value.change"
] | 972,827 | 972,828 | u047554023 | cpp |
p03165 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main() {
string s, t;
cin >> s >> t;
int ls = s.size();
int lt = t.size();
vector<vector<int>> dp(ls + 1, vector<int>(lt + 1));
rep(i, ls) {
rep(j, lt) {
if (s[i] == t[j]) {
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main() {
string s, t;
cin >> s >> t;
int ls = s.size();
int lt = t.size();
vector<vector<int>> dp(ls + 1, vector<int>(lt + 1));
rep(i, ls) {
rep(j, lt) {
if (s[i] == t[j]) {
... | [
"misc.opposites",
"control_flow.loop.condition.change"
] | 972,839 | 972,840 | u314917898 | cpp |
p03165 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
using P = pair<ll, ll>;
templa... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
using P = pair<ll, ll>;
templa... | [
"call.arguments.change",
"expression.operation.unary.remove"
] | 972,855 | 972,856 | u952081880 | cpp |
p03165 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
using P = pair<ll, ll>;
templa... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
using P = pair<ll, ll>;
templa... | [
"call.arguments.change",
"expression.operation.unary.remove",
"control_flow.loop.condition.change"
] | 972,857 | 972,856 | u952081880 | cpp |
p03165 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
// dp[i][j] := sのi文字目, tのj文字目まで見たときの最長共通部分列(LCS)
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
for (int i = 0; i < n; i++) {
for (int j = 0;... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
// dp[i][j] := sのi文字目, tのj文字目まで見たときの最長共通部分列(LCS)
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
for (int i = 0; i < n; i++) {
for (int j = 0;... | [
"call.arguments.change"
] | 972,901 | 972,902 | u813098295 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ll long long
template <class T> using v = std::vector<T>;
template <class T> using vv = v<v<T>>;
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ll long long
template <class T> using v = std::vector<T>;
template <class T> using vv = v<v<T>>;
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x ... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 972,903 | 972,904 | u411751515 | cpp |
p03165 | #include <bits/stdc++.h>
#include <regex>
#ifdef _DEBUG
#include "debug.h"
#endif
#define int ll
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define all(v) (v).begin(), (v).end()
#define mkpr make_pair
#define mktp make_tuple
#define tv(tp, i) get<(i)>(tp)
#define CLEAR(obj... | #include <bits/stdc++.h>
#include <regex>
#ifdef _DEBUG
#include "debug.h"
#endif
#define int ll
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define all(v) (v).begin(), (v).end()
#define mkpr make_pair
#define mktp make_tuple
#define tv(tp, i) get<(i)>(tp)
#define CLEAR(obj... | [
"assignment.change"
] | 972,909 | 972,910 | u404244809 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
vector<vector<int>> dp(s.size() + 1, vector<int>(t.size() + 1));
dp.at(0).at(0) = 0;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < t.size(); j++) {
dp.at(i + 1).at(j + 1) = max(dp.at(i + 1).at(j + 1), ... | #include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
vector<vector<int>> dp(s.size() + 1, vector<int>(t.size() + 1));
dp.at(0).at(0) = 0;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < t.size(); j++) {
dp.at(i + 1).at(j + 1) = max(dp.at(i + 1).at(j + 1), ... | [
"assignment.value.change",
"assignment.change"
] | 972,944 | 972,945 | u718758485 | cpp |
p03165 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define gcd __gcd
#define all(a) a.begin(), a.end()
#define sz(a) (ll)(a.size())... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define gcd __gcd
#define all(a) a.begin(), a.end()
#define sz(a) (ll)(a.size())... | [
"expression.operation.binary.remove",
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 972,979 | 972,980 | u616547520 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.