text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[207], b[207], id[207];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
id[i] = i;
b[i] = a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < n; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
temp = id[j];
id[j] = id[j + 1];
id[j + 1] = temp;
}
}
}
int res = -1007;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int temp = 0;
for (int t = i; t <= j; t++) temp += b[t];
int id_ = n;
int count_ = k;
while (id_ >= 1 && count_ > 0) {
if (id[id_] > j || id[id_] < i) {
if (temp + a[id_] > temp) {
temp = temp + a[id_];
count_--;
} else
break;
}
id_--;
}
count_ = k - count_;
for (int t = 1; t <= n; t++) {
if (id[t] >= i && id[t] <= j && count_ > 0) {
temp -= a[t];
count_--;
}
if (count_ == 0) break;
}
res = max(res, temp);
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXINT = 0x6fffffff;
const long long MAXLONG = (long long)1 << 60;
const int MAXN = 220;
int arr[MAXN];
int n, k;
int calc(vector<int> &vin, vector<int> &vout) {
for (long long i = (0); i < (k); i += 1) {
if (i >= vin.size() || i >= vout.size()) break;
if (vin[i] >= vout[i]) break;
swap(vin[i], vout[i]);
}
int res = accumulate(vin.begin(), vin.end(), 0);
return res;
}
int main() {
while (scanf("%d %d", &n, &k) != -1) {
for (long long i = (0); i < (n); i += 1) {
scanf("%d", &arr[i]);
}
int res = -MAXINT;
for (long long len = (1); len < (n + 1); len += 1) {
for (long long s = (0); s < (n - len + 1); s += 1) {
vector<int> vin, vout;
for (long long i = (0); i < (n); i += 1) {
if (s <= i && i <= s + len - 1) {
vin.push_back(arr[i]);
} else {
vout.push_back(arr[i]);
}
}
sort(vin.begin(), vin.end());
sort(vout.begin(), vout.end());
reverse(vout.begin(), vout.end());
int once = calc(vin, vout);
res = max(res, once);
}
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 222;
vector<int> v1, v2;
int a[maxn];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int ans = -1000000000;
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
int sum = 0;
v1.clear();
v2.clear();
for (int i = 1; i < l; i++) v1.push_back(a[i]);
for (int i = l; i <= r; i++) {
v2.push_back(a[i]);
sum += a[i];
}
for (int i = r + 1; i <= n; i++) v1.push_back(a[i]);
sort(v1.begin(), v1.end());
reverse(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
for (int i = 0; i < v1.size() && i < v2.size() && i < k; i++) {
if (v2[i] >= v1[i]) break;
sum += v1[i] - v2[i];
}
ans = max(ans, sum);
}
cout << ans << endl;
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205];
vector<int> in, out;
int main() {
int n, k;
int sol = -999999;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
int sum = 0;
in.clear();
out.clear();
for (int l = 0; l < n; l++) {
if (i <= l && l <= j)
in.push_back(a[l]);
else
out.push_back(a[l]);
}
sort(in.begin(), in.end());
sort(out.begin(), out.end());
reverse(out.begin(), out.end());
for (int l = 0; l < in.size(); l++) {
if (l < k && l < out.size())
sum += max(in[l], out[l]);
else
sum += in[l];
}
if (sum > sol) sol = sum;
}
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ret;
int a[205], aa[205], b[205];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
ret = a[0];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
int x = 0, y = 0, s = 0;
for (int k = 0; k < n; k++) {
if (k >= i && k <= j)
aa[x++] = a[k], s += a[k];
else
b[y++] = a[k];
}
sort(aa, aa + x);
sort(b, b + y);
reverse(b, b + y);
for (int k = 0; k < m; k++) {
if (k >= x || k >= y) break;
if (b[k] < aa[k]) break;
s += b[k] - aa[k];
}
ret = max(ret, s);
}
cout << ret;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans = -1000000007, temp_ans = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) ans = max(ans, a[i]);
for (int l = 0; l < n; l++) {
for (int r = l + 1; r < n; r++) {
vector<int> temp, rest;
for (int k = l; k <= r; k++) temp.push_back(a[k]);
for (int k = 0; k < l; k++) rest.push_back(a[k]);
for (int k = r + 1; k < n; k++) rest.push_back(a[k]);
sort(temp.begin(), temp.end());
sort(rest.rbegin(), rest.rend());
for (int i = 0; i < k; i++) {
if (i == (int)temp.size() || i == (int)rest.size()) break;
if (temp[i] < rest[i]) {
swap(temp[i], rest[i]);
} else
break;
}
for (int i = 0; i < (int)temp.size(); i++) temp_ans += temp[i];
ans = max(ans, temp_ans);
temp_ans = 0;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v, ve, b;
int main() {
long long m, ans = -1e10, n, k, a[1111];
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
long long sum = 0;
for (int k = i; k <= j; k++) {
sum += a[k];
v.push_back(a[k]);
}
for (int k = 1; k < i; k++) ve.push_back(a[k]);
for (int k = j + 1; k <= n; k++) ve.push_back(a[k]);
sort(v.begin(), v.end());
sort(ve.begin(), ve.end());
int l = 0, r = ve.size() - 1, p = m;
while ((p--) && l < v.size() && r >= 0) {
if (v[l] < ve[r]) {
sum -= v[l];
sum += ve[r];
l++;
r--;
}
}
ans = max(ans, sum);
v = b;
ve = b;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 202;
const int max_k = 11;
int n, k, m1, m2;
int a[max_n];
int b[max_n];
int c[max_n];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
int ans;
bool found = false;
for (int l = 0; l < n; ++l)
for (int r = l; r < n; ++r) {
m1 = r - l + 1;
for (int i = l; i <= r; ++i) b[i - l] = a[i];
sort(b, b + m1);
m2 = 0;
for (int i = 0; i < l; ++i) {
c[m2] = a[i];
++m2;
}
for (int i = r + 1; i < n; ++i) {
c[m2] = a[i];
++m2;
}
sort(c, c + m2);
for (int i = 0; i < k; ++i)
if (i < m1 && m2 - i - 1 >= 0) {
if (b[i] >= c[m2 - i - 1]) break;
b[i] = c[m2 - i - 1];
}
int cans = 0;
for (int i = 0; i < m1; ++i) cans += b[i];
if (!found || cans > ans) {
found = 1;
ans = cans;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[220], sum[220], oth[220], mine[220];
int main() {
int n, k;
scanf("%d %d", &n, &k);
sum[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
int best = -200000000;
for (int l = 1; l <= n; l++) {
for (int r = l; r <= n; r++) {
int pos = 0, pmine = 0;
for (int i = 1; i <= n; i++) {
if (l <= i && i <= r) {
mine[pmine++] = a[i];
}
if (!(l <= i && i <= r)) {
oth[pos++] = a[i];
}
}
sort(oth, oth + pos, greater<int>());
sort(mine, mine + pmine);
int s = sum[r] - sum[l - 1];
for (int i = 0; i < k && i < pos && i < pmine; i++) {
if (oth[i] > mine[i]) {
s += oth[i] - mine[i];
}
}
if (s > best) best = s;
}
}
printf("%d\n", best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a[200], ans = -(0x3f3f3f3f);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
vector<int> u, v;
for (int k = 0; k < n; ++k) {
if (k < i || k > j)
u.push_back(a[k]);
else
v.push_back(a[k]);
}
sort(u.rbegin(), u.rend());
for (int k = 0; k < m && k < u.size(); ++k) {
v.push_back(u[k]);
}
sort(v.rbegin(), v.rend());
int s = 0;
for (int k = 0; k <= j - i; ++k) s += v[k];
ans = max(ans, s);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j, l, m, max, x, xi, xj, y;
int a[201], b[201], c[201];
while (scanf("%d%d", &n, &k) != EOF) {
c[0] = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
c[i] = c[i - 1] + a[i];
}
max = -1001;
for (i = 0; i < n; i++)
for (j = i + 1; j <= n; j++) {
y = c[j] - c[i];
for (l = 1; l <= n; l++) b[l] = a[l];
sort(b + i + 1, b + j);
for (l = 0; l < k && l < j - i; l++) {
b[0] = -1001;
x = 0;
for (m = 1; m <= i; m++)
if (b[x] < b[m]) x = m;
for (m = j + 1; m <= n; m++)
if (b[x] < b[m]) x = m;
if (b[x] > b[i + 1 + l]) {
y = y - b[i + 1 + l] + b[x];
b[x] = -1001;
} else
break;
}
if (max < y) {
max = y;
}
}
printf("%d\n", max);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAX_N = 302;
const int EPS = 0.0000001;
int N, K, sol;
int v[MAX_N], a[MAX_N], b[MAX_N];
int main() {
cin >> N >> K;
for (int i = 1; i <= N; ++i) cin >> v[i];
sol = v[1];
for (int i = 1; i <= N; ++i)
for (int j = i; j <= N; ++j) {
int now = 0;
int n1 = 0, n2 = 0;
for (int k = i; k <= j; ++k) {
now += v[k];
a[++n1] = v[k];
}
for (int k = 1; k < i; ++k) b[++n2] = v[k];
for (int k = j + 1; k <= N; ++k) b[++n2] = v[k];
sort(a + 1, a + n1 + 1);
sort(b + 1, b + n2 + 1);
for (int k = 1, ind_a = 1, ind_b = n2;
k <= K && ind_a <= n1 && ind_b >= 1; ++k, ++ind_a, --ind_b)
if (b[ind_b] > a[ind_a]) {
now -= a[ind_a];
now += b[ind_b];
}
sol = max(sol, now);
}
cout << sol << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[206];
vector<int> x, y;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int key = a[1];
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
x.clear();
y.clear();
for (int t = 1; t <= n; t++) {
if (i <= t && t <= j)
x.push_back(a[t]);
else
y.push_back(a[t]);
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
reverse(y.begin(), y.end());
for (int t = 0; t < k && t < x.size() && t < y.size() && x[t] < y[t]; t++)
swap(x[t], y[t]);
int sum = 0;
for (int t = 0; t < x.size(); t++) sum += x[t];
if (sum > key) key = sum;
}
}
printf("%d\n", key);
return 0;
}
|
#include <bits/stdc++.h>
static const int INF = 0x7fffffff;
static const int MAXN = 205;
static const int MAXK = 12;
template <typename T>
inline void upd_max(T &var, const T val) {
if (var < val) var = val;
}
int n, k, a[MAXN];
int f[MAXN][MAXN];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int ans = -INF;
for (int i = 0; i < n; ++i) {
std::multiset<int> inner, outer;
int inner_sum = 0;
for (int j = 0; j < n; ++j) outer.insert(a[j]);
for (int j = i; j < n; ++j) {
inner.insert(a[j]);
inner_sum += a[j];
outer.erase(outer.find(a[j]));
int cur = inner_sum;
std::multiset<int>::iterator p = inner.begin();
std::multiset<int>::reverse_iterator q = outer.rbegin();
upd_max(ans, cur);
for (int i = 0; i < k && p != inner.end() && q != outer.rend();
++i, ++p, ++q) {
cur += (*q - *p);
upd_max(ans, cur);
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int N = 210;
int n, k;
int a[N];
int ans;
map<int, int> s;
int sn;
map<int, int, greater<int> > e;
void update(int i) {
if (sn < k || s.rbegin()->first > a[i]) {
++s[a[i]];
++sn;
if (sn > k) {
--sn;
map<int, int>::reverse_iterator it = s.rbegin();
--it->second;
if (it->second == 0) s.erase(it->first);
}
}
}
void del(int i) {
map<int, int>::iterator it = e.find(a[i]);
--it->second;
if (it->second == 0) e.erase(it);
}
int get() {
int ret = 0;
int m = min(k, sn);
int i = 0;
map<int, int>::const_iterator it = s.begin();
map<int, int, greater<int> >::const_iterator jt = e.begin();
if (it == s.end() || jt == e.end()) return 0;
int a = it->second;
int b = jt->second;
for (; it != s.end() && jt != e.end() && i < m;) {
if (it->first >= jt->first) break;
int j = min(a, b);
j = min(j, m - i);
ret += j * (jt->first - it->first);
a -= j;
b -= j;
i += j;
if (a == 0) {
++it;
if (it != s.end()) a = it->second;
}
if (b == 0) {
++jt;
if (jt != e.end()) b = jt->second;
}
}
return ret;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
ans = a[0];
for (int l = 0; l < n; ++l) {
int sum = 0;
e.clear();
s.clear();
sn = 0;
for (int r = 0; r < n; ++r) ++e[a[r]];
for (int r = l; r < n; ++r) {
sum += a[r];
update(r);
del(r);
ans = max(ans, sum + get());
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[210];
vector<int> v, vv;
int ans, res;
int main() {
int n, chance;
cin >> n >> chance;
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
res = num[1];
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
v.clear();
vv.clear();
ans = 0;
for (int k = i; k <= j; k++) {
v.push_back(num[k]);
ans += num[k];
}
for (int k = 1; k <= n; k++)
if (k < i || k > j) vv.push_back(num[k]);
sort(v.begin(), v.end());
sort(vv.begin(), vv.end());
int len1 = v.size();
int len2 = vv.size();
res = max(res, ans);
for (int k = 1; k <= chance && k <= len1 && k <= len2; k++) {
ans -= v[k - 1];
ans += vv[len2 - k];
res = max(res, ans);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[210], m;
priority_queue<int> q;
priority_queue<int, vector<int>, greater<int> > q2;
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int ans = a[0];
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
for (int k = 0; k < n; ++k) {
if (k >= i && k <= j)
q2.push(a[k]);
else
q.push(a[k]);
}
for (int k = 0; k < m; ++k) {
if (q.empty() || q2.empty()) break;
int s = q2.top();
q2.pop();
int l = q.top();
q.pop();
q2.push(l);
q.push(s);
}
int sum = 0;
while (!q2.empty()) {
sum += q2.top();
q2.pop();
}
ans = max(ans, sum);
while (!q.empty()) {
q.pop();
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace p425ASerejaandSwaps {
int x[222], cur[222], oth[222];
void solve(int test_num) {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> x[i];
int ans = -1337;
for (int a = 0; a < N; a++) {
int sum = 0, C = 0;
for (int b = a; b < N; b++) {
sum += x[b];
cur[C++] = x[b];
int M = 0;
for (int i = 0; i < a; i++) oth[M++] = x[i];
for (int i = b + 1; i < N; i++) oth[M++] = x[i];
sort(cur, cur + C);
sort(oth, oth + M, greater<int>());
int nsum = sum;
for (int i = 0; i < K && i < min(C, M) && oth[i] > cur[i]; i++)
nsum += oth[i] - cur[i];
ans = max(ans, nsum);
}
}
cout << ans << endl;
}
void solve() { solve(1); }
} // namespace p425ASerejaandSwaps
int main() {
p425ASerejaandSwaps::solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int res = INT_MIN;
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
vector<int> x, y;
for (int i = 0; i < n; i++) {
if (l <= i && i <= r) {
x.push_back(a[i]);
} else {
y.push_back(a[i]);
}
}
sort(begin(x), end(x));
sort(begin(y), end(y), greater<int>());
int j = 0;
for (int i = 0; i < k; i++, j++) {
if (j == (int)x.size() || j == (int)y.size() || x[j] > y[j]) {
break;
}
x[j] = y[j];
}
int cur = 0;
for (int i = 0; i < (int)x.size(); i++) {
cur += x[i];
}
res = max(res, cur);
}
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205], p[205], n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int ans = -0x3f3f3f3f;
for (int l = 1; l <= n; ++l) {
for (int r = l; r <= n; ++r) {
for (int x = 1; x <= n; ++x) p[x] = a[x];
for (int x = 1; x <= k; ++x) {
int minn = 0x3f3f3f3f, maxn = -minn, wmin = 0, wmax = 0;
for (int i = 1; i < l; ++i)
if (maxn < p[i]) wmax = i, maxn = p[i];
for (int i = l; i <= r; ++i)
if (minn > p[i]) wmin = i, minn = p[i];
for (int i = r + 1; i <= n; ++i)
if (maxn < p[i]) wmax = i, maxn = p[i];
if (minn < maxn)
swap(p[wmin], p[wmax]);
else
break;
}
int tot = 0;
for (int i = l; i <= r; ++i) tot += p[i];
ans = max(ans, tot);
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, kk, a[200];
scanf("%d%d", &n, &kk);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int sum, tp, mx = a[0];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
priority_queue<int> la, sm;
sum = 0;
for (int k = 0; k < n; k++)
if (k >= i && k <= j) {
sm.push(-a[k]);
sum += a[k];
} else
la.push(a[k]);
if (mx < sum) mx = sum;
int ts = sum;
for (int k = 0; k < kk; k++) {
sum += sm.top();
la.push(-sm.top());
sm.pop();
sum += la.top();
sm.push(-la.top());
la.pop();
if (ts >= sum) break;
}
if (mx < sum) mx = sum;
}
printf("%d", mx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210;
const int INF = 0x3f3f3f3f;
int v[MAXN];
int n, m;
int rr = -INF;
void f(int l, int r) {
vector<int> v1, v2;
int soma = 0;
for (int i = l; i <= r; i++) soma += v[i], v1.push_back(v[i]);
for (int i = 1; i < l; i++) v2.push_back(-v[i]);
for (int i = r + 1; i <= n; i++) v2.push_back(-v[i]);
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
for (int i = 0; i < min({m, (int)v1.size(), (int)v2.size()}); i++) {
if (v1[i] > -v2[i]) break;
soma -= v1[i];
soma -= v2[i];
}
rr = max(rr, soma);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
f(i, j);
}
}
cout << rr << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[250];
multiset<int, greater<int> > Swap;
multiset<int> E;
int main() {
int n, p;
scanf("%d %d", &n, &p);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int tr, tl;
int maxi = -1000000000;
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
Swap.clear();
E.clear();
int sum = 0;
for (int k = l; k <= r; k++) sum += a[k];
for (int k = l; k <= r; k++) E.insert(a[k]);
for (int k = 0; k < l; k++) Swap.insert(a[k]);
for (int k = r + 1; k < n; k++) Swap.insert(a[k]);
set<int>::iterator its = E.begin();
set<int, greater<int> >::iterator itb = Swap.begin();
int k = 0;
while (k < p && itb != Swap.end() && its != E.end()) {
if (*itb > *its) {
sum += *itb;
sum -= *its;
}
k++;
itb++;
its++;
}
maxi = max(maxi, sum);
}
}
printf("%d\n", maxi);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 209;
int a[N];
int n, k;
int f() {
int mx = -1000 * 1000;
int nw = 0;
for (int i = 0; i < int(n); ++i) {
nw += a[i];
mx = max(mx, nw);
if (nw < 0) nw = 0;
}
return mx;
}
int main() {
cin >> n >> k;
for (int i = 0; i < int(n); ++i) cin >> a[i];
int mx = -1000 * 1000;
int ans = f();
int il, ir;
for (int l = 0; l < int(n); ++l)
for (int r = l; r < n; ++r) {
int sum_in = 0, sum_out = 0;
vector<int> a1, a2;
for (int i = 0; i < int(n); ++i)
if (i <= r && i >= l)
a1.push_back(a[i]);
else
a2.push_back(a[i]);
int nw = 0;
for (int i = l; i <= r; ++i) nw += a[i];
sort(a1.begin(), a1.end());
sort(a2.begin(), a2.end());
reverse(a2.begin(), a2.end());
int pos = min(a1.size(), a2.size());
pos = min(pos, k);
for (int i = 0; i < pos; ++i) {
if (a1[i] < a2[i]) sum_in += a1[i], sum_out += a2[i];
}
ans = max(ans, nw + sum_out - sum_in);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int a[222], b[222], c[222];
int ls, ls2;
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
ans = -1000;
for (int r = (1); r <= (n); ++r)
for (int l = (1); l <= (r); ++l) {
ls = 0, ls2 = 0;
int s = 0;
for (int i = (l); i <= (r); ++i) b[++ls] = a[i], s += a[i];
for (int i = (1); i <= (l - 1); ++i) c[++ls2] = a[i];
for (int i = (r + 1); i <= (n); ++i) c[++ls2] = a[i];
sort(b + 1, b + 1 + ls);
sort(c + 1, c + 1 + ls2);
reverse(c + 1, c + 1 + ls2);
for (int i = (1); i <= (min(min(m, ls), ls2)); ++i)
if (c[i] > b[i]) s = s + c[i] - b[i];
ans = max(ans, s);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
const int INF = 0x3f3f3f3f;
int n, k;
int a[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
int ans = -INF;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
vector<int> in, out;
for (int l = i; l <= j; l++) in.push_back(a[l]);
for (int l = 0; l < i; l++) out.push_back(a[l]);
for (int l = j + 1; l < n; l++) out.push_back(a[l]);
sort(in.begin(), in.end());
sort(out.begin(), out.end(), greater<int>());
for (int l = 0, s = 0, pos = 0;
l < out.size() && pos < in.size() && s < k;) {
if (out[l] > in[pos]) {
swap(out[l], in[pos]);
pos++;
s++;
l++;
} else {
break;
}
}
int cur = accumulate(in.begin(), in.end(), 0);
ans = max(ans, cur);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[256], ans, b[256], c[256];
int check(int l, int r) {
int sum = 0, m = 0, t = 0;
for (int i = 1; i <= n; i++)
if (l <= i && i <= r)
b[++m] = a[i];
else
c[++t] = a[i];
if (!m || !t) return ans;
sort(c + 1, c + t + 1);
sort(b + 1, b + m + 1);
int j = t;
for (int i = 1; i <= min(k, m) && j > 0; i++)
if (c[j] < b[i])
break;
else
b[i] = c[j], j--;
for (int i = 1; i <= m; i++) sum += b[i];
return sum;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), ans += a[i];
for (int i = 1; i < n; i++)
for (int j = i; j <= n; j++) ans = max(ans, check(i, j));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int A[201];
int X[201], xc;
int Y[201], yc;
int main() {
int N, K;
int i, j, k;
int Max, first = 0, S;
scanf("%d %d", &N, &K);
for (i = 1; i <= N; i++) scanf("%d", &A[i]);
for (i = 1; i <= N; i++) {
for (j = i; j <= N; j++) {
xc = yc = S = 0;
for (k = 1; k <= N; k++) {
if (i <= k && k <= j)
X[++xc] = A[k], S += A[k];
else
Y[++yc] = A[k];
}
std::sort(X + 1, X + 1 + xc);
std::sort(Y + 1, Y + 1 + yc);
if (!first)
first = 1, Max = S;
else if (Max < S)
Max = S;
for (k = 1; k <= K; k++) {
if (yc - k + 1 < 1) break;
if (k > xc) break;
if (Y[yc - k + 1] <= X[k]) continue;
S = S - X[k] + Y[yc - k + 1];
if (Max < S) Max = S;
}
}
}
printf("%d", Max);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
const int nmax = 200;
int str[nmax];
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> str[i];
int ans = 0x80000000;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
vector<int> in(str + i, str + j + 1), out(str, str + i),
out1(str + j + 1, str + n);
out.insert(out.end(), out1.begin(), out1.end());
sort(out.begin(), out.end());
sort(in.begin(), in.end());
int t = 0, sum = 0;
for (; t < k && t < in.size() && t < out.size(); t++) {
if (in[t] < out[out.size() - t - 1])
sum += out[out.size() - t - 1];
else
break;
}
for (; t < in.size(); t++) sum += in[t];
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> A(n), acc(n);
for (int i = (0); i < (n); ++i) cin >> A[i];
acc[0] = A[0];
for (int i = (1); i < (n); ++i) acc[i] = A[i] + acc[i - 1];
int rsp = -inf;
for (int i = (0); i < (n); ++i) {
for (int j = (i); j < (n); ++j) {
int sum = acc[j] - (i ? acc[i - 1] : 0);
rsp = max(rsp, sum);
vector<int> v1, v2;
for (int kk = (0); kk < (n); ++kk) {
if (kk < i or kk > j) {
v1.push_back(A[kk]);
} else {
v2.push_back(A[kk]);
}
}
sort(v1.rbegin(), v1.rend());
sort(v2.begin(), v2.end());
int lim = min(v1.size(), v2.size());
for (int kk = (0); kk < (min(k, lim)); ++kk) {
sum -= v2[kk];
sum += v1[kk];
rsp = max(rsp, sum);
}
}
}
printf("%d\n", rsp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const long long INF = 1e10;
const int MOD = 1e9 + 7;
const double EPS = 1e-7;
const double PI = acos(-1.0);
pair<long long, long long> p[N];
long long n, k, a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
p[i] = {a[i], i};
}
sort(p, p + n);
long long ans = LLONG_MIN;
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
long long sum = 0;
vector<long long> subarr(r - l + 1);
for (int i = l, j = 0; i <= r; i++, j++) {
subarr[j] = a[i];
sum += a[i];
}
sort(subarr.begin(), subarr.end());
for (int i = 0, j = n - 1; i < min(k, r - l + 1ll); i++) {
while (j >= 0 && p[j].second <= r && p[j].second >= l) {
j--;
}
if (j >= 0) {
sum = max(sum, sum - subarr[i] + p[j].first);
j--;
}
}
ans = max(ans, sum);
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("-Ofast")
#pragma GCC optimize("trapv")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.2,popcnt,abm,mmx,avx2,tune=native")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-funroll-all-loops,-fpeel-loops,-funswitch-loops")
const int N = 1e5 + 40;
const int MAXK = 12;
const long long int INF = 1000000000000000000;
const int RANDOM =
chrono::high_resolution_clock::now().time_since_epoch().count();
long long int expo_pow(long long int x, long long int y) {
if (y == 0) return 1;
y = y % ((1000000007) - 1);
x %= (1000000007);
if (y == 0) y = (1000000007) - 1;
long long int res = 1;
while (y) {
if (y & 1) res = (res * x) % (1000000007);
x = (x * x) % (1000000007);
y >>= 1;
}
return res;
}
long long int modInverse(long long int a, long long int m = (1000000007)) {
return expo_pow(a, m - 2);
}
void solve() {
int n, k;
cin >> n >> k;
int a[n + 2];
for (int i = (1); i < (n + 1); i++) {
cin >> a[i];
}
int ans = -1e9;
for (int i = (1); i < (n + 1); i++) {
for (int j = (i); j < (n + 1); j++) {
cout.flush();
multiset<int> second, oth;
for (int k = (i); k < (j + 1); k++) second.insert(a[k]);
for (int k = (1); k < (n + 1); k++) {
if (k >= i && k <= j)
continue;
else {
oth.insert(-a[k]);
}
}
cout.flush();
for (int l = (1); l < (k + 1); l++) {
if (oth.empty() || second.empty()) break;
int cur1 = *second.begin();
int cur2 = -*oth.begin();
if (cur2 > cur1) {
second.erase(second.find(cur1));
oth.erase(oth.find(-cur2));
second.insert(cur2);
} else
break;
}
int ta = 0;
while (second.size()) {
ta += *second.begin();
second.erase(second.find(*second.begin()));
}
ans = max(ans, ta);
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
while (T--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int a[222], n, kth;
int b[222], c[222];
int main() {
scanf("%d%d", &n, &kth);
for (int i = 0; i < n; i++) scanf("%d", a + i);
int ans = -INF;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int nb = 0, nc = 0, sum = 0;
for (int k = 0; k < n; k++) {
if (!(k >= i && k <= j))
c[nc++] = a[k];
else {
sum += a[k];
b[nb++] = a[k];
}
}
sort(b, b + nb);
sort(c, c + nc);
for (int k = 0; k < kth; k++) {
if (nc - k - 1 >= 0 && k < nb && c[nc - k - 1] > b[k]) {
sum = sum - b[k] + c[nc - k - 1];
} else
break;
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e2 + 5;
int main() {
int n, k;
scanf("%d %d", &n, &k);
priority_queue<pair<int, int> > pq;
vector<int> vc;
map<pair<int, int>, multiset<int> > mp;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
vc.push_back(x);
pq.push({x, i});
}
for (int pt1 = 0; pt1 < n; pt1++) {
for (int pt2 = 0; pt2 < n; pt2++) {
for (int x = pt1; x <= pt2; x++) mp[{pt1, pt2}].insert(vc[x]);
}
}
int ans = INT_MIN;
for (auto it = mp.begin(); it != mp.end(); it++) {
int l = it->first.first;
int r = it->first.second;
multiset<int> st = it->second;
priority_queue<pair<int, int> > tmp = pq;
int val = k;
int sum = 0;
for (auto &i : st) {
sum += i;
if (val > 0)
while (tmp.size()) {
int number = tmp.top().first;
int index = tmp.top().second;
tmp.pop();
if (number < i) break;
if (index < l || index > r) {
sum -= i;
sum += number;
break;
}
}
val--;
}
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, kk, t;
int a[205], a1[205], a2[205];
int num1, num2;
while (~scanf("%d%d", &n, &kk)) {
int sum = -300000, tmp;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
tmp = 0;
num1 = num2 = 0;
for (int k = i; k < j; k++) {
a1[num1++] = a[k];
tmp += a[k];
}
if (tmp > sum) sum = tmp;
if (num1 == n) continue;
for (int k = 0; k < i; k++) a2[num2++] = a[k];
for (int k = j; k < n; k++) a2[num2++] = a[k];
sort(a1, a1 + num1);
sort(a2, a2 + num2);
for (int k = 0; k < kk; k++) {
if (a1[0] < a2[num2 - 1]) {
t = a1[0];
a1[0] = a2[num2 - 1];
a2[num2 - 1] = t;
}
sort(a1, a1 + num1);
sort(a2, a2 + num2);
}
tmp = 0;
for (int k = 0; k < num1; k++) {
tmp += a1[k];
}
if (tmp > sum) sum = tmp;
}
}
printf("%d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ans = -200000, temp;
int a[205];
vector<int> in_range, out_range;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
int sum = 0;
temp = k;
for (int i = l; i <= r; i++) in_range.push_back(a[i]);
for (int j = 0; j < l; j++) out_range.push_back(a[j]);
for (int j = r + 1; j < n; j++) out_range.push_back(a[j]);
sort(in_range.begin(), in_range.end());
sort(out_range.begin(), out_range.end());
for (int i = 0;
i < min((int)out_range.size(), (int)in_range.size()) and temp--;
i++) {
if (out_range[(int)out_range.size() - 1 - i] > in_range[i])
in_range[i] = out_range[(int)out_range.size() - 1 - i];
}
for (int i = 0; i < (int)in_range.size(); i++) sum += in_range[i];
ans = max(sum, ans);
in_range.clear();
out_range.clear();
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
vector<int> v, a, g;
int n, k;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
a.push_back(x);
}
int ans = -inf;
for (int l = 0; l < n; ++l)
for (int r = l; r < n; ++r) {
v.clear();
g.clear();
for (int i = 0; i < l; ++i) v.push_back(a[i]);
for (int i = r + 1; i < n; ++i) v.push_back(a[i]);
for (int i = l; i <= r; ++i) g.push_back(a[i]);
sort(v.begin(), v.end(), greater<int>());
sort(g.begin(), g.end());
int res = 0, c = min(min(k, (int(v.size()))), (int(g.size())));
while (c > 0 && g[c - 1] > v[c - 1]) c--;
for (int i = c; i < (int(g.size())); ++i) res += g[i];
for (int i = 0; i < c; ++i) res += v[i];
ans = max(ans, res);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 201, M = 2001;
int n, k, a[N], ans = -1 * 1000 * 1000 * 100;
int all[M], in[M];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] += 1000;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
memset(all, 0, sizeof all);
memset(in, 0, sizeof in);
int sum = 0;
for (int tmp = 1; tmp <= n; tmp++) {
if (tmp >= i && tmp <= j)
in[a[tmp]]++, sum += a[tmp];
else
all[a[tmp]]++;
}
int r = 2000, l = 0, kp = k;
while (r > l && kp > 0) {
while (all[r] == 0 && r > l) r--;
while (in[l] == 0 && l < r) l++;
if (r > l) kp--, in[l]--, all[r]--, in[r]++, all[l]++, sum += r - l;
}
ans = max(ans, sum - (j - i + 1) * 1000);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
const int N = 2e2 + 7;
const int xinc[] = {0, 0, 1, -1};
const int yinc[] = {1, -1, 0, 0};
const long double PI = 3.141592653589793;
int n, k, a[N], ans;
void solve() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
ans = INT_MIN;
for (int l = 0; l < n; l++)
for (int r = l; r < n; r++) {
vector<int> orig, temp;
for (int i = l; i <= r; i++) orig.push_back(a[i]);
for (int i = 0; i < l; i++) temp.push_back(a[i]);
for (int i = r + 1; i < n; i++) temp.push_back(a[i]);
sort((temp).begin(), (temp).end(), greater<int>());
int ns = min((int)temp.size(), k);
temp.resize(ns);
for (auto i : temp) orig.push_back(i);
sort((orig).begin(), (orig).end(), greater<int>());
orig.resize(r - l + 1);
int sum = 0;
for (auto i : orig) sum += i;
ans = max(sum, ans);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[205];
int f[205], rest[205];
int main() {
int i, j, k, l, ans = -2000000;
int n1, n2;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
n1 = 0;
for (k = i; k <= j; k++) {
n1++;
f[n1] = a[k];
}
n2 = 0;
for (k = 1; k <= i - 1; k++) {
n2++;
rest[n2] = a[k];
}
for (k = j + 1; k <= n; k++) {
n2++;
rest[n2] = a[k];
}
sort(f + 1, f + n1 + 1);
sort(rest + 1, rest + n2 + 1);
k = 1;
while (k <= m && k <= n1 && k <= n2 && rest[n2 - k + 1] > f[k]) {
l = f[k];
f[k] = rest[n2 - k + 1];
rest[n2 - k + 1] = l;
k++;
}
l = 0;
for (k = 1; k <= n1; k++) l += f[k];
if (l > ans) ans = l;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[220];
int n, k;
int b[220], c[220];
bool cmp(int a, int b) { return a > b; }
int cal(int l, int r) {
int i, j, s1 = 0, s2 = 0;
vector<int> b, c;
for (i = 0; i < n; i++) {
if (i < l || i > r)
b.push_back(a[i]);
else
c.push_back(a[i]);
}
sort(b.rbegin(), b.rend());
sort(c.begin(), c.end());
s1 = b.size(), s2 = c.size();
for (i = 0; i < k && i < s1 && i < s2; i++) {
if (b[i] > c[i]) swap(b[i], c[i]);
}
int ans = 0;
for (i = 0; i < s2; i++) ans += c[i];
return ans;
}
int main() {
int i, j;
scanf("%d%d", &n, &k);
int ans = -1000000;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++)
for (j = i; j < n; j++) ans = max(ans, cal(i, j));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1001000;
const int maxm = 1000100;
const int INF = 0x3f3f3f3f;
const int mod = 1000000007;
int n, m;
int a[maxn];
int b[maxn];
int c[maxn];
int sum[maxn];
int main() {
int i, j;
int k;
scanf("%d%d", &n, &m);
sum[0] = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
int ans = -INF;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
int cntb = 0;
int cntc = 0;
for (k = 1; k <= n; k++) {
if (k >= i && k <= j) {
b[cntb++] = a[k];
} else {
c[cntc++] = a[k];
}
}
sort(b, b + cntb);
sort(c, c + cntc);
int cnt = min(cntb, cntc);
int temp = sum[j] - sum[i - 1];
for (k = 0; k < cnt && k < m; k++) {
if (b[k] < c[cntc - 1 - k]) {
temp += c[cntc - 1 - k] - b[k];
}
}
ans = max(ans, temp);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000;
const int INF = 1e9 + 7;
int n, k, ans;
int a[N], s[N];
bool vis[N];
vector<pair<int, int> > b;
int f(int l, int r) {
int res = s[r] - s[l - 1], cnt = 0;
memset(vis, false, sizeof vis);
for (int i = 0; i < n; i++) {
if (cnt == k) break;
if (l > b[i].second || b[i].second > r) continue;
for (int j = n - 1; j >= 0; j--)
if (!vis[j] && (l > b[j].second || b[j].second > r) &&
b[j].first > b[i].first) {
cnt++;
res += b[j].first - b[i].first;
vis[j] = true;
break;
}
}
return res;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
b.push_back(pair<int, int>(a[i], i));
}
sort(b.begin(), b.end());
ans = -INF;
for (int l = 1; l <= n; l++) {
for (int r = l; r <= n; r++) {
ans = max(f(l, r), ans);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[201];
int main() {
int n, k;
int res = 0;
bool found = false;
scanf("%d%d", &n, &k);
for (int i = 0; i < (n); i++) scanf("%d", &a[i]);
for (int l = 0; l < n; l++)
for (int r = l; r < n; r++) {
multiset<int> inside;
multiset<int> outside;
for (int i = 0; i < n; i++) {
if (l <= i && i <= r)
inside.insert(a[i]);
else
outside.insert(a[i]);
}
multiset<int>::reverse_iterator it;
int left = k;
for (it = outside.rbegin(); it != outside.rend() && left; it++, left--)
inside.insert(*it);
left = r - l + 1;
int sum = 0;
for (it = inside.rbegin(); it != inside.rend() && left; it++, left--)
sum += *it;
if (!found || res < sum) {
found = true;
res = sum;
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, max = -100000;
int a[200], inter[200], exter[200];
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int sum = 0;
vector<int> inter, exter;
inter.clear();
exter.clear();
for (int m = i; m < j + 1; m++) {
sum += a[m];
inter.push_back(a[m]);
}
for (int m = 0; m < i; m++) exter.push_back(a[m]);
for (int m = j + 1; m < n; m++) exter.push_back(a[m]);
sort(inter.begin(), inter.end());
sort(exter.begin(), exter.end());
for (int m = 0; m < k; m++) {
if (m >= inter.size() || exter.size() < m + 1) break;
if (exter[exter.size() - 1 - m] > inter[m])
sum += exter[exter.size() - 1 - m] - inter[m];
}
max = max > sum ? max : sum;
}
}
cout << max << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tupple {
int numb;
int place;
};
tupple arr[201];
int n, m;
bool f(tupple i, tupple j) {
if (i.numb < j.numb || (i.numb == j.numb && i.place < j.place)) return true;
return false;
}
int sum[201][201];
int k;
int calc(int i, int j) {
int sm = sum[i][j];
int swp = 0;
int ed = n - 1;
int start = 0;
while (start < ed && swp < k) {
while (start < n && (arr[start].place < i || arr[start].place > j)) start++;
while (ed >= 0 && (arr[ed].place >= i && arr[ed].place <= j)) ed--;
if (start < ed) {
sm += arr[ed].numb - arr[start].numb;
start++;
ed--;
swp++;
}
}
return sm;
}
int main() {
cin >> n;
cin >> k;
for (int i = 0; i < n; i++) arr[i].place = i;
for (int i = 0; i < n; i++) cin >> arr[i].numb;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
if (i == j)
sum[i][j] = arr[i].numb;
else
sum[i][j] = sum[i][j - 1] + arr[j].numb;
sort(arr, arr + n, f);
long mx = -10000001;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
if (calc(i, j) > mx) {
mx = calc(i, j);
}
cout << mx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using std::map;
const int CMAX = 205;
const char Cfd[] = "", Cfr[] = "";
int sum(int A[], int l, int r, int k, int n) {
priority_queue<int> OUT;
priority_queue<int, vector<int>, greater<int> > IN;
for (int i = 0; i < n; i++)
if (i >= l && i <= r)
IN.push(A[i]);
else
OUT.push(A[i]);
for (int i = 0; i < k && IN.size() > 0 && OUT.size() > 0; i++) {
if (OUT.top() < IN.top()) break;
int out = OUT.top();
int in = IN.top();
OUT.pop();
IN.pop();
IN.push(out);
OUT.push(in);
}
int s = 0;
while (!IN.empty()) {
s += IN.top();
IN.pop();
}
return s;
}
int main() {
int n, k, A[CMAX];
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> A[i];
int res = -5000;
for (int l = 0; l < n; l++)
for (int r = l; r < n; r++) res = max(res, sum(A, l, r, k, n));
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
int n, k;
int a[300];
std::vector<std::pair<int, int> > v;
std::pair<int, int> temp;
std::multiset<int> s;
std::multiset<int>::iterator it;
std::vector<int> ka;
int suma;
bool cmp(std::pair<int, int> a, std::pair<int, int> b) {
return a.first > b.first;
}
void Brisi() {
it = s.end();
--it;
s.erase(it);
}
int rez = -90000000;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
v.resize(n);
for (int i = 0; i < n; ++i) {
temp.first = a[i];
temp.second = i;
v[i] = temp;
}
std::sort(v.begin(), v.end(), cmp);
for (int l = 0; l < n; ++l) {
for (int r = l; r < n; ++r) {
s.clear();
ka.clear();
suma = 0;
for (int i = l; i <= r; ++i) {
suma += a[i];
if (a[i] < 0) s.insert(a[i]);
if (s.size() > k) Brisi();
}
if (s.empty()) {
rez = std::max(rez, suma);
continue;
}
for (int i = 0; (i < n) && (ka.size() < k); ++i) {
if (v[i].second < l || v[i].second > r) ka.push_back(v[i].first);
}
for (int i = 0; i < ka.size() && !s.empty(); ++i) {
if (ka[i] > *s.begin()) {
suma -= *s.begin();
suma += ka[i];
s.erase(s.begin());
} else {
s.erase(s.begin());
--i;
}
}
rez = std::max(rez, suma);
}
}
printf("%d\n", rez);
}
|
#include <bits/stdc++.h>
using namespace std;
int v[220];
int n, swa;
int main() {
cin >> n >> swa;
for (int i = 0; i < n; i++) cin >> v[i];
vector<int> in, out;
int ans = -2000005;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
in.clear();
out.clear();
for (int k = 0; k < i; k++) out.push_back(v[k]);
int sum = 0;
for (int k = i; k <= j; k++) {
in.push_back(v[k]);
sum += v[k];
}
for (int k = j + 1; k < n; k++) out.push_back(v[k]);
sort(in.begin(), in.end());
sort(out.begin(), out.end());
int obj = min(swa, (int)min(in.size(), out.size()));
int insize = in.size();
int outsize = out.size();
for (int k = 0; k <= obj; k++) {
int adi = 0, sub = 0;
for (int l = 0; l < k; l++) {
adi += out[outsize - l - 1];
sub += in[l];
}
ans = max(ans, sum + adi - sub);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, ans = -1000000000;
cin >> n >> k;
int a[10000];
int b[10000];
for (int i = 0; i < n; i++) cin >> a[i];
for (int l = 0; l < n; l++)
for (int r = l; r < n; r++) {
for (int i = 0; i < n; i++) b[i] = a[i];
for (int i = 0; i < k; i++) {
int min = 10000000, max = -10000000, nmin, nmax;
for (int j = l; j <= r; j++)
if (b[j] < min) {
min = b[j];
nmin = j;
}
for (int j = 0; j < n; j++)
if ((j < l || j > r) && b[j] > max) {
max = b[j];
nmax = j;
}
if (min < max) {
int x = b[nmax];
b[nmax] = b[nmin];
b[nmin] = x;
}
}
int sum = 0;
for (int i = l; i <= r; i++) sum += b[i];
if (sum > ans) {
ans = sum;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int inf = 1 << 30;
const int base = 257;
const int mod = int(1e9) + 7;
int ans = -inf, n, k, a[maxn], used[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
vector<int> x, y;
memset(used, 0, sizeof used);
int sum = 0;
for (int v = i; v <= j; v++) {
x.push_back(a[v]);
sum += a[v];
}
for (int v = 1; v < i; v++) y.push_back(a[v]);
for (int v = j + 1; v <= n; v++) y.push_back(a[v]);
sort(x.begin(), x.end());
sort(y.begin(), y.end());
reverse(y.begin(), y.end());
int kk = min(k, min((int)x.size(), (int)y.size()));
for (int v = 0; v < kk; v++)
if (x[v] < y[v]) sum += y[v] - x[v];
ans = max(ans, sum);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[201];
int first[201];
int last[201];
int Mid[201];
int main() {
int n, m, ans = -1000000000;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int c1 = 0, c2 = 0;
for (int k = 0; k < i; k++) {
first[c1++] = arr[k];
}
for (int k = j + 1; k < n; k++) {
first[c1++] = arr[k];
}
sort(first, first + c1);
c1--;
int sum = 0;
for (int k = i; k <= j; k++) {
Mid[c2++] = arr[k];
sum += arr[k];
}
sort(Mid, Mid + c2);
int o = m;
int u = 0;
while (true) {
if (c1 < 0 || u >= c2 || o <= 0) break;
o--;
if (Mid[u] < first[c1]) {
sum -= Mid[u++];
sum += first[c1--];
}
}
ans = max(ans, sum);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[205];
vector<int> b, c;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int r = -(1 << 30);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
int t = 0;
b.clear();
c.clear();
for (int u = 1; u <= n; u++)
if (i <= u && u <= j)
b.push_back(a[u]), t += a[u];
else
c.push_back(a[u]);
sort(b.begin(), b.end());
sort(c.begin(), c.end(), greater<int>());
for (int u = 0; u < k; u++) {
if (u >= b.size() || u >= c.size()) break;
if (b[u] > c[u]) break;
t = t - b[u] + c[u];
}
r = max(r, t);
}
cout << r;
}
|
#include <bits/stdc++.h>
using namespace std;
int top, maxx = -999999, d1[205], d2[205], s, s2;
int n, m, k, t, h[2010], arr[205], a[205], i, j;
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
for (k = 1; k <= n; k++)
if (k >= i && k <= j)
d1[s++] = arr[k], top += arr[k];
else
d2[s2++] = arr[k];
sort(d1, d1 + s);
sort(d2, d2 + s2);
reverse(d2, d2 + s2);
for (k = 0; k < m; k++)
if (d2[k] > 0)
top += d2[k] - d1[k];
else
break;
if (top > maxx) maxx = top;
memset(d1, 0, sizeof d1);
memset(d2, 0, sizeof d2);
top = s = s2 = 0;
}
printf("%d", maxx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[234], a1[234], a2[234], maxsum;
int main() {
int n, k, sz1, sz2, itr1, itr2, temp;
scanf("%d", &n);
scanf("%d", &k);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
maxsum = INT_MIN;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
sz1 = sz2 = 0;
for (int l = i; l <= j; l++) a1[sz1++] = arr[l];
for (int l = 0; l < i; l++) a2[sz2++] = arr[l];
for (int l = j + 1; l < n; l++) a2[sz2++] = arr[l];
sort(a1, a1 + sz1);
sort(a2, a2 + sz2);
reverse(a2, a2 + sz2);
itr1 = itr2 = 0;
temp = k;
while (1) {
if (itr2 == sz2) break;
if (itr1 == sz1) break;
if (temp == 0) break;
if (a2[itr2] > a1[itr1]) {
a1[itr1] = a2[itr2];
itr1++;
temp--;
} else
break;
itr2++;
}
temp = 0;
for (int l = 0; l < sz1; l++) temp += a1[l];
if (temp == 41)
cerr << "i"
<< ": " << i << " | "
<< "j"
<< ": " << j << " | "
<< "sz1"
<< ": " << sz1 << endl;
;
maxsum = max(maxsum, temp);
}
}
printf("%d\n", maxsum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a[205], b[205];
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int Max = -1111111111;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int sum = 0;
for (int k = 1; k <= n; k++) {
b[k] = a[k];
if (k >= i && k <= j) sum += a[k];
}
for (int k = 0; k < m; k++) {
sort(b + i, b + j + 1);
int p1 = -1, Mmax = -1111111;
for (int k1 = 1; k1 < i; k1++) {
if (Mmax < b[k1]) {
Mmax = b[k1];
p1 = k1;
}
}
for (int k1 = j + 1; k1 <= n; k1++) {
if (Mmax < b[k1]) {
Mmax = b[k1];
p1 = k1;
}
}
if (Mmax > b[i]) {
sum = sum + Mmax - b[i];
swap(b[i], b[p1]);
}
if (sum > Max) Max = sum;
}
}
}
cout << Max << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ans = INT_MIN, d[205];
vector<int> a, b;
int check(int x, int y) {
a.clear(), b.clear();
for (int i = 1; i <= n; ++i)
if (i >= x && i <= y)
a.push_back(d[i]);
else
b.push_back(d[i]);
sort(a.begin(), a.end());
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
int r = 0, e = 0, o = 0, s = 0;
while (o < k && r < a.size() && e < b.size() && a[r] < b[e])
swap(a[r++], b[e++]), o++;
for (int i = 0; i < a.size(); ++i) s += a[i];
return s;
}
signed main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &d[i]);
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j) ans = max(ans, check(i, j));
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int size = 107;
const long long modulo = 1000000007;
const long long INF = 1234567890LL;
const double EPS = 1e-8;
const double PI = acos(-1.0);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int ans = -INF;
for (int l = 0; l < n; l++)
for (int r = l; r < n; r++) {
multiset<int> in, out;
for (int i = 0; i < l; i++) out.insert(a[i]);
for (int i = l; i <= r; i++) in.insert(a[i]);
for (int i = r + 1; i < n; i++) out.insert(a[i]);
for (int i = 0; i < k; i++) {
if (in.empty() || out.empty()) break;
if (*in.begin() < *out.rbegin()) {
in.insert(*out.rbegin());
out.insert(*in.begin());
in.erase(in.begin());
out.erase(--out.end());
} else
break;
}
int res = 0;
for (auto it = in.begin(); it != in.end(); it++) res += (*it);
ans = max(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int ReadInt() {
char c;
while (c = getchar(), c < '0' || c > '9')
;
int x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
return x;
}
const int N = 2e2 + 1;
int n, a[N], k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int ans = -(int)1e9, cur, cur1, cur2;
vector<int> v1, v2;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
v1.clear();
v2.clear();
cur = 0;
for (int i1 = i; i1 <= j; i1++) {
cur += a[i1];
v1.push_back(a[i1]);
}
for (int i1 = 1; i1 < i; i1++) v2.push_back(a[i1]);
for (int i1 = j + 1; i1 <= n; i1++) v2.push_back(a[i1]);
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
reverse(v2.begin(), v2.end());
cur1 = cur2 = 0;
ans = max(ans, cur);
for (int i1 = 0; i1 < min(k, min((int)v1.size(), (int)v2.size())); i1++) {
cur1 += v1[i1];
cur2 += v2[i1];
ans = max(ans, cur - cur1 + cur2);
}
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, v[210], sum[210], sol = -1000000000;
multiset<int> S1, S2;
int main() {
std::ios_base::sync_with_stdio(false);
int i, j, k, nr, a, b, now;
cin >> n >> K;
for (i = 1; i <= n; ++i) {
cin >> v[i];
sum[i] = sum[i - 1] + v[i];
}
for (i = 1; i <= n; ++i) {
for (j = i; j <= n; ++j) {
now = sum[j] - sum[i - 1];
S2.clear();
S1.clear();
for (k = 1; k < i; ++k) S1.insert(-v[k]);
for (k = j + 1; k <= n; ++k) S1.insert(-v[k]);
for (k = i; k <= j; ++k) S2.insert(v[k]);
nr = 0;
while (nr < K && S1.size() && S2.size()) {
a = *(S2.begin());
b = -(*(S1.begin()));
if (a < b) {
S2.erase(S2.find(a));
S1.erase(S1.find(-b));
S2.insert(b);
now += (b - a);
nr++;
} else
nr = K;
}
sol = max(sol, now);
}
}
cout << sol << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool man(int a, int b) { return a < b; }
int main() {
int n, z;
cin >> n >> z;
int a[1005];
for (int i = 0; i < n; i++) cin >> a[i];
int mx = -200 * 2000;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
vector<int> mn, max;
for (int k = i; k <= j; k++) {
if (mn.size() < z) {
mn.push_back(a[k]);
sort(mn.begin(), mn.end());
} else if (!mn.empty() && mn[mn.size() - 1] > a[k]) {
mn[mn.size() - 1] = a[k];
sort(mn.begin(), mn.end());
}
}
for (int k = 0; k < i; k++) {
if (max.size() < z) {
max.push_back(a[k]);
sort(max.begin(), max.end());
} else if (!max.empty() && max[0] < a[k]) {
max[0] = a[k];
sort(max.begin(), max.end());
}
}
for (int k = j + 1; k < n; k++) {
if (max.size() < z) {
max.push_back(a[k]);
sort(max.begin(), max.end());
} else if (!max.empty() && max[0] < a[k]) {
max[0] = a[k];
sort(max.begin(), max.end());
}
}
int sum = 0;
for (int k = i; k <= j; k++) {
sum += a[k];
}
int f = min(max.size(), mn.size());
for (int k = 0; k < f; k++) {
if (mn[k] < max[max.size() - 1 - k])
sum += -mn[k] + max[max.size() - 1 - k];
}
if (sum > mx) mx = sum;
}
}
cout << mx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205];
int save1[205], n1, save2[205], n2;
int n, k;
int solve(int l, int r) {
n1 = 0;
int ans = 0;
for (int i = l; i <= r; i++) {
ans += a[i];
save1[n1] = a[i];
n1++;
}
n2 = 0;
for (int i = 0; i < l; i++) {
save2[n2] = a[i];
n2++;
}
for (int i = r + 1; i < n; i++) {
save2[n2] = a[i];
n2++;
}
sort(save1, save1 + n1);
sort(save2, save2 + n2);
int now = k;
for (int i = 0, j = n2 - 1;; i++, j--) {
if (now == 0 || j < 0 || i >= n1) break;
if (save1[i] < save2[j]) {
ans += save2[j] - save1[i];
now--;
} else
break;
}
return ans;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
int ans = -1e9;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
ans = max(solve(i, j), ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
const int INF = (int)1e9;
int a[N], fst[N], scnd[N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int res = -INF;
for (int i = 0; i < n; i++)
for (int s = i; s < n; s++) {
int indF = 0, indS = 0;
for (int q = 0; q < n; q++) {
if (q < i || q > s)
fst[indF++] = a[q];
else
scnd[indS++] = a[q];
}
sort(fst, fst + indF, greater<int>());
sort(scnd, scnd + indS);
int ans = 0;
int cnt = 0;
for (int q = 0; q < min(k, min(indF, indS)); q++) {
if (fst[q] > scnd[q]) {
ans += fst[q];
cnt++;
} else
break;
}
for (int q = cnt; q < indS; q++) ans += scnd[q];
res = max(res, ans);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char untl = '\n';
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
for (; !(ch >= '0' && ch <= '9'); ch = getchar())
if (ch == '-') f *= -1;
for (; (ch >= '0' && ch <= '9'); ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ 48);
return x * f;
}
inline bool read(long long &x) {
x = 0;
long long f = 1;
char ch = getchar();
for (; !(ch >= '0' && ch <= '9'); ch = getchar())
if (ch == '-') f *= -1;
for (; (ch >= '0' && ch <= '9'); ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ 48);
x *= f;
if (ch == '\r') ch = getchar();
return ch != untl && ch != EOF;
}
inline char getDg() {
char ch = getchar();
for (; !(ch >= '0' && ch <= '9');) ch = getchar();
return ch;
}
inline char getLw() {
char ch = getchar();
for (; !(ch >= 'a' && ch <= 'z');) ch = getchar();
return ch;
}
inline char getUp() {
char ch = getchar();
for (; !(ch >= 'A' && ch <= 'Z');) ch = getchar();
return ch;
}
inline char getLtr() {
char ch = getchar();
for (; !((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'));)
ch = getchar();
return ch;
}
inline char gc() {
char ch = getchar();
for (; ch == '\n' || ch == '\r' || ch == ' ';) ch = getchar();
return ch;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x > 9) write(x / 10);
putchar((x % 10) ^ 48);
return;
}
inline void write(char const *a) {
for (long long i = 0; a[i]; ++i) putchar(a[i]);
return;
}
inline void write(char ch) {
putchar(ch);
return;
}
inline void write(pair<long long, long long> a, char const *b = " ") {
write(a.first);
write(b);
write(a.second);
return;
}
inline void clr() {
putchar(10);
return;
}
inline void spc() {
putchar(32);
return;
}
inline void writeln(long long x) {
write(x);
clr();
return;
}
inline void writeln(char const *a) {
write(a);
clr();
return;
}
inline void writeln(char a) {
write(a);
clr();
return;
}
inline void writeln(pair<long long, long long> a, char const *b = " ") {
write(a, b);
clr();
return;
}
inline void writesc(long long x) {
write(x);
spc();
return;
}
inline void writesc(char const *a) {
write(a);
spc();
return;
}
inline void writesc(char a) {
write(a);
spc();
return;
}
inline void writesc(pair<long long, long long> a, char const *b = " ") {
write(a);
spc();
return;
}
inline void AC();
int main(int argc, char *argv[]) {
AC();
return 0;
}
const long long maxn = 2E2 + 8;
long long n, m, a[maxn], s = -1E11;
inline void AC() {
n = read();
m = read();
for (long long i = 1; i <= n; ++i) a[i] = read();
for (long long i = 1; i <= n; ++i)
for (long long j = i; j <= n; ++j) {
priority_queue<long long> mx;
priority_queue<long long, vector<long long>, greater<long long> > mn;
long long c = 0;
for (long long k = 1; k < i; ++k) mx.push(a[k]);
for (long long k = j + 1; k <= n; ++k) mx.push(a[k]);
for (long long k = i; k <= j; ++k) {
c += a[k];
mn.push(a[k]);
}
for (long long k = m; k--;) {
if (mx.empty() || mx.top() < mn.top()) break;
long long t1 = mx.top(), t2 = mn.top();
mx.pop();
mn.pop();
c += t1 - t2;
mn.push(t1);
mx.push(t2);
}
s = max(s, c);
}
writeln(s);
return;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int ar[222], tmp[222], on[222];
pair<int, int> pp[222];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a = 0, b, c, d, e = 0, f = 0, g, h = 0, x, y, z;
cin >> a >> b;
for (int i = (0); i < (a); ++i) {
cin >> ar[i];
pp[i].first = ar[i];
pp[i].second = i;
}
sort(pp, pp + a);
e = -INT_MAX / 3;
for (int i = 0; i < a; i++) {
for (int j = i; j < a; j++) {
memset(on, 0, sizeof on);
d = 0;
g = 0;
h = b;
for (int k = i; k <= j; k++) {
on[k] = 1;
tmp[d++] = ar[k];
g += ar[k];
}
sort(tmp, tmp + d);
f = a - 1;
for (int k = 0; k < d; k++) {
while (f >= 0 && on[pp[f].second] == 1) {
f--;
}
if (f < 0 || h == 0 || pp[f].first < tmp[k]) continue;
on[pp[f].second] = 1;
g += pp[f].first;
g -= tmp[k];
h--;
}
e = max(e, g);
}
}
cout << e << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxint = numeric_limits<int>::max();
const long long maxll = numeric_limits<long long>::max();
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long long md = 1e9 + 7;
const long double eps = 1e-10;
int main() {
int n, k;
cin >> n >> k;
vector<int> a;
a.resize(n);
for (auto &i : a) cin >> i;
int ans = -maxint;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int cnt = 0;
multiset<int> setik;
multiset<int> left;
for (int j_ = 0; j_ < i; j_++) left.insert(a[j_]);
for (int j_ = j + 1; j_ < n; j_++) left.insert(a[j_]);
for (int j_ = i; j_ <= j; j_++) cnt += a[j_], setik.insert(a[j_]);
int k_ = k;
while (k_-- && !left.empty()) {
if (*left.rbegin() > *setik.begin()) {
int from = *setik.begin();
int to = *left.rbegin();
setik.erase(setik.find(from));
left.erase(left.find(to));
setik.insert(to);
left.insert(from);
cnt -= from;
cnt += to;
}
}
ans = max(ans, cnt);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a[210];
cin >> n >> k;
for (int(i) = 0; (i) < (n); i++) cin >> a[i];
int res = -(1e9);
for (int(R) = 0; (R) < (n); R++)
for (int(L) = 0; (L) < (R + 1); L++) {
vector<int> v;
int sum = 0;
for (int i = L; i <= R; i++) {
v.push_back(a[i]);
sum += a[i];
}
sort((v).begin(), (v).end());
if ((int)(v).size() > k) v.resize(k);
vector<int> w;
for (int(i) = 0; (i) < (n); i++) {
if (i < L || i > R) w.push_back(a[i]);
}
sort((w).begin(), (w).end());
reverse((w).begin(), (w).end());
if ((int)(w).size() > k) w.resize(k);
for (int(i) = 0; (i) < (min((int)(v).size(), (int)(w).size())); i++) {
if (v[i] < w[i]) {
sum -= v[i];
sum += w[i];
}
}
res = max(res, sum);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
multiset<int> in;
multiset<int, greater<int> > out;
int N, K, A[202];
int main() {
scanf("%d %d", &N, &K);
for (int i = 0; i < N; i++) scanf("%d", &A[i]);
int ans = 0x80000000;
for (int i = 0; i < N; i++) {
in.clear();
out.clear();
for (int j = 0; j < N; j++) out.insert(A[j]);
int s = 0;
for (int j = i; j < N; j++) {
in.insert(A[j]);
s += A[j];
out.erase(out.find(A[j]));
int f = min(K, (int)min(in.size(), out.size()));
if (ans < s) ans = s;
multiset<int>::iterator I = in.begin();
multiset<int, greater<int> >::iterator J = out.begin();
int t = s;
while (f--) {
t -= *I;
t += *J;
if (ans < t) ans = t;
I++;
J++;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace SolveIt {
template <class _T>
void read(_T &x) {
x = 0;
char c = getchar();
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ '0'), c = getchar();
x *= f;
}
template <class _T>
void write(_T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int MAXN = 200 + 5, INF = 1005;
int N, K, A[MAXN], C[MAXN];
vector<pair<int, int> > hasWaped;
} // namespace SolveIt
int main() {
using namespace SolveIt;
read(N), read(K);
for (int i = 1; i <= N; ++i) read(A[i]);
int Ans = -INF * MAXN;
for (int dis = 1; dis <= N; ++dis) {
for (int i = 1, j = dis; j <= N; ++i, ++j) {
hasWaped.clear();
for (int k = 1; k <= K; ++k) {
int MinL = +INF * MAXN, MaxL = -INF * MAXN;
int MinP = 0, MaxP = 0;
for (int l = 1; l <= i - 1; ++l) {
if (MaxL < A[l]) MaxP = l, MaxL = A[l];
}
for (int l = i; l <= j; ++l) {
if (MinL > A[l]) MinP = l, MinL = A[l];
}
for (int l = j + 1; l <= N; ++l) {
if (MaxL < A[l]) MaxP = l, MaxL = A[l];
}
if (MaxL > MinL)
swap(A[MinP], A[MaxP]), hasWaped.push_back(make_pair(MinP, MaxP));
else
break;
}
int Res = 0;
for (int k = i; k <= j; ++k) Res += A[k];
Ans = max(Res, Ans);
for (unsigned k = 0; k < hasWaped.size(); ++k)
swap(A[hasWaped[k].first], A[hasWaped[k].second]);
}
}
write(Ans), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int INF = 1000000000;
const long long INFL = 1000000000000000LL;
const int MAXN = 200;
const double EPS = 1e-10;
pair<int, int> ar[MAXN];
int n, kk;
priority_queue<int, vector<int>, greater<int> > dalem;
priority_queue<int> luar;
int main() {
scanf("%d%d", &n, &kk);
for (int i = 0; i < n; i++) {
scanf("%d", &ar[i].first);
ar[i].second = i;
}
sort(ar, ar + n);
int maks = -INF;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
vector<int> dalem, luar;
int jumlah = 0;
for (int k = 0; k < n; k++) {
if (ar[k].second < i || ar[k].second > j)
luar.push_back(ar[k].first);
else
dalem.push_back(ar[k].first), jumlah += ar[k].first;
}
int SL = (int)luar.size();
int SD = (int)dalem.size();
int now = SL - 1;
int awal = 0;
int cou = 0;
while (awal < SD && now >= 0 && cou < kk && dalem[awal] < luar[now]) {
jumlah += luar[now] - dalem[awal];
awal++;
now--;
cou++;
}
maks = max(maks, jumlah);
}
}
printf("%d\n", maks);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int INF = (int)1e9;
int main() {
int n, K;
int num[N];
cin >> n >> K;
for (int i = 0; i < n; i++) cin >> num[i];
int ans = -INF;
vector<int> in, out;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
int sum = 0;
in.clear();
out.clear();
for (int k = 0; k < n; k++) {
if (k >= i && k <= j) {
in.push_back(num[k]);
sum += num[k];
} else
out.push_back(num[k]);
}
sort(in.begin(), in.end());
sort(out.begin(), out.end());
int in_sz = in.size();
int out_sz = out.size();
int x = min(in_sz, out_sz);
for (int k = 1; k <= min(x, K); k++)
if (in[k - 1] < out[out_sz - k]) sum += out[out_sz - k] - in[k - 1];
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1005];
int main() {
int cc;
int n, m;
while (cin >> n >> m) {
for (int i = 1; i <= n; i++) cin >> a[i];
int ans = -0x3f3f3f3f;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
vector<int> ss, pp;
int sum = 0;
for (int k = i; k <= j; k++) {
sum += a[k];
ss.push_back(a[k]);
}
for (int k = 1; k < i; k++) pp.push_back(a[k]);
for (int k = j + 1; k <= n; k++) pp.push_back(a[k]);
sort(ss.begin(), ss.end());
sort(pp.begin(), pp.end());
int l = 0, r = pp.size() - 1, p = m;
while ((p--) && l < ss.size() && r >= 0) {
if (ss[l] < pp[r]) {
sum -= ss[l];
sum += pp[r];
l++;
r--;
}
}
ans = max(ans, sum);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int A[200] = {};
int main() {
cin >> n >> k;
for (int x = 0; x < n; x++) cin >> A[x];
vector<int> B[201][201] = {};
for (int x = 0; x < n; x++) {
for (int y = 0; y < n; y++)
for (int z = 0; z < n; z++)
if (y <= x && x <= z) B[y][z].push_back(A[x]);
}
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++) sort(B[x][y].begin(), B[x][y].end());
int best = -(1 << 28);
for (int x = 0; x < n; x++)
for (int y = x; y < n; y++) {
vector<int> tmpA;
for (int N : B[y + 1][n - 1]) tmpA.push_back(N);
if (x > 0)
for (int N : B[0][x - 1]) tmpA.push_back(N);
sort(tmpA.begin(), tmpA.end());
int j = (int)tmpA.size() - 1;
int i = 0, tmp = 0, K = 0;
for (int N : B[x][y]) tmp += N;
while (i < B[x][y].size() && j >= 0 && tmpA[j] > B[x][y][i] && K < k) {
tmp += tmpA[j] - B[x][y][i];
i++;
j--;
K++;
}
best = max(best, tmp);
}
cout << best << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, res = -1000000007, k, tab[1000007];
multiset<int> in, out;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &tab[i]);
for (int l = 0; l < n; l++) {
in.clear();
out.clear();
for (int i = 0; i < n; i++) out.insert(tab[i]);
int suma = 0;
for (int r = l; r <= n - 1; r++) {
out.erase(out.lower_bound(tab[r]));
in.insert(tab[r]);
suma += tab[r];
int ile = k, s = suma;
set<int>::iterator itin = in.begin();
set<int>::reverse_iterator itout = out.rbegin();
while (ile > 0 && itin != in.end() && itout != out.rend() &&
*itin < *itout) {
s = s - *itin + *itout;
ile--;
itin++;
itout++;
}
res = max(res, s);
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[300];
long long int n, k;
long long int maxima(long long int l, long long int r) {
vector<long long int> naka, soto;
for (long long int i = 0; i < ((long long int)(n)); i++) {
if (i >= l && i <= r)
naka.push_back(a[i]);
else
soto.push_back(a[i]);
}
sort((naka).begin(), (naka).end());
sort((soto).begin(), (soto).end());
long long int kk = k;
long long int sn = ((long long int)(naka).size()),
ss = ((long long int)(soto).size());
for (long long int i = 0; i < ((long long int)(kk)); i++) {
if (i < sn && ss - i - 1 >= 0 && naka[i] < soto[ss - i - 1]) {
swap(naka[i], soto[ss - i - 1]);
} else
break;
}
long long int res = 0;
for (long long int i = 0; i < ((long long int)(sn)); i++) res += naka[i];
return res;
}
int main() {
cin >> n >> k;
for (long long int i = 0; i < ((long long int)(n)); i++) {
cin >> a[i];
}
long long int res = -99999999;
for (long long int i = 0; i < ((long long int)(n)); i++) {
for (long long int j = (long long int)(i); j < ((long long int)(n)); j++) {
res = max(res, maxima(i, j));
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 201;
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 0; i < n; ++i) cin >> a[i];
int res = accumulate(a, a + n, 0);
for (int i = 0; i < n; ++i)
for (int j = i; j < n; ++j) {
multiset<int> x(a + i, a + j + 1);
multiset<int> y(a, a + i);
y.insert(a + j + 1, a + n);
for (int t = 0; t < k; ++t) {
y.insert(*x.begin());
x.erase(x.begin());
x.insert(*y.rbegin());
y.erase(--y.end());
}
res = max(res, accumulate(x.begin(), x.end(), 0));
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500];
int main() {
int n, T;
scanf("%d %d", &n, &T);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int maxs = -0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
priority_queue<int, vector<int>, less<int> > out;
priority_queue<int, vector<int>, greater<int> > in;
for (int k = 1; k <= n; k++) {
if (k >= i && k <= j) {
in.push(a[k]);
} else {
out.push(a[k]);
}
}
int temp = T;
while (temp--) {
if (out.size() == 0 || in.size() == 0) continue;
int u = out.top();
int v = in.top();
if (u > v) {
in.pop();
out.pop();
out.push(v);
in.push(u);
}
}
int sum = 0;
while (!in.empty()) {
int u = in.top();
sum += u;
in.pop();
}
maxs = max(maxs, sum);
}
}
printf("%d\n", maxs);
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, a[210], sum[211], b[211], c[211], K;
int main() {
cin >> n >> K;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
int ans = -int(2e9);
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j) {
int p = 1, second = 1;
for (int k = 1; k <= n; ++k)
if (k >= i && k <= j)
b[p++] = a[k];
else
c[second++] = a[k];
sort(c + 1, c + second);
reverse(c + 1, c + second);
sort(b + 1, b + p);
int res = sum[j] - sum[i - 1];
ans = max(ans, res);
int t1 = 1, t2 = 1;
for (int q = 0; q < K; ++q) {
int x = -int(2e9), y = -int(2e9);
if (t1 < second) x = c[t1++];
if (t2 < p) y = b[t2++];
if (y == -int(2e9)) break;
if (x > y)
res += (x - y);
else if (y < 0 && j - i + 1 > 1)
res += y;
ans = max(ans, res);
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
int main() {
int n, m;
int ans, tot;
ans = -10000000;
int a[201];
scanf("%d", &n);
scanf("%d", &m);
for (int i = 1; i < n + 1; i++) scanf("%d", &a[i]);
for (int i = 1; i < n + 1; i++)
for (int j = i; j < n + 1; j++) {
tot = 0;
priority_queue<int> mx, mn;
for (int k = i; k < j + 1; k++) {
tot += a[k];
mn.push(-a[k]);
}
for (int k = 1; k < i; k++) mx.push(a[k]);
for (int k = j + 1; k < n + 1; k++) mx.push(a[k]);
int k = 0;
while (k < m && !mn.empty() && !mx.empty()) {
int t = mn.top();
int s = mx.top();
mn.pop(), mx.pop();
if (s + t > 0) tot += s + t;
k += 1;
}
ans = max(ans, tot);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, arr[202];
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
int ans = arr[0];
for (int l = 0; l < n; ++l) {
vector<int> in;
int sum = 0;
for (int r = l; r < n; ++r) {
sum += arr[r];
in.push_back(arr[r]);
vector<int> out;
for (int i = 0; i < n; ++i) {
if (i < l || i > r) out.push_back(arr[i]);
}
sort(in.begin(), in.end());
sort(out.rbegin(), out.rend());
int old = sum;
ans = max(ans, sum);
for (int i = 0; i < k && i < in.size() && i < out.size(); ++i) {
sum += out[i] - in[i];
ans = max(ans, sum);
}
sum = old;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 205;
int q, n, k, i, j, a[nmax], aux, s, sol;
multiset<int, greater<int> > out;
multiset<int> in;
multiset<int>::iterator itout, itin;
int main() {
scanf("%d%d", &n, &q);
sol = 1 << 31;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) {
out.clear();
in.clear();
s = 0;
for (j = 1; j <= n; j++) out.insert(a[j]);
for (j = i; j <= n; j++) {
out.erase(out.find(a[j]));
in.insert(a[j]);
s += a[j];
aux = s;
for (itout = out.begin(), itin = in.begin(), k = 1;
itout != out.end() && itin != in.end() && k <= q;
itout++, itin++, k++) {
if (*itout >= *itin)
aux += *itout - *itin;
else
break;
}
sol = max(sol, aux);
}
}
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205];
int main() {
int n, mm;
while (~scanf("%d%d", &n, &mm)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = -10000000;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
priority_queue<int, vector<int>, greater<int> > q1;
priority_queue<int> q2;
int sum = 0;
for (int k = 1; k <= n; k++) {
if (k >= i && k <= j) {
sum += a[k];
q1.push(a[k]);
} else
q2.push(a[k]);
}
int m = mm;
while (m && (!q2.empty()) && (!q1.empty()) && (q2.top() > q1.top())) {
m--;
sum -= q1.top();
sum += q2.top();
q1.pop();
q2.pop();
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NN = 222;
int main() {
ios::sync_with_stdio(false);
int N, K;
scanf("%d%d", &N, &K);
vector<int> s(N);
for (int i = 0; i < N; i++) scanf("%d", &s[i]);
vector<pair<int, int> > st;
for (int i = 0; i < N; i++) st.push_back(make_pair(s[i], i));
sort(st.rbegin(), st.rend());
int ans = -1 << 29;
for (int i = 0; i < N; i++) {
vector<int> x;
int val = 0;
for (int j = i; j < N; j++) {
vector<int> cur;
val = 0;
for (int k = i; k < j + 1; k++) cur.push_back(s[k]), val += s[k];
sort(cur.begin(), cur.end());
int idx = 0;
for (int k = 0; k < N; k++)
if (st[k].second < i || st[k].second > j) {
if (st[k].first > cur[idx])
val -= cur[idx], val += st[k].first, idx++;
else
break;
if (idx == ((int)cur.size()) || idx == K) break;
}
ans = ((ans) > (val) ? (ans) : (val));
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, mx = -1000000000;
long long a[201];
void initialization() {
cin >> n >> k;
for (long long i = 0; i < n; ++i) cin >> a[i];
}
void solve() {
for (long long l = 0; l < n; ++l)
for (long long r = l; r < n; ++r) {
long long one[201], two[201];
for (long long k = l; k <= r; ++k) one[k - l] = a[k];
for (long long k = 0; k < l; ++k) two[k] = a[k];
for (long long k = r + 1; k < n; ++k) two[k - r - 1 + l] = a[k];
sort(one, one + r - l + 1);
sort(two, two + n - r + l - 1);
long long cur_one = 0, cur_two = n - r + l - 2, op = 0;
while (cur_one < r - l + 1 && cur_two >= 0 && op < k &&
one[cur_one] < two[cur_two]) {
swap(one[cur_one], two[cur_two]);
++cur_one;
--cur_two;
++op;
}
long long sum = 0;
for (long long k = 0; k <= r - l; ++k) sum += one[k];
if (mx < sum) mx = sum;
}
}
void print() { cout << mx; }
int main() {
initialization();
solve();
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int a[202];
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int sum[202] = {0};
sum[0] = 0;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i - 1];
int MAX = -100000;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
vector<int> in, out;
for (int t = 0; t < n; t++) {
if (i <= t && t <= j)
in.push_back(a[t]);
else
out.push_back(a[t]);
}
sort(in.begin(), in.end());
sort(out.begin(), out.end());
int ret = sum[j + 1] - sum[i];
int s = 0, t = out.size() - 1;
if (t >= 0)
while (s < k && in[s] < out[t] && s < in.size() && t >= 0) {
ret += out[t] - in[s];
s++;
t--;
}
MAX = max(MAX, ret);
}
}
printf("%d\n", MAX);
}
|
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
void CI(int &_x) { scanf("%d", &_x); }
void CO(int &_x) { cout << _x; }
template <typename T>
void getarray(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void printarray(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
int dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
int dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
int dr4[4] = {0, 0, 1, -1};
int dc4[4] = {-1, 1, 0, 0};
int kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
int kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
bool taken[205] = {0};
int sz;
int main() {
vector<int> V;
int n, kount;
cin >> n >> kount;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
V.push_back(temp);
}
int ans = -(1 << 30);
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
vector<int> A, B;
for (int k = 0; k < n; k++)
if (k >= i && k <= j)
A.push_back(V[k]);
else
B.push_back(V[k]);
sort(A.begin(), A.end());
sort(B.begin(), B.end());
int sz = B.size() - 1;
for (int k = 0; k < A.size() && k < kount && sz >= 0; k++) {
if (A[k] < B[sz]) {
swap(A[k], B[sz]);
sz--;
}
}
int sum = 0;
for (int k = 0; k < A.size(); k++) {
sum += A[k];
}
ans = max(ans, sum);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 207;
int a[maxn], n, k, l1[maxn], l2[maxn], c1, c2;
bool mycmp(const int &a, const int &b) { return a > b; }
int cal(int l, int r) {
c1 = 0;
for (int i = 1, _c = l - 1; i <= _c; i++) l1[++c1] = a[i];
for (int i = r + 1, _c = n; i <= _c; i++) l1[++c1] = a[i];
c2 = 0;
int res = 0;
for (int i = l, _c = r; i <= _c; i++) l2[++c2] = a[i], res += a[i];
if (c1 > 0) sort(l1 + 1, l1 + c1 + 1, mycmp);
if (c2 > 0) sort(l2 + 1, l2 + c2 + 1);
int idx = 1;
for (int i = 1, _c = min(k, min(c1, c2)); i <= _c; i++) {
if (l1[i] - l2[i] > 0)
res += l1[i] - l2[i];
else
break;
}
return res;
}
int main() {
cin >> n >> k;
for (int i = 1, _c = n; i <= _c; i++) cin >> a[i];
int res = -1000000007;
for (int i = 1, _c = n; i <= _c; i++)
for (int j = i, _c = n; j <= _c; j++) {
res = max(res, cal(i, j));
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXBUF = 10000;
char buf[MAXBUF], *ps = buf, *pe = buf + 1;
inline bool isdigit(const char &n) { return (n >= '0' && n <= '9'); }
inline void rnext() {
if (++ps == pe)
pe = (ps = buf) +
fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin);
}
template <class T>
inline bool in(T &ans) {
ans = 0;
T f = 1;
if (ps == pe) return false;
do {
rnext();
if ('-' == *ps) f = -1;
} while (!isdigit(*ps) && ps != pe);
if (ps == pe) return false;
do {
ans = (ans << 1) + (ans << 3) + *ps - 48;
rnext();
} while (isdigit(*ps) && ps != pe);
ans *= f;
return true;
}
const int MAXOUT = 10000;
char bufout[MAXOUT], outtmp[50], *pout = bufout, *pend = bufout + MAXOUT;
inline void write() {
fwrite(bufout, sizeof(char), pout - bufout, stdout);
pout = bufout;
}
inline void out_char(char c) {
*(pout++) = c;
if (pout == pend) write();
}
inline void out_str(char *s) {
while (*s) {
*(pout++) = *(s++);
if (pout == pend) write();
}
}
template <class T>
inline void out_int(T x) {
if (!x) {
out_char('0');
return;
}
if (x < 0) x = -x, out_char('-');
int len = 0;
while (x) {
outtmp[len++] = x % 10 + 48;
x /= 10;
}
outtmp[len] = 0;
for (int i = 0, j = len - 1; i < j; i++, j--) swap(outtmp[i], outtmp[j]);
out_str(outtmp);
}
template <typename T, typename... T2>
inline int in(T &value, T2 &...value2) {
in(value);
return in(value2...);
}
const double eps = 1e-9;
const int maxn = 210;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int N, K;
int a[maxn];
bool vis[maxn][3][15][15];
int dp[maxn][3][15][15];
int DP(int l, int st, int out, int In) {
if (l == N && !st) return -INF;
if (l == N + 1) {
if (In == out && st) return 0;
return -INF;
}
if (vis[l][st][out][In]) return dp[l][st][out][In];
int &ans = dp[l][st][out][In] = -INF;
if (st == 0) {
ans = max(DP(l + 1, 1, out, In), DP(l + 1, 0, out, In));
if (In < K && l) {
ans = max(ans, DP(l + 1, 0, out, In + 1) + a[l]);
ans = max(ans, DP(l + 1, 1, out, In + 1) + a[l]);
}
} else if (st == 1) {
ans = max(DP(l + 1, 1, out, In) + a[l], DP(l + 1, 2, out, In) + a[l]);
if (out < K) {
ans = max(DP(l + 1, 1, out + 1, In), ans);
ans = max(DP(l + 1, 2, out + 1, In), ans);
}
} else {
ans = DP(l + 1, 2, out, In);
if (In < K) {
ans = max(ans, DP(l + 1, 2, out, In + 1) + a[l]);
}
}
vis[l][st][out][In] = 1;
return ans;
}
int main() {
in(N, K);
for (int i = 1; i <= N; i++) in(a[i]);
printf("%d\n", DP(0, 0, 0, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500];
int main() {
int n, T;
while (~scanf("%d%d", &n, &T)) {
int output = -0x3f3f3f3f;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
priority_queue<int, vector<int>, less<int> > out;
priority_queue<int, vector<int>, greater<int> > in;
for (int k = 1; k <= n; k++) {
if (k >= i && k <= j) {
in.push(a[k]);
} else
out.push(a[k]);
}
int temp = T;
while (temp--) {
if (out.size() == 0 || in.size() == 0) continue;
int u = out.top();
int v = in.top();
if (u > v) {
in.pop();
out.pop();
out.push(v);
in.push(u);
}
}
int sum = 0;
while (!in.empty()) {
int u = in.top();
sum += u;
in.pop();
}
output = max(output, sum);
}
}
printf("%d\n", output);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210;
int a[maxn], b[maxn], c[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = -1e9;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
int sum = 0;
for (int t = i; t <= j; t++) {
b[t - i] = a[t];
sum += a[t];
}
int p = 0;
for (int t = 1; t < i; t++) c[p++] = a[t];
for (int t = j + 1; t <= n; t++) c[p++] = a[t];
sort(b, b + j - i + 1);
sort(c, c + p);
int p1 = 0, p2 = p - 1;
int cnt = 0;
while (cnt < k) {
if (p1 >= j - i + 1 || p2 <= -1) break;
if (b[p1] >= c[p2]) break;
sum += c[p2] - b[p1];
p2--;
p1++;
cnt++;
}
if (sum > ans) ans = sum;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int a[200];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int mx = -1000;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n - i; j++) {
vector<int> ch;
vector<int> out;
for (int k = 0; k < n; k++) {
if (j <= k && k <= i + j - 1) {
ch.push_back(a[k]);
} else {
out.push_back(a[k]);
}
}
sort(ch.begin(), ch.end());
sort(out.begin(), out.end());
int sum = 0;
for (int k = 0; k < i; k++) {
sum += ch[k];
}
int down = out.size();
int up = min(min(s, i), down);
for (int k = 0; k < up; k++) {
if (ch[k] < out[down - k - 1]) {
sum += out[down - k - 1] - ch[k];
} else {
break;
}
}
mx = max(mx, sum);
}
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
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 = -300 * 1000;
for (int i = 0; i < n; ++i)
for (int j = i; j < n; ++j) {
vector<int> w;
vector<int> w2(v.begin() + i, v.begin() + j + 1);
for (int k = 0; k < n; ++k) {
if (k >= i && k <= j) continue;
w.push_back(v[k]);
}
sort(w.rbegin(), w.rend());
if ((int)w.size() > K) w = vector<int>(w.begin(), w.begin() + K);
for (auto tmp : w) w2.push_back(tmp);
sort(w2.rbegin(), w2.rend());
int tmp = 0;
for (int k = 0; k < j - i + 1; ++k) tmp += w2[k];
ans = max(ans, tmp);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, B[201];
pair<int, int> a[201];
bool comp(pair<int, int> x, pair<int, int> y) { return x.first > y.first; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
long long res = 0;
for (int i = 1, b = (n); i <= b; ++i) {
cin >> a[i].first;
a[i].second = i;
res += a[i].first;
B[i] = a[i].first;
}
sort(a + 1, a + 1 + n, comp);
for (int lo = 1, b = (n); lo <= b; ++lo)
for (int hi = lo, b = (n); hi <= b; ++hi) {
vector<int> tmp;
long long cur = 0;
for (int i = lo, b = (hi); i <= b; ++i) {
tmp.push_back(B[i]);
cur += B[i];
}
sort(tmp.begin(), tmp.end());
int i = 0, j = 1;
int _k = k;
while (_k > 0) {
while (j <= n && a[j].second <= hi && a[j].second >= lo) ++j;
if (i <= ((int)tmp.size()) - 1 && j <= n && a[j].first > tmp[i]) {
cur = cur - tmp[i] + a[j].first;
++i;
++j;
--_k;
} else
break;
}
if (res < cur) {
res = cur;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[222], sum[222];
struct node {
int a, id;
} b[222];
bool cmp(node s, node d) { return s.a < d.a; }
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i], b[i].a = a[i], b[i].id = i;
;
sum[0] = a[0];
for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + a[i];
sort(b, b + n, cmp);
int ans = -22222;
for (int l = 0; l < n; l++)
for (int r = l; r < n; r++) {
int p = min(k, r - l + 1);
int res = sum[r];
if (l) res -= sum[l - 1];
int i = 0, j = n - 1;
while (p--) {
while (i < n && b[i].id < l || b[i].id > r) i++;
while (j >= 0 && b[j].id >= l && b[j].id <= r) j--;
if (i == n || j == -1) break;
if (b[i].a > b[j].a) break;
res += (b[j].a - b[i].a);
i++;
j--;
}
ans = max(ans, res);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int maxSubArraySum(long long int a[], long long int size) {
long long int max_so_far = INT_MIN, max_ending_here = 0;
for (long long int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_so_far < max_ending_here) max_so_far = max_ending_here;
if (max_ending_here < 0) max_ending_here = 0;
}
return max_so_far;
}
int32_t main() {
long long int t;
t = 1;
while (t--) {
long long int n;
cin >> n;
long long int sum = 0;
long long int a[n];
string s;
vector<long long int> v;
long long int k;
cin >> k;
long long int b[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
long long int p = 0;
for (long long int i = 0; i < n; i++) {
if (a[i] != b[i]) {
p = 1;
break;
}
}
if (p == 0) {
cout << maxSubArraySum(a, n);
} else {
long long int ansfinal = -1e9;
for (long long int i = 0; i < n; i++) {
for (long long int j = i; j < n; j++) {
long long int u = k;
long long int ans = 0;
priority_queue<long long int> pq;
priority_queue<long long int, vector<long long int>,
greater<long long int>>
pqmin;
for (long long int k = 0; k < n; k++) {
if (k >= i && k <= j) {
ans += a[k];
pqmin.push(a[k]);
} else {
pq.push(a[k]);
}
}
while (u && pq.size() && pqmin.size()) {
if (pqmin.top() >= pq.top()) {
break;
} else {
ans -= pqmin.top();
pqmin.pop();
ans += pq.top();
pq.pop();
}
u--;
}
ansfinal = max(ans, ansfinal);
}
}
cout << ansfinal;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int A[200];
vector<int> res;
for (int i = 0; i < n; ++i) cin >> A[i];
for (int l = 0; l < n; ++l) {
for (int r = l; r < n; ++r) {
int ins[200], outs[200];
int d1 = 0, d2 = 0;
for (int j = 0; j < n; ++j) {
if (j < l || j > r) {
outs[d1] = A[j];
++d1;
} else {
ins[d2] = A[j];
++d2;
}
}
sort(ins, ins + d2);
sort(outs, outs + d1);
for (int j = 0; j < min(k, min(d2, d1)); ++j) {
if (ins[j] < outs[d1 - 1 - j]) {
ins[j] = outs[d1 - 1 - j];
} else
break;
}
int sum = 0;
for (int j = 0; j < d2; ++j) sum += ins[j];
res.push_back(sum);
}
}
sort(res.begin(), res.end());
cout << res[res.size() - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int s[205];
void init() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &s[i]);
}
}
int id[205];
bool sortByValue(int x, int y) { return s[x] > s[y]; }
void process() {
for (int i = 0; i < n; i++) id[i] = i;
sort(id, id + n, sortByValue);
int ans = -1000000000;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int tmp = 0, left = k, cnt = 0;
for (int t = 0; t < n; t++) {
if (i <= id[t] && id[t] <= j) {
tmp += s[id[t]];
cnt++;
} else if (left > 0) {
tmp += s[id[t]];
cnt++, left--;
}
if (cnt == j - i + 1) break;
}
ans = max(ans, tmp);
}
}
printf("%d\n", ans);
}
int main() {
init();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[205];
int main() {
int N, K;
scanf("%d%d", &N, &K);
for (int i = 0; i < N; i++) scanf("%d", &A[i]);
int ans = A[0];
for (int L = 0; L < N; L++)
for (int R = L; R < N; R++) {
vector<int> B, C;
for (int i = 0; i < L; i++) B.push_back(A[i]);
for (int i = R + 1; i < N; i++) B.push_back(A[i]);
sort(B.begin(), B.end());
for (int i = L; i <= R; i++) C.push_back(A[i]);
sort(C.begin(), C.end());
int indC = 0, indB = B.size() - 1, count = 0;
while (count < K && indB >= 0 && indC < C.size()) {
if (C[indC] < B[indB]) {
C[indC] = B[indB];
indC++;
indB--;
count++;
} else {
break;
}
}
int temp = 0;
for (int i = 0; i < C.size(); i++) temp += C[i];
ans = max(ans, temp);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9, MOD = 1e9 + 7;
const int n_ = 210;
long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
int main() {
ios_base::sync_with_stdio(false);
int n, a[n_], m, x[n_], y[n_], first, second, sum, ans = -INF;
scanf("%d %d", &n, &m);
for (int(i) = 0; (i) < (n); (i)++) scanf("%d", a + i);
for (int(e) = 0; (e) < (n); (e)++) {
for (int(b) = 0; (b) < (e + 1); (b)++) {
first = second = sum = 0;
for (int(k) = 0; (k) < (n); (k)++) {
if (b <= k && k <= e) {
x[first++] = a[k];
sum += a[k];
} else {
y[second++] = a[k];
}
}
sort(x, x + first);
sort(y, y + second, greater<int>());
for (int(k) = 0; (k) < (m); (k)++) {
if (k < min(first, second) && x[k] < y[k]) {
sum += y[k] - x[k];
}
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1010], s[1010];
int main() {
int n, rem, k, i, j, l, m, cur, tmp;
while (cin >> n >> rem) {
for (i = 0; i < n; i++) cin >> a[i];
int ans = a[0];
for (l = 1; l <= n; l++) {
for (i = 0; i <= n - l; i++) {
k = rem;
cur = 0;
priority_queue<int> st, nu;
for (j = i; j < i + l; j++) {
st.push(-a[j]);
cur += a[j];
}
for (; j < n; j++) nu.push(a[j]);
for (j = 0; j < i; j++) nu.push(a[j]);
while (k > 0 && !(nu.empty())) {
auto x = nu.top(), y = st.top();
nu.pop();
st.pop();
if (x <= (-y)) break;
st.push(-x);
cur += y;
cur += x;
k--;
}
ans = max(cur, ans);
}
}
cout << ans << endl;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.