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 | #include <bits/stdc++.h>
using namespace std;
int arr[55];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int R = min(n, k);
int ans = 0;
for (int i = 1; i <= R; i++) {
for (int j = 1; j <= R; j++) {
if (i + j > R) {
break;
}
vector<int> negg;
int sum = 0;
for (int a = 0; a < i; a++) {
sum += arr[a];
if (arr[a] < 0) {
negg.push_back(arr[a]);
}
}
for (int b = 0; b < j; b++) {
sum += arr[n - b - 1];
if (arr[n - b - 1] < 0) {
negg.push_back(arr[n - b - 1]);
}
}
ans = max(ans, sum);
sort(negg.begin(), negg.end());
for (int c = 0; c < negg.size() && c + i + j < k; c++) {
sum -= negg[c];
ans = max(ans, sum);
}
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int arr[55];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int R = min(n, k);
int ans = 0;
for (int i = 0; i <= R; i++) {
for (int j = 0; j <= R; j++) {
if (i + j > R) {
break;
}
vector<int> negg;
int sum = 0;
for (int a = 0; a < i; a++) {
sum += arr[a];
if (arr[a] < 0) {
negg.push_back(arr[a]);
}
}
for (int b = 0; b < j; b++) {
sum += arr[n - b - 1];
if (arr[n - b - 1] < 0) {
negg.push_back(arr[n - b - 1]);
}
}
ans = max(ans, sum);
sort(negg.begin(), negg.end());
for (int c = 0; c < negg.size() && c + i + j < k; c++) {
sum -= negg[c];
ans = max(ans, sum);
}
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 844,132 | 844,133 | u009824133 | cpp |
p03032 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
//入力
int N, K;
cin >> N >> K;
vector<ll> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
// A,Bを全探索
ll total_value;
ll minus_total;
ll max_value = 0;
vector<ll> V_minus(0);
for (int A = 0; A <= K; A++) {
for (int B = 0; B <= K; B++) {
if (A + B > N) { //宝石が空なのに拾ってもしゃーない
break;
}
//拾う
total_value = 0;
V_minus.clear();
for (int i = 0; i < A; i++) {
total_value += V[i];
if (V[i] < 0) { //負なら負の価値の宝石の配列にadd
V_minus.push_back(V[i]);
}
}
for (int i = 0; i < B; i++) {
total_value += V[N - 1 - i];
if (V[N - 1 - i] < 0) { //負なら負の価値の宝石の配列にadd
V_minus.push_back(V[N - 1 - i]);
}
}
//負の宝石を昇順ソート
sort(V_minus.begin(), V_minus.end());
// K-(A+B)だけ捨てる。それ以下なら全部捨てることになるね。
minus_total = 0;
for (int i = 0; i < K - (A + B); i++) {
if (i == V_minus.size()) {
break;
} //負の宝石を使い切ったらbreak
minus_total += V_minus[i];
}
//負の宝石を捨てる（＝その分足す）
if (max_value < total_value - minus_total) {
max_value = total_value - minus_total;
}
}
}
cout << max_value;
return 0;
} | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
//入力
int N, K;
cin >> N >> K;
vector<ll> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
// A,Bを全探索
ll total_value;
ll minus_total;
ll max_value = 0;
vector<ll> V_minus(0);
for (int A = 0; A <= K; A++) {
for (int B = 0; B <= K; B++) {
if (A + B > N || A + B > K) { //宝石が空なのに拾ってもしゃーない
break;
}
//拾う
total_value = 0;
V_minus.clear();
for (int i = 0; i < A; i++) {
total_value += V[i];
if (V[i] < 0) { //負なら負の価値の宝石の配列にadd
V_minus.push_back(V[i]);
}
}
for (int i = 0; i < B; i++) {
total_value += V[N - 1 - i];
if (V[N - 1 - i] < 0) { //負なら負の価値の宝石の配列にadd
V_minus.push_back(V[N - 1 - i]);
}
}
//負の宝石を昇順ソート
sort(V_minus.begin(), V_minus.end());
// K-(A+B)だけ捨てる。それ以下なら全部捨てることになるね。
minus_total = 0;
for (int i = 0; i < K - (A + B); i++) {
if (i == V_minus.size()) {
break;
} //負の宝石を使い切ったらbreak
minus_total += V_minus[i];
}
//負の宝石を捨てる（＝その分足す）
if (max_value < total_value - minus_total) {
max_value = total_value - minus_total;
}
}
}
cout << max_value;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,138 | 844,139 | u730476362 | cpp |
p03032 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
//入力
int N, K;
cin >> N >> K;
vector<ll> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
// A,Bを全探索
ll total_value;
ll minus_total;
ll max_value = 0;
vector<ll> V_minus(0);
for (int A = 0; A <= K; A++) {
for (int B = 0; B <= K; B++) {
if (A + B > N) { //宝石が空なのに拾ってもしゃーない
break;
}
//拾う
total_value = 0;
V_minus.clear();
for (int i = 0; i < A; i++) {
total_value += V[i];
if (V[i] < 0) { //負なら負の価値の宝石の配列にadd
V_minus.push_back(V[i]);
}
}
for (int i = 0; i < B; i++) {
total_value += V[N - 1 - i];
if (V[N - 1 - i] < 0) { //負なら負の価値の宝石の配列にadd
V_minus.push_back(V[N - 1 - i]);
}
}
//負の宝石を昇順ソート
sort(V_minus.begin(), V_minus.end());
// K-(A+B)だけ捨てる。それ以下なら全部捨てることになるね。
minus_total = 0;
for (int i = 0; i < K - (A + B); i++) {
if (i == V_minus.size()) {
break;
} //負の宝石を使い切ったらbreak
minus_total += V_minus[i];
}
//負の宝石を捨てる（＝その分足す）
if (max_value < total_value - minus_total) {
max_value = total_value - minus_total;
}
}
}
cout << max_value;
return 0;
} | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
//入力
int N, K;
cin >> N >> K;
vector<ll> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
// A,Bを全探索
ll total_value;
ll minus_total;
ll max_value = 0;
vector<ll> V_minus(0);
for (int A = 0; A <= K; A++) {
for (int B = 0; A + B <= K; B++) {
if (A + B > N) { //宝石が空なのに拾ってもしゃーない
break;
}
//拾う
total_value = 0;
V_minus.clear();
for (int i = 0; i < A; i++) {
total_value += V[i];
if (V[i] < 0) { //負なら負の価値の宝石の配列にadd
V_minus.push_back(V[i]);
}
}
for (int i = 0; i < B; i++) {
total_value += V[N - 1 - i];
if (V[N - 1 - i] < 0) { //負なら負の価値の宝石の配列にadd
V_minus.push_back(V[N - 1 - i]);
}
}
//負の宝石を昇順ソート
sort(V_minus.begin(), V_minus.end());
// K-(A+B)だけ捨てる。それ以下なら全部捨てることになるね。
minus_total = 0;
for (int i = 0; i < K - (A + B); i++) {
if (i == V_minus.size()) {
break;
} //負の宝石を使い切ったらbreak
minus_total += V_minus[i];
}
//負の宝石を捨てる（＝その分足す）
if (max_value < total_value - minus_total) {
max_value = total_value - minus_total;
}
}
}
cout << max_value;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 844,138 | 844,140 | u730476362 | cpp |
p03032 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
ll ans = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int l = 0; l < min(n, k); l++) {
for (int r = 0; r < min(n - l, k - l); r++) {
ll tmp = 0;
vector<ll> sub;
for (int i = 0; i < l; i++) {
tmp += v[i];
if (v[i] < 0)
sub.push_back(v[i]);
}
for (int i = 0; i < r; i++) {
tmp += v[n - i - 1];
if (v[n - i - 1] < 0)
sub.push_back(v[n - i - 1]);
}
sort(sub.begin(), sub.end());
int m = max(0, min((int)sub.size(), k - l - r));
for (int i = 0; i < m; i++)
tmp -= sub[i];
ans = max(ans, tmp);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
ll ans = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int l = 0; l <= min(n, k); l++) {
for (int r = 0; r <= min(n - l, k - l); r++) {
ll tmp = 0;
vector<ll> sub;
for (int i = 0; i < l; i++) {
tmp += v[i];
if (v[i] < 0)
sub.push_back(v[i]);
}
for (int i = 0; i < r; i++) {
tmp += v[n - i - 1];
if (v[n - i - 1] < 0)
sub.push_back(v[n - i - 1]);
}
sort(sub.begin(), sub.end());
int m = max(0, min((int)sub.size(), k - l - r));
for (int i = 0; i < m; i++)
tmp -= sub[i];
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"
] | 844,157 | 844,158 | u127194462 | cpp |
p03032 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
ll ans = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int l = 0; l < min(n, k); l++) {
for (int r = 0; l + r < min(n, k); r++) {
ll tmp = 0;
vector<ll> sub;
for (int i = 0; i < l; i++) {
tmp += v[i];
sub.push_back(v[i]);
}
for (int i = 0; i < r; i++) {
tmp += v[n - i - 1];
sub.push_back(v[n - i - 1]);
}
sort(sub.begin(), sub.end());
int m = min((int)sub.size(), k - l - r);
for (int i = 0; i < m; i++) {
if (sub[i] < 0)
tmp -= sub[i];
}
ans = max(ans, tmp);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
ll ans = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int l = 0; l <= min(n, k); l++) {
for (int r = 0; l + r <= min(n, k); r++) {
ll tmp = 0;
vector<ll> sub;
for (int i = 0; i < l; i++) {
tmp += v[i];
sub.push_back(v[i]);
}
for (int i = 0; i < r; i++) {
tmp += v[n - i - 1];
sub.push_back(v[n - i - 1]);
}
sort(sub.begin(), sub.end());
int m = min((int)sub.size(), k - l - r);
for (int i = 0; i < m; i++) {
if (sub[i] < 0)
tmp -= sub[i];
}
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"
] | 844,159 | 844,160 | u127194462 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using ll = long long;
int main() {
int N, K;
std::cin >> N >> K;
std::vector<int> a(N);
for (int i = 0; i < N; i++) {
std::cin >> a[i];
}
int ans = 0;
for (int l = 0; l < K; l++) {
for (int r = 0; r < K - l + 1; r++) {
//操作が上限に達した
if (l + r > N)
continue;
//消せる回数
int d = K - l - r;
//今のスコア
int n = 0;
//取り出した数字
std::vector<int> s;
for (int i = 0; i < l; i++) {
n += a[i];
s.emplace_back(a[i]);
}
for (int i = 0; i < r; i++) {
n += a[N - i - 1];
s.emplace_back(a[N - i - 1]);
}
std::sort(s.begin(), s.end());
for (int i = 0; i < d; i++) {
if (i >= s.size())
break;
if (s[i] > 0)
break;
n -= s[i];
}
ans = std::max(n, ans);
}
}
std::cout << ans << std::endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using ll = long long;
int main() {
int N, K;
std::cin >> N >> K;
std::vector<int> a(N);
for (int i = 0; i < N; i++) {
std::cin >> a[i];
}
int ans = 0;
for (int l = 0; l < K + 1; l++) {
for (int r = 0; r < K - l + 1; r++) {
//操作が上限に達した
if (l + r > N)
continue;
//消せる回数
int d = K - l - r;
//今のスコア
int n = 0;
//取り出した数字
std::vector<int> s;
for (int i = 0; i < l; i++) {
n += a[i];
s.emplace_back(a[i]);
}
for (int i = 0; i < r; i++) {
n += a[N - i - 1];
s.emplace_back(a[N - i - 1]);
}
std::sort(s.begin(), s.end());
for (int i = 0; i < d; i++) {
if (i >= s.size())
break;
if (s[i] > 0)
break;
n -= s[i];
}
ans = std::max(n, ans);
}
}
std::cout << ans << std::endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 844,163 | 844,164 | u303039933 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using ll = long long;
int main() {
int N, K;
std::cin >> N >> K;
std::vector<int> a(N);
for (int i = 0; i < N; i++) {
std::cin >> a[i];
}
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 n = 0;
//取り出した数字
std::vector<int> s;
for (int i = 0; i < l; i++) {
n += a[i];
s.emplace_back(a[i]);
}
for (int i = 0; i < r; i++) {
n += a[N - i - 1];
s.emplace_back(a[N - i - 1]);
}
std::sort(s.begin(), s.end());
for (int i = 0; i < d; i++) {
if (i >= s.size())
break;
if (s[i] > 0)
break;
n -= s[i];
}
ans = std::max(n, ans);
}
}
std::cout << ans << std::endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using ll = long long;
int main() {
int N, K;
std::cin >> N >> K;
std::vector<int> a(N);
for (int i = 0; i < N; i++) {
std::cin >> a[i];
}
int ans = 0;
for (int l = 0; l < K + 1; l++) {
for (int r = 0; r < K - l + 1; r++) {
//操作が上限に達した
if (l + r > N)
continue;
//消せる回数
int d = K - l - r;
//今のスコア
int n = 0;
//取り出した数字
std::vector<int> s;
for (int i = 0; i < l; i++) {
n += a[i];
s.emplace_back(a[i]);
}
for (int i = 0; i < r; i++) {
n += a[N - i - 1];
s.emplace_back(a[N - i - 1]);
}
std::sort(s.begin(), s.end());
for (int i = 0; i < d; i++) {
if (i >= s.size())
break;
if (s[i] > 0)
break;
n -= s[i];
}
ans = std::max(n, ans);
}
}
std::cout << ans << std::endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 844,165 | 844,164 | u303039933 | cpp |
p03032 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define debug(x) cout << #x << " = " << (x) << endl;
using namespace std;
typedef long long int LL;
typedef unsigned long long int ULL;
int main() {
int n, k;
cin >> n >> k;
vector<LL> values;
rep(i, n) {
LL value;
cin >> value;
values.push_back(value);
}
LL n_iter = min(n, k);
LL ans = 0;
rep(left, n_iter) {
rep(right, n_iter) {
if (left + right >= n_iter)
continue;
vector<LL> having;
rep(i, left) { having.push_back(values[i]); }
rep(i, right) { having.push_back(values[n - i - 1]); }
sort(having.begin(), having.end());
LL num_waste = k - left - right;
LL res = 0;
rep(i, having.size()) {
if (num_waste > 0 and having[i] < 0) {
num_waste--;
continue;
}
res += having[i];
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define debug(x) cout << #x << " = " << (x) << endl;
using namespace std;
typedef long long int LL;
typedef unsigned long long int ULL;
int main() {
int n, k;
cin >> n >> k;
vector<LL> values;
rep(i, n) {
LL value;
cin >> value;
values.push_back(value);
}
LL n_iter = min(n, k);
LL ans = 0;
rep(left, n_iter + 1) {
rep(right, n_iter + 1) {
if (left + right > n_iter)
continue;
vector<LL> having;
rep(i, left) { having.push_back(values[i]); }
rep(i, right) { having.push_back(values[n - i - 1]); }
sort(having.begin(), having.end());
LL num_waste = k - left - right;
LL res = 0;
rep(i, having.size()) {
if (num_waste > 0 and having[i] < 0) {
num_waste--;
continue;
}
res += having[i];
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,168 | 844,169 | u614063956 | cpp |
p03032 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define debug(x) cout << #x << " = " << (x) << endl;
using namespace std;
typedef long long int LL;
typedef unsigned long long int ULL;
int main() {
int n, k;
cin >> n >> k;
vector<LL> values;
rep(i, n) {
LL value;
cin >> value;
values.push_back(value);
}
LL n_iter = min(n, k);
LL ans = 0;
rep(left, n_iter) {
rep(right, n_iter) {
if (left + right > n_iter)
continue;
vector<LL> having;
rep(i, left) { having.push_back(values[i]); }
rep(i, right) { having.push_back(values[n - i - 1]); }
sort(having.begin(), having.end());
LL num_waste = k - left - right;
LL res = 0;
rep(i, having.size()) {
if (num_waste > 0 and having[i] < 0) {
num_waste--;
continue;
}
res += having[i];
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define debug(x) cout << #x << " = " << (x) << endl;
using namespace std;
typedef long long int LL;
typedef unsigned long long int ULL;
int main() {
int n, k;
cin >> n >> k;
vector<LL> values;
rep(i, n) {
LL value;
cin >> value;
values.push_back(value);
}
LL n_iter = min(n, k);
LL ans = 0;
rep(left, n_iter + 1) {
rep(right, n_iter + 1) {
if (left + right > n_iter)
continue;
vector<LL> having;
rep(i, left) { having.push_back(values[i]); }
rep(i, right) { having.push_back(values[n - i - 1]); }
sort(having.begin(), having.end());
LL num_waste = k - left - right;
LL res = 0;
rep(i, having.size()) {
if (num_waste > 0 and having[i] < 0) {
num_waste--;
continue;
}
res += having[i];
}
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 844,170 | 844,169 | u614063956 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define UNIQUE(v) \
do { \
sort(v.begin(), v.end()); \
v.erase(unique(v.begin(), v.end()), v.end()); \
} while (0)
#define y0 y3487465
#define y1 y8687969
#define m0(x) memset(x, 0, sizeof(x))
#define m1(x) memset(x, 63, sizeof(x))
typedef long long ll;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pi> vpi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
double EPS = 1e-9;
int INFi = 1000000005;
long long INFll = 1000000000000000005ll;
double PI = acos(-1);
int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};
ll MOD = 1000000007;
int N, K;
const int MAX_N = 50;
ll V[MAX_N];
int main() {
cin >> N >> K;
REP(i, N) cin >> V[i];
ll ans = 0;
REP(l, min(N, K)) {
REP(r, min(N, K) - l) {
ll s = 0;
vll tmp;
REP(i, l) {
s += V[i];
tmp.pb(V[i]);
}
REP(j, r) {
s += V[N - 1 - j];
tmp.pb(V[N - 1 - j]);
}
sort(ALL(tmp));
REP(i, min(K - l - r, int(tmp.size()))) {
if (tmp[i] < 0) {
s -= tmp[i];
}
}
ans = max(ans, s);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define UNIQUE(v) \
do { \
sort(v.begin(), v.end()); \
v.erase(unique(v.begin(), v.end()), v.end()); \
} while (0)
#define y0 y3487465
#define y1 y8687969
#define m0(x) memset(x, 0, sizeof(x))
#define m1(x) memset(x, 63, sizeof(x))
typedef long long ll;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pi> vpi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
double EPS = 1e-9;
int INFi = 1000000005;
long long INFll = 1000000000000000005ll;
double PI = acos(-1);
int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};
ll MOD = 1000000007;
int N, K;
const int MAX_N = 50;
ll V[MAX_N];
int main() {
cin >> N >> K;
REP(i, N) cin >> V[i];
ll ans = 0;
REP(l, min(N, K) + 1) {
REP(r, min(N, K) + 1 - l) {
ll s = 0;
vll tmp;
REP(i, l) {
s += V[i];
tmp.pb(V[i]);
}
REP(j, r) {
s += V[N - 1 - j];
tmp.pb(V[N - 1 - j]);
}
sort(ALL(tmp));
REP(i, min(K - l - r, int(tmp.size()))) {
if (tmp[i] < 0) {
s -= tmp[i];
}
}
ans = max(ans, s);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 844,171 | 844,172 | u505831576 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V;
int v;
int ans = 0;
for (int i = 0; i < N; i++) {
cin >> v;
V.push_back(v);
}
int vsize = V.size();
for (int a = 0; a < min(N, K); a++) {
for (int b = 0; b < min(N, K) - a; b++) {
int preans = 0;
vector<int> minus;
for (int i = 0; i < a; i++) {
preans += V[i];
if (V[i] < 0) {
minus.push_back(V[i]);
}
}
for (int i = 0; i < b; i++) {
preans += V[vsize - 1 - i];
if (V[vsize - 1 - i] < 0) {
minus.push_back(V[vsize - 1 - i]);
}
}
sort(minus.begin(), minus.end());
for (int i = 0; i < min(K - a - b, (int)minus.size()); i++) {
preans -= minus[i];
}
ans = max(ans, preans);
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V;
int v;
int ans = 0;
for (int i = 0; i < N; i++) {
cin >> v;
V.push_back(v);
}
int vsize = V.size();
for (int a = 0; a <= min(N, K); a++) {
for (int b = 0; b <= min(N, K) - a; b++) {
int preans = 0;
vector<int> minus;
for (int i = 0; i < a; i++) {
preans += V[i];
if (V[i] < 0) {
minus.push_back(V[i]);
}
}
for (int i = 0; i < b; i++) {
preans += V[vsize - 1 - i];
if (V[vsize - 1 - i] < 0) {
minus.push_back(V[vsize - 1 - i]);
}
}
sort(minus.begin(), minus.end());
for (int i = 0; i < min(K - a - b, (int)minus.size()); i++) {
preans -= minus[i];
}
ans = max(ans, preans);
}
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,200 | 844,201 | u982234424 | cpp |
p03032 | #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, K;
cin >> N >> K;
VI V(N);
REP(i, N) { cin >> V.at(i); }
int ans = 0;
REP(l, K) {
REP(r, K - l) {
if (l + r > N)
break;
int d = K - l - r;
int now = 0; //現在価値
VI S; //拾った宝石
REP(i, l) {
now += V.at(i); //左からl個
S.pb(V.at(i));
}
FOR(i, N - r, N) {
now += V.at(i); //右からr個
S.pb(V.at(i));
}
SORT(S);
REP(i, d) {
if (i >= S.size())
break;
if (S.at(i) > 0)
break;
now -= S.at(i);
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, K;
cin >> N >> K;
VI V(N);
REP(i, N) { cin >> V.at(i); }
int ans = 0;
REP(l, K + 1) {
REP(r, K - l + 1) {
if (l + r > N)
break;
int d = K - l - r;
int now = 0; //現在価値
VI S; //拾った宝石
REP(i, l) {
now += V.at(i); //左からl個
S.pb(V.at(i));
}
FOR(i, N - r, N) {
now += V.at(i); //右からr個
S.pb(V.at(i));
}
SORT(S);
REP(i, d) {
if (i >= S.size())
break;
if (S.at(i) > 0)
break;
now -= S.at(i);
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 844,204 | 844,205 | u055131803 | cpp |
p03032 | #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, K;
cin >> N >> K;
VI V(N);
REP(i, N) { cin >> V.at(i); }
int ans = 0;
REP(l, K) {
REP(r, K - l) {
if (l + r > N)
continue;
int d = K - l - r;
int now = 0; //現在価値
VI S; //拾った宝石
REP(i, l) {
now += V.at(i); //左からl個
S.pb(V.at(i));
}
FOR(i, N - r, N) {
now += V.at(i); //右からr個
S.pb(V.at(i));
}
SORT(S);
REP(i, d) {
if (i >= S.size())
break;
if (S.at(i) > 0)
break;
now -= S.at(i);
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, K;
cin >> N >> K;
VI V(N);
REP(i, N) { cin >> V.at(i); }
int ans = 0;
REP(l, K + 1) {
REP(r, K - l + 1) {
if (l + r > N)
break;
int d = K - l - r;
int now = 0; //現在価値
VI S; //拾った宝石
REP(i, l) {
now += V.at(i); //左からl個
S.pb(V.at(i));
}
FOR(i, N - r, N) {
now += V.at(i); //右からr個
S.pb(V.at(i));
}
SORT(S);
REP(i, d) {
if (i >= S.size())
break;
if (S.at(i) > 0)
break;
now -= S.at(i);
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.continue.remove",
"control_flow.break.add"
] | 844,206 | 844,205 | u055131803 | cpp |
p03032 | #include <algorithm>
#include <climits>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define REPR(i, n) for (int i = n - 1; 0 <= i; i--)
#define FOR(i, s, e) for (int i = s; i <= e; i++)
#define FORR(i, s, e) for (int i = s; e <= i; i--)
#define LLI long long int
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
int N, K;
cin >> N >> K;
vector<int> v(N);
REP(i, N) { cin >> v[i]; }
int ma = 0;
for (int i = 0; i <= K; i++) {
for (int j = 0; j <= K - i; j++) {
vector<int> arr;
int sum = 0;
REP(k, N) {
if (k < i || N - j <= k) {
arr.push_back(v[k]);
sum += v[k];
}
}
SORT(arr);
REP(k, min(K - i - j, i + j)) {
if (v[k] < 0) {
sum -= arr[k];
}
}
chmax(ma, sum);
}
}
cout << ma;
return 0;
} | #include <algorithm>
#include <climits>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define REPR(i, n) for (int i = n - 1; 0 <= i; i--)
#define FOR(i, s, e) for (int i = s; i <= e; i++)
#define FORR(i, s, e) for (int i = s; e <= i; i--)
#define LLI long long int
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
int N, K;
cin >> N >> K;
vector<int> v(N);
REP(i, N) { cin >> v[i]; }
int ma = 0;
for (int i = 0; i <= K; i++) {
for (int j = 0; j <= K - i; j++) {
vector<int> arr;
int sum = 0;
REP(k, N) {
if (k < i || N - j <= k) {
arr.push_back(v[k]);
sum += v[k];
}
}
SORT(arr);
REP(k, min(K - i - j, i + j)) {
if (arr[k] < 0) {
sum -= arr[k];
}
}
chmax(ma, sum);
}
}
cout << ma;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 844,207 | 844,208 | u840105874 | cpp |
p03032 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int n, K;
cin >> n >> K;
ll v[n + 1] = {};
rep(i, n) cin >> v[i + 1];
ll l[n + 1] = {}, r[n + 1] = {};
rep(i, n) { l[i + 1] = l[i] + v[i + 1]; }
rep(i, n) { r[i] = l[n] - l[n - i]; }
ll ans = 0;
for (int i = 0; i <= min(K, n); i++) {
for (int j = 0; j <= i; j++) {
ll sum = 0;
vector<ll> vec;
vec.clear();
if (j > 0) {
for (int k = 1; k <= j; k++)
vec.push_back(v[k]);
}
if (j < i) {
for (int k = n - i + j + 1; k <= n; k++)
vec.push_back(v[k]);
}
sort(vec.begin(), vec.end());
int temp = 0;
while (temp < K - i && temp < vec.size() && vec[temp] < 0) {
sum -= vec[temp];
temp++;
}
ans = max(ans, sum + l[j] + r[i - j]);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int n, K;
cin >> n >> K;
ll v[n + 1] = {};
rep(i, n) cin >> v[i + 1];
ll l[n + 1] = {}, r[n + 1] = {};
rep(i, n) { l[i + 1] = l[i] + v[i + 1]; }
rep(i, n + 1) { r[i] = l[n] - l[n - i]; }
ll ans = 0;
for (int i = 0; i <= min(K, n); i++) {
for (int j = 0; j <= i; j++) {
ll sum = 0;
vector<ll> vec;
vec.clear();
if (j > 0) {
for (int k = 1; k <= j; k++)
vec.push_back(v[k]);
}
if (j < i) {
for (int k = n - i + j + 1; k <= n; k++)
vec.push_back(v[k]);
}
sort(vec.begin(), vec.end());
int temp = 0;
while (temp < K - i && temp < vec.size() && vec[temp] < 0) {
sum -= vec[temp];
temp++;
}
ans = max(ans, sum + l[j] + r[i - j]);
}
}
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 844,227 | 844,228 | u906208439 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
ll n, K, temp, ans;
int v[51];
vector<int> pq_v;
int main() {
cin >> n >> K;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
ans = 0;
for (int i = 1; i <= K; i++) {
for (int j = 0; j <= i; j++) {
priority_queue<int, vector<int>, greater<int>> pq;
for (int k = 0; k < j; k++)
pq.push(v[k]);
for (int k = (i - j); k < n && k > 0; k--)
pq.push(v[n - k]);
for (int k = 0; k < K - i; k++)
if (!pq.empty() && pq.top() < 0)
pq.pop();
temp = 0;
while (pq.size()) {
temp += pq.top();
pq.pop();
}
// cout <<j << " " << i-j << " " << K-i << " " << temp << endl;
ans = max(ans, temp);
}
}
cout << ans << endl;
}
// i個とる
// 左からj個, 右からi-j個とる
// 小さい順に,負ならばK-i個戻す
// 価値が大きければ更新，そうでなければ更新しない
// i=1~Kまでする
// i=-では0 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
ll n, K, temp, ans;
int v[51];
vector<int> pq_v;
int main() {
cin >> n >> K;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
ans = 0;
for (int i = 1; i <= min(n, K); i++) {
for (int j = 0; j <= i; j++) {
priority_queue<int, vector<int>, greater<int>> pq;
for (int k = 0; k < j; k++)
pq.push(v[k]);
for (int k = (i - j); k < n && k > 0; k--)
pq.push(v[n - k]);
for (int k = 0; k < K - i; k++)
if (!pq.empty() && pq.top() < 0)
pq.pop();
temp = 0;
while (pq.size()) {
temp += pq.top();
pq.pop();
}
// cout <<j << " " << i-j << " " << K-i << " " << temp << endl;
ans = max(ans, temp);
}
}
cout << ans << endl;
}
// i個とる
// 左からj個, 右からi-j個とる
// 小さい順に,負ならばK-i個戻す
// 価値が大きければ更新，そうでなければ更新しない
// i=1~Kまでする
// i=0では0 | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 844,229 | 844,230 | u263858205 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int mod = 1e9;
const int maxn = 55;
int a[maxn], n, k;
int g(int l, int r) {
if (l + r > k || l + r == 0)
return -mod;
vi v;
for (int i = 0; i < l; i++)
v.push_back(a[i]);
for (int i = 0; i < r; i++)
v.push_back(a[n - i - 1]);
int sum = accumulate(v.begin(), v.end(), 0);
sort(v.begin(), v.end());
for (int i = 0; i < k - l - r && i < v.size(); i++) {
if (v[i] >= 0)
break;
sum -= v[i];
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
int res = 0;
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < n + 1; j++)
res = max(res, g(i, j));
cout << res;
}
| #include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int mod = 1e9;
const int maxn = 55;
int a[maxn], n, k;
int g(int l, int r) {
if (l + r > k || l + r > n || l + r == 0)
return -mod;
vi v;
for (int i = 0; i < l; i++)
v.push_back(a[i]);
for (int i = 0; i < r; i++)
v.push_back(a[n - i - 1]);
int sum = accumulate(v.begin(), v.end(), 0);
sort(v.begin(), v.end());
for (int i = 0; i < k - l - r && i < v.size(); i++) {
if (v[i] >= 0)
break;
sum -= v[i];
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
int res = 0;
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < n + 1; j++)
res = max(res, g(i, j));
cout << res;
}
| [
"control_flow.branch.if.condition.change"
] | 844,236 | 844,237 | u348155686 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
std::vector<int> V;
int main() {
////////////input//////////////////
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
V.push_back(a);
}
////////////compute////////////////
int ans = 0;
////////////操作Aと操作Bのすべての組み合わせを試す//////////////
for (int i = 0; i <= min(k, n); i++) {
for (int j = 0; i + j <= min(k, n); j++) {
//////////////////////////////////////////////////////////
vector<int> v; ///////ansを計算するための配列////////
for (int x = 1; x <= i; x++)
v.push_back(V[x]);
for (int x = 0; x < j; x++)
v.push_back(V[n - x]);
sort(v.rbegin(), v.rend());
int k2 = k - i - j;
while (k2 > 0 && !v.empty() && v.back() < 0) {
v.pop_back();
k2--;
}
int sum = 0;
for (int x : v)
sum += x;
ans = max(ans, sum);
}
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
std::vector<int> V;
int main() {
////////////input//////////////////
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
V.push_back(a);
}
////////////compute////////////////
int ans = 0;
////////////操作Aと操作Bのすべての組み合わせを試す//////////////
for (int i = 0; i <= min(k, n); i++) {
for (int j = 0; i + j <= min(k, n); j++) {
//////////////////////////////////////////////////////////
vector<int> v; ///////ansを計算するための配列////////
for (int x = 0; x < i; x++)
v.push_back(V[x]);
for (int x = 1; x <= j; x++)
v.push_back(V[n - x]);
sort(v.rbegin(), v.rend());
int k2 = k - i - j;
while (k2 > 0 && !v.empty() && v.back() < 0) {
v.pop_back();
k2--;
}
int sum = 0;
for (int x : v)
sum += x;
ans = max(ans, sum);
}
}
cout << ans;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 844,242 | 844,243 | u430974466 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
std::vector<int> V;
int main() {
////////////input//////////////////
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
V.push_back(a);
}
////////////compute////////////////
int ans = 0;
////////////操作Aと操作Bのすべての組み合わせを試す//////////////
for (int i = 0; i <= min(k, n); i++) {
for (int j = 0; i + j <= min(k, n); j++) {
//////////////////////////////////////////////////////////
vector<int> v; ///////ansを計算するための配列////////
for (int x = 0; x < i; x++)
v.push_back(V[x]);
for (int x = 0; x < j; x++)
v.push_back(V[n - x]);
sort(v.rbegin(), v.rend());
int k2 = k - i - j;
while (k2 > 0 && !v.empty() && v.back() < 0) {
v.pop_back();
k2--;
}
int sum = 0;
for (int x : v)
sum += x;
ans = max(ans, sum);
}
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
std::vector<int> V;
int main() {
////////////input//////////////////
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
V.push_back(a);
}
////////////compute////////////////
int ans = 0;
////////////操作Aと操作Bのすべての組み合わせを試す//////////////
for (int i = 0; i <= min(k, n); i++) {
for (int j = 0; i + j <= min(k, n); j++) {
//////////////////////////////////////////////////////////
vector<int> v; ///////ansを計算するための配列////////
for (int x = 0; x < i; x++)
v.push_back(V[x]);
for (int x = 1; x <= j; x++)
v.push_back(V[n - x]);
sort(v.rbegin(), v.rend());
int k2 = k - i - j;
while (k2 > 0 && !v.empty() && v.back() < 0) {
v.pop_back();
k2--;
}
int sum = 0;
for (int x : v)
sum += x;
ans = max(ans, sum);
}
}
cout << ans;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 844,244 | 844,243 | u430974466 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
using VI = vector<LL>;
using VVI = vector<VI>;
using VB = vector<bool>;
using VS = vector<string>;
using PII = pair<LL, LL>;
using VP = vector<PII>;
#define PB push_back
#define MP make_pair
#define SZ(a) LL((a).size())
#define EACH(x, c) for (auto x : (c))
#define ALL(c) (c).begin(), (c).end()
#define REVERSE(c) reverse(ALL(c))
#define SORT(c) stable_sort(ALL(c))
#define RSORT(c) stable_sort((c).rbegin(), (c).rend())
#define FOR(i, a, b) for (LL i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define dump(x) cerr << #x << " = " << (x) << endl;
int main() {
LL N, K;
cin >> N >> K;
VI V(N);
REP(i, N) { cin >> V[i]; }
LL ans = 0;
REP(nl, min(N, K)) {
REP(nr, min(N, K) - nl) {
VI tmp(nl + nr);
REP(i, nl) { tmp[i] = V[i]; }
REP(i, nr) { tmp[SZ(tmp) - 1 - i] = V[SZ(V) - 1 - i]; }
SORT(tmp);
LL i;
for (i = 0; i < min(K - (nl + nr), nl + nr); ++i) {
if (tmp[i] >= 0)
break;
}
LL ans_ = 0;
FOR(j, i, SZ(tmp)) { ans_ += tmp[j]; }
if (ans_ > ans)
ans = ans_;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using LL = long long;
using VI = vector<LL>;
using VVI = vector<VI>;
using VB = vector<bool>;
using VS = vector<string>;
using PII = pair<LL, LL>;
using VP = vector<PII>;
#define PB push_back
#define MP make_pair
#define SZ(a) LL((a).size())
#define EACH(x, c) for (auto x : (c))
#define ALL(c) (c).begin(), (c).end()
#define REVERSE(c) reverse(ALL(c))
#define SORT(c) stable_sort(ALL(c))
#define RSORT(c) stable_sort((c).rbegin(), (c).rend())
#define FOR(i, a, b) for (LL i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define dump(x) cerr << #x << " = " << (x) << endl;
int main() {
LL N, K;
cin >> N >> K;
VI V(N);
REP(i, N) { cin >> V[i]; }
LL ans = 0;
REP(nl, min(N, K) + 1) {
REP(nr, min(N, K) + 1 - nl) {
VI tmp(nl + nr);
REP(i, nl) { tmp[i] = V[i]; }
REP(i, nr) { tmp[SZ(tmp) - 1 - i] = V[SZ(V) - 1 - i]; }
SORT(tmp);
LL i;
for (i = 0; i < min(K - (nl + nr), nl + nr); ++i) {
if (tmp[i] >= 0)
break;
}
LL ans_ = 0;
FOR(j, i, SZ(tmp)) { ans_ += tmp[j]; }
if (ans_ > ans)
ans = ans_;
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 844,250 | 844,251 | u816800341 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int val = 0;
vector<int> V;
for (int i = 0; i < N; i++) {
int v;
cin >> v;
V.emplace_back(v);
}
int maxval = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; i + j < min(N, K); j++) {
int val = 0;
vector<int> neg;
for (int k = 0; k < i; k++) {
val += V[k];
if (V[k] < 0) {
neg.emplace_back(V[k]);
}
}
for (int k = 1; k <= j; k++) {
val += V[N - k];
if (V[N - k] < 0) {
neg.emplace_back(V[N - k]);
}
}
sort(neg.rbegin(), neg.rend());
int r = K - i - j;
while (!neg.empty() && r != 0) {
val -= neg.back();
neg.pop_back();
r--;
}
maxval = max(val, maxval);
}
}
cout << maxval << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int val = 0;
vector<int> V;
for (int i = 0; i < N; i++) {
int v;
cin >> v;
V.emplace_back(v);
}
int maxval = 0;
for (int i = 0; i <= N; i++) {
for (int j = 0; i + j <= min(N, K); j++) {
int val = 0;
vector<int> neg;
for (int k = 0; k < i; k++) {
val += V[k];
if (V[k] < 0) {
neg.emplace_back(V[k]);
}
}
for (int k = 1; k <= j; k++) {
val += V[N - k];
if (V[N - k] < 0) {
neg.emplace_back(V[N - k]);
}
}
sort(neg.rbegin(), neg.rend());
int r = K - i - j;
while (!neg.empty() && r != 0) {
val -= neg.back();
neg.pop_back();
r--;
}
maxval = max(val, maxval);
}
}
cout << maxval << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,252 | 844,253 | u213451288 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
#define pb push_back
#define all(v) (v).begin(), (v).end()
ll mod = 1000000007;
ll INF = 1000000099;
signed main() {
ll n, k, ans = 0;
cin >> n >> k;
vector<ll> v(n);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
for (int i = 0; i <= min(n, k); i++) {
for (int j = 0; j + i <= min(n, k); j++) {
priority_queue<ll> q;
ll sub = 0;
for (int a = 0; a < i; a++) {
q.push(-v.at(a));
sub += v.at(a);
}
for (int b = 0; b < j; b++) {
q.push(-v.at(n - 1 - b));
sub += v.at(n - 1 - b);
}
ans = max(ans, sub);
for (int c = 0; c < k - i - j && !q.empty(); c++) {
sub -= q.top();
q.pop();
ans = max(ans, sub);
}
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
#define pb push_back
#define all(v) (v).begin(), (v).end()
ll mod = 1000000007;
ll INF = 1000000099;
signed main() {
ll n, k, ans = 0;
cin >> n >> k;
vector<ll> v(n);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
for (int i = 0; i <= min(n, k); i++) {
for (int j = 0; j + i <= min(n, k); j++) {
priority_queue<ll> q;
ll sub = 0;
for (int a = 0; a < i; a++) {
q.push(-v.at(a));
sub += v.at(a);
}
for (int b = 0; b < j; b++) {
q.push(-v.at(n - 1 - b));
sub += v.at(n - 1 - b);
}
ans = max(ans, sub);
for (int c = 0; c < k - i - j && !q.empty(); c++) {
sub += q.top();
q.pop();
ans = max(ans, sub);
}
}
}
cout << ans << endl;
}
| [
"expression.operator.change"
] | 844,256 | 844,257 | u317711717 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
int main() {
ll n, k;
cin >> n >> k;
vector<ll> v(n);
rep(i, n) cin >> v[i];
ll sum = 0;
rep(i, k) {
if (i <= n) {
// cout << "i=" << i << endl;
rep(j, i + 1) {
vector<ll> vv;
ll tmp = 0;
rep(h, j) {
vv.push_back(v[h]);
tmp += v[h];
}
rep(h, i - j) {
vv.push_back(v[n - h - 1]);
tmp += v[n - h - 1];
}
sort(vv.begin(), vv.end());
ll vvsize = vv.size();
ll mn = min(k - i + 1, vvsize);
rep(g, mn) {
if (vv[g] < 0)
tmp -= vv[g];
}
// cout << "tmp" << tmp << endl;
sum = max(sum, tmp);
}
} else {
break;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
int main() {
ll n, k;
cin >> n >> k;
vector<ll> v(n);
rep(i, n) cin >> v[i];
ll sum = 0;
rep(i, k + 1) {
if (i <= n) {
// cout << "i=" << i << endl;
rep(j, i + 1) {
vector<ll> vv;
ll tmp = 0;
// cout << "i,j" << i << "," << j << endl;
rep(h, j) {
vv.push_back(v[h]);
tmp += v[h];
}
rep(h, i - j) {
vv.push_back(v[n - h - 1]);
tmp += v[n - h - 1];
}
sort(vv.begin(), vv.end());
// cout << "vv" << vv << endl;
ll vvsize = vv.size();
ll mn = min(k - i, vvsize);
rep(g, mn) {
if (vv[g] < 0)
tmp -= vv[g];
}
// cout << "tmp" << tmp << endl;
sum = max(sum, tmp);
}
} else {
break;
}
}
cout << sum << endl;
}
| [
"expression.operation.binary.remove"
] | 844,258 | 844,259 | u475675023 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
int main() {
ll n, k;
cin >> n >> k;
vector<ll> v(n);
rep(i, n) cin >> v[i];
ll sum = 0;
rep(i, k) {
if (i <= n) {
// cout << "i=" << i << endl;
rep(j, i + 1) {
vector<ll> vv;
ll tmp = 0;
rep(h, j) {
vv.push_back(v[h]);
tmp += v[h];
}
rep(h, i - j) {
vv.push_back(v[n - h - 1]);
tmp += v[n - h - 1];
}
sort(vv.begin(), vv.end());
ll vvsize = vv.size();
ll mn = min(k - i, vvsize);
rep(g, mn) {
if (vv[g] < 0)
tmp -= vv[g];
}
// cout << "tmp" << tmp << endl;
sum = max(sum, tmp);
}
} else {
break;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
int main() {
ll n, k;
cin >> n >> k;
vector<ll> v(n);
rep(i, n) cin >> v[i];
ll sum = 0;
rep(i, k + 1) {
if (i <= n) {
// cout << "i=" << i << endl;
rep(j, i + 1) {
vector<ll> vv;
ll tmp = 0;
// cout << "i,j" << i << "," << j << endl;
rep(h, j) {
vv.push_back(v[h]);
tmp += v[h];
}
rep(h, i - j) {
vv.push_back(v[n - h - 1]);
tmp += v[n - h - 1];
}
sort(vv.begin(), vv.end());
// cout << "vv" << vv << endl;
ll vvsize = vv.size();
ll mn = min(k - i, vvsize);
rep(g, mn) {
if (vv[g] < 0)
tmp -= vv[g];
}
// cout << "tmp" << tmp << endl;
sum = max(sum, tmp);
}
} else {
break;
}
}
cout << sum << endl;
}
| [
"expression.operation.binary.add"
] | 844,260 | 844,259 | u475675023 | cpp |
p03032 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll;
using namespace std;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
static const int MAX = 100;
static const int INF = (1 << 23);
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
// ll sum=0;
rep(i, n) {
cin >> v[i];
// sum+=v[i];
}
int ans = 0;
int lim = min(n, k);
for (int l = 0; l <= lim; l++) {
for (int r = 0; r <= lim - l; r++) {
vector<int> te;
int sum = 0;
for (int i = 0; i < l; i++) {
sum += v[i];
if (v[i] < 0) {
te.push_back(v[i]);
}
}
for (int i = 0; i < r; i++) {
sum += v[n - i - 1];
if (v[n - i - 1] < 0) {
te.push_back(v[n - i - 1]);
}
}
int a = k - (l + r);
int b = te.size();
sort(te.begin(), te.end());
for (int tt = 0; tt < min(a, b); tt++) {
// if(tt!=0){
sum -= te[tt];
//}
// cout<<l<<" "<<r<<" "<<sum<<endl;
if (ans < sum) {
ans = sum;
}
}
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll;
using namespace std;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
static const int MAX = 100;
static const int INF = (1 << 23);
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
// ll sum=0;
rep(i, n) {
cin >> v[i];
// sum+=v[i];
}
int ans = 0;
int lim = min(n, k);
for (int l = 0; l <= lim; l++) {
for (int r = 0; r <= lim - l; r++) {
vector<int> te;
int sum = 0;
for (int i = 0; i < l; i++) {
sum += v[i];
if (v[i] < 0) {
te.push_back(v[i]);
}
}
for (int i = 0; i < r; i++) {
sum += v[n - i - 1];
if (v[n - i - 1] < 0) {
te.push_back(v[n - i - 1]);
}
}
int a = k - (l + r);
int b = te.size();
sort(te.begin(), te.end());
for (int tt = 0; tt < min(a, b); tt++) {
// if(tt!=0){
sum -= te[tt];
//}
// cout<<l<<" "<<r<<" "<<sum<<endl;
}
if (ans < sum) {
ans = sum;
}
}
}
cout << ans << endl;
return 0;
}
| [] | 844,261 | 844,262 | u031448582 | cpp |
p03032 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll;
using namespace std;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
static const int MAX = 100;
static const int INF = (1 << 23);
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
// ll sum=0;
rep(i, n) {
cin >> v[i];
// sum+=v[i];
}
int ans = 0;
int lim = min(n, k);
for (int l = 0; l <= lim; l++) {
for (int r = 0; r <= lim - l; r++) {
vector<int> te;
int sum = 0;
for (int i = 0; i < l; i++) {
sum += v[i];
if (v[i] < 0) {
te.push_back(v[i]);
}
}
for (int i = 0; i < r; i++) {
sum += v[n - i - 1];
if (v[n - i - 1] < 0) {
te.push_back(v[n - i - 1]);
}
}
int a = k - (l + r);
int b = te.size();
sort(te.begin(), te.end());
for (int tt = 0; tt < min(a, b); tt++) {
// if(tt!=0){
sum -= te[tt];
//}
// cout<<l<<" "<<r<<" "<<sum<<endl;
ans = max(sum, ans);
}
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll;
using namespace std;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
static const int MAX = 100;
static const int INF = (1 << 23);
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
// ll sum=0;
rep(i, n) {
cin >> v[i];
// sum+=v[i];
}
int ans = 0;
int lim = min(n, k);
for (int l = 0; l <= lim; l++) {
for (int r = 0; r <= lim - l; r++) {
vector<int> te;
int sum = 0;
for (int i = 0; i < l; i++) {
sum += v[i];
if (v[i] < 0) {
te.push_back(v[i]);
}
}
for (int i = 0; i < r; i++) {
sum += v[n - i - 1];
if (v[n - i - 1] < 0) {
te.push_back(v[n - i - 1]);
}
}
int a = k - (l + r);
int b = te.size();
sort(te.begin(), te.end());
for (int tt = 0; tt < min(a, b); tt++) {
// if(tt!=0){
sum -= te[tt];
//}
// cout<<l<<" "<<r<<" "<<sum<<endl;
}
ans = max(sum, ans);
}
}
cout << ans << endl;
return 0;
}
| [] | 844,263 | 844,264 | u031448582 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repb(i, n) for (int i = (n - 1); i >= 0; i--)
#define rea(i, a, b) for (int i = (a); i < (b); i++)
#define reab(i, a, b) for (int i = (a)-1; i >= (b); i--)
#define ALL(a) (a).begin(), (a).end()
#define SZ(x) ((int)(x).size())
#define PRINT(V) \
for (auto v : (V)) { \
cerr << v << " "; \
} \
cerr << endl
#define dump(x) cerr << #x << " : " << (x) << endl
#define dump2(x, y) \
cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")" << endl
inline ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
const int MOD = 1000000007;
/* END OF TEMPLATE */
// < val の要素数
ll CountLower(const vll &vec, ll val) {
return distance(vec.begin(), lower_bound(ALL(vec), val));
}
int main() {
ll n, k;
cin >> n >> k;
vll v(n);
rep(i, n) { cin >> v[i]; }
vll lsum(n + 1), rsum(n + 1);
lsum[0] = rsum[0] = 0;
rep(i, n) {
lsum[i + 1] = lsum[i] + v[i];
rsum[i + 1] = rsum[i] + v[n - 1 - i];
}
// 解説
ll m = min(n, k);
ll ansmax = -1LL << 50;
rep(a, m) {
rep(b, m - a + 1) {
ll ans = lsum[a] + rsum[b];
vll have;
copy(v.begin(), v.begin() + a, back_inserter(have));
copy(v.end() - b, v.end(), back_inserter(have));
sort(ALL(have));
ll z = min(CountLower(have, 0), k - a - b);
rep(i, z) { ans -= have[i]; }
ansmax = max(ansmax, ans);
}
}
cout << ansmax << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repb(i, n) for (int i = (n - 1); i >= 0; i--)
#define rea(i, a, b) for (int i = (a); i < (b); i++)
#define reab(i, a, b) for (int i = (a)-1; i >= (b); i--)
#define ALL(a) (a).begin(), (a).end()
#define SZ(x) ((int)(x).size())
#define PRINT(V) \
for (auto v : (V)) { \
cerr << v << " "; \
} \
cerr << endl
#define dump(x) cerr << #x << " : " << (x) << endl
#define dump2(x, y) \
cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")" << endl
inline ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
const int MOD = 1000000007;
/* END OF TEMPLATE */
// < val の要素数
ll CountLower(const vll &vec, ll val) {
return distance(vec.begin(), lower_bound(ALL(vec), val));
}
int main() {
ll n, k;
cin >> n >> k;
vll v(n);
rep(i, n) { cin >> v[i]; }
vll lsum(n + 1), rsum(n + 1);
lsum[0] = rsum[0] = 0;
rep(i, n) {
lsum[i + 1] = lsum[i] + v[i];
rsum[i + 1] = rsum[i] + v[n - 1 - i];
}
// 解説
ll m = min(n, k);
ll ansmax = -1LL << 50;
rep(a, m + 1) {
rep(b, m - a + 1) {
ll ans = lsum[a] + rsum[b];
vll have;
copy(v.begin(), v.begin() + a, back_inserter(have));
copy(v.end() - b, v.end(), back_inserter(have));
sort(ALL(have));
ll z = min(CountLower(have, 0), k - a - b);
rep(i, z) { ans -= have[i]; }
ansmax = max(ansmax, ans);
}
}
cout << ansmax << endl;
} | [
"expression.operation.binary.add"
] | 844,265 | 844,266 | u116670634 | cpp |
p03032 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int maxn = 52;
const int maxk = 102;
int v[maxn], f[maxn][maxk], g[maxn][maxk];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> v[i];
int lim = min(n, k);
for (int i = 0; i <= lim; ++i)
for (int j = 0; j <= k; ++j)
f[i][j] = g[i][j] = INT_MIN;
f[0][0] = g[0][0] = 0;
for (int i = 1; i <= lim; ++i) {
for (int j = i; j <= min(k, 2 * i); ++j) {
if (f[i - 1][j - 1] != INT_MIN)
f[i][j] = max(f[i][j], f[i - 1][j - 1] + v[i - 1]);
if (j > 1)
f[i][j] = max(f[i][j], f[i - 1][j - 2]);
if (g[i - 1][j - 1] != INT_MIN)
g[i][j] = max(g[i][j], g[i - 1][j - 1] + v[n - i]);
if (j > 1)
g[i][j] = max(g[i][j], g[i - 1][j - 2]);
// printf("%d %d:%d %d\n", i, j, f[i][j], g[i][j]);
}
}
for (int i = 1; i <= lim; ++i)
f[i][0] = g[i][0] = 0;
for (int i = 1; i <= k; ++i)
f[0][i] = g[0][i] = 0;
for (int i = 1; i <= lim; ++i)
for (int j = 1; j <= k; ++j) {
f[i][j] = max(f[i][j], f[i - 1][j]);
g[i][j] = max(g[i][j], g[i - 1][j]);
}
for (int i = 1; i <= lim; ++i)
for (int j = 1; j <= k; ++j) {
f[i][j] = max(f[i][j], f[i][j - 1]);
g[i][j] = max(g[i][j], g[i][j - 1]);
}
long long ans = 0;
for (int i = 0; i <= lim; ++i)
for (int j = 0; j <= k; ++j)
ans = max(ans, (long long)f[i][j] + g[n - i][k - j]);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int maxn = 52;
const int maxk = 102;
int v[maxn], f[maxn][maxk], g[maxn][maxk];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> v[i];
int lim = n;
for (int i = 0; i <= lim; ++i)
for (int j = 0; j <= k; ++j)
f[i][j] = g[i][j] = INT_MIN;
f[0][0] = g[0][0] = 0;
for (int i = 1; i <= lim; ++i) {
for (int j = i; j <= min(k, 2 * i); ++j) {
if (f[i - 1][j - 1] != INT_MIN)
f[i][j] = max(f[i][j], f[i - 1][j - 1] + v[i - 1]);
if (j > 1)
f[i][j] = max(f[i][j], f[i - 1][j - 2]);
if (g[i - 1][j - 1] != INT_MIN)
g[i][j] = max(g[i][j], g[i - 1][j - 1] + v[n - i]);
if (j > 1)
g[i][j] = max(g[i][j], g[i - 1][j - 2]);
// printf("%d %d:%d %d\n", i, j, f[i][j], g[i][j]);
}
}
for (int i = 1; i <= lim; ++i)
f[i][0] = g[i][0] = 0;
for (int i = 1; i <= k; ++i)
f[0][i] = g[0][i] = 0;
for (int i = 1; i <= lim; ++i)
for (int j = 1; j <= k; ++j) {
f[i][j] = max(f[i][j], f[i - 1][j]);
g[i][j] = max(g[i][j], g[i - 1][j]);
}
for (int i = 1; i <= lim; ++i)
for (int j = 1; j <= k; ++j) {
f[i][j] = max(f[i][j], f[i][j - 1]);
g[i][j] = max(g[i][j], g[i][j - 1]);
}
long long ans = 0;
for (int i = 0; i <= lim; ++i)
for (int j = 0; j <= k; ++j)
ans = max(ans, (long long)f[i][j] + g[n - i][k - j]);
cout << ans << endl;
return 0;
} | [
"call.remove",
"call.arguments.change"
] | 844,273 | 844,274 | u499373855 | cpp |
p03032 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = (n)-1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<par<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
#define SORT(v) sort(all(v))
#define RSORT(v) sort(all(v), greater<int>())
using namespace std;
const int mod = 1e9 + 7;
const string sp = " ";
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
void run() {
int n, k;
cin >> n >> k;
vi v(n);
rep(i, n) cin >> v[i];
int c = min(n, k);
int ans = 0;
rep(i, c) {
rep(j, c) {
if (i + j > c)
continue;
int r = k - i - j;
int t = 0;
vi a;
rep(l, i) {
t += v[l];
if (v[l] < 0)
a.pb(v[l]);
}
rep(l, j) {
t += v[n - l - 1];
if (v[n - k - 1] < 0)
a.pb(v[n - l - 1]);
}
SORT(a);
rep(l, min((int)a.size(), r)) t -= a[l];
ans = max(ans, t);
}
}
cout << ans << endl;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = (n)-1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<par<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
#define SORT(v) sort(all(v))
#define RSORT(v) sort(all(v), greater<int>())
using namespace std;
const int mod = 1e9 + 7;
const string sp = " ";
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
void run() {
int n, k;
cin >> n >> k;
vi v(n);
rep(i, n) cin >> v[i];
int c = min(n, k);
int ans = 0;
rep(i, c + 1) {
rep(j, c + 1) {
if (i + j > c)
continue;
int r = k - i - j;
int t = 0;
vi a;
rep(l, i) {
t += v[l];
if (v[l] < 0)
a.pb(v[l]);
}
rep(l, j) {
t += v[n - l - 1];
if (v[n - k - 1] < 0)
a.pb(v[n - l - 1]);
}
SORT(a);
rep(l, min((int)a.size(), r)) t -= a[l];
ans = max(ans, t);
}
}
cout << ans << endl;
} | [
"expression.operation.binary.add"
] | 844,281 | 844,282 | u128527648 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int n, k, ans = 0;
deque<int> d;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
d.push_back(x);
}
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++) {
if (i + j > k)
continue;
int u = k - i - j;
vector<int> hand;
deque<int> tmp = d;
for (int l = 0; l < i && d.size(); l++) {
hand.push_back(tmp[0]);
tmp.pop_front();
}
for (int l = 0; l < j && d.size(); l++) {
hand.push_back(tmp[tmp.size() - 1]);
tmp.pop_back();
}
int sum = 0;
for (int l = 0; l < hand.size(); l++)
sum += hand[l];
sort(hand.begin(), hand.end());
for (int l = 0; l < u; l++) {
if (l >= hand.size())
break;
if (hand[l] >= 0)
break;
sum -= hand[l];
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, k, ans = 0;
deque<int> d;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
d.push_back(x);
}
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++) {
if (i + j > k)
continue;
int u = k - i - j;
vector<int> hand;
deque<int> tmp = d;
for (int l = 0; l < i && tmp.size(); l++) {
hand.push_back(tmp[0]);
tmp.pop_front();
}
for (int l = 0; l < j && tmp.size(); l++) {
hand.push_back(tmp[tmp.size() - 1]);
tmp.pop_back();
}
int sum = 0;
for (int l = 0; l < hand.size(); l++)
sum += hand[l];
sort(hand.begin(), hand.end());
for (int l = 0; l < u; l++) {
if (l >= hand.size())
break;
if (hand[l] >= 0)
break;
sum -= hand[l];
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 844,290 | 844,291 | u954081460 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
vector<ll> v(N + 1);
for (int i = 1; i <= N; ++i) {
cin >> v[i];
}
ll res = 0;
priority_queue<ll, vector<ll>, greater<ll>> que;
for (int l = 0; l <= N; ++l) {
for (int r = N + 1; r > 0; --r) {
int n = l + N + 1 - r;
if (n > K) {
continue;
}
for (int i = 1; i <= l; ++i) {
que.push(v[i]);
}
for (int i = r; i <= N; ++i) {
que.push(v[i]);
}
while (n < K && !que.empty()) {
if (que.top() > 0) {
break;
}
que.pop();
++n;
}
ll tmp = 0;
while (!que.empty()) {
tmp += que.top();
que.pop();
}
res = max(res, tmp);
}
}
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
vector<ll> v(N + 1);
for (int i = 1; i <= N; ++i) {
cin >> v[i];
}
ll res = 0;
priority_queue<ll, vector<ll>, greater<ll>> que;
for (int l = 0; l <= N; ++l) {
for (int r = N + 1; r > 0; --r) {
int n = l + N + 1 - r;
if (n > K || l >= r) {
continue;
}
for (int i = 1; i <= l; ++i) {
que.push(v[i]);
}
for (int i = r; i <= N; ++i) {
que.push(v[i]);
}
while (n < K && !que.empty()) {
if (que.top() > 0) {
break;
}
que.pop();
++n;
}
ll tmp = 0;
while (!que.empty()) {
tmp += que.top();
que.pop();
}
res = max(res, tmp);
}
}
cout << res << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,292 | 844,293 | u203927510 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
int n, k;
vector<ll> v;
ll ans = 0ll;
ll tans(int a, int b) {
ll tans = 0ll;
set<ll> s;
int cd = k - a - b;
REP(i, a + 1) {
s.insert(v[i]);
tans += v[i];
}
REP(j, b) {
s.insert(v[n - 1 - j]);
tans += v[n - 1 - j];
}
for (auto itr : s) {
if (cd < 1 || itr > 0) {
break;
} else {
tans -= itr;
cd--;
}
}
return tans;
}
int main() {
cin >> n >> k;
REP(i, n) {
int tv;
cin >> tv;
v.push_back(tv);
}
REP(a, k + 1) {
REP(b, k + 1 - a) {
if (a + b > n)
break;
ans = max(ans, tans(a, b));
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
int n, k;
vector<ll> v;
ll ans = 0ll;
ll tans(int a, int b) {
ll tans = 0ll;
set<ll> s;
int cd = k - a - b;
REP(i, a) {
s.insert(v[i]);
tans += v[i];
}
REP(j, b) {
s.insert(v[n - 1 - j]);
tans += v[n - 1 - j];
}
for (auto itr : s) {
if (cd < 1 || itr > 0) {
break;
} else {
tans -= itr;
cd--;
}
}
return tans;
}
int main() {
cin >> n >> k;
REP(i, n) {
int tv;
cin >> tv;
v.push_back(tv);
}
REP(a, k + 1) {
REP(b, k + 1 - a) {
if (a + b > n)
break;
ans = max(ans, tans(a, b));
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 844,296 | 844,297 | u007637377 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
int n, k;
vector<ll> v;
ll ans = 0ll;
ll tans(int a, int b) {
ll tans = 0ll;
set<ll> s;
int cd = k - a - b;
REP(i, a + 1) {
s.insert(v[i]);
tans += v[i];
}
REP(j, b) {
s.insert(v[n - 1 - j]);
tans += v[n - 1 - j];
}
for (auto itr : s) {
if (cd < 2 || itr > 0) {
break;
} else {
tans -= itr;
cd--;
}
}
return tans;
}
int main() {
cin >> n >> k;
REP(i, n) {
int tv;
cin >> tv;
v.push_back(tv);
}
REP(a, k + 1) {
REP(b, k + 1 - a) {
if (a + b > n)
break;
ans = max(ans, tans(a, b));
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
int n, k;
vector<ll> v;
ll ans = 0ll;
ll tans(int a, int b) {
ll tans = 0ll;
set<ll> s;
int cd = k - a - b;
REP(i, a) {
s.insert(v[i]);
tans += v[i];
}
REP(j, b) {
s.insert(v[n - 1 - j]);
tans += v[n - 1 - j];
}
for (auto itr : s) {
if (cd < 1 || itr > 0) {
break;
} else {
tans -= itr;
cd--;
}
}
return tans;
}
int main() {
cin >> n >> k;
REP(i, n) {
int tv;
cin >> tv;
v.push_back(tv);
}
REP(a, k + 1) {
REP(b, k + 1 - a) {
if (a + b > n)
break;
ans = max(ans, tans(a, b));
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 844,298 | 844,297 | u007637377 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b);
return a;
}
int main() {
int n, k, ans = 0;
cin >> n >> k;
vector<int> d(n);
rep(i, n) { cin >> d[i]; }
for (int l = 0; l <= k; l++) {
for (int r = 0; r <= k - l; r++) {
int b, sum = 0;
if (l + r > n)
continue;
vector<int> tmp;
rep(i, l) { tmp.emplace_back(d[i]); }
rep(i, r) { tmp.emplace_back(d[n - i - 1]); }
sort(tmp.begin(), tmp.end());
for (b = 0; b <= k - l - r; b++) {
if (b >= tmp.size())
break;
if (tmp[b] >= 0)
break;
}
while (b < tmp.size()) {
sum += tmp[b];
b++;
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b);
return a;
}
int main() {
int n, k, ans = 0;
cin >> n >> k;
vector<int> d(n);
rep(i, n) { cin >> d[i]; }
for (int l = 0; l <= k; l++) {
for (int r = 0; r <= k - l; r++) {
int b, sum = 0;
if (l + r > n)
continue;
vector<int> tmp;
rep(i, l) { tmp.emplace_back(d[i]); }
rep(i, r) { tmp.emplace_back(d[n - i - 1]); }
sort(tmp.begin(), tmp.end());
for (b = 0; b < k - l - r; b++) {
if (b >= tmp.size())
break;
if (tmp[b] >= 0)
break;
}
while (b < tmp.size()) {
sum += tmp[b];
b++;
}
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,309 | 844,310 | u561013007 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b);
return a;
}
int main() {
int n, k, ans = 0;
cin >> n >> k;
vector<int> d(n);
rep(i, n) { cin >> d[i]; }
for (int l = 0; l < k; l++) {
for (int r = 0; r < k - l; r++) {
int b, sum = 0;
if (l + r > n)
continue;
vector<int> tmp;
rep(i, l) { tmp.emplace_back(d[i]); }
rep(i, r) { tmp.emplace_back(d[n - i - 1]); }
sort(tmp.begin(), tmp.end());
for (b = 0; b < k - l - r; b++) {
if (b >= tmp.size())
break;
if (tmp[b] >= 0)
break;
}
while (b < tmp.size()) {
sum += tmp[b];
b++;
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b);
return a;
}
int main() {
int n, k, ans = 0;
cin >> n >> k;
vector<int> d(n);
rep(i, n) { cin >> d[i]; }
for (int l = 0; l <= k; l++) {
for (int r = 0; r <= k - l; r++) {
int b, sum = 0;
if (l + r > n)
continue;
vector<int> tmp;
rep(i, l) { tmp.emplace_back(d[i]); }
rep(i, r) { tmp.emplace_back(d[n - i - 1]); }
sort(tmp.begin(), tmp.end());
for (b = 0; b < k - l - r; b++) {
if (b >= tmp.size())
break;
if (tmp[b] >= 0)
break;
}
while (b < tmp.size()) {
sum += tmp[b];
b++;
}
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,311 | 844,310 | u561013007 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int N, K;
int64_t ans;
int main() {
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++)
cin >> V[i];
ans = 0;
int R = min(N, K);
for (int A = 0; A < R; A++) {
for (int B = 0; B < R - A; B++) {
vector<int> v;
int64_t res = 0;
for (int i = 0; i < A; i++)
v.push_back(V[i]);
for (int i = 0; i < B; i++)
v.push_back(V[N - 1 - i]);
sort(v.begin(), v.end());
int del = K - (A + B);
for (int i = 0; i < v.size(); i++) {
if (del <= i || 0 < v[i])
res += v[i];
}
ans = max(ans, res);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int N, K;
int64_t ans;
int main() {
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++)
cin >> V[i];
ans = 0;
int R = min(N, K);
for (int A = 0; A <= R; A++) {
for (int B = 0; B <= R - A; B++) {
vector<int> v;
int64_t res = 0;
for (int i = 0; i < A; i++)
v.push_back(V[i]);
for (int i = 0; i < B; i++)
v.push_back(V[N - 1 - i]);
sort(v.begin(), v.end());
int del = K - (A + B);
for (int i = 0; i < v.size(); i++) {
if (del <= i || 0 < v[i])
res += v[i];
}
ans = max(ans, res);
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,320 | 844,321 | u992875223 | cpp |
p03032 | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_D main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LONG_MAX / 2)
const int MGN = 8;
const int ARY_SZ_MAX = 10000000;
using namespace std;
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvvb = vector<vvb>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
// functions
#endif
int main_D() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vi V(N);
REP(i, N) cin >> V[i];
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;
vi a;
int sum = 0;
REP(i, l) {
a.push_back(V[i]);
sum += V[i];
}
REP(i, r) {
a.push_back(V[N - 1 - i]);
sum += V[N - 1 - i];
}
sort(a.begin(), a.end());
REP(i, d) {
if (i >= a.size())
break;
if (a[i] > 0)
break;
sum -= a[i];
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
} | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_D main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LONG_MAX / 2)
const int MGN = 8;
const int ARY_SZ_MAX = 10000000;
using namespace std;
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvvb = vector<vvb>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
// functions
#endif
int main_D() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vi V(N);
REP(i, N) cin >> V[i];
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;
vi a;
int sum = 0;
REP(i, l) {
a.push_back(V[i]);
sum += V[i];
}
REP(i, r) {
a.push_back(V[N - 1 - i]);
sum += V[N - 1 - i];
}
sort(a.begin(), a.end());
REP(i, d) {
if (i >= a.size())
break;
if (a[i] > 0)
break;
sum -= a[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,334 | 844,335 | u404244809 | cpp |
p03032 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ld float
#define rep(i, a, b) for (ll i = a; i < b; i += 1)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define sz(a) int((a).size())
#define hell (ll)1000000007
#define f first
#define s second
#define sll(x) scanf("%lld", &x)
#define si(x) scanf("%d", &x)
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
ll t = 1;
void solve() {
ll n, k, ans = 0;
cin >> n >> k;
vector<ll> v(n);
rep(i, 0, n) cin >> v[i];
ll up = min(n, k) + 1;
rep(i, 0, up) {
rep(j, 0, up) {
if (i + j > up)
continue;
ll cur = 0;
vector<ll> tmp;
rep(_, 0, i) tmp.pb(v[_]);
for (ll _ = n - 1; _ >= n - j; _--) {
tmp.pb(v[_]);
}
sort(all(tmp));
for (auto u : tmp)
cur += u;
// cout << endl;
rep(_, 0, min(i + j, k - i - j)) {
if (tmp[_] < 0)
cur -= tmp[_];
}
ans = max(ans, cur);
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// cin>>t;
while (t--)
solve();
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ld float
#define rep(i, a, b) for (ll i = a; i < b; i += 1)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define sz(a) int((a).size())
#define hell (ll)1000000007
#define f first
#define s second
#define sll(x) scanf("%lld", &x)
#define si(x) scanf("%d", &x)
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
ll t = 1;
void solve() {
ll n, k, ans = 0;
cin >> n >> k;
vector<ll> v(n);
rep(i, 0, n) cin >> v[i];
ll up = min(n, k) + 1;
rep(i, 0, up) {
rep(j, 0, up) {
if (i + j > up - 1)
continue;
ll cur = 0;
vector<ll> tmp;
rep(_, 0, i) tmp.pb(v[_]);
for (ll _ = n - 1; _ >= n - j; _--) {
tmp.pb(v[_]);
}
sort(all(tmp));
for (auto u : tmp)
cur += u;
// cout << endl;
rep(_, 0, min(i + j, k - i - j)) {
if (tmp[_] < 0)
cur -= tmp[_];
}
ans = max(ans, cur);
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// cin>>t;
while (t--)
solve();
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 844,340 | 844,341 | u889695981 | cpp |
p03032 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ld float
#define rep(i, a, b) for (ll i = a; i < b; i += 1)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define sz(a) int((a).size())
#define hell (ll)1000000007
#define f first
#define s second
#define sll(x) scanf("%lld", &x)
#define si(x) scanf("%d", &x)
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
ll t = 1;
void solve() {
ll n, k, ans = 0;
cin >> n >> k;
vector<ll> v(n);
rep(i, 0, n) cin >> v[i];
ll up = min(n, k);
rep(i, 0, up) {
rep(j, 0, up) {
if (i + j > up)
continue;
ll cur = 0;
vector<ll> tmp;
rep(_, 0, i) tmp.pb(v[_]);
for (ll _ = n - 1; _ >= n - j; _--) {
tmp.pb(v[_]);
}
sort(all(tmp));
for (auto u : tmp)
cur += u;
// cout << endl;
rep(_, 0, min(i + j, k - i - j)) {
if (tmp[_] < 0)
cur -= tmp[_];
}
ans = max(ans, cur);
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// cin>>t;
while (t--)
solve();
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ld float
#define rep(i, a, b) for (ll i = a; i < b; i += 1)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define sz(a) int((a).size())
#define hell (ll)1000000007
#define f first
#define s second
#define sll(x) scanf("%lld", &x)
#define si(x) scanf("%d", &x)
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
ll t = 1;
void solve() {
ll n, k, ans = 0;
cin >> n >> k;
vector<ll> v(n);
rep(i, 0, n) cin >> v[i];
ll up = min(n, k) + 1;
rep(i, 0, up) {
rep(j, 0, up) {
if (i + j > up - 1)
continue;
ll cur = 0;
vector<ll> tmp;
rep(_, 0, i) tmp.pb(v[_]);
for (ll _ = n - 1; _ >= n - j; _--) {
tmp.pb(v[_]);
}
sort(all(tmp));
for (auto u : tmp)
cur += u;
// cout << endl;
rep(_, 0, min(i + j, k - i - j)) {
if (tmp[_] < 0)
cur -= tmp[_];
}
ans = max(ans, cur);
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// cin>>t;
while (t--)
solve();
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 844,342 | 844,341 | u889695981 | cpp |
p03032 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : abs(x); }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
// 解法はすぐ分かったが、何故が実装がバグったので、解説をﾁｮｯﾄ見た(は?)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &a : v) {
cin >> a;
}
int ans = 0;
for (int left = 0; left <= k; left++) {
for (int right = 0; right < k - left; right++) {
if (left + right > n) {
continue;
}
int now = 0;
vector<int> s;
for (int i = 0; i < left; i++) {
now += v[i];
s.push_back(v[i]);
}
for (int i = n - right; i < n; i++) {
now += v[i];
s.push_back(v[i]);
}
sort(begin(s), end(s));
int d = k - left - right;
for (int i = 0; i < d; i++) {
if (i >= s.size() || s[i] >= 0) {
break;
}
now -= s[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : abs(x); }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
// 解法はすぐ分かったが、何故が実装がバグったので、解説をﾁｮｯﾄ見た(は?)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &a : v) {
cin >> a;
}
int ans = 0;
for (int left = 0; left <= k; left++) {
for (int right = 0; right <= k - left; right++) {
if (left + right > n) {
continue;
}
int now = 0;
vector<int> s;
for (int i = 0; i < left; i++) {
now += v[i];
s.push_back(v[i]);
}
for (int i = n - right; i < n; i++) {
now += v[i];
s.push_back(v[i]);
}
sort(begin(s), end(s));
int d = k - left - right;
for (int i = 0; i < d; i++) {
if (i >= s.size() || s[i] >= 0) {
break;
}
now -= s[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,356 | 844,357 | u825215512 | cpp |
p03032 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : abs(x); }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
// 解法はすぐ分かったが、何故が実装がバグったので、解説をﾁｮｯﾄ見た(は?)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &a : v) {
cin >> a;
}
int ans = 0;
for (int left = 0; left < k; left++) {
for (int right = 0; right < k - left; right++) {
if (left + right > n) {
continue;
}
int now = 0;
vector<int> s;
for (int i = 0; i < left; i++) {
now += v[i];
s.push_back(v[i]);
}
for (int i = n - right; i < n; i++) {
now += v[i];
s.push_back(v[i]);
}
sort(begin(s), end(s));
int d = k - left - right;
for (int i = 0; i < d; i++) {
if (i >= s.size() || s[i] >= 0) {
break;
}
now -= s[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : abs(x); }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
// 解法はすぐ分かったが、何故が実装がバグったので、解説をﾁｮｯﾄ見た(は?)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &a : v) {
cin >> a;
}
int ans = 0;
for (int left = 0; left <= k; left++) {
for (int right = 0; right <= k - left; right++) {
if (left + right > n) {
continue;
}
int now = 0;
vector<int> s;
for (int i = 0; i < left; i++) {
now += v[i];
s.push_back(v[i]);
}
for (int i = n - right; i < n; i++) {
now += v[i];
s.push_back(v[i]);
}
sort(begin(s), end(s));
int d = k - left - right;
for (int i = 0; i < d; i++) {
if (i >= s.size() || s[i] >= 0) {
break;
}
now -= s[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,358 | 844,357 | u825215512 | cpp |
p03032 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : abs(x); }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
// 解法はすぐ分かったが、何故が実装がバグったので、解説をﾁｮｯﾄ見た(は?)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &a : v) {
cin >> a;
}
int ans = 0;
for (int left = 0; left < k; left++) {
for (int right = 0; right < k - left; right++) {
if (left + right > n) {
break;
}
int now = 0;
vector<int> s;
for (int i = 0; i < left; i++) {
now += v[i];
s.push_back(v[i]);
}
for (int i = n - right; i < n; i++) {
now += v[i];
s.push_back(v[i]);
}
sort(begin(s), end(s));
int d = k - left - right;
for (int i = 0; i < d; i++) {
if (i >= s.size() || s[i] >= 0) {
break;
}
now -= s[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : abs(x); }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
// 解法はすぐ分かったが、何故が実装がバグったので、解説をﾁｮｯﾄ見た(は?)
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n);
for (auto &a : v) {
cin >> a;
}
int ans = 0;
for (int left = 0; left <= k; left++) {
for (int right = 0; right <= k - left; right++) {
if (left + right > n) {
continue;
}
int now = 0;
vector<int> s;
for (int i = 0; i < left; i++) {
now += v[i];
s.push_back(v[i]);
}
for (int i = n - right; i < n; i++) {
now += v[i];
s.push_back(v[i]);
}
sort(begin(s), end(s));
int d = k - left - right;
for (int i = 0; i < d; i++) {
if (i >= s.size() || s[i] >= 0) {
break;
}
now -= s[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.break.remove",
"control_flow.continue.add"
] | 844,359 | 844,357 | u825215512 | cpp |
p03032 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drep2(j, n) for (int j = (n)-1; j >= 0; --j)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define srep2(j, s, t) for (int j = s; j < t; ++j)
#define srep3(k, s, t) for (int k = s; k < t; ++k)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
int main() {
int N, K;
cin >> N >> K;
vi V(N);
rep(i, N) { cin >> V[i]; }
int ans = 0;
for (int i = 0; i < K; i++) {
for (int j = 0; i + j < K; j++) {
if (i + j > N)
continue;
int now = 0;
PQ(int) q;
rep(a, i) {
now += V[a];
q.push(V[a]);
}
rep(b, j) {
now += V[N - b - 1];
q.push(V[N - b - 1]);
}
for (int d = 0; i + j + d < K; d++) {
if (!q.empty()) {
int x = q.top();
if (x > 0)
break;
now -= x;
q.pop();
}
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drep2(j, n) for (int j = (n)-1; j >= 0; --j)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define srep2(j, s, t) for (int j = s; j < t; ++j)
#define srep3(k, s, t) for (int k = s; k < t; ++k)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
int main() {
int N, K;
cin >> N >> K;
vi V(N);
rep(i, N) { cin >> V[i]; }
int ans = 0;
for (int i = 0; i <= K; i++) {
for (int j = 0; i + j <= K; j++) {
if (i + j > N)
continue;
int now = 0;
PQ(int) q;
rep(a, i) {
now += V[a];
q.push(V[a]);
}
rep(b, j) {
now += V[N - b - 1];
q.push(V[N - b - 1]);
}
for (int d = 0; i + j + d < K; d++) {
if (!q.empty()) {
int x = q.top();
if (x > 0)
break;
now -= x;
q.pop();
}
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,360 | 844,361 | u340293807 | cpp |
p03032 | #include <algorithm>
#include <deque>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
/* editorial */
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
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 l = 0; l <= i; l++) {
int L = l, R = i - l;
vector<int> tmp;
for (int j = 0; j < L; j++) {
tmp.push_back(V[j]);
}
for (int j = 0; j < R; j++) {
tmp.push_back(V[(N - 1) - j]);
}
sort(tmp.begin(), tmp.end());
int rest = K - i;
for (int j = 0; j < rest; j++) {
if (tmp.size() > 0 && tmp[0] < 0) {
tmp.erase(tmp.begin());
} else {
break;
}
}
ans = max(ans, accumulate(tmp.begin(), tmp.end(), 0));
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <deque>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
/* editorial */
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
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 l = 0; l <= i; l++) {
int L = l, R = i - l;
vector<int> tmp;
for (int j = 0; j < L; j++) {
tmp.push_back(V[j]);
}
for (int j = 0; j < R; j++) {
tmp.push_back(V[(N - 1) - j]);
}
sort(tmp.begin(), tmp.end());
int rest = K - i;
for (int j = 0; j < rest; j++) {
if (tmp.size() > 0 && tmp[0] < 0) {
tmp.erase(tmp.begin());
} else {
break;
}
}
ans = max(ans, accumulate(tmp.begin(), tmp.end(), 0));
// cout << "i = " << i << ", l = " << l << endl;
// cout << "ans: " << ans << endl;
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,362 | 844,363 | u341347211 | cpp |
p03032 | #include "bits/stdc++.h"
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V1(N);
vector<int> V2(N);
for (int i = 0; i < N; i++) {
cin >> V1[i];
V2[N - 1 - i] = V1[i];
}
int ans = 0;
for (int i = 1; i <= K; i++) {
for (int j = 0; j <= i; j++) {
int res = K - i;
int sum = 0;
int A = i - j;
int B = j;
vector<int> cnt = {};
for (int a = 0; a < A; a++)
cnt.push_back(V1[a]);
for (int b = 0; b < B; b++)
cnt.push_back(V2[b]);
sort(cnt.begin(), cnt.end());
// for (int i = 0; i < cnt.size(); i++) cout << cnt[i] << " ";
// cout << ":" << res << endl;
for (int k = 0; k < cnt.size(); k++) {
if (res > 0) {
if (cnt[k] < 0) {
cnt[k] = 0;
res--;
} else
break;
} else
break;
}
for (int k = 0; k < cnt.size(); k++)
sum += cnt[k];
// cout << sum << endl;
ans = max(ans, sum);
}
}
cout << ans << endl;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V1(N);
vector<int> V2(N);
for (int i = 0; i < N; i++) {
cin >> V1[i];
V2[N - 1 - i] = V1[i];
}
int ans = 0;
for (int i = 1; i <= min(N, K); i++) {
for (int j = 0; j <= i; j++) {
int res = K - i;
int sum = 0;
int A = i - j;
int B = j;
vector<int> cnt = {};
for (int a = 0; a < A; a++)
cnt.push_back(V1[a]);
for (int b = 0; b < B; b++)
cnt.push_back(V2[b]);
sort(cnt.begin(), cnt.end());
// for (int i = 0; i < cnt.size(); i++) cout << cnt[i] << " ";
// cout << ":" << res << endl;
for (int k = 0; k < cnt.size(); k++) {
if (res > 0) {
if (cnt[k] < 0) {
cnt[k] = 0;
res--;
} else
break;
} else
break;
}
for (int k = 0; k < cnt.size(); k++)
sum += cnt[k];
// cout << sum << endl;
ans = max(ans, sum);
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 844,368 | 844,369 | u365956698 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using Data = pair<long, int>;
int main() {
int i, j, h, N, K, L, R, ans = 0, cnt = 0, kcnt;
long val;
scanf("%d", &N);
scanf("%d", &K);
vector<long> v(100), lv(100, 0), rv(100, 0);
vector<Data> order(100, Data(0, 0));
for (i = 1; i <= N; i++) {
scanf("%ld", &v[i]);
lv[i] = lv[i - 1] + v[i];
if (v[i] < 0)
order[cnt++] = Data(v[i], i);
}
sort(order.begin(), order.end());
for (i = N; i > 0; i--) {
rv[i] = rv[i + 1] + v[i];
}
L = min(N, K);
for (i = 0; i <= L; i++) {
R = min(K - i, N);
for (j = 0; j <= R; j++) {
val = lv[i] + rv[N - j + 1];
kcnt = K - i - j;
for (h = 0; h < cnt; h++) {
if (kcnt == 0)
break;
if (order[h].second <= i || order[h].second > N - j + 1) {
val -= order[h].first;
kcnt--;
}
}
if (ans < val)
ans = val;
}
}
printf("%d\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using Data = pair<long, int>;
int main() {
int i, j, h, N, K, L, R, ans = 0, cnt = 0, kcnt;
long val;
scanf("%d", &N);
scanf("%d", &K);
vector<long> v(100), lv(100, 0), rv(100, 0);
vector<Data> order(100, Data(0, 0));
for (i = 1; i <= N; i++) {
scanf("%ld", &v[i]);
lv[i] = lv[i - 1] + v[i];
if (v[i] < 0)
order[cnt++] = Data(v[i], i);
}
sort(order.begin(), order.end());
for (i = N; i > 0; i--) {
rv[i] = rv[i + 1] + v[i];
}
L = min(N, K);
for (i = 0; i <= L; i++) {
R = min(K - i, N - i);
for (j = 0; j <= R; j++) {
val = lv[i] + rv[N - j + 1];
kcnt = K - i - j;
for (h = 0; h < cnt; h++) {
if (kcnt == 0)
break;
if (order[h].second <= i || order[h].second > N - j + 1) {
val -= order[h].first;
kcnt--;
}
}
if (ans < val)
ans = val;
}
}
printf("%d\n", ans);
return 0;
} | [
"assignment.change"
] | 844,372 | 844,373 | u251847465 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using Data = pair<long, int>;
int main() {
int i, j, h, N, K, L, R, ans = 0, cnt = 0, kcnt;
long val;
scanf("%d", &N);
scanf("%d", &K);
vector<long> v(100), lv(100, 0), rv(100, 0);
vector<Data> order(100, Data(0, 0));
for (i = 1; i <= N; i++) {
scanf("%ld", &v[i]);
lv[i] = lv[i - 1] + v[i];
if (v[i] < 0)
order[cnt++] = Data(v[i], i);
}
sort(order.begin(), order.end());
for (i = N; i > 0; i--) {
rv[i] = rv[i + 1] + v[i];
}
L = min(N, K);
for (i = 0; i < L; i++) {
R = min(K - i, N);
for (j = 0; j <= R; j++) {
val = lv[i] + rv[N - j + 1];
kcnt = K - i - j;
for (h = 0; h < cnt; h++) {
if (kcnt == 0)
break;
if (order[h].second <= i || order[h].second > N - j + 1) {
val -= order[h].first;
kcnt--;
}
}
if (ans < val)
ans = val;
}
}
printf("%d\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using Data = pair<long, int>;
int main() {
int i, j, h, N, K, L, R, ans = 0, cnt = 0, kcnt;
long val;
scanf("%d", &N);
scanf("%d", &K);
vector<long> v(100), lv(100, 0), rv(100, 0);
vector<Data> order(100, Data(0, 0));
for (i = 1; i <= N; i++) {
scanf("%ld", &v[i]);
lv[i] = lv[i - 1] + v[i];
if (v[i] < 0)
order[cnt++] = Data(v[i], i);
}
sort(order.begin(), order.end());
for (i = N; i > 0; i--) {
rv[i] = rv[i + 1] + v[i];
}
L = min(N, K);
for (i = 0; i <= L; i++) {
R = min(K - i, N - i);
for (j = 0; j <= R; j++) {
val = lv[i] + rv[N - j + 1];
kcnt = K - i - j;
for (h = 0; h < cnt; h++) {
if (kcnt == 0)
break;
if (order[h].second <= i || order[h].second > N - j + 1) {
val -= order[h].first;
kcnt--;
}
}
if (ans < val)
ans = val;
}
}
printf("%d\n", ans);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"assignment.change"
] | 844,374 | 844,373 | u251847465 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
// 問題点全部プラスでK回取り出せばいいときうまく行かない(K-1回しか取り出してくれない)
int main() {
int N, K;
cin >> N >> K;
vector<ll> vec(N);
priority_queue<ll, vector<ll>, greater<ll>> pque;
ll ans = 0;
for (int i = 0; i < N; i++)
cin >> vec.at(i);
for (int A = 0; A < min(N, K); A++) {
for (int B = 0; B < min(N, K) - A + 1;
B++) { // min(N,K)-A+1に変更。+1してみた。
for (int i = 0; i < A; i++)
pque.push(vec.at(i));
for (int i = 0; i < B; i++)
pque.push(vec.at(N - i - 1));
for (int i = 0; i < K - A - B; i++) {
if (!pque.empty() && pque.top() < 0)
pque.pop();
else
break;
}
ll wa = 0;
while (!pque.empty()) {
wa += pque.top();
pque.pop();
}
ans = max(ans, wa);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
// 問題点全部プラスでK回取り出せばいいときうまく行かない(K-1回しか取り出してくれない)
int main() {
int N, K;
cin >> N >> K;
vector<ll> vec(N);
priority_queue<ll, vector<ll>, greater<ll>> pque;
ll ans = 0;
for (int i = 0; i < N; i++)
cin >> vec.at(i);
for (int A = 0; A < min(N, K) + 1; A++) {
for (int B = 0; B < min(N, K) - A + 1;
B++) { // min(N,K)-A+1に変更。+1してみた。エラー減ったけど...
for (int i = 0; i < A; i++)
pque.push(vec.at(i));
for (int i = 0; i < B; i++)
pque.push(vec.at(N - i - 1));
for (int i = 0; i < K - A - B; i++) {
if (!pque.empty() && pque.top() < 0)
pque.pop();
else
break;
}
ll wa = 0;
while (!pque.empty()) {
wa += pque.top();
pque.pop();
}
ans = max(ans, wa);
}
}
cout << ans << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 844,377 | 844,378 | u889812821 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rer(i, l, u) for (int(i) = (int)(l); (i) <= (int)(u); ++(i))
#define reu(i, l, u) for (int(i) = (int)(l); (i) < (int)(u); ++(i))
typedef long long ll;
static const int dy[4] = {0, 1, 0, -1};
static const int dx[4] = {1, 0, -1, 0};
using namespace std;
int main() {
int n, k;
ll ans = 0;
cin >> n >> k;
vector<int> v(n, 0);
for (int i = 0; i < n; i++)
cin >> v[i];
for (int p = 0; p < min(k, n); p++) {
for (int q = 0; q < min(k, n) - p; q++) {
ll sum = 0;
vector<ll> select;
for (int i = 0; i < p; i++) {
select.push_back(v[i]);
sum += v[i];
}
for (int i = 0; i < q; i++) {
select.push_back(v[n - 1 - i]);
sum += v[n - 1 - i];
}
sort(select.begin(), select.end());
for (int i = 0; i < min(k - p - q, (int)select.size()); i++) {
if (select[i] < 0)
sum += -select[i];
}
ans = max(sum, ans);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rer(i, l, u) for (int(i) = (int)(l); (i) <= (int)(u); ++(i))
#define reu(i, l, u) for (int(i) = (int)(l); (i) < (int)(u); ++(i))
typedef long long ll;
static const int dy[4] = {0, 1, 0, -1};
static const int dx[4] = {1, 0, -1, 0};
using namespace std;
int main() {
int n, k;
ll ans = 0;
cin >> n >> k;
vector<int> v(n, 0);
for (int i = 0; i < n; i++)
cin >> v[i];
for (int p = 0; p <= min(k, n); p++) {
for (int q = 0; q <= min(k, n) - p; q++) {
ll sum = 0;
vector<ll> select;
for (int i = 0; i < p; i++) {
select.push_back(v[i]);
sum += v[i];
}
for (int i = 0; i < q; i++) {
select.push_back(v[n - 1 - i]);
sum += v[n - 1 - i];
}
sort(select.begin(), select.end());
for (int i = 0; i < min(k - p - q, (int)select.size()); i++) {
if (select[i] < 0)
sum += -select[i];
}
ans = max(sum, ans);
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,382 | 844,383 | u484962958 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int solve(vector<int> v, int max_del_num) {
sort(v.begin(), v.end());
int sum = 0;
for (int x : v)
sum += x;
for (int i = 0; i < max_del_num && i < v.size(); ++i) {
if (v[i] < 0) {
sum -= v[i];
} else
break;
}
return sum;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n + 1);
for (int i = 1; i <= n; ++i)
cin >> v[i];
int ans = 0;
for (int l = 0; l <= k; ++l) {
for (int r = 0; r + l <= k; ++r) {
vector<int> con;
for (int i = 1; i <= l; ++i)
con.push_back(v[i]);
for (int i = n; i > n - r && i > l; --i)
con.push_back(v[i]);
ans = max(ans, solve(con, k - (l + r)));
}
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int solve(vector<int> v, int max_del_num) {
sort(v.begin(), v.end());
int sum = 0;
for (int x : v)
sum += x;
for (int i = 0; i < max_del_num && i < v.size(); ++i) {
if (v[i] < 0) {
sum -= v[i];
} else
break;
}
return sum;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n + 1);
for (int i = 1; i <= n; ++i)
cin >> v[i];
int ans = 0;
for (int l = 0; l <= k; ++l) {
for (int r = 0; r + l <= k; ++r) {
vector<int> con;
for (int i = 1; i <= l && i <= n; ++i)
con.push_back(v[i]);
for (int i = n; i > n - r && i > l; --i)
con.push_back(v[i]);
ans = max(ans, solve(con, k - (l + r)));
}
}
cout << ans;
} | [
"control_flow.loop.for.condition.change"
] | 844,386 | 844,387 | u914762730 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define boost \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define track(x) cout << #x << " : " << (x) << endl
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
//#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> edge;
typedef pair<ll, ll> mypair;
typedef priority_queue<ll> max_heap;
typedef priority_queue<ll, vector<ll>, greater<ll>> min_heap;
const ll mod = 1000000007;
const ll inf = 1e15;
const ll N = 3e5 + 10;
ll n, k;
ll v[60];
ll get(ll l, ll r) {
std::vector<ll> temp;
for (ll i = 0; i <= l; i++)
temp.pb(v[i]);
for (ll i = r; i < n; i++)
temp.pb(v[i]);
sort(all(temp));
ll ans = 0;
ll lim = k - (ll)temp.size();
if (lim < 0)
return 0;
for (auto &i : temp) {
if (i < 0 and lim)
lim--;
else
ans += i;
}
return ans;
}
int main() {
boost;
cin >> n >> k;
for (ll i = 0; i < n; i++)
cin >> v[i];
ll ans = 0;
for (ll l = -1; l < n; l++) {
for (ll r = l + 1; r < n; r++) {
ans = max(ans, get(l, r));
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define boost \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define track(x) cout << #x << " : " << (x) << endl
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
//#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> edge;
typedef pair<ll, ll> mypair;
typedef priority_queue<ll> max_heap;
typedef priority_queue<ll, vector<ll>, greater<ll>> min_heap;
const ll mod = 1000000007;
const ll inf = 1e15;
const ll N = 3e5 + 10;
ll n, k;
ll v[60];
ll get(ll l, ll r) {
std::vector<ll> temp;
for (ll i = 0; i <= l; i++)
temp.pb(v[i]);
for (ll i = r; i < n; i++)
temp.pb(v[i]);
sort(all(temp));
ll ans = 0;
ll lim = k - (ll)temp.size();
if (lim < 0)
return 0;
for (auto &i : temp) {
if (i < 0 and lim)
lim--;
else
ans += i;
}
return ans;
}
int main() {
boost;
cin >> n >> k;
for (ll i = 0; i < n; i++)
cin >> v[i];
ll ans = 0;
for (ll l = -1; l < n; l++) {
for (ll r = l + 1; r <= n; r++) {
ans = max(ans, get(l, r));
}
}
cout << ans;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,388 | 844,389 | u202858603 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> v(N, 0);
for (int i = 0; i < N; i++)
cin >> v[i];
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 now = 0;
vector<int> S;
for (int i = 0; i < l; i++) {
now += v[i];
S.push_back(v[i]);
}
for (int i = N - r; i < N; i++) {
now += v[i];
S.push_back(v[i]);
}
sort(S.begin(), S.end());
for (int i = 0; i < d; i++) {
if (i >= S.size())
break;
if (S[i] > 0)
break;
now -= S[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> v(N, 0);
for (int i = 0; i < N; i++)
cin >> v[i];
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 now = 0;
vector<int> S;
for (int i = 0; i < l; i++) {
now += v[i];
S.push_back(v[i]);
}
for (int i = N - r; i < N; i++) {
now += v[i];
S.push_back(v[i]);
}
sort(S.begin(), S.end());
for (int i = 0; i < d; i++) {
if (i >= S.size())
break;
if (S[i] > 0)
break;
now -= S[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,399 | 844,400 | u547844563 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n);
vector<bool> ju(n, false);
vector<pair<int, int>> da(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
da[i].first = p[i];
da[i].second = i;
}
int ans = 0;
// sort(da.begin(), da.end());
for (int i = 1; i < min(m, n); i++) {
for (int j = 0; j < i + 1; j++) {
int mo = 0;
vector<int> me(i);
for (int l = 0; l < j; l++) {
me[l] = p[l];
mo += me[l];
}
for (int l = j; l < i; l++) {
me[l] = p[n - l + j - 1];
mo += me[l];
}
sort(me.begin(), me.end());
for (int l = 0; l < min(i, m - i); l++) {
if (me[l] > 0)
break;
mo -= me[l];
}
ans = max(ans, mo);
// cout << ans << endl;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n);
vector<bool> ju(n, false);
vector<pair<int, int>> da(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
da[i].first = p[i];
da[i].second = i;
}
int ans = 0;
// sort(da.begin(), da.end());
for (int i = 1; i < min(m, n) + 1; i++) {
for (int j = 0; j < i + 1; j++) {
int mo = 0;
vector<int> me(i);
for (int l = 0; l < j; l++) {
me[l] = p[l];
mo += me[l];
}
for (int l = j; l < i; l++) {
me[l] = p[n - l + j - 1];
mo += me[l];
}
sort(me.begin(), me.end());
for (int l = 0; l < min(i, m - i); l++) {
if (me[l] > 0)
break;
mo -= me[l];
}
ans = max(ans, mo);
// cout << ans << endl;
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 844,401 | 844,402 | u057079894 | cpp |
p03032 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
using INT64 = long long;
int main(void) {
IOS int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int gmax = min(n, k);
int vmax = 0;
for (int i = 0; i < gmax; i++) {
for (int l = 0; l <= i; l++) {
for (int r = 0; r <= i - l; r++) {
// cerr << "l:" << l << "r:" << r << " ";
vector<int> v2;
for (int l2 = 0; l2 < l; l2++)
v2.push_back(v[l2]);
for (int r2 = 0; r2 < r; r2++)
v2.push_back(v[n - r2 - 1]);
/*
for(int x = 0; x < v2.size(); x++) {
cerr << v2[x] << " ";
}
*/
// cerr << endl;
sort(v2.rbegin(), v2.rend());
for (int d = 0; d < k - l - r; d++) {
if (!(v2.empty()) && (v2.back() < 0)) {
v2.pop_back();
} else {
break;
}
}
int val = accumulate(v2.begin(), v2.end(), 0);
// cerr << "v:" << val << endl;
if (vmax < val)
vmax = val;
}
}
}
cout << vmax << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
using INT64 = long long;
int main(void) {
IOS int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int gmax = min(n, k);
int vmax = 0;
for (int i = 0; i <= gmax; i++) {
for (int l = 0; l <= i; l++) {
for (int r = 0; r <= i - l; r++) {
// cerr << "l:" << l << "r:" << r << " ";
vector<int> v2;
for (int l2 = 0; l2 < l; l2++)
v2.push_back(v[l2]);
for (int r2 = 0; r2 < r; r2++)
v2.push_back(v[n - r2 - 1]);
/*
for(int x = 0; x < v2.size(); x++) {
cerr << v2[x] << " ";
}
*/
// cerr << endl;
sort(v2.rbegin(), v2.rend());
for (int d = 0; d < k - l - r; d++) {
if (!(v2.empty()) && (v2.back() < 0)) {
v2.pop_back();
} else {
break;
}
}
int val = accumulate(v2.begin(), v2.end(), 0);
// cerr << "v:" << val << endl;
if (vmax < val)
vmax = val;
}
}
}
cout << vmax << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,403 | 844,404 | u330661451 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
vector<int> v;
int main(int argc, char const *argv[]) {
int N, K;
cin >> N >> K;
int Joutmax = min(N, K);
long long ans = 0;
for (int i = 0; i < N; i++) {
int temp;
cin >> temp;
v.push_back(temp);
}
// 取り出す個数
for (int k = 1; k <= Joutmax; k++) {
for (int left = 0; left <= k; left++) {
int right = k - left;
long long sum = 0;
int diff = K - k;
vector<int> vecJ;
for (int index = 0; index < left; index++) {
sum += v[index];
vecJ.push_back(v[index]);
}
for (int index = 0; index < right; index++) {
sum += v[N - index - 1];
vecJ.push_back(v[N - index - 1]);
}
sort(vecJ.begin(), vecJ.end());
for (int index = 0; index < diff; index++) {
sum -= min(0, vecJ[index]);
}
// cout << sum << endl;
ans = max(sum, ans);
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
vector<int> v;
int main(int argc, char const *argv[]) {
int N, K;
cin >> N >> K;
int Joutmax = min(N, K);
long long ans = 0;
for (int i = 0; i < N; i++) {
int temp;
cin >> temp;
v.push_back(temp);
}
// 取り出す個数
for (int k = 1; k <= Joutmax; k++) {
for (int left = 0; left <= k; left++) {
int right = k - left;
long long sum = 0;
int diff = K - k;
vector<int> vecJ;
for (int index = 0; index < left; index++) {
sum += v[index];
vecJ.push_back(v[index]);
}
for (int index = 0; index < right; index++) {
sum += v[N - index - 1];
vecJ.push_back(v[N - index - 1]);
}
sort(vecJ.begin(), vecJ.end());
for (int index = 0; index < min(diff, k); index++) {
sum -= min(0, vecJ[index]);
}
// cout << sum << endl;
ans = max(sum, ans);
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 844,424 | 844,425 | u636137609 | cpp |
p03032 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n, k;
ll max = 0;
cin >> n >> k;
vector<ll> v(n);
for (ll i = 0; i < n; i++)
cin >> v[i];
for (ll i = 0; i <= k; i++) {
for (ll j = 0; j <= i; j++) {
vector<ll> have;
for (ll l = 0; l < j; l++) {
have.push_back(v[l]);
}
for (ll l = 0; l < i - j; l++) {
have.push_back(v[n - 1 - l]);
}
sort(have.begin(), have.end());
for (ll l = 0; l < k - i; l++) {
if (have.size() == 0)
break;
if (have[0] < 0) {
have.erase(have.begin());
} else {
break;
}
}
ll sum = 0;
for (ll vv : have) {
sum += vv;
}
if (max < sum)
max = sum;
}
}
cout << max << endl;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n, k;
ll max = 0;
cin >> n >> k;
vector<ll> v(n);
for (ll i = 0; i < n; i++)
cin >> v[i];
for (ll i = 0; i <= min(n, k); i++) {
for (ll j = 0; j <= i; j++) {
vector<ll> have;
for (ll l = 0; l < j; l++) {
have.push_back(v[l]);
}
for (ll l = 0; l < i - j; l++) {
have.push_back(v[n - 1 - l]);
}
sort(have.begin(), have.end());
for (ll l = 0; l < k - i; l++) {
if (have.size() == 0)
break;
if (have[0] < 0) {
have.erase(have.begin());
} else {
break;
}
}
ll sum = 0;
for (ll vv : have) {
sum += vv;
}
if (max < sum)
max = sum;
}
}
cout << max << endl;
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 844,428 | 844,429 | u201316840 | cpp |
p03032 | #include <bits/stdc++.h>
#define SORT(a) sort(a.begin(), a.end())
#define RSORT(a) sort(a.rbegin(), a.rend())
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n; 0 <= i; i--)
#define FOR(i, start, end) for (int i = start; i < end; i++)
#define FORSTEP(i, start, end, step) for (int i = start; i < end; i += step)
#define RFOR(i, start, end) for (int i = start; end <= i; i--)
#define ALL(a) a.begin(), a.end()
#define MOD(a) a %= 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;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<int> V(N);
REP(i, N) cin >> V[i];
ll ans = (int)-1E9;
REP(l, K + 1) {
REP(r, K + 1) {
if (K < l + r)
break;
vector<int> a;
REP(i, l) { a.push_back(V[i]); }
REP(i, r) { a.push_back(V[N - i - 1]); }
SORT(a);
ll sum = 0;
REP(i, a.size()) {
if (a[i] < 0 && i < K - r - l) {
} else {
sum += a[i];
}
}
chmax(ans, sum);
}
}
std::cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
#define SORT(a) sort(a.begin(), a.end())
#define RSORT(a) sort(a.rbegin(), a.rend())
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n; 0 <= i; i--)
#define FOR(i, start, end) for (int i = start; i < end; i++)
#define FORSTEP(i, start, end, step) for (int i = start; i < end; i += step)
#define RFOR(i, start, end) for (int i = start; end <= i; i--)
#define ALL(a) a.begin(), a.end()
#define MOD(a) a %= 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;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<int> V(N);
REP(i, N) cin >> V[i];
ll ans = (int)-1E9;
REP(l, K + 1) {
REP(r, K + 1) {
if (min(K, N) < l + r)
break;
vector<int> a;
REP(i, l) { a.push_back(V[i]); }
REP(i, r) { a.push_back(V[N - i - 1]); }
SORT(a);
ll sum = 0;
REP(i, a.size()) {
if (a[i] < 0 && i < K - r - l) {
} else {
sum += a[i];
}
}
chmax(ans, sum);
}
}
std::cout << ans << '\n';
return 0;
} | [
"control_flow.branch.if.condition.change",
"call.add",
"call.arguments.add"
] | 844,430 | 844,431 | u324303263 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int calc(vector<int> V, int a, int b, int k) {
vector<int> v;
if (a == 0) {
if (b > 0)
v = vector<int>(V.end() - b, V.end());
else
return 0;
} else {
v = vector<int>(V.begin(), V.begin() + a);
if (b > 0)
v.insert(v.end(), V.end() - b, V.end());
}
sort(v.begin(), v.end());
int res = 0;
for (int i = 0; i < a + b; i++) {
if (v.at(i) >= 0) {
res += v.at(i);
} else {
if (i >= k - a - b)
res += v.at(i);
}
}
return res;
}
int main() {
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int r = min(N, K);
int ans = 0;
for (int a = 0; a < r; a++) {
for (int b = 0; b < r - a; b++) {
int res = calc(V, a, b, K);
if (ans < res)
ans = res;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int calc(vector<int> V, int a, int b, int k) {
vector<int> v;
if (a == 0) {
if (b > 0)
v = vector<int>(V.end() - b, V.end());
else
return 0;
} else {
v = vector<int>(V.begin(), V.begin() + a);
if (b > 0)
v.insert(v.end(), V.end() - b, V.end());
}
sort(v.begin(), v.end());
int res = 0;
for (int i = 0; i < a + b; i++) {
if (v.at(i) >= 0) {
res += v.at(i);
} else {
if (i >= k - a - b)
res += v.at(i);
}
}
return res;
}
int main() {
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int r = min(N, K);
int ans = 0;
for (int a = 0; a <= r; a++) {
for (int b = 0; b <= r - a; b++) {
int res = calc(V, a, b, K);
if (ans < res)
ans = res;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,436 | 844,437 | u326609687 | cpp |
p03032 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> v(n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
int ans = 0;
for (int i = 0; i <= min(k, n - 1); i++) {
for (int j = 0; j <= min(k - i, n - 1); j++) {
priority_queue<int, vector<int>, greater<int>> que;
int sum = 0;
for (int l = 0; l < i; l++) {
que.push(v[l]);
sum += v[l];
}
for (int l = n - 1; l > n - 1 - j; l--) {
que.push(v[l]);
sum += v[l];
}
int cnt = 0, tmp;
while (cnt < k - i - j && !que.empty() && (tmp = que.top()) < 0) {
sum -= tmp;
que.pop();
cnt++;
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> v(n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
int ans = 0;
for (int i = 0; i <= min(k, n); i++) {
for (int j = 0; j <= min(k - i, n - i); j++) {
priority_queue<int, vector<int>, greater<int>> que;
int sum = 0;
for (int l = 0; l < i; l++) {
que.push(v[l]);
sum += v[l];
}
for (int l = n - 1; l > n - 1 - j; l--) {
que.push(v[l]);
sum += v[l];
}
int cnt = 0, tmp;
while (cnt < k - i - j && !que.empty() && (tmp = que.top()) < 0) {
sum -= tmp;
que.pop();
cnt++;
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"expression.operation.binary.change"
] | 844,440 | 844,441 | u711985352 | cpp |
p03032 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> v(n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
int ans = 0;
for (int i = 0; i <= min(k, n - 1); i++) {
for (int j = 0; j <= min(k - i, n - 1); j++) {
priority_queue<int, vector<int>, greater<int>> que;
int sum = 0;
for (int l = 0; l < i; l++) {
que.push(v[l]);
sum += v[l];
}
for (int l = n - 1; l > max(n - 1 - j, i - 1); l--) {
que.push(v[l]);
sum += v[l];
}
int cnt = 0, tmp;
while (cnt < k - i - j - 1 && !que.empty() && (tmp = que.top()) < 0) {
sum -= tmp;
que.pop();
cnt++;
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> v(n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
int 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>> que;
int sum = 0;
for (int l = 0; l < i; l++) {
que.push(v[l]);
sum += v[l];
}
for (int l = n - 1; l > max(n - 1 - j, i - 1); l--) {
que.push(v[l]);
sum += v[l];
}
int cnt = 0, tmp;
while (cnt < k - i - j && !que.empty() && (tmp = que.top()) < 0) {
sum -= tmp;
que.pop();
cnt++;
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 844,442 | 844,443 | u711985352 | cpp |
p03033 | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long Int;
typedef pair<Int, Int> P;
typedef pair<Int, P> P2;
const int inf = 2147483647;
struct LazySegTree {
private:
int n;
vector<Int> node, lazy;
vector<bool> lazyflag;
public:
LazySegTree(vector<Int> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1);
lazy.resize(2 * n - 1, inf);
lazyflag.resize(2 * n - 1, false);
for (int i = 0; i < sz; i++)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
void eval(int k, int l, int r) {
if (lazyflag[k]) {
node[k] = lazy[k];
if (r - l > 1) {
lazy[2 * k + 1] = lazy[k];
lazy[2 * k + 2] = lazy[k];
lazyflag[2 * k + 1] = true;
lazyflag[2 * k + 2] = true;
}
lazyflag[k] = false;
}
}
void update(int a, int b, Int x, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
eval(k, l, r);
if (b <= l || r <= a)
return;
if (a <= l && r <= b) {
lazy[k] = x;
lazyflag[k] = true;
eval(k, l, r);
} else {
update(a, b, x, 2 * k + 1, l, (l + r) / 2);
update(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
}
}
Int getmin(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
eval(k, l, r);
if (r <= a || b <= l)
return inf;
if (a <= l && r <= b)
return node[k];
return min(getmin(a, b, 2 * k + 1, l, (l + r) / 2),
getmin(a, b, 2 * k + 2, (l + r) / 2, r));
}
void debug() {
for (int i = 0; i < node.size(); i++)
cout << node[i] << " ";
cout << endl;
for (int i = 0; i < lazy.size(); i++)
cout << lazy[i] << " ";
cout << endl;
}
};
int main() {
int n, q;
cin >> n >> q;
vector<P2> vec;
vector<Int> comp;
for (int i = 0; i < n; i++) {
Int s, t, x;
cin >> s >> t >> x;
comp.push_back(max(s - x, (Int)-1));
comp.push_back(max(t - x, (Int)0));
vec.push_back(P2(x, P(s, t)));
}
comp.push_back(0);
comp.push_back(-1);
comp.push_back(inf);
sort(vec.begin(), vec.end());
sort(comp.begin(), comp.end());
comp.erase(unique(comp.begin(), comp.end()), comp.end());
vector<Int> kv(2 * n + 5, -1);
LazySegTree seg = LazySegTree(kv);
for (int i = vec.size() - 1; i >= 0; i--) {
Int s = max(vec[i].second.first - vec[i].first, (Int)-1);
Int t = max(vec[i].second.second - vec[i].first, (Int)0);
int spos = lower_bound(comp.begin(), comp.end(), s) - comp.begin();
int tpos = lower_bound(comp.begin(), comp.end(), t) - comp.begin();
seg.update(spos, tpos, vec[i].first);
// cout<<spos<<" "<<tpos<<endl;
}
for (int i = 0; i < q; i++) {
int d;
cin >> d;
int pos = lower_bound(comp.begin(), comp.end(), d) - comp.begin();
Int ans = seg.getmin(pos, pos + 1);
// cout<<pos<<" ";
cout << ans << endl;
}
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long Int;
typedef pair<Int, Int> P;
typedef pair<Int, P> P2;
const int inf = 2147483647;
struct LazySegTree {
private:
int n;
vector<Int> node, lazy;
vector<bool> lazyflag;
public:
LazySegTree(vector<Int> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1);
lazy.resize(2 * n - 1, inf);
lazyflag.resize(2 * n - 1, false);
for (int i = 0; i < sz; i++)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
void eval(int k, int l, int r) {
if (lazyflag[k]) {
node[k] = lazy[k];
if (r - l > 1) {
lazy[2 * k + 1] = lazy[k];
lazy[2 * k + 2] = lazy[k];
lazyflag[2 * k + 1] = true;
lazyflag[2 * k + 2] = true;
}
lazyflag[k] = false;
}
}
void update(int a, int b, Int x, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
eval(k, l, r);
if (b <= l || r <= a)
return;
if (a <= l && r <= b) {
lazy[k] = x;
lazyflag[k] = true;
eval(k, l, r);
} else {
update(a, b, x, 2 * k + 1, l, (l + r) / 2);
update(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
}
}
Int getmin(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
eval(k, l, r);
if (r <= a || b <= l)
return inf;
if (a <= l && r <= b)
return node[k];
return min(getmin(a, b, 2 * k + 1, l, (l + r) / 2),
getmin(a, b, 2 * k + 2, (l + r) / 2, r));
}
void debug() {
for (int i = 0; i < node.size(); i++)
cout << node[i] << " ";
cout << endl;
for (int i = 0; i < lazy.size(); i++)
cout << lazy[i] << " ";
cout << endl;
}
};
int main() {
int n, q;
cin >> n >> q;
vector<P2> vec;
vector<Int> comp;
for (int i = 0; i < n; i++) {
Int s, t, x;
cin >> s >> t >> x;
comp.push_back(max(s - x, (Int)-1));
comp.push_back(max(t - x, (Int)0));
vec.push_back(P2(x, P(s, t)));
}
comp.push_back(0);
comp.push_back(-1);
comp.push_back(inf);
sort(vec.begin(), vec.end());
sort(comp.begin(), comp.end());
comp.erase(unique(comp.begin(), comp.end()), comp.end());
// for(int i=0;i<comp.size();i++) cout<<comp[i]<<" ";
// cout<<endl;
vector<Int> kv(2 * n + 50, -1);
LazySegTree seg = LazySegTree(kv);
for (int i = vec.size() - 1; i >= 0; i--) {
Int s = max(vec[i].second.first - vec[i].first, (Int)-1);
Int t = max(vec[i].second.second - vec[i].first, (Int)0);
int spos = lower_bound(comp.begin(), comp.end(), s) - comp.begin();
int tpos = lower_bound(comp.begin(), comp.end(), t) - comp.begin();
seg.update(spos, tpos, vec[i].first);
// cout<<spos<<" "<<tpos<<endl;
}
for (int i = 0; i < q; i++) {
int d;
cin >> d;
int pos = upper_bound(comp.begin(), comp.end(), d) - comp.begin();
pos--;
Int ans = seg.getmin(pos, pos + 1);
// cout<<pos<<" ";
cout << ans << endl;
}
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"identifier.change",
"call.function.change",
"expression.unary.arithmetic.add"
] | 844,490 | 844,491 | u440213743 | cpp |
p03033 | // https://atcoder.jp/contests/abc128/tasks/abc128_e
/*<head>*/
// #include "Template.hpp"
/*</head>*/
/*<body>*/
/* #region header */
/**
* @file Template.hpp
* @brief 競技プログラミング用テンプレート
* @author btk15049
* @date 2019/05/02
*/
#include <bits/stdc++.h>
using namespace std;
/* #region macro */
#ifdef BTK
#define DEBUG if (1)
#define CIN_ONLY if (0)
#else
#define DEBUG if (0)
#define CIN_ONLY if (1)
#endif
/** @def
* ALLマクロ
*/
#define ALL(v) (v).begin(), (v).end()
/** @def
* 再帰ラムダをするためのマクロ
*/
#define REC(ret, ...) std::function<ret(__VA_ARGS__)>
/* #endregion */
namespace _Template_ {
/**
* @brief cin高速化処理を行うための構造体
* @details CIN_ONLYマクロで動作が変わる
*/
struct cww {
cww() {
CIN_ONLY {
ios::sync_with_stdio(false);
cin.tie(0);
}
}
} star;
/**
* @brief change min
* @tparam T 型
* @param l 参照
* @param r 非参照
* @return 更新があればtrue
*/
template <typename T> inline bool chmin(T &l, T r) {
bool a = l > r;
if (a)
l = r;
return a;
}
/**
* @brief chminのmax版
* @see chmin
*/
template <typename T> inline bool chmax(T &l, T r) {
bool a = l < r;
if (a)
l = r;
return a;
}
/**
* @brief
* vectorに直接cin流すためのやつ
* @tparam T
* @param is
* @param v
* @return istream&
*/
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
/**
* @brief
* rangeを逆向きに操作したいとき用
* @details
* ループの範囲は[bg,ed)なので注意
* @see range
*/
class reverse_range {
private:
struct I {
int x;
int operator*() { return x - 1; }
bool operator!=(I &lhs) { return x > lhs.x; }
void operator++() { --x; }
};
I i, n;
public:
reverse_range(int n) : i({0}), n({n}) {}
reverse_range(int i, int n) : i({i}), n({n}) {}
I &begin() { return n; }
I &end() { return i; }
};
/**
* @brief
* python みたいな range-based for を実現
* @details
* ループの範囲は[bg,ed)なので注意
* !つけると逆向きにループが回る (reverse_range)
* 空間計算量はO(1)
* 使わない変数ができて警告が出がちなので，unused_varとかを使って警告消しするとよい
*/
class range {
private:
struct I {
int x;
int operator*() { return x; }
bool operator!=(I &lhs) { return x < lhs.x; }
void operator++() { ++x; }
};
I i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
I &begin() { return i; }
I &end() { return n; }
reverse_range operator!() { return reverse_range(*i, *n); }
};
/**
* @brief
* rangeで生まれる使わない変数を消す用（警告消し）
*/
template <typename T> inline T &unused_var(T &v) { return v; }
using LL = long long;
} // namespace _Template_
using namespace _Template_;
/* #endregion */
/*</body>*/
constexpr int S = 412345;
int s[S];
int t[S];
LL x[S];
LL d[S];
LL ret[S];
inline LL compute_start_time(LL tm, LL ps) {
cerr << ps - tm << " ";
return ps - tm;
}
vector<pair<int, LL>> query[S];
int main() {
int N, Q;
cin >> N >> Q;
for (int i : range(N)) {
cin >> s[i] >> t[i] >> x[i];
}
for (int i : range(Q)) {
cin >> d[i];
d[i] = -d[i];
}
reverse(d, d + Q);
for (int i : range(N)) {
int b = upper_bound(d, d + Q, compute_start_time(t[i], x[i])) - d;
int e = lower_bound(d, d + Q, compute_start_time(s[i], x[i])) - d;
// swap(b,e);
if (b > e)
continue;
query[b].push_back({e, x[i]});
cerr << b << " ";
cerr << e << " ";
cerr << x[i] << "\n";
}
set<pair<LL, int>> ps_min;
set<pair<int, LL>> id_min;
for (int i : range(Q)) {
while (id_min.size() > 0 && id_min.begin()->first <= i) {
auto it = *id_min.begin();
ps_min.erase({it.second, it.first});
id_min.erase(it);
}
for (auto &it : query[i]) {
id_min.insert(it);
ps_min.insert({it.second, it.first});
}
if (ps_min.size()) {
ret[i] = ps_min.begin()->first;
} else {
ret[i] = -1;
}
}
reverse(ret, ret + Q);
for (int i : range(Q))
cout << ret[i] << "\n";
return 0;
} | // https://atcoder.jp/contests/abc128/tasks/abc128_e
/*<head>*/
// #include "Template.hpp"
/*</head>*/
/*<body>*/
/* #region header */
/**
* @file Template.hpp
* @brief 競技プログラミング用テンプレート
* @author btk15049
* @date 2019/05/02
*/
#include <bits/stdc++.h>
using namespace std;
/* #region macro */
#ifdef BTK
#define DEBUG if (1)
#define CIN_ONLY if (0)
#else
#define DEBUG if (0)
#define CIN_ONLY if (1)
#endif
/** @def
* ALLマクロ
*/
#define ALL(v) (v).begin(), (v).end()
/** @def
* 再帰ラムダをするためのマクロ
*/
#define REC(ret, ...) std::function<ret(__VA_ARGS__)>
/* #endregion */
namespace _Template_ {
/**
* @brief cin高速化処理を行うための構造体
* @details CIN_ONLYマクロで動作が変わる
*/
struct cww {
cww() {
CIN_ONLY {
ios::sync_with_stdio(false);
cin.tie(0);
}
}
} star;
/**
* @brief change min
* @tparam T 型
* @param l 参照
* @param r 非参照
* @return 更新があればtrue
*/
template <typename T> inline bool chmin(T &l, T r) {
bool a = l > r;
if (a)
l = r;
return a;
}
/**
* @brief chminのmax版
* @see chmin
*/
template <typename T> inline bool chmax(T &l, T r) {
bool a = l < r;
if (a)
l = r;
return a;
}
/**
* @brief
* vectorに直接cin流すためのやつ
* @tparam T
* @param is
* @param v
* @return istream&
*/
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
/**
* @brief
* rangeを逆向きに操作したいとき用
* @details
* ループの範囲は[bg,ed)なので注意
* @see range
*/
class reverse_range {
private:
struct I {
int x;
int operator*() { return x - 1; }
bool operator!=(I &lhs) { return x > lhs.x; }
void operator++() { --x; }
};
I i, n;
public:
reverse_range(int n) : i({0}), n({n}) {}
reverse_range(int i, int n) : i({i}), n({n}) {}
I &begin() { return n; }
I &end() { return i; }
};
/**
* @brief
* python みたいな range-based for を実現
* @details
* ループの範囲は[bg,ed)なので注意
* !つけると逆向きにループが回る (reverse_range)
* 空間計算量はO(1)
* 使わない変数ができて警告が出がちなので，unused_varとかを使って警告消しするとよい
*/
class range {
private:
struct I {
int x;
int operator*() { return x; }
bool operator!=(I &lhs) { return x < lhs.x; }
void operator++() { ++x; }
};
I i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
I &begin() { return i; }
I &end() { return n; }
reverse_range operator!() { return reverse_range(*i, *n); }
};
/**
* @brief
* rangeで生まれる使わない変数を消す用（警告消し）
*/
template <typename T> inline T &unused_var(T &v) { return v; }
using LL = long long;
} // namespace _Template_
using namespace _Template_;
/* #endregion */
/*</body>*/
constexpr int S = 412345;
int s[S];
int t[S];
LL x[S];
LL d[S];
LL ret[S];
inline LL compute_start_time(LL tm, LL ps) {
cerr << ps - tm << " ";
return ps - tm;
}
vector<pair<int, LL>> query[S];
int main() {
int N, Q;
cin >> N >> Q;
for (int i : range(N)) {
cin >> s[i] >> t[i] >> x[i];
}
for (int i : range(Q)) {
cin >> d[i];
d[i] = -d[i];
}
reverse(d, d + Q);
for (int i : range(N)) {
int b = upper_bound(d, d + Q, compute_start_time(t[i], x[i])) - d; // OK
int e = upper_bound(d, d + Q, compute_start_time(s[i], x[i])) - d; // NG
// swap(b,e);
if (b >= e)
continue;
query[b].push_back({e, x[i]});
cerr << b << " ";
cerr << e << " ";
cerr << x[i] << "\n";
}
set<pair<LL, int>> ps_min;
set<pair<int, LL>> id_min;
for (int i : range(Q)) {
while (id_min.size() > 0 && id_min.begin()->first <= i) {
auto it = *id_min.begin();
ps_min.erase({it.second, it.first});
id_min.erase(it);
}
for (auto &it : query[i]) {
id_min.insert(it);
ps_min.insert({it.second, it.first});
}
if (ps_min.size()) {
ret[i] = ps_min.begin()->first;
} else {
ret[i] = -1;
}
}
reverse(ret, ret + Q);
for (int i : range(Q))
cout << ret[i] << "\n";
return 0;
} | [
"identifier.change",
"call.function.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,511 | 844,512 | u613658617 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define ll long long
#define P pair<int, int>
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define LAST(x) (x)[(x).size() - 1]
#define GI(name) \
int(name); \
scanf("%d", &(name))
#define GI2(name1, name2) \
int(name1), (name2); \
scanf("%d %d", &(name1), &(name2))
#define GI3(name1, name2, name3) \
int(name1), (name2), (name3); \
scanf("%d %d %d", &(name1), &(name2), &(name3))
#define GVI(name, size) \
vector<int>(name)(size); \
FOR(i, (size)) scanf("%d", &(name)[i])
#define GS(name) \
string(name); \
cin >> (name);
#define MOD 1000000007
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
FOR(i, v.size() - 1) { ret += to_string(v[i]) + ","; }
if (v.size() > 0) {
ret += to_string(LAST(v));
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
int main() {
GI2(N, K);
vector<ll> V(N);
FOR(i, N) { cin >> V[i]; }
ll ans = 0LL;
for (int l = 0; l <= min(N, K); ++l) {
vector<ll> vl(l, 0);
for (int x = 0; x < l; ++x)
vl[x] = V[x];
for (int r = 0; r <= min(N, K - l); ++r) {
if (l + r == 0)
continue;
vector<ll> vr(r, 0);
for (int x = 0; x < r; ++x)
vr[x] = V[N - 1 - x];
if (l > 0)
vr.insert(vr.begin(), vl.begin(), vl.end());
sort(ALL(vr));
int bound = upper_bound(ALL(vr), 0LL) - vr.begin();
bound = min(bound, K - l - r);
ll s = accumulate(vr.begin() + bound, vr.end(), 0LL);
if (ans < s)
ans = s;
}
}
print(ans);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define ll long long
#define P pair<int, int>
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define LAST(x) (x)[(x).size() - 1]
#define GI(name) \
int(name); \
scanf("%d", &(name))
#define GI2(name1, name2) \
int(name1), (name2); \
scanf("%d %d", &(name1), &(name2))
#define GI3(name1, name2, name3) \
int(name1), (name2), (name3); \
scanf("%d %d %d", &(name1), &(name2), &(name3))
#define GVI(name, size) \
vector<int>(name)(size); \
FOR(i, (size)) scanf("%d", &(name)[i])
#define GS(name) \
string(name); \
cin >> (name);
#define MOD 1000000007
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
FOR(i, v.size() - 1) { ret += to_string(v[i]) + ","; }
if (v.size() > 0) {
ret += to_string(LAST(v));
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
int main() {
GI2(N, K);
vector<ll> V(N);
FOR(i, N) { cin >> V[i]; }
ll ans = 0LL;
for (int l = 0; l <= min(N, K); ++l) {
vector<ll> vl(l, 0);
for (int x = 0; x < l; ++x)
vl[x] = V[x];
for (int r = 0; r <= min(N - l, K - l); ++r) {
if (l + r == 0)
continue;
vector<ll> vr(r, 0);
for (int x = 0; x < r; ++x)
vr[x] = V[N - 1 - x];
if (l > 0)
vr.insert(vr.begin(), vl.begin(), vl.end());
sort(ALL(vr));
int bound = upper_bound(ALL(vr), 0LL) - vr.begin();
bound = min(bound, K - l - r);
ll s = accumulate(vr.begin() + bound, vr.end(), 0LL);
if (ans < s)
ans = s;
}
}
print(ans);
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 844,534 | 844,535 | u656771711 | cpp |
p03032 | #include <bits/stdc++.h>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
// template<typename key, typename val>
// using ordered_tree =
// tree<key, val, greater<>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int64;
typedef complex<double> comp;
const double pi = 3.14159265358979323846;
const int inf = (int)1e+9 + 2;
const int64 inf64 = (int64)1e+18 + 2;
const double dinf = 1e+20;
const int mod = 1'000'000'007; // 998244353;
const int base = 2187;
const double eps = 1e-8;
const int N = 1 << 16;
const int LOGN = 19;
int n, m, k;
int a[50];
void solve(int test) {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> c;
int64 ans = 0;
for (int i = 0; i <= k; ++i) {
for (int l = 0; l <= i; ++l) {
int r = i - l;
priority_queue<int, vector<int>, greater<int>> q(greater<int>(), c);
for (int j = 0; j < l; ++j) {
q.push(a[j]);
}
for (int j = 0; j < r; ++j) {
q.push(a[n - 1 - j]);
}
for (int j = 0; j < k - i && !q.empty() && q.top() < 0; ++j) {
q.pop();
}
int64 mx = 0;
while (!q.empty()) {
mx += q.top();
q.pop();
}
ans = max(ans, mx);
}
}
cout << ans << '\n';
}
void precalc() {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
precalc();
int test = 1;
// cin >> test;
// auto start = chrono::high_resolution_clock::now();
for (int i = 1; i <= test; ++i)
solve(i);
// cerr <<
// chrono::duration_cast<chrono::milliseconds>(chrono::high_resolution_clock::now()
// - start).count() << '\n';
return 0;
}
| #include <bits/stdc++.h>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
// template<typename key, typename val>
// using ordered_tree =
// tree<key, val, greater<>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int64;
typedef complex<double> comp;
const double pi = 3.14159265358979323846;
const int inf = (int)1e+9 + 2;
const int64 inf64 = (int64)1e+18 + 2;
const double dinf = 1e+20;
const int mod = 1'000'000'007; // 998244353;
const int base = 2187;
const double eps = 1e-8;
const int N = 1 << 16;
const int LOGN = 19;
int n, m, k;
int a[50];
void solve(int test) {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> c;
int64 ans = 0;
for (int i = 0; i <= min(n, k); ++i) {
for (int l = 0; l <= i; ++l) {
int r = i - l;
priority_queue<int, vector<int>, greater<int>> q(greater<int>(), c);
for (int j = 0; j < l; ++j) {
q.push(a[j]);
}
for (int j = 0; j < r; ++j) {
q.push(a[n - 1 - j]);
}
for (int j = 0; j < k - i && !q.empty() && q.top() < 0; ++j) {
q.pop();
}
int64 mx = 0;
while (!q.empty()) {
mx += q.top();
q.pop();
}
ans = max(ans, mx);
}
}
cout << ans << '\n';
}
void precalc() {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
precalc();
int test = 1;
// cin >> test;
// auto start = chrono::high_resolution_clock::now();
for (int i = 1; i <= test; ++i)
solve(i);
// cerr <<
// chrono::duration_cast<chrono::milliseconds>(chrono::high_resolution_clock::now()
// - start).count() << '\n';
return 0;
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 844,541 | 844,542 | u432090061 | cpp |
p03032 | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define sqr(x) (x) * (x)
#include <algorithm>
#include <functional>
#include <bitset>
#include <functional>
#include <chrono>
typedef unsigned int u32;
typedef int i32;
typedef unsigned long long int u64;
typedef long long int i64;
typedef uint16_t u16;
typedef int16_t i16;
typedef uint8_t u8;
typedef int8_t i8;
using namespace std;
using namespace std::chrono;
struct less_key {
bool operator()(pair<i64, i64> p1, pair<i64, i64> p2) {
return p1.first > p2.first ||
(p1.first == p2.first && p1.second < p2.second);
}
};
struct pair_hash {
public:
std::size_t operator()(const std::pair<u64, u64> &x) const {
return std::hash<u64>()(x.first) ^ std::hash<u64>()(x.second);
}
};
#include <random>
const i64 mod = 1000000007ll;
const i64 smod = 998244353ll;
const i64 inf = 10000000000000007ll;
const double eps = 1e-10;
// del
const i64 MAXN = 100005;
i64 n, k;
i64 a[MAXN];
i64 check(i64 l, i64 r, list<i64> q) {
vector<i64> e;
for (i64 i = 0; i < l; i++) {
if (!q.empty()) {
e.push_back(q.front());
q.pop_front();
}
}
for (i64 i = 0; i < r; i++) {
if (!q.empty()) {
e.push_back(q.back());
q.pop_back();
}
}
sort(e.begin(), e.end());
i64 R = 0;
for (auto t : e) {
R += t;
}
for (i64 i = 0; i < min((i64)e.size(), max(0ll, k - (l + r))); i++) {
if (e[i] >= 0) {
break;
}
R -= e[i];
}
return R;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
cout.setf(ios::fixed);
cin >> n >> k;
list<i64> q;
for (i64 i = 0; i < n; i++) {
i64 t;
cin >> t;
q.push_back(t);
}
i64 R = 0;
for (i64 i = 0; i <= k; i++) {
for (i64 j = 0; j <= k; j++) {
R = max(R, check(i, j, q));
}
}
cout << R;
return 0;
} | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define sqr(x) (x) * (x)
#include <algorithm>
#include <functional>
#include <bitset>
#include <functional>
#include <chrono>
typedef unsigned int u32;
typedef int i32;
typedef unsigned long long int u64;
typedef long long int i64;
typedef uint16_t u16;
typedef int16_t i16;
typedef uint8_t u8;
typedef int8_t i8;
using namespace std;
using namespace std::chrono;
struct less_key {
bool operator()(pair<i64, i64> p1, pair<i64, i64> p2) {
return p1.first > p2.first ||
(p1.first == p2.first && p1.second < p2.second);
}
};
struct pair_hash {
public:
std::size_t operator()(const std::pair<u64, u64> &x) const {
return std::hash<u64>()(x.first) ^ std::hash<u64>()(x.second);
}
};
#include <random>
const i64 mod = 1000000007ll;
const i64 smod = 998244353ll;
const i64 inf = 10000000000000007ll;
const double eps = 1e-10;
// del
const i64 MAXN = 100005;
i64 n, k;
i64 a[MAXN];
i64 check(i64 l, i64 r, list<i64> q) {
vector<i64> e;
for (i64 i = 0; i < l; i++) {
if (!q.empty()) {
e.push_back(q.front());
q.pop_front();
}
}
for (i64 i = 0; i < r; i++) {
if (!q.empty()) {
e.push_back(q.back());
q.pop_back();
}
}
sort(e.begin(), e.end());
i64 R = 0;
for (auto t : e) {
R += t;
}
for (i64 i = 0; i < min((i64)e.size(), max(0ll, k - (l + r))); i++) {
if (e[i] >= 0) {
break;
}
R -= e[i];
}
return R;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
cout.setf(ios::fixed);
cin >> n >> k;
list<i64> q;
for (i64 i = 0; i < n; i++) {
i64 t;
cin >> t;
q.push_back(t);
}
i64 R = 0;
for (i64 i = 0; i <= k; i++) {
for (i64 j = 0; j <= (k - i); j++) {
R = max(R, check(i, j, q));
}
}
cout << R;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 844,543 | 844,544 | u462405902 | cpp |
p03032 | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define sqr(x) (x) * (x)
#include <algorithm>
#include <functional>
#include <bitset>
#include <functional>
#include <chrono>
typedef unsigned int u32;
typedef int i32;
typedef unsigned long long int u64;
typedef long long int i64;
typedef uint16_t u16;
typedef int16_t i16;
typedef uint8_t u8;
typedef int8_t i8;
using namespace std;
using namespace std::chrono;
struct less_key {
bool operator()(pair<i64, i64> p1, pair<i64, i64> p2) {
return p1.first > p2.first ||
(p1.first == p2.first && p1.second < p2.second);
}
};
struct pair_hash {
public:
std::size_t operator()(const std::pair<u64, u64> &x) const {
return std::hash<u64>()(x.first) ^ std::hash<u64>()(x.second);
}
};
#include <random>
const i64 mod = 1000000007ll;
const i64 smod = 998244353ll;
const i64 inf = 10000000000000007ll;
const double eps = 1e-10;
// del
const i64 MAXN = 100005;
i64 n, k;
i64 a[MAXN];
i64 check(i64 l, i64 r, list<i64> q) {
vector<i64> e;
for (i64 i = 0; i < l; i++) {
if (!q.empty()) {
e.push_back(q.front());
q.pop_front();
}
}
for (i64 i = 0; i < r; i++) {
if (!q.empty()) {
e.push_back(q.back());
q.pop_back();
}
}
sort(e.begin(), e.end());
i64 R = 0;
for (auto t : e) {
R += t;
}
for (i64 i = 0; i < min((i64)e.size(), max(0ll, k - (l + r))); i++) {
if (e[i] >= 0) {
break;
}
R -= e[i];
}
return R;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
cout.setf(ios::fixed);
cin >> n >> k;
list<i64> q;
for (i64 i = 0; i < n; i++) {
i64 t;
cin >> t;
q.push_back(t);
}
i64 R = 0;
for (i64 i = 0; i < k; i++) {
for (i64 j = 0; j < k; j++) {
R = max(R, check(i, j, q));
}
}
cout << R;
return 0;
} | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define sqr(x) (x) * (x)
#include <algorithm>
#include <functional>
#include <bitset>
#include <functional>
#include <chrono>
typedef unsigned int u32;
typedef int i32;
typedef unsigned long long int u64;
typedef long long int i64;
typedef uint16_t u16;
typedef int16_t i16;
typedef uint8_t u8;
typedef int8_t i8;
using namespace std;
using namespace std::chrono;
struct less_key {
bool operator()(pair<i64, i64> p1, pair<i64, i64> p2) {
return p1.first > p2.first ||
(p1.first == p2.first && p1.second < p2.second);
}
};
struct pair_hash {
public:
std::size_t operator()(const std::pair<u64, u64> &x) const {
return std::hash<u64>()(x.first) ^ std::hash<u64>()(x.second);
}
};
#include <random>
const i64 mod = 1000000007ll;
const i64 smod = 998244353ll;
const i64 inf = 10000000000000007ll;
const double eps = 1e-10;
// del
const i64 MAXN = 100005;
i64 n, k;
i64 a[MAXN];
i64 check(i64 l, i64 r, list<i64> q) {
vector<i64> e;
for (i64 i = 0; i < l; i++) {
if (!q.empty()) {
e.push_back(q.front());
q.pop_front();
}
}
for (i64 i = 0; i < r; i++) {
if (!q.empty()) {
e.push_back(q.back());
q.pop_back();
}
}
sort(e.begin(), e.end());
i64 R = 0;
for (auto t : e) {
R += t;
}
for (i64 i = 0; i < min((i64)e.size(), max(0ll, k - (l + r))); i++) {
if (e[i] >= 0) {
break;
}
R -= e[i];
}
return R;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
cout.setf(ios::fixed);
cin >> n >> k;
list<i64> q;
for (i64 i = 0; i < n; i++) {
i64 t;
cin >> t;
q.push_back(t);
}
i64 R = 0;
for (i64 i = 0; i <= k; i++) {
for (i64 j = 0; j <= (k - i); j++) {
R = max(R, check(i, j, q));
}
}
cout << R;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,545 | 844,544 | u462405902 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V(N);
int ans = 0;
int term = 0;
for (int i = 0; i < N; i++) {
cin >> V[i];
}
for (int i = 0; i < min(N, K); i++) {
for (int j = 0; j < min(N, K) - i; j++) {
term = 0;
vector<int> tmp(i + j, 0);
for (int k = 0; k < i; k++) {
term += V[k];
tmp[k] = V[k];
}
for (int k = 0; k < j; k++) {
term += V[N - k - 1];
tmp[i + k] = V[N - k - 1];
}
sort(tmp.begin(), tmp.end());
for (int k = 0; k < min(i + j, K - i - j); k++) {
if (tmp[k] < 0) {
term += abs(tmp[k]);
}
}
ans = max(ans, term);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V(N);
int ans = 0;
int term = 0;
for (int i = 0; i < N; i++) {
cin >> V[i];
}
for (int i = 0; i <= min(N, K); i++) {
for (int j = 0; j <= min(N, K) - i; j++) {
term = 0;
vector<int> tmp(i + j, 0);
for (int k = 0; k < i; k++) {
term += V[k];
tmp[k] = V[k];
}
for (int k = 0; k < j; k++) {
term += V[N - k - 1];
tmp[i + k] = V[N - k - 1];
}
sort(tmp.begin(), tmp.end());
for (int k = 0; k < min(i + j, K - i - j); k++) {
if (tmp[k] < 0) {
term += abs(tmp[k]);
}
}
ans = max(ans, term);
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,555 | 844,556 | u912534104 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, limit;
cin >> n >> limit;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int ret = 0;
for (int i = 0; i < min(limit, n); i++) {
for (int j = 0; j <= i; j++) {
vector<int> now;
for (int k = 0; k < j; k++)
now.push_back(v[k]);
for (int k = 0; k < i - j; k++)
now.push_back(v[n - 1 - k]);
sort(now.begin(), now.end());
int nowsum = 0;
for (int k = 0; k < now.size(); k++) {
if (k < limit - i && now[k] < 0)
continue;
nowsum += now[k];
}
ret = max(ret, nowsum);
}
}
cout << ret << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, limit;
cin >> n >> limit;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int ret = 0;
for (int i = 0; i <= min(limit, n); i++) {
for (int j = 0; j <= i; j++) {
vector<int> now;
for (int k = 0; k < j; k++)
now.push_back(v[k]);
for (int k = 0; k < i - j; k++)
now.push_back(v[n - 1 - k]);
sort(now.begin(), now.end());
int nowsum = 0;
for (int k = 0; k < now.size(); k++) {
if (k < limit - i && now[k] < 0)
continue;
nowsum += now[k];
}
ret = max(ret, nowsum);
}
}
cout << ret << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,559 | 844,560 | u412908746 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define REP(var, n) for (int var = 0; var < (n); var++)
#define RREP(var, n) for (auto var = n - 1; var != static_cast<int>(-1); var--)
#define FOR(var, a, b) for (auto var = (a); var < (b); var++)
#define RFOR(var, a, b) for (auto var = b - 1; var != a; var--)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
#define all(c) begin(c), end(c)
#define D(x) \
do { \
std::cerr << x << " "; \
} while (0)
#define D2(x) \
do { \
std::cerr << #x << ": " << x << std::endl; \
} while (0)
template <typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
if (!v.empty()) {
out << '[';
std::copy(v.begin(), v.end(), std::ostream_iterator<T>(out, ", "));
out << "\b\b]";
}
return out;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
int MOD = (int)1e9 + 7;
auto solve() {
int N, K;
cin >> N >> K;
vi V(N);
REP(i, N) cin >> V[i];
int ans = 0;
REP(i, K) {
REP(j, K) {
REP(t, K) {
if (i + j + t > K)
continue;
if (i + j > N)
continue;
int pos = 0;
vi neg;
REP(u, i) {
if (V[u] >= 0)
pos += V[u];
else
neg.push_back(-1 * V[u]);
}
REP(_u, j) {
int u = N - _u - 1;
if (V[u] >= 0)
pos += V[u];
else
neg.push_back(-1 * V[u]);
}
int tneg = 0;
sort(all(neg));
reverse(all(neg));
FOR(u, min(t, (int)neg.size()), (int)neg.size()) { tneg += neg[u]; }
chmax(ans, pos - tneg);
}
}
}
return ans;
}
int main() {
cout.precision(30);
cin.tie(0);
ios::sync_with_stdio(false);
cout << solve() << endl;
// solve();
// cout << (solve() ? "Yes" : "No") << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(var, n) for (int var = 0; var < (n); var++)
#define RREP(var, n) for (auto var = n - 1; var != static_cast<int>(-1); var--)
#define FOR(var, a, b) for (auto var = (a); var < (b); var++)
#define RFOR(var, a, b) for (auto var = b - 1; var != a; var--)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
#define all(c) begin(c), end(c)
#define D(x) \
do { \
std::cerr << x << " "; \
} while (0)
#define D2(x) \
do { \
std::cerr << #x << ": " << x << std::endl; \
} while (0)
template <typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
if (!v.empty()) {
out << '[';
std::copy(v.begin(), v.end(), std::ostream_iterator<T>(out, ", "));
out << "\b\b]";
}
return out;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
int MOD = (int)1e9 + 7;
auto solve() {
int N, K;
cin >> N >> K;
vi V(N);
REP(i, N) cin >> V[i];
int ans = 0;
REP(i, K + 1) {
REP(j, K + 1) {
REP(t, K + 1) {
if (i + j + t > K)
continue;
if (i + j > N)
continue;
int pos = 0;
vi neg;
REP(u, i) {
if (V[u] >= 0)
pos += V[u];
else
neg.push_back(-1 * V[u]);
}
REP(_u, j) {
int u = N - _u - 1;
if (V[u] >= 0)
pos += V[u];
else
neg.push_back(-1 * V[u]);
}
int tneg = 0;
sort(all(neg));
reverse(all(neg));
FOR(u, min(t, (int)neg.size()), (int)neg.size()) { tneg += neg[u]; }
chmax(ans, pos - tneg);
}
}
}
return ans;
}
int main() {
cout.precision(30);
cin.tie(0);
ios::sync_with_stdio(false);
cout << solve() << endl;
// solve();
// cout << (solve() ? "Yes" : "No") << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 844,569 | 844,570 | u249955257 | cpp |
p03032 | #include <bits/stdc++.h>
/// TONI BO$$ was here
/// #MLC
using namespace std;
int v[102];
int main() {
int n, k, i, rez, a, b, sum, kaux;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++)
scanf("%d", &v[i]);
rez = INT_MIN;
for (a = 0; a <= n; a++)
for (b = 0; b <= n && a + b <= k && n + 1 - b > a; b++) {
vector<int> aux;
sum = 0;
for (i = 0; i <= a; i++) {
sum += v[i];
if (i > 0)
aux.push_back(v[i]);
}
for (i = 0; i <= b; i++) {
sum += v[n + 1 - i];
if (i > 0)
aux.push_back(v[n + 1 - i]);
}
kaux = k - a - b;
sort(aux.begin(), aux.end());
for (auto it : aux) {
if (!kaux)
break;
sum -= it;
kaux--;
}
rez = max(rez, sum);
}
printf("%d", rez);
return 0;
}
| #include <bits/stdc++.h>
/// TONI BO$$ was here
/// #MLC
using namespace std;
int v[102];
int main() {
int n, k, i, rez, a, b, sum, kaux;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++)
scanf("%d", &v[i]);
rez = INT_MIN;
for (a = 0; a <= n; a++)
for (b = 0; b <= n && a + b <= k && n + 1 - b > a; b++) {
vector<int> aux;
sum = 0;
for (i = 0; i <= a; i++) {
sum += v[i];
if (i > 0)
aux.push_back(v[i]);
}
for (i = 0; i <= b; i++) {
sum += v[n + 1 - i];
if (i > 0)
aux.push_back(v[n + 1 - i]);
}
kaux = k - a - b;
sort(aux.begin(), aux.end());
for (auto it : aux) {
if (!kaux || it > 0)
break;
sum -= it;
kaux--;
}
rez = max(rez, sum);
}
printf("%d", rez);
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,575 | 844,576 | u503211001 | cpp |
p03032 | #include <bits/stdc++.h>
#ifdef NON_SUBMIT
#define TEST(n) (n)
#define tout cerr
#else
#define TEST(n) ((void)0)
#define tout cin
#endif
using namespace std;
vector<int> A;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
TEST(freopen("input.txt", "r", stdin));
TEST(freopen("output.txt", "w", stdout));
TEST(freopen("debug.txt", "w", stderr));
int N, K, ans = 0;
cin >> N >> K;
A.resize(N);
for (auto &a : A)
cin >> a;
for (int i = 1; i <= min(N, K); i++)
for (int j = 0; j <= i; j++) {
set<int> t;
int v = K - i, sum = 0;
for (int k = 0; k < j; k++)
t.insert(A[k]);
for (int k = 0; k < i - j; k++)
t.insert(A[N - 1 - k]);
while (v && t.size() && *t.begin() < 0) {
t.erase(t.begin());
v--;
}
for (auto a : t)
sum += a;
ans = max(ans, sum);
}
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
#ifdef NON_SUBMIT
#define TEST(n) (n)
#define tout cerr
#else
#define TEST(n) ((void)0)
#define tout cin
#endif
using namespace std;
vector<int> A;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
TEST(freopen("input.txt", "r", stdin));
TEST(freopen("output.txt", "w", stdout));
TEST(freopen("debug.txt", "w", stderr));
int N, K, ans = 0;
cin >> N >> K;
A.resize(N);
for (auto &a : A)
cin >> a;
for (int i = 1; i <= min(N, K); i++)
for (int j = 0; j <= i; j++) {
multiset<int> t;
int v = K - i, sum = 0;
for (int k = 0; k < j; k++)
t.insert(A[k]);
for (int k = 0; k < i - j; k++)
t.insert(A[N - 1 - k]);
while (v && t.size() && *t.begin() < 0) {
t.erase(t.begin());
v--;
}
for (auto a : t)
sum += a;
ans = max(ans, sum);
}
cout << ans << '\n';
return 0;
} | [
"variable_declaration.type.change"
] | 844,577 | 844,578 | u548859367 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define REV(i, n) for (ll(i) = (n)-1; (i) >= 0; --i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) \
{ \
REP(WW, n) cerr << v[WW] << ' '; \
cerr << endl << endl; \
}
#define SHOW2d(v, WW, HH) \
{ \
REP(W_, WW) { \
REP(H_, HH) cerr << v[W_][H_] << ' '; \
cerr << endl; \
} \
cerr << endl; \
}
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 998244353
typedef long long ll;
typedef pair<ll, ll> P;
vector<ll> v;
ll dp[55][55][111];
ll n, k;
ll dfs(ll l, ll r, ll cou) {
if (l > l)
return 0;
if (cou > k)
return -LLINF;
if (dp[l][r][cou] != -LLINF)
return dp[l][r][cou];
ll ret = 0;
ret = max(ret, dfs(l + 1, r, cou + 1) + v[l]);
ret = max(ret, dfs(l + 1, r, cou + 2));
ret = max(ret, dfs(l, r - 1, cou + 1) + v[r]);
ret = max(ret, dfs(l, r - 1, cou + 2));
return dp[l][r][cou] = ret;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
REP(i, 55) REP(j, 55) REP(k, 111) dp[i][j][k] = -LLINF;
cin >> n >> k;
REP(i, n) {
int tmp;
cin >> tmp;
v.PB(tmp);
}
cout << dfs(0, n - 1, 0) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define REV(i, n) for (ll(i) = (n)-1; (i) >= 0; --i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) \
{ \
REP(WW, n) cerr << v[WW] << ' '; \
cerr << endl << endl; \
}
#define SHOW2d(v, WW, HH) \
{ \
REP(W_, WW) { \
REP(H_, HH) cerr << v[W_][H_] << ' '; \
cerr << endl; \
} \
cerr << endl; \
}
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 998244353
typedef long long ll;
typedef pair<ll, ll> P;
vector<ll> v;
ll dp[55][55][111];
ll n, k;
ll dfs(ll l, ll r, ll cou) {
if (l > r || cou == k)
return 0;
if (cou > k)
return -LLINF;
if (dp[l][r][cou] != -LLINF)
return dp[l][r][cou];
ll ret = 0;
ret = max(ret, dfs(l + 1, r, cou + 1) + v[l]);
ret = max(ret, dfs(l + 1, r, cou + 2));
ret = max(ret, dfs(l, r - 1, cou + 1) + v[r]);
ret = max(ret, dfs(l, r - 1, cou + 2));
return dp[l][r][cou] = ret;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
REP(i, 55) REP(j, 55) REP(k, 111) dp[i][j][k] = -LLINF;
cin >> n >> k;
REP(i, n) {
int tmp;
cin >> tmp;
v.PB(tmp);
}
cout << dfs(0, n - 1, 0) << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 844,585 | 844,586 | u382880969 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int n, k;
int v[50];
void take_input() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i != n; ++i)
cin >> v[i];
}
int simulate(int l, int r) {
if (l > n || r > n)
return 0;
vector<int> tmp;
for (int i = 0; i != l; ++i)
tmp.push_back(v[i]);
for (int i = 0; i != r; ++i)
tmp.push_back(v[n - i - 1]);
sort(tmp.begin(), tmp.end());
int i = 0;
while (i != tmp.size() && tmp[i] < 0 && i != k - l - r)
++i;
int ret = 0;
while (i != tmp.size())
ret += tmp[i++];
return ret;
}
void solve() {
int ans = 0;
for (int i = 0; i <= k; ++i)
for (int j = 0; j + i <= k; ++j)
ans = max(ans, simulate(i, j));
cout << ans << '\n';
}
int main() {
take_input();
solve();
} | #include <bits/stdc++.h>
using namespace std;
int n, k;
int v[50];
void take_input() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i != n; ++i)
cin >> v[i];
}
int simulate(int l, int r) {
if (l + r > n)
return 0;
vector<int> tmp;
for (int i = 0; i != l; ++i)
tmp.push_back(v[i]);
for (int i = 0; i != r; ++i)
tmp.push_back(v[n - i - 1]);
sort(tmp.begin(), tmp.end());
int i = 0;
while (i != tmp.size() && tmp[i] < 0 && i != k - l - r)
++i;
int ret = 0;
while (i != tmp.size())
ret += tmp[i++];
return ret;
}
void solve() {
int ans = 0;
for (int i = 0; i <= k; ++i)
for (int j = 0; j + i <= k; ++j)
ans = max(ans, simulate(i, j));
cout << ans << '\n';
}
int main() {
take_input();
solve();
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 844,587 | 844,588 | u776338097 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define all(x) begin(x), end(x)
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vi a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<vi> prefs(n + 1), suffs(n + 1);
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j <= n; ++j) {
prefs[j].push_back(a[i]);
}
for (int j = n - i; j <= n; ++j) {
suffs[j].push_back(a[i]);
}
}
for (int i = 0; i <= n; ++i) {
sort(all(prefs[i]));
sort(all(suffs[i]));
}
// left[i][j] best score you can get by taking i from the left and dropping j
vector<vi> lefts(n + 1, vi(k + 1, 0));
vector<vi> rights(n + 1, vi(k + 1, 0));
for (int i = 1; i <= n; ++i) {
for (int x : prefs[i])
lefts[i][0] += x;
for (int x : suffs[i])
rights[i][0] += x;
for (int j = 1; j <= k; ++j) {
if (j - 1 < prefs[i].size() and prefs[i][j - 1] < 0) {
lefts[i][j] = lefts[i][j - 1] - prefs[i][j - 1];
} else {
lefts[i][j] = lefts[i][j - 1];
}
if (j - 1 < suffs[i].size() and suffs[i][j - 1] < 0) {
rights[i][j] = rights[i][j - 1] - suffs[i][j - 1];
} else {
rights[i][j] = rights[i][j - 1];
}
}
}
int ans = 0;
for (int drop = 0; drop <= n; ++drop) {
int take = k - drop;
if (take < drop)
break;
for (int l = 0; l <= take; ++l) {
int r = take - l;
for (int dl = 0; dl <= drop; ++dl) {
int dr = drop - dl;
ans = max(ans, lefts[l][dl] + rights[r][dr]);
}
}
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define all(x) begin(x), end(x)
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vi a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<vi> prefs(n + 1), suffs(n + 1);
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j <= n; ++j) {
prefs[j].push_back(a[i]);
}
for (int j = n - i; j <= n; ++j) {
suffs[j].push_back(a[i]);
}
}
for (int i = 0; i <= n; ++i) {
sort(all(prefs[i]));
sort(all(suffs[i]));
}
// left[i][j] best score you can get by taking i from the left and dropping j
vector<vi> lefts(n + 1, vi(k + 1, 0));
vector<vi> rights(n + 1, vi(k + 1, 0));
for (int i = 1; i <= n; ++i) {
for (int x : prefs[i])
lefts[i][0] += x;
for (int x : suffs[i])
rights[i][0] += x;
for (int j = 1; j <= k; ++j) {
if (j - 1 < prefs[i].size() and prefs[i][j - 1] < 0) {
lefts[i][j] = lefts[i][j - 1] - prefs[i][j - 1];
} else {
lefts[i][j] = lefts[i][j - 1];
}
if (j - 1 < suffs[i].size() and suffs[i][j - 1] < 0) {
rights[i][j] = rights[i][j - 1] - suffs[i][j - 1];
} else {
rights[i][j] = rights[i][j - 1];
}
}
}
int ans = 0;
for (int drop = 0; drop <= n; ++drop) {
int take = min(n, k - drop);
if (take < drop)
break;
for (int l = 0; l <= take; ++l) {
int r = take - l;
for (int dl = 0; dl <= drop; ++dl) {
int dr = drop - dl;
ans = max(ans, lefts[l][dl] + rights[r][dr]);
}
}
}
cout << ans << '\n';
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 844,589 | 844,590 | u906129425 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define fore(x, c) for (auto &&x : c)
#define rep(i, a, n) for (int i = a, i##len = (int)(n); i < i##len; ++i)
#define rrep(i, a, n) for (int i = (int)(n - 1); i >= a; --i)
#define sz(c) ((int)c.size())
#define contains(c, x) (c.find(x) != end(c))
#define inseg(l, x, r) ((l) <= (x) && (x) < (r))
#define dump(...)
#define pb push_back
#define _ 0
const signed INF_ = 1001001001;
const long long INF = 1001001001001001001LL;
const int DX[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
DY[9] = {-1, 0, 1, 0, -1, 1, 1, -1, 0};
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto i = begin(v); i != end(v); i++)
os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto i = begin(v); i != end(v); i++)
is >> *i;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T, class U> bool chmax(T &a, const U &b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U> bool chmin(T &a, const U &b) {
return a > b ? a = b, 1 : 0;
}
template <class T> void psum(T &c) { partial_sum(begin(c), end(c), begin(c)); }
template <class T> using heap = priority_queue<T, vector<T>, greater<T>>;
struct before_main_function {
before_main_function() {
cin.tie(nullptr);
ios::sync_with_stdio(0);
cout << setprecision(15) << fixed;
// #define endl "\n"
}
} before_main_function;
//------------------8<------------------------------------8<--------------------
signed main() {
int N, K;
cin >> N >> K;
deque<int> V(N);
rep(i, 0, N) cin >> V[i];
int ans = 0;
rep(l, 0, K + 1) {
rep(r, 0, K + 1) {
int d = K - (l + r);
if (d < 0)
continue;
auto deq = V;
set<int> se;
rep(i, 0, l) {
if (sz(deq)) {
se.insert(deq.front());
deq.pop_front();
}
}
rep(i, 0, r) {
if (sz(deq)) {
se.insert(deq.back());
deq.pop_back();
}
}
rep(i, 0, d) {
if (sz(se)) {
auto itr = se.begin();
if (*itr < 0) {
se.erase(itr);
}
}
}
int tmp = 0;
for (int x : se) {
tmp += x;
}
dump(l, r, d, tmp);
chmax(ans, tmp);
}
}
cout << ans << endl;
return (0 ^ _ ^ 0);
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define fore(x, c) for (auto &&x : c)
#define rep(i, a, n) for (int i = a, i##len = (int)(n); i < i##len; ++i)
#define rrep(i, a, n) for (int i = (int)(n - 1); i >= a; --i)
#define sz(c) ((int)c.size())
#define contains(c, x) (c.find(x) != end(c))
#define inseg(l, x, r) ((l) <= (x) && (x) < (r))
#define dump(...)
#define pb push_back
#define _ 0
const signed INF_ = 1001001001;
const long long INF = 1001001001001001001LL;
const int DX[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
DY[9] = {-1, 0, 1, 0, -1, 1, 1, -1, 0};
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto i = begin(v); i != end(v); i++)
os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto i = begin(v); i != end(v); i++)
is >> *i;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T, class U> bool chmax(T &a, const U &b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U> bool chmin(T &a, const U &b) {
return a > b ? a = b, 1 : 0;
}
template <class T> void psum(T &c) { partial_sum(begin(c), end(c), begin(c)); }
template <class T> using heap = priority_queue<T, vector<T>, greater<T>>;
struct before_main_function {
before_main_function() {
cin.tie(nullptr);
ios::sync_with_stdio(0);
cout << setprecision(15) << fixed;
// #define endl "\n"
}
} before_main_function;
//------------------8<------------------------------------8<--------------------
signed main() {
int N, K;
cin >> N >> K;
deque<int> V(N);
rep(i, 0, N) cin >> V[i];
int ans = 0;
rep(l, 0, K + 1) {
rep(r, 0, K + 1) {
int d = K - (l + r);
if (d < 0)
continue;
auto deq = V;
multiset<int> se;
rep(i, 0, l) {
if (sz(deq)) {
se.insert(deq.front());
deq.pop_front();
}
}
rep(i, 0, r) {
if (sz(deq)) {
se.insert(deq.back());
deq.pop_back();
}
}
rep(i, 0, d) {
if (sz(se)) {
auto itr = se.begin();
if (*itr < 0) {
se.erase(itr);
}
}
}
int tmp = 0;
for (int x : se) {
tmp += x;
}
dump(l, r, d, tmp);
chmax(ans, tmp);
}
}
cout << ans << endl;
return (0 ^ _ ^ 0);
}
| [
"variable_declaration.type.change"
] | 844,610 | 844,611 | u133129810 | cpp |
p03032 | // KALAM
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 17, K = 200 + 17;
int dp[N][N][K];
int n, k, a[N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%d", a + i);
for (int i = 1; i <= n; ++i)
for (int f = 1; f <= k; ++f)
dp[i][i][f] = max(a[f], 0);
for (int len = 2; len <= n; ++len)
for (int le = 1; le + len <= n + 1; ++le)
for (int i = 1; i <= k; ++i) {
int ri = le + len - 1;
dp[le][ri][i] = max(dp[le][ri][i], dp[le][ri - 1][i - 1] + a[ri]);
if (i > 1)
dp[le][ri][i] =
max(dp[le][ri][i], dp[le][ri - 1][i - 2] + max(a[ri], 0));
dp[le][ri][i] = max(dp[le][ri][i], dp[le + 1][ri][i - 1] + a[le]);
if (i > 1)
dp[le][ri][i] =
max(dp[le][ri][i], dp[le + 1][ri][i - 2] + max(a[le], 0));
}
printf("%d\n", dp[1][n][k]);
return 0;
}
| // KALAM
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 17, K = 200 + 17;
int dp[N][N][K];
int n, k, a[N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%d", a + i);
for (int i = 1; i <= n; ++i)
for (int f = 1; f <= k; ++f)
dp[i][i][f] = max(a[i], 0);
for (int len = 2; len <= n; ++len)
for (int le = 1; le + len <= n + 1; ++le)
for (int i = 1; i <= k; ++i) {
int ri = le + len - 1;
dp[le][ri][i] = max(dp[le][ri][i], dp[le][ri - 1][i - 1] + a[ri]);
if (i > 1)
dp[le][ri][i] =
max(dp[le][ri][i], dp[le][ri - 1][i - 2] + max(a[ri], 0));
dp[le][ri][i] = max(dp[le][ri][i], dp[le + 1][ri][i - 1] + a[le]);
if (i > 1)
dp[le][ri][i] =
max(dp[le][ri][i], dp[le + 1][ri][i - 2] + max(a[le], 0));
}
printf("%d\n", dp[1][n][k]);
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 844,618 | 844,619 | u154653457 | cpp |
p03032 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
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 = INT_MIN;
for (int l = 0; l <= n; ++l) {
for (int r = 0; l + r <= n; ++r) {
if (l + r > k)
continue;
vector<int> w;
for (int i = 0; i < l; ++i)
w.push_back(v[i]);
for (int i = 0; i < r; ++i)
w.push_back(v[n - 1 - i]);
int sum = accumulate(w.begin(), w.end(), 0);
sort(w.begin(), w.end());
for (int i = 0; i < min(k - l - r, (int)w.size()); ++i)
sum -= w[i];
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
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 = INT_MIN;
for (int l = 0; l <= n; ++l) {
for (int r = 0; l + r <= n; ++r) {
if (l + r > k)
continue;
vector<int> w;
for (int i = 0; i < l; ++i)
w.push_back(v[i]);
for (int i = 0; i < r; ++i)
w.push_back(v[n - 1 - i]);
int sum = accumulate(w.begin(), w.end(), 0);
sort(w.begin(), w.end());
for (int i = 0; i < min(k - l - r, (int)w.size()); ++i)
sum -= min(0, w[i]);
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 844,626 | 844,627 | u917944707 | cpp |
p03033 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N = 2e5 + 5;
vector<int> parent(N);
int find(int u) {
if (parent[u] == u)
return u;
return parent[u] = find(parent[u]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < N; i++)
parent[i] = i;
int n, q;
cin >> n >> q;
vector<pair<int, pair<int, int>>> vec;
for (int i = 0; i < n; i++) {
int s, t, x;
cin >> s >> t >> x;
vec.push_back({x, {s, t}});
}
sort(vec.begin(), vec.end());
vector<int> d(q), ans(q, -1);
for (auto &i : d)
cin >> i;
for (int i = 0; i < n; i++) {
int x = vec[i].first, s = vec[i].second.first, t = vec[i].second.second;
int idx = lower_bound(d.begin(), d.end(), s - x) - d.begin();
idx = find(idx);
while (idx < q) {
if (s <= x + d[idx] && x + d[idx] < t) {
ans[idx] = x;
parent[idx] = ++idx;
if (idx >= q)
break;
idx = find(idx);
} else {
break;
}
}
}
for (auto i : ans)
cout << i << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N = 2e5 + 5;
vector<int> parent(N);
int find(int u) {
if (parent[u] == u)
return u;
return parent[u] = find(parent[u]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < N; i++)
parent[i] = i;
int n, q;
cin >> n >> q;
vector<pair<int, pair<int, int>>> vec;
for (int i = 0; i < n; i++) {
int s, t, x;
cin >> s >> t >> x;
vec.push_back({x, {s, t}});
}
sort(vec.begin(), vec.end());
vector<int> d(q), ans(q, -1);
for (auto &i : d)
cin >> i;
for (int i = 0; i < n; i++) {
int x = vec[i].first, s = vec[i].second.first, t = vec[i].second.second;
int idx = lower_bound(d.begin(), d.end(), s - x) - d.begin();
idx = find(idx);
while (idx < q) {
if (s <= x + d[idx] && x + d[idx] < t) {
ans[idx] = x;
parent[idx] = idx + 1;
idx++;
if (idx >= q)
break;
idx = find(idx);
} else {
break;
}
}
}
for (auto i : ans)
cout << i << '\n';
}
| [
"assignment.change",
"expression.unary.arithmetic.add"
] | 844,691 | 844,692 | u929156598 | cpp |
p03033 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
const int inf = 1e9 + 7;
const ll INF = 1e18;
int mod = 1000000007;
#define abs(x) (x >= 0 ? x : -(x))
#define lb(v, x) (int)(lower_bound(all(v), x) - v.begin())
#define ub(v, x) (int)(upper_bound(all(v), x) - v.begin())
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
ll pow(ll a, int b) { return b ? pow(a * a, b / 2) * (b % 2 ? a : 1) : 1; }
ll modpow(ll a, ll b, ll _mod) {
return b ? modpow(a * a % _mod, b / 2, _mod) * (b % 2 ? a : 1) % _mod : 1;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto &vi : vec)
os << vi << " ";
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.F << " " << p.S;
return os;
}
template <typename T> inline istream &operator>>(istream &is, vector<T> &v) {
rep(j, sz(v)) is >> v[j];
return is;
}
template <class T> inline void add(T &a, int b) {
a += b;
if (a >= mod)
a -= mod;
}
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int T;
// cin >> T;
T = 1;
while (T--) {
solve();
}
}
void solve() {
int n, q;
cin >> n >> q;
vector<tuple<int, int, int>> v(n);
rep(i, n) {
int s, t, x;
cin >> s >> t >> x;
v[i] = make_tuple(x, s, t);
}
sort(all(v));
set<pii> st;
rep(i, q) {
int d;
cin >> d;
st.insert(pii(d, i));
}
vector<int> ans(q, -1);
rep(i, n) {
int s, t, x;
tie(x, s, t) = v[i];
auto it = st.lower_bound(pii(s - x, -1));
while (it != st.end()) {
if (it->F > t - 1 - x)
break;
ans[it->S] = x;
st.erase(it++);
}
}
rep(i, n) cout << ans[i] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
const int inf = 1e9 + 7;
const ll INF = 1e18;
int mod = 1000000007;
#define abs(x) (x >= 0 ? x : -(x))
#define lb(v, x) (int)(lower_bound(all(v), x) - v.begin())
#define ub(v, x) (int)(upper_bound(all(v), x) - v.begin())
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
ll pow(ll a, int b) { return b ? pow(a * a, b / 2) * (b % 2 ? a : 1) : 1; }
ll modpow(ll a, ll b, ll _mod) {
return b ? modpow(a * a % _mod, b / 2, _mod) * (b % 2 ? a : 1) % _mod : 1;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto &vi : vec)
os << vi << " ";
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.F << " " << p.S;
return os;
}
template <typename T> inline istream &operator>>(istream &is, vector<T> &v) {
rep(j, sz(v)) is >> v[j];
return is;
}
template <class T> inline void add(T &a, int b) {
a += b;
if (a >= mod)
a -= mod;
}
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int T;
// cin >> T;
T = 1;
while (T--) {
solve();
}
}
void solve() {
int n, q;
cin >> n >> q;
vector<tuple<int, int, int>> v(n);
rep(i, n) {
int s, t, x;
cin >> s >> t >> x;
v[i] = make_tuple(x, s, t);
}
sort(all(v));
set<pii> st;
rep(i, q) {
int d;
cin >> d;
st.insert(pii(d, i));
}
vector<int> ans(q, -1);
rep(i, n) {
int s, t, x;
tie(x, s, t) = v[i];
auto it = st.lower_bound(pii(s - x, -1));
while (it != st.end()) {
if (it->F > t - 1 - x)
break;
ans[it->S] = x;
st.erase(it++);
}
}
rep(i, q) cout << ans[i] << endl;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 844,695 | 844,696 | u277556971 | cpp |
p03021 | // E.cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2020;
// f[u] is the sum of depth;
int n, head[MAX_N], current, siz[MAX_N], f[MAX_N];
char S[MAX_N];
struct edge {
int to, nxt;
} edges[MAX_N << 1];
void addpath(int src, int dst) {
edges[current].to = dst, edges[current].nxt = head[src];
head[src] = current++;
}
void dfs(int u, int fa) {
siz[u] = S[u] - '0', f[u] = 0;
for (int i = head[u]; i != -1; i = edges[i].nxt)
if (edges[i].to != fa)
dfs(edges[i].to, u), siz[u] += siz[edges[i].to],
f[u] += f[edges[i].to] + siz[edges[i].to];
}
int collect(int u, int fa) {
int mpos = 0;
for (int i = head[u]; i != -1; i = edges[i].nxt)
if (edges[i].to != fa && (mpos == 0 || f[mpos] < f[edges[i].to]))
mpos = edges[i].to;
if (mpos == 0)
return 0;
int verdict = collect(mpos, u) + f[mpos];
if (f[u] - f[mpos] - siz[mpos] >= verdict)
// could be finished;
return (f[u] & 1);
// extra;
return verdict - (f[u] - f[mpos] - siz[mpos]);
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%s", &n, S + 1);
for (int i = 1, u, v; i <= n - 1; i++)
scanf("%d%d", &u, &v), addpath(u, v), addpath(v, u);
int ans = 0x3f3f3f3f;
for (int rt = 1; rt <= n; rt++) {
dfs(rt, 0);
if (collect(rt, 0) == 0)
ans = min(ans, f[rt] >> 1);
}
if (ans == 0x3f3f3f3f)
puts("-1");
else
printf("%d\n", ans);
return 0;
} | // E.cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2020;
// f[u] is the sum of depth;
int n, head[MAX_N], current, siz[MAX_N], f[MAX_N];
char S[MAX_N];
struct edge {
int to, nxt;
} edges[MAX_N << 1];
void addpath(int src, int dst) {
edges[current].to = dst, edges[current].nxt = head[src];
head[src] = current++;
}
void dfs(int u, int fa) {
siz[u] = S[u] - '0', f[u] = 0;
for (int i = head[u]; i != -1; i = edges[i].nxt)
if (edges[i].to != fa)
dfs(edges[i].to, u), siz[u] += siz[edges[i].to],
f[u] += f[edges[i].to] + siz[edges[i].to];
}
int collect(int u, int fa) {
int mpos = 0;
for (int i = head[u]; i != -1; i = edges[i].nxt)
if (edges[i].to != fa && (mpos == 0 || f[mpos] < f[edges[i].to]))
mpos = edges[i].to;
if (mpos == 0)
return 0;
int verdict = collect(mpos, u) + siz[mpos];
if (f[u] - f[mpos] - siz[mpos] >= verdict)
// could be finished;
return (f[u] & 1);
// extra;
return verdict - (f[u] - f[mpos] - siz[mpos]);
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%s", &n, S + 1);
for (int i = 1, u, v; i <= n - 1; i++)
scanf("%d%d", &u, &v), addpath(u, v), addpath(v, u);
int ans = 0x3f3f3f3f;
for (int rt = 1; rt <= n; rt++) {
dfs(rt, 0);
if (collect(rt, 0) == 0)
ans = min(ans, f[rt] >> 1);
}
if (ans == 0x3f3f3f3f)
puts("-1");
else
printf("%d\n", ans);
return 0;
} | [
"identifier.change",
"expression.operation.binary.change"
] | 844,701 | 844,702 | u730011912 | cpp |
p03021 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 2005, INF = 1 << 30;
bool exist[MAX];
vector<int> G[MAX];
int depth[MAX], cnt[MAX];
vector<pair<int, int>> dis;
void DFS(int u, int p) {
for (int to : G[u]) {
if (to == p)
continue;
depth[to] = depth[u] + 1;
DFS(to, u);
cnt[u] += cnt[to];
}
if (exist[u])
cnt[u]++;
}
pair<int, int> solve(int u, int p) {
pair<int, int> sum = {0, 0};
vector<int> T;
for (int to : G[u]) {
if (to == p)
continue;
pair<int, int> a = solve(to, u);
sum.first += a.first;
sum.second += a.second;
if (a.first - 2 * a.second - cnt[to] * depth[u])
T.push_back(a.first - 2 * a.second - cnt[to] * depth[u]);
}
if (exist[u]) {
sum.first += depth[u];
}
sort(all(T));
int s = 0;
for (int i = 0; i < T.size(); i++)
s += T[i];
if (T.size())
sum.second += min(s / 2, s - T.back());
return sum;
}
int main() {
std::ifstream in("text.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
string S;
cin >> S;
for (int i = 0; i < N; i++) {
if (S[i] == '1')
exist[i] = 1;
}
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
int ans = INF;
for (int i = 0; i < N; i++) {
memset(depth, 0, sizeof(depth));
memset(cnt, 0, sizeof(cnt));
dis.clear();
DFS(i, -1);
for (int to : G[i]) {
pair<int, int> a = solve(to, i);
if (a.first)
dis.push_back(a);
}
if (dis.size() == 0) {
ans = 0;
continue;
}
sort(all(dis));
int sum = 0;
for (pair<int, int> a : dis)
sum += a.first;
if (sum % 2 == 0) {
if (dis.back().first * 2 <= sum)
ans = min(ans, sum / 2);
else {
if (dis.back().first - dis.back().second <= (sum - dis.back().first))
ans = min(ans, sum / 2);
}
}
}
if (ans == INF)
ans = -1;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 2005, INF = 1 << 30;
bool exist[MAX];
vector<int> G[MAX];
int depth[MAX], cnt[MAX];
vector<pair<int, int>> dis;
void DFS(int u, int p) {
for (int to : G[u]) {
if (to == p)
continue;
depth[to] = depth[u] + 1;
DFS(to, u);
cnt[u] += cnt[to];
}
if (exist[u])
cnt[u]++;
}
pair<int, int> solve(int u, int p) {
pair<int, int> sum = {0, 0};
vector<int> T;
for (int to : G[u]) {
if (to == p)
continue;
pair<int, int> a = solve(to, u);
sum.first += a.first;
sum.second += a.second;
if (a.first - 2 * a.second - cnt[to] * depth[u])
T.push_back(a.first - 2 * a.second - cnt[to] * depth[u]);
}
if (exist[u]) {
sum.first += depth[u];
}
sort(all(T));
int s = 0;
for (int i = 0; i < T.size(); i++)
s += T[i];
if (T.size())
sum.second += min(s / 2, s - T.back());
return sum;
}
int main() {
std::ifstream in("text.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
string S;
cin >> S;
for (int i = 0; i < N; i++) {
if (S[i] == '1')
exist[i] = 1;
}
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
int ans = INF;
for (int i = 0; i < N; i++) {
memset(depth, 0, sizeof(depth));
memset(cnt, 0, sizeof(cnt));
dis.clear();
DFS(i, -1);
for (int to : G[i]) {
pair<int, int> a = solve(to, i);
if (a.first)
dis.push_back(a);
}
if (dis.size() == 0) {
ans = 0;
continue;
}
sort(all(dis));
int sum = 0;
for (pair<int, int> a : dis)
sum += a.first;
if (sum % 2 == 0) {
if (dis.back().first * 2 <= sum)
ans = min(ans, sum / 2);
else {
if (dis.back().first - 2 * dis.back().second <=
(sum - dis.back().first))
ans = min(ans, sum / 2);
}
}
}
if (ans == INF)
ans = -1;
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,719 | 844,720 | u133391510 | cpp |
p03021 | #include <bits/stdc++.h>
typedef long long ll;
const int N = 5005;
int n, c[N], head[N], nxt[N], ver[N], cnt;
ll sum[N], max[N], min[N];
char s[N];
inline void add(int u, int v) {
nxt[++cnt] = head[u];
ver[cnt] = v;
head[u] = cnt;
}
void solve(int x, int f) {
max[x] = min[x] = 0;
sum[x] = c[x];
int max_son = 0;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y != f) {
solve(y, x);
sum[x] += sum[y];
max[x] += max[y];
if (max[y] > max[max_son])
max_son = y;
}
}
if (min[max_son] <= max[x] - max[max_son])
min[x] = (max[x] & 1) + sum[x];
else
min[x] = min[max_son] - (max[x] - max[max_son]) + sum[x];
max[x] += sum[x];
if (f == 0)
max[x] -= sum[x], min[x] -= sum[x], sum[x] -= sum[x];
}
inline char nc() {
static char buf[1000000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int res = 0;
char ch;
do
ch = nc();
while (ch < 48 or ch > 57);
do
res = res * 10 + ch - 48, ch = nc();
while (ch >= 48 and ch <= 57);
return res;
}
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; ++i)
c[i] = s[i] - 48;
for (int i = 2; i < n; ++i) {
int u = read(), v = read();
add(u, v);
add(v, u);
}
ll ans = 1e18;
for (int i = 1; i <= n; ++i) {
solve(i, 0);
if (min[i] == 0)
ans = std::min(ans, max[i] >> 1);
}
if (ans >= 1e18)
puts("-1");
else
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
const int N = 5005;
int n, c[N], head[N], nxt[N], ver[N], cnt;
ll sum[N], max[N], min[N];
char s[N];
inline void add(int u, int v) {
nxt[++cnt] = head[u];
ver[cnt] = v;
head[u] = cnt;
}
void solve(int x, int f) {
max[x] = min[x] = 0;
sum[x] = c[x];
int max_son = 0;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y != f) {
solve(y, x);
sum[x] += sum[y];
max[x] += max[y];
if (max[y] > max[max_son])
max_son = y;
}
}
if (min[max_son] <= max[x] - max[max_son])
min[x] = (max[x] & 1) + sum[x];
else
min[x] = min[max_son] - (max[x] - max[max_son]) + sum[x];
max[x] += sum[x];
if (f == 0)
max[x] -= sum[x], min[x] -= sum[x], sum[x] -= sum[x];
}
inline char nc() {
static char buf[1000000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int res = 0;
char ch;
do
ch = nc();
while (ch < 48 or ch > 57);
do
res = res * 10 + ch - 48, ch = nc();
while (ch >= 48 and ch <= 57);
return res;
}
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; ++i)
c[i] = s[i] - 48;
for (int i = 1; i < n; ++i) {
int u = read(), v = read();
add(u, v);
add(v, u);
}
ll ans = 1e18;
for (int i = 1; i <= n; ++i) {
solve(i, 0);
if (min[i] == 0)
ans = std::min(ans, max[i] >> 1);
}
if (ans >= 1e18)
puts("-1");
else
printf("%lld", ans);
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 844,725 | 844,726 | u778968609 | cpp |
p03021 | #include <bits/stdc++.h>
using namespace std;
const int Maxn = 2005;
int n, cnt, head[Maxn];
long long sum[Maxn], w[Maxn];
string str;
long long ans = 0x3f3f3f3f3f3f3f3fLL;
struct edg {
int nxt, to;
} edge[2 * Maxn];
void add(int x, int y) {
edge[++cnt] = (edg){head[x], y};
head[x] = cnt;
}
void dfs1(int u, int fa) {
sum[u] = w[u] = 0;
if (str[u - 1] == '1')
w[u] = 1;
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (to != fa)
dfs1(to, u), w[u] += w[to], sum[u] += sum[to] + w[to];
}
}
long long dfs2(int u, int fa) {
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (to != fa && (sum[to] + w[to]) * 2 > sum[u])
return max(0LL, dfs2(to, u) + 3 * w[to] - sum[u] + sum[to]);
}
return 0;
}
int main() {
scanf("%d", &n);
cin >> str;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
for (int i = 1; i <= n; i++) {
dfs1(i, 0);
if (!(sum[i] & 1) && !dfs2(i, 0))
ans = min(ans, sum[i] / 2);
}
if (ans == 0x3f3f3f3f3f3f3f3fLL)
puts("-1");
else
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int Maxn = 2005;
int n, cnt, head[Maxn];
long long sum[Maxn], w[Maxn];
string str;
long long ans = 0x3f3f3f3f3f3f3f3fLL;
struct edg {
int nxt, to;
} edge[2 * Maxn];
void add(int x, int y) {
edge[++cnt] = (edg){head[x], y};
head[x] = cnt;
}
void dfs1(int u, int fa) {
sum[u] = w[u] = 0;
if (str[u - 1] == '1')
w[u] = 1;
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (to != fa)
dfs1(to, u), w[u] += w[to], sum[u] += sum[to] + w[to];
}
}
long long dfs2(int u, int fa) {
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (to != fa && (sum[to] + w[to]) * 2 > sum[u])
return max(0LL, dfs2(to, u) + 2 * w[to] - sum[u] + sum[to]);
}
return 0;
}
int main() {
scanf("%d", &n);
cin >> str;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
for (int i = 1; i <= n; i++) {
dfs1(i, 0);
if (!(sum[i] & 1) && !dfs2(i, 0))
ans = min(ans, sum[i] / 2);
}
if (ans == 0x3f3f3f3f3f3f3f3fLL)
puts("-1");
else
printf("%lld", ans);
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 844,732 | 844,733 | u032193798 | cpp |
p03021 | #include <cstdio>
#include <iostream>
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define REP(u) for (int i = hd[u], v; v = e[i].v, i; i = e[i].n)
using namespace std;
const int N = 2020, INF = 1000010000;
int n, ans, fl, u, v;
int hd[N], fa[N], sz[N], f[N], g[N], we[N];
char s[N];
struct edge {
int n, v;
} e[N << 1];
void add(int u, int v) {
e[++fl] = (edge){hd[u], v};
hd[u] = fl;
}
void dfs(int u) {
f[u] = 0;
sz[u] = s[u] ^ 48;
REP(u) if (v != fa[u]) {
fa[v] = u;
dfs(v);
f[v] += sz[v];
g[v] += sz[v];
if (f[v] > f[we[u]])
we[u] = v;
f[u] += f[v];
sz[u] += sz[v];
}
g[u] = g[we[u]] > f[u] - f[we[u]] ? g[we[u]] - f[u] + f[we[u]] : f[u] & 1;
}
void work(int u) {
fa[u] = 0;
dfs(u);
if (g[u] == 0)
ans = min(ans, f[u] / 2);
}
int main() {
// freopen("1.in","r",stdin);
scanf("%d%s", &n, s + 1);
ans = INF;
FOR(i, 2, n) scanf("%d%d", &u, &v), add(u, v), add(v, u);
FOR(i, 1, n) work(i);
cout << (ans == INF ? -1 : ans) << '\n';
}
| #include <cstdio>
#include <iostream>
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define REP(u) for (int i = hd[u], v; v = e[i].v, i; i = e[i].n)
using namespace std;
const int N = 2020, INF = 1000010000;
int n, ans, fl, u, v;
int hd[N], fa[N], sz[N], f[N], g[N], we[N];
char s[N];
struct edge {
int n, v;
} e[N << 1];
void add(int u, int v) {
e[++fl] = (edge){hd[u], v};
hd[u] = fl;
}
void dfs(int u) {
f[u] = we[u] = 0;
sz[u] = s[u] ^ 48;
REP(u) if (v != fa[u]) {
fa[v] = u;
dfs(v);
f[v] += sz[v];
g[v] += sz[v];
if (f[v] > f[we[u]])
we[u] = v;
f[u] += f[v];
sz[u] += sz[v];
}
g[u] = g[we[u]] > f[u] - f[we[u]] ? g[we[u]] - f[u] + f[we[u]] : f[u] & 1;
}
void work(int u) {
fa[u] = 0;
dfs(u);
if (g[u] == 0)
ans = min(ans, f[u] / 2);
}
int main() {
// freopen("1.in","r",stdin);
scanf("%d%s", &n, s + 1);
ans = INF;
FOR(i, 2, n) scanf("%d%d", &u, &v), add(u, v), add(v, u);
FOR(i, 1, n) work(i);
cout << (ans == INF ? -1 : ans) << '\n';
}
| [
"assignment.change"
] | 844,738 | 844,739 | u599057573 | cpp |
p03021 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2010;
const ll inf = 1e18;
int n, sz[N];
char s[N];
ll ds[N], dz[N], sn[N];
vector<int> g[N];
void dfs(int u, int fa) {
sz[u] = s[u] - '0';
ll sum = ds[u] = sn[u] = 0, mx = 0;
for (int v : g[u]) {
if (v == fa)
continue;
dfs(v, u);
ds[u] += ds[v] + sz[v];
sz[u] += sz[v];
if (ds[v] + sz[v] >= mx)
sum += mx, mx = ds[sn[u] = v] + sz[v];
else
sum += ds[v] + sz[v];
}
dz[u] = dz[sn[u]] + mx >= sum ? sum : ((mx + sum) >> 1);
}
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
ll ans = inf;
for (int i = 1; i <= n; ++i) {
dfs(i, 0);
if (ds[i] & 1)
continue;
if (dz[i] * 2 >= ds[i])
ans = min(ds[i] >> 1, ans);
}
if (ans == inf)
puts("-1");
else
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2010;
const ll inf = 1e18;
int n, sz[N];
char s[N];
ll ds[N], dz[N], sn[N];
vector<int> g[N];
void dfs(int u, int fa) {
sz[u] = s[u] - '0';
ll sum = ds[u] = sn[u] = 0, mx = 0;
for (int v : g[u]) {
if (v == fa)
continue;
dfs(v, u);
ds[u] += ds[v] + sz[v];
sz[u] += sz[v];
if (ds[v] + sz[v] >= mx)
sum += mx, mx = ds[sn[u] = v] + sz[v];
else
sum += ds[v] + sz[v];
}
dz[u] = dz[sn[u]] + ((mx >= sum) ? sum : ((mx + sum) >> 1));
}
int main() {
// freopen("E.in","r",stdin);
// freopen("E.out","w",stdout);
scanf("%d%s", &n, s + 1);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
ll ans = inf;
for (int i = 1; i <= n; ++i) {
dfs(i, 0);
if (ds[i] & 1)
continue;
if (dz[i] * 2 >= ds[i])
ans = min(ds[i] >> 1, ans);
}
if (ans == inf)
puts("-1");
else
cout << ans << endl;
return 0;
}
| [] | 844,758 | 844,759 | u323092931 | cpp |
p03021 | /*raghav0307 - Raghav Gupta*/
#include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pb push_back
#define fast_io() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
#define int ll
const int MAX_N = 2e3 + 5;
int n;
string s;
vector<int> graph[MAX_N];
int low[MAX_N], high[MAX_N], cnt[MAX_N];
void dfs(int nd, int parent) {
cnt[nd] = 0;
high[nd] = 0;
low[nd] = 0;
if (s[nd - 1] == '1')
cnt[nd]++;
int max_si = 0;
int max_pos = 0;
int sum_si = 0;
int ans1 = 0;
for (auto x : graph[nd]) {
if (x == parent)
continue;
dfs(x, nd);
cnt[nd] += cnt[x];
high[nd] += cnt[x] + high[x];
ans1 += (cnt[x] + low[x]) % 2;
sum_si += (cnt[x] + high[x]);
if ((cnt[x] + high[x]) > max_si) {
max_si = (cnt[x] + high[x]);
max_pos = x;
}
}
// cout << sum_si << " " << max_si << "\n";
int ans2 = 0;
if (max_si * 2 > sum_si) {
// cout << "Woah!\n";
ans2 = 2 * max_si - (sum_si - low[max_pos] + high[max_pos]);
}
low[nd] = max(ans1 % 2, ans2);
// cout << "cnt[" << nd << "]: " << cnt[nd] << "\n";
// cout << "low[" << nd << "]: " << low[nd] << "\n";
// cout << "high[" << nd << "]: " << high[nd] << "\n";
}
signed main() {
fast_io();
cin >> n;
cin >> s;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
graph[a].pb(b);
graph[b].pb(a);
}
int ans = 1e8;
for (int i = 3; i <= n; i++) {
dfs(i, -1);
if (low[i] == 0)
ans = min(ans, high[i] / 2);
}
if (ans == (int)1e8)
cout << "-1";
else
cout << ans;
return 0;
} | /*raghav0307 - Raghav Gupta*/
#include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pb push_back
#define fast_io() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
#define int ll
const int MAX_N = 2e3 + 5;
int n;
string s;
vector<int> graph[MAX_N];
int low[MAX_N], high[MAX_N], cnt[MAX_N];
void dfs(int nd, int parent) {
cnt[nd] = 0;
high[nd] = 0;
low[nd] = 0;
if (s[nd - 1] == '1')
cnt[nd]++;
int max_si = 0;
int max_pos = 0;
int sum_si = 0;
int ans1 = 0;
for (auto x : graph[nd]) {
if (x == parent)
continue;
dfs(x, nd);
cnt[nd] += cnt[x];
high[nd] += cnt[x] + high[x];
ans1 += (cnt[x] + low[x]) % 2;
sum_si += (cnt[x] + high[x]);
if ((cnt[x] + high[x]) > max_si) {
max_si = (cnt[x] + high[x]);
max_pos = x;
}
}
// cout << sum_si << " " << max_si << "\n";
int ans2 = 0;
if (max_si * 2 > sum_si) {
// cout << "Woah!\n";
ans2 = 2 * max_si - (sum_si - low[max_pos] + high[max_pos]);
}
low[nd] = max(ans1 % 2, ans2);
// cout << "cnt[" << nd << "]: " << cnt[nd] << "\n";
// cout << "low[" << nd << "]: " << low[nd] << "\n";
// cout << "high[" << nd << "]: " << high[nd] << "\n";
}
signed main() {
fast_io();
cin >> n;
cin >> s;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
graph[a].pb(b);
graph[b].pb(a);
}
int ans = 1e8;
for (int i = 1; i <= n; i++) {
dfs(i, -1);
if (low[i] == 0)
ans = min(ans, high[i] / 2);
}
if (ans == (int)1e8)
cout << "-1";
else
cout << ans;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 844,766 | 844,767 | u855714015 | cpp |
p03021 | #include "bits/stdc++.h"
using namespace std;
string s;
vector<int> g[2002];
int dp[2002];
int tot[2002];
int sum[2002];
void dfs(int x, int par) {
sum[x] = 0;
tot[x] = s[x] - '0';
for (int i : g[x]) {
if (i - par) {
dfs(i, x);
tot[x] += tot[i];
sum[x] += tot[i] + sum[i];
}
}
}
bool matcher(int x, int par, int take) {
if (take <= 0)
return true;
if (sum[x] - (sum[x] % 2) < take)
return false;
int big = -1;
for (int i : g[x]) {
if (i - par) {
if (big == -1 || tot[big] + sum[big] < tot[i] + sum[i]) {
big = i;
}
}
}
if (big == -1)
return false;
int w = tot[big] + sum[big];
if (sum[x] - w < w) {
int opt1 = 2 * w - sum[x];
int opt2 = take - (sum[x] - w);
return matcher(big, x, min(opt1, opt2));
} else {
return true;
}
}
int main(int argc, char const *argv[]) {
int n;
cin >> n;
cin >> s;
s = "&" + s;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
int ans = INT_MAX;
for (int i = 1; i <= n; i++) {
dfs(i, 0);
if (sum[i] % 2 == 0) {
if (matcher(i, 0, sum[i])) {
ans = min(ans, sum[i] / 2);
}
}
}
if (ans == INT_MAX)
ans = -1;
cout << ans << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
string s;
vector<int> g[2002];
int dp[2002];
int tot[2002];
int sum[2002];
void dfs(int x, int par) {
sum[x] = 0;
tot[x] = s[x] - '0';
for (int i : g[x]) {
if (i - par) {
dfs(i, x);
tot[x] += tot[i];
sum[x] += tot[i] + sum[i];
}
}
}
bool matcher(int x, int par, int take) {
if (take <= 0)
return true;
if (sum[x] - (sum[x] % 2) < take)
return false;
int big = -1;
for (int i : g[x]) {
if (i - par) {
if (big == -1 || tot[big] + sum[big] < tot[i] + sum[i]) {
big = i;
}
}
}
if (big == -1)
return false;
int w = tot[big] + sum[big];
if (sum[x] - w < w) {
int opt1 = 2 * w - sum[x];
int opt2 = take - 2 * (sum[x] - w);
return matcher(big, x, min(opt1, opt2));
} else {
return true;
}
}
int main(int argc, char const *argv[]) {
int n;
cin >> n;
cin >> s;
s = "&" + s;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
int ans = INT_MAX;
for (int i = 1; i <= n; i++) {
dfs(i, 0);
if (sum[i] % 2 == 0) {
if (matcher(i, 0, sum[i])) {
ans = min(ans, sum[i] / 2);
}
}
}
if (ans == INT_MAX)
ans = -1;
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 844,772 | 844,773 | u669432519 | cpp |
p03021 | #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#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 long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define F0Rd(i, a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define sz(x) (int)x.size()
#define beg(x) x.begin()
#define en(x) x.end()
#define all(x) beg(x), en(x)
#define resz resize
const int MOD = 1000000007;
const ll INF = 1e18;
const int MX = 200005;
const ld PI = 4 * atan((ld)1);
template <class T> void ckmin(T &a, T b) { a = min(a, b); }
template <class T> void ckmax(T &a, T b) { a = max(a, b); }
namespace input {
template <class T> void re(complex<T> &x);
template <class T1, class T2> void re(pair<T1, T2> &p);
template <class T> void re(vector<T> &a);
template <class T, size_t SZ> void re(array<T, SZ> &a);
template <class T> void re(T &x) { cin >> x; }
void re(double &x) {
string t;
re(t);
x = stod(t);
}
void re(ld &x) {
string t;
re(t);
x = stold(t);
}
template <class Arg, class... Args> void re(Arg &first, Args &...rest) {
re(first);
re(rest...);
}
template <class T> void re(complex<T> &x) {
T a, b;
re(a, b);
x = cd(a, b);
}
template <class T1, class T2> void re(pair<T1, T2> &p) { re(p.f, p.s); }
template <class T> void re(vector<T> &a) { F0R(i, sz(a)) re(a[i]); }
template <class T, size_t SZ> void re(array<T, SZ> &a) { F0R(i, SZ) re(a[i]); }
} // namespace input
using namespace input;
namespace output {
template <class T1, class T2> void pr(const pair<T1, T2> &x);
template <class T, size_t SZ> void pr(const array<T, SZ> &x);
template <class T> void pr(const vector<T> &x);
template <class T> void pr(const set<T> &x);
template <class T1, class T2> void pr(const map<T1, T2> &x);
template <class T> void pr(const T &x) { cout << x; }
template <class Arg, class... Args>
void pr(const Arg &first, const Args &...rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2> void pr(const pair<T1, T2> &x) {
pr("{", x.f, ", ", x.s, "}");
}
template <class T> void prContain(const T &x) {
pr("{");
bool fst = 1;
for (const auto &a : x)
pr(!fst ? ", " : "", a), fst = 0; // const needed for vector<bool>
pr("}");
}
template <class T, size_t SZ> void pr(const array<T, SZ> &x) { prContain(x); }
template <class T> void pr(const vector<T> &x) { prContain(x); }
template <class T> void pr(const set<T> &x) { prContain(x); }
template <class T1, class T2> void pr(const map<T1, T2> &x) { prContain(x); }
void ps() { pr("\n"); }
template <class Arg> void ps(const Arg &first) {
pr(first);
ps(); // no space at end of line
}
template <class Arg, class... Args>
void ps(const Arg &first, const Args &...rest) {
pr(first, " ");
ps(rest...); // print w/ spaces
}
} // namespace output
using namespace output;
namespace io {
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void setIO(string s = "") {
ios_base::sync_with_stdio(0);
cin.tie(0); // fast I/O
if (sz(s)) {
setIn(s + ".in"), setOut(s + ".out");
} // for USACO
}
} // namespace io
using namespace io;
template <class T> T invGeneral(T a, T b) {
a %= b;
if (a == 0)
return b == 1 ? 0 : -1;
T x = invGeneral(b, a);
return x == -1 ? -1 : ((1 - (ll)b * x) / a + b) % b;
}
template <class T> struct modular {
T val;
explicit operator T() const { return val; }
modular() { val = 0; }
template <class U> modular(const U &v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0)
val += MOD;
}
friend ostream &operator<<(ostream &os, const modular &a) {
return os << a.val;
}
friend bool operator==(const modular &a, const modular &b) {
return a.val == b.val;
}
friend bool operator!=(const modular &a, const modular &b) {
return !(a == b);
}
modular operator-() const { return modular(-val); }
modular &operator+=(const modular &m) {
if ((val += m.val) >= MOD)
val -= MOD;
return *this;
}
modular &operator-=(const modular &m) {
if ((val -= m.val) < 0)
val += MOD;
return *this;
}
modular &operator*=(const modular &m) {
val = (ll)val * m.val % MOD;
return *this;
}
friend modular exp(modular a, ll p) {
modular ans = 1;
for (; p; p /= 2, a *= a)
if (p & 1)
ans *= a;
return ans;
}
friend modular inv(const modular &a) { return invGeneral(a.val, MOD); }
// inv is equivalent to return exp(b,b.mod-2) if prime
modular &operator/=(const modular &m) { return (*this) *= inv(m); }
friend modular operator+(modular a, const modular &b) { return a += b; }
friend modular operator-(modular a, const modular &b) { return a -= b; }
friend modular operator*(modular a, const modular &b) { return a *= b; }
friend modular operator/(modular a, const modular &b) { return a /= b; }
};
typedef modular<int> mi;
typedef pair<mi, mi> pmi;
typedef vector<mi> vmi;
typedef vector<pmi> vpmi;
int N;
char c[2001];
vi adj[2001];
int ans = MOD, sumDist;
int par(vpi tmp) {
int res = 0;
trav(t, tmp) { res ^= t.f & 1; }
return res;
}
int calc(vpi tmp) {
if (!sz(tmp))
return 0;
int mx = 0, sum = 0;
trav(t, tmp) {
ckmax(mx, t.f);
sum += t.s;
}
trav(t, tmp) if (t.f == mx) {
sum -= t.s;
return max(par(tmp), mx - sum);
}
exit(5);
}
array<int, 3> dfs(int x, int y, int d) { // smallest, original, # of tokens
if (c[x] == '1')
sumDist += d;
array<int, 3> stat = {0, 0, c[x] == '1'};
vpi tmp;
trav(a, adj[x]) if (a != y) {
auto b = dfs(a, x, d + 1);
b[0] += b[2], b[1] += b[2];
stat[1] += b[1];
stat[2] += b[2];
tmp.pb({b[1], b[2]});
}
stat[0] = calc(tmp);
return stat;
}
int main() {
re(N);
FOR(i, 1, N + 1) re(c[i]);
F0R(i, N - 1) {
int a, b;
re(a, b);
adj[a].pb(b), adj[b].pb(a);
}
FOR(i, 1, N + 1) {
sumDist = 0;
auto x = dfs(i, 0, 0);
if (x[0] == 0)
ckmin(ans, sumDist / 2);
}
if (ans == MOD)
ps(-1);
else
ps(ans);
// you should actually read the stuff at the bottom
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?), set tle
* do smth instead of nothing and stay organized
*/ | #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#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 long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define F0Rd(i, a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define sz(x) (int)x.size()
#define beg(x) x.begin()
#define en(x) x.end()
#define all(x) beg(x), en(x)
#define resz resize
const int MOD = 1000000007;
const ll INF = 1e18;
const int MX = 200005;
const ld PI = 4 * atan((ld)1);
template <class T> void ckmin(T &a, T b) { a = min(a, b); }
template <class T> void ckmax(T &a, T b) { a = max(a, b); }
namespace input {
template <class T> void re(complex<T> &x);
template <class T1, class T2> void re(pair<T1, T2> &p);
template <class T> void re(vector<T> &a);
template <class T, size_t SZ> void re(array<T, SZ> &a);
template <class T> void re(T &x) { cin >> x; }
void re(double &x) {
string t;
re(t);
x = stod(t);
}
void re(ld &x) {
string t;
re(t);
x = stold(t);
}
template <class Arg, class... Args> void re(Arg &first, Args &...rest) {
re(first);
re(rest...);
}
template <class T> void re(complex<T> &x) {
T a, b;
re(a, b);
x = cd(a, b);
}
template <class T1, class T2> void re(pair<T1, T2> &p) { re(p.f, p.s); }
template <class T> void re(vector<T> &a) { F0R(i, sz(a)) re(a[i]); }
template <class T, size_t SZ> void re(array<T, SZ> &a) { F0R(i, SZ) re(a[i]); }
} // namespace input
using namespace input;
namespace output {
template <class T1, class T2> void pr(const pair<T1, T2> &x);
template <class T, size_t SZ> void pr(const array<T, SZ> &x);
template <class T> void pr(const vector<T> &x);
template <class T> void pr(const set<T> &x);
template <class T1, class T2> void pr(const map<T1, T2> &x);
template <class T> void pr(const T &x) { cout << x; }
template <class Arg, class... Args>
void pr(const Arg &first, const Args &...rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2> void pr(const pair<T1, T2> &x) {
pr("{", x.f, ", ", x.s, "}");
}
template <class T> void prContain(const T &x) {
pr("{");
bool fst = 1;
for (const auto &a : x)
pr(!fst ? ", " : "", a), fst = 0; // const needed for vector<bool>
pr("}");
}
template <class T, size_t SZ> void pr(const array<T, SZ> &x) { prContain(x); }
template <class T> void pr(const vector<T> &x) { prContain(x); }
template <class T> void pr(const set<T> &x) { prContain(x); }
template <class T1, class T2> void pr(const map<T1, T2> &x) { prContain(x); }
void ps() { pr("\n"); }
template <class Arg> void ps(const Arg &first) {
pr(first);
ps(); // no space at end of line
}
template <class Arg, class... Args>
void ps(const Arg &first, const Args &...rest) {
pr(first, " ");
ps(rest...); // print w/ spaces
}
} // namespace output
using namespace output;
namespace io {
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void setIO(string s = "") {
ios_base::sync_with_stdio(0);
cin.tie(0); // fast I/O
if (sz(s)) {
setIn(s + ".in"), setOut(s + ".out");
} // for USACO
}
} // namespace io
using namespace io;
template <class T> T invGeneral(T a, T b) {
a %= b;
if (a == 0)
return b == 1 ? 0 : -1;
T x = invGeneral(b, a);
return x == -1 ? -1 : ((1 - (ll)b * x) / a + b) % b;
}
template <class T> struct modular {
T val;
explicit operator T() const { return val; }
modular() { val = 0; }
template <class U> modular(const U &v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0)
val += MOD;
}
friend ostream &operator<<(ostream &os, const modular &a) {
return os << a.val;
}
friend bool operator==(const modular &a, const modular &b) {
return a.val == b.val;
}
friend bool operator!=(const modular &a, const modular &b) {
return !(a == b);
}
modular operator-() const { return modular(-val); }
modular &operator+=(const modular &m) {
if ((val += m.val) >= MOD)
val -= MOD;
return *this;
}
modular &operator-=(const modular &m) {
if ((val -= m.val) < 0)
val += MOD;
return *this;
}
modular &operator*=(const modular &m) {
val = (ll)val * m.val % MOD;
return *this;
}
friend modular exp(modular a, ll p) {
modular ans = 1;
for (; p; p /= 2, a *= a)
if (p & 1)
ans *= a;
return ans;
}
friend modular inv(const modular &a) { return invGeneral(a.val, MOD); }
// inv is equivalent to return exp(b,b.mod-2) if prime
modular &operator/=(const modular &m) { return (*this) *= inv(m); }
friend modular operator+(modular a, const modular &b) { return a += b; }
friend modular operator-(modular a, const modular &b) { return a -= b; }
friend modular operator*(modular a, const modular &b) { return a *= b; }
friend modular operator/(modular a, const modular &b) { return a /= b; }
};
typedef modular<int> mi;
typedef pair<mi, mi> pmi;
typedef vector<mi> vmi;
typedef vector<pmi> vpmi;
int N;
char c[2001];
vi adj[2001];
int ans = MOD, sumDist;
int par(vpi tmp) {
int res = 0;
trav(t, tmp) { res ^= t.f & 1; }
return res;
}
int calc(vpi tmp) {
if (!sz(tmp))
return 0;
int mx = 0, sum = 0;
trav(t, tmp) {
ckmax(mx, t.f);
sum += t.s;
}
trav(t, tmp) if (t.f == mx) {
sum -= t.s;
return max(par(tmp), mx - sum);
}
exit(5);
}
array<int, 3> dfs(int x, int y, int d) { // smallest, original, # of tokens
if (c[x] == '1')
sumDist += d;
array<int, 3> stat = {0, 0, c[x] == '1'};
vpi tmp;
trav(a, adj[x]) if (a != y) {
auto b = dfs(a, x, d + 1);
b[0] += b[2], b[1] += b[2];
stat[1] += b[1];
stat[2] += b[2];
tmp.pb({b[0], b[1]});
}
stat[0] = calc(tmp);
return stat;
}
int main() {
re(N);
FOR(i, 1, N + 1) re(c[i]);
F0R(i, N - 1) {
int a, b;
re(a, b);
adj[a].pb(b), adj[b].pb(a);
}
FOR(i, 1, N + 1) {
sumDist = 0;
auto x = dfs(i, 0, 0);
if (x[0] == 0)
ckmin(ans, sumDist / 2);
}
if (ans == MOD)
ps(-1);
else
ps(ans);
// you should actually read the stuff at the bottom
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?), set tle
* do smth instead of nothing and stay organized
*/ | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 844,774 | 844,775 | u025222195 | cpp |
p03021 | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v)
out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 2010
int N;
int ball[SIZE];
vector<int> tree[SIZE];
struct Data {
int max = 0;
int min = 0;
int size = 0;
int ans = 0;
};
Data dfs1(int now, int back = -1) {
Data res = {0, 0, 0, 0};
for (int to : tree[now]) {
if (back == to)
continue;
auto p = dfs1(to, now);
p.max += p.size;
p.min += p.size;
debug(res.min - p.max);
debug(p.min - res.max);
if (min(p.max, res.max) - max(p.min, res.min) >= 0) {
res.min = (p.max % 2) ^ (res.max % 2);
} else {
res.min = max(res.min - p.max, p.min - res.max);
}
res.max += p.max;
res.ans += p.ans + p.size;
res.size += p.size;
}
res.size += ball[now];
debug(now);
debug(res.min);
debug(res.max);
debug(res.size);
return res;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++)
scanf("%1d", ball + i);
for (int i = 0; i < N - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
tree[a].push_back(b);
tree[b].push_back(a);
}
int ans = INF;
for (int i = 0; i < N; i++) {
auto res = dfs1(i);
if (res.min == 0) {
debug("Yes");
ans = min(ans, res.ans);
}
}
if (ans == INF) {
puts("-1");
} else {
printf("%d\n", ans);
}
return 0;
}
| #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v)
out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 2010
int N;
int ball[SIZE];
vector<int> tree[SIZE];
struct Data {
int max = 0;
int min = 0;
int size = 0;
int ans = 0;
};
Data dfs1(int now, int back = -1) {
Data res = {0, 0, 0, 0};
for (int to : tree[now]) {
if (back == to)
continue;
auto p = dfs1(to, now);
p.max += p.size;
p.min += p.size;
debug(res.min - p.max);
debug(p.min - res.max);
if (min(p.max, res.max) - max(p.min, res.min) >= 0) {
res.min = (p.max % 2) ^ (res.max % 2);
} else {
res.min = max(res.min - p.max, p.min - res.max);
}
res.max += p.max;
res.ans += p.ans + p.size;
res.size += p.size;
}
res.size += ball[now];
debug(now);
debug(res.min);
debug(res.max);
debug(res.size);
return res;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++)
scanf("%1d", ball + i);
for (int i = 0; i < N - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
tree[a].push_back(b);
tree[b].push_back(a);
}
int ans = INF;
for (int i = 0; i < N; i++) {
auto res = dfs1(i);
if (res.min == 0) {
debug("Yes");
ans = min(ans, res.ans / 2);
}
}
if (ans == INF) {
puts("-1");
} else {
printf("%d\n", ans);
}
return 0;
}
| [
"assignment.change"
] | 844,783 | 844,784 | u378419207 | cpp |
p03021 | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define N 2010
ll n;
string s;
vector<ll> g[N];
ll f[N], e[N], siz[N];
ll dfs(ll x, ll from, ll dep) {
ll sum = 0, ssum = (s[x - 1] == '1');
for (auto y : g[x])
if (y != from) {
ssum += dfs(y, x, dep + 1);
sum += e[y] + siz[y];
}
siz[x] = ssum;
ll ma = 0;
for (auto y : g[x])
if (y != from) {
ma = max(ma, f[y] + siz[y] - (sum - e[y] + siz[y]));
}
f[x] = ma;
e[x] = sum;
return siz[x];
}
ll solve(ll t) {
dfs(t, 0, 0);
if (f[t] > 0 || e[t] % 2 == 1)
return -1;
return e[t] / 2;
}
int main() {
cin >> n >> s;
for (int i = 0; i < n - 1; i++) {
ll a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
ll mi = 1e17;
for (int i = 1; i <= n; i++) {
ll res = solve(i);
if (~res)
mi = min(mi, res);
}
if (mi == 1e17)
mi = -1;
cout << mi << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define N 2010
ll n;
string s;
vector<ll> g[N];
ll f[N], e[N], siz[N];
ll dfs(ll x, ll from, ll dep) {
ll sum = 0, ssum = (s[x - 1] == '1');
for (auto y : g[x])
if (y != from) {
ssum += dfs(y, x, dep + 1);
sum += e[y] + siz[y];
}
siz[x] = ssum;
ll ma = 0;
for (auto y : g[x])
if (y != from) {
ma = max(ma, f[y] + siz[y] - (sum - (e[y] + siz[y])));
}
f[x] = ma;
e[x] = sum;
return siz[x];
}
ll solve(ll t) {
dfs(t, 0, 0);
if (f[t] > 0 || e[t] % 2 == 1)
return -1;
return e[t] / 2;
}
int main() {
cin >> n >> s;
for (int i = 0; i < n - 1; i++) {
ll a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
ll mi = 1e17;
for (int i = 1; i <= n; i++) {
ll res = solve(i);
if (~res)
mi = min(mi, res);
}
if (mi == 1e17)
mi = -1;
cout << mi << endl;
return 0;
}
| [
"call.arguments.change"
] | 844,785 | 844,786 | u924885571 | cpp |
p03021 | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define N 2010
ll n;
string s;
vector<ll> g[N];
ll f[N], e[N], siz[N];
ll dfs(ll x, ll from, ll dep) {
ll sum = 0, ssum = (s[x - 1] == '1');
for (auto y : g[x])
if (y != from) {
ssum += dfs(y, x, dep + 1);
sum += e[y] * siz[y];
}
siz[x] = ssum;
ll ma = 0;
for (auto y : g[x])
if (y != from) {
ma = max(ma, f[y] + siz[y] - (sum - e[y] * siz[y]));
}
f[x] = ma;
e[x] = sum;
return siz[x];
}
ll solve(ll t) {
dfs(t, 0, 0);
if (f[t] > 0 || e[t] % 2 == 1)
return -1;
return e[t] / 2;
}
int main() {
cin >> n >> s;
for (int i = 0; i < n - 1; i++) {
ll a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
ll mi = 1e17;
for (int i = 1; i <= n; i++) {
ll res = solve(i);
if (~res)
mi = min(mi, res);
}
if (mi == 1e17)
mi = -1;
cout << mi << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define N 2010
ll n;
string s;
vector<ll> g[N];
ll f[N], e[N], siz[N];
ll dfs(ll x, ll from, ll dep) {
ll sum = 0, ssum = (s[x - 1] == '1');
for (auto y : g[x])
if (y != from) {
ssum += dfs(y, x, dep + 1);
sum += e[y] + siz[y];
}
siz[x] = ssum;
ll ma = 0;
for (auto y : g[x])
if (y != from) {
ma = max(ma, f[y] + siz[y] - (sum - (e[y] + siz[y])));
}
f[x] = ma;
e[x] = sum;
return siz[x];
}
ll solve(ll t) {
dfs(t, 0, 0);
if (f[t] > 0 || e[t] % 2 == 1)
return -1;
return e[t] / 2;
}
int main() {
cin >> n >> s;
for (int i = 0; i < n - 1; i++) {
ll a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
ll mi = 1e17;
for (int i = 1; i <= n; i++) {
ll res = solve(i);
if (~res)
mi = min(mi, res);
}
if (mi == 1e17)
mi = -1;
cout << mi << endl;
return 0;
}
| [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 844,787 | 844,786 | u924885571 | cpp |
p03021 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define itn int
#define make_unique(x) \
sort((x).begin(), (x).end()); \
(x).erase(unique((x).begin(), (x).end()), (x).end())
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
const int N = 2222;
vector<int> a[N];
string s;
long long level[N];
int cnt[N];
long long minsuml[N];
long long suml[N];
void dfs(int v, int p) {
long long res = 0;
if (s[v] == '1') {
res += level[v];
cnt[v] = 1;
}
vector<int> tos;
vector<long long> sumls;
for (int x : a[v]) {
if (x != p) {
level[x] = level[v] + 1;
dfs(x, v);
suml[v] += suml[x] + cnt[x];
sumls.push_back(suml[x] + cnt[x]);
tos.push_back(x);
cnt[v] += cnt[x];
}
}
if (tos.empty()) {
minsuml[v] = suml[v];
return;
}
int idx = max_element(all(sumls)) - sumls.begin();
if (suml[v] / 2 < sumls[idx]) {
long long newsuml =
suml[v] - sumls[idx] + minsuml[tos[idx]] + cnt[tos[idx]];
if (newsuml / 2 >= minsuml[tos[idx]] + cnt[tos[idx]]) {
minsuml[v] = suml[v] % 2;
} else {
minsuml[v] = newsuml - (minsuml[tos[idx]] + cnt[tos[idx]]);
}
} else {
minsuml[v] = suml[v] % 2;
}
}
long long solve(int r) {
memset(level, 0, sizeof(level));
memset(cnt, 0, sizeof(cnt));
memset(minsuml, 0, sizeof(minsuml));
memset(suml, 0, sizeof(suml));
dfs(r, -1);
if (minsuml[r] == 0) {
return suml[r] / 2;
} else {
return -1;
}
}
int main() {
int n = nxt();
cin >> s;
for (int i = 0; i < n - 1; ++i) {
int u = nxt() - 1, v = nxt() - 1;
a[u].push_back(v);
a[v].push_back(u);
}
long long ans = -1;
for (int r = 0; r < n; ++r) {
long long tmp = solve(r);
if (ans == -1 || (tmp > -1 && tmp < ans)) {
ans = tmp;
}
}
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define itn int
#define make_unique(x) \
sort((x).begin(), (x).end()); \
(x).erase(unique((x).begin(), (x).end()), (x).end())
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
const int N = 2222;
vector<int> a[N];
string s;
long long level[N];
int cnt[N];
long long minsuml[N];
long long suml[N];
void dfs(int v, int p) {
long long res = 0;
if (s[v] == '1') {
res += level[v];
cnt[v] = 1;
}
vector<int> tos;
vector<long long> sumls;
for (int x : a[v]) {
if (x != p) {
level[x] = level[v] + 1;
dfs(x, v);
suml[v] += suml[x] + cnt[x];
sumls.push_back(suml[x] + cnt[x]);
tos.push_back(x);
cnt[v] += cnt[x];
}
}
if (tos.empty()) {
minsuml[v] = suml[v];
return;
}
int idx = max_element(all(sumls)) - sumls.begin();
if (suml[v] / 2 < sumls[idx]) {
long long newsuml =
suml[v] - sumls[idx] + minsuml[tos[idx]] + cnt[tos[idx]];
if (newsuml / 2 >= minsuml[tos[idx]] + cnt[tos[idx]]) {
minsuml[v] = suml[v] % 2;
} else {
minsuml[v] =
newsuml - 2 * (newsuml - (minsuml[tos[idx]] + cnt[tos[idx]]));
}
} else {
minsuml[v] = suml[v] % 2;
}
}
long long solve(int r) {
memset(level, 0, sizeof(level));
memset(cnt, 0, sizeof(cnt));
memset(minsuml, 0, sizeof(minsuml));
memset(suml, 0, sizeof(suml));
dfs(r, -1);
// if (r == 2) {
// for (int i = 0; i < 7; ++i) {
// cerr << i + 1 << ": " << suml[i] << " " << minsuml[i] << " " <<
// cnt[i] << " " << level[i] << "\n";
// }
// }
if (minsuml[r] == 0) {
return suml[r] / 2;
} else {
return -1;
}
}
int main() {
int n = nxt();
cin >> s;
for (int i = 0; i < n - 1; ++i) {
int u = nxt() - 1, v = nxt() - 1;
a[u].push_back(v);
a[v].push_back(u);
}
long long ans = -1;
for (int r = 0; r < n; ++r) {
long long tmp = solve(r);
if (ans == -1 || (tmp > -1 && tmp < ans)) {
ans = tmp;
}
}
cout << ans << "\n";
return 0;
}
| [
"assignment.change"
] | 844,790 | 844,791 | u984947419 | cpp |
p03034 | #include <bits/stdc++.h>
#define fr(i, n) for (int i = 0; i < (n); ++i)
#define foor(i, a, b) for (int i = (a); i <= (b); ++i)
#define rf(i, n) for (int i = (n); i--;)
#define roof(i, b, a) for (int i = (b); i >= (a); --i)
#define elsif else if
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define Reverse(x) reverse(all(x))
#define PQ priority_queue
#define NP(x) next_permutation(all(x))
#define M_PI 3.14159265358979323846
#define popcount __builtin_popcount
using namespace std;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef unsigned long long ull;
typedef vector<ull> vu;
typedef vector<vu> vvu;
typedef double dbl;
typedef vector<dbl> vd;
typedef vector<vd> vvd;
typedef string str;
typedef vector<str> vs;
typedef vector<vs> vvs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef map<int, int> mii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef map<ll, ll> mll;
typedef pair<dbl, dbl> pdd;
typedef vector<pdd> vpdd;
typedef map<dbl, dbl> mdd;
typedef pair<str, str> pss;
typedef vector<pss> vpss;
typedef map<str, str> mss;
typedef pair<int, ll> pil;
typedef vector<pil> vpil;
typedef map<int, ll> mil;
typedef pair<ll, int> pli;
typedef vector<pli> vpli;
typedef map<ll, int> mli;
typedef pair<dbl, int> pdi;
typedef vector<pdi> vpdi;
typedef map<dbl, int> mdi;
template <typename T> vector<T> &operator<<(vector<T> &v, const T t) {
v.push_back(t);
return v;
}
template <typename T> multiset<T> &operator<<(multiset<T> &m, const T t) {
m.insert(t);
return m;
}
template <typename T> set<T> &operator<<(set<T> &s, const T t) {
s.insert(t);
return s;
}
template <typename T> stack<T> &operator<<(stack<T> &s, const T t) {
s.push(t);
return s;
}
template <typename T> stack<T> &operator>>(stack<T> &s, T &t) {
t = s.top();
s.pop();
return s;
}
template <typename T> queue<T> &operator<<(queue<T> &q, const T t) {
q.push(t);
return q;
}
template <typename T> queue<T> &operator>>(queue<T> &q, T &t) {
t = q.front();
q.pop();
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator<<(PQ<T, vector<T>, U> &q, const T t) {
q.push(t);
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator>>(PQ<T, vector<T>, U> &q, T &t) {
t = q.top();
q.pop();
return q;
}
template <typename T, typename U>
istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <typename T> istream &operator>>(istream &s, vector<T> &v) {
fr(i, v.size()) { s >> v[i]; }
return s;
}
template <typename T, typename U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
// template<typename T>ostream&operator<<(ostream&s,const vector<T>v){for(auto
// a:v){s<<a<<endl;}return s;}
template <typename T> ostream &operator<<(ostream &s, const vector<T> v) {
fr(i, v.size()) { i ? s << " " << v[i] : s << v[i]; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const deque<T> d) {
fr(i, d.size()) { i ? s << " " << d[i] : s << d[i]; }
return s;
}
template <typename T> _Bit_reference operator&=(_Bit_reference b, T t) {
return b = b & t;
}
template <typename T> _Bit_reference operator^=(_Bit_reference b, T t) {
return b = b ^ t;
}
template <typename T> _Bit_reference operator|=(_Bit_reference b, T t) {
return b = b | t;
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
void print(void) { cout << endl; }
template <typename T> void print(T t) { cout << t << endl; }
template <typename T, typename... U> void print(T &&t, U &&...u) {
cout << t << " ";
print(forward<U>(u)...);
}
bool YN(bool b) {
print(b ? "YES" : "NO");
return b;
}
bool PI(bool b) {
print(b ? "POSSIBLE" : "IMPOSSIBLE");
return b;
}
bool Yn(bool b) {
print(b ? "Yes" : "No");
return b;
}
bool Pi(bool b) {
print(b ? "Possible" : "Impossible");
return b;
}
bool yn(bool b) {
print(b ? "yes" : "no");
return b;
}
bool pi(bool b) {
print(b ? "possible" : "impossible");
return b;
}
const int e5 = 1e5;
const int e9 = 1e9;
const int MD = 1e9 + 7;
const ll e18 = 1e18;
template <typename T> str to_string(const T &n) {
ostringstream s;
s << n;
return s.str();
}
template <typename T> T &chmax(T &a, T b) { return a = max(a, b); }
template <typename T> T &chmin(T &a, T b) { return a = min(a, b); }
template <typename T, typename U>
vector<pair<T, U>> dijkstra(const vector<vector<pair<T, U>>> &E, const U s,
const T inf) {
using P = pair<T, U>;
vector<P> d;
fr(i, E.size()) { d << P{inf, i}; }
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
template <typename T, typename U>
map<U, pair<T, U>> dijkstra(map<U, vector<pair<T, U>>> E, const U s,
const T inf) {
using P = pair<T, U>;
map<U, P> d;
for (pair<U, vector<P>> e : E) {
d[e.first] = P{inf, e.first};
}
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
ll maxflow(vector<mil> &E, int s, int t) {
ll z = 0;
vi b(E.size(), -1);
for (int i = 0;; ++i) {
static auto dfs = [&](int v, ll f, auto &dfs) -> ll {
if (v == t)
return f;
b[v] = i;
for (auto &p : E[v]) {
if (b[p.first] < i && p.second) {
if (ll r = dfs(p.first, min(f, p.second), dfs)) {
p.second -= r;
E[p.first][v] += r;
return r;
}
}
}
return 0;
};
ll x = dfs(s, ll(1e18), dfs);
z += x;
if (x == 0)
return z;
}
}
template <typename T> T distsq(pair<T, T> a, pair<T, T> b) {
return (a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second);
}
template <typename T> T max(const vector<T> a) {
T m = a[0];
for (T e : a) {
m = max(m, e);
}
return m;
}
template <typename T> T min(const vector<T> a) {
T m = a[0];
for (T e : a) {
m = min(m, e);
}
return m;
}
template <typename T> T gcd(const T a, const T b) {
return a ? gcd(b % a, a) : b;
}
template <typename T> T gcd(const vector<T> a) {
T g = a[0];
for (T e : a) {
g = gcd(g, e);
}
return g;
}
template <typename T> vector<T> LIS(const vector<T> A) {
vector<T> B;
for (T a : A) {
auto it = lower_bound(all(B), a);
if (it == B.end()) {
B << a;
} else {
*it = a;
}
}
return B;
}
template <typename T> vector<T> LCS(vector<T> A, vector<T> B) {
int N = A.size(), M = B.size();
vector<vector<pair<int, pii>>> d(N + 1, vector<pair<int, pii>>(M + 1));
fr(i, N) {
fr(j, M) {
if (A[i] == B[j]) {
d[i + 1][j + 1] = {d[i][j].first + 1, {i, j}};
} else {
d[i + 1][j + 1] = max(d[i][j + 1], d[i + 1][j]);
}
}
}
vector<T> r;
for (pii p = {N, M}; d[p.first][p.second].first;
p = d[p.first][p.second].second) {
r << A[d[p.first][p.second].second.first];
}
Reverse(r);
return r;
}
str LCS(str S, str T) {
vector<char> s =
LCS(vector<char>(S.begin(), S.end()), vector<char>(T.begin(), T.end()));
return str(s.begin(), s.end());
}
template <typename T> vector<pair<T, T>> ConvexHull(vector<pair<T, T>> V) {
if (V.size() <= 3) {
return V;
}
Sort(V);
rf(i, V.size() - 1) V << V[i];
vector<pair<T, T>> r;
for (pair<T, T> p : V) {
int s = r.size();
while (s >= 2 &&
(p.second - r[s - 1].second) * (p.first - r[s - 2].first) <
(p.second - r[s - 2].second) * (p.first - r[s - 1].first)) {
r.pop_back();
--s;
}
r << p;
}
r.pop_back();
return r;
}
class UnionFind {
vi p, s;
void extend(int N) {
foor(i, p.size(), N) {
p << i;
s << 1;
}
}
public:
UnionFind(void) {}
UnionFind(int N) { extend(N - 1); }
int find(int i) {
extend(i);
return p[i] = p[i] == i ? i : find(p[i]);
}
void unite(int a, int b) {
extend(a);
extend(b);
if ((a = find(a)) != (b = find(b))) {
if (s[a] > s[b]) {
swap(a, b);
}
s[b] += s[a];
p[a] = b;
}
}
void unite(pii p) { return unite(p.first, p.second); }
bool same(int a, int b) {
extend(a);
extend(b);
return find(a) == find(b);
}
bool same(pii p) { return same(p.first, p.second); }
int size(int x) {
extend(x);
return s[find(x)];
}
};
ll MST(vector<pair<ll, pii>> &E) {
Sort(E);
UnionFind uf;
ll z = 0;
for (auto &e : E) {
if (!uf.same(e.second)) {
z += e.first;
uf.unite(e.second);
}
}
return z;
}
ll strmod(const str &s, const int m) {
ll x = 0;
fr(i, s.size()) { x = (x * 10 + s[i] - 48) % m; }
return x;
}
vvl mul(const vvl &A, const vvl &B, const int m) {
vvl C;
fr(y, A.size()) { C << vl(B[y].size()); }
fr(y, C.size()) {
fr(x, C[y].size()) {
fr(i, A[0].size()) { (C[y][x] += A[y][i] * B[i][x]) %= m; }
}
}
return C;
}
vvl pow(const vvl &A, const ll n, const int m) {
vvl B;
fr(y, A.size()) { B << vl(A.size()); }
if (n == 0) {
fr(i, B.size()) { B[i][i] = 1; }
}
elsif(n % 2) { B = mul(A, pow(A, n - 1, m), m); }
else {
vvl C = pow(A, n / 2, m);
B = mul(C, C, m);
}
return B;
}
ll pow(const ll a, const ll n, const int m) {
ll t;
return n ? (n & 1 ? a >= 0 ? a % m : (m - (-a % m)) % m : 1) *
(t = pow(a, n >> 1, m), t * t % m) % m
: !!a;
}
ll inv(const ll x, const int p) { return pow(x, p - 2, p); }
ll inv(const ll x) { return inv(x, MD); }
vpll fact(const int n, const int p) {
vpll v(n + 1);
v[0].first = 1;
foor(i, 1, n) { v[i].first = v[i - 1].first * i % p; }
v[n].second = inv(v[n].first, p);
roof(i, n, 1) { v[i - 1].second = v[i].second * i % p; }
return v;
}
class Combination {
const vpll f;
const int M;
public:
Combination(int n, int m) : f(fact(n, m)), M(m) {}
Combination(int n) : Combination(n, MD) {}
ll P(int n, int k) {
return n < 0 || k < 0 || n < k ? 0ll : f[n].first * f[n - k].second % M;
}
ll C(int n, int k) { return k < 0 ? 0 : P(n, k) * f[k].second % M; }
ll H(int n, int k) { return n == 0 && k == 0 ? 1ll : C(n + k - 1, k); }
ll F(int n) { return n < 0 ? 0 : f[n].first; }
};
ll C2(const int n) { return (ll)n * ~-n / 2; }
ll sum(const vi a) {
ll s = 0;
for (int e : a) {
s += e;
}
return s;
}
ll sum(const vl a) {
ll s = 0;
for (ll e : a) {
s += e;
}
return s;
}
template <typename T> int MSB(T N) {
int r = -1;
for (; N > 0; N /= 2) {
++r;
}
return r;
}
template <typename T> class SegmentTree {
vector<T> S;
T (*const op)(T a, T b);
const T zero;
const int B;
public:
SegmentTree(int N, T (*f)(T a, T b), const T zero)
: S(1 << MSB(N - 1) + 2, zero), op(f), zero(zero),
B(1 << MSB(N - 1) + 1) {}
SegmentTree(vector<T> v, T (*f)(T a, T b), const T zero)
: SegmentTree(v.size(), f, zero) {
fr(i, v.size()) { S[S.size() / 2 + i] = v[i]; }
roof(i, S.size() / 2 - 1, 1) { S[i] = op(S[i * 2], S[i * 2 + 1]); }
}
T calc(int l, int r) {
l += B;
r += B;
if (l > r) {
return zero;
}
if (l == r) {
return S[l];
}
T L = S[l], R = S[r];
for (; l / 2 < r / 2; l /= 2, r /= 2) {
if (l % 2 == 0) {
L = op(L, S[l + 1]);
}
if (r % 2 == 1) {
R = op(S[r - 1], R);
}
}
return op(L, R);
}
void replace(int i, T x) {
for (S[i += B] = x; i != 1; i /= 2) {
if (i % 2) {
S[i / 2] = op(S[i - 1], S[i]);
} else {
S[i / 2] = op(S[i], S[i + 1]);
}
}
}
void add(int i, T x) { replace(i, op(S[B + i], x)); }
T top() { return S[1]; }
};
ll BITsum(vl &B, int i) {
ll z = 0;
while (i > 0) {
z += B[i];
i -= i & -i;
}
return z;
}
void BITadd(vl &B, int i, ll x) {
while (i < B.size()) {
B[i] += x;
i += i & -i;
}
}
ll fib(const ll n, const int m) {
ll a, b, c, d, A, B, C, D;
a = 1;
b = 0;
c = 0;
d = 1;
rf(i, 63) {
A = a * a + b * c;
B = a * b + b * d;
C = c * a + d * c;
D = c * b + d * d;
if (n >> i & 1) {
a = A;
b = B;
c = C;
d = D;
A = a + b;
B = a;
C = c + d;
D = c;
}
a = A % m;
b = B % m;
c = C % m;
d = D % m;
}
return b;
}
vi primes(int n) {
vb b(n + 1);
vi p;
foor(i, 2, n) {
if (!b[i]) {
p << i;
for (int j = 2 * i; j <= n; j += i) {
b[j] = true;
}
}
}
return p;
}
vb isprime(const int n) {
vb v(n + 1, true);
v[0] = v[1] = false;
foor(i, 2, n) {
if (v[i]) {
for (int j = 2 * i; j <= n; j += i) {
v[j] = false;
}
}
}
return v;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vl s(N);
cin >> s;
ll z = 0;
foor(i, 2, N - 1) {
ll x = 0;
vb b(N);
for (int l = 0, r = N - 1; l < N; l += i, r -= i) {
b[l] = true;
if (b[r])
break;
x += s[l] + s[r];
chmax(z, x);
}
}
print(z);
}
| #include <bits/stdc++.h>
#define fr(i, n) for (int i = 0; i < (n); ++i)
#define foor(i, a, b) for (int i = (a); i <= (b); ++i)
#define rf(i, n) for (int i = (n); i--;)
#define roof(i, b, a) for (int i = (b); i >= (a); --i)
#define elsif else if
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define Reverse(x) reverse(all(x))
#define PQ priority_queue
#define NP(x) next_permutation(all(x))
#define M_PI 3.14159265358979323846
#define popcount __builtin_popcount
using namespace std;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef unsigned long long ull;
typedef vector<ull> vu;
typedef vector<vu> vvu;
typedef double dbl;
typedef vector<dbl> vd;
typedef vector<vd> vvd;
typedef string str;
typedef vector<str> vs;
typedef vector<vs> vvs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef map<int, int> mii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef map<ll, ll> mll;
typedef pair<dbl, dbl> pdd;
typedef vector<pdd> vpdd;
typedef map<dbl, dbl> mdd;
typedef pair<str, str> pss;
typedef vector<pss> vpss;
typedef map<str, str> mss;
typedef pair<int, ll> pil;
typedef vector<pil> vpil;
typedef map<int, ll> mil;
typedef pair<ll, int> pli;
typedef vector<pli> vpli;
typedef map<ll, int> mli;
typedef pair<dbl, int> pdi;
typedef vector<pdi> vpdi;
typedef map<dbl, int> mdi;
template <typename T> vector<T> &operator<<(vector<T> &v, const T t) {
v.push_back(t);
return v;
}
template <typename T> multiset<T> &operator<<(multiset<T> &m, const T t) {
m.insert(t);
return m;
}
template <typename T> set<T> &operator<<(set<T> &s, const T t) {
s.insert(t);
return s;
}
template <typename T> stack<T> &operator<<(stack<T> &s, const T t) {
s.push(t);
return s;
}
template <typename T> stack<T> &operator>>(stack<T> &s, T &t) {
t = s.top();
s.pop();
return s;
}
template <typename T> queue<T> &operator<<(queue<T> &q, const T t) {
q.push(t);
return q;
}
template <typename T> queue<T> &operator>>(queue<T> &q, T &t) {
t = q.front();
q.pop();
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator<<(PQ<T, vector<T>, U> &q, const T t) {
q.push(t);
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator>>(PQ<T, vector<T>, U> &q, T &t) {
t = q.top();
q.pop();
return q;
}
template <typename T, typename U>
istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <typename T> istream &operator>>(istream &s, vector<T> &v) {
fr(i, v.size()) { s >> v[i]; }
return s;
}
template <typename T, typename U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
// template<typename T>ostream&operator<<(ostream&s,const vector<T>v){for(auto
// a:v){s<<a<<endl;}return s;}
template <typename T> ostream &operator<<(ostream &s, const vector<T> v) {
fr(i, v.size()) { i ? s << " " << v[i] : s << v[i]; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const deque<T> d) {
fr(i, d.size()) { i ? s << " " << d[i] : s << d[i]; }
return s;
}
template <typename T> _Bit_reference operator&=(_Bit_reference b, T t) {
return b = b & t;
}
template <typename T> _Bit_reference operator^=(_Bit_reference b, T t) {
return b = b ^ t;
}
template <typename T> _Bit_reference operator|=(_Bit_reference b, T t) {
return b = b | t;
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
void print(void) { cout << endl; }
template <typename T> void print(T t) { cout << t << endl; }
template <typename T, typename... U> void print(T &&t, U &&...u) {
cout << t << " ";
print(forward<U>(u)...);
}
bool YN(bool b) {
print(b ? "YES" : "NO");
return b;
}
bool PI(bool b) {
print(b ? "POSSIBLE" : "IMPOSSIBLE");
return b;
}
bool Yn(bool b) {
print(b ? "Yes" : "No");
return b;
}
bool Pi(bool b) {
print(b ? "Possible" : "Impossible");
return b;
}
bool yn(bool b) {
print(b ? "yes" : "no");
return b;
}
bool pi(bool b) {
print(b ? "possible" : "impossible");
return b;
}
const int e5 = 1e5;
const int e9 = 1e9;
const int MD = 1e9 + 7;
const ll e18 = 1e18;
template <typename T> str to_string(const T &n) {
ostringstream s;
s << n;
return s.str();
}
template <typename T> T &chmax(T &a, T b) { return a = max(a, b); }
template <typename T> T &chmin(T &a, T b) { return a = min(a, b); }
template <typename T, typename U>
vector<pair<T, U>> dijkstra(const vector<vector<pair<T, U>>> &E, const U s,
const T inf) {
using P = pair<T, U>;
vector<P> d;
fr(i, E.size()) { d << P{inf, i}; }
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
template <typename T, typename U>
map<U, pair<T, U>> dijkstra(map<U, vector<pair<T, U>>> E, const U s,
const T inf) {
using P = pair<T, U>;
map<U, P> d;
for (pair<U, vector<P>> e : E) {
d[e.first] = P{inf, e.first};
}
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
ll maxflow(vector<mil> &E, int s, int t) {
ll z = 0;
vi b(E.size(), -1);
for (int i = 0;; ++i) {
static auto dfs = [&](int v, ll f, auto &dfs) -> ll {
if (v == t)
return f;
b[v] = i;
for (auto &p : E[v]) {
if (b[p.first] < i && p.second) {
if (ll r = dfs(p.first, min(f, p.second), dfs)) {
p.second -= r;
E[p.first][v] += r;
return r;
}
}
}
return 0;
};
ll x = dfs(s, ll(1e18), dfs);
z += x;
if (x == 0)
return z;
}
}
template <typename T> T distsq(pair<T, T> a, pair<T, T> b) {
return (a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second);
}
template <typename T> T max(const vector<T> a) {
T m = a[0];
for (T e : a) {
m = max(m, e);
}
return m;
}
template <typename T> T min(const vector<T> a) {
T m = a[0];
for (T e : a) {
m = min(m, e);
}
return m;
}
template <typename T> T gcd(const T a, const T b) {
return a ? gcd(b % a, a) : b;
}
template <typename T> T gcd(const vector<T> a) {
T g = a[0];
for (T e : a) {
g = gcd(g, e);
}
return g;
}
template <typename T> vector<T> LIS(const vector<T> A) {
vector<T> B;
for (T a : A) {
auto it = lower_bound(all(B), a);
if (it == B.end()) {
B << a;
} else {
*it = a;
}
}
return B;
}
template <typename T> vector<T> LCS(vector<T> A, vector<T> B) {
int N = A.size(), M = B.size();
vector<vector<pair<int, pii>>> d(N + 1, vector<pair<int, pii>>(M + 1));
fr(i, N) {
fr(j, M) {
if (A[i] == B[j]) {
d[i + 1][j + 1] = {d[i][j].first + 1, {i, j}};
} else {
d[i + 1][j + 1] = max(d[i][j + 1], d[i + 1][j]);
}
}
}
vector<T> r;
for (pii p = {N, M}; d[p.first][p.second].first;
p = d[p.first][p.second].second) {
r << A[d[p.first][p.second].second.first];
}
Reverse(r);
return r;
}
str LCS(str S, str T) {
vector<char> s =
LCS(vector<char>(S.begin(), S.end()), vector<char>(T.begin(), T.end()));
return str(s.begin(), s.end());
}
template <typename T> vector<pair<T, T>> ConvexHull(vector<pair<T, T>> V) {
if (V.size() <= 3) {
return V;
}
Sort(V);
rf(i, V.size() - 1) V << V[i];
vector<pair<T, T>> r;
for (pair<T, T> p : V) {
int s = r.size();
while (s >= 2 &&
(p.second - r[s - 1].second) * (p.first - r[s - 2].first) <
(p.second - r[s - 2].second) * (p.first - r[s - 1].first)) {
r.pop_back();
--s;
}
r << p;
}
r.pop_back();
return r;
}
class UnionFind {
vi p, s;
void extend(int N) {
foor(i, p.size(), N) {
p << i;
s << 1;
}
}
public:
UnionFind(void) {}
UnionFind(int N) { extend(N - 1); }
int find(int i) {
extend(i);
return p[i] = p[i] == i ? i : find(p[i]);
}
void unite(int a, int b) {
extend(a);
extend(b);
if ((a = find(a)) != (b = find(b))) {
if (s[a] > s[b]) {
swap(a, b);
}
s[b] += s[a];
p[a] = b;
}
}
void unite(pii p) { return unite(p.first, p.second); }
bool same(int a, int b) {
extend(a);
extend(b);
return find(a) == find(b);
}
bool same(pii p) { return same(p.first, p.second); }
int size(int x) {
extend(x);
return s[find(x)];
}
};
ll MST(vector<pair<ll, pii>> &E) {
Sort(E);
UnionFind uf;
ll z = 0;
for (auto &e : E) {
if (!uf.same(e.second)) {
z += e.first;
uf.unite(e.second);
}
}
return z;
}
ll strmod(const str &s, const int m) {
ll x = 0;
fr(i, s.size()) { x = (x * 10 + s[i] - 48) % m; }
return x;
}
vvl mul(const vvl &A, const vvl &B, const int m) {
vvl C;
fr(y, A.size()) { C << vl(B[y].size()); }
fr(y, C.size()) {
fr(x, C[y].size()) {
fr(i, A[0].size()) { (C[y][x] += A[y][i] * B[i][x]) %= m; }
}
}
return C;
}
vvl pow(const vvl &A, const ll n, const int m) {
vvl B;
fr(y, A.size()) { B << vl(A.size()); }
if (n == 0) {
fr(i, B.size()) { B[i][i] = 1; }
}
elsif(n % 2) { B = mul(A, pow(A, n - 1, m), m); }
else {
vvl C = pow(A, n / 2, m);
B = mul(C, C, m);
}
return B;
}
ll pow(const ll a, const ll n, const int m) {
ll t;
return n ? (n & 1 ? a >= 0 ? a % m : (m - (-a % m)) % m : 1) *
(t = pow(a, n >> 1, m), t * t % m) % m
: !!a;
}
ll inv(const ll x, const int p) { return pow(x, p - 2, p); }
ll inv(const ll x) { return inv(x, MD); }
vpll fact(const int n, const int p) {
vpll v(n + 1);
v[0].first = 1;
foor(i, 1, n) { v[i].first = v[i - 1].first * i % p; }
v[n].second = inv(v[n].first, p);
roof(i, n, 1) { v[i - 1].second = v[i].second * i % p; }
return v;
}
class Combination {
const vpll f;
const int M;
public:
Combination(int n, int m) : f(fact(n, m)), M(m) {}
Combination(int n) : Combination(n, MD) {}
ll P(int n, int k) {
return n < 0 || k < 0 || n < k ? 0ll : f[n].first * f[n - k].second % M;
}
ll C(int n, int k) { return k < 0 ? 0 : P(n, k) * f[k].second % M; }
ll H(int n, int k) { return n == 0 && k == 0 ? 1ll : C(n + k - 1, k); }
ll F(int n) { return n < 0 ? 0 : f[n].first; }
};
ll C2(const int n) { return (ll)n * ~-n / 2; }
ll sum(const vi a) {
ll s = 0;
for (int e : a) {
s += e;
}
return s;
}
ll sum(const vl a) {
ll s = 0;
for (ll e : a) {
s += e;
}
return s;
}
template <typename T> int MSB(T N) {
int r = -1;
for (; N > 0; N /= 2) {
++r;
}
return r;
}
template <typename T> class SegmentTree {
vector<T> S;
T (*const op)(T a, T b);
const T zero;
const int B;
public:
SegmentTree(int N, T (*f)(T a, T b), const T zero)
: S(1 << MSB(N - 1) + 2, zero), op(f), zero(zero),
B(1 << MSB(N - 1) + 1) {}
SegmentTree(vector<T> v, T (*f)(T a, T b), const T zero)
: SegmentTree(v.size(), f, zero) {
fr(i, v.size()) { S[S.size() / 2 + i] = v[i]; }
roof(i, S.size() / 2 - 1, 1) { S[i] = op(S[i * 2], S[i * 2 + 1]); }
}
T calc(int l, int r) {
l += B;
r += B;
if (l > r) {
return zero;
}
if (l == r) {
return S[l];
}
T L = S[l], R = S[r];
for (; l / 2 < r / 2; l /= 2, r /= 2) {
if (l % 2 == 0) {
L = op(L, S[l + 1]);
}
if (r % 2 == 1) {
R = op(S[r - 1], R);
}
}
return op(L, R);
}
void replace(int i, T x) {
for (S[i += B] = x; i != 1; i /= 2) {
if (i % 2) {
S[i / 2] = op(S[i - 1], S[i]);
} else {
S[i / 2] = op(S[i], S[i + 1]);
}
}
}
void add(int i, T x) { replace(i, op(S[B + i], x)); }
T top() { return S[1]; }
};
ll BITsum(vl &B, int i) {
ll z = 0;
while (i > 0) {
z += B[i];
i -= i & -i;
}
return z;
}
void BITadd(vl &B, int i, ll x) {
while (i < B.size()) {
B[i] += x;
i += i & -i;
}
}
ll fib(const ll n, const int m) {
ll a, b, c, d, A, B, C, D;
a = 1;
b = 0;
c = 0;
d = 1;
rf(i, 63) {
A = a * a + b * c;
B = a * b + b * d;
C = c * a + d * c;
D = c * b + d * d;
if (n >> i & 1) {
a = A;
b = B;
c = C;
d = D;
A = a + b;
B = a;
C = c + d;
D = c;
}
a = A % m;
b = B % m;
c = C % m;
d = D % m;
}
return b;
}
vi primes(int n) {
vb b(n + 1);
vi p;
foor(i, 2, n) {
if (!b[i]) {
p << i;
for (int j = 2 * i; j <= n; j += i) {
b[j] = true;
}
}
}
return p;
}
vb isprime(const int n) {
vb v(n + 1, true);
v[0] = v[1] = false;
foor(i, 2, n) {
if (v[i]) {
for (int j = 2 * i; j <= n; j += i) {
v[j] = false;
}
}
}
return v;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vl s(N);
cin >> s;
ll z = 0;
foor(i, 1, N - 1) {
ll x = 0;
vb b(N);
for (int l = 0, r = N - 1; l < N - i; l += i, r -= i) {
b[l] = true;
if (b[r])
break;
x += s[l] + s[r];
chmax(z, x);
}
}
print(z);
}
| [
"literal.number.change",
"call.arguments.change",
"control_flow.loop.for.condition.change"
] | 844,808 | 844,807 | u283869437 | cpp |
p03034 | #include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <chrono>
#include <random>
#include <thread>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define all(c) c.begin(), c.end()
#define repeat(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ",";
os << *it;
}
return os << "}";
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &v) {
os << "{";
os << v.first << ", " << v.second;
return os << "}";
}
// ---------------------------------------------------------------------------
using point = complex<double>;
using ll = int64_t;
int my_main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
vector<ll> s(n);
for (ll &i : s)
cin >> i;
ll ret = 0;
for (ll c = 1; c < n - 1; c++) {
vector<bool> used(n, false);
ll sum = 0;
for (ll k = 1; (n - 1) - (k * c) < c; k++) {
ll a0 = (n - 1) - k * c;
ll a1 = k * c;
if (used[a0])
break;
used[a0] = true;
if (used[a1])
break;
used[a1] = true;
sum += s[a0] + s[a1];
ret = max(ret, sum);
}
}
cout << ret << endl;
return 0;
}
// ----------------------------------------------------------------------------
// Test driver
#ifdef DEBUG
#define MAY_RUN_TESTCASE
#endif
#ifdef MAY_RUN_TESTCASE
#include <fstream>
#if __has_include(<unistd.h>)
// Mac, Linux
#include <unistd.h>
#elif __has_include(<io.h>)
// Windows
#include <io.h>
#else
// Other?
#error "unistd.h or io.h not found"
#endif
bool test_file_exists(const std::string &str) {
std::ifstream fs(str);
return fs.is_open();
}
#endif
int main(int argc, char **argv) {
#ifndef MAY_RUN_TESTCASE
return my_main(argc, argv);
#else
if (argc == 1) {
return my_main(argc, argv);
} else if (argc == 2) {
char *stdin_file = argv[1];
freopen(stdin_file, "r", stdin);
return my_main(argc, argv);
} else if (argc == 5) {
std::string stdin_file = argv[1];
std::string expected_file = argv[2];
std::string stdout_file = argv[3];
std::string stderr_file = argv[4];
if (!test_file_exists(stdin_file)) {
std::cerr << stdin_file << " not found" << std::endl;
return 3;
}
if (!test_file_exists(expected_file)) {
std::cerr << expected_file << " not found" << std::endl;
return 3;
}
int original_stdin = dup(fileno(stdin));
int original_stdout = dup(fileno(stdout));
int original_stderr = dup(fileno(stderr));
freopen(stdin_file.c_str(), "r", stdin);
freopen(stdout_file.c_str(), "w", stdout);
freopen(stderr_file.c_str(), "w", stderr);
int ret = my_main(argc, argv);
fflush(stdout);
fflush(stderr);
dup2(original_stderr, fileno(stderr));
dup2(original_stdout, fileno(stdout));
dup2(original_stdin, fileno(stdin));
if (ret != 0) {
std::cerr << "main returns " << ret << std::endl;
return ret;
}
std::ifstream inp(stdin_file);
std::ifstream out(stdout_file);
std::ifstream err(stderr_file);
std::ifstream exp(expected_file);
// Clear is needed if the file is empty.
std::cout << "----- input -----" << std::endl;
std::cout << inp.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "----- output ----" << std::endl;
std::cout << out.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "---- expected ---" << std::endl;
std::cout << exp.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "----- stderr ----" << std::endl;
std::cout << err.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl;
inp.seekg(0);
out.seekg(0);
exp.seekg(0);
err.seekg(0);
std::string output_str, expected_str;
{
std::stringstream output_ss;
output_ss << out.rdbuf();
output_str = output_ss.str();
std::stringstream expected_ss;
expected_ss << exp.rdbuf();
expected_str = expected_ss.str();
}
// Remove trailing spaces
output_str.erase(output_str.find_last_not_of(" \n\r\t") + 1);
expected_str.erase(expected_str.find_last_not_of(" \n\r\t") + 1);
if (output_str == expected_str)
return 0;
else
return 1;
}
return 1;
#endif
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <chrono>
#include <random>
#include <thread>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define all(c) c.begin(), c.end()
#define repeat(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ",";
os << *it;
}
return os << "}";
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &v) {
os << "{";
os << v.first << ", " << v.second;
return os << "}";
}
// ---------------------------------------------------------------------------
using point = complex<double>;
using ll = int64_t;
int my_main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
vector<ll> s(n);
for (ll &i : s)
cin >> i;
ll ret = 0;
for (ll c = 1; c < n - 1; c++) {
vector<bool> used(n, false);
ll sum = 0;
for (ll k = 1; c < (n - 1 - k * c); k++) {
ll a0 = (n - 1) - k * c;
ll a1 = k * c;
if (used[a0])
break;
used[a0] = true;
if (used[a1])
break;
used[a1] = true;
sum += s[a0] + s[a1];
ret = max(ret, sum);
}
}
cout << ret << endl;
return 0;
}
// ----------------------------------------------------------------------------
// Test driver
#ifdef DEBUG
#define MAY_RUN_TESTCASE
#endif
#ifdef MAY_RUN_TESTCASE
#include <fstream>
#if __has_include(<unistd.h>)
// Mac, Linux
#include <unistd.h>
#elif __has_include(<io.h>)
// Windows
#include <io.h>
#else
// Other?
#error "unistd.h or io.h not found"
#endif
bool test_file_exists(const std::string &str) {
std::ifstream fs(str);
return fs.is_open();
}
#endif
int main(int argc, char **argv) {
#ifndef MAY_RUN_TESTCASE
return my_main(argc, argv);
#else
if (argc == 1) {
return my_main(argc, argv);
} else if (argc == 2) {
char *stdin_file = argv[1];
freopen(stdin_file, "r", stdin);
return my_main(argc, argv);
} else if (argc == 5) {
std::string stdin_file = argv[1];
std::string expected_file = argv[2];
std::string stdout_file = argv[3];
std::string stderr_file = argv[4];
if (!test_file_exists(stdin_file)) {
std::cerr << stdin_file << " not found" << std::endl;
return 3;
}
if (!test_file_exists(expected_file)) {
std::cerr << expected_file << " not found" << std::endl;
return 3;
}
int original_stdin = dup(fileno(stdin));
int original_stdout = dup(fileno(stdout));
int original_stderr = dup(fileno(stderr));
freopen(stdin_file.c_str(), "r", stdin);
freopen(stdout_file.c_str(), "w", stdout);
freopen(stderr_file.c_str(), "w", stderr);
int ret = my_main(argc, argv);
fflush(stdout);
fflush(stderr);
dup2(original_stderr, fileno(stderr));
dup2(original_stdout, fileno(stdout));
dup2(original_stdin, fileno(stdin));
if (ret != 0) {
std::cerr << "main returns " << ret << std::endl;
return ret;
}
std::ifstream inp(stdin_file);
std::ifstream out(stdout_file);
std::ifstream err(stderr_file);
std::ifstream exp(expected_file);
// Clear is needed if the file is empty.
std::cout << "----- input -----" << std::endl;
std::cout << inp.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "----- output ----" << std::endl;
std::cout << out.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "---- expected ---" << std::endl;
std::cout << exp.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "----- stderr ----" << std::endl;
std::cout << err.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl;
inp.seekg(0);
out.seekg(0);
exp.seekg(0);
err.seekg(0);
std::string output_str, expected_str;
{
std::stringstream output_ss;
output_ss << out.rdbuf();
output_str = output_ss.str();
std::stringstream expected_ss;
expected_ss << exp.rdbuf();
expected_str = expected_ss.str();
}
// Remove trailing spaces
output_str.erase(output_str.find_last_not_of(" \n\r\t") + 1);
expected_str.erase(expected_str.find_last_not_of(" \n\r\t") + 1);
if (output_str == expected_str)
return 0;
else
return 1;
}
return 1;
#endif
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 844,817 | 844,818 | u419874471 | cpp |
p03034 | #include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <chrono>
#include <random>
#include <thread>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define all(c) c.begin(), c.end()
#define repeat(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ",";
os << *it;
}
return os << "}";
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &v) {
os << "{";
os << v.first << ", " << v.second;
return os << "}";
}
// ---------------------------------------------------------------------------
using point = complex<double>;
using ll = int64_t;
int my_main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
vector<ll> s(n);
for (ll &i : s)
cin >> i;
ll ret = 0;
for (ll c = 1; c < n - 1; c++) {
vector<bool> used(n, false);
ll sum = 0;
if (c >= n - 1 - c)
continue;
for (ll k = 1; (n - 1) - (k * c) > 0L; k++) {
if (n - 1 - c * k > c)
break;
ll a0 = (n - 1) - k * c;
ll a1 = k * c;
if (used[a0])
break;
used[a0] = true;
if (used[a1])
break;
used[a1] = true;
sum += s[a0] + s[a1];
ret = max(ret, sum);
}
}
cout << ret << endl;
return 0;
}
// ----------------------------------------------------------------------------
// Test driver
#ifdef DEBUG
#define MAY_RUN_TESTCASE
#endif
#ifdef MAY_RUN_TESTCASE
#include <fstream>
#if __has_include(<unistd.h>)
// Mac, Linux
#include <unistd.h>
#elif __has_include(<io.h>)
// Windows
#include <io.h>
#else
// Other?
#error "unistd.h or io.h not found"
#endif
bool test_file_exists(const std::string &str) {
std::ifstream fs(str);
return fs.is_open();
}
#endif
int main(int argc, char **argv) {
#ifndef MAY_RUN_TESTCASE
return my_main(argc, argv);
#else
if (argc == 1) {
return my_main(argc, argv);
} else if (argc == 2) {
char *stdin_file = argv[1];
freopen(stdin_file, "r", stdin);
return my_main(argc, argv);
} else if (argc == 5) {
std::string stdin_file = argv[1];
std::string expected_file = argv[2];
std::string stdout_file = argv[3];
std::string stderr_file = argv[4];
if (!test_file_exists(stdin_file)) {
std::cerr << stdin_file << " not found" << std::endl;
return 3;
}
if (!test_file_exists(expected_file)) {
std::cerr << expected_file << " not found" << std::endl;
return 3;
}
int original_stdin = dup(fileno(stdin));
int original_stdout = dup(fileno(stdout));
int original_stderr = dup(fileno(stderr));
freopen(stdin_file.c_str(), "r", stdin);
freopen(stdout_file.c_str(), "w", stdout);
freopen(stderr_file.c_str(), "w", stderr);
int ret = my_main(argc, argv);
fflush(stdout);
fflush(stderr);
dup2(original_stderr, fileno(stderr));
dup2(original_stdout, fileno(stdout));
dup2(original_stdin, fileno(stdin));
if (ret != 0) {
std::cerr << "main returns " << ret << std::endl;
return ret;
}
std::ifstream inp(stdin_file);
std::ifstream out(stdout_file);
std::ifstream err(stderr_file);
std::ifstream exp(expected_file);
// Clear is needed if the file is empty.
std::cout << "----- input -----" << std::endl;
std::cout << inp.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "----- output ----" << std::endl;
std::cout << out.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "---- expected ---" << std::endl;
std::cout << exp.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "----- stderr ----" << std::endl;
std::cout << err.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl;
inp.seekg(0);
out.seekg(0);
exp.seekg(0);
err.seekg(0);
std::string output_str, expected_str;
{
std::stringstream output_ss;
output_ss << out.rdbuf();
output_str = output_ss.str();
std::stringstream expected_ss;
expected_ss << exp.rdbuf();
expected_str = expected_ss.str();
}
// Remove trailing spaces
output_str.erase(output_str.find_last_not_of(" \n\r\t") + 1);
expected_str.erase(expected_str.find_last_not_of(" \n\r\t") + 1);
if (output_str == expected_str)
return 0;
else
return 1;
}
return 1;
#endif
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#include <cassert>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <chrono>
#include <random>
#include <thread>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define all(c) c.begin(), c.end()
#define repeat(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ",";
os << *it;
}
return os << "}";
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &v) {
os << "{";
os << v.first << ", " << v.second;
return os << "}";
}
// ---------------------------------------------------------------------------
using point = complex<double>;
using ll = int64_t;
int my_main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
vector<ll> s(n);
for (ll &i : s)
cin >> i;
ll ret = 0;
for (ll c = 1; c < n - 1; c++) {
vector<bool> used(n, false);
ll sum = 0;
if (c >= n - 1 - c)
continue;
for (ll k = 1; (n - 1) - (k * c) > 0L; k++) {
if (n - 1 - c * k <= c)
break;
ll a0 = (n - 1) - k * c;
ll a1 = k * c;
if (used[a0])
break;
used[a0] = true;
if (used[a1])
break;
used[a1] = true;
sum += s[a0] + s[a1];
ret = max(ret, sum);
}
}
cout << ret << endl;
return 0;
}
// ----------------------------------------------------------------------------
// Test driver
#ifdef DEBUG
#define MAY_RUN_TESTCASE
#endif
#ifdef MAY_RUN_TESTCASE
#include <fstream>
#if __has_include(<unistd.h>)
// Mac, Linux
#include <unistd.h>
#elif __has_include(<io.h>)
// Windows
#include <io.h>
#else
// Other?
#error "unistd.h or io.h not found"
#endif
bool test_file_exists(const std::string &str) {
std::ifstream fs(str);
return fs.is_open();
}
#endif
int main(int argc, char **argv) {
#ifndef MAY_RUN_TESTCASE
return my_main(argc, argv);
#else
if (argc == 1) {
return my_main(argc, argv);
} else if (argc == 2) {
char *stdin_file = argv[1];
freopen(stdin_file, "r", stdin);
return my_main(argc, argv);
} else if (argc == 5) {
std::string stdin_file = argv[1];
std::string expected_file = argv[2];
std::string stdout_file = argv[3];
std::string stderr_file = argv[4];
if (!test_file_exists(stdin_file)) {
std::cerr << stdin_file << " not found" << std::endl;
return 3;
}
if (!test_file_exists(expected_file)) {
std::cerr << expected_file << " not found" << std::endl;
return 3;
}
int original_stdin = dup(fileno(stdin));
int original_stdout = dup(fileno(stdout));
int original_stderr = dup(fileno(stderr));
freopen(stdin_file.c_str(), "r", stdin);
freopen(stdout_file.c_str(), "w", stdout);
freopen(stderr_file.c_str(), "w", stderr);
int ret = my_main(argc, argv);
fflush(stdout);
fflush(stderr);
dup2(original_stderr, fileno(stderr));
dup2(original_stdout, fileno(stdout));
dup2(original_stdin, fileno(stdin));
if (ret != 0) {
std::cerr << "main returns " << ret << std::endl;
return ret;
}
std::ifstream inp(stdin_file);
std::ifstream out(stdout_file);
std::ifstream err(stderr_file);
std::ifstream exp(expected_file);
// Clear is needed if the file is empty.
std::cout << "----- input -----" << std::endl;
std::cout << inp.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "----- output ----" << std::endl;
std::cout << out.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "---- expected ---" << std::endl;
std::cout << exp.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl << std::endl;
std::cout << "----- stderr ----" << std::endl;
std::cout << err.rdbuf() << std::endl;
std::cout.clear();
std::cout << "-----------------" << std::endl;
inp.seekg(0);
out.seekg(0);
exp.seekg(0);
err.seekg(0);
std::string output_str, expected_str;
{
std::stringstream output_ss;
output_ss << out.rdbuf();
output_str = output_ss.str();
std::stringstream expected_ss;
expected_ss << exp.rdbuf();
expected_str = expected_ss.str();
}
// Remove trailing spaces
output_str.erase(output_str.find_last_not_of(" \n\r\t") + 1);
expected_str.erase(expected_str.find_last_not_of(" \n\r\t") + 1);
if (output_str == expected_str)
return 0;
else
return 1;
}
return 1;
#endif
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,819 | 844,820 | u419874471 | cpp |
p03034 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pii;
const ll MOD = 1000000007;
const long double EPS = 1e-10;
const int dyx[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<ll> s(n);
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
ll score = 0LL;
for (int c = 1; c < n / 2; ++c) {
ll tmp_score = 0LL;
if ((n - 1) % c) {
for (int x = 0; n - 1 - c * x <= c; ++x) {
tmp_score += s[c * x] + s[n - 1 - c * x];
score = max(score, tmp_score);
}
} else {
for (int x = 0; c * x < n - 1 - c * x; ++x) {
tmp_score += s[c * x] + s[n - 1 - c * x];
score = max(score, tmp_score);
}
}
}
cout << score << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pii;
const ll MOD = 1000000007;
const long double EPS = 1e-10;
const int dyx[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<ll> s(n);
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
ll score = 0LL;
for (int c = 1; c < n / 2; ++c) {
ll tmp_score = 0LL;
if ((n - 1) % c) {
for (int x = 0; n - 1 - c * x >= c; ++x) {
tmp_score += s[c * x] + s[n - 1 - c * x];
score = max(score, tmp_score);
}
} else {
for (int x = 0; c * x < n - 1 - c * x; ++x) {
tmp_score += s[c * x] + s[n - 1 - c * x];
score = max(score, tmp_score);
}
}
}
cout << score << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,852 | 844,853 | u986399983 | cpp |
p03034 | //
// abc128_f.cpp
//
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;
int main() {
int n;
cin >> n;
vector<int> seq(n);
for (int i = 0; i < n; ++i) {
cin >> seq[i];
}
long long ret = 0;
for (int j = 1; j < n; ++j) {
long long s = 0;
for (int k = 1; j + k < n - 1; k += j) {
if (k >= (n - 1 - k) && (n - 1) % j == 0)
break;
s += seq[k] + seq[n - 1 - k];
ret = max(ret, s);
}
}
cout << ret << endl;
return 0;
}
| //
// abc128_f.cpp
//
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;
int main() {
int n;
cin >> n;
vector<int> seq(n);
for (int i = 0; i < n; ++i) {
cin >> seq[i];
}
long long ret = 0;
for (int j = 1; j < n; ++j) {
long long s = 0;
for (int k = 0; j + k < n - 1; k += j) {
if (k >= (n - 1 - k) && (n - 1) % j == 0)
break;
s += seq[k] + seq[n - 1 - k];
ret = max(ret, s);
}
}
cout << ret << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 844,866 | 844,867 | u038229929 | cpp |
p03034 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define rep(i, l, r) for (ll i = l; i <= r; i++)
ll N, M, a, b, c, t, ans, q[100007], qw[100007];
int main() {
scanf("%lld", &N);
rep(i, 1, N) scanf("%lld", &q[i]);
rep(i, 1, N) {
ll p1 = 1, p2 = N, s = 0;
while (p1 + i < N) {
p1 += i;
if (qw[p1] == i)
break;
s += q[p1];
qw[p1] = i;
p2 -= i;
if (qw[p2] == i)
break;
s += q[p2];
qw[p2] = i;
if (p2 <= i)
ans = max(ans, s);
}
}
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define rep(i, l, r) for (ll i = l; i <= r; i++)
ll N, M, a, b, c, t, ans, q[100007], qw[100007];
int main() {
scanf("%lld", &N);
rep(i, 1, N) scanf("%lld", &q[i]);
rep(i, 1, N) {
ll p1 = 1, p2 = N, s = 0;
while (p1 + i < N) {
p1 += i;
if (qw[p1] == i)
break;
s += q[p1];
qw[p1] = i;
p2 -= i;
if (qw[p2] == i)
break;
s += q[p2];
qw[p2] = i;
if (p2 > i + 1)
ans = max(ans, s);
}
}
printf("%lld\n", ans);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,869 | 844,870 | u371175444 | cpp |
p03034 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
using tlll = tuple<ll, ll, ll>;
using vs = vector<string>;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) range(i, 0, n)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define range(i, a, n) for (int i = (a); i < (n); i++)
#define LINF ((ll)1ll << 60)
#define INF ((int)1 << 30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout << setprecision(a) << fixed
#define fs first
#define sc second
#define PI 3.1415926535897932384
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1}, dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class S> S acm(vector<S> &a) { return accumulate(all(a), S()); }
template <class S> S max(vector<S> &a) { return *max_element(all(a)); }
template <class S> S min(vector<S> &a) { return *min_element(all(a)); }
void YN(bool b) { cout << (b ? "YES" : "NO") << "\n"; }
void Yn(bool b) { cout << (b ? "Yes" : "No") << "\n"; }
void yn(bool b) { cout << (b ? "yes" : "no") << "\n"; }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
template <class T> void puta(T &&t) { cout << t << "\n"; }
template <class H, class... T> void puta(H &&h, T &&...t) {
cout << h << ' ';
puta(t...);
}
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
};
template <class S> auto &operator<<(ostream &os, vector<S> t) {
bool a = 1;
for (auto s : t) {
os << (a ? "" : " ") << s;
a = 0;
}
return os;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
ll ans = 0;
cin >> n;
vl v(n);
rep(i, n) cin >> v[i];
for (int i = 1; i < n / 2; i++) {
ll sum = 0;
int l = 0, r = n - 1;
while (l < n && i < r && l + i < n) {
sum += v[l] + v[r];
chmax(ans, sum);
// puta(l,r,sum);
if (l + i == r)
l = n;
l += i, r -= i;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
using tlll = tuple<ll, ll, ll>;
using vs = vector<string>;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) range(i, 0, n)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define range(i, a, n) for (int i = (a); i < (n); i++)
#define LINF ((ll)1ll << 60)
#define INF ((int)1 << 30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout << setprecision(a) << fixed
#define fs first
#define sc second
#define PI 3.1415926535897932384
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1}, dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class S> S acm(vector<S> &a) { return accumulate(all(a), S()); }
template <class S> S max(vector<S> &a) { return *max_element(all(a)); }
template <class S> S min(vector<S> &a) { return *min_element(all(a)); }
void YN(bool b) { cout << (b ? "YES" : "NO") << "\n"; }
void Yn(bool b) { cout << (b ? "Yes" : "No") << "\n"; }
void yn(bool b) { cout << (b ? "yes" : "no") << "\n"; }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
template <class T> void puta(T &&t) { cout << t << "\n"; }
template <class H, class... T> void puta(H &&h, T &&...t) {
cout << h << ' ';
puta(t...);
}
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
};
template <class S> auto &operator<<(ostream &os, vector<S> t) {
bool a = 1;
for (auto s : t) {
os << (a ? "" : " ") << s;
a = 0;
}
return os;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
ll ans = 0;
cin >> n;
vl v(n);
rep(i, n) cin >> v[i];
for (int i = 1; i < n / 2; i++) {
ll sum = 0;
int l = 0, r = n - 1;
while (l < n && i < r && l + i < n && l != r) {
sum += v[l] + v[r];
chmax(ans, sum);
// puta(l,r,sum);
if (l + i == r)
l = n;
l += i, r -= i;
}
}
cout << ans << endl;
}
| [
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change"
] | 844,871 | 844,872 | u591883167 | cpp |
p03034 | #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for (LL i = (l); i < (r); ++i)
#define incII(i, l, r) for (LL i = (l); i <= (r); ++i)
#define decID(i, l, r) for (LL i = (r)-1; i >= (l); --i)
#define decII(i, l, r) for (LL i = (r); i >= (l); --i)
#define inc(i, n) incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n) decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inID(v, l, r) ((l) <= (v) && (v) < (r))
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
template <typename T> bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmineq(T &a, T b) {
if (b <= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmaxeq(T &a, T b) {
if (b >= a) {
a = b;
return true;
} else {
return false;
}
}
LL mo(LL a, LL b) {
assert(b > 0);
a %= b;
if (a < 0) {
a += b;
}
return a;
}
LL fl(LL a, LL b) {
assert(b > 0);
return (a > 0 ? a / b : (a - b + 1) / b);
}
LL ce(LL a, LL b) {
assert(b > 0);
return (a < 0 ? a / b : (a + b - 1) / b);
}
template <typename T> T gcd(T a, T b) { return (b == 0 ? a : gcd(b, a % b)); }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
#define bit(b, i) (((b) >> (i)) & 1)
#define BC __builtin_popcountll
#define SC static_cast
#define SI(v) SC<int>(v.size())
#define SL(v) SC<LL>(v.size())
#define RF(e, v) for (auto &e : v)
#define ef else if
#define UR assert(false)
// ---- ----
LL n, a[100000];
int main() {
cin >> n;
inc(i, n) { cin >> a[i]; }
LL ans = 0;
incII(d, 2, n - 1) {
LL x = 0, y = 0;
for (LL i = 0; i < n - 1; i += d) {
if ((n - 1) % d == 0 && i >= n - 1 - i) {
break;
}
if (i > n - 1 - d) {
break;
}
y += a[i] + a[n - 1 - i];
setmax(x, y);
}
setmax(ans, x);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for (LL i = (l); i < (r); ++i)
#define incII(i, l, r) for (LL i = (l); i <= (r); ++i)
#define decID(i, l, r) for (LL i = (r)-1; i >= (l); --i)
#define decII(i, l, r) for (LL i = (r); i >= (l); --i)
#define inc(i, n) incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n) decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inID(v, l, r) ((l) <= (v) && (v) < (r))
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
template <typename T> bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmineq(T &a, T b) {
if (b <= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmaxeq(T &a, T b) {
if (b >= a) {
a = b;
return true;
} else {
return false;
}
}
LL mo(LL a, LL b) {
assert(b > 0);
a %= b;
if (a < 0) {
a += b;
}
return a;
}
LL fl(LL a, LL b) {
assert(b > 0);
return (a > 0 ? a / b : (a - b + 1) / b);
}
LL ce(LL a, LL b) {
assert(b > 0);
return (a < 0 ? a / b : (a + b - 1) / b);
}
template <typename T> T gcd(T a, T b) { return (b == 0 ? a : gcd(b, a % b)); }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
#define bit(b, i) (((b) >> (i)) & 1)
#define BC __builtin_popcountll
#define SC static_cast
#define SI(v) SC<int>(v.size())
#define SL(v) SC<LL>(v.size())
#define RF(e, v) for (auto &e : v)
#define ef else if
#define UR assert(false)
// ---- ----
LL n, a[100000];
int main() {
cin >> n;
inc(i, n) { cin >> a[i]; }
LL ans = 0;
inc1(d, n - 1) {
LL x = 0, y = 0;
for (LL i = 0; i < n - 1; i += d) {
if ((n - 1) % d == 0 && i >= n - 1 - i) {
break;
}
if (i > n - 1 - d) {
break;
}
y += a[i] + a[n - 1 - i];
setmax(x, y);
}
setmax(ans, x);
}
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 844,892 | 844,893 | u568652083 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.