problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9 values |
|---|---|---|---|---|---|---|---|
p03032 | #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
#define rep(i, a, b) for (int i = (a); i < (b); i++)
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef complex<double> com;
const int mod = 1e9 + 7;
const int MOD = 998244353;
const int inf = 2e9;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n), sum(n + 1, 0);
rep(i, 0, n) cin >> a[i];
int ans = 0;
rep(i, 0, k + 1) rep(l, 0, i + 1) {
int sub = 0;
priority_queue<int, vector<int>, greater<int>> pq;
rep(j, 0, l) {
sub += a[j];
pq.push(a[j]);
}
reverse(a.begin(), a.end());
rep(r, 0, min(i, n) - l) {
sub += a[r];
pq.push(a[r]);
}
reverse(a.begin(), a.end());
int cnt = k - i;
while (cnt > 0 && !pq.empty() && pq.top() < 0) {
cnt--;
sub -= pq.top();
pq.pop();
}
ans = max(ans, sub);
}
printf("%d", ans);
return 0;
}
| #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
#define rep(i, a, b) for (int i = (a); i < (b); i++)
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef complex<double> com;
const int mod = 1e9 + 7;
const int MOD = 998244353;
const int inf = 2e9;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n), sum(n + 1, 0);
rep(i, 0, n) cin >> a[i];
int ans = 0;
rep(i, 0, k + 1) rep(l, 0, i + 1) {
int sub = 0;
priority_queue<int, vector<int>, greater<int>> pq;
rep(j, 0, min(l, n)) {
sub += a[j];
pq.push(a[j]);
}
reverse(a.begin(), a.end());
rep(r, 0, min(i, n) - l) {
sub += a[r];
pq.push(a[r]);
}
reverse(a.begin(), a.end());
int cnt = k - i;
while (cnt > 0 && !pq.empty() && pq.top() < 0) {
cnt--;
sub -= pq.top();
pq.pop();
}
ans = max(ans, sub);
}
printf("%d", ans);
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 843,574 | 843,575 | u407614884 | cpp |
p03032 | #define _CRT_SECURE_NO_WARNINGS
/* include ***********************/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* define *************************/
// for
#define REP(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define REPS(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define RREP(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define RREPS(i, n) for (int i = (int)(n); i > 0; i--)
#define FOR(i, s, n) \
for (int i = (int)(s), i##_len = (int)(n); i < i##_len; i++)
#define RFOR(i, s, n) \
for (int i = (int)(n)-1, i##_len = (int)(s); i >= i##_len; i--)
// printf
#define PRINTD(d) printf("%d\n", (d))
#define PRINTL(d) printf("%lld\n", (d))
// memset
#define m0(s) memset(s, 0, sizeof(s))
#define ml(s) memset(s, 63, sizeof(s))
#define fill(s, c) memset(s, c, sizeof(s))
#define INF 1e9
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int diff[4][2] = {
{0, -1},
{-1, 0},
{1, 0},
{0, 1},
};
//今回の変数
int Min(int a, int b) { return (a) < (b) ? (a) : (b); }
int Max(int a, int b) { return (a) > (b) ? (a) : (b); }
ll Minl(ll a, ll b) { return (a) < (b) ? (a) : (b); }
ll Maxl(ll a, ll b) { return (a) > (b) ? (a) : (b); }
void hSwap(int x[], int i, int j) {
int temp;
temp = x[i];
x[i] = x[j];
x[j] = temp;
}
void ShowData(int x[], int left, int right) {
int i;
for (i = left; i <= right; i++)
printf("%d ", x[i]);
printf("\n");
}
void QSort(int x[], int left, int right, int n) {
int i, j; //左端,右端
int pivot; //軸
i = left;
j = right;
pivot = x[(left + right) / 2];
while (1) {
if (n > 0) { // n>0なら昇順、n<=0なら降順
while ((x[i] < pivot) && (i <= right))
i++; //軸値より大きい要素
while ((pivot < x[j]) && (i <= right))
j--; //軸値より小さい要素
} else {
while ((x[i] > pivot) && (i <= right))
i++; //軸値より小さい要素
while ((pivot > x[j]) && (i <= right))
j--; //軸値より大きい要素
}
if (i >= j)
break;
hSwap(x, i, j);
i++;
j--;
}
// ShowData(x, left, right);
if (left < i - 1)
QSort(x, left, i - 1, n);
if (j + 1 < right)
QSort(x, j + 1, right, n);
}
int main() {
int ans = -1 * 1e9;
int n, k;
scanf("%d%d", &n, &k);
int v[50];
REP(i, n) scanf("%d", &v[i]);
REP(i, n + 1) {
if (i > k)
break;
REP(j, n + 1) {
if (i + j > k)
break;
int left = i;
int right = j;
int back = k - left - right;
int min[50];
int num = 0;
int cnt = 0;
REP(m, 50) min[m] = 1e9;
REP(m, left) {
num += v[m];
if (v[m] < 0) {
min[cnt++] = v[m];
}
}
REP(m, right) {
num += v[n - 1 - m];
if (v[n - 1 - m] < 0) {
min[cnt++] = v[n - 1 - m];
}
}
if (cnt > back) {
QSort(min, 0, cnt - 1, 1);
}
REP(m, Min(cnt, back)) { num -= min[m]; }
// printf("left:%d,right:%d,back:%d,:cnt:%d\n", left, right, back, cnt);
ans = Max(ans, num);
// PRINTD(ans);
// puts("");
}
}
PRINTD(ans);
}
| #define _CRT_SECURE_NO_WARNINGS
/* include ***********************/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* define *************************/
// for
#define REP(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define REPS(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define RREP(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define RREPS(i, n) for (int i = (int)(n); i > 0; i--)
#define FOR(i, s, n) \
for (int i = (int)(s), i##_len = (int)(n); i < i##_len; i++)
#define RFOR(i, s, n) \
for (int i = (int)(n)-1, i##_len = (int)(s); i >= i##_len; i--)
// printf
#define PRINTD(d) printf("%d\n", (d))
#define PRINTL(d) printf("%lld\n", (d))
// memset
#define m0(s) memset(s, 0, sizeof(s))
#define ml(s) memset(s, 63, sizeof(s))
#define fill(s, c) memset(s, c, sizeof(s))
#define INF 1e9
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int diff[4][2] = {
{0, -1},
{-1, 0},
{1, 0},
{0, 1},
};
//今回の変数
int Min(int a, int b) { return (a) < (b) ? (a) : (b); }
int Max(int a, int b) { return (a) > (b) ? (a) : (b); }
ll Minl(ll a, ll b) { return (a) < (b) ? (a) : (b); }
ll Maxl(ll a, ll b) { return (a) > (b) ? (a) : (b); }
void hSwap(int x[], int i, int j) {
int temp;
temp = x[i];
x[i] = x[j];
x[j] = temp;
}
void ShowData(int x[], int left, int right) {
int i;
for (i = left; i <= right; i++)
printf("%d ", x[i]);
printf("\n");
}
void QSort(int x[], int left, int right, int n) {
int i, j; //左端,右端
int pivot; //軸
i = left;
j = right;
pivot = x[(left + right) / 2];
while (1) {
if (n > 0) { // n>0なら昇順、n<=0なら降順
while ((x[i] < pivot) && (i <= right))
i++; //軸値より大きい要素
while ((pivot < x[j]) && (i <= right))
j--; //軸値より小さい要素
} else {
while ((x[i] > pivot) && (i <= right))
i++; //軸値より小さい要素
while ((pivot > x[j]) && (i <= right))
j--; //軸値より大きい要素
}
if (i >= j)
break;
hSwap(x, i, j);
i++;
j--;
}
// ShowData(x, left, right);
if (left < i - 1)
QSort(x, left, i - 1, n);
if (j + 1 < right)
QSort(x, j + 1, right, n);
}
int main() {
int ans = -1 * 1e9;
int n, k;
scanf("%d%d", &n, &k);
int v[50];
REP(i, n) scanf("%d", &v[i]);
REP(i, n + 1) {
if (i > k)
break;
REP(j, n + 1 - i) {
if (i + j > k)
break;
int left = i;
int right = j;
int back = k - left - right;
int min[50];
int num = 0;
int cnt = 0;
REP(m, 50) min[m] = 1e9;
REP(m, left) {
num += v[m];
if (v[m] < 0) {
min[cnt++] = v[m];
}
}
REP(m, right) {
num += v[n - 1 - m];
if (v[n - 1 - m] < 0) {
min[cnt++] = v[n - 1 - m];
}
}
if (cnt > back) {
QSort(min, 0, cnt - 1, 1);
}
REP(m, Min(cnt, back)) { num -= min[m]; }
// printf("left:%d,right:%d,back:%d,:cnt:%d\n", left, right, back, cnt);
ans = Max(ans, num);
// PRINTD(ans);
// puts("");
}
}
PRINTD(ans);
}
| [
"expression.operation.binary.add"
] | 843,578 | 843,579 | u539339654 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; ++i) {
cin >> V[i];
}
long long res = 0;
for (int r = 0; r < K + 1; ++r) {
for (int l = 0; l < K - r + 1; ++l) {
priority_queue<int> pq;
long long score = 0;
for (int i = 0; i < r; ++i) {
score += V[i];
pq.push(-V[i]);
}
for (int i = 0; i < l && N - i - 1 >= r; ++i) {
score += V[N - i - 1];
pq.push(-V[N - i - 1]);
}
for (int i = 0; i < K - r - l && !pq.empty() && pq.top() > 0; ++i) {
score += pq.top();
pq.pop();
}
res = max(score, res);
}
}
cout << res << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; ++i) {
cin >> V[i];
}
long long res = 0;
for (int r = 0; r < K + 1; ++r) {
for (int l = 0; l < K - r + 1; ++l) {
priority_queue<int> pq;
long long score = 0;
for (int i = 0; i < r && i < N; ++i) {
score += V[i];
pq.push(-V[i]);
}
for (int i = 0; i < l && N - i - 1 >= r; ++i) {
score += V[N - i - 1];
pq.push(-V[N - i - 1]);
}
for (int i = 0; i < K - r - l && !pq.empty() && pq.top() > 0; ++i) {
score += pq.top();
pq.pop();
}
res = max(score, res);
}
}
cout << res << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 843,580 | 843,581 | u979452668 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N, K, V[55];
cin >> N >> K;
rep(i, N) cin >> V[i];
int ans = 0;
for (int L = 0; L < min(K, N); L++) {
for (int R = 0; R < min(K - L, N - L); R++) {
if (L + R == 0)
continue;
vector<int> tmp;
rep(i, L) tmp.push_back(V[i]);
int idx = N - 1;
rep(i, R) {
tmp.push_back(V[idx]);
idx--;
}
sort(tmp.begin(), tmp.end());
reverse(tmp.begin(), tmp.end());
int cnt = L + R - 1;
int del = K - (L + R);
while (tmp[cnt] < 0 && del > 0) {
tmp.pop_back();
cnt--;
del--;
}
int tmp_ans = accumulate(tmp.begin(), tmp.end(), 0);
ans = max(ans, tmp_ans);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N, K, V[55];
cin >> N >> K;
rep(i, N) cin >> V[i];
int ans = 0;
for (int L = 0; L <= min(K, N); L++) {
for (int R = 0; R <= min(K - L, N - L); R++) {
if (L + R == 0)
continue;
vector<int> tmp;
rep(i, L) tmp.push_back(V[i]);
int idx = N - 1;
rep(i, R) {
tmp.push_back(V[idx]);
idx--;
}
sort(tmp.begin(), tmp.end());
reverse(tmp.begin(), tmp.end());
int cnt = L + R - 1;
int del = K - (L + R);
while (tmp[cnt] < 0 && del > 0) {
tmp.pop_back();
cnt--;
del--;
}
int tmp_ans = accumulate(tmp.begin(), tmp.end(), 0);
ans = max(ans, tmp_ans);
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,582 | 843,583 | u730946954 | cpp |
p03032 | #pragma region include
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define MOD 1000000007
#define INF 1000000000
#define LLINF 4000000000000000000
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
#pragma endregion
//#define __DEBUG__
#ifdef __DEBUG__
#define dump(x) \
cerr << #x << " = " << (x) << " [" << __LINE__ << ":" << __FUNCTION__ \
<< "] " << endl;
// vector出力
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
os << "{";
REP(i, (int)v.size()) { os << v[i] << (i < v.size() - 1 ? ", " : ""); }
os << "}";
return os;
}
// pair出力
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
// map出力
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
for (auto itr = map_var.begin(); itr != map_var.end(); itr++) {
os << "(" << itr->first << ", " << itr->second << ")";
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set 出力
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
for (auto itr = set_var.begin(); itr != set_var.end(); itr++) {
os << *itr;
++itr;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#endif
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
VI v1(N), v2(N);
vector<ll> sum(N + 1);
REP(i, N) {
cin >> v1[i];
v2[N - 1 - i] = v1[i];
}
sum[0] = 0;
REP(i, N) { sum[i + 1] = sum[i] + v1[i]; }
ll val = 0;
ll ans = 0;
int aaa = max(N, K);
int bbb = min(N, K);
for (int a = 0; a <= bbb; a++) {
for (int b = 0; b <= bbb - a; b++) {
val = sum[a] - sum[N - b] + sum[N];
vector<int> vec(aaa, INF);
REP(i, a) { vec[i] = v1[i]; }
for (int i = 0; i < b; i++) {
vec[i + a] = v2[i];
}
sort(ALL(vec));
REP(i, aaa - a - b) {
if (vec[i] < 0) {
val -= vec[i];
} else {
break;
}
}
ans = max(ans, val);
}
}
cout << ans << endl;
getchar();
getchar();
} | #pragma region include
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define MOD 1000000007
#define INF 1000000000
#define LLINF 4000000000000000000
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
#pragma endregion
//#define __DEBUG__
#ifdef __DEBUG__
#define dump(x) \
cerr << #x << " = " << (x) << " [" << __LINE__ << ":" << __FUNCTION__ \
<< "] " << endl;
// vector出力
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
os << "{";
REP(i, (int)v.size()) { os << v[i] << (i < v.size() - 1 ? ", " : ""); }
os << "}";
return os;
}
// pair出力
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
// map出力
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
for (auto itr = map_var.begin(); itr != map_var.end(); itr++) {
os << "(" << itr->first << ", " << itr->second << ")";
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set 出力
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
for (auto itr = set_var.begin(); itr != set_var.end(); itr++) {
os << *itr;
++itr;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#endif
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
VI v1(N), v2(N);
vector<ll> sum(N + 1);
REP(i, N) {
cin >> v1[i];
v2[N - 1 - i] = v1[i];
}
sum[0] = 0;
REP(i, N) { sum[i + 1] = sum[i] + v1[i]; }
ll val = 0;
ll ans = 0;
int aaa = max(N, K);
int bbb = min(N, K);
for (int a = 0; a <= bbb; a++) {
for (int b = 0; b <= bbb - a; b++) {
val = sum[a] - sum[N - b] + sum[N];
vector<int> vec(aaa, INF);
REP(i, a) { vec[i] = v1[i]; }
for (int i = 0; i < b; i++) {
vec[i + a] = v2[i];
}
sort(ALL(vec));
REP(i, K - a - b) {
if (vec[i] < 0) {
val -= vec[i];
} else {
break;
}
}
ans = max(ans, val);
}
}
cout << ans << endl;
getchar();
getchar();
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 843,592 | 843,593 | u435935167 | cpp |
p03032 | #include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, K;
cin >> n >> K;
vector<int> a(n);
for (auto &e : a) {
cin >> e;
}
int ans = 0;
for (int k = 1; k <= K; k++) {
for (int d = 1; d <= k; d++) { // d個取り出す
auto e = k - d; // e個戻す
if (d < e)
continue;
map<int, int> s;
int sum = 0;
int left = d - 1, right = n; // [0, left], [right, n - 1]
rep(i, d) {
s[a[i]] += 1;
sum += a[i];
}
{
int sub = 0, cnt = e;
for (auto p : s) {
sub += p.first * min(p.second, cnt);
cnt -= p.second;
if (cnt <= 0)
break;
}
ans = max(ans, sum - sub);
}
while (left >= 0) {
s[a[left]] -= 1;
sum -= a[left];
s[a[right - 1]] += 1;
sum += a[right - 1];
left--;
right--;
int sub = 0, cnt = e;
for (auto p : s) {
sub += p.first * min(p.second, cnt);
cnt -= p.second;
if (cnt <= 0)
break;
}
ans = max(ans, sum - sub);
}
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, K;
cin >> n >> K;
vector<int> a(n);
for (auto &e : a) {
cin >> e;
}
int ans = 0;
for (int k = 1; k <= K; k++) {
for (int d = 1; d <= min(k, n); d++) { // d個取り出す
auto e = k - d; // e個戻す
if (d < e)
continue;
map<int, int> s;
int sum = 0;
int left = d - 1, right = n; // [0, left], [right, n - 1]
rep(i, d) {
s[a[i]] += 1;
sum += a[i];
}
{
int sub = 0, cnt = e;
for (auto p : s) {
sub += p.first * min(p.second, cnt);
cnt -= p.second;
if (cnt <= 0)
break;
}
ans = max(ans, sum - sub);
}
while (left >= 0) {
s[a[left]] -= 1;
sum -= a[left];
s[a[right - 1]] += 1;
sum += a[right - 1];
left--;
right--;
int sub = 0, cnt = e;
for (auto p : s) {
sub += p.first * min(p.second, cnt);
cnt -= p.second;
if (cnt <= 0)
break;
}
ans = max(ans, sum - sub);
}
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 843,612 | 843,613 | u882868478 | cpp |
p03032 | #include <bits/stdc++.h>
constexpr int INF = 2147483647;
constexpr long long int INF_LL = 9223372036854775807;
constexpr int MOD = 1000000007;
using namespace std;
using ll = long long int;
using ull = unsigned long long int;
int main() {
int N, K;
cin >> N >> K;
vector<int> D(N);
for (int i = 0; i < N; i++)
cin >> D[i];
int ans = -INF;
for (int i = 0; i <= K; i++) {
if (i > N)
continue;
for (int j = 0; j <= i; j++) {
vector<int> n;
for (int k = 0; k < j; k++)
n.push_back(D[k]);
for (int k = 0; k < i - j; k++)
n.push_back(D[N - k - 1]);
// cout << endl;
// for (int k = 0; k < n.size(); k++)cout << n[k] << endl;
// cout << " " << K - i << endl;
sort(n.begin(), n.end());
for (int k = 0; k <= K - i && k < n.size(); k++) {
int tmp = 0;
for (int s = k; s < n.size(); s++)
tmp += n[s];
ans = max(tmp, ans);
}
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
constexpr int INF = 2147483647;
constexpr long long int INF_LL = 9223372036854775807;
constexpr int MOD = 1000000007;
using namespace std;
using ll = long long int;
using ull = unsigned long long int;
int main() {
int N, K;
cin >> N >> K;
vector<int> D(N);
for (int i = 0; i < N; i++)
cin >> D[i];
int ans = 0;
for (int i = 0; i <= K; i++) {
if (i > N)
continue;
for (int j = 0; j <= i; j++) {
vector<int> n;
for (int k = 0; k < j; k++)
n.push_back(D[k]);
for (int k = 0; k < i - j; k++)
n.push_back(D[N - k - 1]);
// cout << endl;
// for (int k = 0; k < n.size(); k++)cout << n[k] << endl;
// cout << " " << K - i << endl;
sort(n.begin(), n.end());
for (int k = 0; k <= K - i && k < n.size(); k++) {
int tmp = 0;
for (int s = k; s < n.size(); s++)
tmp += n[s];
ans = max(tmp, ans);
}
}
}
cout << ans << endl;
}
| [
"variable_declaration.value.change",
"expression.operation.unary.remove"
] | 843,616 | 843,617 | u326966549 | cpp |
p03032 | #include "algorithm"
#include "iostream"
#include "set"
#include "vector"
using namespace std;
vector<int> v;
int n, k;
int check(int d) {
int best = 0;
for (int l = 0; l <= d; ++l) {
set<int> st;
for (int i = 0; i < l; ++i) {
st.insert(v[i]);
}
int r = d - l;
for (int i = 0; i < r; ++i) {
st.insert(v[n - 1 - i]);
}
int x = k - d;
while (!st.empty() and x > 0) {
x--;
if (*st.begin() > 0)
continue;
st.erase(st.begin());
}
int sum = 0;
for (int x : st)
sum += x;
best = max(best, sum);
}
return best;
}
int main() {
scanf("%d %d", &n, &k);
v.resize(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
int d = min(k, n);
int best = 0;
for (int i = 0; i <= d; ++i) {
best = max(best, check(i));
}
cout << best << endl;
} | #include "algorithm"
#include "iostream"
#include "set"
#include "vector"
using namespace std;
vector<int> v;
int n, k;
int check(int d) {
int best = 0;
for (int l = 0; l <= d; ++l) {
multiset<int> st;
for (int i = 0; i < l; ++i) {
st.insert(v[i]);
}
int r = d - l;
for (int i = 0; i < r; ++i) {
st.insert(v[n - 1 - i]);
}
int x = k - d;
while (!st.empty() and x > 0) {
x--;
if (*st.begin() > 0)
continue;
st.erase(st.begin());
}
int sum = 0;
for (int x : st)
sum += x;
best = max(best, sum);
}
return best;
}
int main() {
scanf("%d %d", &n, &k);
v.resize(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
int d = min(k, n);
int best = 0;
for (int i = 1; i <= d; ++i) {
best = max(best, check(i));
}
cout << best << endl;
} | [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 843,623 | 843,624 | u753391427 | cpp |
p03032 | #include "algorithm"
#include "iostream"
#include "set"
#include "vector"
using namespace std;
vector<int> v;
int n, k;
int check(int d) {
int best = 0;
for (int l = 0; l <= d; ++l) {
set<int> st;
for (int i = 0; i < l; ++i) {
st.insert(v[i]);
}
int r = d - l;
for (int i = 0; i < r; ++i) {
st.insert(v[n - 1 - i]);
}
int x = k - d;
while (!st.empty() and x > 0) {
x--;
if (*st.begin() > 0)
continue;
st.erase(st.begin());
}
int sum = 0;
for (int x : st)
sum += x;
best = max(best, sum);
}
return best;
}
int main() {
scanf("%d %d", &n, &k);
v.resize(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
int d = min(k, n);
int best = 0;
for (int i = 1; i <= d; ++i) {
best = max(best, check(i));
}
cout << best << endl;
} | #include "algorithm"
#include "iostream"
#include "set"
#include "vector"
using namespace std;
vector<int> v;
int n, k;
int check(int d) {
int best = 0;
for (int l = 0; l <= d; ++l) {
multiset<int> st;
for (int i = 0; i < l; ++i) {
st.insert(v[i]);
}
int r = d - l;
for (int i = 0; i < r; ++i) {
st.insert(v[n - 1 - i]);
}
int x = k - d;
while (!st.empty() and x > 0) {
x--;
if (*st.begin() > 0)
continue;
st.erase(st.begin());
}
int sum = 0;
for (int x : st)
sum += x;
best = max(best, sum);
}
return best;
}
int main() {
scanf("%d %d", &n, &k);
v.resize(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
int d = min(k, n);
int best = 0;
for (int i = 1; i <= d; ++i) {
best = max(best, check(i));
}
cout << best << endl;
} | [
"variable_declaration.type.change"
] | 843,625 | 843,624 | u753391427 | cpp |
p03032 | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
int main() {
int N, K;
cin >> N >> K;
vector<ll> V(N, 0);
// vector<ll> s(N, 0);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
// s[0] = V[0];
// for (int i = 1; i < N; i++) {
// s[i] = s[i-1] + V[i];
// }
ll maxpt = 0;
int maxtake = min(K, N);
for (int i = 0; i < maxtake; i++) {
for (int j = 0; j <= i; j++) {
ll pt = 0;
priority_queue<ll, vector<ll>, greater<ll>> que;
for (int k = 0; k < j; k++) {
pt += V[k];
que.push(V[k]);
}
for (int k = N - 1; k >= N - (i - j); k--) {
pt += V[k];
que.push(V[k]);
}
int cntremain = K - i;
// if (!que.empty()) cout << "!" << que.top() << endl;;
while (cntremain > 0 && !que.empty() && que.top() < 0) {
pt -= que.top();
que.pop();
cntremain--;
}
// cout << i << " " << j << " " << pt << " " << cntremain << endl;
maxpt = max(maxpt, pt);
}
}
cout << maxpt << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
int main() {
int N, K;
cin >> N >> K;
vector<ll> V(N, 0);
// vector<ll> s(N, 0);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
// s[0] = V[0];
// for (int i = 1; i < N; i++) {
// s[i] = s[i-1] + V[i];
// }
ll maxpt = 0;
int maxtake = min(K, N);
for (int i = 0; i <= maxtake; i++) {
for (int j = 0; j <= i; j++) {
ll pt = 0;
priority_queue<ll, vector<ll>, greater<ll>> que;
for (int k = 0; k < j; k++) {
pt += V[k];
que.push(V[k]);
}
for (int k = N - 1; k >= N - (i - j); k--) {
pt += V[k];
que.push(V[k]);
}
int cntremain = K - i;
// if (!que.empty()) cout << "!" << que.top() << endl;;
while (cntremain > 0 && !que.empty() && que.top() < 0) {
pt -= que.top();
que.pop();
cntremain--;
}
// cout << i << " " << j << " " << pt << " " << cntremain << endl;
maxpt = max(maxpt, pt);
}
}
cout << maxpt << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,626 | 843,627 | u194385557 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, K;
cin >> N >> K;
vector<int> V;
for (int i = 0; i < N; ++i) {
int v;
cin >> v;
V.push_back(v);
}
vector<int> nums = V;
for (int i = 0; i < N; ++i) {
nums.push_back(V[i]);
}
int ans = 0;
for (int deleteCount = 0; K - deleteCount >= 0; ++deleteCount) {
int pickCount = K - deleteCount;
if (pickCount < deleteCount)
continue;
// fprintf(stderr, "PC: %d, DC: %d\n", pickCount, deleteCount);
int from = max(0, N - pickCount);
for (int i = from; i <= N; ++i) {
priority_queue<int, vector<int>, greater<int>> pque;
int sum = 0;
for (int j = i; j < i + pickCount; ++j) {
sum += nums[j];
pque.push(nums[j]);
}
for (int k = 0; k < deleteCount && !pque.empty(); ++k) {
if (pque.top() >= 0)
break;
sum -= pque.top();
pque.pop();
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, K;
cin >> N >> K;
vector<int> V;
for (int i = 0; i < N; ++i) {
int v;
cin >> v;
V.push_back(v);
}
vector<int> nums = V;
for (int i = 0; i < N; ++i) {
nums.push_back(V[i]);
}
int ans = 0;
for (int deleteCount = 0; K - deleteCount >= 0; ++deleteCount) {
int pickCount = min(N, K - deleteCount);
if (pickCount < deleteCount)
continue;
// fprintf(stderr, "PC: %d, DC: %d\n", pickCount, deleteCount);
int from = max(0, N - pickCount);
for (int i = from; i <= N; ++i) {
priority_queue<int, vector<int>, greater<int>> pque;
int sum = 0;
for (int j = i; j < i + pickCount; ++j) {
sum += nums[j];
pque.push(nums[j]);
}
for (int k = 0; k < deleteCount && !pque.empty(); ++k) {
if (pque.top() >= 0)
break;
sum -= pque.top();
pque.pop();
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 843,636 | 843,637 | u740836226 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n, k;
cin >> n >> k;
vector<int64_t> vs(n);
for (auto &v : vs) {
cin >> v;
}
int64_t ans = -(1LL << 60);
for (int i = 0; i <= n; i++) {
for (int j = 0; i + j <= n; j++) {
if (k < i + j) {
continue;
}
vector<int64_t> tmp;
for (int l = 0; l < i; l++) {
tmp.emplace_back(vs[l]);
}
for (int l = 0; l < j; l++) {
tmp.emplace_back(vs[n - l - 1]);
}
sort(tmp.begin(), tmp.end());
int64_t s = accumulate(tmp.begin(), tmp.end(), int64_t(0));
for (int l = 0; l < tmp.size() && 2 * l < k - (i + j); l++) {
if (0 <= tmp[l]) {
break;
}
s -= tmp[l];
}
ans = max(ans, s);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n, k;
cin >> n >> k;
vector<int64_t> vs(n);
for (auto &v : vs) {
cin >> v;
}
int64_t ans = -(1LL << 60);
for (int i = 0; i <= n; i++) {
for (int j = 0; i + j <= n; j++) {
if (k < i + j) {
continue;
}
vector<int64_t> tmp;
for (int l = 0; l < i; l++) {
tmp.emplace_back(vs[l]);
}
for (int l = 0; l < j; l++) {
tmp.emplace_back(vs[n - l - 1]);
}
sort(tmp.begin(), tmp.end());
int64_t s = accumulate(tmp.begin(), tmp.end(), int64_t(0));
for (int l = 0; l < tmp.size() && l < k - (i + j); l++) {
if (0 <= tmp[l]) {
break;
}
s -= tmp[l];
}
ans = max(ans, s);
}
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 843,642 | 843,643 | u017167684 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int j[100];
int n;
int getAns(int k, int sum, priority_queue<int, vector<int>, greater<int>> q) {
while (k > 0 && q.size() > 0 && q.top() < 0) {
sum -= q.top();
q.pop();
k--;
}
return sum;
}
int moveRight(int k, int sum,
priority_queue<int, vector<int>, greater<int>> q) {
int i = n - 1, ans = getAns(k, sum, q);
while (q.size() <= n && k > 0) {
q.push(j[i]);
sum += j[i];
i--;
k--;
ans = max(ans, getAns(k, sum, q));
}
return ans;
}
int main() {
int k;
priority_queue<int, vector<int>, greater<int>> q;
int sum = 0;
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> j[i];
int ans = moveRight(k, sum, q);
for (int l = 0; l < min(n, k); l++) {
q.push(j[l]);
sum += j[l];
ans = max(ans, moveRight(k - l - 1, sum, q));
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int j[100];
int n;
int getAns(int k, int sum, priority_queue<int, vector<int>, greater<int>> q) {
while (k > 0 && q.size() > 0 && q.top() < 0) {
sum -= q.top();
q.pop();
k--;
}
return sum;
}
int moveRight(int k, int sum,
priority_queue<int, vector<int>, greater<int>> q) {
int i = n - 1, ans = getAns(k, sum, q);
while (q.size() < n && k > 0) {
q.push(j[i]);
sum += j[i];
i--;
k--;
ans = max(ans, getAns(k, sum, q));
}
return ans;
}
int main() {
int k;
priority_queue<int, vector<int>, greater<int>> q;
int sum = 0;
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> j[i];
int ans = moveRight(k, sum, q);
for (int l = 0; l < min(n, k); l++) {
q.push(j[l]);
sum += j[l];
ans = max(ans, moveRight(k - l - 1, sum, q));
}
cout << ans;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 843,648 | 843,649 | u219398458 | cpp |
p03032 | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// sortは初期で昇順 greater<hoge>()で降順
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph &G, ll s, ll t) {
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xとyの集合を統合する
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
int _sum(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
int n, height;
vector<int> dat;
// 初期化（_nは最大要素数）
SumSegTree(int _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<int>(2 * n - 1);
}
// 場所i(0-indexed)にxを足す
void add(int i, int x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 内部クエリ_sum()を呼び出す
int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
bool compare_by_b(pair<ll, ll> a, pair<ll, ll> b) { //降順second
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool compare_by_a(pair<ll, ll> a, pair<ll, ll> b) { //降順first
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second > b.second;
}
}
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
int main() {
ll n, k;
cin >> n >> k;
Array v(n);
REP(i, n) { cin >> v[i]; }
Array l(n + 1);
Array r(n + 1);
l[0] = 0;
r[0] = 0;
REP(i, n) {
l[i + 1] = l[i] + v[i];
r[i + 1] = r[i] + v[n - 1 - i];
}
ll ans = 0;
for (int i = 1; i <= min(k, n); i++) {
for (int j = 0; j <= i; j++) {
ll total = 0;
total += l[j] - l[0];
total += r[i - j] - r[0];
priority_queue<ll> que;
REP(a, j) {
if (v[a] < 0)
que.push(-v[a]);
}
REP(a, i - j) {
if (v[n - 1 - a] < 0)
que.push(-v[n - 1 - a]);
}
REP(a, k - i) {
if (que.size()) {
total += que.top();
que.pop();
}
}
chmax(ans, total);
}
}
if (k > n) {
ll total = l[n];
sort(all(v));
REP(i, k - n) {
if (i >= n)
break;
if (v[i] < 0) {
total += -v[i];
}
}
cout << total;
chmax(ans, total);
}
cout << ans;
return 0;
} | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// sortは初期で昇順 greater<hoge>()で降順
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph &G, ll s, ll t) {
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xとyの集合を統合する
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
int _sum(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
int n, height;
vector<int> dat;
// 初期化（_nは最大要素数）
SumSegTree(int _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<int>(2 * n - 1);
}
// 場所i(0-indexed)にxを足す
void add(int i, int x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 内部クエリ_sum()を呼び出す
int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
bool compare_by_b(pair<ll, ll> a, pair<ll, ll> b) { //降順second
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool compare_by_a(pair<ll, ll> a, pair<ll, ll> b) { //降順first
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second > b.second;
}
}
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
int main() {
ll n, k;
cin >> n >> k;
Array v(n);
REP(i, n) { cin >> v[i]; }
Array l(n + 1);
Array r(n + 1);
l[0] = 0;
r[0] = 0;
REP(i, n) {
l[i + 1] = l[i] + v[i];
r[i + 1] = r[i] + v[n - 1 - i];
}
ll ans = 0;
for (int i = 1; i <= min(k, n); i++) {
for (int j = 0; j <= i; j++) {
ll total = 0;
total += l[j] - l[0];
total += r[i - j] - r[0];
priority_queue<ll> que;
REP(a, j) {
if (v[a] < 0)
que.push(-v[a]);
}
REP(a, i - j) {
if (v[n - 1 - a] < 0)
que.push(-v[n - 1 - a]);
}
REP(a, k - i) {
if (que.size()) {
total += que.top();
que.pop();
}
}
chmax(ans, total);
}
}
if (k > n) {
ll total = l[n];
sort(all(v));
REP(i, k - n) {
if (i >= n)
break;
if (v[i] < 0) {
total += -v[i];
}
}
// cout << total;
chmax(ans, total);
}
cout << ans;
return 0;
} | [] | 843,650 | 843,651 | u051493691 | cpp |
p03032 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long int
ll const MOD = 1000000007;
ll const INF = (long long int)1 << 61;
ll mypow(ll x, ll n) {
ll ret = 1;
while (n > 0) {
if (n & 1) {
ret = (ret * x) % MOD;
}
x = (x * x) % MOD;
n >>= 1;
}
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<ll> sum(n);
sum[0] = a[0];
for (int i = 1; i < n; i++) {
sum[i] = sum[i - 1] + a[i];
}
vector<vector<vector<ll>>> dp(
n + 1, vector<vector<ll>>(n + 1, vector<ll>(n + 1, 0)));
for (int i = 0; i < n; i++) {
for (int j = 0; i + j < k && j < n && i + j < n; j++) {
if (a[i] < 0) {
ll t = a[i];
for (int x = 0; x < n + 1; x++) {
if (dp[i][j][x] <= t) {
dp[i + 1][j][x] = dp[i][j][x];
} else {
dp[i + 1][j][x] = t;
t = dp[i][j][x];
}
}
} else {
for (int x = 0; x < n + 1; x++) {
dp[i + 1][j][x] = dp[i][j][x];
}
}
if (a[n - j - 1] < 0) {
ll t = a[n - j - 1];
for (int x = 0; x < n + 1; x++) {
if (dp[i][j][x] <= t) {
dp[i][j + 1][x] = dp[i][j][x];
} else {
dp[i][j + 1][x] = t;
t = dp[i][j][x];
}
}
} else {
for (int x = 0; x < n + 1; x++) {
dp[i][j + 1][x] = dp[i][j][x];
}
}
}
}
ll ans = 0;
for (int i = 0; i < n + 1; i++) {
for (int j = 0; i + j <= k && i + j < n + 1; j++) {
ll front;
if (i == 0) {
front = 0;
} else {
front = sum[i - 1];
}
ll back = sum.back();
if (j != n) {
back -= sum[n - j - 1];
}
ll tmp = front + back;
for (int x = 0; x + i + j < k; x++) {
tmp -= dp[i][j][x];
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long int
ll const MOD = 1000000007;
ll const INF = (long long int)1 << 61;
ll mypow(ll x, ll n) {
ll ret = 1;
while (n > 0) {
if (n & 1) {
ret = (ret * x) % MOD;
}
x = (x * x) % MOD;
n >>= 1;
}
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<ll> sum(n);
sum[0] = a[0];
for (int i = 1; i < n; i++) {
sum[i] = sum[i - 1] + a[i];
}
vector<vector<vector<ll>>> dp(
n + 1, vector<vector<ll>>(n + 1, vector<ll>(n + 1, 0)));
for (int i = 0; i < n; i++) {
for (int j = 0; i + j < k && j < n && i + j < n; j++) {
if (a[i] < 0) {
ll t = a[i];
for (int x = 0; x < n + 1; x++) {
if (dp[i][j][x] <= t) {
dp[i + 1][j][x] = dp[i][j][x];
} else {
dp[i + 1][j][x] = t;
t = dp[i][j][x];
}
}
} else {
for (int x = 0; x < n + 1; x++) {
dp[i + 1][j][x] = dp[i][j][x];
}
}
if (a[n - j - 1] < 0) {
ll t = a[n - j - 1];
for (int x = 0; x < n + 1; x++) {
if (dp[i][j][x] <= t) {
dp[i][j + 1][x] = dp[i][j][x];
} else {
dp[i][j + 1][x] = t;
t = dp[i][j][x];
}
}
} else {
for (int x = 0; x < n + 1; x++) {
dp[i][j + 1][x] = dp[i][j][x];
}
}
}
}
ll ans = 0;
for (int i = 0; i < n + 1; i++) {
for (int j = 0; i + j <= k && i + j < n + 1; j++) {
ll front;
if (i == 0) {
front = 0;
} else {
front = sum[i - 1];
}
ll back = sum.back();
if (j != n) {
back -= sum[n - j - 1];
}
ll tmp = front + back;
for (int x = 0; x + i + j < k && x < n + 1; x++) {
tmp -= dp[i][j][x];
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 843,654 | 843,655 | u369508054 | cpp |
p03032 | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
#include "ext/rope"
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
typedef long long ll;
typedef pair<int, int> pii;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); ++i)
#define pb push_back
#define sz size
#define f first
#define s second
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, k;
cin >> n >> k;
vector<ll> v(n);
F0R(i, n) cin >> v[i];
ll res = 0;
FOR(i, 1, k + 1) {
if (k > n)
break;
F0R(j, i + 1) {
vector<ll> taken;
F0R(a, j) taken.pb(v[a]);
F0R(x, i - j) taken.pb(v[v.sz() - 1 - x]);
sort(taken.begin(), taken.end());
ll rem = k - i;
ll cmax = 0;
F0R(j, taken.sz()) {
if (taken[j] < 0 && rem > 0) {
rem--;
} else {
cmax += taken[j];
}
}
res = max(res, cmax);
}
}
cout << res;
return 0;
} | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
#include "ext/rope"
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
typedef long long ll;
typedef pair<int, int> pii;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); ++i)
#define pb push_back
#define sz size
#define f first
#define s second
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, k;
cin >> n >> k;
vector<ll> v(n);
F0R(i, n) cin >> v[i];
ll res = 0;
FOR(i, 1, k + 1) {
if (i > n)
break;
F0R(j, i + 1) {
vector<ll> taken;
F0R(a, j) taken.pb(v[a]);
F0R(x, i - j) taken.pb(v[v.sz() - 1 - x]);
sort(taken.begin(), taken.end());
ll rem = k - i;
ll cmax = 0;
F0R(j, taken.sz()) {
if (taken[j] < 0 && rem > 0) {
rem--;
} else {
cmax += taken[j];
}
}
res = max(res, cmax);
}
}
cout << res;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 843,656 | 843,657 | u712630284 | cpp |
p03032 | #include <algorithm>
#include <array>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &e : v)
cin >> e;
vector<int> csum(n + 1);
for (int i = 0; i < n; ++i)
csum[i + 1] = csum[i] + v[i];
int ans = 0;
for (int len = n - k; len < n; ++len) {
for (int l = 0; l + len <= n; ++l) {
priority_queue<int, vector<int>, greater<>> que;
for (int i = 0; i < n; ++i) {
if (l <= i && i < l + len)
continue;
que.push(v[i]);
}
int tmp = csum[l + len] - csum[l];
int d = k - (n - len);
while (d > 0 && !que.empty() && que.top() < 0) {
tmp += que.top();
que.pop();
--d;
}
ans = max(ans, csum[n] - tmp);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &e : v)
cin >> e;
vector<int> csum(n + 1);
for (int i = 0; i < n; ++i)
csum[i + 1] = csum[i] + v[i];
int ans = 0;
for (int len = max(n - k, 0); len < n; ++len) {
for (int l = 0; l + len <= n; ++l) {
priority_queue<int, vector<int>, greater<>> que;
for (int i = 0; i < n; ++i) {
if (l <= i && i < l + len)
continue;
que.push(v[i]);
}
int tmp = csum[l + len] - csum[l];
int d = k - (n - len);
while (d > 0 && !que.empty() && que.top() < 0) {
tmp += que.top();
que.pop();
--d;
}
ans = max(ans, csum[n] - tmp);
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"call.add",
"call.arguments.add"
] | 843,664 | 843,665 | u158253287 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
//関数
// main関数
int main() {
//入力
long N, K;
cin >> N >> K;
vector<long> V(N);
for (int i = 0; i < N; i++) {
cin >> V.at(i);
}
//計算
long ans = -1000000000000, Ls = 0;
multiset<long> Lm;
for (int L = 0; L <= N; L++) {
if (L > 0) {
Ls += V.at(L - 1);
if (V.at(L - 1) < 0)
Lm.insert(V.at(L - 1));
}
long Rs = 0;
multiset<long> M = Lm;
for (int R = 0; L + R <= K; R++) {
if (R > 0) {
Rs += V.at(N - R);
if (V.at(N - R) < 0)
M.insert(V.at(N - R));
}
long Pans = Ls + Rs;
long count = 0;
for (auto ite = M.begin(); (ite != M.end() && count < K - L - R); ite++) {
Pans -= *ite;
count++;
}
// cout<<"L"<<L<<"R"<<R<<"Pans"<<Pans<<endl;
ans = max(Pans, ans);
}
}
//出力
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
//関数
// main関数
int main() {
//入力
long N, K;
cin >> N >> K;
vector<long> V(N);
for (int i = 0; i < N; i++) {
cin >> V.at(i);
}
//計算
long ans = -1000000000000, Ls = 0;
multiset<long> Lm;
for (int L = 0; L <= N; L++) {
if (L > 0) {
Ls += V.at(L - 1);
if (V.at(L - 1) < 0)
Lm.insert(V.at(L - 1));
}
long Rs = 0;
multiset<long> M = Lm;
for (int R = 0; L + R <= min(K, N); R++) {
if (R > 0) {
Rs += V.at(N - R);
if (V.at(N - R) < 0)
M.insert(V.at(N - R));
}
long Pans = Ls + Rs;
long count = 0;
for (auto ite = M.begin(); (ite != M.end() && count < K - L - R); ite++) {
Pans -= *ite;
count++;
}
// cout<<"L"<<L<<"R"<<R<<"Pans"<<Pans<<endl;
ans = max(Pans, ans);
}
}
//出力
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 843,666 | 843,667 | u968365254 | cpp |
p03032 | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int ans = 0;
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
int rest_count = k - l - (n - r);
if (rest_count < 0)
continue;
priority_queue<int, vector<int>, greater<int>> q;
for (int i = 0; i < l; i++) {
q.push(arr[i]);
}
for (int i = n - 1; i >= r; i--) {
q.push(arr[i]);
}
for (;;) {
if (rest_count <= 0)
break;
if (q.size() <= 0)
break;
int tp = q.top();
if (tp < 0) {
q.pop();
rest_count--;
} else {
break;
}
}
int temp_ans = 0;
while (!q.empty()) {
temp_ans += q.top();
q.pop();
}
ans = max(ans, temp_ans);
// cout << "(l,r,ans)=("<<l<<","<<r<<","<<temp_ans<<")"<<endl;
}
}
cout << ans << endl;
/*
vector<int> sum_arr(n+1);
for(int i = 0; i < n; i++) {
sum_arr[i+1] = sum_arr[i]+sum_arr[i];
}
vector<int> sum_minus_arr(n+1);
for(int i = 0; i < n; i++) {
if(arr[i]<0) sum_minus_arr[i+1] = sum_minus_arr[i]+sum_minus_arr[i];
}
*/
return 0;
}
| #include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int ans = 0;
for (int l = 0; l <= n; l++) {
for (int r = l; r <= n; r++) {
int rest_count = k - l - (n - r);
if (rest_count < 0)
continue;
priority_queue<int, vector<int>, greater<int>> q;
for (int i = 0; i < l; i++) {
q.push(arr[i]);
}
for (int i = n - 1; i >= r; i--) {
q.push(arr[i]);
}
for (;;) {
if (rest_count <= 0)
break;
if (q.size() <= 0)
break;
int tp = q.top();
if (tp < 0) {
q.pop();
rest_count--;
} else {
break;
}
}
int temp_ans = 0;
while (!q.empty()) {
temp_ans += q.top();
q.pop();
}
ans = max(ans, temp_ans);
// cout << "(l,r,ans)=("<<l<<","<<r<<","<<temp_ans<<")"<<endl;
}
}
cout << ans << endl;
/*
vector<int> sum_arr(n+1);
for(int i = 0; i < n; i++) {
sum_arr[i+1] = sum_arr[i]+sum_arr[i];
}
vector<int> sum_minus_arr(n+1);
for(int i = 0; i < n; i++) {
if(arr[i]<0) sum_minus_arr[i+1] = sum_minus_arr[i]+sum_minus_arr[i];
}
*/
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,672 | 843,673 | u508729896 | cpp |
p03032 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int a[101], b[101];
int main() {
int n, k, i, j, p, q;
int ans = 0;
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> a[i];
for (i = 1; i <= k; i++) {
for (j = 0; j <= i; j++) {
int l = j, r = i - j, cnt = 0, res = 0;
for (p = 1; p <= l; p++)
b[++cnt] = a[p];
for (p = n; p > n - i + j; p--)
b[++cnt] = a[p];
sort(b + 1, b + cnt + 1);
for (p = 1; p <= k - i && p <= cnt; p++)
if (b[p] >= 0)
break;
else
b[p] = 0;
for (p = 1; p <= cnt; p++)
res += b[p];
ans = max(ans, res);
}
}
cout << ans;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
int a[101], b[101];
int main() {
int n, k, i, j, p, q;
int ans = 0;
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> a[i];
for (i = 1; i <= k && i <= n; i++) {
for (j = 0; j <= i; j++) {
int l = j, r = i - j, cnt = 0, res = 0;
for (p = 1; p <= l; p++)
b[++cnt] = a[p];
for (p = n; p > n - i + j; p--)
b[++cnt] = a[p];
sort(b + 1, b + cnt + 1);
for (p = 1; p <= k - i && p <= cnt; p++)
if (b[p] >= 0)
break;
else
b[p] = 0;
for (p = 1; p <= cnt; p++)
res += b[p];
ans = max(ans, res);
}
}
cout << ans;
}
| [
"control_flow.loop.for.condition.change"
] | 843,690 | 843,691 | u327887532 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
long long mod = 1e9 + 7;
int main(void) {
int n, k;
cin >> n >> k;
vector<long long> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
long long ans = 0;
for (int g = 0; g <= k; g++) {
int p = k - g;
if (p > n)
break;
for (int l = 0; l <= p; l++) {
for (int r = 0; r <= p; r++) {
if (r + l > p)
break;
if (r + l >= n)
r = n - l;
priority_queue<long long> q;
for (int i = 0; i < l; i++)
q.push(-v[i]);
for (int i = 0; i < r; i++)
q.push(-v[n - i - 1]);
for (int i = 0; i < g; i++) {
if (q.empty())
break;
if (q.top() < 0)
break;
q.pop();
}
long long tmp = 0;
while (!q.empty()) {
tmp -= q.top();
q.pop();
}
ans = max(ans, tmp);
}
}
}
cout << ans << endl;
return 0;
}
// EOF
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
long long mod = 1e9 + 7;
int main(void) {
int n, k;
cin >> n >> k;
vector<long long> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
long long ans = 0;
for (int g = 0; g <= k; g++) {
int p = k - g;
if (p > n)
continue;
for (int l = 0; l <= p; l++) {
for (int r = 0; r <= p; r++) {
if (r + l > p)
break;
if (r + l >= n)
r = n - l;
priority_queue<long long> q;
for (int i = 0; i < l; i++)
q.push(-v[i]);
for (int i = 0; i < r; i++)
q.push(-v[n - i - 1]);
for (int i = 0; i < g; i++) {
if (q.empty())
break;
if (q.top() < 0)
break;
q.pop();
}
long long tmp = 0;
while (!q.empty()) {
tmp -= q.top();
q.pop();
}
ans = max(ans, tmp);
}
}
}
cout << ans << endl;
return 0;
}
// EOF
| [
"control_flow.break.remove",
"control_flow.continue.add"
] | 843,694 | 843,695 | u543657872 | cpp |
p03032 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cassert>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define Ma_PI 3.141592653589793
#define eps 0.00000001
#define LONG_INF 300000000000000000
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define MOD 998244353
#define REP(i, n) for (long long i = 0; i < n; ++i)
#define seg_size 524288
double dot(complex<double> a, complex<double> b) {
return a.real() * b.real() + a.imag() * b.imag();
}
double gyaku_dot(complex<double> a, complex<double> b) {
return a.real() * b.imag() - a.imag() * b.real();
}
double leng(complex<double> a) {
return sqrt(a.real() * a.real() + a.imag() * a.imag());
}
double angles(complex<double> a, complex<double> b) {
double cosine = dot(a, b) / (leng(a) * leng(b));
double sine = gyaku_dot(a, b) / (leng(a) * leng(b));
double kaku = acos(cosine);
if (sine <= 0) {
kaku = 2 * Ma_PI - kaku;
}
return kaku;
}
vector<int> convex_hull(vector<complex<double>> a) {
vector<int> ans;
double now_minnest = a[0].real();
int now_itr = 0;
REP(i, a.size()) {
if (now_minnest > a[i].real()) {
now_minnest = a[i].real();
now_itr = i;
}
}
ans.push_back(now_itr);
complex<double> ba(0, 1);
while (true) {
int now_go = 0;
double now_min = 0;
int starter = ans[ans.size() - 1];
for (int i = 0; i < a.size(); ++i) {
if (i != starter) {
double goa = angles(ba, a[i] - a[starter]);
if (goa > now_min) {
now_min = goa;
now_go = i;
}
}
}
if (now_go == ans[0])
break;
ans.push_back(now_go);
ba = complex<double>(a[now_go] - a[starter]);
}
return ans;
}
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
pair<long long, long long> seg_tree[seg_size * 4];
pair<long long, long long> seg_find(long long now, long long n_l, long long n_r,
long long w_l, long long w_r) {
if (w_l <= n_l && n_r <= w_r)
return seg_tree[now];
if (n_r <= w_l || w_r <= n_l)
return make_pair(0, 0);
pair<long long, long long> a = seg_find(now * 2, n_l, (n_l + n_r) / 2, w_l,
w_r),
b = seg_find(now * 2 + 1, (n_l + n_r) / 2, n_r,
w_l, w_r);
a.first += b.first;
a.second += b.second;
return a;
}
long long seg_set(int now) {
seg_tree[now] =
make_pair(seg_tree[now * 2].first + seg_tree[now * 2 + 1].first,
seg_tree[now * 2].second + seg_tree[now * 2 + 1].second);
if (now != 1)
seg_set(now / 2);
return 0;
}
long long inv(long long now) {
long long now_go = MAX_MOD - 2LL;
long long ans = 1;
while (now_go != 0) {
if (now_go % 2 == 1) {
ans *= now;
ans %= MAX_MOD;
}
now *= now;
now %= MAX_MOD;
now_go /= 2;
}
return ans;
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
int n, k;
cin >> n >> k;
vector<int> input;
REP(i, n) {
int a;
cin >> a;
input.push_back(a);
}
long long ans = 0;
for (int i = 0; i <= n; ++i) {
vector<long long> gogo;
long long pre_k = k;
REP(t, i) {
gogo.push_back(input[t]);
pre_k--;
}
if (pre_k >= 0) {
for (int q = n - 1; q >= -1; --q) {
sort(gogo.begin(), gogo.end());
long long pre_ans = 0;
long long nya_k = pre_k;
for (int t = 0; t < gogo.size(); ++t) {
if (gogo[t] >= 0) {
pre_ans += gogo[t];
} else if (nya_k > 0) {
nya_k--;
} else {
pre_ans += gogo[t];
}
}
ans = max(ans, pre_ans);
if (q != -1) {
pre_k--;
gogo.push_back(input[q]);
if (pre_k < 0)
break;
}
}
}
}
cout << ans << endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cassert>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define Ma_PI 3.141592653589793
#define eps 0.00000001
#define LONG_INF 300000000000000000
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define MOD 998244353
#define REP(i, n) for (long long i = 0; i < n; ++i)
#define seg_size 524288
double dot(complex<double> a, complex<double> b) {
return a.real() * b.real() + a.imag() * b.imag();
}
double gyaku_dot(complex<double> a, complex<double> b) {
return a.real() * b.imag() - a.imag() * b.real();
}
double leng(complex<double> a) {
return sqrt(a.real() * a.real() + a.imag() * a.imag());
}
double angles(complex<double> a, complex<double> b) {
double cosine = dot(a, b) / (leng(a) * leng(b));
double sine = gyaku_dot(a, b) / (leng(a) * leng(b));
double kaku = acos(cosine);
if (sine <= 0) {
kaku = 2 * Ma_PI - kaku;
}
return kaku;
}
vector<int> convex_hull(vector<complex<double>> a) {
vector<int> ans;
double now_minnest = a[0].real();
int now_itr = 0;
REP(i, a.size()) {
if (now_minnest > a[i].real()) {
now_minnest = a[i].real();
now_itr = i;
}
}
ans.push_back(now_itr);
complex<double> ba(0, 1);
while (true) {
int now_go = 0;
double now_min = 0;
int starter = ans[ans.size() - 1];
for (int i = 0; i < a.size(); ++i) {
if (i != starter) {
double goa = angles(ba, a[i] - a[starter]);
if (goa > now_min) {
now_min = goa;
now_go = i;
}
}
}
if (now_go == ans[0])
break;
ans.push_back(now_go);
ba = complex<double>(a[now_go] - a[starter]);
}
return ans;
}
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
pair<long long, long long> seg_tree[seg_size * 4];
pair<long long, long long> seg_find(long long now, long long n_l, long long n_r,
long long w_l, long long w_r) {
if (w_l <= n_l && n_r <= w_r)
return seg_tree[now];
if (n_r <= w_l || w_r <= n_l)
return make_pair(0, 0);
pair<long long, long long> a = seg_find(now * 2, n_l, (n_l + n_r) / 2, w_l,
w_r),
b = seg_find(now * 2 + 1, (n_l + n_r) / 2, n_r,
w_l, w_r);
a.first += b.first;
a.second += b.second;
return a;
}
long long seg_set(int now) {
seg_tree[now] =
make_pair(seg_tree[now * 2].first + seg_tree[now * 2 + 1].first,
seg_tree[now * 2].second + seg_tree[now * 2 + 1].second);
if (now != 1)
seg_set(now / 2);
return 0;
}
long long inv(long long now) {
long long now_go = MAX_MOD - 2LL;
long long ans = 1;
while (now_go != 0) {
if (now_go % 2 == 1) {
ans *= now;
ans %= MAX_MOD;
}
now *= now;
now %= MAX_MOD;
now_go /= 2;
}
return ans;
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
int n, k;
cin >> n >> k;
vector<int> input;
REP(i, n) {
int a;
cin >> a;
input.push_back(a);
}
long long ans = 0;
for (int i = 0; i <= n; ++i) {
vector<long long> gogo;
long long pre_k = k;
REP(t, i) {
gogo.push_back(input[t]);
pre_k--;
}
if (pre_k >= 0) {
for (int q = n - 1; q >= i - 1; --q) {
sort(gogo.begin(), gogo.end());
long long pre_ans = 0;
long long nya_k = pre_k;
for (int t = 0; t < gogo.size(); ++t) {
if (gogo[t] >= 0) {
pre_ans += gogo[t];
} else if (nya_k > 0) {
nya_k--;
} else {
pre_ans += gogo[t];
}
}
ans = max(ans, pre_ans);
if (q != -1) {
pre_k--;
gogo.push_back(input[q]);
if (pre_k < 0)
break;
}
}
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 843,702 | 843,703 | u545022164 | cpp |
p03032 | #include <bits/stdc++.h>
#define int long long
#define uint unsigned int
#define ld long double
#define showoff \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define pii pair<int, int>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define RFOR(i, a, b) for (int i = a; i > b; --i)
#define f first
#define se second
#define maxn 200005
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define mod 1000000007
#define pqueue priority_queue<int>
#define pdqueue priority_queue<int, vector<int>, greater<int>>
using namespace std;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int power(int a, int n) {
if (n == 1)
return a;
if (n == 0)
return 1;
if (n % 2)
return a * power(a * a, n / 2);
return power(a * a, n / 2);
}
const int md = 998244353;
const int inf = (int)1e18;
/*int inverse(int x){
return power(x,mod-2)%mod;//little fermat....
}*/
signed main() {
showoff;
/*int n,ans[maxn];
cin >> n;
vector<pair<pair<string,int>,int> >v;
FOR(i,1,n+1){
int sc;
string s;
cin >> s >> sc;
v.pb({{s,-sc},i});
}
sort(v.begin(),v.end());
FOR(i,0,n)ans[v[i].se] = i+1;
FOR(i,1,n+1)cout << ans[i] << "\n";*/
int n, k, ans = 0;
cin >> n >> k;
vector<int> v(n + 5);
FOR(i, 1, n + 1) cin >> v[i];
FOR(i, 0, k + 1) {
FOR(j, 0, k + 1) {
if (i + j > k)
break;
vector<int> pos, neg;
int tot = 0;
FOR(l, 1, i + 1) if (v[l] > 0) pos.pb(v[l]), tot += v[l];
else if (v[l] < 0) neg.pb(v[l]), tot += v[l];
FOR(l, 1, j + 1)
if (v[n - l + 1] > 0) pos.pb(v[n - l + 1]),
tot += v[n - l + 1];
else if (v[n - l + 1] < 0) neg.pb(v[n - l + 1]), tot += v[n - l + 1];
sort(neg.begin(), neg.end());
FOR(l, 0, min(sz(neg), k - i - j)) tot += neg[l];
ans = max(ans, tot);
}
}
cout << ans << "\n";
return 0;
}
//*->for large size of matrix take int not long long if possible......
//*->always take maximum as inf for safer side ... | #include <bits/stdc++.h>
#define int long long
#define uint unsigned int
#define ld long double
#define showoff \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define pii pair<int, int>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define RFOR(i, a, b) for (int i = a; i > b; --i)
#define f first
#define se second
#define maxn 200005
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define mod 1000000007
#define pqueue priority_queue<int>
#define pdqueue priority_queue<int, vector<int>, greater<int>>
using namespace std;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int power(int a, int n) {
if (n == 1)
return a;
if (n == 0)
return 1;
if (n % 2)
return a * power(a * a, n / 2);
return power(a * a, n / 2);
}
const int md = 998244353;
const int inf = (int)1e18;
/*int inverse(int x){
return power(x,mod-2)%mod;//little fermat....
}*/
signed main() {
showoff;
/*int n,ans[maxn];
cin >> n;
vector<pair<pair<string,int>,int> >v;
FOR(i,1,n+1){
int sc;
string s;
cin >> s >> sc;
v.pb({{s,-sc},i});
}
sort(v.begin(),v.end());
FOR(i,0,n)ans[v[i].se] = i+1;
FOR(i,1,n+1)cout << ans[i] << "\n";*/
int n, k, ans = 0;
cin >> n >> k;
vector<int> v(n + 5);
FOR(i, 1, n + 1) cin >> v[i];
FOR(i, 0, k + 1) {
FOR(j, 0, k + 1) {
if (i + j > min(n, k))
break;
vector<int> pos, neg;
int tot = 0;
FOR(l, 1, i + 1) if (v[l] > 0) pos.pb(v[l]), tot += v[l];
else if (v[l] < 0) neg.pb(v[l]), tot += v[l];
FOR(l, 1, j + 1)
if (v[n - l + 1] > 0) pos.pb(v[n - l + 1]),
tot += v[n - l + 1];
else if (v[n - l + 1] < 0) neg.pb(v[n - l + 1]), tot += v[n - l + 1];
sort(neg.begin(), neg.end());
FOR(l, 0, min(sz(neg), k - i - j)) tot -= neg[l];
ans = max(ans, tot);
}
}
cout << ans << "\n";
return 0;
}
//*->for large size of matrix take int not long long if possible......
//*->always take maximum as inf for safer side ... | [
"control_flow.branch.if.condition.change",
"call.add",
"expression.operator.change"
] | 843,706 | 843,707 | u578751202 | cpp |
p03032 | #include <bits/stdc++.h>
#define int long long
#define uint unsigned int
#define ld long double
#define showoff \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define pii pair<int, int>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define RFOR(i, a, b) for (int i = a; i > b; --i)
#define f first
#define se second
#define maxn 200005
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define mod 1000000007
#define pqueue priority_queue<int>
#define pdqueue priority_queue<int, vector<int>, greater<int>>
using namespace std;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int power(int a, int n) {
if (n == 1)
return a;
if (n == 0)
return 1;
if (n % 2)
return a * power(a * a, n / 2);
return power(a * a, n / 2);
}
const int md = 998244353;
const int inf = (int)1e18;
/*int inverse(int x){
return power(x,mod-2)%mod;//little fermat....
}*/
signed main() {
showoff;
/*int n,ans[maxn];
cin >> n;
vector<pair<pair<string,int>,int> >v;
FOR(i,1,n+1){
int sc;
string s;
cin >> s >> sc;
v.pb({{s,-sc},i});
}
sort(v.begin(),v.end());
FOR(i,0,n)ans[v[i].se] = i+1;
FOR(i,1,n+1)cout << ans[i] << "\n";*/
int n, k, ans = 0;
cin >> n >> k;
vector<int> v(n + 5);
FOR(i, 1, n + 1) cin >> v[i];
FOR(i, 0, k + 1) {
FOR(j, 0, k + 1) {
if (i + j > k)
break;
vector<int> pos, neg;
int tot = 0;
FOR(l, 1, i + 1) if (v[l] > 0) pos.pb(v[l]), tot += v[l];
else if (v[l] < 0) neg.pb(v[l]), tot += v[l];
FOR(l, 1, j + 1)
if (v[n - l + 1] > 0) pos.pb(v[n - l + 1]),
tot += v[n - l + 1];
else if (v[n - l + 1] < 0) neg.pb(v[n - l + 1]), tot += v[n - l + 1];
sort(neg.begin(), neg.end());
FOR(l, 0, min(sz(neg), k - i - j)) tot -= neg[l];
ans = max(ans, tot);
}
}
cout << ans << "\n";
return 0;
}
//*->for large size of matrix take int not long long if possible......
//*->always take maximum as inf for safer side ... | #include <bits/stdc++.h>
#define int long long
#define uint unsigned int
#define ld long double
#define showoff \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define pii pair<int, int>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define RFOR(i, a, b) for (int i = a; i > b; --i)
#define f first
#define se second
#define maxn 200005
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define mod 1000000007
#define pqueue priority_queue<int>
#define pdqueue priority_queue<int, vector<int>, greater<int>>
using namespace std;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int power(int a, int n) {
if (n == 1)
return a;
if (n == 0)
return 1;
if (n % 2)
return a * power(a * a, n / 2);
return power(a * a, n / 2);
}
const int md = 998244353;
const int inf = (int)1e18;
/*int inverse(int x){
return power(x,mod-2)%mod;//little fermat....
}*/
signed main() {
showoff;
/*int n,ans[maxn];
cin >> n;
vector<pair<pair<string,int>,int> >v;
FOR(i,1,n+1){
int sc;
string s;
cin >> s >> sc;
v.pb({{s,-sc},i});
}
sort(v.begin(),v.end());
FOR(i,0,n)ans[v[i].se] = i+1;
FOR(i,1,n+1)cout << ans[i] << "\n";*/
int n, k, ans = 0;
cin >> n >> k;
vector<int> v(n + 5);
FOR(i, 1, n + 1) cin >> v[i];
FOR(i, 0, k + 1) {
FOR(j, 0, k + 1) {
if (i + j > min(n, k))
break;
vector<int> pos, neg;
int tot = 0;
FOR(l, 1, i + 1) if (v[l] > 0) pos.pb(v[l]), tot += v[l];
else if (v[l] < 0) neg.pb(v[l]), tot += v[l];
FOR(l, 1, j + 1)
if (v[n - l + 1] > 0) pos.pb(v[n - l + 1]),
tot += v[n - l + 1];
else if (v[n - l + 1] < 0) neg.pb(v[n - l + 1]), tot += v[n - l + 1];
sort(neg.begin(), neg.end());
FOR(l, 0, min(sz(neg), k - i - j)) tot -= neg[l];
ans = max(ans, tot);
}
}
cout << ans << "\n";
return 0;
}
//*->for large size of matrix take int not long long if possible......
//*->always take maximum as inf for safer side ... | [
"control_flow.branch.if.condition.change",
"call.add"
] | 843,708 | 843,707 | u578751202 | cpp |
p03032 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define SHOWP(x) cerr << "[" << (x).FI << ", " << (x).SE << "]";
#define SHOWX(x) cerr << #x << ": " << x << endl;
#define SHOWVEC(v, e) \
REP(i, e) cerr << (v[i]) << ' '; \
cerr << endl;
#define SHOW2D(a, h, w) \
REP(i, h) { \
REP(j, w) cerr << setw(3) << (a[i][j]) << ' '; \
cerr << endl; \
}
constexpr int INF = 1100000000;
constexpr long long LLINF = 1100000000000000000LL;
constexpr long long MOD = 1000000007;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
int N, K;
cin >> N >> K;
vector<ll> V(N);
REP(i, N) cin >> V[i];
ll ans = 0;
if (N <= K) {
for (auto &e : V) {
ans += max(0LL, e);
}
cout << ans << endl;
return 0;
}
vector<ll> Vr(V);
reverse(ALL(Vr));
REP(i, K) {
REP(j, K - i) {
vector<ll> v;
REP(k, i) v.PB(V[k]);
REP(k, j) v.PB(Vr[k]);
if (v.empty())
continue;
sort(ALL(v));
ll tmp = 0;
REP(k, v.size()) tmp += v[k];
REP(k, K - i - j) {
if (k >= v.size() || v[k] > 0)
break;
tmp -= v[k];
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define SHOWP(x) cerr << "[" << (x).FI << ", " << (x).SE << "]";
#define SHOWX(x) cerr << #x << ": " << x << endl;
#define SHOWVEC(v, e) \
REP(i, e) cerr << (v[i]) << ' '; \
cerr << endl;
#define SHOW2D(a, h, w) \
REP(i, h) { \
REP(j, w) cerr << setw(3) << (a[i][j]) << ' '; \
cerr << endl; \
}
constexpr int INF = 1100000000;
constexpr long long LLINF = 1100000000000000000LL;
constexpr long long MOD = 1000000007;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
int N, K;
cin >> N >> K;
vector<ll> V(N);
REP(i, N) cin >> V[i];
ll ans = 0;
if (N <= K) {
for (auto &e : V) {
ans += max(0LL, e);
}
cout << ans << endl;
return 0;
}
vector<ll> Vr(V);
reverse(ALL(Vr));
REP(i, K + 1) {
REP(j, K - i + 1) {
vector<ll> v;
REP(k, i) v.PB(V[k]);
REP(k, j) v.PB(Vr[k]);
if (v.empty()) {
continue;
}
sort(ALL(v));
ll tmp = 0;
REP(k, v.size()) tmp += v[k];
REP(k, K - i - j) {
if (k >= v.size() || v[k] > 0)
break;
tmp -= v[k];
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 843,711 | 843,712 | u973997867 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
signed main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &&u : v)
cin >> u;
int tmp, ans = 0ll;
vector<int> val;
for (int i = k; i >= 0; i--) {
for (int r = 0; r <= i; r++) {
val.clear();
rep(j, r) val.push_back(v[j]);
rep(j, i - r) val.push_back(v[n - 1 - j]);
sort(begin(val), end(val), greater<int>());
// for (auto&& u : val) cerr << u << ((&u < &val.back()) ? " " :
// "\n");
int cnt = k - i;
while (cnt--) {
if (val.back() < 0ll)
val.pop_back();
}
// for (auto&& u : val) tmp += u;
tmp = accumulate(begin(val), end(val), 0ll);
// for (auto&& u : val) cerr << u << " ";
// cerr << endl;
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
signed main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &&u : v)
cin >> u;
int tmp, ans = 0ll;
vector<int> val;
for (int i = min(k, n); i >= 0; i--) {
for (int r = 0; r <= i; r++) {
val.clear();
rep(j, r) val.push_back(v[j]);
rep(j, i - r) val.push_back(v[n - 1 - j]);
sort(begin(val), end(val), greater<int>());
// for (auto&& u : val) cerr << u << ((&u < &val.back()) ? " " :
// "\n");
int cnt = k - i;
while (cnt--) {
if (val.back() < 0ll)
val.pop_back();
}
// for (auto&& u : val) tmp += u;
tmp = accumulate(begin(val), end(val), 0ll);
// for (auto&& u : val) cerr << u << " ";
// cerr << endl;
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| [
"control_flow.loop.for.initializer.change",
"call.add",
"call.arguments.add"
] | 843,719 | 843,718 | u731175398 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
int ans = 0;
for (int i = 0; i <= k; ++i) {
for (int j = 0; j <= i; ++j) {
vector<int> vv;
for (int l = 0; l < i - j; ++l)
vv.push_back(v[l]);
for (int l = n - 1; l > n - 1 - j; --l)
vv.push_back(v[l]);
sort(vv.begin(), vv.end());
int sum = accumulate(vv.begin(), vv.end(), 0);
for (int l = 0; l < min(k - i, i); ++l)
if (vv[l] < 0)
sum -= vv[l];
ans = max(ans, sum);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
int ans = 0;
for (int i = 0; i <= min(n, k); ++i) {
for (int j = 0; j <= i; ++j) {
vector<int> vv;
for (int l = 0; l < i - j; ++l)
vv.push_back(v[l]);
for (int l = n - 1; l > n - 1 - j; --l)
vv.push_back(v[l]);
sort(vv.begin(), vv.end());
int sum = accumulate(vv.begin(), vv.end(), 0);
for (int l = 0; l < min(k - i, i); ++l)
if (vv[l] < 0)
sum -= vv[l];
ans = max(ans, sum);
}
}
cout << ans << endl;
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 843,722 | 843,723 | u640800420 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define ALL(c) (c).begin(), (c).end()
const int MOD = 1000000007;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int mx = 0;
int limit = min(n, k);
for (int i = 0; i < limit; i++) {
for (int j = 0; j < limit - i; j++) {
int t = 0;
vector<int> m;
for (int l = 0; l < i; l++) {
t += v[l];
if (v[l] < 0) {
m.push_back(v[l]);
}
}
for (int r = 0; r < j; r++) {
t += v[n - 1 - r];
if (v[n - i - r] < 0) {
m.push_back(v[n - 1 - r]);
}
}
sort(ALL(m));
for (int d = 0; d < min(k - (i + j), (int)m.size()); d++) {
t -= m[d];
}
mx = max(mx, t);
}
}
cout << mx << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define ALL(c) (c).begin(), (c).end()
const int MOD = 1000000007;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int mx = 0;
int limit = min(n, k);
for (int i = 0; i <= limit; i++) {
for (int j = 0; j <= limit - i; j++) {
int t = 0;
vector<int> m;
for (int l = 0; l < i; l++) {
t += v[l];
if (v[l] < 0) {
m.push_back(v[l]);
}
}
for (int r = 0; r < j; r++) {
t += v[n - 1 - r];
if (v[n - 1 - r] < 0) {
m.push_back(v[n - 1 - r]);
}
}
sort(ALL(m));
for (int d = 0; d < min(k - (i + j), (int)m.size()); d++) {
t -= m[d];
}
mx = max(mx, t);
}
}
cout << mx << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 843,726 | 843,727 | u540491484 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int ans = 0;
for (int h = 0; h < n; h++) {
vector<int> u;
for (int i = 0; i < h; i++)
u.push_back(v[i]);
for (int t = n; t >= 0; t--) {
if (t == n || h + (n - t - 1) < k && h <= t) {
if (t != n)
u.push_back(v[t]);
int sum = 0;
if (u.size() != 0) {
for (int x : u)
sum += x;
sort(u.begin(), u.end());
for (int i = 0; i < (k - (int)u.size()); i++)
if (i < (int)u.size() && u[i] < 0)
sum -= u[i];
}
ans = max(ans, sum);
}
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int ans = 0;
for (int h = 0; h < n; h++) {
vector<int> u;
for (int i = 0; i < h; i++)
u.push_back(v[i]);
for (int t = n; t >= 0; t--) {
if ((t == n && h < k) || h + (n - t - 1) < k && h <= t) {
if (t != n)
u.push_back(v[t]);
int sum = 0;
if (u.size() != 0) {
for (int x : u)
sum += x;
sort(u.begin(), u.end());
for (int i = 0; i < (k - (int)u.size()); i++)
if (i < (int)u.size() && u[i] < 0)
sum -= u[i];
}
ans = max(ans, sum);
}
}
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 843,732 | 843,733 | u754651673 | cpp |
p03032 | #include "bits/stdc++.h"
#define REP(i, a, b) for (int i = (a); i <= (b); ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define FORV(a, A) for (auto &a : A)
using namespace std;
using ll = long long;
int N, K;
int cost(int cl, int cr, int amari, vector<ll> V) {
vector<ll> A(cl + cr);
int n = 0;
for (int i = 0; i < cl; i++) {
A[n] = V[i];
n++;
}
for (int i = 0; i < cr; i++) {
A[n] = V[N - i - 1];
n++;
}
sort(A.begin(), A.end());
int64_t sum = 0;
for (int i = amari; i < n; i++)
sum += A[i];
return sum;
}
void Main() {
cin >> N >> K;
vector<ll> V(N);
FORV(v, V)
cin >> v;
int cl, cr;
int64_t mm = LONG_MIN;
int64_t sum;
for (int k = 0; k <= K; k++) {
for (int amari = 0; amari <= k / 2; amari++) {
if (K - amari > N)
continue;
for (int cl = 0; cl <= k - amari; cl++) {
sum = cost(cl, k - amari - cl, amari, V);
mm = max(mm, sum);
}
}
}
cout << mm << endl;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
| #include "bits/stdc++.h"
#define REP(i, a, b) for (int i = (a); i <= (b); ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define FORV(a, A) for (auto &a : A)
using namespace std;
using ll = long long;
int N, K;
int cost(int cl, int cr, int amari, vector<ll> V) {
vector<ll> A(cl + cr);
int n = 0;
for (int i = 0; i < cl; i++) {
A[n] = V[i];
n++;
}
for (int i = 0; i < cr; i++) {
A[n] = V[N - i - 1];
n++;
}
sort(A.begin(), A.end());
int64_t sum = 0;
for (int i = amari; i < n; i++)
sum += A[i];
return sum;
}
void Main() {
cin >> N >> K;
vector<ll> V(N);
FORV(v, V)
cin >> v;
int cl, cr;
int64_t mm = LONG_MIN;
int64_t sum;
for (int k = 0; k <= K; k++) {
for (int amari = 0; amari <= k / 2; amari++) {
if (k - amari > N)
continue;
for (int cl = 0; cl <= k - amari; cl++) {
sum = cost(cl, k - amari - cl, amari, V);
mm = max(mm, sum);
}
}
}
cout << mm << endl;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 843,734 | 843,735 | u747184036 | cpp |
p03032 | #include <bits/stdc++.h>
#define range(i, l, r) for (int(i) = (l); (i) < (r); (i)++)
#define reversed_range(i, l, r) for (int(i) = (r)-1; (i) >= l; (i)--)
using namespace std;
template <typename T> using vec = vector<T>;
using lint = long long;
using ulint = unsigned long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
template <typename S, typename T>
ostream &operator<<(ostream &os, pair<S, T> p) {
os << "(";
os << p.first << ", " << p.second;
return os << ")";
}
template <typename T> ostream &operator<<(ostream &os, vec<T> v) {
os << "[";
for (int i = 0; i < v.size() - 1; i++) {
os << v.at(i) << ", ";
}
return os << v.at(v.size() - 1) << "]";
}
template <typename T> ostream &operator<<(ostream &os, set<T> &s) {
os << "{";
auto it_first_item = s.begin();
cout << *it_first_item;
for (auto it = ++it_first_item; it != s.end(); it++) {
cout << ", " << *it;
}
return cout << "}";
}
template <typename T> ostream &operator<<(ostream &os, unordered_set<T> &s) {
os << "{";
auto it_first_item = s.begin();
cout << *it_first_item;
for (auto it = ++it_first_item; it != s.end(); it++) {
cout << ", " << *it;
}
return cout << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &os, map<K, V> m) {
os << "{";
auto it_first_item = m.begin();
cout << it_first_item->first << ": " << it_first_item->second;
for (auto it = ++it_first_item; it != m.end(); it++) {
cout << ", " << it->first << ": " << it->second;
}
return os << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &os, unordered_map<K, V> m) {
os << "{";
auto it_first_item = m.begin();
cout << it_first_item->first << ": " << it_first_item->second;
for (auto it = ++it_first_item; it != m.end(); it++) {
cout << ", " << it->first << ": " << it->second;
}
return os << "}";
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vec<lint> cylinder;
range(i, 0, N) {
lint jewelry;
cin >> jewelry;
cylinder.emplace_back(jewelry);
}
lint max_sum_value = 0;
range(num_taken, 0, min(K + 1, N + 1)) {
range(left, 0, num_taken + 1) {
set<lint> taken;
range(i, 0, left) taken.emplace(cylinder.at(i));
range(i, 0, num_taken - left) taken.emplace(cylinder.at(N - i - 1));
int remaining_steps = K - num_taken;
while (remaining_steps && !taken.empty() && *taken.begin() < 0) {
lint poped_item = *taken.begin();
taken.erase(poped_item);
remaining_steps -= 1;
}
lint sum_value = 0;
for (const auto item : taken)
sum_value += item;
max_sum_value = max(max_sum_value, sum_value);
}
}
cout << max_sum_value << "\n";
} | #include <bits/stdc++.h>
#define range(i, l, r) for (int(i) = (l); (i) < (r); (i)++)
#define reversed_range(i, l, r) for (int(i) = (r)-1; (i) >= l; (i)--)
using namespace std;
template <typename T> using vec = vector<T>;
using lint = long long;
using ulint = unsigned long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
template <typename S, typename T>
ostream &operator<<(ostream &os, pair<S, T> p) {
os << "(";
os << p.first << ", " << p.second;
return os << ")";
}
template <typename T> ostream &operator<<(ostream &os, vec<T> v) {
os << "[";
for (int i = 0; i < v.size() - 1; i++) {
os << v.at(i) << ", ";
}
return os << v.at(v.size() - 1) << "]";
}
template <typename T> ostream &operator<<(ostream &os, set<T> &s) {
os << "{";
auto it_first_item = s.begin();
cout << *it_first_item;
for (auto it = ++it_first_item; it != s.end(); it++) {
cout << ", " << *it;
}
return cout << "}";
}
template <typename T> ostream &operator<<(ostream &os, unordered_set<T> &s) {
os << "{";
auto it_first_item = s.begin();
cout << *it_first_item;
for (auto it = ++it_first_item; it != s.end(); it++) {
cout << ", " << *it;
}
return cout << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &os, map<K, V> m) {
os << "{";
auto it_first_item = m.begin();
cout << it_first_item->first << ": " << it_first_item->second;
for (auto it = ++it_first_item; it != m.end(); it++) {
cout << ", " << it->first << ": " << it->second;
}
return os << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &os, unordered_map<K, V> m) {
os << "{";
auto it_first_item = m.begin();
cout << it_first_item->first << ": " << it_first_item->second;
for (auto it = ++it_first_item; it != m.end(); it++) {
cout << ", " << it->first << ": " << it->second;
}
return os << "}";
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vec<lint> cylinder;
range(i, 0, N) {
lint jewelry;
cin >> jewelry;
cylinder.emplace_back(jewelry);
}
lint max_sum_value = 0;
range(num_taken, 0, min(K + 1, N + 1)) {
range(left, 0, num_taken + 1) {
multiset<lint> taken;
range(i, 0, left) taken.emplace(cylinder.at(i));
range(i, 0, num_taken - left) taken.emplace(cylinder.at(N - i - 1));
int remaining_steps = K - num_taken;
while (remaining_steps && !taken.empty() && *taken.begin() < 0) {
lint poped_item = *taken.begin();
taken.erase(poped_item);
remaining_steps -= 1;
}
lint sum_value = 0;
for (const auto item : taken)
sum_value += item;
max_sum_value = max(max_sum_value, sum_value);
}
}
cout << max_sum_value << "\n";
} | [
"variable_declaration.type.change"
] | 843,736 | 843,737 | u069838609 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]) {
int N, K;
int V[51];
vector<int> q;
cin >> N >> K;
for (int i = 0; i < N; i++) {
int V;
cin >> V;
q.push_back(V);
}
int a = min(N, K);
int max = 0;
for (int i = 0; i < a; i++) {
for (int j = 0; j < a - i; j++) {
vector<int> q2;
for (int k = 0; k < i; k++) {
int L = q[k];
q2.push_back(L);
}
for (int k = 0; k < j; k++) {
int R = q[N - 1 - k];
q2.push_back(R);
}
sort(q2.begin(), q2.end());
for (int k = 0; k < K - i - j && q2.size() > 0; k++) {
if (q2[0] < 0) {
q2.erase(q2.begin());
}
}
int sum = 0;
for (int k = 0; k < q2.size(); k++) {
sum += q2[k];
}
max = sum > max ? sum : max;
}
}
cout << max << "\n";
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]) {
int N, K;
int V[51];
vector<int> q;
cin >> N >> K;
for (int i = 0; i < N; i++) {
int V;
cin >> V;
q.push_back(V);
}
int a = min(N, K);
int max = 0;
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= a - i; j++) {
vector<int> q2;
for (int k = 0; k < i; k++) {
int L = q[k];
q2.push_back(L);
}
for (int k = 0; k < j; k++) {
int R = q[N - 1 - k];
q2.push_back(R);
}
sort(q2.begin(), q2.end());
for (int k = 0; k < K - i - j && q2.size() > 0; k++) {
if (q2[0] < 0) {
q2.erase(q2.begin());
}
}
int sum = 0;
for (int k = 0; k < q2.size(); k++) {
sum += q2[k];
}
max = sum > max ? sum : max;
}
}
cout << max << "\n";
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,744 | 843,745 | u993229809 | cpp |
p03032 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rrep(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)
#define fore(i, a) for (auto &i : a)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define isin(i, a, b) ((a) <= (i) && (i) < (b))
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define fi first
#define se second
#define pb push_back
#define sz(a) (int)(a).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
using ll = long long;
using unit = unsigned;
using ull = unsigned long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vp = vector<P>;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
template <class T> void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> void POSS(T condition) {
if (condition)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
}
template <class T> void Poss(T condition) {
if (condition)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> T gcd(T a, T b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
constexpr double eps = 1e-10;
constexpr int inf = INT_MAX / 2;
constexpr ll infl = 1LL << 60;
void _main() {
int N, K;
cin >> N >> K;
vi V(N);
rep(i, 0, N) cin >> V[i];
int ans = 0;
rep(l, 0, K) rep(r, 0, K - l) {
if (l + r > N)
break;
vi S;
int d = K - l - r;
int t = 0;
rep(li, 0, l) {
t += V[li];
S.emplace_back(V[li]);
}
rep(ri, N - r, N) {
t += V[ri];
S.emplace_back(V[ri]);
}
sort(all(S));
rep(i, 0, d) {
if (i >= sz(S))
break;
if (S[i] > 0)
break;
t -= S[i];
}
chmax(ans, t);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rrep(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)
#define fore(i, a) for (auto &i : a)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define isin(i, a, b) ((a) <= (i) && (i) < (b))
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define fi first
#define se second
#define pb push_back
#define sz(a) (int)(a).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
using ll = long long;
using unit = unsigned;
using ull = unsigned long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vp = vector<P>;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
template <class T> void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> void POSS(T condition) {
if (condition)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
}
template <class T> void Poss(T condition) {
if (condition)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> T gcd(T a, T b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
constexpr double eps = 1e-10;
constexpr int inf = INT_MAX / 2;
constexpr ll infl = 1LL << 60;
void _main() {
int N, K;
cin >> N >> K;
vi V(N);
rep(i, 0, N) cin >> V[i];
int ans = 0;
rep(l, 0, K + 1) rep(r, 0, K - l + 1) {
if (l + r > N)
break;
vi S;
int d = K - l - r;
int t = 0;
rep(li, 0, l) {
t += V[li];
S.emplace_back(V[li]);
}
rep(ri, N - r, N) {
t += V[ri];
S.emplace_back(V[ri]);
}
sort(all(S));
rep(i, 0, d) {
if (i >= sz(S))
break;
if (S[i] > 0)
break;
t -= S[i];
}
chmax(ans, t);
}
cout << ans << endl;
} | [
"expression.operation.binary.add"
] | 843,746 | 843,747 | u430494842 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int ans = 0;
for (int d = 0; d < K; d++) {
for (int l = 0; l + d < K; l++) {
if (d + l > N)
continue;
int tmp_sum = 0;
vector<int> tmp_elm;
for (int i = 0; i < d; i++) {
tmp_sum += V[i];
tmp_elm.push_back(V[i]);
}
for (int i = 0; i < l; i++) {
tmp_sum += V[N - 1 - i];
tmp_elm.push_back(V[N - 1 - i]);
}
sort(tmp_elm.begin(), tmp_elm.end());
int N_add = K - d - l;
for (int i = 0; i < N_add; i++) {
if (i >= tmp_elm.size())
break;
if (tmp_elm[i] >= 0)
break;
tmp_sum -= tmp_elm[i];
}
chmax(ans, tmp_sum);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int ans = 0;
for (int d = 0; d <= K; d++) {
for (int l = 0; l + d <= K; l++) {
if (d + l > N)
continue;
int tmp_sum = 0;
vector<int> tmp_elm;
for (int i = 0; i < d; i++) {
tmp_sum += V[i];
tmp_elm.push_back(V[i]);
}
for (int i = 0; i < l; i++) {
tmp_sum += V[N - 1 - i];
tmp_elm.push_back(V[N - 1 - i]);
}
sort(tmp_elm.begin(), tmp_elm.end());
int N_add = K - d - l;
for (int i = 0; i < N_add; i++) {
if (i >= tmp_elm.size())
break;
if (tmp_elm[i] >= 0)
break;
tmp_sum -= tmp_elm[i];
}
chmax(ans, tmp_sum);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,751 | 843,752 | u187878098 | cpp |
p03032 | #include <algorithm>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll MOD = 1e9 + 7;
const double EPS = 1e-9;
int main(int argc, const char *argv[]) {
int N, K;
cin >> N >> K;
vector<int> v(N);
for (int i = 0; i < N; i++)
cin >> v[i];
vector<int> vl, vr;
int ans = 0, tmp;
for (int l = 0; l < min(N, K); l++) {
vl.clear();
for (int i = 0; i < l; i++)
vl.push_back(v[i]);
for (int r = 0; r < min(N - l, K - l); r++) {
vr.clear();
for (int i = 0; i < r; i++)
vr.push_back(v[N - 1 - i]);
vr.insert(vr.end(), vl.begin(), vl.end());
sort(vr.begin(), vr.end());
for (int k = 0; k <= K - l - r; k++) {
int elim = min(k, (int)vr.size());
tmp = accumulate(vr.begin() + elim, vr.end(), 0);
ans = max(ans, tmp);
}
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll MOD = 1e9 + 7;
const double EPS = 1e-9;
int main(int argc, const char *argv[]) {
int N, K;
cin >> N >> K;
vector<int> v(N);
for (int i = 0; i < N; i++)
cin >> v[i];
vector<int> vl, vr;
int ans = 0, tmp;
for (int l = 0; l <= min(N, K); l++) {
vl.clear();
for (int i = 0; i < l; i++)
vl.push_back(v[i]);
for (int r = 0; r <= min(N - l, K - l); r++) {
vr.clear();
for (int i = 0; i < r; i++)
vr.push_back(v[N - 1 - i]);
vr.insert(vr.end(), vl.begin(), vl.end());
sort(vr.begin(), vr.end());
for (int k = 0; k <= K - l - r; k++) {
int elim = min(k, (int)vr.size());
tmp = accumulate(vr.begin() + elim, vr.end(), 0);
ans = max(ans, tmp);
}
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,759 | 843,760 | u320491590 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rrep(i, n) for (ll i = n - 1; i >= 0; i--)
#define range(i, n, m) for (ll i = n; i < m; i++)
#define rrange(i, n, m) for (ll i = n - 1; i = > m; i--)
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vp vector<pair<ll, ll>>
#define vvp vector<vector<pair<ll, ll>>>
//#define MOD 998244353
typedef long long int ll;
typedef unsigned long long int ull;
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;
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
vector<ll> V(N);
rep(i, N) { cin >> V[i]; }
ll max = 0;
rep(A, min(N, K) + 1) {
rep(B, min(N, K) - A + 1) {
vl minus;
ll sum = 0;
rep(l, A) {
sum += V[l];
if (V[l] < 0)
minus.push_back(V[l]);
}
rep(r, B) {
sum += V[N - 1 - r];
if (V[N - 1 - r] < 0)
minus.push_back(V[N - 1 - r]);
}
sort(minus.begin(), minus.end(), greater<ll>());
rep(k, K - A + B) {
if (minus.size() == 0)
break;
sum -= minus.back();
minus.pop_back();
}
chmax(max, sum);
}
}
cout << max << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rrep(i, n) for (ll i = n - 1; i >= 0; i--)
#define range(i, n, m) for (ll i = n; i < m; i++)
#define rrange(i, n, m) for (ll i = n - 1; i = > m; i--)
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vp vector<pair<ll, ll>>
#define vvp vector<vector<pair<ll, ll>>>
//#define MOD 998244353
typedef long long int ll;
typedef unsigned long long int ull;
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;
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
vector<ll> V(N);
rep(i, N) { cin >> V[i]; }
ll max = 0;
rep(A, min(N, K) + 1) {
rep(B, min(N, K) - A + 1) {
vl minus;
ll sum = 0;
rep(l, A) {
sum += V[l];
if (V[l] < 0)
minus.push_back(V[l]);
}
rep(r, B) {
sum += V[N - 1 - r];
if (V[N - 1 - r] < 0)
minus.push_back(V[N - 1 - r]);
}
sort(minus.begin(), minus.end(), greater<ll>());
rep(k, K - A - B) {
if (minus.size() == 0)
break;
sum -= minus.back();
minus.pop_back();
}
chmax(max, sum);
}
}
cout << max << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 843,765 | 843,766 | u991974907 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rrep(i, n) for (ll i = n - 1; i >= 0; i--)
#define range(i, n, m) for (ll i = n; i < m; i++)
#define rrange(i, n, m) for (ll i = n - 1; i = > m; i--)
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vp vector<pair<ll, ll>>
#define vvp vector<vector<pair<ll, ll>>>
//#define MOD 998244353
typedef long long int ll;
typedef unsigned long long int ull;
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;
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
vector<ll> V(N);
rep(i, N) { cin >> V[i]; }
ll max = 0;
rep(A, min(N, K)) {
rep(B, min(N, K) - A) {
vl minus;
ll sum = 0;
rep(l, A) {
sum += V[l];
if (V[l] < 0)
minus.push_back(V[l]);
}
rep(r, B) {
sum += V[N - 1 - r];
if (V[N - 1 - r] < 0)
minus.push_back(V[N - 1 - r]);
}
sort(minus.begin(), minus.end(), greater<ll>());
rep(k, K - A + B) {
if (minus.size() == 0)
break;
sum -= minus.back();
minus.pop_back();
}
chmax(max, sum);
}
}
cout << max << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rrep(i, n) for (ll i = n - 1; i >= 0; i--)
#define range(i, n, m) for (ll i = n; i < m; i++)
#define rrange(i, n, m) for (ll i = n - 1; i = > m; i--)
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vp vector<pair<ll, ll>>
#define vvp vector<vector<pair<ll, ll>>>
//#define MOD 998244353
typedef long long int ll;
typedef unsigned long long int ull;
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;
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
vector<ll> V(N);
rep(i, N) { cin >> V[i]; }
ll max = 0;
rep(A, min(N, K) + 1) {
rep(B, min(N, K) - A + 1) {
vl minus;
ll sum = 0;
rep(l, A) {
sum += V[l];
if (V[l] < 0)
minus.push_back(V[l]);
}
rep(r, B) {
sum += V[N - 1 - r];
if (V[N - 1 - r] < 0)
minus.push_back(V[N - 1 - r]);
}
sort(minus.begin(), minus.end(), greater<ll>());
rep(k, K - A - B) {
if (minus.size() == 0)
break;
sum -= minus.back();
minus.pop_back();
}
chmax(max, sum);
}
}
cout << max << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 843,767 | 843,766 | u991974907 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define chmin(x, y) (x) = min((x), (y))
#define chmax(x, y) (x) = max((x), (y))
#define endl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
void solve() {
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int ans = 0;
for (int k = 1; k < K; k++) {
for (int o = N - k; o <= N; o++) {
// cout << "--" << endl;
priority_queue<int, vector<int>, greater<int>> Q;
int sum = 0;
for (int i = 0; i < k; i++) {
// cout << V[(o + i) % N] << endl;
Q.push(V[(o + i) % N]);
sum += V[(o + i) % N];
}
ans = max(ans, sum);
int rest = K - k;
for (int r = 0; r < rest; r++) {
if (Q.empty())
break;
int t = Q.top();
Q.pop();
if (t >= 0)
break;
sum -= t;
}
ans = max(ans, sum);
}
}
cout << ans << endl;
}
int main() {
#ifdef LOCAL_ENV
cin.exceptions(ios::failbit);
#endif
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
solve();
} | #include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define chmin(x, y) (x) = min((x), (y))
#define chmax(x, y) (x) = max((x), (y))
#define endl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
void solve() {
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int ans = 0;
for (int k = 1; k <= min(K, N); k++) {
for (int o = N - k; o <= N; o++) {
// cout << "--" << endl;
priority_queue<int, vector<int>, greater<int>> Q;
int sum = 0;
for (int i = 0; i < k; i++) {
// cout << V[(o + i) % N] << endl;
Q.push(V[(o + i) % N]);
sum += V[(o + i) % N];
}
ans = max(ans, sum);
int rest = K - k;
for (int r = 0; r < rest; r++) {
if (Q.empty())
break;
int t = Q.top();
Q.pop();
if (t >= 0)
break;
sum -= t;
}
ans = max(ans, sum);
}
}
cout << ans << endl;
}
int main() {
#ifdef LOCAL_ENV
cin.exceptions(ios::failbit);
#endif
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
solve();
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.add",
"call.arguments.add"
] | 843,782 | 843,783 | u745250049 | cpp |
p03032 | #include <bits/stdc++.h>
#include <stdlib.h>
#include <time.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#define pb push_back
#define mp make_pair
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pll pair<ll, ll>
#define vll vector<ll, ll>
#define all(a) (a).begin(), (a).end()
#define ff first
#define ss second
#define sz(x) (ll) x.size()
#define hell 1000000007
#define repf(i, a, b) for (ll i = a; i < b; i++)
#define repb(i, a, b) for (ll i = a; i > b; i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define gcd(a, b) __gcd((a), (b))
#define EPS 1e-12
#define lcm(a, b) ((a) * (b)) / __gcd((a), (b))
#define sqrt sqrtl
#define cbrt cbrtl
using namespace std;
ll n, k, ans;
vector<ll> a;
ll dp[100][100][105];
ll solve(ll ss, ll se, ll cnt) {
if (cnt > k)
return -1e18;
if (cnt == k)
return 0;
if (dp[ss][se][cnt] != -1)
return dp[ss][se][cnt];
ll val = 0;
if (a[ss] >= 0)
val = max(val, a[ss] + solve(ss + 1, se, cnt + 1));
else {
val = max(val, a[ss] + solve(ss + 1, se, cnt + 1));
val = max(val, solve(ss + 1, se, cnt + 2));
}
if (a[se] >= 0)
val = max(val, a[se] + solve(ss, se - 1, cnt + 1));
else {
val = max(val, a[se] + solve(ss, se - 1, cnt + 1));
val = max(val, solve(ss, se - 1, cnt + 2));
}
dp[ss][se][cnt] = val;
return val;
}
int main() {
IOS cin >> n >> k;
ll i, x;
for (i = 0; i < n; i++) {
cin >> x;
a.pb(x);
}
memset(dp, -1, sizeof(dp));
cout << max(0LL, solve(0, n - 1, 0));
// cout<<ans;
// cout<<ans;
return 0;
} | #include <bits/stdc++.h>
#include <stdlib.h>
#include <time.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#define pb push_back
#define mp make_pair
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pll pair<ll, ll>
#define vll vector<ll, ll>
#define all(a) (a).begin(), (a).end()
#define ff first
#define ss second
#define sz(x) (ll) x.size()
#define hell 1000000007
#define repf(i, a, b) for (ll i = a; i < b; i++)
#define repb(i, a, b) for (ll i = a; i > b; i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define gcd(a, b) __gcd((a), (b))
#define EPS 1e-12
#define lcm(a, b) ((a) * (b)) / __gcd((a), (b))
#define sqrt sqrtl
#define cbrt cbrtl
using namespace std;
ll n, k, ans;
vector<ll> a;
ll dp[100][100][105];
ll solve(ll ss, ll se, ll cnt) {
if (cnt > k)
return -1e18;
if (cnt == k || ss > se)
return 0;
if (dp[ss][se][cnt] != -1)
return dp[ss][se][cnt];
ll val = 0;
if (a[ss] >= 0)
val = max(val, a[ss] + solve(ss + 1, se, cnt + 1));
else {
val = max(val, a[ss] + solve(ss + 1, se, cnt + 1));
val = max(val, solve(ss + 1, se, cnt + 2));
}
if (a[se] >= 0)
val = max(val, a[se] + solve(ss, se - 1, cnt + 1));
else {
val = max(val, a[se] + solve(ss, se - 1, cnt + 1));
val = max(val, solve(ss, se - 1, cnt + 2));
}
dp[ss][se][cnt] = val;
return val;
}
int main() {
IOS cin >> n >> k;
ll i, x;
for (i = 0; i < n; i++) {
cin >> x;
a.pb(x);
}
memset(dp, -1, sizeof(dp));
cout << max(0LL, solve(0, n - 1, 0));
// cout<<ans;
// cout<<ans;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 843,784 | 843,785 | u634201987 | cpp |
p03032 | #include <bits/stdc++.h>
#include <stdlib.h>
#include <time.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#define pb push_back
#define mp make_pair
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pll pair<ll, ll>
#define vll vector<ll, ll>
#define all(a) (a).begin(), (a).end()
#define ff first
#define ss second
#define sz(x) (ll) x.size()
#define hell 1000000007
#define repf(i, a, b) for (ll i = a; i < b; i++)
#define repb(i, a, b) for (ll i = a; i > b; i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define gcd(a, b) __gcd((a), (b))
#define EPS 1e-12
#define lcm(a, b) ((a) * (b)) / __gcd((a), (b))
#define sqrt sqrtl
#define cbrt cbrtl
using namespace std;
ll n, k, ans;
vector<ll> a;
ll dp[100][100][105];
ll solve(ll ss, ll se, ll cnt) {
if (cnt > k)
return -1e18;
if (cnt == k)
return 0;
if (dp[ss][se][cnt] != -1)
return dp[ss][se][cnt];
ll val = 0;
val = max(val, a[ss] + solve(ss + 1, se, cnt + 1));
val = max(val, solve(ss + 1, se, cnt + 2));
val = max(val, a[se] + solve(ss, se - 1, cnt + 1));
val = max(val, solve(ss, se - 1, cnt + 2));
dp[ss][se][cnt] = val;
return val;
}
int main() {
IOS cin >> n >> k;
ll i, x;
for (i = 0; i < n; i++) {
cin >> x;
a.pb(x);
}
memset(dp, -1, sizeof(dp));
cout << max(0LL, solve(0, n - 1, 0));
// cout<<ans;
// cout<<ans;
return 0;
} | #include <bits/stdc++.h>
#include <stdlib.h>
#include <time.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#define pb push_back
#define mp make_pair
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pll pair<ll, ll>
#define vll vector<ll, ll>
#define all(a) (a).begin(), (a).end()
#define ff first
#define ss second
#define sz(x) (ll) x.size()
#define hell 1000000007
#define repf(i, a, b) for (ll i = a; i < b; i++)
#define repb(i, a, b) for (ll i = a; i > b; i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define gcd(a, b) __gcd((a), (b))
#define EPS 1e-12
#define lcm(a, b) ((a) * (b)) / __gcd((a), (b))
#define sqrt sqrtl
#define cbrt cbrtl
using namespace std;
ll n, k, ans;
vector<ll> a;
ll dp[100][100][105];
ll solve(ll ss, ll se, ll cnt) {
if (cnt > k)
return -1e18;
if (cnt == k || ss > se)
return 0;
if (dp[ss][se][cnt] != -1)
return dp[ss][se][cnt];
ll val = 0;
val = max(val, a[ss] + solve(ss + 1, se, cnt + 1));
val = max(val, solve(ss + 1, se, cnt + 2));
val = max(val, a[se] + solve(ss, se - 1, cnt + 1));
val = max(val, solve(ss, se - 1, cnt + 2));
dp[ss][se][cnt] = val;
return val;
}
int main() {
IOS cin >> n >> k;
ll i, x;
for (i = 0; i < n; i++) {
cin >> x;
a.pb(x);
}
memset(dp, -1, sizeof(dp));
cout << max(0LL, solve(0, n - 1, 0));
// cout<<ans;
// cout<<ans;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 843,786 | 843,787 | u634201987 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> II;
typedef vector<II> VII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef long long int LL;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define SZ(a) (int)(a.size())
#define ALL(a) a.begin(), a.end()
#define SET(a, b) memset(a, b, sizeof(a))
#define si(n) scanf("%d", &n)
#define dout(n) printf("%d\n", n)
#define sll(n) scanf("%lld", &n)
#define lldout(n) printf("%lld\n", n)
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define endl '\n'
const int N = 1000;
LL x[N];
int main() {
fast_io;
LL n, k;
cin >> n >> k;
for (LL i = 0; i < n; i++) {
cin >> x[i];
}
LL msum = 0;
for (LL i = 0; i < n; i++) {
for (LL j = 0; j < n; j++) {
if (i + j <= k && i + j <= n - 2) {
LL sum = 0;
std::vector<LL> y;
for (LL l = 0; l < i; l++) {
sum += x[l];
y.PB(x[l]);
}
for (LL l = n - j; l < n; l++) {
sum += x[l];
y.PB(x[l]);
}
sort(ALL(y));
LL rem = k - i - j;
rem = min(rem, 1LL * SZ(y));
for (LL l = 0; l < rem; l++)
if (y[l] < 0)
sum -= y[l];
msum = max(msum, sum);
}
}
}
cout << msum << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> II;
typedef vector<II> VII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef long long int LL;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define SZ(a) (int)(a.size())
#define ALL(a) a.begin(), a.end()
#define SET(a, b) memset(a, b, sizeof(a))
#define si(n) scanf("%d", &n)
#define dout(n) printf("%d\n", n)
#define sll(n) scanf("%lld", &n)
#define lldout(n) printf("%lld\n", n)
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define endl '\n'
const int N = 1000;
LL x[N];
int main() {
fast_io;
LL n, k;
cin >> n >> k;
for (LL i = 0; i < n; i++) {
cin >> x[i];
}
LL msum = 0;
for (LL i = 0; i <= n; i++) {
for (LL j = 0; j <= n; j++) {
if (i + j <= k && i + j <= n) {
LL sum = 0;
std::vector<LL> y;
for (LL l = 0; l < i; l++) {
sum += x[l];
y.PB(x[l]);
}
for (LL l = n - j; l < n; l++) {
sum += x[l];
y.PB(x[l]);
}
sort(ALL(y));
LL rem = k - i - j;
rem = min(rem, 1LL * SZ(y));
for (LL l = 0; l < rem; l++)
if (y[l] < 0)
sum -= y[l];
msum = max(msum, sum);
}
}
}
cout << msum << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 843,790 | 843,789 | u665172861 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> II;
typedef vector<II> VII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef long long int LL;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define SZ(a) (int)(a.size())
#define ALL(a) a.begin(), a.end()
#define SET(a, b) memset(a, b, sizeof(a))
#define si(n) scanf("%d", &n)
#define dout(n) printf("%d\n", n)
#define sll(n) scanf("%lld", &n)
#define lldout(n) printf("%lld\n", n)
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define endl '\n'
const int N = 1000;
LL x[N];
int main() {
fast_io;
LL n, k;
cin >> n >> k;
for (LL i = 0; i < n; i++) {
cin >> x[i];
}
LL msum = 0;
for (LL i = 0; i < n; i++) {
for (LL j = 0; j < n; j++) {
if (i + j < k && i + j <= n) {
LL sum = 0;
std::vector<LL> y;
for (LL l = 0; l < i; l++) {
sum += x[l];
y.PB(x[l]);
}
for (LL l = n - j; l < n; l++) {
sum += x[l];
y.PB(x[l]);
}
sort(ALL(y));
LL rem = k - i - j;
rem = min(rem, 1LL * SZ(y));
for (LL l = 0; l < rem; l++)
if (y[l] < 0)
sum -= y[l];
msum = max(msum, sum);
}
}
}
cout << msum << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> II;
typedef vector<II> VII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef long long int LL;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define SZ(a) (int)(a.size())
#define ALL(a) a.begin(), a.end()
#define SET(a, b) memset(a, b, sizeof(a))
#define si(n) scanf("%d", &n)
#define dout(n) printf("%d\n", n)
#define sll(n) scanf("%lld", &n)
#define lldout(n) printf("%lld\n", n)
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define endl '\n'
const int N = 1000;
LL x[N];
int main() {
fast_io;
LL n, k;
cin >> n >> k;
for (LL i = 0; i < n; i++) {
cin >> x[i];
}
LL msum = 0;
for (LL i = 0; i <= n; i++) {
for (LL j = 0; j <= n; j++) {
if (i + j <= k && i + j <= n) {
LL sum = 0;
std::vector<LL> y;
for (LL l = 0; l < i; l++) {
sum += x[l];
y.PB(x[l]);
}
for (LL l = n - j; l < n; l++) {
sum += x[l];
y.PB(x[l]);
}
sort(ALL(y));
LL rem = k - i - j;
rem = min(rem, 1LL * SZ(y));
for (LL l = 0; l < rem; l++)
if (y[l] < 0)
sum -= y[l];
msum = max(msum, sum);
}
}
}
cout << msum << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 843,792 | 843,789 | u665172861 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define int long long
#define pie 3.141592653589793238462643383279
#define mod 1000000007
#define INF 1145141919364364
#define all(vec) vec.begin(), vec.end()
#define ggr \
getchar(); \
getchar(); \
return 0;
#define ll long long
#define P pair<int, int>
#define S second
#define F first
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
bool prime(int x) {
for (int i = 2; i <= sqrt(x); i++) {
if (x % i == 0)
return false;
}
return true;
}
int kai(int x) {
if (x == 1)
return 1;
return kai(x - 1) * x % mod;
}
int mod_pow(int x, int y, int moder) {
int res = 1;
while (y > 0) {
if (y & 1)
res = res * x % moder;
x = x * x % moder;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
if (y > x)
return 0;
if (x == y)
return 1;
return kai(x) * mod_pow(kai(x - y), mod - 2, mod) % mod *
mod_pow(kai(y), mod - 2, mod) % mod;
}
int n, m, v[55];
int cnt;
priority_queue<int, vector<int>, greater<int>> que;
int ans;
signed main() {
cin >> n >> m;
rep(i, n) cin >> v[i];
rep(i, min(n, m) + 1) {
rep(j, min(n, m) + 1 - i) {
rep(k, i) {
cnt += v[k];
if (v[k] < 0)
que.push(v[k]);
}
for (int k = n - 1; k >= n - j; k--) {
cnt += v[k];
if (v[k] < 0)
que.push(v[k]);
}
rep(k, m - (i + j)) {
if (que.size()) {
cnt -= que.top();
que.pop();
}
}
rep(i, que.size()) que.pop();
ans = max(ans, cnt);
cnt = 0;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define int long long
#define pie 3.141592653589793238462643383279
#define mod 1000000007
#define INF 1145141919364364
#define all(vec) vec.begin(), vec.end()
#define ggr \
getchar(); \
getchar(); \
return 0;
#define ll long long
#define P pair<int, int>
#define S second
#define F first
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
bool prime(int x) {
for (int i = 2; i <= sqrt(x); i++) {
if (x % i == 0)
return false;
}
return true;
}
int kai(int x) {
if (x == 1)
return 1;
return kai(x - 1) * x % mod;
}
int mod_pow(int x, int y, int moder) {
int res = 1;
while (y > 0) {
if (y & 1)
res = res * x % moder;
x = x * x % moder;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
if (y > x)
return 0;
if (x == y)
return 1;
return kai(x) * mod_pow(kai(x - y), mod - 2, mod) % mod *
mod_pow(kai(y), mod - 2, mod) % mod;
}
int n, m, v[55];
int cnt;
priority_queue<int, vector<int>, greater<int>> que;
int ans;
signed main() {
cin >> n >> m;
rep(i, n) cin >> v[i];
rep(i, min(n, m) + 1) {
rep(j, min(n, m) + 1 - i) {
rep(k, i) {
cnt += v[k];
if (v[k] < 0)
que.push(v[k]);
}
for (int k = n - 1; k >= n - j; k--) {
cnt += v[k];
if (v[k] < 0)
que.push(v[k]);
}
rep(k, m - (i + j)) {
if (que.size()) {
cnt -= que.top();
que.pop();
}
}
while (que.size())
que.pop();
ans = max(ans, cnt);
cnt = 0;
}
}
cout << ans << endl;
} | [
"call.arguments.change"
] | 843,793 | 843,794 | u277153875 | cpp |
p03032 | #include <bits/stdc++.h> // include all standard C++ libraries
using namespace std;
// Loops
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define _rrep(i, n) rrepi(i, n, 0)
#define rrepi(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define rrep(...) _overload3(__VA_ARGS__, rrepi, _rrep, )(__VA_ARGS__)
#define each(xi, x) for (auto &&xi : x)
// Note: we can use rep(i,N) or rep(i,from,to)
// typedef
using ll = long long;
template <class T> using vec = vector<T>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
// Constants
// Shorter repr for frequently used terms
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
// Algorithms
#define all(x) (x).begin(), (x).end()
#define uniq(v) v.erase(unique(all(v)), v.end())
#define perm(c) \
sort(all(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(all(c)))
template <class T> pair<T, size_t> max(vector<T> &x) {
auto it = max_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> pair<T, size_t> min(vector<T> &x) {
auto it = min_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> inline bool chmax(T &maxval, const T &newval) {
if (maxval < newval) {
maxval = newval;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &minval, const T &newval) {
if (minval > newval) {
minval = newval;
return 1;
}
return 0;
}
// Utilities
// Grid world utilities
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
#define inside(H, W, y, x) 0 <= (x) && (x) < (W) && 0 <= (y) && (y) < (H)
inline int in() {
int x;
cin >> x;
return x;
} // read int from cin
inline ll IN() {
ll x;
cin >> x;
return x;
} // read ll from cin
// Debug
#ifdef LOCAL
#include "dump.hpp"
#define debug(x) cerr << #x << ": " << x << '\n'
#else
#define dump(...)
#define debug(x)
#endif
// Paste snippets here!!
//
int main() {
cin.tie(0);
ios::sync_with_stdio(false); // Magic for faster cin
int N, K;
cin >> N >> K;
vi V(N);
rep(i, N) cin >> V[i];
int valmax = 0;
rep(A, K + 1) {
rep(B, K + 1) {
if (A + B > N)
continue;
int val = 0;
vi negV;
rep(i, A) {
val += V[i];
if (V[i] < 0)
negV.pb(V[i]);
}
rep(i, B) {
val += V[N - i - 1];
if (V[N - i - 1] < 0)
negV.pb(V[N - i - 1]);
}
sort(all(negV));
rep(i, min((int)negV.size(), K - A - B)) { val -= negV[i]; }
valmax = max(valmax, val);
}
}
cout << max(valmax, 0) << endl;
return 0;
}
| #include <bits/stdc++.h> // include all standard C++ libraries
using namespace std;
// Loops
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define _rrep(i, n) rrepi(i, n, 0)
#define rrepi(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define rrep(...) _overload3(__VA_ARGS__, rrepi, _rrep, )(__VA_ARGS__)
#define each(xi, x) for (auto &&xi : x)
// Note: we can use rep(i,N) or rep(i,from,to)
// typedef
using ll = long long;
template <class T> using vec = vector<T>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
// Constants
// Shorter repr for frequently used terms
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
// Algorithms
#define all(x) (x).begin(), (x).end()
#define uniq(v) v.erase(unique(all(v)), v.end())
#define perm(c) \
sort(all(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(all(c)))
template <class T> pair<T, size_t> max(vector<T> &x) {
auto it = max_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> pair<T, size_t> min(vector<T> &x) {
auto it = min_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> inline bool chmax(T &maxval, const T &newval) {
if (maxval < newval) {
maxval = newval;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &minval, const T &newval) {
if (minval > newval) {
minval = newval;
return 1;
}
return 0;
}
// Utilities
// Grid world utilities
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
#define inside(H, W, y, x) 0 <= (x) && (x) < (W) && 0 <= (y) && (y) < (H)
inline int in() {
int x;
cin >> x;
return x;
} // read int from cin
inline ll IN() {
ll x;
cin >> x;
return x;
} // read ll from cin
// Debug
#ifdef LOCAL
#include "dump.hpp"
#define debug(x) cerr << #x << ": " << x << '\n'
#else
#define dump(...)
#define debug(x)
#endif
// Paste snippets here!!
//
int main() {
cin.tie(0);
ios::sync_with_stdio(false); // Magic for faster cin
int N, K;
cin >> N >> K;
vi V(N);
rep(i, N) cin >> V[i];
int valmax = 0;
rep(A, K + 1) {
rep(B, K + 1) {
if (A + B > min(N, K))
continue;
int val = 0;
vi negV;
rep(i, A) {
val += V[i];
if (V[i] < 0)
negV.pb(V[i]);
}
rep(i, B) {
val += V[N - i - 1];
if (V[N - i - 1] < 0)
negV.pb(V[N - i - 1]);
}
sort(all(negV));
rep(i, min((int)negV.size(), K - A - B)) { val -= negV[i]; }
valmax = max(valmax, val);
}
}
cout << max(valmax, 0) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"call.add",
"call.arguments.add"
] | 843,808 | 843,809 | u292813062 | cpp |
p03032 | #include <bits/stdc++.h> // include all standard C++ libraries
using namespace std;
// Loops
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define _rrep(i, n) rrepi(i, n, 0)
#define rrepi(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define rrep(...) _overload3(__VA_ARGS__, rrepi, _rrep, )(__VA_ARGS__)
#define each(xi, x) for (auto &&xi : x)
// Note: we can use rep(i,N) or rep(i,from,to)
// typedef
using ll = long long;
template <class T> using vec = vector<T>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
// Constants
// Shorter repr for frequently used terms
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
// Algorithms
#define all(x) (x).begin(), (x).end()
#define uniq(v) v.erase(unique(all(v)), v.end())
#define perm(c) \
sort(all(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(all(c)))
template <class T> pair<T, size_t> max(vector<T> &x) {
auto it = max_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> pair<T, size_t> min(vector<T> &x) {
auto it = min_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> inline bool chmax(T &maxval, const T &newval) {
if (maxval < newval) {
maxval = newval;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &minval, const T &newval) {
if (minval > newval) {
minval = newval;
return 1;
}
return 0;
}
// Utilities
// Grid world utilities
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
#define inside(H, W, y, x) 0 <= (x) && (x) < (W) && 0 <= (y) && (y) < (H)
inline int in() {
int x;
cin >> x;
return x;
} // read int from cin
inline ll IN() {
ll x;
cin >> x;
return x;
} // read ll from cin
// Debug
#ifdef LOCAL
#include "dump.hpp"
#define debug(x) cerr << #x << ": " << x << '\n'
#else
#define dump(...)
#define debug(x)
#endif
// Paste snippets here!!
//
int main() {
cin.tie(0);
ios::sync_with_stdio(false); // Magic for faster cin
int N, K;
cin >> N >> K;
vi V(N);
rep(i, N) cin >> V[i];
int valmax = 0;
rep(A, K + 1) {
rep(B, K + 1) {
if (A + B >= N)
continue;
int val = 0;
vi negV;
rep(i, A) {
val += V[i];
if (V[i] < 0)
negV.pb(V[i]);
}
rep(i, B) {
val += V[N - i - 1];
if (V[N - i - 1] < 0)
negV.pb(V[N - i - 1]);
}
sort(all(negV));
rep(i, min((int)negV.size(), K - A - B)) { val -= negV[i]; }
valmax = max(valmax, val);
}
}
cout << max(valmax, 0) << endl;
return 0;
}
| #include <bits/stdc++.h> // include all standard C++ libraries
using namespace std;
// Loops
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define _rrep(i, n) rrepi(i, n, 0)
#define rrepi(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define rrep(...) _overload3(__VA_ARGS__, rrepi, _rrep, )(__VA_ARGS__)
#define each(xi, x) for (auto &&xi : x)
// Note: we can use rep(i,N) or rep(i,from,to)
// typedef
using ll = long long;
template <class T> using vec = vector<T>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
// Constants
// Shorter repr for frequently used terms
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
// Algorithms
#define all(x) (x).begin(), (x).end()
#define uniq(v) v.erase(unique(all(v)), v.end())
#define perm(c) \
sort(all(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(all(c)))
template <class T> pair<T, size_t> max(vector<T> &x) {
auto it = max_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> pair<T, size_t> min(vector<T> &x) {
auto it = min_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> inline bool chmax(T &maxval, const T &newval) {
if (maxval < newval) {
maxval = newval;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &minval, const T &newval) {
if (minval > newval) {
minval = newval;
return 1;
}
return 0;
}
// Utilities
// Grid world utilities
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
#define inside(H, W, y, x) 0 <= (x) && (x) < (W) && 0 <= (y) && (y) < (H)
inline int in() {
int x;
cin >> x;
return x;
} // read int from cin
inline ll IN() {
ll x;
cin >> x;
return x;
} // read ll from cin
// Debug
#ifdef LOCAL
#include "dump.hpp"
#define debug(x) cerr << #x << ": " << x << '\n'
#else
#define dump(...)
#define debug(x)
#endif
// Paste snippets here!!
//
int main() {
cin.tie(0);
ios::sync_with_stdio(false); // Magic for faster cin
int N, K;
cin >> N >> K;
vi V(N);
rep(i, N) cin >> V[i];
int valmax = 0;
rep(A, K + 1) {
rep(B, K + 1) {
if (A + B > min(N, K))
continue;
int val = 0;
vi negV;
rep(i, A) {
val += V[i];
if (V[i] < 0)
negV.pb(V[i]);
}
rep(i, B) {
val += V[N - i - 1];
if (V[N - i - 1] < 0)
negV.pb(V[N - i - 1]);
}
sort(all(negV));
rep(i, min((int)negV.size(), K - A - B)) { val -= negV[i]; }
valmax = max(valmax, val);
}
}
cout << max(valmax, 0) << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.add",
"call.arguments.add"
] | 843,810 | 843,809 | u292813062 | cpp |
p03032 | #include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
// const int INF = (1 << 30) - 1;
// const ll LL_INF = (1LL << 62) - 1;
// const ll MOD = 1e9 + 7;
int N, K;
vector<int> V;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K;
V.resize(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int ans = 0;
for (int i = 0; i <= K; i++) {
for (int j = 0; j <= K; j++) {
int sum = 0;
if (i + j > K) {
continue;
}
int r = min(i + j, K - i - j);
priority_queue<int, vector<int>, greater<int>> pq;
for (int k = 0; k < i; k++) {
sum += V[k];
pq.push(V[k]);
}
for (int k = 0; k < j; k++) {
sum += V[N - k - 1];
pq.push(V[N - k - 1]);
}
for (int k = 0; k < r; k++) {
int n = pq.top();
pq.pop();
if (n < 0) {
sum -= n;
}
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
// const int INF = (1 << 30) - 1;
// const ll LL_INF = (1LL << 62) - 1;
// const ll MOD = 1e9 + 7;
int N, K;
vector<int> V;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K;
V.resize(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int ans = 0;
for (int i = 0; i <= K; i++) {
for (int j = 0; j <= K; j++) {
int sum = 0;
if (i + j > min(N, K)) {
continue;
}
int r = min(i + j, K - i - j);
priority_queue<int, vector<int>, greater<int>> pq;
for (int k = 0; k < i; k++) {
sum += V[k];
pq.push(V[k]);
}
for (int k = 0; k < j; k++) {
sum += V[N - k - 1];
pq.push(V[N - k - 1]);
}
for (int k = 0; k < r; k++) {
int n = pq.top();
pq.pop();
if (n < 0) {
sum -= n;
}
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"call.add"
] | 843,823 | 843,824 | u751964641 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define vi vector<int>
#define vl vector<ll>
int main() {
int N, K;
cin >> N >> K;
vi v;
int tmp;
for (int i = 0; i < N; i++) {
cin >> tmp;
v.push_back(tmp);
}
vi score;
for (int k = 0; k <= K; k++) {
for (int l = 0; l <= k; l++) {
int sum = 0;
vi getV;
for (int i = 0; i < l; i++) {
getV.push_back(v[i]);
}
for (int i = N - (k - l); i < N; i++) {
getV.push_back(v[i]);
}
sort(getV.begin(), getV.end());
for (int i = 0; i < min(K - k, (int)getV.size()); i++) {
getV[i] = max(0, getV[i]);
}
for (int i = 0; i < getV.size(); i++) {
sum += getV[i];
}
score.push_back(sum);
}
}
cout << *max_element(score.begin(), score.end()) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define vi vector<int>
#define vl vector<ll>
int main() {
int N, K;
cin >> N >> K;
vi v;
int tmp;
for (int i = 0; i < N; i++) {
cin >> tmp;
v.push_back(tmp);
}
vi score;
for (int k = 0; k <= min(K, N); k++) {
for (int l = 0; l <= k; l++) {
int sum = 0;
vi getV;
for (int i = 0; i < l; i++) {
getV.push_back(v[i]);
}
for (int i = N - (k - l); i < N; i++) {
getV.push_back(v[i]);
}
sort(getV.begin(), getV.end());
for (int i = 0; i < min(K - k, (int)getV.size()); i++) {
getV[i] = max(0, getV[i]);
}
for (int i = 0; i < getV.size(); i++) {
sum += getV[i];
}
score.push_back(sum);
}
}
cout << *max_element(score.begin(), score.end()) << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 843,825 | 843,826 | u269804060 | cpp |
p03032 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int N, K;
vector<int> V;
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
int v;
cin >> v;
V.push_back(v);
}
int act = min(N, K);
int maxscore = 0;
for (int i = 0; i < act; i++) {
for (int j = 0; j < act - i; j++) {
int score = 0;
vector<int> minus;
for (int k = 0; k < i; k++) {
if (V[k] >= 0)
score += V[k];
else {
minus.push_back(V[k]);
}
}
for (int k = 0; k < j; k++) {
if (V[N - k - 1] >= 0)
score += V[N - k - 1];
else {
minus.push_back(V[N - k - 1]);
}
}
sort(minus.begin(), minus.end());
for (int k = K - i - j; k < minus.size(); k++) {
score += minus[k];
}
if (score > maxscore)
maxscore = score;
}
}
cout << maxscore << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int N, K;
vector<int> V;
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
int v;
cin >> v;
V.push_back(v);
}
int act = min(N, K);
int maxscore = 0;
for (int i = 0; i < act + 1; i++) {
for (int j = 0; j < act - i + 1; j++) {
int score = 0;
vector<int> minus;
for (int k = 0; k < i; k++) {
if (V[k] >= 0)
score += V[k];
else {
minus.push_back(V[k]);
}
}
for (int k = 0; k < j; k++) {
if (V[N - k - 1] >= 0)
score += V[N - k - 1];
else {
minus.push_back(V[N - k - 1]);
}
}
sort(minus.begin(), minus.end());
for (int k = K - i - j; k < minus.size(); k++) {
score += minus[k];
}
if (score > maxscore)
maxscore = score;
}
}
cout << maxscore << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 843,831 | 843,832 | u450733728 | cpp |
p03032 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define int long long
#define ll long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807 //ない環境用
#define LL_HALFMAX 9223372036854775807 / 2 //ない環境用
#define MIN -(9223372036854775807 / 2)
#define INF 9223372036854775807 / 2
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
using namespace std;
std::mt19937 mt((int)time(0));
int dx[4] = {0, 1, 0, -1}; // x軸方向への変位
int dy[4] = {1, 0, -1, 0}; // y軸方向への変位
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
}
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x])
std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
//!!!問題をちゃんと読む!!!
//!!!問題をちゃんと読め!!!
//!!!問題は読みましたか？!!!
class rest {
public:
string S;
int P;
int Num;
public:
rest(string s, int p, int num) {
S = s;
P = p;
Num = num;
}
bool operator<(const rest &another) const {
if (S != another.S)
return S < another.S;
return P > another.P;
};
};
int imos[1000000];
signed main() {
int N, K;
cin >> N >> K;
vector<int> v;
rep(i, N) {
int val;
cin >> val;
v.push_back(val);
}
//取り出す個数について全探索
int ans = 0;
for (int get = 0; get <= K; get++) {
//取り出し方について全探索
vector<int> got;
for (int left = 0; left <= get; left++) {
int right = get - left - 1;
got.clear();
//全部とれるなら取る
bool all = false;
if (get >= N) {
got = v;
all = true;
}
if (!all) {
//左と右から取る
for (int i = 0; i < left; i++) {
got.push_back(v[i]);
}
for (int i = N - 1, cnt = 0; cnt < right; i--, cnt++) {
got.push_back(v[i]);
}
}
sort(got.begin(), got.end());
int candAns = 0;
//捨てるを考えながら和を計算
int maxTrash = K - get;
int trash = 0;
for (int val : got) {
//?
if (val < 0 && trash < maxTrash) {
trash++;
continue;
}
candAns += val;
}
ans = max(ans, candAns);
}
}
cout << ans << "\n";
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define int long long
#define ll long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807 //ない環境用
#define LL_HALFMAX 9223372036854775807 / 2 //ない環境用
#define MIN -(9223372036854775807 / 2)
#define INF 9223372036854775807 / 2
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
using namespace std;
std::mt19937 mt((int)time(0));
int dx[4] = {0, 1, 0, -1}; // x軸方向への変位
int dy[4] = {1, 0, -1, 0}; // y軸方向への変位
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
}
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x])
std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
//!!!問題をちゃんと読む!!!
//!!!問題をちゃんと読め!!!
//!!!問題は読みましたか？!!!
class rest {
public:
string S;
int P;
int Num;
public:
rest(string s, int p, int num) {
S = s;
P = p;
Num = num;
}
bool operator<(const rest &another) const {
if (S != another.S)
return S < another.S;
return P > another.P;
};
};
int imos[1000000];
signed main() {
int N, K;
cin >> N >> K;
vector<int> v;
rep(i, N) {
int val;
cin >> val;
v.push_back(val);
}
//取り出す個数について全探索
int ans = 0;
for (int get = 0; get <= K; get++) {
//取り出し方について全探索
vector<int> got;
for (int left = 0; left <= get; left++) {
int right = get - left;
got.clear();
//全部とれるなら取る
bool all = false;
if (get >= N) {
got = v;
all = true;
}
//左と右から取る
if (!all) {
for (int i = 0; i < left; i++) {
got.push_back(v[i]);
}
for (int i = N - 1, cnt = 0; cnt < right; i--, cnt++) {
got.push_back(v[i]);
}
}
sort(got.begin(), got.end());
int candAns = 0;
//捨てるを考えながら和を計算
int maxTrash = K - get;
int trash = 0;
for (int val : got) {
//?
if (val < 0 && trash < maxTrash) {
trash++;
continue;
}
candAns += val;
}
ans = max(ans, candAns);
}
}
cout << ans << "\n";
return 0;
} | [
"expression.operation.binary.remove"
] | 843,848 | 843,849 | u783675879 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define DEBUG(x) cout << #x << ": " << (x) << '\n'
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << ' ' << v[i]; \
cout << '\n'
#define ALL(a) (a).begin(), (a).end()
template <typename T> inline void CHMAX(T &a, const T b) {
if (a < b)
a = b;
}
template <typename T> inline void CHMIN(T &a, const T b) {
if (a > b)
a = b;
}
constexpr ll MOD = 1000000007ll;
// constexpr ll MOD=998244353ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const double EPS = 1e-11;
#define EQ0(x) (abs((x)) < EPS)
#define EQ(a, b) (abs((a) - (b)) < EPS)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout<<setprecision(10)<<fixed;
int n, k;
int v[60];
cin >> n >> k;
assert(n > 50 || k > 100);
REP(i, n) { cin >> v[i]; }
int ans = 0;
REP(i, k + 1) {
REP(j, k - i + 1) {
if (i + j > n) {
continue;
}
int x2[i + j];
REP(j2, i) { x2[j2] = v[j2]; }
int cnt = i - 1;
FORR(j2, n - j, n) { x2[++cnt] = v[j2]; }
sort(x2, x2 + i + j);
int sum = 0;
REP(a, i + j) { sum += x2[a]; }
REP(a, min(k - i - j, i + j)) {
if (x2[a] >= 0) {
break;
}
sum -= x2[a];
}
CHMAX(ans, sum);
}
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define DEBUG(x) cout << #x << ": " << (x) << '\n'
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << ' ' << v[i]; \
cout << '\n'
#define ALL(a) (a).begin(), (a).end()
template <typename T> inline void CHMAX(T &a, const T b) {
if (a < b)
a = b;
}
template <typename T> inline void CHMIN(T &a, const T b) {
if (a > b)
a = b;
}
constexpr ll MOD = 1000000007ll;
// constexpr ll MOD=998244353ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const double EPS = 1e-11;
#define EQ0(x) (abs((x)) < EPS)
#define EQ(a, b) (abs((a) - (b)) < EPS)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout<<setprecision(10)<<fixed;
int n, k;
int v[60];
cin >> n >> k;
assert(n <= 50 && k <= 100);
REP(i, n) { cin >> v[i]; }
int ans = 0;
REP(i, k + 1) {
REP(j, k - i + 1) {
if (i + j > n) {
continue;
}
int x2[i + j];
REP(j2, i) { x2[j2] = v[j2]; }
int cnt = i - 1;
FORR(j2, n - j, n) { x2[++cnt] = v[j2]; }
sort(x2, x2 + i + j);
int sum = 0;
REP(a, i + j) { sum += x2[a]; }
REP(a, min(k - i - j, i + j)) {
if (x2[a] >= 0) {
break;
}
sum -= x2[a];
}
CHMAX(ans, sum);
}
}
cout << ans << '\n';
return 0;
}
| [
"expression.operator.compare.change",
"call.arguments.change",
"expression.operation.binary.change",
"misc.opposites"
] | 843,860 | 843,861 | u833393891 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define DEBUG(x) cout << #x << ": " << (x) << '\n'
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << ' ' << v[i]; \
cout << '\n'
#define ALL(a) (a).begin(), (a).end()
template <typename T> inline void CHMAX(T &a, const T b) {
if (a < b)
a = b;
}
template <typename T> inline void CHMIN(T &a, const T b) {
if (a > b)
a = b;
}
constexpr ll MOD = 1000000007ll;
// constexpr ll MOD=998244353ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const double EPS = 1e-11;
#define EQ0(x) (abs((x)) < EPS)
#define EQ(a, b) (abs((a) - (b)) < EPS)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout<<setprecision(10)<<fixed;
int n, k;
int v[60];
cin >> n >> k;
assert(n > 50 || k > 100);
REP(i, n) { cin >> v[i]; }
int ans = 0;
REP(i, k + 1) {
REP(j, k - i + 1) {
if (i + j > n) {
continue;
}
int x2[i + j];
REP(j2, i) { x2[j2] = v[j2]; }
int cnt = i - 1;
FORR(j2, n - j, n) { x2[++cnt] = v[j2]; }
sort(x2, x2 + i + j);
int sum = 0;
REP(a, i + j) { sum += x2[a]; }
REP(a, min(k - i - j, i + j)) {
if (x2[a] >= 0) {
break;
}
sum -= x2[a];
}
CHMAX(ans, sum);
}
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define DEBUG(x) cout << #x << ": " << (x) << '\n'
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << ' ' << v[i]; \
cout << '\n'
#define ALL(a) (a).begin(), (a).end()
template <typename T> inline void CHMAX(T &a, const T b) {
if (a < b)
a = b;
}
template <typename T> inline void CHMIN(T &a, const T b) {
if (a > b)
a = b;
}
constexpr ll MOD = 1000000007ll;
// constexpr ll MOD=998244353ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const double EPS = 1e-11;
#define EQ0(x) (abs((x)) < EPS)
#define EQ(a, b) (abs((a) - (b)) < EPS)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout<<setprecision(10)<<fixed;
int n, k;
int v[60];
cin >> n >> k;
assert(n <= 50 || k <= 100);
REP(i, n) { cin >> v[i]; }
int ans = 0;
REP(i, k + 1) {
REP(j, k - i + 1) {
if (i + j > n) {
continue;
}
int x2[i + j];
REP(j2, i) { x2[j2] = v[j2]; }
int cnt = i - 1;
FORR(j2, n - j, n) { x2[++cnt] = v[j2]; }
sort(x2, x2 + i + j);
int sum = 0;
REP(a, i + j) { sum += x2[a]; }
REP(a, min(k - i - j, i + j)) {
if (x2[a] >= 0) {
break;
}
sum -= x2[a];
}
CHMAX(ans, sum);
}
}
cout << ans << '\n';
return 0;
}
| [
"expression.operator.compare.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 843,860 | 843,862 | u833393891 | cpp |
p03032 | /*
C++
encoding:UTF-8
Modified: <26/May/2019 07:23:02 PM>
✪ H4WK3yE乡
Mohd. Farhan Tahir
Indian Institute Of Information Technology
(IIIT), Gwalior
*/
#include <bits/stdc++.h>
using namespace std;
// clang-format off
#define ll long long
#define mod 1000000007
#define ve vector
#define pb push_back
#define umap unordered_map
#define pq priority_queue
#define endl "\n";
#define ff first
#define ss second
#define pii pair<ll, ll>
#define len(v) ll(v.size())
#define all(v) v.begin(), v.end()
#define reset(a, b) memset(a, b, sizeof(a));
#define sum(v) accumulate(v.begin(), v.end(), (ll)0);
#define pr1(x) cout<<x<<"\n"
#define pr2(x, y) cout<<x<<" "<<y<<"\n"
#define pr3(x, y, z) cout<<x<<" "<<y<<" "<<z<<"\n"
#define prv(v, s, n) fr(i, s, n) cout<<v[i]<<" "; cout<<"\n"
#define fr(i, s, n) for (ll i = s ; i < n ; ++i)
#define dfr(i, s, n) for (ll i = s ; i > n ; --i)
// clang-format on
const ll N = 51;
ll v[N];
ll n, k;
ll mx;
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
fr(i, 0, n) cin >> v[i];
ll ans = 0;
fr(i, 0, min(n, k)) {
fr(j, 0, min(k - i, n - i)) {
multiset<ll> s;
ll a = 0;
fr(p, 0, i) {
a += v[p];
if (v[p] < 0)
s.insert(v[p]);
}
fr(p, 0, j) {
a += v[n - 1 - p];
if (v[n - 1 - p] < 0)
s.insert(v[n - 1 - p]);
}
ll out = k - i - j;
while (out and !s.empty()) {
auto it = s.begin();
a -= (*it);
s.erase(it);
out--;
}
ans = max(ans, a);
}
}
pr1(ans);
return 0;
}
| /*
C++
encoding:UTF-8
Modified: <26/May/2019 07:25:51 PM>
✪ H4WK3yE乡
Mohd. Farhan Tahir
Indian Institute Of Information Technology
(IIIT), Gwalior
*/
#include <bits/stdc++.h>
using namespace std;
// clang-format off
#define ll long long
#define mod 1000000007
#define ve vector
#define pb push_back
#define umap unordered_map
#define pq priority_queue
#define endl "\n";
#define ff first
#define ss second
#define pii pair<ll, ll>
#define len(v) ll(v.size())
#define all(v) v.begin(), v.end()
#define reset(a, b) memset(a, b, sizeof(a));
#define sum(v) accumulate(v.begin(), v.end(), (ll)0);
#define pr1(x) cout<<x<<"\n"
#define pr2(x, y) cout<<x<<" "<<y<<"\n"
#define pr3(x, y, z) cout<<x<<" "<<y<<" "<<z<<"\n"
#define prv(v, s, n) fr(i, s, n) cout<<v[i]<<" "; cout<<"\n"
#define fr(i, s, n) for (ll i = s ; i < n ; ++i)
#define dfr(i, s, n) for (ll i = s ; i > n ; --i)
// clang-format on
const ll N = 51;
ll v[N];
ll n, k;
ll mx;
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
fr(i, 0, n) cin >> v[i];
ll ans = 0;
fr(i, 0, min(n, k) + 1) {
fr(j, 0, min(k - i, n - i) + 1) {
multiset<ll> s;
ll a = 0;
fr(p, 0, i) {
a += v[p];
if (v[p] < 0)
s.insert(v[p]);
}
fr(p, 0, j) {
a += v[n - 1 - p];
if (v[n - 1 - p] < 0)
s.insert(v[n - 1 - p]);
}
ll out = k - i - j;
while (out and !s.empty()) {
auto it = s.begin();
a -= (*it);
s.erase(it);
out--;
}
ans = max(ans, a);
}
}
pr1(ans);
return 0;
}
| [
"expression.operation.binary.add"
] | 843,865 | 843,866 | u907206514 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<long> V;
for (int i = 0; i < N; i++) {
long v;
cin >> v;
V.push_back(v);
}
for (int i = 0; i < N; i++) {
V.push_back(V[i]);
}
long ans = 0;
for (int n = 0; n <= K; n++) {
for (int i = N - n; i < N + 1; i++) {
priority_queue<long, vector<long>, greater<long>> pq;
for (int k = 0; k < n; k++) {
pq.push(V[i + k]);
}
long sum = 0;
long c = K - n;
while (not pq.empty()) {
auto t = pq.top();
pq.pop();
if (c > 0 and t < 0) {
c--;
} else {
sum += t;
}
// cerr << t << " ";
}
// cerr << endl;
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<long> V;
for (int i = 0; i < N; i++) {
long v;
cin >> v;
V.push_back(v);
}
for (int i = 0; i < N; i++) {
V.push_back(V[i]);
}
long ans = 0;
for (int n = 0; n <= min(N, K); n++) {
for (int i = N - n; i < N + 1; i++) {
priority_queue<long, vector<long>, greater<long>> pq;
for (int k = 0; k < n; k++) {
pq.push(V[i + k]);
}
long sum = 0;
long c = K - n;
while (not pq.empty()) {
auto t = pq.top();
pq.pop();
if (c > 0 and t < 0) {
c--;
} else {
sum += t;
}
// cerr << t << " ";
}
// cerr << endl;
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 843,876 | 843,877 | u500092662 | cpp |
p03032 |
#include <algorithm>
#include <iostream>
#include <list>
#include <math.h>
#include <string>
using namespace std;
int value[50];
int n;
int k;
long long dopick(int pickup) {
long long maxvalue = 0;
long long valuebox[100];
for (int left = 0; left <= pickup; left++) {
int right = pickup - left;
long long wkvalue = 0;
for (int i = 0; i < left; i++) {
valuebox[i] = value[i];
}
for (int i = 0; i < right; i++) {
valuebox[left + i] = value[n - 1 - i];
}
sort(valuebox, valuebox + pickup);
int cancel = min(k - pickup, pickup);
long long wkans = 0;
for (int i = 0; i < cancel; i++) {
if (valuebox[i] < 0) {
wkans -= valuebox[i];
} else {
break;
}
}
for (int i = 0; i < pickup; i++) {
wkans += valuebox[i];
}
if (wkans > maxvalue)
maxvalue = wkans;
}
return maxvalue;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> value[i];
}
long long ans = 0;
//取れる最大回数は５０回まで。nが５０までだから。
for (int pickup = 0; pickup <= min(k, 50); pickup++) {
long long wkans;
// pickup回取り出し。 (k-pickup)回まで戻し。
wkans = dopick(pickup);
if (wkans > ans)
ans = wkans;
}
cout << ans << endl;
system("pause");
return 0;
} |
#include <algorithm>
#include <iostream>
#include <list>
#include <math.h>
#include <string>
using namespace std;
int value[50];
int n;
int k;
long long dopick(int pickup) {
long long maxvalue = 0;
long long valuebox[100];
for (int left = 0; left <= pickup; left++) {
int right = pickup - left;
long long wkvalue = 0;
for (int i = 0; i < left; i++) {
valuebox[i] = value[i];
}
for (int i = 0; i < right; i++) {
valuebox[left + i] = value[n - 1 - i];
}
sort(valuebox, valuebox + pickup);
int cancel = min(k - pickup, pickup);
long long wkans = 0;
for (int i = 0; i < cancel; i++) {
if (valuebox[i] < 0) {
wkans -= valuebox[i];
} else {
break;
}
}
for (int i = 0; i < pickup; i++) {
wkans += valuebox[i];
}
if (wkans > maxvalue)
maxvalue = wkans;
}
return maxvalue;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> value[i];
}
long long ans = 0;
//取れる最大回数は５０回まで。nが５０までだから。
for (int pickup = 0; pickup <= min(n, min(k, 50)); pickup++) {
long long wkans;
// pickup回取り出し。 (k-pickup)回まで戻し。
wkans = dopick(pickup);
if (wkans > ans)
ans = wkans;
}
cout << ans << endl;
system("pause");
return 0;
} | [
"control_flow.loop.for.condition.change",
"call.arguments.add",
"call.arguments.change"
] | 843,881 | 843,882 | u845284573 | cpp |
p03032 | #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
deque<int> jdqOrig(n), jdq;
for (auto &j : jdqOrig)
cin >> j;
auto maxNum = 0LL, num = 0LL;
vector<deque<int>> jdqStates;
multiset<int> havingStates;
for (int turn = 1; turn < k; ++turn) {
// take until 'turn', and push
for (int fl = 0; fl <= turn; ++fl) {
jdq.clear();
havingStates.clear();
copy(jdqOrig.begin(), jdqOrig.end(), back_inserter(jdq));
num = 0LL;
// take 'fl' from left
for (int i = 0; i < fl; ++i) {
if (jdq.empty())
break;
havingStates.insert(jdq.front());
jdq.pop_front();
}
for (int i = fl; i < turn; ++i) {
if (jdq.empty())
break;
havingStates.insert(jdq.back());
jdq.pop_back();
}
for (int p = turn; p < k; ++p) {
// push
if (havingStates.empty())
break;
if (*havingStates.begin() < 0) {
havingStates.erase(havingStates.begin(), (++havingStates.begin()));
}
}
for (auto &hs : havingStates)
num += hs;
if (num > maxNum) {
maxNum = num;
}
}
}
cout << maxNum << endl;
return 0;
} | #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
deque<int> jdqOrig(n), jdq;
for (auto &j : jdqOrig)
cin >> j;
auto maxNum = 0LL, num = 0LL;
vector<deque<int>> jdqStates;
multiset<int> havingStates;
for (int turn = 1; turn <= k; ++turn) {
// take until 'turn', and push
for (int fl = 0; fl <= turn; ++fl) {
jdq.clear();
havingStates.clear();
copy(jdqOrig.begin(), jdqOrig.end(), back_inserter(jdq));
num = 0LL;
// take 'fl' from left
for (int i = 0; i < fl; ++i) {
if (jdq.empty())
break;
havingStates.insert(jdq.front());
jdq.pop_front();
}
for (int i = fl; i < turn; ++i) {
if (jdq.empty())
break;
havingStates.insert(jdq.back());
jdq.pop_back();
}
for (int p = turn; p < k; ++p) {
// push
if (havingStates.empty())
break;
if (*havingStates.begin() < 0) {
havingStates.erase(havingStates.begin(), (++havingStates.begin()));
}
}
for (auto &hs : havingStates)
num += hs;
if (num > maxNum) {
maxNum = num;
}
}
}
cout << maxNum << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,887 | 843,888 | u967138082 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int n, K;
cin >> n >> K;
// int a, b, c; cin >> a >> b >> c;
vector<ll> vs;
for (int i = 0; i < n; i++) {
ll v;
cin >> v;
vs.push_back(v);
}
ll maxs = 0;
int mk, mt, mtl;
for (int k = 0; k <= K; k++) {
for (int t = 0; t <= k; t++) {
int s = k - t;
for (int tl = 0; tl <= t; tl++) {
// cout << "k:" << k << " ";
ll sum = 0;
int tr = t - tl;
// cout << "tl tr: " << tl << " " << tr << " ";
priority_queue<ll, vector<ll>, greater<ll>> minus;
// cout << "lpick: ";
for (int i = 0; i < tl && i < n; i++) {
sum += vs[i];
// cout << vs[i] << " ";
if (vs[i] < 0)
minus.push(vs[i]);
}
// cout << "rpick: ";
for (int i = n - 1; (n - tr) <= i && 0 <= i; i--) {
// cout << vs[i] << " ";
sum += vs[i];
if (vs[i] < 0)
minus.push(vs[i]);
}
// cout << "throw: ";
for (int i = 0; i < s; i++) {
if (minus.empty())
break;
// cout << minus.top() << " ";
sum -= minus.top();
minus.pop();
}
// cout << "sum: " << sum;
// cout << endl;
if (maxs < sum) {
maxs = sum;
}
}
}
}
cout << maxs << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int n, K;
cin >> n >> K;
// int a, b, c; cin >> a >> b >> c;
vector<ll> vs;
for (int i = 0; i < n; i++) {
ll v;
cin >> v;
vs.push_back(v);
}
ll maxs = 0;
int mk, mt, mtl;
for (int k = 0; k <= K; k++) {
for (int t = 0; t <= k && t <= n; t++) {
int s = k - t;
for (int tl = 0; tl <= t; tl++) {
// cout << "k:" << k << " ";
ll sum = 0;
int tr = t - tl;
// cout << "tl tr: " << tl << " " << tr << " ";
priority_queue<ll, vector<ll>, greater<ll>> minus;
// cout << "lpick: ";
for (int i = 0; i < tl && i < n; i++) {
sum += vs[i];
// cout << vs[i] << " ";
if (vs[i] < 0)
minus.push(vs[i]);
}
// cout << "rpick: ";
for (int i = n - 1; (n - tr) <= i && 0 <= i; i--) {
// cout << vs[i] << " ";
sum += vs[i];
if (vs[i] < 0)
minus.push(vs[i]);
}
// cout << "throw: ";
for (int i = 0; i < s; i++) {
if (minus.empty())
break;
// cout << minus.top() << " ";
sum -= minus.top();
minus.pop();
}
// cout << "sum: " << sum;
// cout << endl;
if (maxs < sum) {
maxs = sum;
}
}
}
}
cout << maxs << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 843,893 | 843,892 | u218356514 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
int odp = 0;
for (int i = 1; i <= k; ++i) {
for (int p = 0; p <= n; ++p) {
for (int s = 0; p + s <= n; ++s) {
int r = k - (p + s);
if (r < 0)
continue;
vector<int> b;
for (int j = 0; j < p; ++j)
b.push_back(a[j]);
for (int j = n - s; j < n; ++j)
b.push_back(a[j]);
sort(b.begin(), b.end());
if (r > b.size())
continue;
int S = 0;
for (int j = r; j < b.size(); ++j)
S += b[j];
odp = max(odp, S);
}
}
}
cout << odp;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
int odp = 0;
for (int i = 1; i <= k; ++i) {
for (int p = 0; p <= n; ++p) {
for (int s = 0; p + s <= n; ++s) {
int r = i - (p + s);
if (r < 0)
continue;
vector<int> b;
for (int j = 0; j < p; ++j)
b.push_back(a[j]);
for (int j = n - s; j < n; ++j)
b.push_back(a[j]);
sort(b.begin(), b.end());
if (r > b.size())
continue;
int S = 0;
for (int j = r; j < b.size(); ++j)
S += b[j];
odp = max(odp, S);
}
}
}
cout << odp;
return 0;
}
| [
"identifier.change",
"expression.operation.binary.change"
] | 843,902 | 843,903 | u535773602 | cpp |
p03032 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long int> v;
for (int i = 0; i < n; i++) {
long long int tmp;
cin >> tmp;
v.push_back(tmp);
}
long long int res = 0;
for (int i = 0; i <= n && i <= k; i++) {
for (int j = 0; j <= n - i && j <= k; j++) {
vector<long long int> mine;
for (int l = 0; l < i; l++) {
mine.push_back(v[l]);
}
for (int r = 0; r < j; r++) {
int s = v.size() - 1;
mine.push_back(v[s - r]);
}
// for (int take = 0; take < mine.size(); take++) {
// cout << mine[take] << " ";
// }
// cout << endl;
sort(mine.begin(), mine.end());
for (int x = 0; x < k - i - j; x++) {
if (mine.empty() || mine.front() >= 0) {
break;
} else {
mine.erase(mine.begin());
}
}
long long int tmpRes;
if (mine.empty()) {
tmpRes = 0;
} else {
tmpRes = accumulate(mine.begin(), mine.end(), 0);
}
res = max(res, tmpRes);
}
}
cout << res << endl;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long int> v;
for (int i = 0; i < n; i++) {
long long int tmp;
cin >> tmp;
v.push_back(tmp);
}
long long int res = 0;
for (int i = 0; i <= n && i <= k; i++) {
for (int j = 0; j <= n - i && j <= k - i; j++) {
vector<long long int> mine;
for (int l = 0; l < i; l++) {
mine.push_back(v[l]);
}
for (int r = 0; r < j; r++) {
int s = v.size() - 1;
mine.push_back(v[s - r]);
}
// for (int take = 0; take < mine.size(); take++) {
// cout << mine[take] << " ";
// }
// cout << endl;
sort(mine.begin(), mine.end());
for (int x = 0; x < k - i - j; x++) {
if (mine.empty() || mine.front() >= 0) {
break;
} else {
mine.erase(mine.begin());
}
}
long long int tmpRes;
if (mine.empty()) {
tmpRes = 0;
} else {
tmpRes = accumulate(mine.begin(), mine.end(), 0);
}
res = max(res, tmpRes);
}
}
cout << res << endl;
}
| [
"control_flow.loop.for.condition.change"
] | 843,921 | 843,922 | u231458241 | cpp |
p03032 | // {{{
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// }}}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
static constexpr int mod = (int)1e9 + 7;
static constexpr int inf = 100100100;
static constexpr ll linf = 1e18;
static constexpr double eps = 1e-9;
static constexpr double pi = 3.14159265359;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (ll i = n; i >= 0; --i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define pb push_back
#define ist insert
#define fst first
#define snd second
int main() {
// cin.tie(0);
// ios_base::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
deque<ll> d;
rep(i, N) {
ll v;
cin >> v;
d.pb(v);
}
ll M = min(N, K);
ll ans = -linf;
for (ll a = 0; a < M; ++a) {
for (ll b = 0; a + b < M; ++b) {
auto q = d;
vector<ll> v;
rep(i, a) {
v.pb(q.front());
q.pop_front();
}
rep(i, b) {
v.pb(q.back());
q.pop_back();
}
sort(all(v));
ll c = 0;
ll tmp = 0;
for (ll i : v) {
if (i < 0 && a + b + c < K) {
++c;
continue;
}
tmp += i;
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| // {{{
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// }}}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
static constexpr int mod = (int)1e9 + 7;
static constexpr int inf = 100100100;
static constexpr ll linf = 1e18;
static constexpr double eps = 1e-9;
static constexpr double pi = 3.14159265359;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (ll i = n; i >= 0; --i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define pb push_back
#define ist insert
#define fst first
#define snd second
int main() {
// cin.tie(0);
// ios_base::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
deque<ll> d;
rep(i, N) {
ll v;
cin >> v;
d.pb(v);
}
ll M = min(N, K);
ll ans = -linf;
for (ll a = 0; a <= M; ++a) {
for (ll b = 0; a + b <= M; ++b) {
auto q = d;
vector<ll> v;
rep(i, a) {
v.pb(q.front());
q.pop_front();
}
rep(i, b) {
v.pb(q.back());
q.pop_back();
}
sort(all(v));
ll c = 0;
ll tmp = 0;
for (ll i : v) {
if (i < 0 && a + b + c < K) {
++c;
continue;
}
tmp += i;
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,939 | 843,940 | u186294233 | cpp |
p03032 | // {{{
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// }}}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
static constexpr int mod = (int)1e9 + 7;
static constexpr int inf = 100100100;
static constexpr ll linf = 1e18;
static constexpr double eps = 1e-9;
static constexpr double pi = 3.14159265359;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (ll i = n; i >= 0; --i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define pb push_back
#define ist insert
#define fst first
#define snd second
int main() {
// cin.tie(0);
// ios_base::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
deque<ll> d;
rep(i, N) {
ll v;
cin >> v;
d.pb(v);
}
ll M = min(N, K);
ll ans = 0;
for (ll a = 0; a < M; ++a) {
for (ll b = 0; a + b < M; ++b) {
auto q = d;
vector<ll> v;
rep(i, a) {
v.pb(q.front());
q.pop_front();
}
rep(i, b) {
v.pb(q.back());
q.pop_back();
}
sort(all(v));
ll c = 0;
ll tmp = 0;
for (ll i : v) {
if (i < 0 && a + b + c < K) {
++c;
continue;
}
tmp += i;
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| // {{{
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// }}}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
static constexpr int mod = (int)1e9 + 7;
static constexpr int inf = 100100100;
static constexpr ll linf = 1e18;
static constexpr double eps = 1e-9;
static constexpr double pi = 3.14159265359;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (ll i = n; i >= 0; --i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define pb push_back
#define ist insert
#define fst first
#define snd second
int main() {
// cin.tie(0);
// ios_base::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
deque<ll> d;
rep(i, N) {
ll v;
cin >> v;
d.pb(v);
}
ll M = min(N, K);
ll ans = -linf;
for (ll a = 0; a <= M; ++a) {
for (ll b = 0; a + b <= M; ++b) {
auto q = d;
vector<ll> v;
rep(i, a) {
v.pb(q.front());
q.pop_front();
}
rep(i, b) {
v.pb(q.back());
q.pop_back();
}
sort(all(v));
ll c = 0;
ll tmp = 0;
for (ll i : v) {
if (i < 0 && a + b + c < K) {
++c;
continue;
}
tmp += i;
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| [
"expression.operation.unary.add",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,941 | 843,940 | u186294233 | cpp |
p03032 | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author toshibablack
*/
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long int
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) for (int i = 0; i < n; ++i)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(a) (a).begin(), (a).end()
#define OUT(x) out << (x) << endl;
#define M0(x) memset(x, 0, sizeof(x))
#define MINF(x) memset(x, 0x3f, sizeof(x))
#define MMINUS(a) memset(a, 0xff, sizeof(a))
#define ten(n) ((int)1e##n)
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
const double EPS = 1.0 / LINF;
const char ENDL = '\n'; // for JetBrains IDE only supports yen
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
using namespace std;
class DEqueue {
public:
int N, K;
int V[100]{0};
void solve(std::istream &in, std::ostream &out) {
in >> N >> K;
REP(i, N) in >> V[i];
int ans = 0;
FOR(l, 0, min(N, K)) {
FOR(r, 0, min(N, K) - l - 1) {
vector<int> v;
int sum = 0;
REP(i, l) {
sum += V[i];
v.push_back(V[i]);
}
REP(i, r) {
sum += V[N - 1 - i];
v.push_back(V[N - 1 - i]);
}
sort(ALL(v));
int nokori = max(K - l - r, 0);
REP(i, nokori) {
if (i == v.size())
break;
sum += max(-v[i], 0);
}
chmax(ans, sum);
}
}
OUT(ans);
}
};
int main() {
DEqueue solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author toshibablack
*/
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long int
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) for (int i = 0; i < n; ++i)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(a) (a).begin(), (a).end()
#define OUT(x) out << (x) << endl;
#define M0(x) memset(x, 0, sizeof(x))
#define MINF(x) memset(x, 0x3f, sizeof(x))
#define MMINUS(a) memset(a, 0xff, sizeof(a))
#define ten(n) ((int)1e##n)
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
const double EPS = 1.0 / LINF;
const char ENDL = '\n'; // for JetBrains IDE only supports yen
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
using namespace std;
class DEqueue {
public:
int N, K;
int V[100]{0};
void solve(std::istream &in, std::ostream &out) {
in >> N >> K;
REP(i, N) in >> V[i];
int ans = 0;
FOR(l, 0, min(N, K)) {
FOR(r, 0, min(N, K) - l) {
vector<int> v;
int sum = 0;
REP(i, l) {
sum += V[i];
v.push_back(V[i]);
}
REP(i, r) {
sum += V[N - 1 - i];
v.push_back(V[N - 1 - i]);
}
sort(ALL(v));
int nokori = max(K - l - r, 0);
REP(i, nokori) {
if (i == v.size())
break;
sum += max(-v[i], 0);
}
chmax(ans, sum);
}
}
OUT(ans);
}
};
int main() {
DEqueue solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| [
"expression.operation.binary.remove"
] | 843,942 | 843,943 | u585670083 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vl;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(i) i.begin(), i.end()
template <class T, class U> void cmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void cmin(T &a, U b) {
if (a > b)
a = b;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vi v(n);
rep(i, n) cin >> v[i];
ll ans = 0;
rep(i, n + 1) {
rep(j, n + 1) {
if (i + j > k)
continue;
priority_queue<int, vector<int>, greater<int>> que;
ll sum = 0;
rep(l, i) {
sum += v[l];
que.push(v[l]);
}
rep(l, j) {
sum += v[n - 1 - l];
que.push(v[n - 1 - l]);
}
rep(l, k - i - j) {
if (que.size() && que.top() < 0) {
int q = que.top();
que.pop();
sum -= q;
}
}
cmax(ans, sum);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vl;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(i) i.begin(), i.end()
template <class T, class U> void cmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void cmin(T &a, U b) {
if (a > b)
a = b;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vi v(n);
rep(i, n) cin >> v[i];
ll ans = 0;
rep(i, n + 1) {
rep(j, n + 1) {
if (i + j > min(n, k))
continue;
priority_queue<int, vector<int>, greater<int>> que;
ll sum = 0;
rep(l, i) {
sum += v[l];
que.push(v[l]);
}
rep(l, j) {
sum += v[n - 1 - l];
que.push(v[n - 1 - l]);
}
rep(l, k - i - j) {
if (que.size() && que.top() < 0) {
int q = que.top();
que.pop();
sum -= q;
}
}
cmax(ans, sum);
}
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change",
"call.add"
] | 843,944 | 843,945 | u366644013 | cpp |
p03032 | #include <algorithm>
#include <cstdio>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int n, k, ans = 0;
scanf("%d%d", &n, &k);
vector<int> v(n);
for (int i = 0; i < n; ++i)
scanf("%d", &v.at(i));
for (int l = 0; l <= min(n, k); ++l)
for (int r = 0; r <= min(n, k - l); ++r) {
int sum = 0;
vector<int> neg;
for (auto lp = v.begin(); lp != v.begin() + l; ++lp) {
if (*lp < 0)
neg.push_back(*lp);
else
sum += *lp;
}
for (auto rp = v.end() - r; rp != v.end(); ++rp) {
if (*rp < 0)
neg.push_back(*rp);
else
sum += *rp;
}
sort(neg.begin(), neg.end());
sum += accumulate(neg.begin() + min(int(neg.size()), k - (l + r)),
neg.end(), 0);
ans = max(ans, sum);
}
printf("%d\n", ans);
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int n, k, ans = 0;
scanf("%d%d", &n, &k);
vector<int> v(n);
for (int i = 0; i < n; ++i)
scanf("%d", &v.at(i));
for (int l = 0; l <= min(n, k); ++l)
for (int r = 0; r <= min(n, k) - l; ++r) {
int sum = 0;
vector<int> neg;
for (auto lp = v.begin(); lp != v.begin() + l; ++lp) {
if (*lp < 0)
neg.push_back(*lp);
else
sum += *lp;
}
for (auto rp = v.end() - r; rp != v.end(); ++rp) {
if (*rp < 0)
neg.push_back(*rp);
else
sum += *rp;
}
sort(neg.begin(), neg.end());
sum += accumulate(neg.begin() + min(int(neg.size()), k - (l + r)),
neg.end(), 0);
ans = max(ans, sum);
}
printf("%d\n", ans);
return 0;
}
| [
"call.arguments.change"
] | 843,954 | 843,955 | u359025499 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF 1 << 30
#define LINF (ll)1 << 62
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> P;
typedef vector<pair<ll, ll>> vpl;
int main() {
ll n, k;
cin >> n >> k;
ll mn = min(n, k);
vl v(n);
rep(i, n) cin >> v[i];
set<ll> st;
ll mx = 0;
rep(l, mn + 1) {
rep(r, mn + 1 - l) {
rep(i, l) st.insert(v[i]);
rep(j, r) st.insert(v[n - j - 1]);
ll rest = k - l - r;
while (*st.begin() < 0 && rest > 0) {
st.erase(st.begin());
rest--;
}
ll sum = 0;
for (auto i : st) {
sum += i;
}
mx = max(mx, sum);
st.clear();
}
}
cout << mx << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF 1 << 30
#define LINF (ll)1 << 62
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> P;
typedef vector<pair<ll, ll>> vpl;
int main() {
ll n, k;
cin >> n >> k;
ll mn = min(n, k);
vl v(n);
rep(i, n) cin >> v[i];
multiset<ll> st;
ll mx = 0;
rep(l, mn + 1) {
rep(r, mn + 1 - l) {
rep(i, l) st.insert(v[i]);
rep(j, r) st.insert(v[n - j - 1]);
ll rest = k - l - r;
while (*st.begin() < 0 && rest > 0) {
st.erase(st.begin());
rest--;
}
ll sum = 0;
for (auto i : st) {
// cout << i << endl;
sum += i;
}
mx = max(mx, sum);
st.clear();
}
}
cout << mx << endl;
} | [
"variable_declaration.type.change"
] | 843,956 | 843,957 | u242679311 | cpp |
p03032 | #include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <chrono>
#include <complex>
#include <condition_variable>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <future>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
int main() {
int n, k, maxi = 0;
cin >> n >> k;
vector<int> arr(n);
for (int i = 0; i < n; i++)
cin >> arr[i];
for (int i = 0; i < min(n, k); i++) { // (number of things we're taking)-1
for (int j = 0; j <= i + 1; j++) { // n.o.t.w.t from the left side
multiset<int> ms;
int kk = k - i - 1, temp = 0;
for (int x = 0; x < j; x++) {
ms.insert(arr[x]);
temp += arr[x];
}
for (int x = n - i + j - 1; x < n; x++) {
ms.insert(arr[x]);
temp += arr[x];
}
for (auto x : ms) {
if (x >= 0)
break;
if (--kk)
break;
temp -= x;
}
maxi = max(maxi, temp);
}
}
cout << maxi;
} | #include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <chrono>
#include <complex>
#include <condition_variable>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <future>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
int main() {
int n, k, maxi = 0;
cin >> n >> k;
vector<int> arr(n);
for (int i = 0; i < n; i++)
cin >> arr[i];
for (int i = 0; i < min(n, k); i++) { // (number of things we're taking)-1
for (int j = 0; j <= i + 1; j++) { // n.o.t.w.t from the left side
multiset<int> ms;
int kk = k - i - 1, temp = 0;
for (int x = 0; x < j; x++) {
ms.insert(arr[x]);
temp += arr[x];
}
for (int x = n - i + j - 1; x < n; x++) {
ms.insert(arr[x]);
temp += arr[x];
}
for (auto x : ms) {
if (x >= 0)
break;
if (!kk--)
break;
temp -= x;
}
maxi = max(maxi, temp);
}
}
cout << maxi;
} | [
"control_flow.branch.if.condition.change"
] | 843,965 | 843,966 | u913008467 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int ans = 0;
int N, K;
cin >> N >> K;
vector<int> V(N);
for (auto &_V : V)
cin >> _V;
for (int hold = 0; hold <= K; hold++) {
int return_num = K - hold;
for (int left = 0; left <= hold; left++) {
int right = hold - left;
vector<int> stones;
for (int i = 0; i < left; i++) {
stones.push_back(V[i]);
}
for (int i = 0; i < right; i++) {
stones.push_back(V[N - 1 - i]);
}
sort(stones.begin(), stones.end());
int begin_idx;
for (begin_idx = 0; begin_idx < min(return_num, (int)stones.size());
begin_idx++) {
if (stones[begin_idx] >= 0) {
break;
}
}
int res = accumulate(stones.begin() + begin_idx, stones.end(), 0);
ans = max(ans, res);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
int ans = 0;
int N, K;
cin >> N >> K;
vector<int> V(N);
for (auto &_V : V)
cin >> _V;
for (int hold = 0; hold <= min(N, K); hold++) {
int return_num = K - hold;
for (int left = 0; left <= hold; left++) {
int right = hold - left;
vector<int> stones;
for (int i = 0; i < left; i++) {
stones.push_back(V[i]);
}
for (int i = 0; i < right; i++) {
stones.push_back(V[N - 1 - i]);
}
sort(stones.begin(), stones.end());
int begin_idx;
for (begin_idx = 0; begin_idx < min(return_num, (int)stones.size());
begin_idx++) {
if (stones[begin_idx] >= 0) {
break;
}
}
int res = accumulate(stones.begin() + begin_idx, stones.end(), 0);
ans = max(ans, res);
}
}
cout << ans << endl;
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 843,968 | 843,969 | u251945221 | cpp |
p03032 | #include <bits/stdc++.h>
#include <numeric>
#include <vector>
#define PI 3.14159265358979323846
#define MAXINF (1e18L)
#define INF (1e9L)
#define EPS (1e-9)
#define MOD ((ll)(1e9 + 7))
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define ALL(v) v.begin(), v.end()
#define FIND(v, x) (binary_search(ALL(v), (x)))
#define SORT(v) sort(ALL(v))
#define RSORT(v) \
sort(ALL(v)); \
reverse(ALL(v))
#define DEBUG(x) cerr << #x << ": " << x << endl;
#define DEBUG_VEC(v) \
cerr << #v << ":"; \
for (int i = 0; i < v.size(); i++) \
cerr << " " << v[i]; \
cerr << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define pb push_back
#define fi first
#define se second
using namespace std;
template <class A> void pr(A a) { cout << (a) << endl; }
template <class A, class B> void pr(A a, B b) {
cout << a << " ";
pr(b);
}
template <class A, class B, class C> void pr(A a, B b, C c) {
cout << a << " ";
pr(b, c);
}
template <class A, class B, class C, class D> void pr(A a, B b, C c, D d) {
cout << a << " ";
pr(b, c, d);
}
template <class T> inline bool chmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T> inline bool chmax(T &a, T b) {
return a < b ? a = b, true : false;
}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main(void) {
int N, K;
vector<ll> v;
cin >> N >> K;
v.assign(N, 0);
REP(i, N) { cin >> v[i]; }
ll ans = 0;
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= N; j++) {
if (i + j > K)
break;
vector<ll> vt;
REP(a, i) vt.pb(v[a]);
REP(b, j) vt.pb(v[N - b - 1]);
for (int k = 0; k <= K - (i + j); k++) {
SORT(vt);
ll tmp_ans = 0;
for (int t = k; t < i + j; t++) {
tmp_ans += vt[t];
}
ans = max(ans, tmp_ans);
}
}
}
pr(ans);
} | #include <bits/stdc++.h>
#include <numeric>
#include <vector>
#define PI 3.14159265358979323846
#define MAXINF (1e18L)
#define INF (1e9L)
#define EPS (1e-9)
#define MOD ((ll)(1e9 + 7))
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define ALL(v) v.begin(), v.end()
#define FIND(v, x) (binary_search(ALL(v), (x)))
#define SORT(v) sort(ALL(v))
#define RSORT(v) \
sort(ALL(v)); \
reverse(ALL(v))
#define DEBUG(x) cerr << #x << ": " << x << endl;
#define DEBUG_VEC(v) \
cerr << #v << ":"; \
for (int i = 0; i < v.size(); i++) \
cerr << " " << v[i]; \
cerr << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define pb push_back
#define fi first
#define se second
using namespace std;
template <class A> void pr(A a) { cout << (a) << endl; }
template <class A, class B> void pr(A a, B b) {
cout << a << " ";
pr(b);
}
template <class A, class B, class C> void pr(A a, B b, C c) {
cout << a << " ";
pr(b, c);
}
template <class A, class B, class C, class D> void pr(A a, B b, C c, D d) {
cout << a << " ";
pr(b, c, d);
}
template <class T> inline bool chmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T> inline bool chmax(T &a, T b) {
return a < b ? a = b, true : false;
}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main(void) {
int N, K;
vector<ll> v;
cin >> N >> K;
v.assign(N, 0);
REP(i, N) { cin >> v[i]; }
ll ans = 0;
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= N; j++) {
if (i + j > K || i + j > N)
break;
vector<ll> vt;
REP(a, i) vt.pb(v[a]);
REP(b, j) vt.pb(v[N - b - 1]);
for (int k = 0; k <= K - (i + j); k++) {
SORT(vt);
ll tmp_ans = 0;
for (int t = k; t < i + j; t++) {
tmp_ans += vt[t];
}
ans = max(ans, tmp_ans);
}
}
}
pr(ans);
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 843,982 | 843,983 | u528720841 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
long long ans = -1LL << 60;
for (int a = 0; a <= min(N, K); a++) {
for (int b = 0; b <= min(N, K) - a; b++) {
vector<int> vec;
long long res = 0;
for (int i = 0; i < b; i++) {
vec.push_back(V[i]);
res += V[i];
}
for (int j = N - a; j < N; j++) {
vec.push_back(V[j]);
res += V[j];
}
sort(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] < 0 && cnt < (K - (a + b))) {
res += abs(vec[i]);
} //小さい順に K - ( a + b) こ分までは捨てられる
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
long long ans = -1LL << 60;
for (int a = 0; a <= min(N, K); a++) {
for (int b = 0; b <= min(N, K) - a; b++) {
vector<int> vec;
long long res = 0;
for (int i = 0; i < b; i++) {
vec.push_back(V[i]);
res += V[i];
}
for (int j = N - a; j < N; j++) {
vec.push_back(V[j]);
res += V[j];
}
sort(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] < 0 && cnt < (K - (a + b))) {
res += abs(vec[i]);
cnt++;
} //小さい順に K - ( a + b) こ分までは捨てられる
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.unary.arithmetic.add"
] | 843,989 | 843,990 | u904123392 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
long long ans = -1LL << 60;
for (int a = 0; a <= min(N, K); a++) {
for (int b = 0; b <= min(N, K) - a; b++) {
vector<int> vec;
long long res = 0;
for (int i = 0; i < b; i++) {
vec.push_back(V[i]);
res += V[i];
}
for (int j = N - 1 - a; j < N; j++) {
vec.push_back(V[j]);
res += V[j];
}
sort(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] < 0 && cnt < (K - (a + b))) {
res += abs(vec[i]);
} //小さい順に K - ( a + b) こ分までは捨てる
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
long long ans = -1LL << 60;
for (int a = 0; a <= min(N, K); a++) {
for (int b = 0; b <= min(N, K) - a; b++) {
vector<int> vec;
long long res = 0;
for (int i = 0; i < b; i++) {
vec.push_back(V[i]);
res += V[i];
}
for (int j = N - a; j < N; j++) {
vec.push_back(V[j]);
res += V[j];
}
sort(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] < 0 && cnt < (K - (a + b))) {
res += abs(vec[i]);
cnt++;
} //小さい順に K - ( a + b) こ分までは捨てられる
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.unary.arithmetic.add"
] | 843,991 | 843,990 | u904123392 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
long long ans = -1LL << 60;
for (int a = 0; a <= min(N, K); a++) {
for (int b = 0; b <= min(N, K) - a; b++) {
vector<int> vec;
long long res = 0;
for (int i = 0; i < b; i++) {
vec.push_back(V[i]);
res += V[i];
}
for (int j = N - a; j < N; j++) {
vec.push_back(V[j]);
res += V[j];
}
sort(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] < 0 && cnt < (K - (a + b))) {
res += abs(vec[i]);
} //小さい順に K - ( a + b) こ分までは捨てられる
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
long long ans = -1LL << 60;
for (int a = 0; a <= min(N, K); a++) {
for (int b = 0; b <= min(N, K) - a; b++) {
vector<int> vec;
long long res = 0;
for (int i = 0; i < b; i++) {
vec.push_back(V[i]);
res += V[i];
}
for (int j = N - a; j < N; j++) {
vec.push_back(V[j]);
res += V[j];
}
sort(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] < 0 && cnt < (K - (a + b))) {
res += abs(vec[i]);
cnt++;
} //小さい順に K - ( a + b) こ分までは捨てられる
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
} | [
"expression.unary.arithmetic.add"
] | 843,989 | 843,992 | u904123392 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
long long ans = -1LL << 60;
for (int a = 0; a <= min(N, K); a++) {
for (int b = 0; b <= min(N, K) - a; b++) {
vector<int> vec;
long long res = 0;
for (int i = 0; i < b; i++) {
vec.push_back(V[i]);
res += V[i];
}
for (int j = N - 1 - a; j < N; j++) {
vec.push_back(V[j]);
res += V[j];
}
sort(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] < 0 && cnt < (K - (a + b))) {
res += abs(vec[i]);
} //小さい順に K - ( a + b) こ分までは捨てる
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
long long ans = -1LL << 60;
for (int a = 0; a <= min(N, K); a++) {
for (int b = 0; b <= min(N, K) - a; b++) {
vector<int> vec;
long long res = 0;
for (int i = 0; i < b; i++) {
vec.push_back(V[i]);
res += V[i];
}
for (int j = N - a; j < N; j++) {
vec.push_back(V[j]);
res += V[j];
}
sort(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] < 0 && cnt < (K - (a + b))) {
res += abs(vec[i]);
cnt++;
} //小さい順に K - ( a + b) こ分までは捨てられる
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.unary.arithmetic.add"
] | 843,991 | 843,992 | u904123392 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define N 200010
#define ll long long
const ll mod = 1e9 + 7;
int n, k;
int a[55];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
ll ans = 0;
for (int i = 0; i <= min(k, n); i++) {
for (int j = 0; j <= min(k - i, n); j++) {
priority_queue<int, vector<int>, greater<int>> q;
ll sum = 0;
for (int x = 1; x <= i; x++)
q.push(a[x]), sum += a[x];
for (int y = 1; y <= j; y++)
q.push(a[n - y + 1]), sum += a[n - y + 1];
int c = k - i - j;
while (c--) {
if (q.empty())
break;
if (q.top() < 0)
sum -= q.top(), q.pop();
else
break;
}
ans = max(ans, sum);
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define N 200010
#define ll long long
const ll mod = 1e9 + 7;
int n, k;
int a[55];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
ll ans = 0;
for (int i = 0; i <= min(k, n); i++) {
for (int j = 0; i + j <= min(k, n); j++) {
priority_queue<int, vector<int>, greater<int>> q;
ll sum = 0;
for (int x = 1; x <= i; x++)
q.push(a[x]), sum += a[x];
for (int y = 1; y <= j; y++)
q.push(a[n - y + 1]), sum += a[n - y + 1];
int c = k - i - j;
while (c--) {
if (q.empty())
break;
if (q.top() < 0)
sum -= q.top(), q.pop();
else
break;
}
ans = max(ans, sum);
}
}
cout << ans;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 843,993 | 843,994 | u820628270 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define rrep(i, a, n) for (int(i) = (a); (i) >= (n); (i)--)
#define INF 1000000000
#define MOD 1000000007
typedef long long ll;
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
double euclid_distance(double a, double b) { return sqrt(a * a + b * b); }
ll gcd(ll a, ll b) {
ll r;
if (a < b) {
ll tmp;
tmp = a;
a = b;
b = tmp;
}
while (r = a % b) {
a = b;
b = r;
}
return b;
}
void Integer_factorization(long long int b, long long int n) {
long long int a = 2;
long long int count = 0;
long long int ans = 1;
long long int ndash = n;
if (b == 1)
cout << n << endl;
else {
while (ndash >= a * a) {
if (n % a == 0) {
count++;
n /= a;
if (count % b == 0) {
ans *= a;
}
} else {
a++;
count = 0;
}
}
cout << ans << endl;
}
}
ll r_fuct[2000];
ll fuct[2000];
// MOD逆元
void conb(ll n, ll k) {
fuct[0] = 1;
for (int i = 1; i < k + 1; i++) {
fuct[i] *= fuct[i - 1] % MOD;
ll b = MOD, u = 1, v = 0;
ll value = fuct[i];
while (b) {
ll t = value / b;
value -= t * b;
swap(value, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
r_fuct[i] = u;
}
}
void solve() {
ll n, k;
cin >> n >> k;
vector<ll> q;
ll ans = 0;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
q.push_back(t);
}
for (int i = 0; i < min(n, k) + 1; i++) {
for (int j = 0; j < min(n, k) - i + 1; j++) {
vector<ll> s = q;
s.erase(s.begin() + i, s.end() - j);
sort(s.begin(), s.end());
if (k - i - j == 0)
continue;
for (int p = 0; p < min((ll)k - i - j, (ll)s.size()); p++) {
s[p] = max((ll)0, s[p]);
}
ll tmp = accumulate(s.begin(), s.end(), 0);
ans = max(ans, tmp);
}
}
cout << max(ans, (ll)0) << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define rrep(i, a, n) for (int(i) = (a); (i) >= (n); (i)--)
#define INF 1000000000
#define MOD 1000000007
typedef long long ll;
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
double euclid_distance(double a, double b) { return sqrt(a * a + b * b); }
ll gcd(ll a, ll b) {
ll r;
if (a < b) {
ll tmp;
tmp = a;
a = b;
b = tmp;
}
while (r = a % b) {
a = b;
b = r;
}
return b;
}
void Integer_factorization(long long int b, long long int n) {
long long int a = 2;
long long int count = 0;
long long int ans = 1;
long long int ndash = n;
if (b == 1)
cout << n << endl;
else {
while (ndash >= a * a) {
if (n % a == 0) {
count++;
n /= a;
if (count % b == 0) {
ans *= a;
}
} else {
a++;
count = 0;
}
}
cout << ans << endl;
}
}
ll r_fuct[2000];
ll fuct[2000];
// MOD逆元
void conb(ll n, ll k) {
fuct[0] = 1;
for (int i = 1; i < k + 1; i++) {
fuct[i] *= fuct[i - 1] % MOD;
ll b = MOD, u = 1, v = 0;
ll value = fuct[i];
while (b) {
ll t = value / b;
value -= t * b;
swap(value, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
r_fuct[i] = u;
}
}
void solve() {
ll n, k;
cin >> n >> k;
vector<ll> q;
ll ans = 0;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
q.push_back(t);
}
for (int i = 0; i < min(n, k) + 1; i++) {
for (int j = 0; j < min(n, k) - i + 1; j++) {
vector<ll> s = q;
s.erase(s.begin() + i, s.end() - j);
sort(s.begin(), s.end());
if (k - i - j < 0)
continue;
for (int p = 0; p < min((ll)k - i - j, (ll)s.size()); p++) {
s[p] = max((ll)0, s[p]);
}
ll tmp = accumulate(s.begin(), s.end(), 0);
ans = max(ans, tmp);
}
}
cout << max(ans, (ll)0) << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 843,995 | 843,996 | u677400065 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef long long int lli;
using namespace std;
typedef pair<int, int> ii;
// #define int long long int
inline void swap(int &a, int &b) {
int tmp = a;
a = b;
b = tmp;
}
signed main() {
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
int _v;
cin >> _v;
V[i] = _v;
}
int ans = 0;
for (int p = 0; p < K; p++) {
for (int q = 0; q < K - p; q++) {
if (p + q > N)
continue;
int hand = 0;
priority_queue<int, vector<int>, greater<int>> neg;
for (int i = 0; i < p; i++) {
int v = V[i];
hand += v;
if (v < 0)
neg.push(v);
}
for (int i = 0; i < q; i++) {
int v = V[(N - 1) - i];
hand += v;
if (v < 0)
neg.push(v);
}
const int k = K - (p + q);
for (int i = 0; i < k && !neg.empty(); i++) {
int negV = neg.top();
neg.pop();
hand -= negV;
}
ans = max(hand, ans);
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef long long int lli;
using namespace std;
typedef pair<int, int> ii;
// #define int long long int
inline void swap(int &a, int &b) {
int tmp = a;
a = b;
b = tmp;
}
signed main() {
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
int _v;
cin >> _v;
V[i] = _v;
}
int ans = 0;
for (int p = 0; p <= K; p++) {
for (int q = 0; q <= K - p; q++) {
if (p + q > N)
continue;
int hand = 0;
priority_queue<int, vector<int>, greater<int>> neg;
for (int i = 0; i < p; i++) {
int v = V[i];
hand += v;
if (v < 0)
neg.push(v);
}
for (int i = 0; i < q; i++) {
int v = V[(N - 1) - i];
hand += v;
if (v < 0)
neg.push(v);
}
const int k = K - (p + q);
for (int i = 0; i < k && !neg.empty(); i++) {
int negV = neg.top();
neg.pop();
hand -= negV;
}
ans = max(hand, ans);
}
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 843,999 | 844,000 | u576106056 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
#define T true
#define F false
using namespace std;
int main(void) {
int i, l, r, num, k, lim, sum, ans = 0;
cin >> num >> k;
vector<int> d(num);
lim = min(num, k);
for (i = 0; i < num; i++)
scanf("%d", &d[i]);
for (l = 0; l < lim; l++) {
for (r = 0; l + r < lim; r++) {
sum = 0;
priority_queue<int, vector<int>, greater<int>> s;
for (i = 0; i < l; i++) {
s.push(d[i]);
sum += d[i];
}
for (i = num - 1; i >= num - r; i--) {
s.push(d[i]);
sum += d[i];
}
for (i = 0; i < k - r - l; i++) {
if (!s.empty() && s.top() < 0) {
sum -= s.top();
s.pop();
} else
break;
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
#define T true
#define F false
using namespace std;
int main(void) {
int i, l, r, num, k, lim, sum, ans = 0;
cin >> num >> k;
vector<int> d(num);
lim = min(num, k);
for (i = 0; i < num; i++)
scanf("%d", &d[i]);
for (l = 0; l <= lim; l++) {
for (r = 0; l + r <= lim; r++) {
sum = 0;
priority_queue<int, vector<int>, greater<int>> s;
for (i = 0; i < l; i++) {
s.push(d[i]);
sum += d[i];
}
for (i = num - 1; i >= num - r; i--) {
s.push(d[i]);
sum += d[i];
}
for (i = 0; i < k - r - l; i++) {
if (!s.empty() && s.top() < 0) {
sum -= s.top();
s.pop();
} else
break;
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,004 | 844,005 | u583354994 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
long long int mod = 1e9 + 7;
bool debug = false;
typedef long long ll;
int main() {
int n, k, r;
cin >> n >> k;
vector<int> v(n);
rep(i, n) cin >> v[i];
long long int max = 0, sum;
rep(left, k) {
rep(right, k) {
r = k - left - right;
if (r >= 0 && left + right <= n && (left > 0 || right > 0)) {
vector<int> a(left + right);
rep(i, left) a[i] = v[i];
rep(i, right) a[i + left] = v[n - 1 - i];
sort(a.begin(), a.end());
rep(i, r) {
if (a[i] < 0)
a[i] = 0;
}
sum = 0;
rep(i, a.size()) sum += a[i];
if (max < sum)
max = sum;
}
}
}
cout << max << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
long long int mod = 1e9 + 7;
bool debug = false;
typedef long long ll;
int main() {
int n, k, r;
cin >> n >> k;
vector<int> v(n);
rep(i, n) cin >> v[i];
long long int max = 0, sum;
rep(left, k + 1) {
rep(right, k + 1) {
r = k - left - right;
if (r >= 0 && left + right <= n && (left > 0 || right > 0)) {
vector<int> a(left + right);
rep(i, left) a[i] = v[i];
rep(i, right) a[i + left] = v[n - 1 - i];
sort(a.begin(), a.end());
rep(i, r) {
if (a[i] < 0)
a[i] = 0;
}
sum = 0;
rep(i, a.size()) sum += a[i];
if (max < sum)
max = sum;
}
}
}
cout << max << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 844,009 | 844,010 | u732502311 | cpp |
p03032 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> //__gnu_pbds::gp_hash_table<int, int> table;
// priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int,
// int>>> pq; //min heap
typedef int OwO;
typedef double UwU;
#define int long long
#define double long double
#define INF 1000000000
#define PI 3.14159265358979323846
#define watch(x) cout << (#x) << " is " << (x) << endl
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
#define vvi vector<vector<int>>
#define vi vector<int>
using namespace std;
OwO main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int N, K;
cin >> N >> K;
vector<int> t;
for (int x = 0; x < N; x++) {
int a;
cin >> a;
t.push_back(a);
}
int oup = -INF;
for (int tl = 0; tl < min(N, K); tl++) {
for (int tr = 0; tr + tl < min(N, K); tr++) {
int size = tl + tr;
vi hand = t;
hand.erase(hand.begin() + tl, hand.end() - tr);
sort(hand.rbegin(), hand.rend());
for (int x = 0; hand.size() && x < K - size && hand[size - x - 1] < 0;
x++)
hand.pop_back();
oup = max(oup, (int)accumulate(hand.begin(), hand.end(), 0));
}
}
cout << oup << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> //__gnu_pbds::gp_hash_table<int, int> table;
// priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int,
// int>>> pq; //min heap
typedef int OwO;
typedef double UwU;
#define int long long
#define double long double
#define INF 1000000000
#define PI 3.14159265358979323846
#define watch(x) cout << (#x) << " is " << (x) << endl
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
#define vvi vector<vector<int>>
#define vi vector<int>
using namespace std;
OwO main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int N, K;
cin >> N >> K;
vector<int> t;
for (int x = 0; x < N; x++) {
int a;
cin >> a;
t.push_back(a);
}
int oup = -INF;
for (int tl = 0; tl <= min(N, K); tl++) {
for (int tr = 0; tr + tl < min(N, K) + 1; tr++) {
int size = tl + tr;
vi hand = t;
hand.erase(hand.begin() + tl, hand.end() - tr);
sort(hand.rbegin(), hand.rend());
for (int x = 0; hand.size() && x < K - size && hand[size - x - 1] < 0;
x++)
hand.pop_back();
oup = max(oup, (int)accumulate(hand.begin(), hand.end(), 0));
}
}
cout << oup << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"misc.off_by_one"
] | 844,011 | 844,012 | u769471034 | cpp |
p03032 | #define _CRT_NONSTDC_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int INTMAX = numeric_limits<int>::max();
const int INTMIN = numeric_limits<int>::min();
const ll LLMAX = numeric_limits<long long>::max();
const ll LLMIN = numeric_limits<long long>::min();
const int MOD = 1000000007;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
bool solve() {
int n, k;
cin >> n >> k;
deque<int> v(n);
for (auto &&e : v)
cin >> e;
ll ans = 0;
for (int lout = 0; lout < k; lout++) {
for (int rout = 0; lout + rout < k; rout++) {
deque<int> vt(v);
priority_queue<int, std::vector<int>, greater<int>> q;
ll sum = 0;
for (int i = 0; i < lout; i++) {
if (vt.empty())
break;
q.push(vt.front());
sum += vt.front();
vt.pop_front();
}
for (int i = 0; i < rout; i++) {
if (vt.empty())
break;
q.push(vt.back());
sum += vt.back();
vt.pop_back();
}
for (int i = 0; i < k - lout - rout; i++) {
if (q.empty())
break;
if (q.top() < 0) {
sum -= q.top();
q.pop();
} else
break;
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return true;
}
signed main() {
solve();
return 0;
} | #define _CRT_NONSTDC_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int INTMAX = numeric_limits<int>::max();
const int INTMIN = numeric_limits<int>::min();
const ll LLMAX = numeric_limits<long long>::max();
const ll LLMIN = numeric_limits<long long>::min();
const int MOD = 1000000007;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
bool solve() {
int n, k;
cin >> n >> k;
deque<int> v(n);
for (auto &&e : v)
cin >> e;
ll ans = 0;
for (int lout = 0; lout <= k; lout++) {
for (int rout = 0; lout + rout <= k; rout++) {
deque<int> vt(v);
priority_queue<int, std::vector<int>, greater<int>> q;
ll sum = 0;
for (int i = 0; i < lout; i++) {
if (vt.empty())
break;
q.push(vt.front());
sum += vt.front();
vt.pop_front();
}
for (int i = 0; i < rout; i++) {
if (vt.empty())
break;
q.push(vt.back());
sum += vt.back();
vt.pop_back();
}
for (int i = 0; i < k - lout - rout; i++) {
if (q.empty())
break;
if (q.top() < 0) {
sum -= q.top();
q.pop();
} else
break;
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return true;
}
signed main() {
solve();
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,013 | 844,014 | u713333397 | cpp |
p03032 | // https://atcoder.jp/contests/abc128/tasks/abc128_d
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef priority_queue<int, vector<int>, greater<int>> PQ;
#define INF (1e9)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
// int gcd(long a, long b) { return b ? gcd(b, a % b) : a; }
// int lcm(long a, long b) { return a * b / gcd(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<ll> v(n), ans(100, -INF);
REP(i, n) cin >> v[i];
// 左側から取り出す処理
ll suml = 0;
PQ que1;
for (int i = 0; i <= min(k, n); i++) {
if (i > 0) {
que1.push(v[i - 1]);
suml += v[i - 1];
}
ll sumr = 0;
PQ que2 = que1;
// 右側から取り出す処理
for (int j = 0; j <= min(k, n); j++) {
if (j > 0) {
que2.push(v[n - j]);
sumr += v[n - j];
}
ans[i + j] = max(ans[i + j], suml + sumr);
ll cnt = 0, mi = 0;
PQ que3 = que2;
while (!que3.empty()) {
cnt++;
if (i + j + cnt > k)
break;
mi += que3.top();
que3.pop();
ans[i + j + cnt] = max(ans[i + j + cnt], suml + sumr - mi);
}
}
}
cout << *max_element(ALL(ans)) << endl;
return 0;
}
| // https://atcoder.jp/contests/abc128/tasks/abc128_d
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef priority_queue<int, vector<int>, greater<int>> PQ;
#define INF (1e9)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
// int gcd(long a, long b) { return b ? gcd(b, a % b) : a; }
// int lcm(long a, long b) { return a * b / gcd(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n), ans(100, -INF);
REP(i, n) cin >> v[i];
// 左側から取り出す処理
int suml = 0;
PQ que1;
for (int i = 0; i <= min(k, n); i++) {
if (i > 0) {
que1.push(v[i - 1]);
suml += v[i - 1];
}
int sumr = 0;
PQ que2 = que1;
// 右側から取り出す処理
for (int j = 0; i + j <= min(k, n); j++) {
if (j > 0) {
que2.push(v[n - j]);
sumr += v[n - j];
}
ans[i + j] = max(ans[i + j], suml + sumr);
int cnt = 0, mi = 0;
PQ que3 = que2;
while (!que3.empty()) {
cnt++;
if (i + j + cnt > k)
break;
mi += que3.top();
que3.pop();
ans[i + j + cnt] = max(ans[i + j + cnt], suml + sumr - mi);
}
}
}
cout << *max_element(ALL(ans)) << endl;
return 0;
}
| [
"variable_declaration.type.change",
"control_flow.loop.for.condition.change"
] | 844,015 | 844,016 | u858107870 | cpp |
p03032 | // https://atcoder.jp/contests/abc128/tasks/abc128_d
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef priority_queue<int, vector<int>, greater<int>> PQ;
#define INF (1e9)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
// int gcd(long a, long b) { return b ? gcd(b, a % b) : a; }
// int lcm(long a, long b) { return a * b / gcd(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n), ans(100, -INF);
REP(i, n) cin >> v[i];
// 左側から取り出す処理
int suml = 0;
PQ que1;
for (int i = 0; i <= min(k, n); i++) {
// 昇順に処理する
if (i > 0) {
que1.push(v[i - 1]);
suml += v[i - 1];
}
int sumr = 0;
PQ que2 = que1;
// 右側から取り出す処理
for (int j = 0; j <= min(k, n); j++) {
if (j > 0) {
que2.push(v[n - j]);
sumr += v[n - j];
}
ans[i + j] = max(ans[i + j], suml + sumr);
int cnt = 0, mi = 0;
PQ que3 = que2;
while (!que3.empty()) {
cnt++;
if (i + j + cnt > k)
break;
mi += que3.top();
que3.pop();
ans[i + j + cnt] = max(ans[i + j + cnt], suml + sumr - mi);
}
}
}
cout << *max_element(ALL(ans)) << endl;
return 0;
}
| // https://atcoder.jp/contests/abc128/tasks/abc128_d
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef priority_queue<int, vector<int>, greater<int>> PQ;
#define INF (1e9)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
// int gcd(long a, long b) { return b ? gcd(b, a % b) : a; }
// int lcm(long a, long b) { return a * b / gcd(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n), ans(100, -INF);
REP(i, n) cin >> v[i];
// 左側から取り出す処理
int suml = 0;
PQ que1;
for (int i = 0; i <= min(k, n); i++) {
if (i > 0) {
que1.push(v[i - 1]);
suml += v[i - 1];
}
int sumr = 0;
PQ que2 = que1;
// 右側から取り出す処理
for (int j = 0; i + j <= min(k, n); j++) {
if (j > 0) {
que2.push(v[n - j]);
sumr += v[n - j];
}
ans[i + j] = max(ans[i + j], suml + sumr);
int cnt = 0, mi = 0;
PQ que3 = que2;
while (!que3.empty()) {
cnt++;
if (i + j + cnt > k)
break;
mi += que3.top();
que3.pop();
ans[i + j + cnt] = max(ans[i + j + cnt], suml + sumr - mi);
}
}
}
cout << *max_element(ALL(ans)) << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 844,017 | 844,016 | u858107870 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int add(vector<int> &a) {
int sum = 0;
for (int i = 0; i < (int)a.size(); i++) {
sum += a[i];
}
return sum;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i <= n; i++) {
vector<int> b(a.begin(), a.begin() + i);
for (int j = n - 1; j >= i + 1 && (int)b.size() <= k; j--) {
sort(b.begin(), b.end());
int sum = add(b);
ans = max(ans, sum);
for (int l = 0;
l < (int)b.size() && b[l] < 0 && l + 1 + (int)b.size() <= k; l++) {
sum -= b[l];
ans = max(sum, ans);
}
b.push_back(a[j]);
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int add(vector<int> &a) {
int sum = 0;
for (int i = 0; i < (int)a.size(); i++) {
sum += a[i];
}
return sum;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i <= n; i++) {
vector<int> b(a.begin(), a.begin() + i);
for (int j = n - 1; j >= i - 1 && (int)b.size() <= k; j--) {
sort(b.begin(), b.end());
int sum = add(b);
ans = max(ans, sum);
for (int l = 0;
l < (int)b.size() && b[l] < 0 && l + 1 + (int)b.size() <= k; l++) {
sum -= b[l];
ans = max(sum, ans);
}
b.push_back(a[j]);
}
}
cout << ans;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 844,020 | 844,021 | u711524482 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define inf (ll)1e9
#define mod (ll)(1e9 + 7)
#define d(x) cerr << #x << "=" << x << endl;
#define p(x) cout << (x) << endl
#define ps(x) cout << (x);
#define pfix(d, x) cout << fixed << setprecision(d) << x << endl;
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define minel(v) *min_element(all(v))
#define minind(v) distance((v).begin(), min_element(all(v)))
#define maxel(v) *max_element(all(v))
#define maxind(v) distance((v).begin(), max_element(all(v)))
#define fi first
#define se second
ll a[100], b, d, n, m, x, y, z, k, h, w, sum, mi, ma, ans, s, t, l, r, res, tmp,
itr, p[11], q;
bool flag;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx8[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
char cha;
string st;
typedef map<int, int> imap;
typedef pair<ll, ll> P;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<pair<int, int>> VP;
int main() {
cin >> n >> k;
rep(i, n) cin >> a[i];
VL v;
rep(i, n + 1) rep(j, i + 1, n + 1) {
v.clear();
sum = 0;
d(i) d(j) if (i + (n - j) > k) continue;
rep(r, i) { d(a[r]) v.pb(a[r]); }
rep(r, (n - j)) { d(a[n - 1 - r]) v.pb(a[n - 1 - r]); }
if (v.size() == 0)
continue;
sort(all(v));
rep(r, v.size()) d(v[r]);
d(k - (i + (n - j))) rep(r, k - (i + (n - j))) if (v[r] < 0 && v.size() > 0)
v.erase(v.begin());
d("--") d(v.size()) rep(r, v.size()) d(v[r]);
rep(r, v.size()) sum += v[r];
d(sum);
ma = max(ma, sum);
}
p(ma);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define inf (ll)1e9
#define mod (ll)(1e9 + 7)
#define d(x) cerr << #x << "=" << x << endl;
#define p(x) cout << (x) << endl
#define ps(x) cout << (x);
#define pfix(d, x) cout << fixed << setprecision(d) << x << endl;
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define minel(v) *min_element(all(v))
#define minind(v) distance((v).begin(), min_element(all(v)))
#define maxel(v) *max_element(all(v))
#define maxind(v) distance((v).begin(), max_element(all(v)))
#define fi first
#define se second
ll a[100], b, d, n, m, x, y, z, k, h, w, sum, mi, ma, ans, s, t, l, r, res, tmp,
itr, p[11], q;
bool flag;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx8[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
char cha;
string st;
typedef map<int, int> imap;
typedef pair<ll, ll> P;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<pair<int, int>> VP;
int main() {
cin >> n >> k;
rep(i, n) cin >> a[i];
VL v;
rep(i, n + 1) rep(j, i, n + 1) {
v.clear();
sum = 0;
d(i) d(j) if (i + (n - j) > k) continue;
rep(r, i) { d(a[r]) v.pb(a[r]); }
rep(r, (n - j)) { d(a[n - 1 - r]) v.pb(a[n - 1 - r]); }
if (v.size() == 0)
continue;
sort(all(v));
rep(r, v.size()) d(v[r]);
d(k - (i + (n - j))) rep(r, k - (i + (n - j))) if (v[0] < 0 && v.size() > 0)
v.erase(v.begin());
d("--") d(v.size()) rep(r, v.size()) d(v[r]);
rep(r, v.size()) sum += v[r];
d(sum);
ma = max(ma, sum);
}
p(ma);
return 0;
}
| [
"expression.operation.binary.remove",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 844,033 | 844,032 | u001566280 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define inf (ll)1e9
#define mod (ll)(1e9 + 7)
#define d(x) cerr << #x << "=" << x << endl;
#define p(x) cout << (x) << endl
#define ps(x) cout << (x);
#define pfix(d, x) cout << fixed << setprecision(d) << x << endl;
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define minel(v) *min_element(all(v))
#define minind(v) distance((v).begin(), min_element(all(v)))
#define maxel(v) *max_element(all(v))
#define maxind(v) distance((v).begin(), max_element(all(v)))
#define fi first
#define se second
ll a[100], b, d, n, m, x, y, z, k, h, w, sum, mi, ma, ans, s, t, l, r, res, tmp,
itr, p[11], q;
bool flag;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx8[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
char cha;
string st;
typedef map<int, int> imap;
typedef pair<ll, ll> P;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<pair<int, int>> VP;
int main() {
cin >> n >> k;
rep(i, n) cin >> a[i];
VL v;
rep(i, n + 1) rep(j, i + 1, n + 1) {
v.clear();
sum = 0;
d(i) d(j) if (i + (n - j) > k) continue;
rep(r, i) { d(a[r]) v.pb(a[r]); }
rep(r, (n - j)) { d(a[n - 1 - r]) v.pb(a[n - 1 - r]); }
if (v.size() == 0)
continue;
sort(all(v));
rep(r, v.size()) d(v[r]);
d(k - (i + (n - j))) rep(r, k - (i + (n - j))) if (a[r] < 0 && v.size() > 0)
v.erase(v.begin());
d("--") d(v.size()) rep(r, v.size()) d(v[r]);
rep(r, v.size()) sum += v[r];
d(sum);
ma = max(ma, sum);
}
p(ma);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define inf (ll)1e9
#define mod (ll)(1e9 + 7)
#define d(x) cerr << #x << "=" << x << endl;
#define p(x) cout << (x) << endl
#define ps(x) cout << (x);
#define pfix(d, x) cout << fixed << setprecision(d) << x << endl;
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define minel(v) *min_element(all(v))
#define minind(v) distance((v).begin(), min_element(all(v)))
#define maxel(v) *max_element(all(v))
#define maxind(v) distance((v).begin(), max_element(all(v)))
#define fi first
#define se second
ll a[100], b, d, n, m, x, y, z, k, h, w, sum, mi, ma, ans, s, t, l, r, res, tmp,
itr, p[11], q;
bool flag;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx8[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
char cha;
string st;
typedef map<int, int> imap;
typedef pair<ll, ll> P;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<pair<int, int>> VP;
int main() {
cin >> n >> k;
rep(i, n) cin >> a[i];
VL v;
rep(i, n + 1) rep(j, i, n + 1) {
v.clear();
sum = 0;
d(i) d(j) if (i + (n - j) > k) continue;
rep(r, i) { d(a[r]) v.pb(a[r]); }
rep(r, (n - j)) { d(a[n - 1 - r]) v.pb(a[n - 1 - r]); }
if (v.size() == 0)
continue;
sort(all(v));
rep(r, v.size()) d(v[r]);
d(k - (i + (n - j))) rep(r, k - (i + (n - j))) if (v[0] < 0 && v.size() > 0)
v.erase(v.begin());
d("--") d(v.size()) rep(r, v.size()) d(v[r]);
rep(r, v.size()) sum += v[r];
d(sum);
ma = max(ma, sum);
}
p(ma);
return 0;
}
| [
"expression.operation.binary.remove",
"identifier.change",
"control_flow.branch.if.condition.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 844,034 | 844,032 | u001566280 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, ans = 0, tmp, tmp2;
priority_queue<int, vector<int>, greater<int>> desc;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
for (int i = 0; i <= K; i++) {
for (int j = 0; j <= K; j++) {
tmp = 0;
tmp2 = i + j;
if (tmp2 > K)
continue;
for (int k = 0; k < i; k++) {
desc.push(V[k]);
}
for (int k = 0; k < j; k++) {
desc.push(V[N - 1 - k]);
}
while (!desc.empty()) {
if (desc.top() < 0 && tmp2 < K)
tmp2++;
else
tmp += desc.top();
desc.pop();
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, ans = 0, tmp, tmp2;
priority_queue<int, vector<int>, greater<int>> desc;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
for (int i = 0; i <= K; i++) {
for (int j = 0; j <= K; j++) {
tmp = 0;
tmp2 = i + j;
if (tmp2 > K || tmp2 > N)
continue;
for (int k = 0; k < i; k++) {
desc.push(V[k]);
}
for (int k = 0; k < j; k++) {
desc.push(V[N - 1 - k]);
}
while (!desc.empty()) {
if (desc.top() < 0 && tmp2 < K)
tmp2++;
else
tmp += desc.top();
desc.pop();
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,037 | 844,038 | u074306398 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, ans = 0, tmp, tmp2;
priority_queue<int, vector<int>, greater<int>> desc;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
// for(int i=0; i<=K && i<N; i++){
// for(int j=0; j<=K&& j<N; j++){
for (int i = 0; i <= K && i <= N; i++) {
for (int j = 0; j <= K && j <= N; j++) {
tmp = 0;
tmp2 = i + j;
if (tmp2 > K || tmp > N)
continue;
for (int k = 0; k < i; k++) {
desc.push(V[k]);
}
for (int k = 0; k < j; k++) {
desc.push(V[N - 1 - k]);
}
while (!desc.empty()) {
// cout << desc.top()<< endl;
if (desc.top() < 0 && tmp2 < K)
tmp2++;
else
tmp += desc.top();
desc.pop();
}
// if (tmp == 6)
// cout << i<< " " << j<< endl;
// if (i == 2 && j==1)
// cout << tmp<< endl;
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, ans = 0, tmp, tmp2;
priority_queue<int, vector<int>, greater<int>> desc;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
for (int i = 0; i <= K && i <= N; i++) {
for (int j = 0; j <= K && j <= N; j++) {
tmp = 0;
tmp2 = i + j;
if (tmp2 > K || tmp2 > N)
continue;
for (int k = 0; k < i; k++) {
desc.push(V[k]);
}
for (int k = 0; k < j; k++) {
desc.push(V[N - 1 - k]);
}
while (!desc.empty()) {
if (desc.top() < 0 && tmp2 < K)
tmp2++;
else
tmp += desc.top();
desc.pop();
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 844,039 | 844,040 | u074306398 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, ans = 0, tmp, tmp2;
priority_queue<int, vector<int>, greater<int>> desc;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
// for(int i=0; i<=K && i<N; i++){
// for(int j=0; j<=K&& j<N; j++){
for (int i = 0; i <= K && i <= N; i++) {
for (int j = 0; j <= K && j <= N; j++) {
tmp = 0;
tmp2 = i + j;
if (tmp2 > K)
continue;
for (int k = 0; k < i; k++) {
desc.push(V[k]);
}
for (int k = 0; k < j; k++) {
desc.push(V[N - 1 - k]);
}
while (!desc.empty()) {
// cout << desc.top()<< endl;
if (desc.top() < 0 && tmp2 < K)
tmp2++;
else
tmp += desc.top();
desc.pop();
}
// if (tmp == 6)
// cout << i<< " " << j<< endl;
// if (i == 2 && j==1)
// cout << tmp<< endl;
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, ans = 0, tmp, tmp2;
priority_queue<int, vector<int>, greater<int>> desc;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
for (int i = 0; i <= K && i <= N; i++) {
for (int j = 0; j <= K && j <= N; j++) {
tmp = 0;
tmp2 = i + j;
if (tmp2 > K || tmp2 > N)
continue;
for (int k = 0; k < i; k++) {
desc.push(V[k]);
}
for (int k = 0; k < j; k++) {
desc.push(V[N - 1 - k]);
}
while (!desc.empty()) {
if (desc.top() < 0 && tmp2 < K)
tmp2++;
else
tmp += desc.top();
desc.pop();
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,041 | 844,040 | u074306398 | cpp |
p03032 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define print(s) cout << s << endl
#define acc(v) accumulate(v.begin(), v.end(), 0)
#define cinv(n, v) rep(i, n) cin >> v[i]
using namespace std;
const int INF = 1e9;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vchar;
const ll LINF = 1e18;
const ll MOD = 1e9 + 7;
// const lint MOD = 998244353;
int x_pos[4] = {1, 0, -1, 0}, y_pos[4] = {0, 1, 0, -1};
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
char upper(char c) { return c - 0x20; }
char lower(char c) { return c + 0x20; }
void unique_vector(vector<int> &v) {
sort(all(v));
v.erase(unique(all(v)), v.end());
}
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
rep(i, n) cin >> v[i];
int ans = 0;
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++) {
if (i + j == 0)
continue;
if (i + j > n)
continue;
if (i + j > k)
continue;
vector<int> t;
int s = k - i - j;
for (int f = 0; f < i; f++)
t.push_back(v[f]);
for (int b = n - 1; b > n - 1 - j; b--)
t.push_back(v[b]);
sort(all(t));
rep(ss, s) {
if (t.size() == 0)
break;
if (t[ss] < 0)
t.erase(t.begin());
else
break;
}
ans = max(ans, acc(t));
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define print(s) cout << s << endl
#define acc(v) accumulate(v.begin(), v.end(), 0)
#define cinv(n, v) rep(i, n) cin >> v[i]
using namespace std;
const int INF = 1e9;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vchar;
const ll LINF = 1e18;
const ll MOD = 1e9 + 7;
// const lint MOD = 998244353;
int x_pos[4] = {1, 0, -1, 0}, y_pos[4] = {0, 1, 0, -1};
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
char upper(char c) { return c - 0x20; }
char lower(char c) { return c + 0x20; }
void unique_vector(vector<int> &v) {
sort(all(v));
v.erase(unique(all(v)), v.end());
}
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
rep(i, n) cin >> v[i];
int ans = 0;
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++) {
if (i + j == 0)
continue;
if (i + j > n)
break;
if (i + j > k)
break;
vector<int> t;
int s = k - i - j;
for (int f = 0; f < i; f++)
t.push_back(v[f]);
for (int b = n - 1; b > n - 1 - j; b--)
t.push_back(v[b]);
sort(all(t));
rep(ss, s) {
if (t.size() == 0)
break;
if (t[0] < 0)
t.erase(t.begin());
else
break;
}
ans = max(ans, acc(t));
}
}
cout << ans << endl;
} | [
"control_flow.continue.remove",
"control_flow.break.add",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 844,042 | 844,043 | u130834452 | cpp |
p03032 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define print(s) cout << s << endl
#define acc(v) accumulate(v.begin(), v.end(), 0)
#define cinv(n, v) rep(i, n) cin >> v[i]
using namespace std;
const int INF = 1e9;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vchar;
const ll LINF = 1e18;
const ll MOD = 1e9 + 7;
// const lint MOD = 998244353;
int x_pos[4] = {1, 0, -1, 0}, y_pos[4] = {0, 1, 0, -1};
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
char upper(char c) { return c - 0x20; }
char lower(char c) { return c + 0x20; }
void unique_vector(vector<int> &v) {
sort(all(v));
v.erase(unique(all(v)), v.end());
}
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
rep(i, n) cin >> v[i];
int ans = 0;
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++) {
if (i + j == 0)
continue;
if (i + j > n)
break;
if (i + j > k)
break;
vector<int> t;
int s = k - i - j;
for (int f = 0; f < i; f++)
t.push_back(v[f]);
for (int b = n - 1; b > n - 1 - j; b--)
t.push_back(v[b]);
sort(all(t));
rep(ss, s) {
if (t.size() == 0)
break;
if (t[ss] < 0)
t.erase(t.begin());
else
break;
}
ans = max(ans, acc(t));
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define print(s) cout << s << endl
#define acc(v) accumulate(v.begin(), v.end(), 0)
#define cinv(n, v) rep(i, n) cin >> v[i]
using namespace std;
const int INF = 1e9;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vchar;
const ll LINF = 1e18;
const ll MOD = 1e9 + 7;
// const lint MOD = 998244353;
int x_pos[4] = {1, 0, -1, 0}, y_pos[4] = {0, 1, 0, -1};
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
char upper(char c) { return c - 0x20; }
char lower(char c) { return c + 0x20; }
void unique_vector(vector<int> &v) {
sort(all(v));
v.erase(unique(all(v)), v.end());
}
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
rep(i, n) cin >> v[i];
int ans = 0;
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++) {
if (i + j == 0)
continue;
if (i + j > n)
break;
if (i + j > k)
break;
vector<int> t;
int s = k - i - j;
for (int f = 0; f < i; f++)
t.push_back(v[f]);
for (int b = n - 1; b > n - 1 - j; b--)
t.push_back(v[b]);
sort(all(t));
rep(ss, s) {
if (t.size() == 0)
break;
if (t[0] < 0)
t.erase(t.begin());
else
break;
}
ans = max(ans, acc(t));
}
}
cout << ans << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 844,044 | 844,043 | u130834452 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll n, k;
vector<ll> v;
int main() {
cin >> n >> k;
v.resize(n);
for (int i = 0; i < n; i++)
scanf("%Ld", &v[i]);
ll res = -(1e18);
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= i; j++) {
vector<ll> getj;
for (int l = 0; l < j; l++)
getj.push_back(v[l]);
for (int r = 0; r < i - j; r++)
getj.push_back(v[n - 1 - r]);
ll sum = accumulate(getj.begin(), getj.end(), 0);
sort(getj.begin(), getj.end());
for (int ii = 0; ii < min(k - i, (ll)getj.size()); ii++) {
if (getj[ii] < 0)
sum -= getj[ii];
}
res = max(res, sum);
}
}
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll n, k;
vector<ll> v;
int main() {
cin >> n >> k;
v.resize(n);
for (int i = 0; i < n; i++)
scanf("%Ld", &v[i]);
ll res = -(1e18);
for (int i = 0; i <= min(k, n); i++) {
for (int j = 0; j <= i; j++) {
vector<ll> getj;
for (int l = 0; l < j; l++)
getj.push_back(v[l]);
for (int r = 0; r < i - j; r++)
getj.push_back(v[n - 1 - r]);
ll sum = accumulate(getj.begin(), getj.end(), 0);
sort(getj.begin(), getj.end());
for (int ii = 0; ii < min(k - i, (ll)getj.size()); ii++) {
if (getj[ii] < 0)
sum -= getj[ii];
}
res = max(res, sum);
}
}
cout << res << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 844,045 | 844,046 | u877476774 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <vector>
#define int long long
using namespace std;
int n, k, a[100], ans;
signed main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < min(n, k); i++) {
for (int j = 0; i + j < min(n, k); j++) {
vector<int> v;
int sum = 0;
for (int p = 0; p < i; p++) {
v.push_back(a[p]);
sum += a[p];
}
for (int p = 0; p < j; p++) {
v.push_back(a[n - p - 1]);
sum += a[n - p - 1];
}
sort(v.begin(), v.end());
for (int p = 0; p < min(k - i - j, i + j); p++)
sum -= min(v[p], (int)0);
ans = max(ans, sum);
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define int long long
using namespace std;
int n, k, a[100], ans;
signed main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i <= min(n, k); i++) {
for (int j = 0; i + j <= min(n, k); j++) {
vector<int> v;
int sum = 0;
for (int p = 0; p < i; p++) {
v.push_back(a[p]);
sum += a[p];
}
for (int p = 0; p < j; p++) {
v.push_back(a[n - p - 1]);
sum += a[n - p - 1];
}
sort(v.begin(), v.end());
for (int p = 0; p < min(k - i - j, i + j); p++)
sum -= min(v[p], (int)0);
ans = max(ans, sum);
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,049 | 844,050 | u141968173 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
using namespace std;
void solve(int N, int K, vector<int> v) {
int ans = 0;
for (int l = 0; l < K; l++) {
for (int r = 0; r < K - l; r++) {
if (l + r > N) {
continue;
}
int d = K - l - r;
int cur = 0;
vector<int> vv;
for (int i = 0; i < l; i++) {
cur += v[i];
vv.emplace_back(v[i]);
}
for (int i = N - r; i < N; i++) {
cur += v[i];
vv.emplace_back(v[i]);
}
sort(vv.begin(), vv.end());
for (int i = 0; i < d; i++) {
if (i >= vv.size()) {
break;
}
if (vv[i] < 0) {
cur -= vv[i];
}
}
ans = max(ans, cur);
}
}
printf("%d\n", ans);
}
int main() {
int N, K;
scanf("%d %d", &N, &K);
vector<int> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i];
}
solve(N, K, v);
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
using namespace std;
void solve(int N, int K, vector<int> v) {
int ans = 0;
for (int l = 0; l <= K; l++) {
for (int r = 0; r <= K - l; r++) {
if (l + r > N) {
continue;
}
int d = K - l - r;
int cur = 0;
vector<int> vv;
for (int i = 0; i < l; i++) {
cur += v[i];
vv.emplace_back(v[i]);
}
for (int i = N - r; i < N; i++) {
cur += v[i];
vv.emplace_back(v[i]);
}
sort(vv.begin(), vv.end());
for (int i = 0; i < d; i++) {
if (i >= vv.size()) {
break;
}
if (vv[i] < 0) {
cur -= vv[i];
}
}
ans = max(ans, cur);
}
}
printf("%d\n", ans);
}
int main() {
int N, K;
scanf("%d %d", &N, &K);
vector<int> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i];
}
solve(N, K, v);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,051 | 844,052 | u910756197 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
using namespace std;
void solve(int N, int K, vector<int> v) {
int ans = 0;
for (int l = 0; l < min(N, K); l++) {
for (int r = 0; r < min(N, K); r++) {
if (l + r > min(N, K)) {
continue;
}
int d = K - l - r;
int cur = 0;
vector<int> vv;
for (int i = 0; i < l; i++) {
cur += v[i];
vv.emplace_back(v[i]);
}
for (int i = N - r; i < N; i++) {
cur += v[i];
vv.emplace_back(v[i]);
}
sort(vv.begin(), vv.end());
for (int i = 0; i < d; i++) {
if (i >= vv.size()) {
break;
}
if (vv[i] < 0) {
cur -= vv[i];
}
}
ans = max(ans, cur);
}
}
printf("%d\n", ans);
}
int main() {
int N, K;
scanf("%d %d", &N, &K);
vector<int> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i];
}
solve(N, K, v);
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
using namespace std;
void solve(int N, int K, vector<int> v) {
int ans = 0;
for (int l = 0; l <= min(N, K); l++) {
for (int r = 0; r <= min(N, K); r++) {
if (l + r > min(N, K)) {
continue;
}
int d = K - l - r;
int cur = 0;
vector<int> vv;
for (int i = 0; i < l; i++) {
cur += v[i];
vv.emplace_back(v[i]);
}
for (int i = N - r; i < N; i++) {
cur += v[i];
vv.emplace_back(v[i]);
}
sort(vv.begin(), vv.end());
for (int i = 0; i < d; i++) {
if (i >= vv.size()) {
break;
}
if (vv[i] < 0) {
cur -= vv[i];
}
}
ans = max(ans, cur);
}
}
printf("%d\n", ans);
}
int main() {
int N, K;
scanf("%d %d", &N, &K);
vector<int> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i];
}
solve(N, K, v);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,053 | 844,054 | u910756197 | cpp |
p03032 | // D.
#include <algorithm>
#include <iostream>
#include <numeric>
#include <sstream>
#include <vector>
using namespace std;
typedef long long LL;
int main(int argc, char *argv[]) {
int n, k;
cin >> n >> k;
vector<LL> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
LL ans = 0;
vector<LL> a;
for (int i = 0; i <= k; ++i) {
if (i) {
a.push_back(v[i - 1]);
}
vector<LL> b = a;
for (int j = 0; j <= min(n - k, k - i); ++j) {
if (j) {
b.push_back(v[n - j]);
}
sort(b.begin(), b.end());
LL tot = accumulate(b.begin(), b.end(), 0LL);
for (int l = 0; l < (int)b.size() && l < k - i - j; ++l) {
if (b[l] < 0) {
tot -= b[l];
}
}
ans = max(ans, tot);
}
}
cout << ans << endl;
return 0;
}
| // D.
#include <algorithm>
#include <iostream>
#include <numeric>
#include <sstream>
#include <vector>
using namespace std;
typedef long long LL;
int main(int argc, char *argv[]) {
int n, k;
cin >> n >> k;
vector<LL> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
LL ans = 0;
vector<LL> a;
for (int i = 0; i <= k; ++i) {
if (i) {
a.push_back(v[i - 1]);
}
vector<LL> b = a;
for (int j = 0; j <= min(n - i, k - i); ++j) {
if (j) {
b.push_back(v[n - j]);
}
sort(b.begin(), b.end());
LL tot = accumulate(b.begin(), b.end(), 0LL);
for (int l = 0; l < (int)b.size() && l < k - i - j; ++l) {
if (b[l] < 0) {
tot -= b[l];
}
}
ans = max(ans, tot);
}
}
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 844,055 | 844,056 | u586336940 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define pii pair<int, int>
#define mp make_pair
#define fi first
#define se second
#define inf 0x7fffffff
using namespace std;
int a[100];
multiset<int> s;
int main() {
int i, j, k, n, m, x, y, l, sum, ans = 0;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i <= k; i++) {
for (j = i; j <= n; j++) {
if (n - j > k) {
continue;
}
s.clear();
sum = 0;
for (l = 0; l < i; l++) {
s.insert(a[l]);
sum += a[l];
}
for (l = j; l < n; l++) {
s.insert(a[l]);
sum += a[l];
}
x = k - i - (n - j);
ans = max(ans, sum);
while (x > 0 && !s.empty() && *s.begin() < 0) {
sum -= (*s.begin());
s.erase(s.begin());
x--;
}
ans = max(ans, sum);
}
}
printf("%d", ans);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define pii pair<int, int>
#define mp make_pair
#define fi first
#define se second
#define inf 0x7fffffff
using namespace std;
int a[100];
multiset<int> s;
int main() {
int i, j, k, n, m, x, y, l, sum, ans = 0;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i <= k; i++) {
for (j = i; j <= n; j++) {
if (i + n - j > k) {
continue;
}
s.clear();
sum = 0;
for (l = 0; l < i; l++) {
s.insert(a[l]);
sum += a[l];
}
for (l = j; l < n; l++) {
s.insert(a[l]);
sum += a[l];
}
x = k - i - (n - j);
ans = max(ans, sum);
while (x > 0 && !s.empty() && *s.begin() < 0) {
sum -= (*s.begin());
s.erase(s.begin());
x--;
}
ans = max(ans, sum);
}
}
printf("%d", ans);
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,060 | 844,061 | u742987397 | cpp |
p03032 | //解説参考
//他者コード参考
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
static const int MAX = 50;
using namespace std;
int N, K, ans;
int D[MAX + 2];
int solve() {
for (int a = 0; a <= K && a < N; a++) {
for (int b = 0; a + b < K && a + b < N; b++) {
vector<int> V;
int sum = 0;
for (int i = 0; i < a; i++) {
V.push_back(D[i]);
sum += D[i];
}
for (int i = 0; i < b; i++) {
V.push_back(D[N - 1 - i]);
sum += D[N - 1 - i];
}
ans = max(sum, ans);
sort(V.begin(), V.end());
int i = 0;
while (i < V.size() && a + b + i < K && V[i] < 0) {
sum -= V[i++];
}
ans = max(sum, ans);
}
}
return ans;
}
int main(void) {
scanf("%d %d", &N, &K);
for (int i = 0; i < N; i++) {
int v;
scanf("%d", &v);
D[i] = v;
}
printf("%d\n", solve());
}
| //解説参考
//他者コード参考
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
static const int MAX = 50;
using namespace std;
int N, K, ans;
int D[MAX + 2];
int solve() {
for (int a = 0; a <= K && a <= N; a++) {
for (int b = 0; a + b <= K && a + b <= N; b++) {
vector<int> V;
int sum = 0;
for (int i = 0; i < a; i++) {
V.push_back(D[i]);
sum += D[i];
}
for (int i = 0; i < b; i++) {
V.push_back(D[N - 1 - i]);
sum += D[N - 1 - i];
}
ans = max(sum, ans);
sort(V.begin(), V.end());
int i = 0;
while (i < V.size() && a + b + i < K && V[i] < 0) {
sum -= V[i++];
}
ans = max(sum, ans);
}
}
return ans;
}
int main(void) {
scanf("%d %d", &N, &K);
for (int i = 0; i < N; i++) {
int v;
scanf("%d", &v);
D[i] = v;
}
printf("%d\n", solve());
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,068 | 844,069 | u877847737 | cpp |
p03032 | #include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
struct edge {
int to, cost;
};
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> P;
const int INF = 1e9;
const double EPS = 1e-10;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
const int mx4[] = {0, 1, 0, -1};
const int my4[] = {1, 0, -1, 0};
const int mx8[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int my8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int main() {
int n, k;
cin >> n >> k;
vi v(n);
rep(i, n) cin >> v[i];
ll ans = 0;
for (int left = 0; left < min(n, k); left++) {
for (int right = 0; right < min(n, k); right++) {
if (left + right > min(n, k))
break;
vi num;
for (int i = 0; i < left; i++)
num.emplace_back(v[i]);
for (int i = 0; i < right; i++)
num.emplace_back(v[n - 1 - i]);
sort(all(num));
for (int i = 0; i < num.size() && num[i] < 0 && i < k - left - right;
i++) {
num[i] = 0;
}
ll sum = 0;
for (int i = 0; i < num.size(); i++)
sum += num[i];
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
struct edge {
int to, cost;
};
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> P;
const int INF = 1e9;
const double EPS = 1e-10;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
const int mx4[] = {0, 1, 0, -1};
const int my4[] = {1, 0, -1, 0};
const int mx8[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int my8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int main() {
int n, k;
cin >> n >> k;
vi v(n);
rep(i, n) cin >> v[i];
ll ans = 0;
for (int left = 0; left <= min(n, k); left++) {
for (int right = 0; right <= min(n, k); right++) {
if (left + right > min(n, k))
break;
vi num;
for (int i = 0; i < left; i++)
num.emplace_back(v[i]);
for (int i = 0; i < right; i++)
num.emplace_back(v[n - 1 - i]);
sort(all(num));
for (int i = 0; i < num.size() && num[i] < 0 && i < k - left - right;
i++) {
num[i] = 0;
}
ll sum = 0;
for (int i = 0; i < num.size(); i++)
sum += num[i];
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,077 | 844,078 | u216772548 | cpp |
p03032 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define dbg(...) \
do { \
cerr << __LINE__ << ": "; \
dbgprint(#__VA_ARGS__, __VA_ARGS__); \
} while (0);
using namespace std;
namespace std {
template <class S, class T> struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T> struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v)
h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, v.size()) os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v)
os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v)
os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n, k;
cin >> n >> k;
vi v(n);
rep(i, n) cin >> v[i];
ll ans = 0;
for (int i = max(0, n - k); i <= n; i++)
for (int l = 0; l <= n - i; l++) {
ll tmp = 0;
vi rem;
rep(j, n) {
if (l <= j && j < l + i)
continue;
tmp += v[j];
rem.pb(v[j]);
}
sort(all(rem));
int cnt = min((int)rem.size(), k - n + i);
rep(j, cnt) tmp -= rem[j];
ans = max(ans, tmp);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define dbg(...) \
do { \
cerr << __LINE__ << ": "; \
dbgprint(#__VA_ARGS__, __VA_ARGS__); \
} while (0);
using namespace std;
namespace std {
template <class S, class T> struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T> struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v)
h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, v.size()) os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v)
os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v)
os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n, k;
cin >> n >> k;
vi v(n);
rep(i, n) cin >> v[i];
ll ans = 0;
for (int i = max(0, n - k); i <= n; i++)
for (int l = 0; l <= n - i; l++) {
ll tmp = 0;
vi rem;
rep(j, n) {
if (l <= j && j < l + i)
continue;
tmp += v[j];
rem.pb(v[j]);
}
sort(all(rem));
int cnt = min((int)rem.size(), k - n + i);
rep(j, cnt) tmp -= min(0, rem[j]);
ans = max(ans, tmp);
}
cout << ans << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 844,100 | 844,101 | u525288965 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll N, K;
cin >> N >> K;
vector<ll> V(N);
for (auto &v : V)
cin >> v;
ll ans = 0;
for (ll i = 0; i <= K; i++) {
priority_queue<ll, vector<ll>, greater<ll>> pq;
for (ll left = 0; left <= i; left++) {
ll right = i - left;
for (ll j = 0; j < left; j++) {
pq.push(V[j]);
}
for (ll j = N - 1; j >= N - right; j--) {
pq.push(V[j]);
}
for (ll j = 0; j < K - i; j++) {
if (pq.empty())
break;
ll tmp = pq.top();
if (tmp > 0)
break;
pq.pop();
}
ll sum = 0;
while (!pq.empty()) {
sum += pq.top();
pq.pop();
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
ll N, K;
cin >> N >> K;
vector<ll> V(N);
for (auto &v : V)
cin >> v;
ll ans = 0;
for (ll i = 0; i <= min(N, K); i++) {
priority_queue<ll, vector<ll>, greater<ll>> pq;
for (ll left = 0; left <= i; left++) {
ll right = i - left;
for (ll j = 0; j < left; j++) {
pq.push(V[j]);
}
for (ll j = N - 1; j >= N - right; j--) {
pq.push(V[j]);
}
for (ll j = 0; j < K - i; j++) {
if (pq.empty())
break;
ll tmp = pq.top();
if (tmp > 0)
break;
pq.pop();
}
ll sum = 0;
while (!pq.empty()) {
sum += pq.top();
pq.pop();
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 844,107 | 844,108 | u634208461 | cpp |
p03032 | #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define debug(x) cout << #x << ": " << x << endl
#define repn(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, a) for (int i = 0; i < (int)(a); i++)
#define all(v) v.begin(), v.end()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
int gcd(int a, int b) { return ((b == 0) ? a : gcd(b, a % b)); }
int n, k;
ll v[55];
ll dp[55][55][105];
ll solve(int l, int r, int x) {
if (x < 0)
return -1e9;
if (x == 0 || l > r)
return 0;
if (dp[l][r][x] != -1)
return dp[l][r][x];
ll op1 = solve(l + 1, r, x - 1) + v[l];
ll op2 = solve(l, r - 1, x - 1) + v[r];
ll op3 = solve(l + 1, r, x - 2);
ll op4 = solve(l, r + 1, x - 2);
ll op5 = 0;
ll ret = max({op1, op2, op3, op4, op5});
return dp[l][r][x] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
// freopen("input.in", "r", stdin);
// freopen("output.out", "w", stdout);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
rep(i, n) cin >> v[i];
cout << solve(0, n - 1, k) << endl;
return 0;
}
/*
Things to look out for:
- Integer overflows
- Array bounds
- Special cases
Be careful!
*/
| #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define debug(x) cout << #x << ": " << x << endl
#define repn(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, a) for (int i = 0; i < (int)(a); i++)
#define all(v) v.begin(), v.end()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
int gcd(int a, int b) { return ((b == 0) ? a : gcd(b, a % b)); }
int n, k;
ll v[55];
ll dp[55][55][105];
ll solve(int l, int r, int x) {
if (x < 0)
return -1e9;
if (x == 0 || l > r)
return 0;
if (dp[l][r][x] != -1)
return dp[l][r][x];
ll op1 = solve(l + 1, r, x - 1) + v[l];
ll op2 = solve(l, r - 1, x - 1) + v[r];
ll op3 = solve(l + 1, r, x - 2);
ll op4 = solve(l, r - 1, x - 2);
ll op5 = 0;
ll ret = max({op1, op2, op3, op4, op5});
return dp[l][r][x] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
// freopen("input.in", "r", stdin);
// freopen("output.out", "w", stdout);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
rep(i, n) cin >> v[i];
cout << solve(0, n - 1, k) << endl;
return 0;
}
/*
Things to look out for:
- Integer overflows
- Array bounds
- Special cases
Be careful!
*/
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 844,111 | 844,112 | u626595726 | cpp |
p03032 | #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define debug(x) cout << #x << ": " << x << endl
#define repn(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, a) for (int i = 0; i < (int)(a); i++)
#define all(v) v.begin(), v.end()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
int gcd(int a, int b) { return ((b == 0) ? a : gcd(b, a % b)); }
int n, k;
int v[55];
ll dp[55][55][105];
ll solve(int l, int r, int x) {
if (x < 0)
return -1e9;
if (x == 0 || l > r)
return 0;
if (dp[l][r][x] != -1)
return dp[l][r][x];
ll op1 = solve(l + 1, r, x - 1) + v[l];
ll op2 = solve(l, r - 1, x - 1) + v[r];
ll op3 = solve(l + 1, r, x - 2);
ll op4 = solve(l, r + 1, x - 2);
ll op5 = 0;
ll ret = max({op1, op2, op3, op4, op5});
return dp[l][r][x] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
// freopen("input.in", "r", stdin);
// freopen("output.out", "w", stdout);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
rep(i, n) cin >> v[i];
cout << solve(0, n - 1, k) << endl;
return 0;
}
/*
Things to look out for:
- Integer overflows
- Array bounds
- Special cases
Be careful!
*/
| #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define debug(x) cout << #x << ": " << x << endl
#define repn(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, a) for (int i = 0; i < (int)(a); i++)
#define all(v) v.begin(), v.end()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define endl '\n'
int gcd(int a, int b) { return ((b == 0) ? a : gcd(b, a % b)); }
int n, k;
ll v[55];
ll dp[55][55][105];
ll solve(int l, int r, int x) {
if (x < 0)
return -1e9;
if (x == 0 || l > r)
return 0;
if (dp[l][r][x] != -1)
return dp[l][r][x];
ll op1 = solve(l + 1, r, x - 1) + v[l];
ll op2 = solve(l, r - 1, x - 1) + v[r];
ll op3 = solve(l + 1, r, x - 2);
ll op4 = solve(l, r - 1, x - 2);
ll op5 = 0;
ll ret = max({op1, op2, op3, op4, op5});
return dp[l][r][x] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
// freopen("input.in", "r", stdin);
// freopen("output.out", "w", stdout);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
rep(i, n) cin >> v[i];
cout << solve(0, n - 1, k) << endl;
return 0;
}
/*
Things to look out for:
- Integer overflows
- Array bounds
- Special cases
Be careful!
*/
| [
"variable_declaration.type.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 844,113 | 844,112 | u626595726 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.