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 |
|---|---|---|---|---|---|---|---|
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, k, n) for (int i = (k); i < (n); ++i)
int main() {
int N;
cin >> N;
vector<ll> a(N);
REP(i, N) cin >> a[i];
vector<vector<ll>> dp(N, vector<ll>(N, 0LL))... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, k, n) for (int i = (k); i < (n); ++i)
int main() {
int N;
cin >> N;
vector<ll> a(N);
REP(i, N) cin >> a[i];
vector<vector<ll>> dp(N, vector<ll>(N, 0LL))... | [
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 979,867 | 979,868 | u434282696 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
#define FASTIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll lo... | #include <bits/stdc++.h>
using namespace std;
#define FASTIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll lo... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 979,871 | 979,872 | u029634979 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 3005;
int a[maxn], dp[maxn][maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int l = n - 1; l >= 0; l--) {
for (int r = l; r < n; r++) {
if (r == l)
dp[l][r] = a[l];
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 3005;
ll a[maxn], dp[maxn][maxn];
int main() {
ll n;
cin >> n;
for (ll i = 0; i < n; i++)
cin >> a[i];
for (ll l = n - 1; l >= 0; l--) {
for (ll r = l; r < n; r++) {
if (r == l)
dp[l][r] = a[l];
else... | [
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change"
] | 979,877 | 979,878 | u943208163 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
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... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
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... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"function.return_value.change"
] | 979,883 | 979,884 | u052332717 | cpp |
p03169 | #include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
int N;
cin >> N;
static int c[3];
for (int i = 0, t; i < N; ++i) {
cin >> t;
++c[t - 1];
}
static float dp[301][601][901];
/*function<double(int, int, int)> dfs = [&](int a, int b, int c) {
if (a +... | #include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
int N;
cin >> N;
static int c[3];
for (int i = 0, t; i < N; ++i) {
cin >> t;
++c[t - 1];
}
static double dp[301][301][301];
/*function<double(int, int, int)> dfs = [&](int a, int b, int c) {
if (a ... | [
"variable_declaration.type.primitive.change",
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 979,888 | 979,889 | u209551477 | cpp |
p03169 | #include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
int N;
cin >> N;
static int c[3];
for (int i = 0, t; i < N; ++i) {
cin >> t;
++c[t - 1];
}
static double dp[301][601][901];
/*function<double(int, int, int)> dfs = [&](int a, int b, int c) {
if (a ... | #include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
int N;
cin >> N;
static int c[3];
for (int i = 0, t; i < N; ++i) {
cin >> t;
++c[t - 1];
}
static double dp[301][301][301];
/*function<double(int, int, int)> dfs = [&](int a, int b, int c) {
if (a ... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 979,890 | 979,889 | u209551477 | cpp |
p03169 | #include <bits/stdc++.h>
#define MAXN 310
#define pii pair<int, int>
#define pb push_back
typedef long long ll;
using namespace std;
int n, f[4];
double dp[MAXN][MAXN][MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
f[t... | #include <bits/stdc++.h>
#define MAXN 310
#define pii pair<int, int>
#define pb push_back
typedef long long ll;
using namespace std;
int n, f[4];
double dp[MAXN][MAXN][MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
f[t... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 979,895 | 979,896 | u190314045 | cpp |
p03169 | #include "bits/stdc++.h"
using namespace std;
// typedef pair<int, int> P;
#define int long long
#define ll long long
#define mod 1000000007
#define INF (1LL << 60)
int N, c[4];
double dp[301][301][301];
double solve(int c1, int c2, int c3) {
if (c1 == 0 && c2 == 0 && c3 == 0)
return 0.0;
if (dp[c1][c2][c3... | #include "bits/stdc++.h"
using namespace std;
// typedef pair<int, int> P;
#define int long long
#define ll long long
#define mod 1000000007
#define INF (1LL << 60)
int N, c[4];
double dp[301][301][301];
double solve(int c1, int c2, int c3) {
if (c1 == 0 && c2 == 0 && c3 == 0)
return 0.0;
if (dp[c1][c2][c3... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 979,914 | 979,915 | u592610268 | cpp |
p03169 | #include <bits/stdc++.h>
const int MN = 304;
int N, A[4];
double dp[MN][MN][MN];
double solve(int s1, int s2, int s3) {
if (!s1 && !s2 && !s3)
return 0;
if (dp[s1][s2][s3] >= 0.0)
return dp[s1][s2][s3];
double ret = 1.0;
if (s1)
ret += solve(s1 - 1, s2, s3) * s1 / N;
if (s2)
ret += solve(s1 + ... | #include <bits/stdc++.h>
const int MN = 304;
int N, A[4];
double dp[MN][MN][MN];
double solve(int s1, int s2, int s3) {
if (!s1 && !s2 && !s3)
return 0;
if (dp[s1][s2][s3] >= 0.0)
return dp[s1][s2][s3];
double ret = 1.0;
if (s1)
ret += solve(s1 - 1, s2, s3) * s1 / N;
if (s2)
ret += solve(s1 + ... | [
"assignment.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 979,922 | 979,921 | u596743351 | cpp |
p03169 | #include <bits/stdc++.h>
using namespace std;
const int N = 3e2 + 5;
double f[N][N][N];
int main() {
int n;
cin >> n;
auto h = vector<int>(3, 0);
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
h[x - 1]++;
}
for (int u3 = 0; u3 <= n; u3++)
for (int u2 = 0; u2 <= n; u2++)
for (int u1... | #include <bits/stdc++.h>
using namespace std;
const int N = 3e2 + 5;
double f[N][N][N];
int main() {
int n;
cin >> n;
auto h = vector<int>(3, 0);
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
h[x - 1]++;
}
for (int u3 = 0; u3 <= n; u3++)
for (int u2 = 0; u2 <= n; u2++)
for (int u1... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 979,940 | 979,941 | u596976719 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
#define print printf("==================\n")
#define ll long long
#define pi acos(-1.0)
#define eps 1e-16
#define max3(a, b, c) max(a, max(b, c))
const ll INF = 1 << 30;
#define mod 1000000007
typedef pair<double, double> payar;
typedef struct {
ll x, y;
} point;
priority... | #include <bits/stdc++.h>
using namespace std;
#define print printf("==================\n")
#define ll long long
#define pi acos(-1.0)
#define eps 1e-16
#define max3(a, b, c) max(a, max(b, c))
const ll INF = 1 << 30;
#define mod 1000000007
typedef pair<double, double> payar;
typedef struct {
ll x, y;
} point;
priority... | [] | 979,951 | 979,952 | u826108161 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 15;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// freopen("input.txt", "r", stdin);
int n;
cin >> n;
deque<long long> q;
for (int i = 0; i < n; ++i) {
i... | #include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 15;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// freopen("input.txt", "r", stdin);
int n;
cin >> n;
deque<long long> q;
for (int i = 0; i < n; ++i) {
i... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 979,960 | 979,961 | u784576081 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
int vals[N];
for (int i = 0; i < N; ++i) {
cin >> vals[i];
}
int DP[N][N]; // DP[i][j] = X-Y if vals[i..j] remains.
for (int i = 0; i < N; ++i) {
DP[i][i] = vals[i]... | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
int vals[N];
for (int i = 0; i < N; ++i) {
cin >> vals[i];
}
long long DP[N][N]; // DP[i][j] = X-Y if vals[i..j] remains.
for (int i = 0; i < N; ++i) {
DP[i][i] = v... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 979,962 | 979,963 | u702346849 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
long long f[3001][3001];
int a[3001];
int main() {
int i, j, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (n % 2 == 0)
f[i][i] = a[i];
else
f[i][i] = -a[i];
}
for (j = 1; j < n; j++) {
for (i = 1; i + j <= n; i+... | #include <bits/stdc++.h>
using namespace std;
long long f[3001][3001];
int a[3001];
int main() {
int i, j, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (n % 2 == 0)
f[i][i] = -a[i];
else
f[i][i] = a[i];
}
for (j = 1; j < n; j++) {
for (i = 1; i + j <= n; i+... | [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"assignment.add"
] | 979,966 | 979,967 | u356929542 | cpp |
p03171 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
const l... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = (... | [
"variable_declaration.type.narrow.change",
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 979,968 | 979,969 | u694083533 | cpp |
p03171 | #include <algorithm>
#include <cstdio>
using namespace std;
#define i64 long long int
#define ran 3033
int n;
int a[ran];
i64 f[ran][ran];
bool visd[ran][ran];
i64 dp(int l, int r) {
if (l > r || visd[l][r])
return f[l][r];
i64 t = 0;
if ((r - l) % 2 == (n - 1) % 2)
t = max(dp(l + 1, r) + a[l], dp(l, ... | #include <algorithm>
#include <cstdio>
using namespace std;
#define i64 long long int
#define ran 3033
int n;
int a[ran];
i64 f[ran][ran];
bool visd[ran][ran];
i64 dp(int l, int r) {
if (l > r || visd[l][r])
return f[l][r];
i64 t = 0;
if ((r - l) % 2 == (n - 1) % 2)
t = max(dp(l + 1, r) + a[l], dp(l, ... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 979,970 | 979,971 | u534772498 | cpp |
p03171 | // In the Name of Allah. Ya Ali!
#include <bits/stdc++.h>
typedef long long ll;
const ll MAX_N = 3000 + 5;
const ll MOD = 1e9 + 7;
using namespace std;
int dp[MAX_N][MAX_N][2];
int a[MAX_N];
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> a[i];
for (int i = 1; i <= n; ++i)
dp[1][i][0] ... | // In the Name of Allah. Ya Ali!
#include <bits/stdc++.h>
typedef long long ll;
const ll MAX_N = 3000 + 5;
const ll MOD = 1e9 + 7;
using namespace std;
ll dp[MAX_N][MAX_N][2];
ll a[MAX_N];
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> a[i];
for (int i = 1; i <= n; ++i)
dp[1][i][0] = ... | [
"variable_declaration.type.change"
] | 979,972 | 979,973 | u509226403 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define forup(i, a, b) for (int i = (a); i < (b); ++i)
#define fordn(i, a, b) for (int i = (a); i > (b); --i)
#define rep(i, a) for (int i = 0; i < (a); ++i)
#define gi(x) scanf("%d", &x)
#define gl(x) cin >> x
#define gd... | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define forup(i, a, b) for (int i = (a); i < (b); ++i)
#define fordn(i, a, b) for (int i = (a); i > (b); --i)
#define rep(i, a) for (int i = 0; i < (a); ++i)
#define gi(x) scanf("%d", &x)
#define gl(x) cin >> x
#define gd... | [
"control_flow.branch.if.condition.change"
] | 979,976 | 979,977 | u561426248 | cpp |
p03171 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <stdio.h>
using namespace std;
long long dp1[3000][3000];
long long dp2[3000][3000];
long long a[3000];
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
for (int i = 0; i ... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <stdio.h>
using namespace std;
long long dp1[3000][3000];
long long dp2[3000][3000];
long long a[3000];
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
for (int i = 0; i ... | [
"expression.operation.unary.add"
] | 979,985 | 979,986 | u623349537 | cpp |
p03171 | #include <algorithm>
#include <cstdio>
using namespace std;
const int MAXN = 3 * 1e3 + 5;
int n;
long long a[MAXN];
long long z;
void read_input() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
z += a[i];
}
}
pair<long long, long long> T[MAXN][MAXN][2];
pair<long long, long ... | #include <algorithm>
#include <cstdio>
using namespace std;
const int MAXN = 3 * 1e3 + 5;
int n;
long long a[MAXN];
long long z;
void read_input() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
z += a[i];
}
}
pair<long long, long long> T[MAXN][MAXN][2];
pair<long long, long ... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 979,988 | 979,989 | u666461127 | cpp |
p03171 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace ... | [
"variable_declaration.type.change"
] | 979,994 | 979,995 | u406158207 | cpp |
p03171 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace ... | [
"variable_declaration.type.change"
] | 979,996 | 979,995 | u406158207 | cpp |
p03171 | #include "bits/stdc++.h"
using namespace std;
/* macro */
#define rep(i, a, b) for (int i = a; i < b; i++)
#define revrep(i, a, b) for (int i = a; i > b; i--)
#define int long long
#define exist(s, e) ((s).find(e) != (s).end())
#define all(v) (v).begin(), (v).end()
#define each(s, itr) for (auto(itr) = s.begin(); (itr... | #include "bits/stdc++.h"
using namespace std;
/* macro */
#define rep(i, a, b) for (int i = a; i < b; i++)
#define revrep(i, a, b) for (int i = a; i > b; i--)
#define int long long
#define exist(s, e) ((s).find(e) != (s).end())
#define all(v) (v).begin(), (v).end()
#define each(s, itr) for (auto(itr) = s.begin(); (itr... | [
"control_flow.branch.if.condition.change"
] | 979,997 | 979,998 | u828847847 | cpp |
p03171 | /*input
4
10 80 90 30
*/
#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 tree<long long, null_type, less<long long>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#pragma GCC o... | /*input
4
10 80 90 30
*/
#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 tree<long long, null_type, less<long long>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#pragma GCC o... | [
"variable_declaration.type.change"
] | 980,005 | 980,006 | u110464018 | cpp |
p03171 | /*input
4
10 80 90 30
*/
#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 tree<long long, null_type, less<long long>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#pragma GCC o... | /*input
4
10 80 90 30
*/
#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 tree<long long, null_type, less<long long>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#pragma GCC o... | [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 980,007 | 980,006 | u110464018 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll solve(vector<int> &dq, int st, int end, vector<vector<ll>> &dp) {
if (st > end)
return 0;
if (dp[st][end] != -1)
return dp[st][end];
// dp[st][end] = max(max(solve(dq, st+1, end-1, dp), solve(dq, st+2, end, dp))
// + dq[st], max(so... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll solve(vector<int> &dq, int st, int end, vector<vector<ll>> &dp) {
if (st > end)
return 0;
if (dp[st][end] != -1)
return dp[st][end];
// dp[st][end] = max(max(solve(dq, st+1, end-1, dp), solve(dq, st+2, end, dp))
// + dq[st], max(so... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 980,008 | 980,009 | u662651036 | cpp |
p03171 | #include <algorithm>
#include <cstdio>
using namespace std;
int n, a[3005], dp[3005][3005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dp[i][i] = a[i];
}
for (int i = n; i >= 1; i--) {
for (int j = i + 1; j <= n; j++) {
dp[i][j] = max(a[i] - dp[i + 1][j], ... | #include <algorithm>
#include <cstdio>
using namespace std;
long long n, a[3005], dp[3005][3005];
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
dp[i][i] = a[i];
}
for (int i = n; i >= 1; i--) {
for (int j = i + 1; j <= n; j++) {
dp[i][j] = max(a[i] - dp[i... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 980,013 | 980,014 | u287687156 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
struct point {
int first, second;
};
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
// DP[i][j] gives maximum value chhosen by player A and B
// if()subarray{i.....j] isconsidered;
point dp[n][n];
for (int i ... | #include <bits/stdc++.h>
using namespace std;
struct point {
long long int first, second;
};
int main() {
int n;
cin >> n;
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
// DP[i][j] gives maximum value chhosen by player A and B
// if()subarray{i.....j] isconsidered;
point dp[... | [
"variable_declaration.type.widen.change"
] | 980,015 | 980,016 | u356853948 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
int dfs(int l, int r, vector<long long int> &v,
vector<vector<long long int>> &dp) {
if (l == r)
return v[l];
if (dp[l][r] != INT_MAX)
return dp[l][r];
return dp[l][r] =
max(v[l] - dfs(l + 1, r, v, dp), v[r] - dfs(l, r - 1, v, dp));
}
int ... | #include <bits/stdc++.h>
using namespace std;
long long int dfs(int l, int r, vector<long long int> &v,
vector<vector<long long int>> &dp) {
if (l == r)
return v[l];
if (dp[l][r] != INT_MAX)
return dp[l][r];
return dp[l][r] =
max(v[l] - dfs(l + 1, r, v, dp), v[r] - dfs(l, r ... | [
"variable_declaration.type.widen.change"
] | 980,021 | 980,022 | u719635221 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, n) for (long long i = 0; i < n; ++i)
#define REPP(i, m, n) for (long long i = m; i < n; ++i)
#define rep(i, n) for (long long i = n - 1; i >= 0; --i)
#define repp(i, n, m) for (long long i = n - 1; i >= m; --i)
#define ALL(N) (N.begin(), ... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, n) for (long long i = 0; i < n; ++i)
#define REPP(i, m, n) for (long long i = m; i < n; ++i)
#define rep(i, n) for (long long i = n - 1; i >= 0; --i)
#define repp(i, n, m) for (long long i = n - 1; i >= m; --i)
#define ALL(N) (N.begin(), ... | [] | 980,023 | 980,024 | u901397311 | cpp |
p03171 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
string to_... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
string to_... | [] | 980,032 | 980,033 | u520002141 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
// dp[i] first player winns if its true stones left
int dp[3005][3005];
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int r = 0, l = n - 1;
for (l = n - 1; l >= 0; --l) {
for (r = l; r < n; ++r) {
if (l ==... | #include <bits/stdc++.h>
using namespace std;
// dp[i] first player winns if its true stones left
long long int dp[3005][3005];
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int r = 0, l = n - 1;
for (l = n - 1; l >= 0; --l) {
for (r = l; r < n; ++r) {
... | [
"variable_declaration.type.widen.change"
] | 980,034 | 980,035 | u796511558 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
// dp[i] first player winns if its true stones left
int dp[3005][3005];
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int r = 0, l = n - 1;
for (l = n - 1; l >= 0; l--) {
for (r = l; r < n; r++) {
if (l ==... | #include <bits/stdc++.h>
using namespace std;
// dp[i] first player winns if its true stones left
long long int dp[3005][3005];
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int r = 0, l = n - 1;
for (l = n - 1; l >= 0; --l) {
for (r = l; r < n; ++r) {
... | [
"variable_declaration.type.widen.change"
] | 980,036 | 980,035 | u796511558 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define pb(x) push_back(x)
#define ce(x) cout << x << endl;
using db = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define scl1(a) scanf("%lld", &a)
#define scl2(a, b) scanf("%lld %lld", &a, &b)
#define rep(i, x,... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define pb(x) push_back(x)
#define ce(x) cout << x << endl;
using db = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define scl1(a) scanf("%lld", &a)
#define scl2(a, b) scanf("%lld %lld", &a, &b)
#define rep(i, x,... | [] | 980,037 | 980,038 | u933735545 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define pb(x) push_back(x)
#define ce(x) cout << x << endl;
using db = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define scl1(a) scanf("%lld", &a)
#define scl2(a, b) scanf("%lld %lld", &a, &b)
#define rep(i, x,... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define pb(x) push_back(x)
#define ce(x) cout << x << endl;
using db = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define scl1(a) scanf("%lld", &a)
#define scl2(a, b) scanf("%lld %lld", &a, &b)
#define rep(i, x,... | [
"variable_declaration.type.change"
] | 980,039 | 980,038 | u933735545 | cpp |
p03171 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using vl = vector<ll>;
using vll = vector<vl>;
//**関数... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using vl = vector<ll>;
using vll = vector<vl>;
//**関数... | [
"literal.number.change",
"assignment.value.change"
] | 980,040 | 980,041 | u916974091 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
pair<int, int> dp[n][n];
for (int i = 0; i < n; i++) {
dp[i][i].first = arr[i];
dp[i][i].second = 0;
}
for (int k = 1; k < n; k++) {
for (int i = 0; i... | #include <bits/stdc++.h>
using namespace std;
#define int long long int
signed main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
pair<int, int> dp[n][n];
for (int i = 0; i < n; i++) {
dp[i][i].first = arr[i];
dp[i][i].second = 0;
}
for (int k = 1; k < n;... | [
"variable_declaration.type.widen.change"
] | 980,043 | 980,044 | u100071032 | cpp |
p03171 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <stdio.h>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
typedef pair<int, int> pii;
#define MOD 1000000007
#define MOD1 998244353
#define ff first
#define ss second
#define bn cout << ... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <stdio.h>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
typedef pair<int, int> pii;
#define MOD 1000000007
#define MOD1 998244353
#define ff first
#define ss second
#define bn cout << ... | [
"identifier.change",
"call.function.change",
"call.arguments.change",
"call.arguments.add"
] | 980,045 | 980,046 | u351310875 | cpp |
p03171 | #pragma GCC optimize("03")
#include <bits/stdc++.h>
#define int int64_t
using namespace std;
int n, temp;
deque<int> q;
int32_t main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> temp;
q.push_back(temp);
if (q.size() > 2 and q.back() >= q[q.... | #pragma GCC optimize("03")
#include <bits/stdc++.h>
#define int int64_t
using namespace std;
int n, temp;
deque<int> q;
int32_t main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> temp;
q.push_back(temp);
while (q.size() > 2 and q.back() <= q... | [
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 980,049 | 980,048 | u127754559 | cpp |
p03171 | #include <bits/stdc++.h>
#ifdef _DEBUG
#define debug(x) \
cout << "line: " << __LINE__ << ", func: " << __func__ << " -> " << #x \
<< " = " << x << endl
#define INFILE freopen("input.txt", "r", stdin)
#else
#define debug(x)
#define INFILE
#en... | #include <bits/stdc++.h>
#ifdef _DEBUG
#define debug(x) \
cout << "line: " << __LINE__ << ", func: " << __func__ << " -> " << #x \
<< " = " << x << endl
#define INFILE freopen("input.txt", "r", stdin)
#else
#define debug(x)
#define INFILE
#en... | [
"expression.operation.binary.add"
] | 980,052 | 980,053 | u209647862 | cpp |
p03171 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll dp[3010][3010];
ll a[3010];
int solve(int i, int j) {
if (i > j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
return dp[i][j] = max(a[i] - solve(i + 1, j), a[j] - solve(i, j - 1));
}
int main() {
int n;
cin >> n;
memset(dp, -1,... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll dp[3010][3010];
ll a[3010];
ll solve(int i, int j) {
if (i > j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
return dp[i][j] = max(a[i] - solve(i + 1, j), a[j] - solve(i, j - 1));
}
int main() {
int n;
cin >> n;
memset(dp, -1, ... | [] | 980,054 | 980,055 | u565814877 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
#define _USE_MATH_DEFINES
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// DON'T USE THES... | #include <bits/stdc++.h>
using namespace std;
#define _USE_MATH_DEFINES
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// DON'T USE THES... | [
"variable_declaration.type.change"
] | 980,066 | 980,067 | u645327277 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < n; i++)
#define forn1(i, n) for (int i = 1; i <= n; i++)
#define loop(i, sta, end, inc) for (int i = sta; i <= end; i += inc)
#define itr(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define in(a, b, c) assert(b <= a && a <= c... | #include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < n; i++)
#define forn1(i, n) for (int i = 1; i <= n; i++)
#define loop(i, sta, end, inc) for (int i = sta; i <= end; i += inc)
#define itr(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define in(a, b, c) assert(b <= a && a <= c... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 980,068 | 980,069 | u858856811 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> dp(n, vector<int>(n, 0));
int sum = 0;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
sum += temp;
dp[i][i] = temp;
}
for (int i = 1; i <= n - 1; i++) {
for (int j = 0; i + j < n; j++... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<long>> dp(n, vector<long>(n, 0));
long long sum = 0;
for (int i = 0; i < n; i++) {
long long temp;
cin >> temp;
sum += temp;
dp[i][i] = temp;
}
for (int i = 1; i <= n - 1; i++) {
for (int j = 0; ... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 980,074 | 980,075 | u388587443 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
signed main() {
int n;
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int dp[n + 1][n + 1] = {};
for (int i = n; i >= 1; --i) {
dp[i][i] = a[i];
for (int j = i + 1; j <= n; ++j) {
dp[j][i] = max(a[i] - dp[j][i + 1], ... | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int n;
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int dp[n + 1][n + 1] = {};
for (int i = n; i >= 1; --i) {
dp[i][i] = a[i];
for (int j = i + 1; j <= n; ++j) {
dp[j][i] = max... | [] | 980,076 | 980,077 | u193815565 | cpp |
p03171 | #include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int n;
vector<int> a;
int dp[3010][3010];
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int len = 1; len <= n; ++len) {
for (int i = 0; i + len <= n; ++i) {
int j = i + len;
if (... | #include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int n;
vector<long long> a;
long long dp[3010][3010];
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int len = 1; len <= n; ++len) {
for (int i = 0; i + len <= n; ++i) {
int j = i + len... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 980,078 | 980,079 | u899866702 | cpp |
p03171 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long int
#define INF (2147483647)
#define mod (1000000007)
vector<vector<int>> dp;
vector<vector<bool>> ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long int
#define INF (2147483647)
#define mod (1000000007)
vector<vector<ll>> dp;
vector<vector<bool>> f... | [
"variable_declaration.type.change",
"call.arguments.change"
] | 980,080 | 980,081 | u333945892 | cpp |
p03171 | #include <bits/stdc++.h>
#define ll long long
#define dl double
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define mod 1000000007
#define P(a, b) pair<a, b>
#define CIN(V, s, n) ... | #include <bits/stdc++.h>
#define ll long long
#define dl double
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define mod 1000000007
#define P(a, b) pair<a, b>
#define CIN(V, s, n) ... | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.change"
] | 980,084 | 980,085 | u121266738 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 3100;
struct elem {
long long int first;
long long int second;
};
elem dp[MAXN][MAXN];
long long int A[MAXN];
int N;
void calcDP() {
for (int i = 0; i < N; i++)
dp[i][i].first = A[i];
for (int offset = 1; offset < N; offset++) {
for (int... | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 3100;
struct elem {
long long int first;
long long int second;
};
elem dp[MAXN][MAXN];
long long int A[MAXN];
int N;
void calcDP() {
for (int i = 0; i < N; i++)
dp[i][i].first = A[i];
for (int offset = 1; offset < N; offset++) {
for (int... | [
"expression.operation.binary.remove"
] | 980,086 | 980,087 | u059331720 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int main() {
lli n;
cin >> n;
vector<lli> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
vector<vector<int>> dp(n, vector<int>(n));
for (int l = n - 1; l >= 0; l--) {
for (int r = l; r < n; r++) {
if (l == r) {
d... | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int main() {
// freopen("input.txt","r",stdin);
lli n;
cin >> n;
vector<lli> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
vector<vector<lli>> dp(n, vector<lli>(n));
for (int l = n - 1; l >= 0; l--) {
for (int r = l; r < n; ... | [] | 980,094 | 980,095 | u798858168 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &i : v)
is >> i;
return is;
}
templ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &i : v)
is >> i;
return is;
}
templ... | [
"call.arguments.change"
] | 980,102 | 980,103 | u171804186 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
#define ops cout << "ops" << endl;
#define freopens \
freopen("cowpatibility.in", "r", stdin); \
freopen("cowpatibility.out", "w", stdout);
#define fast ... | #include <bits/stdc++.h>
using namespace std;
#define ops cout << "ops" << endl;
#define freopens \
freopen("cowpatibility.in", "r", stdin); \
freopen("cowpatibility.out", "w", stdout);
#define fast ... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 980,106 | 980,107 | u113008684 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int lim = 3e3 + 7;
const int inf = 1e9 + 9;
int dp[lim][lim][2];
vector<int> a;
int solve(int i, int j, int t) {
if (i > j)
return 0;
if (dp[i][j][t] != -1)
return dp[i][j][t];
if (t) {
dp[i][j][1] = max(a[i] + solve(i + 1, ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int lim = 3e3 + 7;
const int inf = 1e9 + 9;
ll dp[lim][lim][2];
vector<int> a;
ll solve(int i, int j, int t) {
if (i > j)
return 0;
if (dp[i][j][t] != -1)
return dp[i][j][t];
if (t) {
dp[i][j][1] = max(a[i] + solve(i + 1, j,... | [
"variable_declaration.type.change"
] | 980,108 | 980,109 | u515056330 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int dp[3001][3001];
int a[3001];
ll fun(int i, int j, bool flag) {
if (i == j) {
if (flag)
return a[i];
else
return -a[i];
}
if (dp[i][j] != -1)
return dp[i][j];
if (flag)
return dp[i][j] =
max(a[i] +... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[3001][3001];
ll a[3001];
ll fun(int i, int j, bool flag) {
if (i == j) {
if (flag)
return a[i];
else
return -a[i];
}
if (dp[i][j] != -1)
return dp[i][j];
if (flag)
return dp[i][j] =
max(a[i] + f... | [
"variable_declaration.type.change"
] | 980,110 | 980,111 | u003481187 | cpp |
p03171 | #include <cmath>
#include <fstream>
#include <iostream>
using namespace std;
ifstream fin("file.in");
ofstream fout("file.out");
long long int nrnr, sum;
int vec[3005];
long long int ras[3005][3005];
int main() {
fin >> nrnr;
for (int index = 0; index < nrnr; index++) {
fin >> vec[index];
}
for (int in... | #include <cmath>
#include <fstream>
#include <iostream>
using namespace std;
ifstream fin("file.in");
ofstream fout("file.out");
long long int nrnr, sum;
int vec[3005];
long long int ras[3005][3005];
int main() {
cin >> nrnr;
for (int index = 0; index < nrnr; index++) {
cin >> vec[index];
}
for (int in... | [
"identifier.change",
"expression.operation.binary.change",
"io.output.change"
] | 980,113 | 980,114 | u147403872 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
long long dp[3010][3010];
int a[3010];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[i][i] = a[i];
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i + len - 1 < n; i++) {
int j = i + len - 1;
dp[i][... | #include <bits/stdc++.h>
using namespace std;
long long dp[3010][3010];
int a[3010];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[i][i] = a[i];
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i + len - 1 < n; i++) {
int j = i + len - 1;
dp[i][... | [
"expression.operation.unary.arithmetic.remove"
] | 980,115 | 980,116 | u183606119 | cpp |
p03171 | #include <bits/stdc++.h>
const int N = 3005;
int n, a[N], dp[N][N][2];
bool calc[N][N][2];
long long f(int l, int r, bool ply) {
if (calc[l][r][ply])
return dp[l][r][ply];
calc[l][r][ply] = true;
if (l == r)
return dp[l][r][ply] = (ply ? -a[l] : a[l]);
long long x = f(l + 1, r, !ply) + (ply ? -a[l]... | #include <bits/stdc++.h>
const int N = 3005;
int n, a[N];
long long dp[N][N][2];
bool calc[N][N][2];
long long f(int l, int r, bool ply) {
if (calc[l][r][ply])
return dp[l][r][ply];
calc[l][r][ply] = true;
if (l == r)
return dp[l][r][ply] = (ply ? -a[l] : a[l]);
long long x = f(l + 1, r, !ply) + (p... | [
"function.return_value.change"
] | 980,119 | 980,120 | u030489681 | cpp |
p03171 | /*
*#*#*#* Author GaryMr *#*#*#*
########################################################################
是否可以简化问题：
抓住数据范围哪里小
dfs or bfs
是否可以化具体为抽象
字符串问题是否可以用数学模拟递归过程（取c[i]或不取来算结果）
二分？左闭右开？
long long？
逆向思维？
dp？
贪心？
树的直径:随便找一... | /*
*#*#*#* Author GaryMr *#*#*#*
########################################################################
是否可以简化问题：
抓住数据范围哪里小
dfs or bfs
是否可以化具体为抽象
字符串问题是否可以用数学模拟递归过程（取c[i]或不取来算结果）
二分？左闭右开？
long long？
逆向思维？
dp？
贪心？
树的直径:随便找一... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 980,123 | 980,124 | u751730221 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
int n, a[10005], f[3005][3005];
int F(int i, int j) {
if (f[i][j] != -1)
return f[i][j];
else if (i > j) {
return 0;
} else {
int res;
if ((i - 1 + n - j) % 2 == 0) {
res = max(F(i + 1, j) + a[i], F(i, j - 1) + a[j]);
} else {
res = mi... | #include <bits/stdc++.h>
using namespace std;
#define int long long
int n, a[10005], f[3005][3005];
int F(int i, int j) {
if (f[i][j] != -1)
return f[i][j];
else if (i > j) {
return 0;
} else {
int res;
if ((i - 1 + n - j) % 2 == 0) {
res = max(F(i + 1, j) + a[i], F(i, j - 1) + a[j]);
}... | [] | 980,127 | 980,128 | u818354373 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int &i : a)
cin >> i;
vector<vector<int>> f(n, vector<int>(n, 0));
for (int i = 0; i < n; i++)
if (n & 1)
f[i][i] = a[i];
else
f[i][i] = -a[i];
for (int i = 2; i <= n; i++) {
for ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int &i : a)
cin >> i;
vector<vector<long long>> f(n, vector<long long>(n, 0));
for (int i = 0; i < n; i++)
if (n & 1)
f[i][i] = a[i];
else
f[i][i] = -a[i];
for (int i = 2; i <= n; i++... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 980,129 | 980,130 | u251828455 | cpp |
p03171 | // L - Deque https://atcoder.jp/contests/dp/tasks/dp_l
/* 入力例
4
10 80 90 30
// →出力 10
*/
#include <bits/stdc++.h>
using namespace std;
int N;
int a[4];
long long int mem[4][4];
int memflag[4][4];
long long int dp(int l, int r) {
if (memflag[l][r] == 1) {
return mem[l][r];
} else if (l == r) {
mem[l][r] =... | // L - Deque https://atcoder.jp/contests/dp/tasks/dp_l
/* 入力例
4
10 80 90 30
// →出力 10
*/
#include <bits/stdc++.h>
using namespace std;
int N;
int a[3000];
long long int mem[3000][3000];
int memflag[3000][3000];
long long int dp(int l, int r) {
if (memflag[l][r] == 1) {
return mem[l][r];
} else if (l == r) {
... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 980,131 | 980,132 | u721871635 | cpp |
p03171 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
int main() {
ll N;
cin >> N;
ll value[N];
ll dp[N][N];
for (ll i = 0; i < N; i++) {
cin >> value[i];
dp[i][i] = value[i];
}
for (ll len = 2; len <= N; len++) {
for (ll i = 0; i <= N - len; i++) {
dp... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
int main() {
ll N;
cin >> N;
ll value[N];
ll dp[N][N];
for (ll i = 0; i < N; i++) {
cin >> value[i];
dp[i][i] = value[i];
}
for (ll len = 2; len <= N; len++) {
for (ll i = 0; i <= N - len; i++) {
dp... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"io.output.change",
"expression.operation.binary.remove"
] | 980,133 | 980,134 | u771978844 | cpp |
p03171 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
int main() {
ll N;
cin >> N;
ll value[N];
ll dp[N][N];
for (ll i = 0; i < N; i++) {
cin >> value[i];
dp[i][i] = value[i];
}
for (ll len = 2; len <= N; len++) {
for (ll i = 0; i <= N - len; i++) {
dp... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
int main() {
ll N;
cin >> N;
ll value[N];
ll dp[N][N];
for (ll i = 0; i < N; i++) {
cin >> value[i];
dp[i][i] = value[i];
}
for (ll len = 2; len <= N; len++) {
for (ll i = 0; i <= N - len; i++) {
dp... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"io.output.change"
] | 980,135 | 980,134 | u771978844 | cpp |
p03171 | #include <bits/stdc++.h>
#define inf (1ll << 62)
using namespace std;
const int maxn = 3005;
typedef long long ll;
int A[maxn];
ll memo[maxn][maxn][2];
int solve(int i, int j, bool flag) {
if (i == j) {
if (flag)
return -A[i];
else
return A[i];
}
ll &ans = memo[i][j][flag];
if (ans != -inf)
... | #include <bits/stdc++.h>
#define inf (1ll << 62)
using namespace std;
const int maxn = 3005;
typedef long long ll;
int A[maxn];
ll memo[maxn][maxn][2];
ll solve(int i, int j, bool flag) {
if (i == j) {
if (flag)
return -A[i];
else
return A[i];
}
ll &ans = memo[i][j][flag];
if (ans != -inf)
... | [
"variable_declaration.type.change"
] | 980,136 | 980,137 | u303586394 | cpp |
p03171 | #include <bits/stdc++.h>
#pragma GCC optimuze("Ofast")
#pragma GCC optimuze("03")
#pragma GCC optimuze("unroll-loops")
#define F first
#define S second
#define pb push_back
#define llong long long
#define ld long double
#define int llong
#define endl '\n'
using namespace std;
const int N = 3e3 + 5;
const int M = 2e... | #include <bits/stdc++.h>
#pragma GCC optimuze("Ofast")
#pragma GCC optimuze("03")
#pragma GCC optimuze("unroll-loops")
#define F first
#define S second
#define pb push_back
#define llong long long
#define ld long double
#define int llong
#define endl '\n'
using namespace std;
const int N = 3e3 + 5;
const int M = 2e... | [
"expression.operation.unary.add",
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change",
"expression.operation.binary.remove"
] | 980,140 | 980,141 | u318879716 | cpp |
p03171 | #include <bits/stdc++.h>
#define rep(i, k, n) for (int i = k; i <= n; i++)
#define per(i, n, k) for (int i = n; i >= k; i--)
#define pb push_back
#define pii pair<int, int>
#define fi first
#define se second
#define mp make_pair
#define ll long long
using namespace std;
const int maxn = 3005;
int f[maxn][maxn], a[maxn]... | #include <bits/stdc++.h>
#define rep(i, k, n) for (int i = k; i <= n; i++)
#define per(i, n, k) for (int i = n; i >= k; i--)
#define pb push_back
#define pii pair<int, int>
#define fi first
#define se second
#define mp make_pair
#define ll long long
using namespace std;
const int maxn = 3005;
ll f[maxn][maxn], a[maxn],... | [
"variable_declaration.type.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 980,142 | 980,143 | u052685836 | cpp |
p03171 | #include <bits/stdc++.h>
#include <iostream>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long l... | #include <bits/stdc++.h>
#include <iostream>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long l... | [
"variable_declaration.type.change"
] | 980,150 | 980,151 | u752814744 | cpp |
p03171 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
#define ll long long
#define pb push_back
#define sz(x) (int)(x).size()
#define mp make_pair
#define all(x) x.begin(), x.end()
using namespace std;
int main() {
int n;
cin >> n;
vec... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
#define ll long long
#define pb push_back
#define sz(x) (int)(x).size()
#define mp make_pair
#define all(x) x.begin(), x.end()
using namespace std;
int main() {
int n;
cin >> n;
vec... | [
"variable_declaration.type.change"
] | 980,156 | 980,157 | u013064880 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define vi vector<int>
#define pb push_back
#define pii pair<int, int>
#define fast ios_base::sync_with_stdio(0)
#define mx 3002
ll arr[mx], dp[mx][mx][2];
int n;
ll fun(int b, int e, int turn) {
turn %= 2;
if (b > e)
return 0;
ll &ret = dp[b]... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define vi vector<int>
#define pb push_back
#define pii pair<int, int>
#define fast ios_base::sync_with_stdio(0)
#define mx 3002
ll arr[mx], dp[mx][mx][2];
int n;
ll fun(int b, int e, int turn) {
turn %= 2;
if (b > e)
return 0;
ll &ret = dp[b]... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 980,167 | 980,168 | u701914155 | cpp |
p03171 | //#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define enl printf("\n")
#define case (t) printf("Case #%d: ", (t))
#define ni(n) scanf("%d", &(n))
#define nl(n) scanf("%I64d", &(n))
#define nai(a, n) ... | //#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define enl printf("\n")
#define case (t) printf("Case #%d: ", (t))
#define ni(n) scanf("%d", &(n))
#define nl(n) scanf("%lld", &(n))
#define nai(a, n) ... | [
"preprocessor.define.value.change"
] | 980,171 | 980,172 | u270920804 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
long long dp[3000][3000][2], cs[3000];
int a[3000];
long long calc(int l, int r, bool turn) {
int t = a[l];
if (l == r)
return t;
if (dp[l][r][turn] != -1)
return dp[l][r][turn];
long long seg = cs[r] - (l ? cs[l - 1] : 0);
int A = seg - calc(l + 1, r, ... | #include <bits/stdc++.h>
using namespace std;
long long dp[3000][3000][2], cs[3000];
int a[3000];
long long calc(int l, int r, bool turn) {
int t = a[l];
if (l == r)
return t;
if (dp[l][r][turn] != -1)
return dp[l][r][turn];
long long seg = cs[r] - (l ? cs[l - 1] : 0);
long long A = seg - calc(l + ... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 980,176 | 980,177 | u279627039 | cpp |
p03171 | #define _CRT_SECURE_NO_WARNINGS
#pragma comment(linker, "/STACK:16777216")
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#... | #define _CRT_SECURE_NO_WARNINGS
#pragma comment(linker, "/STACK:16777216")
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#... | [
"call.arguments.change"
] | 980,190 | 980,191 | u562824357 | cpp |
p03171 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; 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 = ma... | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; 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 = ma... | [
"expression.operation.unary.add"
] | 980,192 | 980,193 | u457283867 | cpp |
p03171 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> P2;
typedef pair<pair<int, int>, int> P3;
typedef pair<pair<int, int>, pair<int, int>> P4;
#define PB(a) push_back(a)
#define MP(a, b) make_pair((a), (b))
#define M3P(a, b, c) make_pair(make_pair((a), (b)), (c))
#define M4P(a, ... | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> P2;
typedef pair<pair<int, int>, int> P3;
typedef pair<pair<int, int>, pair<int, int>> P4;
#define PB(a) push_back(a)
#define MP(a, b) make_pair((a), (b))
#define M3P(a, b, c) make_pair(make_pair((a), (b)), (c))
#define M4P(a, ... | [
"call.arguments.change"
] | 980,196 | 980,197 | u007446928 | cpp |
p03172 | #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <iostream>
#include <map>
#include <math.h>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <vector>
using namespace std;
const int INF = 1e9;
#define ll long long
#define int ll
#define fast ... | #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <iostream>
#include <map>
#include <math.h>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <vector>
using namespace std;
const int INF = 1e9;
#define ll long long
#define int ll
#define fast ... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 980,212 | 980,213 | u556783345 | cpp |
p03172 | #include <bits/stdc++.h>
#define ll long long int
const int MOD = 1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
ll dpp[k + 1] = {0};
dpp[0] = 1;
for (int i = 0; i < n; i++) {
int curr_lim;
cin >> curr_lim;
ll dp[k + 1] = {0};
... | #include <bits/stdc++.h>
#define ll long long int
const int MOD = 1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
ll dpp[k + 1] = {0};
dpp[0] = 1;
for (int i = 0; i < n; i++) {
int curr_lim;
cin >> curr_lim;
ll dp[k + 1] = {0};
... | [] | 980,214 | 980,215 | u863091189 | cpp |
p03172 | #include <bits/stdc++.h>
#define ll long long int
const int MOD = 1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
int dpp[k + 1] = {0};
dpp[0] = 1;
for (int i = 0; i < n; i++) {
int curr_lim;
cin >> curr_lim;
int dp[k + 1] = {0}... | #include <bits/stdc++.h>
#define ll long long int
const int MOD = 1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
ll dpp[k + 1] = {0};
dpp[0] = 1;
for (int i = 0; i < n; i++) {
int curr_lim;
cin >> curr_lim;
ll dp[k + 1] = {0};
... | [
"variable_declaration.type.change"
] | 980,216 | 980,215 | u863091189 | cpp |
p03172 | #include <iostream>
// @idea: digit dp
// n: total number of children
// s : current number of candies
// dp(i, s) : all the ways s candies can be distributed from [1...i]
using namespace std;
const int NMAX = 1e2 + 11;
const int KMAX = 1e5 + 11;
const int MOD = 1e9 + 7;
int n, k, a[NMAX], acc[KMAX... | #include <iostream>
// @idea: digit dp
// n: total number of children
// s : current number of candies
// dp(i, s) : all the ways s candies can be distributed from [1...i]
using namespace std;
const int NMAX = 1e2 + 11;
const int KMAX = 1e5 + 11;
const int MOD = 1e9 + 7;
int n, k, a[NMAX], acc[KMAX... | [
"assignment.change"
] | 980,219 | 980,220 | u508183081 | cpp |
p03172 | #include <iostream>
// @idea: digit dp
// n: total number of children
// s : current number of candies
// dp(i, s) : all the ways s candies can be distributed from [1...i]
using namespace std;
const int NMAX = 1e2 + 11;
const int KMAX = 1e5 + 11;
const int MOD = 1e9 + 7;
int n, k, a[NMAX], acc[KMAX... | #include <iostream>
// @idea: digit dp
// n: total number of children
// s : current number of candies
// dp(i, s) : all the ways s candies can be distributed from [1...i]
using namespace std;
const int NMAX = 1e2 + 11;
const int KMAX = 1e5 + 11;
const int MOD = 1e9 + 7;
int n, k, a[NMAX], acc[KMAX... | [
"assignment.change"
] | 980,221 | 980,220 | u508183081 | cpp |
p03172 | #include <iostream>
// @idea: digit dp
// n: total number of children
// s : current number of candies
// dp(i, s) : all the ways s candies can be distributed from [1...i]
using namespace std;
const int NMAX = 1e2 + 11;
const int KMAX = 1e5 + 11;
const int MOD = 1e9 + 7;
int n, k, a[NMAX], acc[KMAX... | #include <iostream>
// @idea: digit dp
// n: total number of children
// s : current number of candies
// dp(i, s) : all the ways s candies can be distributed from [1...i]
using namespace std;
const int NMAX = 1e2 + 11;
const int KMAX = 1e5 + 11;
const int MOD = 1e9 + 7;
int n, k, a[NMAX], acc[KMAX... | [
"assignment.change"
] | 980,221 | 980,222 | u508183081 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
int dp[N + 1][K + 1] = {};
vector<int> a(N + 1, 0);
for (int i = 1; i <= N; ++i) {
int tmp;
cin >> tmp;
a.at(i) = tmp;
}
for (int i = 0; i <= N; ++i) {
dp[i][0] = 1;
}
for (int i = 1; i <= N; ... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
int dp[N + 1][K + 1] = {};
vector<int> a(N + 1, 0);
for (int i = 1; i <= N; ++i) {
int tmp;
cin >> tmp;
a.at(i) = tmp;
}
for (int i = 0; i <= N; ++i) {
dp[i][0] = 1;
}
for (int i = 1; i <= N; ... | [
"assignment.change"
] | 980,223 | 980,224 | u150012595 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define PII pair<ll, ll>
#define VI vector<ll>
#define VB vector<bool>
#define VC vector<char>
#define VVI vector<vector<ll>>
#define VVC vector<vector<char>>
#define VS vector<string>
#define VP vector<PII>
#define lf(i, a, b) for (ll i = a; i <= b; i... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define PII pair<ll, ll>
#define VI vector<ll>
#define VB vector<bool>
#define VC vector<char>
#define VVI vector<vector<ll>>
#define VVC vector<vector<char>>
#define VS vector<string>
#define VP vector<PII>
#define lf(i, a, b) for (ll i = a; i <= b; i... | [] | 980,227 | 980,228 | u752324944 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100 + 5;
const int K = 1e5 + 5;
const int MOD = 1e9 + 7;
ll dp[N][K];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i]... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100 + 5;
const int K = 1e5 + 5;
const int MOD = 1e9 + 7;
ll dp[N][K];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i]... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 980,229 | 980,230 | u927525869 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n + 1][k + 1];
dp[0][0] = 1;
for (int i = 1; i <= k; i++) {
dp[0][i] = 0;
}
for (int i = 1; i <= n; i++) {
for (int... | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n + 1][k + 1];
dp[0][0] = 1;
for (int i = 1; i <= k; i++) {
dp[0][i] = 0;
}
for (int i = 1; i <= n; i++) {
for (int... | [
"assignment.change"
] | 980,250 | 980,251 | u284577220 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int MOD = 1e9 + 7;
#define dbg(a) cout << "-> " << __LINE__ << ": " << #a << " = " << a << endl
int add(int a, int b) { return (a + b < MOD) ? (a + b) : (a + b - MOD); }
int sub(int a, int b) { return (a > b) ? (a - b) : (a - b + MOD); }
... | #include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int MOD = 1e9 + 7;
#define dbg(a) cout << "-> " << __LINE__ << ": " << #a << " = " << a << endl
int add(int a, int b) { return (a + b < MOD) ? (a + b) : (a + b - MOD); }
int sub(int a, int b) { return (a >= b) ? (a - b) : (a - b + MOD); }
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 980,266 | 980,267 | u222758739 | cpp |
p03172 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define mod 1e9 + 7
#define pb push_back
void add_self(int &here, int y) {
here += y;
if (here > mod)
here -= mod;
return;
}
void sub_self(int &here, int y) {
here -= y;
if (here < 0)
here += mod;
return;
}
int main(... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define mod 1e9 + 7
#define pb push_back
void add_self(int &here, int y) {
here += y;
if (here >= mod)
here -= mod;
return;
}
void sub_self(int &here, int y) {
here -= y;
if (here <= 0)
here += mod;
return;
}
int mai... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 980,275 | 980,276 | u894836225 | cpp |
p03172 | #include <bits/stdc++.h>
#define int long long int // comment for large arrays
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define INF 10000000000000001
#define all(x) (x).begin(), (x).end()
#define LB(v, x) (lower... | #include <bits/stdc++.h>
#define int long long int // comment for large arrays
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define INF 10000000000000001
#define all(x) (x).begin(), (x).end()
#define LB(v, x) (lower... | [
"assignment.change",
"expression.operation.binary.remove"
] | 980,285 | 980,286 | u889896098 | cpp |
p03172 | #include <bits/stdc++.h>
#define int long long int // comment for large arrays
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define INF 10000000000000001
#define all(x) (x).begin(), (x).end()
#define LB(v, x) (lower... | #include <bits/stdc++.h>
#define int long long int // comment for large arrays
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define INF 10000000000000001
#define all(x) (x).begin(), (x).end()
#define LB(v, x) (lower... | [
"assignment.change"
] | 980,287 | 980,286 | u889896098 | cpp |
p03172 | #include <bits/stdc++.h>
#define int long long int // comment for large arrays
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define INF 10000000000000001
#define all(x) (x).begin(), (x).end()
#define LB(v, x) (lower... | #include <bits/stdc++.h>
#define int long long int // comment for large arrays
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define INF 10000000000000001
#define all(x) (x).begin(), (x).end()
#define LB(v, x) (lower... | [
"assignment.change"
] | 980,285 | 980,288 | u889896098 | cpp |
p03172 | #include <bits/stdc++.h>
#define int long long int // comment for large arrays
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define INF 10000000000000001
#define all(x) (x).begin(), (x).end()
#define LB(v, x) (lower... | #include <bits/stdc++.h>
#define int long long int // comment for large arrays
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define INF 10000000000000001
#define all(x) (x).begin(), (x).end()
#define LB(v, x) (lower... | [
"assignment.change"
] | 980,287 | 980,288 | u889896098 | cpp |
p03172 | #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;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
using namespace std;
#define a_macro(args...)... | #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;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
using namespace std;
#define a_macro(args...)... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 980,302 | 980,303 | u450304927 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define watch(x) cout << (#x) << " is " << (x) << endl
#define f(t) for (ll i = 0; i < t; i++)... | #include <bits/stdc++.h>
using namespace std;
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define watch(x) cout << (#x) << " is " << (x) << endl
#define f(t) for (ll i = 0; i < t; i++)... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 980,308 | 980,309 | u626186340 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
vector<int> pref(k), dp(k);
dp[0] = 1;
for (int kid = 1; kid <= n; kid++) {
int c;
cin >> c;
pref[0] = dp[0];
dp[0] = 0;
for (int i = 1; i <= k; i++) {
pref[i] = (pref[i - ... | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
vector<int> pref(k + 1), dp(k + 1);
dp[0] = 1;
for (int kid = 1; kid <= n; kid++) {
int c;
cin >> c;
pref[0] = dp[0];
dp[0] = 0;
for (int i = 1; i <= k; i++) {
pref[i] = (p... | [
"assignment.change"
] | 980,312 | 980,313 | u158312277 | cpp |
p03172 | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pll pair<ll, ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#d... | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pll pair<ll, ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#d... | [
"expression.operator.change"
] | 980,314 | 980,315 | u882039496 | cpp |
p03172 | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
typedef long long ll;
typedef long double ld;
ll mod = 1e9 + 7;
int main() {
ll n, k;
cin >> n >> k;
vector<ll> arr(n);
for (int z... | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
typedef long long ll;
typedef long double ld;
ll mod = 1e9 + 7;
int main() {
ll n, k;
cin >> n >> k;
vector<ll> arr(n + 1);
for (i... | [
"assignment.change"
] | 980,326 | 980,327 | u553927381 | cpp |
p03172 | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
typedef long long ll;
typedef long double ld;
ll mod = 1e9 + 7;
int main() {
ll n, k;
cin >> n >> k;
vector<ll> arr(n + 1);
for (i... | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
typedef long long ll;
typedef long double ld;
ll mod = 1e9 + 7;
int main() {
ll n, k;
cin >> n >> k;
vector<ll> arr(n + 1);
for (i... | [
"control_flow.branch.else.remove"
] | 980,328 | 980,327 | u553927381 | cpp |
p03172 | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
typedef long long ll;
typedef long double ld;
ll mod = 1e9 + 7;
int main() {
ll n, k;
cin >> n >> k;
vector<ll> arr(n);
for (int z... | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
typedef long long ll;
typedef long double ld;
ll mod = 1e9 + 7;
int main() {
ll n, k;
cin >> n >> k;
vector<ll> arr(n);
for (int z... | [
"control_flow.branch.else.remove"
] | 980,329 | 980,330 | u553927381 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
vector<int64_t> dp(k + 1, 0);
dp.at(0) = 1;
vector<int64_t> cumsum_dp(k + 2, 1);
cumsum_dp.at(0) = 0;
for (int i = 0; i < ... | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
vector<int64_t> dp(k + 1, 0);
dp.at(0) = 1;
vector<int64_t> cumsum_dp(k + 2, 1);
cumsum_dp.at(0) = 0;
for (int i = 0; i < ... | [
"assignment.change"
] | 980,331 | 980,332 | u711693740 | cpp |
p03172 | // Om Sree Sai Ram
#include "bits/stdc++.h"
using namespace std;
const int mod = 1e9 + 7;
int add_self(int &a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
int sub_self(int &a, int b) {
a -= b;
if (a <= mod) {
a += mod;
}
}
int main() {
int n, k;
cin >> n >> k;
vector<int> dp(k + 1);
... | // Om Sree Sai Ram
#include "bits/stdc++.h"
using namespace std;
const int mod = 1e9 + 7;
int add_self(int &a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
int sub_self(int &a, int b) {
a -= b;
if (a <= 0) {
a += mod;
}
}
int main() {
int n, k;
cin >> n >> k;
vector<int> dp(k + 1);
//... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change"
] | 980,336 | 980,337 | u279912110 | cpp |
p03172 | #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 tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
#define CLOCK_START clock_t chrono_clk_beg = clock()
#def... | #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 tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
#define CLOCK_START clock_t chrono_clk_beg = clock()
#def... | [
"expression.operation.binary.add"
] | 980,343 | 980,344 | u562572302 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.