text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[333], f[333], z, mx = -1e9, mi, mj, min_ans = 1e9, ans = -1e9, kk;
int solve(int l, int r) {
int mx = 0;
vector<int> v, w;
for (int i = 0; i < n; i++)
if (i < l || i > r)
v.push_back(a[i]);
else {
w.push_back(a[i]);
mx += a[i];
}
int kol = k;
int i = 0;
int j = 0;
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
sort(w.begin(), w.end());
while (81 == 81) {
if (kol == 0 || i == v.size() || j == w.size()) break;
if (v[i] > w[j])
mx += v[i] - w[j];
else
break;
kol--;
i++;
j++;
}
return mx;
}
int main() {
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++) ans = max(ans, solve(i, j));
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n = 0;
vector<int> v;
int flag[2010];
int countt = 0;
int k = 0;
int maxt = 0;
int main() {
cin >> n;
cin >> k;
for (int i = 0; i < n; i++) {
int kari = 0;
cin >> kari;
v.push_back(kari);
if (i == 0) {
maxt = kari;
} else {
maxt = max(maxt, kari);
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
vector<int> u;
vector<int> d;
u.clear();
d.clear();
int sum = 0;
for (int jj = 0; jj < n; jj++) {
if (jj < i || j < jj) {
d.push_back(v[jj]);
} else {
sum += v[jj];
u.push_back(v[jj]);
}
}
sort(u.begin(), u.end());
sort(d.begin(), d.end());
maxt = max(maxt, sum);
{
int ii = 0;
int jj = d.size() - 1;
for (; ii < u.size() && jj >= 0 && ii < k; ii++, jj--) {
sum -= u[ii];
sum += d[jj];
maxt = max(maxt, sum);
}
}
}
}
cout << maxt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int INF = 0x3f3f3f3f;
int n, k, a[N], b[N];
void init() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
}
int solve(int l, int r) {
memcpy(b, a, sizeof(a));
int ans = 0;
for (int i = l; i <= r; i++) ans += a[i];
int p, q;
for (int i = 0; i < k; i++) {
int bMax = -INF, bMin = INF;
for (int j = 1; j <= n; j++) {
if ((j < l || j > r) && b[j] > bMax) {
bMax = b[j];
p = j;
} else if (j >= l && j <= r && b[j] < bMin) {
bMin = b[j];
q = j;
}
}
int t = bMax - bMin;
if (t <= 0) break;
ans += t;
swap(b[p], b[q]);
}
return ans;
}
int main() {
init();
int ans = -INF;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) ans = max(ans, solve(i, j));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
int a[205], b[205];
bool cmp(int x, int y) { return x > y; }
int main() {
int n, k, ans = -inf;
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++) {
int sum = 0, cnt = 0, t;
for (int i = l; i <= r; i++) {
b[cnt++] = a[i];
sum += a[i];
}
sort(b, b + cnt);
for (int i = 0; i < cnt && i < k; i++) {
sum -= b[i];
}
cnt = min(cnt, k);
t = cnt;
for (int i = 0; i < l; i++) {
b[cnt++] = a[i];
}
for (int i = r + 1; i < n; i++) {
b[cnt++] = a[i];
}
sort(b, b + cnt, cmp);
for (int i = 0; i < cnt && i < t; i++) {
sum += b[i];
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = -1e9;
int find_max(multiset<int> &in_range, multiset<int> &out_of_range,
int sum_in_range) {
while (!in_range.empty() and !out_of_range.empty() and
*in_range.begin() < *out_of_range.rbegin()) {
sum_in_range -= *in_range.begin();
sum_in_range += *out_of_range.rbegin();
in_range.erase(in_range.begin());
out_of_range.erase(--out_of_range.end());
}
return sum_in_range;
}
void solve() {
int n, k, res = inf;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
multiset<int> in_range;
multiset<int> out_of_range;
int sum_in_range = 0;
for (int cur_idx = 0; cur_idx < n; cur_idx++) {
if (cur_idx >= l and cur_idx <= r) {
in_range.insert(v[cur_idx]);
sum_in_range += v[cur_idx];
if (in_range.size() > k) {
in_range.erase(--in_range.end());
}
} else {
out_of_range.insert(v[cur_idx]);
if (out_of_range.size() > k) {
out_of_range.erase(out_of_range.begin());
}
}
}
res = max(res, find_max(in_range, out_of_range, sum_in_range));
}
}
cout << res << '\n';
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
long a[200];
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
long m = a[0];
vector<vector<int> > v;
for (int i = 0, _n = n; i < _n; i++) {
vector<int> v1;
v1.push_back(a[i]);
v1.push_back(i);
v.push_back(v1);
}
sort(v.begin(), v.end());
long s = 0;
for (int i = 0; i < n; i++) {
s = a[i];
for (int j = i + 1; j < n; j++) {
s = s + a[j];
long s1 = 0;
long s2 = 0;
int i1 = 0;
int t1 = 0;
while (i1 < n && t1 < k && v[i1][0] < 0) {
if (v[i1][1] >= i && v[i1][1] <= j) {
t1++;
s1 += v[i1][0];
}
i1++;
}
i1 = n - 1;
int t2 = 0;
while (i1 >= 0 && t2 < t1) {
if (v[i1][1] < i || v[i1][1] > j) {
t2++;
s2 += v[i1][0];
}
i1--;
}
if (t1 == t2) {
int m1 = s - s1 + s2;
if (m1 > m) m = m1;
}
}
}
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int INF = 1e9 + 10;
const long long LINF = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000 + 100;
const int MN = 2e2 + 10;
int arr[MN], sv[MN];
int n, k;
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
long long Mx = -INF;
for (int i = 0; i < n; ++i) cin >> arr[i], sv[i] = arr[i];
arr[n] = -INF, arr[n + 1] = +INF;
for (int l = 0; l < n; ++l)
for (int r = l; r < n; ++r) {
int rep = k;
long long sm = 0;
for (int i = l; i <= r; ++i) sm += arr[i];
while (rep--) {
int mx = n, mn = n + 1;
for (int i = 0; i < n; ++i) {
if (l <= i && i <= r && arr[mn] > arr[i])
mn = i;
else if (((i < l) || (r < i)) && arr[mx] < arr[i])
mx = i;
}
if (mx == n || mn == n + 1) continue;
Mx = max(Mx, sm - arr[mn] + arr[mx]);
sm = sm - arr[mn] + arr[mx];
swap(arr[mn], arr[mx]);
}
Mx = max(Mx, sm);
for (int i = 0; i < n; ++i) arr[i] = sv[i];
}
cout << Mx << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, kk, ans = -1000 * 210, a[310], b[310], c[310];
int min(int a, int b) { return (a < b) ? a : b; }
int cmp(int a, int b) {
if (a > b) return true;
return false;
}
int main() {
int i, j, k, tot1, tot2;
scanf("%d%d", &n, &kk);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
if (n == 1) {
printf("%d", a[1]);
return 0;
}
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
for (k = i, tot1 = 0; k <= j; k++) b[++tot1] = a[k];
for (k = 1, tot2 = 0; k < i; k++) c[++tot2] = a[k];
for (k = j + 1; k < n; k++) c[++tot2] = a[k];
sort(b + 1, b + tot1 + 1);
sort(c + 1, c + tot2 + 1, cmp);
for (k = 1; k <= min(kk, j - i + 1); k++)
if (b[k] < c[k]) {
int t = b[k];
b[k] = c[k];
c[k] = t;
} else
break;
int sum = 0;
for (k = 1; k <= tot1; k++) sum += b[k];
if (sum > ans) ans = sum;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x, y, i, j, n, s1, k, l, m, b[300];
vector<int> a[300][300], s;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> b[i];
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
for (l = i; l <= j; l++) a[i][j].push_back(b[l]);
sort(a[i][j].begin(), a[i][j].end());
}
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
s.clear();
for (l = 1; l < i; l++) s.push_back(b[l]);
for (l = j + 1; l <= n; l++) s.push_back(b[l]);
sort(s.begin(), s.end());
x = s.size() - 1;
for (l = 1; l <= k; l++)
if (x >= 0 && l <= a[i][j].size()) {
if (s[x] > a[i][j][l - 1]) {
swap(s[x], a[i][j][l - 1]);
x--;
}
} else
break;
}
k = -100000000;
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
s1 = 0;
for (l = 0; l < a[i][j].size(); l++) s1 += a[i][j][l];
k = max(k, s1);
}
cout << k;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int res = -INF;
for (int l = 0; l < n; l++)
for (int r = l; r < n; r++) {
int len = r - l + 1;
vector<int> in;
vector<int> out;
in.reserve(len);
out.reserve(n - len);
for (int i = 0; i < n; i++)
if (i < l || i > r)
out.push_back(a[i]);
else
in.push_back(a[i]);
sort(in.begin(), in.end());
sort(out.begin(), out.end());
reverse(out.begin(), out.end());
int cur = 0;
for (int i = 0; i < len; i++) cur += in[i];
res = max(res, cur);
int sin = 0;
int sout = 0;
for (int i = 0; i < min(min(len, n - len), k); i++) {
sin += in[i];
sout += out[i];
res = max(res, cur + sout - sin);
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[210], ans = -1e9;
void work(int l, int r) {
vector<int> b, c;
int val = 0;
for (int i = l; i <= r; ++i) b.push_back(a[i]), val += a[i];
for (int i = 1; i <= l - 1; ++i) c.push_back(a[i]);
for (int i = r + 1; i <= n; ++i) c.push_back(a[i]);
sort(b.begin(), b.end());
sort(c.begin(), c.end());
reverse(c.begin(), c.end());
for (int i = 0; i < min((int)min(b.size(), c.size()), k); ++i) {
if (b[i] < c[i])
val += c[i] - b[i];
else
break;
}
ans = max(ans, val);
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int l = 1; l <= n; ++l)
for (int r = l; r <= n; ++r) work(l, r);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[205], b[205], c[205];
int kq;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
kq = a[0];
for (int l = 0; l < n; l++)
for (int r = l; r < n; r++) {
int sum = 0;
int m = 0;
for (int i = 0; i < l; i++) {
b[m] = a[i];
m++;
}
for (int i = r + 1; i < n; i++) {
b[m] = a[i];
m++;
}
sort(b, b + m);
int o = 0;
for (int i = l; i <= r; i++) {
c[o] = a[i];
o++;
}
sort(c, c + o);
sum = 0;
int i = m - 1;
int j = 0;
int d = 0;
while (j < o) {
if (b[i] > c[j] && d < k && i >= 0) {
sum += b[i];
i--;
j++;
d++;
} else {
sum += c[j];
j++;
}
}
kq = max(kq, sum);
}
cout << kq;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, o, p, q, f, k, a[202], mark[202], maxx, minn;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
q = -99999999;
a[0] = -999999;
a[201] = 999999;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
o = 0;
for (int l = i; l <= j; l++) {
o += a[l];
}
for (int l = 1; l <= n; l++) {
mark[l] = 0;
}
for (int l = 1; l <= k; l++) {
maxx = 0;
minn = 201;
for (int w = 1; w < i; w++) {
if (mark[w] == 1) continue;
if (a[maxx] < a[w]) maxx = w;
}
for (int w = j + 1; w <= n; w++) {
if (mark[w] == 1) continue;
if (a[maxx] < a[w]) maxx = w;
}
for (int w = i; w <= j; w++) {
if (mark[w] == 1) continue;
if (a[minn] > a[w]) minn = w;
}
mark[minn] = 1;
mark[maxx] = 1;
if (a[minn] < a[maxx])
o += abs(a[minn] - a[maxx]);
else
l = k + 1;
}
if (o > q) q = o;
}
}
cout << q;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 203;
int a[NMAX], inside[NMAX], outside[NMAX];
int main() {
cin.sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int sol = -(1 << 30), sum = 0, st, dr, insize, outsize;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
st = i;
dr = j;
sum = 0, insize = 0, outsize = 0;
for (int ind = st; ind <= dr; ind++) {
sum += a[ind];
inside[++insize] = a[ind];
}
for (int ind = 1; ind < st; ind++) {
outside[++outsize] = a[ind];
}
for (int ind = dr + 1; ind <= n; ind++) {
outside[++outsize] = a[ind];
}
sort(outside, outside + outsize + 1);
sort(inside, inside + insize + 1);
int insecv = 1;
int sfarsit = outsize;
for (int steps = 1; steps <= k && insecv <= insize && sfarsit; steps++) {
if (inside[insecv] < outside[sfarsit]) {
sum = sum - inside[insecv] + outside[sfarsit];
insecv++, sfarsit--;
} else
break;
}
sol = max(sol, sum);
}
}
cout << sol << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200 + 10;
int a[maxN], n, k;
int get(int l, int r) {
vector<int> b, c;
for (int i = l; i <= r; i++) b.push_back(a[i]);
for (int i = 0; i < l; i++) c.push_back(a[i]);
for (int i = r + 1; i < n; i++) c.push_back(a[i]);
sort(c.begin(), c.end(), greater<int>());
c.resize(min((int)c.size(), k));
for (int i = 0; i < b.size(); i++) c.push_back(b[i]);
sort(c.begin(), c.end(), greater<int>());
c.resize(r - l + 1);
int res = 0;
for (int i = 0; i < r - l + 1; i++) res += c[i];
return res;
}
int32_t 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 = -2e9;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) res = max(res, get(i, j));
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, h, sol = -1e9, a[205];
int main() {
scanf("%d%d", &n, &h);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
priority_queue<int, vector<int>, greater<int> > w, tw;
for (int j = i; j <= n; j++) {
w.push(a[j]);
tw = w;
priority_queue<int> q;
for (int k = 1; k < i; k++) q.push(a[k]);
for (int k = j + 1; k <= n; k++) q.push(a[k]);
int t = 0, sum = 0;
while (!w.empty() && !q.empty() && t < h) {
int e = w.top();
w.pop();
int s = q.top();
q.pop();
if (s <= e) {
sum += e;
break;
}
t++;
sum += s;
}
while (!w.empty()) {
int e = w.top();
w.pop();
sum += e;
}
w = tw;
if (sum > sol) sol = sum;
}
}
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[220], n, k, ans = 0xbfbfbfbf;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
priority_queue<int> mx;
priority_queue<int, vector<int>, greater<int>> mn;
for (int t = 1; t < i; t++) mx.push(v[t]);
for (int t = j + 1; t <= n; t++) mx.push(v[t]);
int sum = 0;
for (int t = i; t <= j; t++) mn.push(v[t]), sum += v[t];
ans = max(ans, sum);
for (int t = 1; t <= k && !mx.empty() && !mn.empty(); t++) {
if (mn.top() < mx.top())
sum -= mn.top(), sum += mx.top(), mn.pop(), mx.pop();
else
break;
}
ans = max(ans, sum);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
void optimizeIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
optimizeIO();
int n, K, ans = INT_MIN;
cin >> n >> K;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
multiset<int> a, b;
int sum = 0;
for (int k = 0; k < i; k++) a.insert(v[k]);
for (int k = i; k <= j; k++) b.insert(v[k]), sum += v[k];
for (int k = j + 1; k < n; k++) a.insert(v[k]);
for (int k = 0; k < K and not a.empty() and not b.empty(); k++) {
int A = *(a.rbegin());
int B = *(b.begin());
if (A <= B) break;
sum += A - B;
a.erase(a.find(A));
b.erase(b.find(B));
}
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[300] = {0};
int solve(int l, int r, int k) {
vector<long long> out, in;
out.empty();
in.empty();
for (int i = 0; i < n; i++)
if (i < l || i > r) out.push_back(a[i]);
for (int i = l; i <= r; i++) in.push_back(a[i]);
sort(out.begin(), out.end());
sort(in.begin(), in.end());
int t = 0;
for (int i = out.size() - 1; i >= 0 && k > t && t < in.size(); i--) {
if (in[t] < out[i]) {
in[t] = out[i];
t++;
} else
break;
}
int sum = 0;
for (int i = 0; i < in.size(); i++) sum += in[i];
return sum;
}
int main() {
int k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int ans = a[0];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) ans = max(ans, solve(i, j, k));
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int a[220];
int ans = -9999999;
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> otr, ost;
for (int g = 1; g <= n; g++)
if (g >= i && g <= j)
otr.push_back(a[g]);
else
ost.push_back(a[g]);
sort(ost.begin(), ost.end());
sort(otr.begin(), otr.end());
int uotr = 0, uost = (int)ost.size() - 1;
while (uotr < otr.size() && uost >= 0 && uotr < k &&
otr[uotr] < ost[uost]) {
otr[uotr] = ost[uost];
uotr++;
uost--;
}
int sum = 0;
for (int g = 0; g < otr.size(); g++) sum += otr[g];
ans = max(ans, sum);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205];
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int MAXSUM = -0x3f3f3f;
for (int l = 0; l < n; ++l)
for (int r = l; r < n; ++r) {
priority_queue<int> Q;
priority_queue<int, vector<int>, greater<int> > P;
int sum = 0;
for (int i = 0; i < n; ++i) {
if (i < l || i > r)
Q.push(a[i]);
else {
P.push(a[i]);
sum += a[i];
}
}
for (int i = 0; i < min(k, n - (r - l + 1)); ++i) {
int MAX = Q.top();
int MIN = P.top();
sum = sum + MAX - MIN;
Q.pop();
P.pop();
P.push(MAX);
Q.push(MIN);
}
if (sum > MAXSUM) MAXSUM = sum;
while (!P.empty()) P.pop();
while (!Q.empty()) Q.pop();
}
printf("%d\n", MAXSUM);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const int maxN = 210;
int a[maxN];
int sum[maxN];
int n, k;
int slv(int l, int r) {
int rs = sum[r] - sum[l - 1];
priority_queue<int, vector<int>, less<int> > mxq;
priority_queue<int, vector<int>, greater<int> > mnq;
for (int i = 1; i <= l - 1; i++) mxq.push(a[i]);
for (int i = r + 1; i <= n; i++) mxq.push(a[i]);
for (int i = l; i <= r; i++) mnq.push(a[i]);
int kk = k;
while (kk && !mnq.empty() && !mxq.empty()) {
int mx = mxq.top();
mxq.pop();
int mn = mnq.top();
mnq.pop();
if (mn >= mx) break;
rs -= mn;
rs += mx;
kk--;
}
return rs;
}
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
int an = -inf;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int tmp = slv(i, j);
if (tmp > an) an = tmp;
}
}
printf("%d\n", an);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[220];
int sum[220];
inline int min(int a, int b) { return a > b ? b : a; }
inline int max(int a, int b) { return a > b ? a : b; }
struct Min {
int aa;
Min() {}
Min(int x) { aa = x; }
bool operator<(const Min& a) const { return aa > a.aa; }
};
struct Max {
int aa;
Max() {}
Max(int x) { aa = x; }
bool operator<(const Max& a) const { return aa < a.aa; }
};
priority_queue<Min> qmin;
priority_queue<Max> qmax;
int main() {
int n, K;
while (scanf("%d%d", &n, &K) == 2) {
int ans = -0x3f3f3f3f;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sum[0] = 0;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int fuck = sum[j] - sum[i - 1];
ans = max(ans, fuck);
while (!qmin.empty()) qmin.pop();
while (!qmax.empty()) qmax.pop();
for (int k = i; k <= j; k++) {
qmin.push(Min(a[k]));
}
for (int k = 1; k < i; k++) {
qmax.push(Max(a[k]));
}
for (int k = j + 1; k <= n; k++) {
qmax.push(Max(a[k]));
}
for (int k = 1; k <= K; k++) {
int aa = 0, bb = 0;
if ((!qmin.empty()) && (!qmax.empty())) {
aa = qmin.top().aa;
bb = qmax.top().aa;
qmin.pop();
qmax.pop();
fuck += bb - aa;
qmin.push(Min(bb));
qmax.push(Max(aa));
}
ans = max(ans, fuck);
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 100000000;
int a[201], k, n, ans = -inf;
bool cmp(int x, int y) { return x > y; }
int solve(int x, int y) {
vector<int> A, B;
int cur1 = 0, cur2 = 0, sum = 0, cntk = 0;
for (int i = 1; i <= n; i++)
if (i >= x && i <= y)
A.push_back(a[i]);
else
B.push_back(a[i]);
sort(A.begin(), A.end());
sort(B.begin(), B.end(), cmp);
while (cntk < k && cur1 < A.size() && cur2 < B.size()) {
if (A[cur1] < B[cur2]) {
swap(A[cur1], B[cur2]);
cur1++, cur2++;
cntk++;
} else
break;
}
for (int i = 0; i < A.size(); i++) sum += A[i];
return sum;
}
int main() {
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++) ans = max(solve(i, j), ans);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205];
int main() {
int n, k, sum, ans = -10000000, i, j, s1, s2, p;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
for (p = i; p < n; p++) {
vector<int> b, c;
sum = 0;
for (j = 0; j < n; j++) {
if (j >= i && j <= p) {
b.push_back(a[j]);
sum += a[j];
} else
c.push_back(a[j]);
}
sort(b.begin(), b.end());
sort(c.begin(), c.end(), greater<int>());
s1 = s2 = 0;
for (j = 0; j < k && j < b.size() && j < c.size(); j++) {
if (c[j] < b[j]) {
break;
}
s1 += b[j];
s2 += c[j];
}
sum += s2 - s1;
ans = ((ans) > (sum) ? (ans) : (sum));
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 220, INF = 0x3f3f3f3f;
int n, k, a[MAXN], ans = -INF;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1, j, l, cursum = 0; i <= n; ++i, cursum = 0) {
priority_queue<int> q;
for (j = 0; i + j <= n; ++j) {
q.push(-a[i + j]);
cursum += a[i + j];
priority_queue<int> q2;
for (l = i + j + 1; l <= n; ++l) q2.push(a[l]);
for (l = 1; l < i; ++l) q2.push(a[l]);
vector<int> v;
int temp = 0;
for (l = 0; l < k && !q.empty() && !q2.empty(); ++l) {
int x = -q.top(), y = q2.top();
if (x > y) break;
v.push_back(x);
q.pop(), q2.pop(), temp += -x + y;
}
while (!v.empty()) q.push(-v.back()), v.pop_back();
ans = max(ans, cursum + temp);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[205], b[205], c[205], ans = -100000000;
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 j = 1; j + i - 1 <= n; ++j) {
int x = 0, y = 0, z = 0, w = 0;
for (int u = 1; u < j; ++u) b[++x] = a[u];
for (int u = j; u <= j + i - 1; ++u) c[++y] = a[u];
for (int u = j + i; u <= n; ++u) b[++x] = a[u];
sort(b + 1, b + x + 1);
sort(c + 1, c + y + 1);
for (int u = 0; u < i; ++u) {
if (w < k && x && b[x] > c[y]) {
z += b[x--];
++w;
} else
z += c[y--];
}
ans = max(ans, z);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1111];
int main() {
int n, K;
scanf("%d", &n);
scanf("%d", &K);
for (int i = 1; i <= (n); i++) scanf("%d", &a[i]);
int ans = a[1];
for (int i = 1; i <= (n); i++) {
set<pair<int, int> > sl, sr, sp;
for (int j = i; j <= n; j++) sr.insert(make_pair(-a[j], j));
for (int j = 1; j < i; j++) sp.insert(make_pair(-a[j], j));
int ts = 0;
for (int j = i; j <= n; j++) {
sr.erase(make_pair(-a[j], j));
sl.insert(make_pair(a[j], j));
ts += a[j];
int e1 = 0, e2 = 0;
set<pair<int, int> >::iterator pl = sl.begin(), pr = sr.begin(),
pp = sp.begin();
ans = max(ans, ts);
for (int c = 1; c <= K; c++) {
if (pl == sl.end()) break;
if (pr == sr.end() && pp == sp.end()) break;
e1 += (*pl).first;
pl++;
if (pr == sr.end()) {
e2 -= (*pp).first;
pp++;
} else if (pp == sp.end()) {
e2 -= (*pr).first;
pr++;
} else {
int a1 = -(*pp).first;
int a2 = -(*pr).first;
if (a1 > a2) {
e2 -= (*pp).first;
pp++;
} else {
e2 -= (*pr).first;
pr++;
}
}
ans = max(ans, ts - e1 + e2);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 20;
int n, K;
int a[N], ans = -2147483647;
void solve() {
priority_queue<int> big;
priority_queue<int, vector<int>, greater<int> > smal;
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
while (smal.size()) smal.pop();
while (big.size()) big.pop();
int sum = 0;
for (int k = 0; k < n; k++) {
if (l <= k && k <= r) {
smal.push(a[k]);
sum += a[k];
} else
big.push(a[k]);
}
for (int k = 0; k < K; k++) {
if (smal.size() && big.size()) {
int x = big.top();
big.pop();
int y = smal.top();
smal.pop();
if (x > y) sum += x - y;
}
}
ans = max(ans, sum);
}
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
solve();
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:30000000")
using namespace std;
const int Direction[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
const int Nmax = 200100;
int a[Nmax];
int used[Nmax];
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
for (int i = 1; i < (int)(n + 1); ++i) cin >> a[i];
int Answer = -2000000000;
int Color = 0;
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
++Color;
int SUM = 0;
for (int j = l; j <= r; j++) SUM += a[j];
for (int j = 1; j <= k; j++) {
int mn = -1;
for (int p = l; p <= r; p++)
if (used[p] < Color)
if (mn == -1 || a[mn] > a[p]) mn = p;
if (mn == -1) break;
used[mn] = Color;
int mx = -1;
for (int p = 1; p < l; p++)
if (used[p] < Color)
if (mx == -1 || a[mx] < a[p]) mx = p;
for (int p = r + 1; p <= n; p++)
if (used[p] < Color)
if (mx == -1 || a[mx] < a[p]) mx = p;
if (mx == -1) break;
used[mx] = Color;
if (a[mn] >= a[mx]) break;
SUM = SUM - a[mn] + a[mx];
}
Answer = max(Answer, SUM);
}
cout << Answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300], b[300], C[300], m, kk;
int c[300];
int main() {
scanf("%d%d", &m, &kk);
c[0] = 0;
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
int ans = -0x3f3f3f3f;
for (int i = 1; i <= m; i++) {
for (int j = i; j <= m; j++) {
int tb = 0, tc = j - i + 1;
for (int k = 1; k <= m; k++) {
if (k < i || k > j) b[tb++] = a[k];
}
for (int k = i; k <= j; k++) c[k - i] = a[k];
sort(c, c + tc);
sort(b, b + tb);
int ri = tb - 1;
for (int k = 0; k < tc && k < tb && k + 1 <= kk && c[k] < b[ri];
k++, ri--) {
c[k] = b[ri];
}
int tmp = 0;
for (int i = 0; i <= tc - 1; i++) tmp += c[i];
ans = max(ans, tmp);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a > b; }
int a[205], b[205], c[205];
int main() {
int n, k, t, j, i, p1, p2;
while (scanf("%d%d", &n, &k) != EOF) {
int ma = -11100000;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
int num1 = 0;
for (p1 = 1; p1 < i; p1++) {
b[++num1] = a[p1];
}
for (p1 = j + 1; p1 <= n; p1++) b[++num1] = a[p1];
int num2 = 0;
int sum = 0;
for (p1 = i; p1 <= j; p1++) {
c[++num2] = a[p1];
sum += a[p1];
}
sort(b + 1, b + 1 + num1, cmp);
sort(c + 1, c + 1 + num2);
for (p1 = 1; p1 <= k && p1 <= num1 && p1 <= num2; p1++) {
if (b[p1] > c[p1]) sum += b[p1] - c[p1];
}
if (sum > ma) ma = sum;
}
printf("%d\n", ma);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void swap(int &a, int &b) {
int tmp;
tmp = a;
a = b;
b = tmp;
return;
}
int jum[210][210];
int main() {
int n, s;
int a[210];
scanf("%d %d", &n, &s);
for (int k = 0; k < n; k++) {
scanf("%d", &a[k]);
}
int x[210];
int y[210];
int ret = -2000000;
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
int px = 0, py = 0;
for (int i = 0; i < n; i++) {
if (i < l || i > r) {
y[py] = a[i];
py++;
} else {
x[px] = a[i];
px++;
}
}
sort(x, x + px);
sort(y, y + py);
int i = 0, k = 0, c = py - 1;
while (i != px && k != s && c >= 0) {
if (x[i] < y[c]) {
swap(x[i], y[c]);
k++;
i++;
}
c--;
}
int jum = 0;
for (int m = 0; m < px; m++) {
jum += x[m];
}
ret = max(ret, jum);
}
}
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int data[207], n, k, ans = -INT_MAX;
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> data[i];
for (int l = 0; l < n; ++l) {
for (int r = l; r < n; ++r) {
vector<int> in, out;
for (int i = l; i <= r; ++i) in.push_back(data[i]);
for (int j = 0; j < l; ++j) out.push_back(data[j]);
for (int j = r + 1; j < n; ++j) out.push_back(data[j]);
sort(in.begin(), in.end());
sort(out.begin(), out.end());
for (size_t i = 0; i < k && i < in.size() && i < out.size() &&
in[i] < out[out.size() - i - 1];
++i)
swap(in[i], out[out.size() - i - 1]);
int sum = 0;
for (size_t i = 0; i < in.size(); ++i) sum += in[i];
ans = max(ans, sum);
if (ans == 0) cout << l << ' ' << r << '\n';
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int i, a[n];
for (i = 0; i < n; ++i) cin >> a[i];
int j, l, ans = a[0];
for (i = 0; i < n; ++i) {
for (j = i; j < n; ++j) {
vector<int> big, small;
for (l = 0; l < n; ++l) {
if (l >= i && l <= j)
big.push_back(a[l]);
else
small.push_back(a[l]);
}
sort(big.begin(), big.end());
sort(small.rbegin(), small.rend());
int sum = 0;
for (l = 0; l < big.size(); ++l) {
sum += big[l];
}
for (int e = 0; e <= k && e <= big.size() && e <= small.size(); ++e) {
int tmp = sum;
for (l = 0; l < e; ++l) {
tmp -= big[l];
tmp += small[l];
}
ans = max(ans, tmp);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205];
int n, k;
multiset<int> ma, mi;
int tmp[20];
int main() {
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++) {
ma.clear();
for (int i = 0; i < l; i++) {
if (ma.size() < k || *ma.begin() < a[i]) {
if (ma.size() == k) ma.erase(ma.begin());
ma.insert(a[i]);
}
}
for (int i = r + 1; i < n; i++) {
if (ma.size() < k || *ma.begin() < a[i]) {
if (ma.size() == k) ma.erase(ma.begin());
ma.insert(a[i]);
}
}
mi.clear();
int sum = 0;
for (int i = l; i <= r; i++) {
sum += a[i];
if (mi.size() < k || *mi.begin() < -a[i]) {
if (mi.size() == k) mi.erase(mi.begin());
mi.insert(-a[i]);
}
}
multiset<int>::iterator itma = ma.begin(), itmi = mi.begin();
int sz = 0, szmi = mi.size();
for (; itma != ma.end(); ++itma) tmp[sz++] = *itma;
for (; itmi != mi.end(); ++itmi) tmp[sz++] = (-*itmi), sum += *itmi;
sort(tmp, tmp + sz);
for (int i = 0; i < szmi; i++) sum += tmp[sz - 1 - i];
ans = max(ans, sum);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l, r, i, j, a[300], b[300], c[300], swaps, max = -1001;
scanf("%d %d", &n, &swaps);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (l = 0; l < n; l++) {
for (r = l; r < n; r++) {
int sizeb = 0, sizec = 0;
for (i = l; i <= r; i++) {
b[sizeb++] = a[i];
}
for (i = 0; i < l; i++) {
c[sizec++] = a[i];
}
for (i = r + 1; i < n; i++) {
c[sizec++] = a[i];
}
sort(b, b + sizeb);
sort(c, c + sizec);
j = 0;
k = sizec - 1;
int count = 0;
while (b[j] < c[k] && count < swaps && j < n && k >= 0) {
int temp = b[j];
b[j] = c[k];
c[k] = temp;
k--;
j++;
count++;
}
int sumb = 0;
for (i = 0; i < sizeb; i++) {
sumb = sumb + b[i];
}
if (sumb > max) {
max = sumb;
}
}
}
printf("%d\n", max);
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 20, oo = 1e9;
int n, k, ans = -oo, a[N];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = i + 1; j <= n; j++) {
vector<int> u, v;
for (int c = 0; c < n; c++) (i <= c && c < j ? v : u).push_back(a[c]);
if (!u.empty() && !v.empty())
for (int c = 0; c < k; c++) {
int &x = *min_element(v.begin(), v.end()),
&y = *max_element(u.begin(), u.end());
if (x < y)
swap(x, y);
else
break;
}
ans = max(ans, accumulate(v.begin(), v.end(), 0));
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int compare(const void *a, const void *b) {
int *p = (int *)a;
int *q = (int *)b;
return q[0] - p[0];
}
int compare1(const void *a, const void *b) {
int *p = (int *)a;
int *q = (int *)b;
return p[0] - q[0];
}
int main() {
int n, k, i, j, a[202], b[202], c[202], p;
scanf("%d%d", &n, &k);
;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
;
int mx = INT_MIN;
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
int sum = 0, q = 0;
for (p = i; p < j + 1; p++) {
sum += a[p];
c[q++] = a[p];
}
int co = 0, x = 0;
for (p = 0; p < i; p++) b[co++] = a[p];
for (p = j + 1; p < n; p++) b[co++] = a[p];
qsort(b, co, sizeof(int), compare);
qsort(c, q, sizeof(int), compare1);
while (x < k && x < co && x < q && b[x] > c[x]) {
sum += b[x];
sum -= c[x];
x++;
}
mx = max(mx, sum);
}
}
printf("%d\n", mx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a[205];
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int t1[205], t2[205], ans = -999999999;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
int n1 = 0, n2 = 0, tp = 0;
for (int k = 0; k < i; k++) t1[n1++] = a[k];
for (int k = j + 1; k < n; k++) t1[n1++] = a[k];
for (int k = i; k <= j; k++) {
tp += a[k];
t2[n2++] = a[k];
}
ans = max(ans, tp);
if (n2 == 0 || n1 == 0) continue;
sort(t1, t1 + n1);
sort(t2, t2 + n2);
int p1 = n1 - 1, p2 = 0;
for (int k = 1; k <= m; k++) {
if (p1 < 0 || p2 >= n2) break;
if (t1[p1] > t2[p2])
tp += t1[p1] - t2[p2];
else
break;
p1--;
p2++;
}
ans = max(ans, tp);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 1e6 + 100;
const int maxe = 1e6 + 100;
using namespace std;
int a[220], sum[220];
void Solve() {
int n, tt;
scanf("%d%d", &n, &tt);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
int ans = -INF;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
priority_queue<int> maxx, minn;
int tmp = sum[j] - sum[i - 1];
for (int k = i; k <= j; k++) minn.push(-a[k]);
for (int k = 1; k < i; k++) maxx.push(a[k]);
for (int k = j + 1; k <= n; k++) maxx.push(a[k]);
int cnt = 0;
while (cnt < tt && !maxx.empty() && !minn.empty() &&
maxx.top() + minn.top() > 0) {
cnt++;
tmp += maxx.top() + minn.top();
maxx.pop();
minn.pop();
}
ans = max(ans, tmp);
}
}
printf("%d\n", ans);
}
int main() {
int Case = 1, cases;
while (Case--) {
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void out(T A[], int n) {
for (int i = 0; i < n; i++) cout << A[i] << " ";
cout << endl;
}
template <class T>
void out(vector<T> A, int n = -1) {
if (n == -1) n = A.size();
for (int i = 0; i < n; i++) cout << A[i] << " ";
cout << endl;
}
const int MAXN = 99999;
const int MAXM = 9999999;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double EPS = 1e-11;
int n, K;
int a[1005];
int ans;
int solve() {
int i, j, k;
for (i = 0; i < n; ++i)
for (j = i + 1; j <= n; ++j) {
vector<int> ta, tb;
for (k = 0; k < n; ++k)
if (k >= i && k < j)
ta.push_back(a[k]);
else
tb.push_back(a[k]);
sort(ta.begin(), ta.end());
sort(tb.rbegin(), tb.rend());
int sum = 0;
for (k = i; k < j; ++k) sum += a[k];
for (k = 0; k < K; ++k) {
if (ta.size() <= k || tb.size() <= k) break;
if (ta[k] > tb[k]) break;
sum -= ta[k];
sum += tb[k];
}
ans = max(ans, sum);
}
return 0;
}
int main() {
cin >> n >> K;
for (int i = 0; i < n; ++i) cin >> a[i];
ans = -INF;
solve();
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300];
int n;
int calc(int l, int r, int k) {
priority_queue<int> q1, q2;
for (int i = 0; i < l; ++i) {
q2.push(a[i]);
}
for (int i = l; i <= r; ++i) {
q1.push(-a[i]);
}
for (int i = r + 1; i < n; ++i) {
q2.push(a[i]);
}
int tot = 0;
int c = r - l + 1;
for (int i = 0; i < c; ++i) {
if (q2.empty() || k == 0) {
tot += (-q1.top());
q1.pop();
} else {
if ((-q1.top()) >= q2.top()) {
tot += (-q1.top());
q1.pop();
} else {
tot += q2.top();
q2.pop();
q1.pop();
k--;
}
}
}
return tot;
}
int MAIN() {
int k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
int best = -1e9;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
best = max(best, calc(i, j, k));
}
}
printf("%d\n", best);
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
|
#include <bits/stdc++.h>
int main(int argc, char **argv) {
int k, n;
std::cin >> n >> k;
std::vector<int> a(n);
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
}
int best = std::numeric_limits<int>::min();
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
std::vector<int> sec(std::begin(a) + i, std::begin(a) + j + 1);
std::vector<int> res;
for (int k = 0; k < i; ++k) {
res.push_back(a[k]);
}
for (int k = j + 1; k < n; ++k) {
res.push_back(a[k]);
}
std::sort(std::begin(sec), std::end(sec));
std::sort(std::begin(res), std::end(res));
auto in_end =
res.rbegin() + std::min(std::min<size_t>(res.size(), k), sec.size());
auto out = sec.begin();
for (auto in = res.rbegin(); in != in_end && *in > *out; ++in, ++out) {
*out = *in;
}
best = std::max(std::accumulate(std::begin(sec), std::end(sec), 0), best);
std::cout << std::endl;
}
}
std::cout << best << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, aklsjdakljdslkasjkldas;
while (scanf("%d%d", &n, &aklsjdakljdslkasjkldas) != EOF) {
vector<int> alslkjdklajsdklajlkdjalkjdlkasjlkdjaskljdklajdlkas;
int x;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
alslkjdklajsdklajlkdjalkjdlkasjlkdjaskljdklajdlkas.push_back(x);
}
int ausdiaousiduaisoduaioasd = -5000;
for (int i = 0;
i < alslkjdklajsdklajlkdjalkjdlkasjlkdjaskljdklajdlkas.size(); i++) {
for (int j = i;
j < alslkjdklajsdklajlkdjalkjdlkasjlkdjaskljdklajdlkas.size(); j++) {
vector<int> aosdkalkskdlkajlksdjaskldajadklasjlkdas;
vector<int> aisduaioudiasuiodaosid;
for (int k = i; k <= j; k++) {
aosdkalkskdlkajlksdjaskldajadklasjlkdas.push_back(
alslkjdklajsdklajlkdjalkjdlkasjlkdjaskljdklajdlkas[k]);
}
for (int k = 0; k < i; k++) {
aisduaioudiasuiodaosid.push_back(
alslkjdklajsdklajlkdjalkjdlkasjlkdjaskljdklajdlkas[k]);
}
for (int k = j + 1; k < n; k++) {
aisduaioudiasuiodaosid.push_back(
alslkjdklajsdklajlkdjalkjdlkasjlkdjaskljdklajdlkas[k]);
}
int troca = 0;
sort(aosdkalkskdlkajlksdjaskldajadklasjlkdas.begin(),
aosdkalkskdlkajlksdjaskldajadklasjlkdas.end());
sort(aisduaioudiasuiodaosid.begin(), aisduaioudiasuiodaosid.end());
reverse(aisduaioudiasuiodaosid.begin(), aisduaioudiasuiodaosid.end());
for (int k = 0; k < aisduaioudiasuiodaosid.size(); k++) {
if (troca >= aklsjdakljdslkasjkldas) break;
if (aisduaioudiasuiodaosid[k] >
aosdkalkskdlkajlksdjaskldajadklasjlkdas[troca]) {
aosdkalkskdlkajlksdjaskldajadklasjlkdas[troca] =
aisduaioudiasuiodaosid[k];
troca++;
}
}
int sum = 0;
for (int k = 0; k < aosdkalkskdlkajlksdjaskldajadklasjlkdas.size();
k++) {
sum += aosdkalkskdlkajlksdjaskldajadklasjlkdas[k];
}
ausdiaousiduaisoduaioasd = max(ausdiaousiduaisoduaioasd, sum);
}
}
printf("%d\n", ausdiaousiduaisoduaioasd);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205], b[205], c[205], nb, nc;
int main() {
int i, j, m, n, k, st, l, vmin, mini, vmax, maxi, ed, sum, ans = -1005;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
for (st = 1; st <= n - i + 1; st++) {
ed = st + i - 1;
nb = 0;
nc = 0;
for (j = 1; j <= n; j++) {
if (j >= st && j <= ed)
b[++nb] = a[j];
else
c[++nc] = a[j];
}
sort(b + 1, b + nb + 1);
sort(c + 1, c + nc + 1);
sum = 0;
for (l = 1; l <= nb; l++) {
sum += b[l];
}
ans = max(ans, sum);
for (l = 1; l <= k; l++) {
if (l <= nb && nc - l + 1 >= 1) {
if (b[l] < c[nc - l + 1]) {
sum += c[nc - l + 1] - b[l];
ans = max(ans, sum);
} else
break;
} else
break;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Custom {
bool operator()(int a, int b) { return a > b; }
};
int SumVector(vector<int> arr) {
int total = 0;
for (vector<int>::iterator it = arr.begin(); it != arr.end(); it++) {
total += *it;
}
return total;
}
int main() {
int n, j, k, large = -2147483647;
cin >> n >> k;
vector<int> arr;
for (int i = 0; i < n; i++) {
cin >> j;
arr.push_back(j);
}
for (vector<int>::iterator it1 = arr.begin(); it1 != arr.end(); it1++) {
large = max(*it1, large);
for (vector<int>::iterator it2 = it1;; it2++) {
if (it2 == it1) continue;
int sum = 0, cnt;
vector<int> in(it1, it2), out(it2, arr.end());
out.insert(out.end(), arr.begin(), it1);
sort(in.begin(), in.end());
sort(out.begin(), out.end(), Custom());
sum = SumVector(in);
for (cnt = 0; cnt < k && cnt < in.size() && cnt < out.size(); cnt++) {
if (in[cnt] >= out[cnt])
break;
else
sum += (out[cnt] - in[cnt]);
}
large = max(sum, large);
if (it2 == arr.end()) break;
}
}
cout << large << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[201];
const int p = -1000 * 1000 * 1000;
int temp[201];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int totalres = p;
for (int i = 0; i < n; i++) {
int cursum = 0;
for (int j = i; j < n; j++) {
cursum += a[j];
for (int l = 0; l < n; l++) temp[l] = a[l];
int sum = cursum;
for (int st = 0; st < k; st++) {
int *it = min_element(temp + i, temp + j + 1);
int *it1 = i != 0 ? max_element(temp, temp + i) : NULL;
int *it2 = j + 1 != n ? max_element(temp + j + 1, temp + n) : NULL;
if (it1 == NULL)
it1 = it2;
else
it1 = (it2 == NULL ? it1 : (*it1 > *it2 ? it1 : it2));
if (it1 != NULL) {
if (*it1 > *it) {
sum += *it1;
sum -= *it;
swap(*it1, *it);
} else
break;
}
}
totalres = max(totalres, sum);
}
}
cout << totalres;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double E = 1e-7;
const int MOD = 1e9 + 7;
const long long MAX = 1e6 + 1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, k;
cin >> n >> k;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
int ans = INT_MIN;
int a[n], b[n];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
int A = j - i + 1;
int B = n - A;
copy(ar + i, ar + j + 1, a);
copy(ar, ar + i, b);
copy(ar + j + 1, ar + n, b + i);
sort(a, a + A);
sort(b, b + B);
for (int l = 0, r = B - 1, q = k; l < A && r >= 0 && a[l] < b[r] && q;
l++, r--, --q)
swap(a[l], b[r]);
int sum = 0;
for (int i = 0; i < A; i++) sum += a[i];
ans = max(ans, sum);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const int mod = 1e9 + 7;
const long long INF = 4e18 + 5;
int n, k;
int a[202];
int O[202], M[202];
int ans = -inf;
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 l = 1; l <= n; ++l) {
for (int r = l; r <= n; ++r) {
int cur = 0;
int cntm = 0, cnto = 0;
for (int i = 1; i < l; ++i) O[++cnto] = a[i];
for (int i = r + 1; i <= n; ++i) O[++cnto] = a[i];
for (int i = l; i <= r; ++i) {
M[++cntm] = a[i];
cur += a[i];
}
sort(O + 1, O + cnto + 1);
sort(M + 1, M + cntm + 1);
for (int i = 1; i <= cnto; ++i) O[i] += O[i - 1];
for (int i = 1; i <= cntm; ++i) M[i] += M[i - 1];
int lim = min(min(cnto, cntm), k);
for (int d = 0; d <= lim; ++d) {
ans = max(ans, cur - M[d] + O[cnto] - O[cnto - d]);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = 205;
int a[MAXN];
int b[MAXN];
int c[MAXN];
int sz0, sz1;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = -2100000000;
for (int l = 1; l <= n; l++) {
for (int r = l; r <= n; r++) {
sz0 = sz1 = 0;
for (int i = l; i <= r; i++) b[sz0++] = a[i];
for (int i = 1; i < l; i++) c[sz1++] = a[i];
for (int i = r + 1; i <= n; i++) c[sz1++] = a[i];
sort(b, b + sz0);
sort(c, c + sz1);
int p1 = 0, p2 = sz1 - 1;
int cnt = k;
while (p1 < sz0 && p2 >= 0 && cnt) {
if (c[p2] > b[p1])
b[p1] = c[p2];
else
break;
cnt--;
p1++;
p2--;
}
int res = 0;
for (int i = 0; i < sz0; i++) res += b[i];
ans = max(ans, res);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[200];
int inside[200], outside[200];
int main(int argc, char** argv) {
std::ios::sync_with_stdio(false);
cin >> N >> K;
int mx = -100000;
for (int i = 0; i < N; i++) {
cin >> A[i];
mx = max(mx, A[i]);
}
int ans;
if (mx <= 0) {
ans = mx;
} else {
ans = 0;
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
if (i == 2 && j == 7) {
cout << "";
}
int sum = 0;
for (int k = i; k <= j; k++) sum += A[k];
int in = 0, ou = 0;
for (int k = 0; k < N; k++) {
if (i <= k && k <= j)
inside[in++] = A[k];
else
outside[ou++] = A[k];
}
sort(inside, inside + in);
sort(outside, outside + ou, greater<int>());
for (int k = 0; k < min(K, min(in, ou)); k++) {
if (outside[k] <= inside[k]) break;
sum += outside[k] - inside[k];
}
ans = max(ans, sum);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1000][1000];
int a[1000];
int n, k;
int find(int k, int l, int r, const vector<pair<int, int> > &ft) {
vector<int> sb1, sb2;
for (int i = 0; i < n; ++i) {
if (i <= r && i >= l) {
sb1.push_back(a[i]);
} else
sb2.push_back(a[i]);
}
sort(sb1.begin(), sb1.end());
sort(sb2.begin(), sb2.end());
int p1 = 0, p2 = sb2.size() - 1;
for (int i = 0; i < k; ++i) {
if (p1 < sb1.size() && p2 >= 0 && sb1[p1] < sb2[p2]) {
swap(sb1[p1], sb2[p2]);
++p1;
--p2;
} else {
break;
}
}
int ans = 0;
for (int i = 0; i < sb1.size(); ++i) {
ans += sb1[i];
}
return ans;
}
int main() {
scanf("%d%d", &n, &k);
memset(dp, 0, sizeof(dp));
memset(a, 0, sizeof(a));
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;
for (int l = i; l <= j; ++l) {
sum += a[l];
}
dp[i][j] = sum;
}
}
int ans = -10000000;
vector<pair<int, int> > ft;
for (int i = 0; i < n; ++i) ft.push_back(make_pair(a[i], i));
sort(ft.begin(), ft.end());
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
ans = max(ans, find(k, i, j, ft));
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int size, k, result = -1e9, tmp = 0, s1, s2;
cin >> size >> k;
vector<int> array(size);
for (int i = 0; i < size; i++) cin >> array[i];
for (int i = 0; i < size; i++)
for (int j = i; j < size; j++) {
vector<int> tmp1, tmp2;
for (int z = 0; z < size; z++)
if (z >= i && z <= j)
tmp1.push_back(array[z]), tmp += array[z];
else
tmp2.push_back(array[z]);
sort(tmp1.begin(), tmp1.end()),
sort(tmp2.begin(), tmp2.end(), greater<int>()), s1 = tmp1.size(),
s2 = tmp2.size();
for (int z = 0; z < k; z++)
(z < s1 && z < s2)
? ((tmp1[z] < tmp2[z]) ? (tmp -= tmp1[z], tmp += tmp2[z]) : 0)
: 0;
result < tmp ? result = tmp : 0, tmp = 0;
}
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k;
int sum_sub(vector<int> &v, int l, int r) {
int s = 0, i;
for (i = l; i <= r; i++) s += v[i];
return s;
}
int sub_arr(vector<int> v, int l, int r) {
int i, n = v.size();
if (l == 0 && r == n - 1) return sum_sub(v, l, r);
multiset<int> s1, s2;
multiset<int>::iterator a, b;
for (i = l; i <= r; i++) s1.insert(v[i]);
for (i = 0; i < l; i++) s2.insert(v[i]);
for (i = r + 1; i < n; i++) s2.insert(v[i]);
for (i = 0; i < k; i++) {
a = s1.begin();
b = s2.end();
b--;
int A = *a, B = *b;
if (A >= B) break;
s1.erase(a);
s2.erase(b);
s1.insert(B);
s2.insert(A);
}
int ans = 0;
for (a = s1.begin(); a != s1.end(); a++) ans += *a;
return ans;
}
int main() {
int i, n, ans = -1000000000, j;
cin >> n >> k;
vector<int> v(n);
for (i = 0; i < n; i++) cin >> v[i];
for (i = 0; i < n; i++)
for (j = i; j < n; j++) ans = max(ans, sub_arr(v, i, j));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t, a[250], p[250], q[250], x, y, v = -1000000000, s;
inline int minest(int a, int b, int c) {
if (a <= b && a <= c) return a;
if (b <= a && b <= c) return b;
return c;
}
int main() {
scanf("%d %d", &n, &m);
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++) {
x = y = s = 0;
for (int k = 1; k <= n; k++)
if (k >= i && k <= j)
x++, p[x] = a[k];
else
y++, q[y] = a[k];
sort(q + 1, q + y + 1);
sort(p + 1, p + x + 1);
t = minest(x, y, m);
for (int k = t + 1; k <= x; k++) s += p[k];
x = t;
for (int k = y; k >= y - t + 1; k--) x++, p[x] = q[k];
sort(p + 1, p + x + 1);
for (int k = 0; k < t; k++) s += p[x - k];
if (s > v) v = s;
}
cout << v << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ret;
int a[205], A[205], B[205];
int main() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); i++) scanf("%d", &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)
A[x++] = a[k], S += a[k];
else
B[y++] = a[k];
}
sort(A, A + 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] < A[k]) break;
S += B[k] - A[k];
}
ret = max(ret, S);
}
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h, x, y, s, t, a[512], b[512], c[512];
int main() {
scanf("%d%d", &n, &m);
s = -100000000;
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
a[n + i] = a[i];
}
for (int l = 0; l < n; ++l)
for (int r = l + 1; r <= n; ++r) {
t = accumulate(a + l, a + r, 0);
if (s < t) s = t;
memmove(b + l, a + l, sizeof(int) * (r - l));
memmove(c + r, a + r, sizeof(int) * (n + l - r));
h = min(m, min(r - l, n + l - r));
for (int i = 0; i < h; ++i) {
nth_element(b + l, b + l + i, b + r, less<int>());
nth_element(c + r, c + r + i, c + n + l, greater<int>());
x = b[l + i];
y = c[r + i];
if (x < y)
s = max(s, t += y - x);
else
break;
}
}
printf("%d", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[300];
multiset<int, greater<int> > s;
multiset<int> sfront[300], sback[300], sbig;
multiset<int>::iterator it;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (int i = 1; i <= n; i++) {
sfront[i] = sfront[i - 1];
sfront[i].insert(a[i]);
if ((int)sfront[i].size() > k) sfront[i].erase(sfront[i].begin());
}
for (int i = n; i >= 1; i--) {
sback[i] = sback[i + 1];
sback[i].insert(a[i]);
if ((int)sback[i].size() > k) sback[i].erase(sback[i].begin());
}
int ans = -(0x3f3f3f3f) * 2;
for (int i = 1; i <= n; i++) {
int sum = 0;
s.clear();
for (int j = i; j <= n; j++) {
sum += a[j];
s.insert(a[j]);
if ((int)s.size() > k) s.erase(s.begin());
int num = (int)s.size();
int sum1 = 0;
sbig.clear();
for (it = s.begin(); it != s.end(); it++) {
sum1 += *it;
sbig.insert(*it);
}
for (it = sfront[i - 1].begin(); it != sfront[i - 1].end(); it++) {
sbig.insert(*it);
if ((int)sbig.size() > num) sbig.erase(sbig.begin());
}
for (it = sback[j + 1].begin(); it != sback[j + 1].end(); it++) {
sbig.insert(*it);
if ((int)sbig.size() > num) sbig.erase(sbig.begin());
}
int sum2 = 0;
for (it = sbig.begin(); it != sbig.end(); it++) {
sum2 += *it;
}
int anst = sum - sum1 + sum2;
ans = max(ans, anst);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[205];
int b[205], c[205];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ma = -200005;
for (int i = 0; i < n; i++) {
for (int r = i; r < n; r++) {
int bn = 0, cn = 0;
for (int t = 0; t < n; t++) {
if (t >= i && t <= r)
b[bn++] = a[t];
else
c[cn++] = a[t];
}
sort(b, b + bn);
sort(c, c + cn);
int f = 0, p = cn - 1;
for (int t = 0; t < bn && f < k && p >= 0; t++, p--) {
if (b[t] >= c[p]) break;
swap(b[t], c[p]);
f++;
}
int tot = 0;
for (int t = 0; t < bn; t++) tot += b[t];
ma = max(ma, tot);
}
}
cout << ma << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const string LN = "\n";
const double eps = 1e-9;
const double pi = acos(-1.0);
const int INF = (int)2e9 + 7;
const long long LINF = (long long)9e18 + 7;
const long long P = 353251;
const long long P1 = 239017;
const long long P2 = 239017;
const long long MOD = 1e9 + 7;
const long long MOD2 = 1e9 + 9;
int n, k;
int a[207];
int ans = -INF;
multiset<int> se, all;
int get(multiset<int> a, multiset<int> b) {
int was = 0;
while (1) {
if (was == k) break;
was++;
if (a.size() > 0 && b.size() > 0 && *a.begin() < *(--b.end())) {
a.erase(a.begin());
a.insert(*(--b.end()));
b.erase(--b.end());
} else
break;
}
int sum = 0;
for (auto t : a) sum += t;
return sum;
}
const bool is_testing = 0;
int main() {
srand('D' + 'E' + 'N' + 'I' + 'S' + 'S' + 'O' + 'N');
ios_base::sync_with_stdio(0);
if (is_testing) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
} else {
}
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
all.insert(a[i]);
}
for (int l = 0; l < n; l++) {
se = all;
multiset<int> now;
for (int r = l; r < n; r++) {
now.insert(a[r]);
se.erase(se.find(a[r]));
ans = max(ans, get(now, se));
}
}
cout << ans;
if (is_testing) {
cout << LN << 1.0 * clock() / CLOCKS_PER_SEC << LN;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, a[333], res = -10000000, rr;
vector<int> v1, v2;
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
v1.clear();
v2.clear();
for (int k = 1; k <= n; k++) {
if (k >= i && k <= j)
v1.push_back(a[k]);
else
v2.push_back(a[k]);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
rr = 0;
for (int k = 0; k < v1.size(); k++) {
if (k < q && k < v2.size())
rr += max(v1[k], v2[v2.size() - 1 - k]);
else
rr += v1[k];
}
res = max(res, rr);
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void initrand() {
long long seed;
asm("rdtsc" : "=A"(seed));
srand(seed);
}
const int maxn = 250;
int n, k, ans = numeric_limits<int>::min(), data[maxn];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &data[i]);
for (int i = 0; i < n; ++i)
for (int j = i; j < n; ++j) {
int sum = 0;
vector<int> top, worst;
for (int z = 0; z < n; ++z)
if (i <= z && z <= j) {
sum += data[z];
worst.push_back(data[z]);
if ((int)worst.size() > k)
worst.erase(max_element(worst.begin(), worst.end()));
} else {
top.push_back(data[z]);
if ((int)top.size() > k)
top.erase(min_element(top.begin(), top.end()));
}
sort(worst.begin(), worst.end());
sort(top.begin(), top.end(), greater<int>());
for (size_t i = 0; i < min(worst.size(), top.size()); ++i)
if (worst[i] < top[i]) sum += top[i] - worst[i];
ans = max(ans, sum);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int sum[200][200];
int a[200];
int ind[200];
void QSort(int l, int r) {
int x = l, y = r, m = a[(l + r) / 2];
while (x <= y) {
while (a[x] < m) x++;
while (a[y] > m) y--;
if (x <= y) {
int tmp = a[x];
a[x] = a[y];
a[y] = tmp;
tmp = ind[x];
ind[x] = ind[y];
ind[y] = tmp;
x++;
y--;
}
}
if (x < r) QSort(x, r);
if (l < y) QSort(l, y);
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
ind[i] = i;
}
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
for (int t = l; t <= r; t++) sum[l][r] += a[t];
}
}
QSort(0, n - 1);
int ans = a[0];
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int tmpAns = sum[i][j];
int left = k;
int x = n - 1, y = 0;
while (left > 0) {
while (x >= 0 && (ind[x] >= i && ind[x] <= j)) x--;
while (y < n && (ind[y] < i || ind[y] > j)) y++;
if (x < y) break;
tmpAns += a[x] - a[y];
x--;
y++;
left--;
}
ans = ((tmpAns) > (ans) ? (tmpAns) : (ans));
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205], b[205], c[205];
int nb, nc;
int main() {
int i, j, k, n, m, ans, sum;
while (scanf("%d %d", &n, &m) != EOF) {
ans = -(1 << 30);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
sum = nb = nc = 0;
for (k = i; k <= j; k++) {
b[++nb] = a[k];
sum += a[k];
}
sort(b + 1, b + nb + 1);
for (k = 1; k < i; k++) c[++nc] = a[k];
for (k = j + 1; k <= n; k++) c[++nc] = a[k];
sort(c + 1, c + nc + 1);
reverse(c + 1, c + nc + 1);
for (k = 1; k <= m && k <= nb && k <= nc; k++) {
if (b[k] >= c[k]) break;
sum = sum - b[k] + c[k];
}
ans = max(ans, sum);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
struct node {
int x, i;
};
node a[205];
bool comp(node a, node b) { return (a.x < b.x); }
int main() {
int res = INT_MAX;
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i].x;
a[i].i = i;
}
sort(a + 1, a + n + 1, comp);
int mx = INT_MIN;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int total = j - i + 1, q = k, ans = 0, key = 1;
for (int c = n; c >= 1; c--) {
if (total == 0) break;
if (a[c].i >= i && a[c].i <= j)
ans += a[c].x, total--;
else if (q)
ans += a[c].x, q--, total--;
}
mx = max(ans, mx);
}
}
cout << mx;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[205];
int n, m;
int has[205], other[205], hsize, osize, sum;
int main() {
while (cin >> n >> m) {
for (int i = 0; i < n; i++) {
cin >> cnt[i];
}
int ans = -1005;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
hsize = osize = sum = 0;
for (int k = 0; k < n; k++) {
if (k >= i && k <= j) {
has[hsize++] = cnt[k];
sum += cnt[k];
} else {
other[osize++] = cnt[k];
}
}
sort(has, has + hsize);
sort(other, other + osize);
int fit = 0;
for (int k = 0; k < min(m, hsize); k++) {
if (osize - k - 1 >= 0 && other[osize - k - 1] - has[k] >= 0) {
fit += other[osize - k - 1] - has[k];
}
}
ans = max(ans, fit + sum);
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[222], k, n;
int process(int l, int r) {
int sum = 0, sz = r - l + 1, popped = 0;
priority_queue<int> in, out;
for (int i = 1; i <= n; i++)
if (l <= i && i <= r)
in.push(a[i]);
else
out.push(a[i]);
for (int i = 0; i < sz - k; i++) {
sum += in.top();
in.pop();
popped++;
}
while (!in.empty()) {
out.push(in.top());
in.pop();
}
for (int i = 0; i < sz - popped; i++) {
sum += out.top();
out.pop();
}
return sum;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int ans = -987654321;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
ans = max(ans, process(i, j));
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 209;
int tab[N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < (n); ++i) scanf("%d", &tab[i]);
int best = -10000;
for (int i = 0; i < (n); ++i)
for (int j = i; j < n; j++) {
set<pair<int, int> > top, down;
int sum = 0;
for (int z = 0; z < (n); ++z) {
if (z < i || z > j)
top.insert(make_pair(tab[z], z));
else {
down.insert(make_pair(tab[z], z));
sum += tab[z];
}
}
int repeat = min((int)min(top.size(), down.size()), k);
for (int z = 0; z < (repeat); ++z) {
pair<int, int> t = *top.rbegin(), d = *down.begin();
if (t.first > d.first) {
sum += t.first - d.first;
top.erase(t);
down.erase(d);
} else
break;
}
best = max(best, sum);
}
printf("%d\n", best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[210], now[210], now2[210];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = -1000000000;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
int cnt = 0, cnt2 = 0;
for (int p = i; p <= j; p++) now[++cnt] = a[p];
for (int p = 1; p < i; p++) now2[++cnt2] = a[p];
for (int p = j + 1; p <= n; p++) now2[++cnt2] = a[p];
sort(now + 1, now + cnt + 1);
sort(now2 + 1, now2 + cnt2 + 1);
int tmp = 0;
for (int p = i; p <= j; p++) tmp += a[p];
ans = max(ans, tmp);
for (int l = 1; l <= j - i + 1; l++) {
if (l > k) break;
if (l > cnt2) break;
tmp += now2[cnt2 + 1 - l] - now[l];
ans = max(ans, tmp);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<int> b(n);
for (auto &c : b) {
scanf("%d", &c);
}
int ans = -1e9;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
multiset<int> f;
for (int a = 0; a < i; a++) {
f.insert(b[a]);
}
for (int a = j + 1; a < n; a++) {
f.insert(b[a]);
}
multiset<int> s;
int sum = 0;
for (int k = i; k <= j; k++) {
sum += b[k];
s.insert(b[k]);
}
int cur = k;
while (1) {
if (cur == 0 || s.size() == 0 || f.size() == 0 ||
*f.rbegin() < *s.begin()) {
break;
}
int x = *s.begin();
int t = *f.rbegin();
sum -= x;
sum += t;
s.erase(s.find(x));
s.insert(t);
f.erase(f.find(t));
f.insert(x);
cur--;
}
ans = max(ans, sum);
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205];
int dp[205][205];
int N, K;
int main() {
int i, j, k, m, t, sum, s;
int x1[205], x2[205], f1, f2;
scanf("%d%d", &N, &K);
for (i = 1; i <= N; i++) scanf("%d", &a[i]);
for (i = 1; i <= N; i++) {
dp[i][i - 1] = 0;
for (j = i; j <= N; j++) dp[i][j] = dp[i][j - 1] + a[j];
}
sum = -1000000;
for (i = 1; i <= N; i++) {
for (j = i; j <= N; j++) {
f1 = 0;
f2 = 0;
for (k = 1; k <= N; k++) {
if (k >= i && k <= j)
x1[f1++] = a[k];
else
x2[f2++] = a[k];
}
sort(x1, x1 + f1);
sort(x2, x2 + f2);
k = K;
int t1 = 0, t2 = f2 - 1;
s = dp[i][j];
if (s > sum) sum = s;
while (k-- && t1 < f1 && t2 >= 0) {
s = s - x1[t1] + x2[t2];
t1++;
t2--;
if (s > sum) sum = s;
}
}
}
printf("%d\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int IT_MAX = 524288;
const int MOD = 1000000007;
const int INF = 1234567891;
const long long LL_INF = 1234567890123456789ll;
int in[205];
int sum[205];
vector<int> V1;
vector<int> V2;
int main() {
int N, K, i, j, k;
scanf("%d %d", &N, &K);
for (i = 1; i <= N; i++) {
scanf("%d", &in[i]);
sum[i] = sum[i - 1] + in[i];
}
int ans = -INF;
for (i = 1; i <= N; i++) {
for (j = i; j <= N; j++) {
int t = sum[j] - sum[i - 1];
for (k = 1; k <= N; k++) {
if (k >= i && k <= j)
V1.push_back(in[k]);
else
V2.push_back(in[k]);
}
sort(V1.begin(), V1.end());
sort(V2.begin(), V2.end());
int p1 = 0, p2 = V2.size() - 1;
for (k = 1; k <= K && p1 < V1.size() && p2 >= 0 && V1[p1] < V2[p2];
k++, p1++, p2--)
t += V2[p2] - V1[p1];
ans = max(ans, t);
V1.clear();
V2.clear();
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:336777216")
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using ui = unsigned int;
ull const mod = 1e9 + 7;
auto mt = mt19937(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n, k;
cin >> n >> k;
vector<int> v(n + 1);
for (int i = 1; i <= n; i++) cin >> v[i];
int ans = -1e9;
for (int s = 1; s <= n; s++) {
for (int e = s; e <= n; e++) {
int sum = 0;
priority_queue<int> outer;
priority_queue<int, vector<int>, greater<int>> inner;
for (int i = 1; i < s; i++) outer.push(v[i]);
for (int i = s; i <= e; i++) inner.push(v[i]), sum += v[i];
for (int i = e + 1; i <= n; i++) outer.push(v[i]);
int times = k;
while (times-- && outer.size() && inner.size()) {
if (outer.top() < inner.top()) break;
sum += outer.top() - inner.top();
outer.pop();
inner.pop();
}
ans = max(ans, sum);
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const double Pi = acos(-1.0);
const int INF = 1000000000;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = (0); i < (n); ++i) {
cin >> a[i];
}
int res = -INF;
for (int l = (0); l < (n); ++l)
for (int r = (l); r < (n); ++r) {
vector<int> b;
vector<int> c;
int sum = 0;
for (int i = (0); i < (n); ++i) {
if (i >= l && i <= r) {
b.push_back(a[i]);
sum += a[i];
} else {
c.push_back(a[i]);
}
}
sort(b.begin(), b.end());
sort(c.begin(), c.end(), greater<int>());
for (int i = (0); i < (min(k, (int)min(b.size(), c.size()))); ++i) {
if (b[i] < c[i]) {
sum += c[i] - b[i];
}
}
res = max(res, sum);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nums[205];
int cpy[205];
int findmin(int l, int r) {
int i, ind = l;
for (i = l + 1; i <= r; i++) {
if (cpy[i] < cpy[ind]) {
ind = i;
}
}
return ind;
}
int findmax(int l, int r) {
int i, ind = l;
for (i = l + 1; i <= r; i++) {
if (cpy[i] > cpy[ind]) {
ind = i;
}
}
return ind;
}
int main() {
int N, K, i, j, k, st, end, tmp, Ans, a, b, c, d;
scanf("%d%d", &N, &K);
for (i = 1; i <= N; i++) scanf("%d", &nums[i]);
int neg = 0;
for (i = 1; i <= N; i++)
if (nums[i] < 0) neg++;
if (neg == N) {
int Ans = nums[1];
for (i = 2; i <= N; i++) Ans = max(Ans, nums[i]);
printf("%d\n", Ans);
return 0;
}
if (neg <= K) {
int Ans = 0;
for (i = 1; i <= N; i++)
if (nums[i] > 0) Ans += nums[i];
printf("%d\n", Ans);
return 0;
}
Ans = 0;
for (st = 1; st <= N; st++) {
for (end = st; end <= N; end++) {
for (i = 1; i <= N; i++) cpy[i] = nums[i];
for (i = 0; i < K; i++) {
a = findmin(st, end);
if (st > 1)
b = findmax(1, st - 1);
else
b = -1;
if (end < N)
c = findmax(end + 1, N);
else
c = -1;
if (b == -1 && c == -1)
continue;
else if (b != -1 && c != -1) {
if (cpy[b] > cpy[c])
d = b;
else
d = c;
} else if (b == -1 && c != -1)
d = c;
else if (c == -1 && b != -1)
d = b;
if (cpy[a] < cpy[d])
swap(cpy[a], cpy[d]);
else
break;
}
tmp = 0;
for (i = st; i <= end; i++) tmp += cpy[i];
Ans = max(Ans, tmp);
}
}
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 205;
const int inf = 1 << 30;
int a[maxn], n, k;
int dp[maxn][5][15][15];
void init_dp() {
for (int i = 0; i < maxn; i++) {
for (int j = 0; j < 5; j++) {
for (int x = 0; x < 15; x++) {
for (int y = 0; y < 15; y++) {
dp[i][j][x][y] = -1;
}
}
}
}
}
int dfs(int i, int state = 0, int holes = 0, int filled = 0) {
if (i > n) {
if (holes == filled && state > 0) return 0;
return -inf;
}
if (dp[i][state][holes][filled] != -1) return dp[i][state][holes][filled];
int res = -inf;
if (state == 0) {
res =
max(dfs(i + 1, 1, holes, filled) + a[i], dfs(i + 1, 0, holes, filled));
res = max(res, dfs(i + 1, 1, holes + 1, filled));
if (filled < k) res = max(res, a[i] + dfs(i + 1, 0, holes, filled + 1));
} else if (state == 1) {
res = max(res, a[i] + dfs(i + 1, state, holes, filled));
if (holes < k) res = max(res, dfs(i + 1, state, holes + 1, filled));
res = max(res, dfs(i, 2, holes, filled));
} else if (state == 2) {
res = max(res, dfs(i + 1, state, holes, filled));
if (filled < k) res = max(res, a[i] + dfs(i + 1, state, holes, filled + 1));
}
return dp[i][state][holes][filled] = res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
init_dp();
int ans = dfs(1);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = (int)1e6 + 123;
const double eps = 1e-6;
const int inf = (int)1e9 + 123;
using namespace std;
int n, k, a[300], first[300], sz_f, second[300], sz_s, ans = -inf, cur;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
cur = sz_f = sz_s = 0;
for (int g = 1; g <= n; g++) {
if (g >= l && g <= r)
first[sz_f++] = a[g];
else
second[sz_s++] = a[g];
}
sort(first, first + sz_f);
sort(second, second + sz_s);
for (int i = 0, j = sz_s - 1, g = 1; i < sz_f && j >= 0 && g <= k;
i++, j--, g++)
if (first[i] < second[j]) swap(first[i], second[j]);
for (int i = 0; i < sz_f; i++) cur += first[i];
ans = max(ans, cur);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[210];
pair<int, int> s[210];
int n, k, tsum, o, sum[210];
int ans;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
s[i].first = a[i].first;
s[i].second = a[i].second;
sum[i] = a[i].first;
if (i) sum[i] += sum[i - 1];
}
sort(s, s + n);
int t, p, h, other, left;
reverse(s, s + n);
ans = sum[n - 1];
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
tsum = sum[j];
if (i) tsum -= sum[i - 1];
o = j - i + 1;
left = j - i + 1;
t = p = 0;
other = 0;
for (int l = 0; l < n; l++) {
if (s[l].second >= i && s[l].second <= j)
t++;
else {
if (t == o) break;
if (other >= o - t || other >= k) break;
other++;
tsum += s[l].first;
}
}
for (int l = n - 1; l >= 0; l--) {
if (!other) break;
if (s[l].second >= i && s[l].second <= j) {
other--;
tsum -= s[l].first;
}
}
ans = max(ans, tsum);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 10000000;
long long int a[200 + 50], n, k, ans = -INF;
vector<int> v1, v2;
int main() {
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++) {
v1.clear();
v2.clear();
long long int sum = 0;
for (int k = i; k <= j; k++) {
v1.push_back(a[k]);
sum += a[k];
}
for (int k = 0; k < i; k++) {
v2.push_back(a[k]);
}
for (int k = j + 1; k < n; k++) {
v2.push_back(a[k]);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
reverse(v2.begin(), v2.end());
int t = 0, r = 0, l = 0;
while (r < v2.size() and t < k) {
if (l == v1.size()) {
ans = max(ans, sum);
break;
}
if (v1[l] < v2[r]) {
sum -= v1[l];
sum += v2[r];
t++;
r++;
l++;
} else {
r++;
}
}
ans = max(ans, sum);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, f[300], k = -1, m[300][20], n[300][20];
long long mx = -9999999;
int main() {
for (int i = 0; i <= 250; i++) {
for (int q = 0; q <= 15; q++) {
m[i][q] = -2000;
n[i][q] = -2000;
}
}
scanf("%d %d", &a, &k);
for (int i = 1; i <= a; i++) {
scanf("%d", &f[i]);
for (int q = k; q >= 1; q--) m[i][q] = m[i - 1][q];
for (int q = k; q >= 1; q--) {
if (f[i] > m[i][q]) {
for (int w = 1; w <= q - 1; w++) m[i][w] = m[i][w + 1];
m[i][q] = f[i];
break;
}
}
}
for (int i = a; i >= 1; i--) {
for (int q = k; q >= 1; q--) n[i][q] = n[i + 1][q];
for (int q = k; q >= 1; q--) {
if (f[i] > n[i][q]) {
for (int w = 1; w <= q - 1; w++) n[i][w] = n[i][w + 1];
n[i][q] = f[i];
break;
}
}
}
int Q[500] = {0};
for (int i = 1; i <= a; i++) {
int V[20], SS = 0, LL = 0;
for (int q = 0; q <= k + 5; q++) V[q] = 2000;
for (int q = i; q <= a; q++) {
LL += f[q];
SS = LL;
for (int w = k; w >= 1; w--) {
if (f[q] < V[w]) {
for (int e = 1; e <= w - 1; e++) V[e] = V[e + 1];
V[w] = f[q];
break;
}
}
int urt = 0;
for (int w = k; w >= 1; w--) {
if (m[i - 1][w] != -2000) {
Q[urt] = m[i - 1][w];
urt++;
}
if (n[q + 1][w] != -2000) {
Q[urt] = n[q + 1][w];
urt++;
}
}
sort(Q, Q + urt);
urt--;
for (int w = k; w >= 1; w--) {
if (urt < 0 || V[w] == 2000) break;
if (V[w] <= Q[urt]) {
SS = SS - V[w] + Q[urt];
urt--;
}
}
if (SS > mx) mx = SS;
if (LL > mx) mx = SS;
}
}
printf("%lld", mx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200 + 20;
int a[maxn];
int sum[maxn];
bool vis[maxn];
int n, k;
const int INF = 0X3F3F3F3F;
int cal(int l, int r) {
priority_queue<int, vector<int>, greater<int> > q;
int ret = 0;
memset(vis, false, sizeof(vis));
for (int i = l; i <= r; i++) {
ret += a[i];
q.push(a[i]);
}
int ktmp = k;
while (ktmp > 0) {
int maxt = -INF;
int maxv;
for (int i = 1; i <= n; i++) {
if ((i >= l && i <= r) || vis[i]) continue;
if (a[i] > maxt) {
maxt = a[i];
maxv = i;
}
}
if (maxt > q.top()) {
ret = ret - q.top() + maxt;
vis[maxv] = true;
q.pop();
q.push(maxt);
}
ktmp--;
}
return ret;
}
int main() {
while (~scanf("%d%d", &n, &k)) {
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
int ans = -INF;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int tmp = cal(i, j);
if (tmp > ans) ans = tmp;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, minn, maxx, num1, num2, ans, sum, t, a[201], now[201];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
ans = -1e9;
for (int l = 1; l <= n; l++) {
for (int r = l; r <= n; r++) {
for (int i = 1; i <= n; i++) now[i] = a[i];
for (int i = 1; i <= k; i++) {
minn = 1e9;
maxx = -1e9;
num1 = 0;
num2 = 0;
for (int j = 1; j < l; j++)
if (maxx < now[j]) {
maxx = now[j];
num1 = j;
}
for (int j = r + 1; j <= n; j++)
if (maxx < now[j]) {
maxx = now[j];
num1 = j;
}
for (int j = l; j <= r; j++)
if (minn > now[j]) {
minn = now[j];
num2 = j;
}
if (minn < maxx)
t = now[num1], now[num1] = now[num2], now[num2] = t;
else
break;
}
sum = 0;
for (int i = l; i <= r; i++) sum += now[i];
ans = max(ans, sum);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[210];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int ans = INT_MIN;
for (int l = 0; l < n; l++)
for (int r = l; r < n; r++) {
vector<int> b;
for (int j = l; j <= r; j++) b.push_back(a[j]);
sort(b.begin(), b.end());
vector<int> c;
for (int j = 0; j < l; j++) c.push_back(a[j]);
for (int j = r + 1; j < n; j++) c.push_back(a[j]);
sort(c.begin(), c.end(), greater<int>());
int t = min(min(b.size(), c.size()), (size_t)k);
for (int j = 0; j < t; j++)
if (c[j] > b[j])
b[j] = c[j];
else
break;
ans = max(ans, accumulate(b.begin(), b.end(), 0));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 300;
int n, k;
int s[MAX];
int curr[MAX], out[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> s[i];
long long sol = -(1LL << 60);
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int it = 0;
int oit = 0;
long long sum = 0;
multiset<long long> S;
for (int l = i; l <= j; l++) S.insert(s[l]), sum += s[l];
for (int l = 0; l < i; l++) out[oit++] = s[l];
for (int l = j + 1; l < n; l++) out[oit++] = s[l];
sort(out, out + oit);
sol = max(sol, sum);
for (int l = oit - 1, cnt = 0; cnt < k && l >= 0; l--, cnt++) {
if (out[l] > (*S.begin())) {
sum -= (*S.begin()), sum += out[l];
S.erase(S.begin());
S.insert(out[l]);
}
sol = max(sol, sum);
}
}
}
cout << sol << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct _ {
ios_base::Init i;
_() {
cout.sync_with_stdio(0);
cout.tie(0);
cin.sync_with_stdio(0);
cin.tie(0);
}
} _;
int slr[205][205];
int ma(vector<int> &a) {
int ma = -100000000;
for (int i = 0; i < int((a).size()); i++) {
slr[i][i] = a[i];
for (int j = i + 1; j < int((a).size()); j++) {
slr[i][j] = slr[i][j - 1] + a[j];
ma = max(ma, slr[i][j]);
}
}
return ma;
}
int solve1(int n, int k, vector<int> &a) {
int ans = -100000000;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int cur = 0;
priority_queue<int> in, out;
for (int q = 0; q < n; q++) {
if (q < i || q > j) {
out.push(a[q]);
} else {
cur += a[q];
in.push(-a[q]);
}
}
int t = min(k, min(int((in).size()), int((out).size())));
while (t) {
cur = cur + in.top();
in.pop();
cur = cur + out.top();
out.pop();
ans = max(ans, cur);
t--;
}
ans = max(ans, cur);
}
}
return ans;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cout << solve1(n, k, a) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<long long, long long> > s;
set<pair<long long, long long> > temp, temp2;
set<pair<long long, long long> >::iterator it1, it2;
int main() {
long long N, K;
scanf("%lld%lld", &N, &K);
long long i, j;
long long arr[N + 5];
long long prefix[N + 5];
prefix[0] = 0;
for (i = 1; i <= N; i++) {
scanf("%lld", &arr[i]);
prefix[i] = prefix[i - 1] + arr[i];
s.insert(make_pair(arr[i], i));
}
long long ans = -1e18;
for (i = 1; i <= N; i++) {
temp = s;
temp2.clear();
long long sum = 0;
long long k;
for (j = i; j <= N; j++) {
temp2.insert(make_pair(arr[j], j));
temp.erase(make_pair(arr[j], j));
sum = prefix[j] - prefix[i - 1];
ans = max(ans, sum);
it2 = temp2.begin();
k = 0;
if (temp.size() > 0) {
it1 = temp.end();
it1--;
while (k < min(j - i + 1, K) && k < min(temp.size(), temp2.size())) {
sum -= (*it2).first;
sum += (*it1).first;
it2++;
it1--;
k++;
ans = max(ans, sum);
}
}
}
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, mx, a[205], top, tk;
vector<int> v1, v2;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
mx = a[1];
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
v1.clear();
v2.clear();
top = tk = 0;
for (int i = 1; i <= n; i++)
if (i >= l and i <= r) {
v1.push_back(a[i]);
top += a[i];
} else
v2.push_back(a[i]);
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end(), greater<int>());
for (int i = 0; i <= (int)(min(v1.size(), v2.size())) - 1; i++) {
if (v1[i] >= v2[i] or tk == k) break;
top -= v1[i];
top += v2[i];
tk++;
}
mx = max(mx, top);
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const double eps = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
int maxsum = -inf;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
multiset<int, greater<int> > msin, msout;
for (int t = 0; t < n; ++t) {
if (i <= t and j >= t)
msin.insert(v[t]);
else
msout.insert(v[t]);
}
int size = j - i + 1;
int swaps = 0;
int sum = 0;
while (size--) {
if (msout.empty() or swaps == k) {
sum += *msin.begin();
msin.erase(msin.begin());
} else {
int in = *msin.begin();
int out = *msout.begin();
if (in >= out) {
sum += in;
msin.erase(msin.begin());
} else {
sum += out;
msout.erase(msout.begin());
++swaps;
}
}
}
maxsum = max(maxsum, sum);
}
}
cout << maxsum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s, t;
int a[205];
struct node1 {
int x;
bool operator<(const node1& rhs) const { return x < rhs.x; }
};
struct node2 {
int x;
bool operator<(const node2& rhs) const { return x > rhs.x; }
};
int main() {
priority_queue<node1> q;
priority_queue<node2> p;
cin >> n >> m;
int ans = -100000000;
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++) {
s = 0;
while (!p.empty()) p.pop();
while (!q.empty()) q.pop();
for (int z = i; z <= j; z++) s += a[z], p.push(node2{a[z]});
int k;
for (k = 0; k < i; k++) {
q.push(node1{a[k]});
}
for (k = j + 1; k < n; k++) {
q.push(node1{a[k]});
}
for (int z = 0; z < m; z++) {
if (q.empty()) break;
if (p.empty()) break;
node1 xx = q.top();
node2 yy = p.top();
q.pop();
p.pop();
if (xx.x > yy.x)
s = s + xx.x - yy.x;
else
break;
}
ans = max(ans, s);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[222];
void readInput() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
}
int l[222][11];
int r[222][11];
void solve() {
for (int i = 0; i <= n; i++) {
l[i][0] = 0;
for (int j = 1; j <= k; j++) {
l[i][j] = -1000000000;
if (i > 0) l[i][j] = max(l[i - 1][j], l[i - 1][j - 1] + a[i]);
}
}
for (int i = n + 1; i >= 1; i--) {
r[i][0] = 0;
for (int j = 1; j <= k; j++) {
r[i][j] = -1000000000;
if (i <= n) r[i][j] = max(r[i + 1][j], r[i + 1][j - 1] + a[i]);
}
}
}
int f[222][11][11];
int ans;
void opt() {
ans = a[1];
for (int i = 0; i <= n; i++)
for (int j1 = 0; j1 <= k; j1++)
for (int j2 = 0; j2 <= k; j2++) f[i][j1][j2] = -1000000000;
f[0][0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j1 = 0; j1 <= k; j1++)
for (int j2 = 0; j2 <= k; j2++) {
f[i][j1][j2] = a[i] + f[i - 1][j1][j2];
if (j1 == 0) f[i][j1][j2] = max(f[i][j1][j2], a[i] + l[i - 1][j2]);
if (j1 == 1) f[i][j1][j2] = max(f[i][j1][j2], l[i - 1][j2]);
if (j1 >= 1) f[i][j1][j2] = max(f[i][j1][j2], f[i - 1][j1 - 1][j2]);
if (j1 >= j2) {
ans = max(ans, f[i][j1][j2] + r[i + 1][j1 - j2]);
}
}
}
}
int main() {
if (0 == 1) {
freopen("input.txt", "r", stdin);
}
readInput();
solve();
opt();
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int i, n, k, a[500], b[500], c[500];
while (scanf("%d%d", &n, &k) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int l, r, j, x, y;
int m = -200100;
for (l = 1; l <= n; l++) {
for (r = l; r <= n; r++) {
for (x = 1, i = l; i <= r; i++) {
b[x] = a[i];
x++;
}
for (y = 1, j = 1; j < l; j++) {
c[y] = a[j];
y++;
}
for (j = r + 1; j <= n; j++) {
c[y] = a[j];
y++;
}
sort(b + 1, b + x);
sort(c + 1, c + y);
for (i = 1, j = y - 1; i <= k && i < x && j >= 1; i++, j--) {
if (c[j] > b[i])
swap(b[i], c[j]);
else
break;
}
int s = 0;
for (i = 1; i < x; i++) {
s = s + b[i];
}
if (s > m) m = s;
}
}
printf("%d\n", m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, k, second[2000], a[2000];
vector<pair<int, int> > v, g;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> k;
int ans = -inf, mx = -inf;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
mx = max(mx, a[i]);
second[i] = second[i - 1] + a[i];
}
for (int l = 1; l <= n; ++l) {
for (int r = l; r <= n; ++r) {
for (int i = 1; i < l; ++i) {
v.push_back(make_pair(a[i], 0));
}
for (int i = r + 1; i <= n; ++i) {
v.push_back(make_pair(a[i], 0));
}
int cur = 0, res = 0;
for (int i = l; i <= r; ++i) {
g.push_back(make_pair(a[i], 1));
}
sort(g.begin(), g.end());
for (int i = 0; i < min((int)g.size(), k); ++i) {
v.push_back(g[i]);
cur += g[i].first;
}
sort(v.begin(), v.end());
for (int i = (int)v.size() - 1; i >= max((int)v.size() - k, 0); --i) {
if (v[i].first < 0) break;
if (v[i].second == 1)
cur -= v[i].first;
else
res += v[i].first;
}
ans = max(ans, second[r] - second[l - 1] - cur + res);
v.clear(), g.clear();
}
}
if (mx < 0) ans = mx;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long p = 1, data = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
data = data * 10 + (ch ^ 48);
ch = getchar();
}
return p * data;
}
inline long long qpow(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = a * r;
a = a * a;
b >>= 1;
}
return r;
}
inline long long gcd(long long a, long long b) {
while (b ^= a ^= b ^= a %= b)
;
return a;
}
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b)
x = 1, y = 0;
else {
exgcd(b, a % b, y, x);
y -= x * (a / b);
}
}
const int mod = 1e9 + 7;
const int maxn = 205;
int a[maxn], ans = -0x3f3f3f3f, stk[maxn], top;
int main() {
int n = read(), tk = read(), mx;
for (int i = 1; i <= n; i++) a[i] = read();
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
mx = 0, top = 0;
int k = tk;
for (int i = l; i <= r; i++) mx += a[i];
vector<int> v;
for (int i = 1; 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++) stk[++top] = a[i];
int len = r - l + 1;
sort(stk + 1, stk + 1 + top);
reverse(stk + 1, stk + 1 + top);
sort(v.begin(), v.end());
for (int i = v.size() - 1; i >= 0 && k; i--) {
if (v[i] <= 0) break;
mx += v[i];
if (top) mx -= stk[top], top--, len--;
k--;
}
while (k && top && len >= 2) {
if (stk[top] >= 0) break;
mx -= stk[top];
top--, k--, len--;
}
ans = max(ans, mx);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 222;
int N, K;
int first[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> first[i];
int ans = -INF;
for (int i = 0; i < N; i++) {
multiset<int> inside, outside;
for (int j = 0; j < N; j++) outside.insert(first[j]);
int sum = 0;
for (int j = i; j < N; j++) {
inside.insert(first[j]);
outside.erase(outside.find(first[j]));
sum += first[j];
int diff = 0;
multiset<int>::iterator it_in = inside.begin(), it_out = outside.end();
for (int k = 0;
k < K && it_in != inside.end() && it_out != outside.begin(); k++) {
it_out--;
diff += max(0, *it_out - *it_in);
it_in++;
}
ans = max(ans, sum + diff);
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 222;
int n, K, a[maxN];
int main() {
scanf("%d%d", &n, &K);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int x[maxN], y[maxN], nx, ny;
int res = a[0];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
nx = ny = 0;
for (int k = 0; k < n; k++)
if (i <= k && k <= j)
x[nx++] = a[k];
else
y[ny++] = a[k];
sort(x, x + nx);
sort(y, y + ny, greater<int>());
for (int k = 0, yk = 0; k < nx && k < K && yk < ny; k++)
if (x[k] < y[yk]) swap(x[k], y[yk++]);
int all = 0;
for (int k = 0; k < nx; k++) all += x[k];
res = max(res, all);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k, res = -9000000000000000000;
cin >> n >> k;
long long t[n];
vector<long long> v, all;
for (long long i = 0; i < n; i++) cin >> t[i], all.push_back(t[i]);
sort(all.rbegin(), all.rend());
for (long long i = 0; i < n; i++) {
for (long long j = i; j < n; j++) {
v.clear();
for (long long l = i; l <= j; l++) {
v.push_back(t[l]);
sort(v.rbegin(), v.rend());
}
long long nb = k, c = 0, curr = 0, sz = v.size();
for (long long l = 0; curr < sz && l < (j - i + 1); l++) {
if (v[curr] == all[l]) {
c += v[curr];
curr++;
} else if (nb) {
c += all[l];
nb--;
} else {
c += v[curr];
curr++;
}
}
res = max(res, c);
}
}
cout << res;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
inline long FastMax(long x, long y) {
return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y;
}
inline long FastMin(long x, long y) {
return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x;
}
long IR[] = {0, -1, 0, 1, -1, -1, 1, 1};
long IC[] = {1, 0, -1, 0, 1, -1, -1, 1};
long N, K;
long A[1007 + 7];
int main(void) {
long i, j, Icase, k = 0;
cin >> N >> K;
for (i = 1; i <= N; i++) {
cin >> A[i];
}
long ans = -1000000007;
for (i = 1; i <= N; i++) {
for (j = i; j <= N; j++) {
vector<long> vc1, vc2;
long s = 0;
for (k = 1; k <= N; k++) {
if (k >= i and k <= j) {
vc1.push_back(A[k]);
s += A[k];
} else {
vc2.push_back(A[k]);
}
}
ans = max(ans, s);
sort(vc1.begin(), vc1.end());
reverse(vc1.begin(), vc1.end());
sort(vc2.begin(), vc2.end());
for (k = 1; k <= K; k++) {
if (!vc1.size() or !vc2.size()) break;
s -= vc1[vc1.size() - 1];
s += vc2[vc2.size() - 1];
vc1.pop_back();
vc2.pop_back();
ans = max(ans, s);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int INF = 1e9;
int a[300];
int n, k;
int in[300];
int out[300];
int pin, pout;
int solve(int l, int r) {
vector<int> in, out;
for (int i = 0; i < l; ++i) out.push_back(-a[i]);
for (int i = l; i <= r; ++i) in.push_back(a[i]);
for (int i = r + 1; i < n; ++i) out.push_back(-a[i]);
sort(in.begin(), in.end());
sort(out.begin(), out.end());
int szin = in.size(), szout = out.size();
int t = min(k, min(szin, szout));
int sum = 0;
int ans = -INF;
for (int i = l; i <= r; ++i) sum += a[i];
ans = sum;
for (int i = 0; i < t; ++i) {
sum -= in[i] + out[i];
ans = max(ans, sum);
}
return ans;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int ans = -INF;
for (int l = 0; l < n; ++l)
for (int r = l; r < n; ++r) {
ans = max(ans, solve(l, r));
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, result = numeric_limits<int>::min();
cin >> N >> K;
vector<int> X(N);
for (int i = 0; i < (int)(N); i++) cin >> X[i];
for (int to = 0; to < (int)(N); to++)
for (int from = 0; from < (int)(to + 1); from++) {
vector<int> inside, outside;
int iSum = 0;
for (int i = 0; i < (int)(N); i++)
if (i < from || i > to)
outside.push_back(X[i]);
else
inside.push_back(X[i]), iSum += X[i];
sort((inside).begin(), (inside).end()),
sort((outside).begin(), (outside).end());
int osize = outside.size();
for (int i = 0; i < (int)(min(K, osize)); i++)
if (i < inside.size() && inside[i] < outside[osize - i - 1])
iSum += outside[osize - i - 1] - inside[i];
result = max(result, iSum);
}
printf("%d\n", result);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.