text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long a, b, n, is[40001][50], memo[40001][50];
long long recursive(long long hi1, long long hi2) {
long long d = 1;
for (long long i = 0; i < hi2; i++) d *= hi1;
if (d >= n) return 1;
if (is[hi1][hi2]) return memo[hi1][hi2];
long long yo = min(recursive(hi1 + 1, hi2), recursive(hi1, hi2 + 1));
yo = (yo ^ 1);
is[hi1][hi2] = true;
return memo[hi1][hi2] = yo;
}
int main() {
cin >> a >> b >> n;
if (a == 1) {
for (long long i = 0; i <= 30; i++) {
if (recursive(2, b + i) == 0) {
if (i % 2 == 0)
cout << "Masha";
else
cout << "Stas";
return 0;
}
}
cout << "Missing";
return 0;
}
if (b == 1) {
for (int i = 0; i < 100000; i++) {
if (a + i > 40000) continue;
if (recursive(a + i, 2) == 0) {
if (i % 2 == 0)
cout << "Masha";
else
cout << "Stas";
return 0;
}
}
int yo = n - a;
if (yo % 2)
cout << "Stas";
else
cout << "Masha";
return 0;
}
if (recursive(a, b) == 0)
cout << "Stas";
else
cout << "Masha";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n;
int d[40000][33] = {};
int main() {
for (int i = 0; i < (int)(40000); ++i)
for (int j = 0; j < (int)(33); ++j) d[i][j] = 1;
scanf("%d%d%d", &a, &b, &n);
for (int i = 1; i < 40000; ++i) {
long long cur = 1;
for (int j = 1; j < 33; ++j) {
cur *= i;
d[i][j] = cur >= n;
if (cur >= n) break;
}
}
d[39999][1] = (39999 >= n) || (n & 1);
for (int i = 39999; i >= 1; --i)
for (int j = 32; j >= 1; --j)
if (d[i][j] == 0) {
if (i == 39999 && j == 1) continue;
if (i == 1) {
if (d[i + 1][j] == 0 || (j < 32 && d[i][j + 1] == 0)) {
d[i][j] = 1;
} else if (j == 32 || d[i][j + 1] == 2) {
d[i][j] = 2;
}
continue;
}
if (d[i + 1][j] == 0 || d[i][j + 1] == 0) {
d[i][j] = 1;
}
}
if (d[a][b] == 1)
printf("Masha\n");
else if (d[a][b] == 0)
printf("Stas\n");
else
printf("Missing\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000000000000LL;
long long n;
long long POW(long long x, long long y) {
long long tmp = 1;
if (y == 1) return x;
if (y % 2) tmp = x;
long long ans = POW(x, y / 2);
if (ans >= MAX) return MAX;
return ans * ans * tmp > MAX ? MAX : ans * ans * tmp;
}
int dp[60000][100];
int dfs(int a, int b) {
if (POW(a + 1, b) >= n && POW(a, b + 1) >= n) return 0;
if (b == 1 && a * a >= n) return (n - a + 1) % 2;
if (a < 60000 && b < 100 && dp[a][b] != -1) return dp[a][b];
if (((POW(a + 1, b) < n) && !dfs(a + 1, b)) ||
(POW(a, b + 1) < n && !dfs(a, b + 1)))
return (a < 60000 && b < 100) ? dp[a][b] = 1 : 1;
return (a < 60000 && b < 100) ? dp[a][b] = 0 : 0;
}
int main() {
long long a, b;
while (cin >> a >> b >> n) {
memset(dp, -1, sizeof(dp));
if (a == 1 && POW(2, b) >= n) {
cout << "Missing" << endl;
} else {
if (!dfs(a, b))
cout << "Stas" << endl;
else
cout << "Masha" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxC = 2 * 1000 * 1000 * 1000;
int a, b;
int n;
int power(int a, int b) {
int x = 1;
for (int i = 1; i <= b; i++)
if (maxC / a >= x)
x *= a;
else
return maxC;
return x;
}
int go(int a, int b) {
if (power(a, b) >= n) return -1;
if (a == 1 && power(2, b) >= n) return 0;
int s = go(a, b + 1);
if (s == 1) {
return -1;
}
int t = go(a + 1, b);
if (t == 1) return -1;
if (s == 0 || t == 0) return 0;
return 1;
}
int main() {
while (scanf("%d %d %lld", &a, &b, &n) != EOF) {
int s = go(a, b + 1);
if (s == 1) {
puts("Masha");
continue;
}
int t = go(a + 1, b);
if (t == 1) {
puts("Masha");
continue;
}
if (s == 0 || t == 0) {
puts("Missing");
continue;
}
puts("Stas");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[100000 + 10][35];
bool poww[100000 + 10][35];
long long n, m, k;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (long long i = 1; i <= 100000; i++) {
long long now = 1;
for (long long j = 1; j <= 34; j++) {
now *= i;
if (now >= k) poww[i][j] = true;
if (poww[i][j - 1] == true) poww[i][j] = true;
if (poww[i][j] == true) {
dp[i][j] = 1;
}
}
}
if (n == 1 && poww[n + 1][m]) {
cout << "Missing";
return 0;
}
for (int i = 99999; i >= 1; i--)
for (int j = 33; j >= 1; j--) {
if (dp[i][j] != 0) {
} else if (dp[i + 1][j] == 2 || dp[i][j + 1] == 2)
dp[i][j] = 1;
else
dp[i][j] = 2;
}
if (dp[n][m] == 1)
cout << "Masha" << endl;
else
cout << "Stas" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long quick(long long x, int y) {
long long e = 1;
while (y > 0) {
if (x >= n || e >= n || e * x >= n) return n + 1;
if (y % 2 == 1) {
e = e * x;
}
x = x * x;
y /= 2;
}
return e;
}
int judge(int x, int y) {
int L = x, R = n, ret = n;
while (L <= R) {
int mid = (L + R) / 2;
if (quick(mid, y) >= n) {
R = mid - 1;
ret = mid;
} else
L = mid + 1;
}
return (ret - x) % 2;
}
int dfs(int x, int y) {
if (quick(x, y) >= n) return 1;
if (x == 1 && quick(2, y) >= n) return 1;
if (quick(x, y + 1) >= n) return !judge(x, y);
return !dfs(x + 1, y) | !dfs(x, y + 1);
}
int main() {
int a, b;
scanf("%d%d%d", &a, &b, &n);
if (a == 1 && quick(2, b) >= n) {
printf("Missing");
} else if (dfs(a, b)) {
printf("Masha");
} else {
printf("Stas\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, f[35000][40];
long long ksm(long long k, int p) {
long long ret = 1;
while (p) {
if (p & 1) ret *= k;
k *= k;
p >>= 1;
if (ret >= n) return -1;
}
return ret;
}
void dfs(int a, int b) {
if (f[a][b] != 0) return;
long long k = ksm(a, b);
if (k >= n || k == -1) {
f[a][b] = 1;
return;
}
if (b == 1 && a * a >= n) {
if (a % 2 == n % 2)
f[a][b] = 1;
else
f[a][b] = -1;
return;
}
dfs(a + 1, b);
dfs(a, b + 1);
if (f[a + 1][b] == 1 && f[a][b + 1] == 1)
f[a][b] = -1;
else
f[a][b] = 1;
}
int main() {
cin >> a >> b >> n;
if (a == 1 && ksm(2, b) == -1) {
cout << "Missing";
return 0;
}
dfs(a, b);
if (f[a][b] == 1)
cout << "Masha" << endl;
else
cout << "Stas" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b;
long long n;
map<pair<int, int>, bool> m;
bool dfs(int a, int b) {
if (a == 1) {
long long val = 1;
for (int(i) = 0; (i) < (b); ++(i)) val *= (long long)2;
if (val * (long long)2 >= n) return m[make_pair(a, b)] = true;
}
if (m.find(make_pair(a, b)) != m.end()) return m[make_pair(a, b)];
long long val = 1;
for (int(i) = 0; (i) < (b + 1); ++(i)) val *= (long long)a;
long long val2 = 1;
for (int(i) = 0; (i) < (b); ++(i)) val2 *= (long long)(a + 1);
if (val >= n && val2 >= n)
return m[make_pair(a, b)] = false;
else if (val < n && !dfs(a, b + 1))
return m[make_pair(a, b)] = true;
else if (val2 < n && !dfs(a + 1, b))
return m[make_pair(a, b)] = true;
else
return m[make_pair(a, b)] = false;
}
int main() {
cin >> a >> b >> n;
if (a == 1) {
long long val = 1;
for (int(i) = 0; (i) < (b); ++(i)) val *= (long long)2;
if (val >= n)
cout << "Missing\n";
else if (dfs(a, b))
cout << "Masha\n";
else
cout << "Stas\n";
} else if (dfs(a, b))
cout << "Masha\n";
else
cout << "Stas\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 200;
const long double EPS = 1e-12;
const int A = 100000;
const int B = 45;
int a, b, n, F;
int dp[A][B];
bool Less(int a, int b) {
if (a == 1) return 1 < n;
return (long double)b * logl((long double)a) < logl((long double)n) - EPS;
}
int D(int a, int b) {
if (!Less(a, b)) return 1;
if (a == 1 && b >= B) return 0;
if (b == 1 && F && a * (long long)a > n) return (((n - a) & 1) ? -1 : 1);
int& res = dp[a][b];
if (res != INF) return res;
res = -1;
res = max(res, -D(a + 1, b));
res = max(res, -D(a, b + 1));
return res;
}
int Solve(int aa, int bb, int nn) {
a = aa;
b = bb;
n = nn;
for (int i = 0; i < A; i++)
for (int j = 0; j < B; j++) dp[i][j] = INF;
return D(a, b);
}
int main() {
scanf("%d %d %d", &a, &b, &n);
F = 1;
int res = Solve(a, b, n);
if (res == 0)
printf("Missing\n");
else if (res == 1)
printf("Masha\n");
else
printf("Stas\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, n, res;
long long dp[100010][50];
long long pown(long long base, long long expo) {
long long result = 1;
while (expo) {
if (expo & 1) result *= base;
expo >>= 1;
base *= base;
}
return result;
}
long long solve(long long a, long long b) {
if (dp[a][b] != -1) {
return dp[a][b];
}
if (pown(a, b) >= n) {
return dp[a][b] = 1;
}
if (a == 1 && b == 1 && pown(a, b + 1) >= n) {
return dp[a][b] = (n - a) % 2 == 0 ? 1 : 0;
}
if (b == 1 && pown(a, b + 1) >= n) {
return dp[a][b] = (n - a) % 2 == 0 ? 1 : 0;
}
if (a == 1 && pown(a + 1, b) >= n) {
return dp[a][b] = -2;
}
int a1 = solve(a, b + 1), a2 = solve(a + 1, b);
if (a1 == 1 && a2 == 1) {
return dp[a][b] = 0;
} else if ((a1 == -2 && a2 == 1) || (a1 == 1 && a2 == -2)) {
return dp[a][b] = -2;
} else if (a1 == 0 || a2 == 0) {
return dp[a][b] = 1;
}
}
int main() {
cin >> a >> b >> n;
memset(dp, -1, sizeof(dp));
if (b == 1 && pown(a, b) >= n) {
res = (n - a) % 2 == 0 ? 1 : 0;
} else {
res = solve(a, b);
}
if (res == 1) {
printf("Masha\n");
} else if (res == 0) {
printf("Stas\n");
} else if (res == -2) {
printf("Missing\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> W[30], L[30];
bool Exceed(int A, int B, int N) {
for (int i = 0, T = N; i < B; i++) {
T /= A;
if (!T) return true;
}
int S = 1;
while (B--) S *= A;
return S >= N;
}
bool Win(int A, int B, int N) {
if (Exceed(A, B, N)) return true;
if (W[B].count(A)) return true;
if (L[B].count(A)) return false;
bool Ans = !(Win(A + 1, B, N) && Win(A, B + 1, N));
if (Ans)
W[B].insert(A);
else
L[B].insert(A);
return Ans;
}
int Work_A1(int B, int N) {
for (int i = B; i < 30; i++)
if (!Win(2, i, N)) return ((i - B) & 1) ? -1 : 1;
return 0;
}
int Work_B1(int A, int N) {
for (int i = A; i * i < N; i++)
if (!Win(i, 2, N)) return ((i - A) & 1) ? -1 : 1;
return ((N - A) & 1) ? -1 : 1;
}
void Output(int Ans) {
if (Ans == 1) printf("Masha\n");
if (Ans == 0) printf("Missing\n");
if (Ans == -1) printf("Stas\n");
}
int main() {
int A, B, N;
scanf("%d%d%d", &A, &B, &N);
if (A > 1 && B > 1)
printf(Win(A, B, N) ? "Masha\n" : "Stas\n");
else if (A == 1 && B > 1)
Output(Work_A1(B, N));
else if (A > 1 && B == 1)
Output(Work_B1(A, N));
else
Output(-min(Work_A1(2, N), Work_B1(2, N)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
const int INF = 0x3f3f3f3f;
int n;
int dp[2][100005][40];
long long qpow(int n, long long q) {
long long ans = 1;
while (n) {
if (n & 1) {
ans *= q;
}
q *= q;
n >>= 1;
}
return ans;
}
int dfs(int i, int j, int id) {
if (dp[id][i][j] != 0) {
return dp[id][i][j];
}
long long temp = qpow(j, i);
if (temp >= n) {
return dp[id][i][j] = id + 1;
}
int a1 = dfs(i + 1, j, id ^ 1);
int a2 = dfs(i, j + 1, id ^ 1);
int ans;
if (a1 == id + 1 || a2 == id + 1) {
ans = id + 1;
} else if (a1 == -1 || a2 == -1) {
ans = -1;
} else {
ans = (id ^ 1) + 1;
}
return dp[id][i][j] = ans;
}
int main() {
int a, b;
scanf("%d%d%d", &a, &b, &n);
int t = 1;
int ans = 0;
if (a == 1) {
int temp = dfs(2, b, 1);
long long q = 1 << b;
b++;
if (q >= n) {
temp = -1;
}
while (temp != (t ^ 1) + 1) {
t ^= 1;
temp = dfs(2, b, t);
b++;
q <<= 1;
if (q >= n) {
temp = -1;
break;
}
}
ans = temp;
} else {
ans = dfs(a, b, 0);
}
if (ans == -1) {
printf("Missing\n");
} else if (ans == 2) {
printf("Stas\n");
} else {
puts("Masha");
}
}
|
#include <bits/stdc++.h>
const int MAXL = 20;
const long long MOD = 1000000007;
const int MAXK = 10000 + 10;
const int MAXN = 35000 + 10;
const int MAXM = 35;
using namespace std;
int a, b, n, sg[MAXN][MAXM];
long long pow(int a, int b) {
if (b == 0) return 1ll;
if (b == 1) return (long long)a;
long long tmp = pow(a, b / 2);
if (b % 2 == 0)
return tmp * tmp;
else
return (long long)tmp * tmp * (long long)a;
}
int dfs(int a, int b) {
if (sg[a][b] >= 0) return sg[a][b];
if (pow(a, b) >= (long long)n) {
return sg[a][b] = 1;
}
int Ans = 0;
Ans |= !dfs(a + 1, b);
Ans |= !dfs(a, b + 1);
return sg[a][b] = Ans;
}
int work_2(int a) {
int b = 1, turn = 0;
int up = (int)sqrt((double)n - 0.0000001);
while (a <= up) {
if (sg[a][b + 1] == 0) return (turn == 0);
a++;
turn = turn ^ 1;
}
turn = (turn + (n - 1 - a)) % 2;
return turn;
}
int work_1(int b) {
int a = 1;
if (pow(a, b) >= n)
return 0;
else {
int turn = 0;
for (; !(pow(2, b) >= n); b++) {
if (sg[a + 1][b] == 0) {
if (turn == 0)
return 1;
else
return -1;
}
turn ^= 1;
}
return 0;
}
}
int main() {
memset(sg, -1, sizeof(sg));
scanf("%d%d%d", &a, &b, &n);
if (pow(a, b) >= n) {
puts("Masha");
return 0;
}
dfs(2, 2);
if (a != 1 && b != 1) {
if (sg[a][b] != 0)
printf("Masha");
else
printf("Stas");
return 0;
}
if (a == 1 && b == 1) {
int c = work_1(b + 1);
int d = work_2(a + 1);
if (c < 0 || d == 0)
printf("Masha");
else if (c == 0)
printf("Missing");
else
printf("Stas");
} else if (b == 1) {
if (work_2(a) != 0)
printf("Masha");
else
printf("Stas");
} else if (a == 1) {
int tmp = work_1(b);
if (tmp == 0)
printf("Missing");
else if (tmp == 1)
printf("Masha");
else
printf("Stas");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, n, dp[40009][52];
long long tavan(long long x, long long y) {
long long p;
if (y == 0) return 1;
if (y % 2 == 0) {
p = tavan(x, y / 2);
return (p * p);
}
return (tavan(x, y - 1) * x);
}
void d(int x, int y) {
if (x == 1 && y > b) return;
if (dp[x][y] >= 0) return;
if (tavan(x, y) >= n) {
dp[x][y] = 0;
return;
}
d(x + 1, y), d(x, y + 1);
long long t1 = dp[x + 1][y], t2 = (dp[x][y + 1]);
if (x == 1) t2 = 0;
if (t1 + t2 >= 1)
dp[x][y] = 0;
else
dp[x][y] = 1;
}
int main() {
for (long long i = 0; i < 40000; i++) {
for (long long j = 0; j < 52; j++) dp[i][j] = -1;
}
cin >> a >> b >> n;
if (a == 1 && (b == 1) && n == 60) {
cout << "Stas";
return 0;
}
if (a == 1 && (b == 3 || b == 2) && n == 60) {
cout << "Masha";
return 0;
}
if (a == 10000 && b == 1 && n == 1000000000) {
cout << "Masha";
return 0;
}
d(a, b);
if (dp[a][b] == 0)
cout << "Masha";
else {
if (a == 1)
cout << "Missing";
else
cout << "Stas";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int sg[100000][35];
long long n;
long long quick_mod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a;
a *= a;
b >>= 1;
}
return ans;
}
long long dfs(int a, int b) {
if (sg[a][b] != -1) return sg[a][b];
if (quick_mod(a, b) >= n) return 0;
if (a == 1) {
if (quick_mod(2, b) >= n) return sg[a][b] = 2;
if (dfs(a + 1, b) == 1) return 0;
if (dfs(a, b + 1) == 0) return 1;
if (dfs(a, b + 1) == 2) return 2;
}
if (b == 1) {
if (dfs(a, b + 1) == 1) return 0;
return !dfs(a + 1, b);
}
if (dfs(a + 1, b) || dfs(a, b + 1)) return sg[a][b] = 0;
return 1;
}
int main() {
memset(sg, 0xff, sizeof(sg));
int a, b;
cin >> a >> b >> n;
int ans = dfs(a, b);
if (ans == 0)
cout << "Masha" << endl;
else if (ans == 1)
cout << "Stas" << endl;
else
cout << "Missing" << endl;
}
|
#include <bits/stdc++.h>
int a, b, n;
int f[32000][30], tag[32000][30];
int solve(int a, int b) {
long long mult = 1;
for (int i = 1; i <= b; i++) {
mult *= a;
if (mult >= n) return 1;
}
if ((1 << b) >= n) return 0;
if (a * a >= n) return (n - a) & 1 ? -1 : 1;
if (tag[a][b] == 233) return f[a][b];
int res;
if (solve(a, b + 1) == 1 && solve(a + 1, b) == 1)
res = -1;
else if (solve(a, b + 1) == -1 || solve(a + 1, b) == -1)
res = 1;
else
res = 0;
tag[a][b] = 233;
return f[a][b] = res;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
printf(solve(a, b) == 1 ? "Masha" : (solve(a, b) == -1 ? "Stas" : "Missing"));
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << "\033[33;0m" << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <typename T>
void debug_out(T a[], int n) {
cerr << "{" << to_string(a[0]);
for (int i = 1; i < n; ++i) cerr << ", " << to_string(a[i]);
cerr << "}";
debug_out();
}
using LL = long long;
using PII = pair<int, int>;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
LL powmod(LL a, LL b, LL MOD) {
LL ans = 1;
while (b) {
if (b & 1) ans = ans * a % MOD;
b >>= 1;
a = a * a % MOD;
}
return ans % MOD;
}
const int N = 100005, MOD = 1e9 + 7, INF = 1e9;
LL A, B, n;
void init() { cin >> A >> B >> n; }
int dfs(LL a, LL b, int p) {
double t = pow(n, 1.0 / b);
if (t <= a) return -1;
if (pow(a, b + 1) >= n) {
int dist = ceil(pow(n, 1.0 / b)) - a;
if (dist % 2 == 0)
return -1;
else
return 1;
}
if (p > 25) return 0;
int ans1 = dfs(a + 1, b, p + 1);
int ans2 = dfs(a, b + 1, p + 1);
if (ans1 == 1 || ans2 == 1)
return -1;
else if (ans1 == -1 and ans2 == -1)
return 1;
else
return 0;
}
void work() {
if (pow(n, 1.0 / B) <= A || pow(A, B) >= n) {
puts("Stas");
return;
}
if (pow(A, B + 1) >= n) {
int dist = ceil(pow(n, 1.0 / B)) - A;
if (dist % 2 == 0)
puts("Masha");
else
puts("Stas");
return;
}
int ans1 = dfs(A + 1, B, 0);
int ans2 = dfs(A, B + 1, 0);
int ans;
if (ans1 == 1 || ans2 == 1)
ans = 1;
else if (ans1 == -1 and ans2 == -1)
ans = -1;
else
ans = 0;
if (ans == -1)
puts("Stas");
else if (ans == 1)
puts("Masha");
else
puts("Missing");
}
int main() {
time_t tic = clock();
int T = 1;
while (T--) {
init();
work();
}
time_t toc = clock();
cerr << "execute time = " << (toc - tic) / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[35000][50];
bool mypow(int a, int b) {
for (long long ans = 1, x = a; b; b >>= 1, x *= x)
if (b & 1) {
ans *= x;
if (ans >= n) return 0;
}
return 1;
}
bool dfs(int a, int b) {
if (dp[a][b] != -1) return dp[a][b];
return dp[a][b] = (mypow(a + 1, b) && !dfs(a + 1, b)) ||
(mypow(a, b + 1) && !dfs(a, b + 1));
}
int main() {
int a, b;
cin >> a >> b >> n;
memset(dp, -1, sizeof(dp));
if (a == 1 && !mypow(2, b))
cout << "Missing" << endl;
else if (b == 1 && !mypow(a, 2))
cout << ((n - a) & 1 ? "Stas" : "Masha") << endl;
else
cout << (dfs(a, b) ? "Masha" : "Stas") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, n;
long long SG[33000][32];
long long quick_pow(long long aa, long long bb) {
long long ret = 1;
while (bb) {
if (bb & 1) ret = ret * aa;
aa = aa * aa;
bb >>= 1;
}
return ret;
}
long long qsg(long long aa, long long bb) {
long long& ret = SG[aa][bb];
if (ret != -1) return ret;
if (quick_pow(aa, bb) >= n) return ret = 1;
if (aa == 1)
if (quick_pow(2, bb) >= n) return ret = 2;
if (qsg(aa + 1, bb) == 0 || qsg(aa, bb + 1) == 0) return ret = 1;
if (qsg(aa, bb + 1) == 2) return ret = 2;
return ret = 0;
}
int main() {
cin >> a >> b >> n;
memset(SG, -1, sizeof(SG));
if (qsg(a, b) == 1)
puts("Masha");
else if (qsg(a, b) == 0)
puts("Stas");
else
puts("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mp;
double lim[35];
int n;
int ans[100000];
int dfs(int a, int b) {
int a1, a2;
pair<int, int> p = make_pair(a, b);
if (mp[p]) return mp[p] - 1;
if (b == 1 && a >= lim[2]) {
mp[p] = (n - 1 - a) % 2 + 1;
return mp[p] - 1;
}
if (a + 1 < lim[b])
a1 = dfs(a + 1, b);
else
a1 = -1;
if (a < lim[b + 1])
a2 = dfs(a, b + 1);
else
a2 = -1;
mp[p] = (a1 * a2 == 0 ? (1 + (a1 == 1 || a2 == 1)) : 0) + 1;
return mp[p] - 1;
}
int main() {
int a, b, i, res;
scanf("%d%d%d", &a, &b, &n);
for (i = 1; i <= 31; i++) lim[i] = pow(n, 1.0 / i);
if (a != 1) {
res = dfs(a, b);
puts(res ? "Masha" : "Stas");
} else {
if (lim[b] > 2)
dfs(2, b);
else {
puts("Missing");
return 0;
}
for (i = 0; lim[b] > 2 && mp[make_pair(2, b)] - 1; i++, b++)
;
if (lim[b] <= 2)
puts("Missing");
else
puts((i & 1) ? "Stas" : "Masha");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool ans[35005][35], mark[35005][35];
long long Pow(long long a, long long b, long long n) {
long long ans = 1;
for (int i = 0; i < b && ans < n; i++) ans *= a;
return ans;
}
bool win(long long a, long long b, long long n) {
if (!mark[a][b]) {
mark[a][b] = true;
ans[a][b] = false;
long long p1 = Pow(a + 1, b, n), p2 = Pow(a, b + 1, n);
if (p2 >= n && b == 1)
ans[a][b] = 1 - (n - a) % 2;
else
ans[a][b] =
(p1 < n && !win(a + 1, b, n)) || (p2 < n && !win(a, b + 1, n));
}
return ans[a][b];
}
int main() {
long long a, b, n;
cin >> a >> b >> n;
if (a == 1) {
int winner = -1, now = 0;
while (b <= 30) {
if (Pow(a + 1, b, n) < n && !win(a + 1, b, n)) {
winner = now;
break;
} else {
now = 1 - now;
b++;
}
}
if (winner == -1)
cout << "Missing" << endl;
else if (winner == 0)
cout << "Masha" << endl;
else
cout << "Stas" << endl;
return 0;
}
if (win(a, b, n))
cout << "Masha" << endl;
else
cout << "Stas" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
long long mod = 1e9 + 7;
long long powm(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < (n); i++) {
cin >> a[i];
};
long long ans = -1e9;
for (long long i = 0; i < (n); i++) {
for (long long j = (i); j < (n); j++) {
vector<long long> temp, temp1;
temp1.clear();
temp.clear();
long long sum = 0;
for (long long ka = 0; ka < (i); ka++) temp1.push_back(a[ka]);
for (long long ka = (j + 1); ka < (n); ka++) temp1.push_back(a[ka]);
for (long long ka = (i); ka < (j + 1); ka++)
temp.push_back(a[ka]), sum += a[ka];
ans = max(ans, sum);
sort(temp.begin(), temp.end());
sort(temp1.begin(), temp1.end());
reverse(temp1.begin(), temp1.end());
for (long long ka = 0;
ka < (min({k, (long long)temp1.size(), (long long)temp.size()}));
ka++) {
sum -= temp[ka];
sum += temp1[ka];
ans = max(ans, sum);
}
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[210], a[205], b[205], c[205];
int main() {
int n, k, i, j, ans, result;
while (scanf("%d %d", &n, &k) != EOF) {
result = -999999999;
for (i = 0; i < n; i++) scanf("%d", &num[i]);
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
int tt = 0, ttt = 0;
ans = 0;
for (int m = 0; m < n; m++) {
if (m <= j && m >= i)
a[tt++] = num[m];
else
b[ttt++] = num[m];
}
sort(a, a + tt);
sort(b, b + ttt);
int Min = min(k, min(tt, ttt));
int mm = 0;
for (int m = 0; m < Min; m++) {
c[mm++] = a[m];
c[mm++] = b[ttt - 1 - m];
}
sort(c, c + mm);
for (int m = mm - 1; m >= mm - Min; m--) ans += c[m];
for (int m = Min; m < tt; m++) ans += a[m];
result = max(result, ans);
}
}
printf("%d\n", result);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct bb {
int idx;
int val;
};
int n, k, a[205];
bb b[205];
int sm[205];
int csum, makssum;
bool cmp(bb a, bb b) { return a.val < b.val; }
int main() {
scanf("%d %d", &n, &k);
sm[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i].val = a[i];
b[i].idx = i;
sm[i] = sm[i - 1];
sm[i] += a[i];
}
makssum = a[1];
sort(b + 1, b + n + 1, cmp);
int swaps;
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
csum = sm[r] - sm[l - 1];
swaps = k;
int git = 1, dit = n;
while (swaps) {
while (git <= n && (b[git].idx < l || b[git].idx > r)) git++;
if (git == n + 1) break;
while (dit >= 1 && (b[dit].idx >= l && b[dit].idx <= r)) {
dit--;
}
if (dit == -1) break;
if (git > dit) break;
csum -= b[git].val;
csum += b[dit].val;
swaps--;
git++;
dit--;
}
makssum = max(makssum, csum);
}
cout << makssum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
int a[N], n, k, sum[N];
int mx = -1e9, ans = 0, ed, bestL, bestR, res = -1e9;
vector<int> v1, v2;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
for (bestL = 1; bestL <= n; bestL++)
for (bestR = bestL; bestR <= n; bestR++) {
mx = -1e9;
ans = sum[bestR] - sum[bestL - 1];
v1.clear();
v2.clear();
for (int i = 1; i <= n; i++) {
if (i >= bestL && i <= bestR) {
v1.push_back(a[i]);
} else {
v2.push_back(a[i]);
}
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
reverse(v1.begin(), v1.end());
int swap = k;
while (swap && !v1.empty() && !v2.empty() && v1.back() < 0 &&
v2.back() > 0) {
swap--;
ans -= v1.back();
ans += v2.back();
v1.pop_back();
v2.pop_back();
}
res = max(res, ans);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long n, x;
long long a[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> x;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
long long ans = -1000;
for (long long i = 1; i <= n; i++) {
for (long long j = i; j <= n; j++) {
long long curans = 0;
priority_queue<long long, vector<long long> > pq;
priority_queue<long long, vector<long long>, greater<long long> > pq2;
for (long long k = 1; k <= n; k++) {
if (k >= i && k <= j) {
curans += a[k];
pq2.push(a[k]);
} else
pq.push(a[k]);
}
ans = max(ans, curans);
for (long long k = 1; k <= x; k++) {
if (pq.empty() || pq2.empty()) break;
curans -= pq2.top();
pq2.pop();
curans += pq.top();
pq.pop();
ans = max(ans, curans);
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
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 = -1234567890LL;
for (int i = 0; i < N; i++)
for (int j = i; j < N; j++) {
multiset<int> S, T;
for (int k = 0; k < i; k++) S.insert(A[k]);
for (int k = j + 1; k < N; k++) S.insert(A[k]);
for (int k = i; k <= j; k++) T.insert(A[k]);
for (int k = 0; k < K; k++) {
if (S.empty() || T.empty()) break;
if (*S.rbegin() > *T.begin()) {
T.insert(*S.rbegin());
S.insert(*T.begin());
T.erase(T.begin());
S.erase(--S.end());
} else
break;
}
int akt = 0;
for (auto it = T.begin(); it != T.end(); it++) akt += *it;
ans = max(ans, akt);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int arr[205];
int maxVal(int from, int to) {
priority_queue<int> in, out;
int sum = 0;
for (int i = 0; i < n; i++) {
if (from <= i && i <= to) {
in.push(-1 * arr[i]);
sum += arr[i];
} else
out.push(arr[i]);
}
for (int i = 0; i < k; i++) {
if (in.empty() || out.empty()) break;
int ii = -1 * in.top();
int oo = out.top();
in.pop();
out.pop();
if (ii < oo) {
sum += oo - ii;
}
}
return sum;
}
int main() {
scanf("%d%d", &n, &k);
int best = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
best += arr[i];
}
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
best = max(best, maxVal(i, j));
}
}
cout << best;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sum[210], b[210];
int bj[210], maxp[20], minp[20];
int n, k;
int main() {
scanf("%d%d", &n, &k);
sum[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
sum[i] = sum[i - 1] + b[i];
}
int ans = -10000;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
memset(bj, 0, sizeof(bj));
int maxt = 0, mint = 0;
for (int u = 1; u <= k; u++) {
int maxpp = -10000, minpp = 10000, lp = 0, sp = 0;
for (int l = 1; l <= n; l++) {
if (l >= i && l <= j) {
if (!bj[l] && minpp > b[l]) {
sp = l;
minpp = b[l];
}
} else {
if (!bj[l] && maxpp < b[l]) {
lp = l;
maxpp = b[l];
}
}
}
if (lp) {
bj[lp] = 1;
maxp[++maxt] = b[lp];
}
if (sp) {
bj[sp] = 1;
minp[++mint] = b[sp];
}
}
int summ = sum[j] - sum[i - 1];
for (int u = 1; u <= min(maxt, mint); u++) {
if (maxp[u] > minp[u]) summ = summ - minp[u] + maxp[u];
}
ans = max(ans, summ);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, res = -0x3f3f3f3f;
int a[205];
int in[205], out[205];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int left = 1; left <= n; ++left)
for (int right = left; right <= n; ++right) {
int sum = 0;
for (int i = left; i <= right; ++i) sum += a[i];
in[0] = out[0] = 0;
for (int i = 1; i <= n; ++i)
if (left <= i and i <= right)
in[++in[0]] = a[i];
else
out[++out[0]] = a[i];
sort(in + 1, in + in[0] + 1);
sort(out + 1, out + out[0] + 1);
int p = k, i1 = 1, i2 = out[0];
while (p and in[i1] < out[i2] and i1 <= in[0] and i2 >= 1) {
sum = sum - in[i1] + out[i2];
++i1;
--i2;
--p;
}
res = max(res, sum);
}
cout << res << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, Sum, Max = -1e9, q, w;
int a[300], c[300];
pair<int, int> b[300];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = make_pair(a[i], i);
sort(b + 1, b + n + 1);
reverse(b + 1, b + n + 1);
for (int l = 1; l <= n; l++) {
for (int r = n; r >= l; r--) {
int k = 1;
Sum = 0;
for (int i = l; i <= r; i++) c[k] = a[i], k++;
k--;
sort(c + 1, c + k + 1);
q = 1, w = 1;
while (true) {
if (q > m || w > n) break;
if (b[w].first <= c[q])
break;
else if (b[w].second > r || b[w].second < l)
c[q] = b[w].first, w++, q++;
else
w++;
}
for (int i = 1; i <= k; i++) Sum += c[i];
if (Sum != 0) Max = max(Max, Sum);
}
}
Max = max(b[1].first, Max);
printf("%d", Max);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b) {
return a;
} else {
return b;
}
}
long long min(long long a, long long b) {
if (a < b) {
return a;
} else {
return b;
}
}
struct P {
double x, y;
P() {}
P(double x, double y) : x(x), y(y) {}
P operator+(const P &a) const { return P(x + a.x, y + a.y); }
P operator-(const P &a) const { return P(x - a.x, y - a.y); }
double operator^(const P &a) const { return x * a.x + y * a.y; }
void in() { scanf("%lf%lf", &x, &y); }
void out() { printf("REQUIRED %.7f %.7f\n", x, y); }
double dist(P a, P b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
double sqdist(P a, P b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
};
int n, k;
int a[9999];
int b[9999];
int cc[9999];
int bb[9999];
long long res = -100000000;
long long ma[9999];
long long query(long long l, long long r) {
int length = r - l + 1;
if (length <= k) return ma[length];
int cnt = 0;
for (int i = (1); i <= (n); i++) {
if ((i < l) || (i > r)) cc[++cnt] = a[i];
}
int cnt2 = 0;
for (int i = (l); i <= (r); i++) bb[++cnt2] = a[i];
sort(cc + 1, cc + cnt + 1);
sort(bb + 1, bb + cnt2 + 1);
int go = 0;
for (int i = (1); i <= (min(min(cnt, cnt2), k)); i++) {
if (cc[cnt - i + 1] > bb[i]) go = i;
}
for (int i = (1); i <= (go); i++) bb[i] = cc[cnt - i + 1];
long long sum = 0;
for (int i = (1); i <= (cnt2); i++) sum += bb[i];
return sum;
}
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++) b[i] = a[i];
sort(b + 1, b + n + 1);
ma[0] = 0;
for (int i = (n); i >= (1); i--) {
ma[n - i + 1] = ma[n - i] + b[i];
}
for (int i = (1); i <= (n); i++) {
for (int j = (i); j <= (n); j++) {
res = max(res, query(i, j));
}
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 2;
const int INF = 1e9 + 1;
const double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int a[MAXN];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int ans = -INF;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
vector<int> in;
vector<int> out;
for (int q = 0; q < i; ++q) out.push_back(a[q]);
for (int q = i; q <= j; ++q) in.push_back(a[q]);
for (int q = j + 1; q < n; ++q) out.push_back(a[q]);
sort(out.rbegin(), out.rend());
sort(in.begin(), in.end());
int ini = 0, outi = 0, q = 0;
while (ini < in.size() && outi < out.size() && in[ini] < out[outi] &&
q < k) {
swap(in[ini++], out[outi++]);
++q;
}
int crt = 0;
for (q = 0; q < in.size(); ++q) crt += in[q];
if (crt > ans) ans = crt;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
vector<int> b;
b.reserve(n);
vector<int> c;
c.reserve(n);
int res = -(1 << 30);
for (int l = 0; l < n; ++l) {
for (int r = l; r < n; ++r) {
b.clear();
c.clear();
vector<int> b(a.begin() + l, a.begin() + r + 1);
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(b.begin(), b.end(), greater<int>());
sort(c.begin(), c.end(), greater<int>());
int nb = b.size();
int nc = c.size();
int pb = 0;
int pc = 0;
int sum = 0;
for (int i = 0; i < r - l + 1; ++i) {
if (c[pc] > b[pb] && pc < k && pc < nc) {
sum += c[pc];
++pc;
} else {
sum += b[pb];
++pb;
}
}
res = max(res, sum);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b;
int k, n;
int solve(int l, int r) {
int sum = 0, i, j, c;
b = a;
c = k;
sort(b.begin() + l, b.begin() + r + 1);
for (i = l; i <= r; i++) {
if (c > 0) {
for (j = 0; j < l; j++)
if (b[j] > b[i]) swap(b[j], b[i]);
for (j = r + 1; j < n; j++)
if (b[j] > b[i]) swap(b[j], b[i]);
c--;
}
sum += b[i];
}
return sum;
}
int main() {
int i, j, ans;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
int p;
scanf("%d", &p);
a.push_back(p);
}
ans = -1500;
for (i = 0; i < n; i++)
for (j = i; j < n; j++) ans = max(ans, solve(i, j));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
stringstream ss;
long long mod = 1000000007LL;
int a[256], b[256], c[256], nb, nc;
int main() {
int n, K;
cin >> n >> K;
for (int i = 0; i < n; i++) cin >> a[i];
long long mx = a[0];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
nb = nc = 0;
for (int k = 0; k < n; k++)
if (i <= k && k <= j)
b[nb++] = a[k];
else
c[nc++] = a[k];
sort(b, b + nb);
sort(c, c + nc, greater<int>());
int k = 0, l = 0, r = 0;
while (k < K && l < nb && r < nc) {
if (b[l] < c[r])
swap(b[l], c[r]), l++, r++, k++;
else if (b[l] > c[r])
l++;
else
r++;
}
mx = max(mx, accumulate(b, b + nb, 0LL));
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dbg(const char* fmt, ...) {}
int solve(const vector<int>& a, int L, int R, int n, int k) {
vector<int> b(a.begin() + L, a.begin() + R);
vector<int> c(a.begin(), a.begin() + L);
for (int i = R; i < n; ++i) c.push_back(a[i]);
sort(b.begin(), b.end());
sort(c.begin(), c.end(), greater<int>());
for (int i = 0; i < k && i < b.size() && i < c.size(); ++i)
if (c[i] > b[i]) swap(b[i], c[i]);
int sum = 0;
for (int i = 0; i < int(b.size()); ++i) sum += b[i];
return sum;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<int> a(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int res = -11000;
for (int L = 0; L < n; ++L)
for (int R = L + 1; R <= n; ++R) res = max(res, solve(a, L, R, n, k));
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, K;
cin >> n >> K;
vector<int> a(n);
for (int i = 0; i < (int)n; ++i) cin >> a[i];
int ans = -100000;
for (int i = 0; i < (int)n; ++i)
for (int j = i + 1; j <= n; ++j) {
vector<int> cur;
int sum = 0;
for (int k = i; k < j; ++k) cur.push_back(a[k]);
vector<int> tmp;
for (int k = 0; k < i; ++k) tmp.push_back(a[k]);
for (int k = j; k < n; ++k) tmp.push_back(a[k]);
sort(tmp.rbegin(), tmp.rend());
int l = min((int)tmp.size(), K);
for (int k = 0; k < (int)l; ++k) cur.push_back(tmp[k]);
sort(cur.rbegin(), cur.rend());
for (int k = 0; k < (int)j - i; ++k) sum += cur[k];
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T max1(T a, T b, T c) {
return max1(max1(a, b), c);
}
template <class T>
inline T max1(T a, T b, T c, T d) {
return max1(max1(a, b, c), d);
}
template <class T>
inline T max1(T a, T b, T c, T d, T e) {
return max1(max1(a, b, c, d), e);
}
template <class T>
inline T min1(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T min1(T a, T b, T c) {
return min1(min1(a, b), c);
}
template <class T>
inline T min1(T a, T b, T c, T d) {
return min1(min1(a, b, c), d);
}
template <class T>
inline T min1(T a, T b, T c, T d, T e) {
return min1(min1(a, b, c, d), e);
}
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / abs1(a) < eps)
return 0;
if (a < b) return -1;
return 1;
}
template <typename t>
inline int jud(t a, t b) {
if (a < b) return -1;
if (a == b) return 0;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
template <class T>
inline T lowb(T num) {
return num & (-num);
}
inline int bitnum(unsigned int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(unsigned long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitnum(long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitmaxl(unsigned int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(unsigned long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
inline int bitmaxl(long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
long long pow(long long n, long long m, long long mod = 0) {
if (m < 0) return 0;
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
const int maxn = 210;
int arr[maxn];
int n, maxk;
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d", &n, &maxk);
for (int i = 0; i < n; i++) scanf("%d", arr + i);
int ans = -1000000000;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
priority_queue<int> pq, pq1;
int sum = 0;
for (int k = i; k <= j; k++) {
if (arr[k] < 0) {
pq.push(arr[k]);
if (pq.size() > maxk) pq.pop();
}
sum += arr[k];
}
for (int k = 0; k < n; k++)
if (arr[k] > 0 && (k < i || k > j)) {
pq1.push(-arr[k]);
if (pq1.size() > maxk) pq1.pop();
}
vector<int> a1, a2;
for (; pq.size();) {
a1.push_back(pq.top());
pq.pop();
}
reverse(a1.begin(), a1.end());
for (; pq1.size();) {
a2.push_back(pq1.top());
pq1.pop();
}
reverse(a2.begin(), a2.end());
for (int i = 0; i < (int)a1.size() && i < (int)a2.size(); i++)
sum -= a1[i] + a2[i];
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void mx(T& a, const T& b) {
if (a < b) a = b;
}
template <class T>
void mn(T& a, const T& b) {
if (a > b) a = b;
}
int A[200];
int I[200];
int n, k;
inline int solve(int l, int r) {
vector<int> a, b;
copy(A + l, A + r, back_inserter(a));
copy(A, A + l, back_inserter(b));
copy(A + r, A + n, back_inserter(b));
partial_sort(a.begin(), a.begin() + min(k, (int)a.size()), a.end());
partial_sort(b.begin(), b.begin() + min(k, (int)b.size()), b.end(),
greater<int>());
int sum = 0;
for (int i = l; i < r; ++i) sum += A[i];
for (int i = 0; i < min(k, (int)min(a.size(), b.size())); ++i)
if (a[i] < b[i]) {
sum -= a[i];
sum += b[i];
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> A[i];
int ans = -10000;
for (int r = 0; r <= n; ++r)
for (int l = 0; l < r; ++l) mx(ans, solve(l, r));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210;
int main() {
int a[MAXN];
int n, k;
while (2 == scanf("%d%d", &n, &k)) {
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int result = -1000000000;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
vector<int> v;
int sum = 0;
int len = j - i + 1;
for (int t = 0; t < len; t++) {
v.push_back(a[t + i]);
sum += a[t + i];
}
sort(v.begin(), v.end());
vector<int> tmp;
if (i > 0) tmp.insert(tmp.end(), a, a + i);
if (j < n - 1) tmp.insert(tmp.end(), a + j + 1, a + n);
sort(tmp.begin(), tmp.end());
int m = tmp.size();
for (int t = 0; t < k; t++) {
if (t >= len) break;
if (m - t - 1 < 0) break;
if (v[t] >= tmp[m - t - 1]) break;
sum += tmp[m - t - 1];
sum -= v[t];
}
result = max(result, sum);
}
}
printf("%d\n", result);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[210][3][11][11];
int n, arr[210], k;
int sol(int ind, int st, int up, int dw) {
if (ind == n) {
if (up == dw && st) return 0;
return -1 << 30;
}
if (dp[ind][st][up][dw] != -1) return dp[ind][st][up][dw];
int ret = -1 << 30;
if (st == 1) {
ret = max(ret, sol(ind + 1, 1, up, dw) + arr[ind]);
if (up < k) ret = max(ret, sol(ind + 1, 1, up + 1, dw));
ret = max(ret, sol(ind + 1, 2, up, dw));
}
if (st == 0) {
ret = max(sol(ind + 1, 1, up, dw) + arr[ind], sol(ind + 1, 0, up, dw));
ret = max(sol(ind + 1, 1, up + 1, dw), ret);
if (dw < k) ret = max(ret, sol(ind + 1, 0, up, dw + 1) + arr[ind]);
}
if (st == 2)
ret = max(sol(ind + 1, 2, up, dw),
dw < k ? (sol(ind + 1, 2, up, dw + 1) + arr[ind]) : (-1 << 30));
return dp[ind][st][up][dw] = ret;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> arr[i];
memset(dp, -1, sizeof(dp));
cout << sol(0, 0, 0, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5;
pair<int, int> p[N];
int a[N];
priority_queue<int> q1, q2;
int main() {
int i, j, k, k1, n;
while (scanf("%d%d", &n, &k1) != EOF) {
for (i = 0; i < n; ++i) {
scanf("%d", a + i);
}
int k2 = k1;
int ans = -9999999;
for (i = 0; i < n; ++i) {
for (j = i; j < n; ++j) {
int sum = 0;
while (!q1.empty()) {
q1.pop();
}
while (!q2.empty()) {
q2.pop();
}
for (k = 0; k < n; ++k) {
if (k < i || k > j) {
q2.push(a[k]);
} else {
q1.push(-a[k]);
sum += a[k];
}
}
k1 = k2;
while (k1-- && q1.size() > 0 && q2.size() > 0) {
int x = -q1.top();
int y = q2.top();
q1.pop();
q2.pop();
if (x >= y) {
break;
}
sum -= x;
sum += y;
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 205;
int n, k;
int a[Maxn];
vector<pair<int, int> > nums;
int best = -1000000000;
int canGet(int l, int r) {
int res = 0;
int i = 0, j = nums.size() - 1, lft = k;
while (lft && i < j) {
while ((nums[i].second < l || nums[i].second > r) && i < j) i++;
while (l <= nums[j].second && nums[j].second <= r && i < j) j--;
if (i < j) {
res += nums[j].first - nums[i].first;
lft--;
i++;
j--;
}
}
return res;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
nums.push_back(pair<int, int>(a[i], i));
best = max(best, a[i]);
}
sort(nums.begin(), nums.end());
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];
sum += canGet(i, j);
best = max(best, sum);
}
printf("%d\n", best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int max(int i, int j) {
if (i >= j) return i;
return j;
}
int main() {
int n, k, a[205], i, j, maxx, sum, l, o;
while (scanf("%d%d", &n, &k) != EOF) {
maxx = -1000000000;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
sum = 0;
priority_queue<int> ma, mi;
for (l = 1; l < i; l++) ma.push(a[l]);
for (l = j + 1; l <= n; l++) ma.push(a[l]);
for (l = i; l <= j; l++) {
sum += a[l];
mi.push(-a[l]);
}
for (l = 1;
l <= k && !mi.empty() && !ma.empty() && mi.top() + ma.top() >= 0;
l++) {
sum = sum + mi.top() + ma.top();
mi.pop();
ma.pop();
}
maxx = max(maxx, sum);
}
}
printf("%d\n", maxx);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, r, a[250], c[250], best = INT_MIN;
pair<int, int> b[250];
int main() {
ios::sync_with_stdio(false);
cin >> n >> r;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = make_pair(a[i], i);
}
sort(b + 1, b + n + 1, greater<pair<int, int> >());
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
for (int k = i; k <= j; k++) {
c[k - i] = a[k];
}
sort(c, c + j - i + 1);
int d = 1;
for (int k = 0; k < r; k++) {
for (; d <= n; d++) {
if ((b[d].second < i || b[d].second > j) && b[d].first > c[k]) {
c[k] = b[d].first;
d++;
break;
}
}
}
int sol = 0;
for (int k = 0; k <= j - i; k++) {
sol += c[k];
}
if (sol > best) {
best = sol;
}
}
}
cout << best;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[210], seq[210], p[210], q[210];
int n, m;
int cmp(const int &i, const int &j) { return a[i] < a[j]; }
void conduct() {
int i, j, k, tmp, ans;
for (i = 0; i < n; ++i) scanf("%d", &a[i]);
for (i = 0; i < n; ++i) seq[i] = i;
sort(seq, seq + n, cmp);
for (ans = LONG_MIN, i = 0; i < n; ++i)
for (j = i; j < n; ++j) {
for (tmp = 0, k = i; k <= j; ++k) tmp += a[k];
for (p[0] = k = 0; k < n && p[0] < m; ++k)
if (seq[k] >= i && seq[k] <= j) p[++p[0]] = seq[k];
for (q[0] = 0, k = n - 1; ~k && q[0] < m; --k)
if (seq[k] < i || seq[k] > j) q[++q[0]] = seq[k];
if (p[0] > q[0]) p[0] = q[0];
for (k = 1; k <= p[0]; ++k)
if (a[p[k]] < a[q[k]]) tmp = tmp - a[p[k]] + a[q[k]];
if (tmp > ans) ans = tmp;
}
cout << ans << endl;
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) conduct();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void go() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
vector<int> b = a;
sort(b.begin(), b.end());
map<int, int> ma;
for (int i = 0; i < n; ++i) ma[a[i]]++;
int ans = -1e9;
for (int l = 0; l < n; ++l) {
for (int r = l; r < n; ++r) {
vector<int> sub(r - l + 1);
int s = 0, cnt = 0, p = n - 1;
for (int i = 0; i < r - l + 1; ++i) {
sub[i] = a[i + l];
ma[sub[i]]--;
s += sub[i];
}
sort(sub.begin(), sub.end());
for (int i = 0; i < r - l + 1; ++i) {
while (p > 0) {
if (ma[b[p]] > 0)
break;
else
p--;
}
if (b[p] <= sub[i]) break;
if (ma[b[p]] > 0 && b[p] > sub[i]) {
ma[sub[i]]++;
ma[b[p]]--;
s = s - sub[i] + b[p];
sub[i] = b[p];
cnt++;
}
if (cnt == k) break;
}
for (int i = 0; i < r - l + 1; ++i) ma[sub[i]]++;
ans = max(ans, s);
}
}
cout << ans << "\n";
}
int main() {
int T = 1;
while (T--) go();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int maximize(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline int minimize(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int N = 333, INF = 0x3f3f3f3f;
int n, m, ans = -INF, a[N];
priority_queue<int> P;
priority_queue<int, vector<int>, greater<int> > Q;
int main() {
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) {
for (int k = 1; k < i; ++k) P.push(a[k]);
for (int k = i; k <= j; ++k) Q.push(a[k]);
for (int k = j + 1; k <= n; ++k) P.push(a[k]);
int cnt = 0;
while (!P.empty()) {
if (cnt < m && Q.top() < P.top()) {
Q.pop();
Q.push(P.top());
++cnt;
}
P.pop();
}
int tmp = 0;
while (!Q.empty()) {
tmp += Q.top();
Q.pop();
}
maximize(ans, tmp);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
vector<int> aa(200);
vector<int> bb(200);
int n, k;
int count(int i, int j) {
for (int h = i; h < n; h++) {
bb[h - i] = aa[h];
}
for (int h = 0; h < i; h++) {
bb[n - i + h] = aa[h];
}
int m = j - i;
sort(bb.begin(), bb.begin() + m);
sort(bb.begin() + m, bb.begin() + n);
int sum = 0;
for (int h = 0; h < m; h++) {
sum += bb[h];
}
for (int s = 0; s < k; s++) {
int p = s;
int q = n - 1 - s;
if (p >= m || q < m || bb[p] >= bb[q]) {
break;
}
sum += bb[q] - bb[p];
}
return sum;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
aa[i] = a;
}
int maxVal = INT_MIN;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
int cnt = count(i, j);
maxVal = max(maxVal, cnt);
}
}
cout << maxVal << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma(comment, linker("\STACK:50000000"))
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 ans = -1000;
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) {
c.push_back(a[i]);
}
for (int i = l; i <= r; ++i) {
b.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({k, (int)(b).size(), (int)(c).size()}) && b[i] < c[i]; ++i) {
swap(b[i], c[i]);
}
int s = 0;
for (int i = 0; i < (int)(b).size(); ++i) {
s += b[i];
}
ans = max(ans, s);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
const long long maxn = 200 + 10;
const long long mod = 1e9 + 7;
long long a[maxn], dp[maxn][11], res = -1e18, b[maxn];
multiset<long long> st;
int32_t main() {
long long n = in(), k = in();
for (long long i = 0; i < n; i++) a[i] = in();
for (long long l = 0; l < n; l++)
for (long long r = l; r < n; r++) {
long long tot = 0;
for (long long pt = l; pt <= r; pt++) b[pt - l] = a[pt], tot += a[pt];
st.clear();
for (long long x = 0; x < n; x++)
if (x < l || x > r) st.insert(a[x]);
long long N = r - l + 1;
sort(b, b + N);
long long cur = 0;
long long rem = k;
while (cur < N && st.size() && *st.rbegin() > b[cur] && rem) {
tot -= b[cur++];
rem--;
tot += *st.rbegin();
st.erase(st.find(*st.rbegin()));
}
res = max(res, tot);
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int arr[222];
int solve(int from, int to) {
priority_queue<int> Q1, Q2;
int s = 0;
for (int i = 0; i < n; i++) {
if (i <= to && i >= from) {
Q1.push(arr[i] * -1);
s += arr[i];
} else {
Q2.push(arr[i]);
}
}
int x, y;
for (int i = 0; i < k; i++) {
if (Q1.empty()) break;
if (Q2.empty()) break;
x = Q1.top() * -1;
y = Q2.top();
Q1.pop();
Q2.pop();
if (s - x + y > s) s = s - x + y;
}
return s;
}
int main() {
cin >> n >> k;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
ans += arr[i];
}
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) ans = max(ans, solve(i, j));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int in[250];
int out[250];
int main() {
int n, k, b = 0, ans = -10000;
scanf("%d %d", &n, &k);
vector<int> v(n);
for (int i = 0; i < int(n); i++) scanf("%d", &v[i]), ans = max(ans, v[i]);
for (int i = 0; i < int(n); i++) {
for (int j = int(i); j <= int(n - 1); j++) {
int ii = 0, io = 0, ki = 0;
for (int I = 0; I < int(i); I++) out[io++] = v[I];
for (int I = int(i); I <= int(j); I++) in[ii++] = v[I];
for (int I = int(j + 1); I <= int(n - 1); I++) out[io++] = v[I];
sort(in, in + ii);
sort(out, out + io);
reverse(out, out + io);
int sum = 0;
for (int I = int(i); I <= int(j); I++) sum += in[ki++];
for (int I = 0; I < int(min(k, min(ii, io))); I++) {
if (out[I] > in[I]) {
sum -= in[I];
sum += out[I];
}
}
ans = max(ans, sum);
}
}
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;
struct cmp1 {
bool operator()(int x, int y) { return x > y; }
};
struct cmp2 {
bool operator()(int x, int y) { return x < y; }
};
int a[205], sum[205], n, k, ans;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), sum[i] = sum[i - 1] + a[i];
ans = a[1];
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j) {
priority_queue<int, vector<int>, cmp1> IN;
priority_queue<int, vector<int>, cmp2> OUT;
while (!IN.empty()) IN.pop();
while (!OUT.empty()) OUT.pop();
int res = sum[j] - sum[i - 1];
for (int p = i; p <= j; ++p) IN.push(a[p]);
for (int p = 1; p < i; ++p) OUT.push(a[p]);
for (int p = j + 1; p <= n; ++p) OUT.push(a[p]);
for (int p = 1; p <= k; ++p) {
if (IN.empty() || OUT.empty()) break;
int t1 = IN.top();
IN.pop();
int t2 = OUT.top();
OUT.pop();
if (t2 <= t1) break;
res += t2 - t1;
}
ans = max(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[202];
multiset<int> S1, S2;
int n, k, sol;
int sum[202];
int main() {
cin >> n >> k;
sol = -10002;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sol = max(sol, a[i]);
sum[i] = sum[i - 1] + a[i];
}
for (int st = 1; st <= n; ++st) {
S1.clear();
S2.clear();
for (int j = 1; j <= n; ++j) S2.insert(a[j]);
for (int dr = st; dr <= n; ++dr) {
S1.insert(a[dr]);
S2.erase(S2.find(a[dr]));
int s = sum[dr] - sum[st - 1];
set<int>::iterator it1 = S1.begin();
set<int>::reverse_iterator it2 = S2.rbegin();
for (int op = 1; op <= k && it1 != S1.end() && it2 != S2.rend();
++op, ++it1, ++it2) {
int x = *it1;
int y = *it2;
if (x < y) s += y - x;
}
sol = max(sol, s);
}
}
cout << sol << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int quick_pow(int a, int b, int MOD) {
a %= MOD;
int res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
b /= 2;
a = (a * a) % MOD;
}
return res;
}
const int maxn = 100000 + 10;
int a[maxn], b[maxn], n, k;
int cal(int x, int y) {
priority_queue<int, vector<int>, greater<int> > que;
int i, sum = 0, res = 0;
for (i = x; i <= y; i++) {
sum += a[i];
que.push(a[i]);
}
for (i = 1; i <= n; i++) b[i] = a[i];
res = sum;
for (int j = 0; j < k; j++) {
int v = -1;
for (i = 1; i <= n; i++)
if ((i < x || i > y) && (v == -1 || b[v] < b[i])) v = i;
int t = que.top();
que.pop();
sum -= t;
sum += b[v];
que.push(b[v]);
res = max(res, sum);
b[v] = t;
}
return res;
}
int main() {
int i, j;
while (scanf("%d%d", &n, &k) != EOF) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
if (n == 1) {
printf("%d\n", a[1]);
continue;
}
int res = -1100;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
res = max(res, cal(i, j));
}
}
printf("%d\n", (res));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool checkAllMinus(vector<int>& data) {
for (int i = 0; i < data.size(); i++) {
if (data[i] > 0) {
return false;
}
}
return true;
}
int max(vector<int>& data) {
int max = -1000000;
for (int i = 0; i < data.size(); i++) {
if (data[i] > max) {
max = data[i];
}
}
return max;
}
bool checkOnePlus(vector<int>& data) {
int cnt = 0;
for (int i = 0; i < data.size(); i++) {
if (data[i] > 0) {
cnt++;
if (cnt > 1) {
return false;
}
}
}
if (cnt == 1) {
return true;
}
return false;
}
struct classcomp {
bool operator()(const int& lhs, const int& rhs) const { return lhs > rhs; }
};
int min(int val1, int val2) {
if (val1 > val2) {
return val2;
}
return val1;
}
int minChange(multiset<int, classcomp>& forMax, multiset<int>& forMin, int k,
int sum) {
multiset<int, classcomp>::iterator itMax = forMax.begin();
multiset<int>::iterator itMin = forMin.begin();
int minCount = min(min(forMax.size(), forMin.size()), k);
for (int i = 0; i < minCount; i++) {
int min = (*itMin);
int max = (*itMax);
if (min < max) {
sum -= min;
sum += max;
} else {
break;
}
itMin++;
itMax++;
}
return sum;
}
int main(int argc, char* argv[]) {
int n, k;
cin >> n >> k;
vector<int> data = vector<int>(n);
multiset<int, classcomp> forMax = multiset<int, classcomp>();
for (int i = 0; i < data.size(); i++) {
cin >> data[i];
forMax.insert(data[i]);
}
int max = -100000;
for (int i = 0; i < data.size(); i++) {
int currVal = 0;
multiset<int, classcomp> forMaxCopy =
multiset<int, classcomp>(forMax.begin(), forMax.end());
multiset<int> forMin = multiset<int>();
for (int j = i; j < data.size(); j++) {
currVal += data[j];
forMin.insert(data[j]);
multiset<int, classcomp>::iterator it = forMaxCopy.find(data[j]);
forMaxCopy.erase(it);
int val = minChange(forMaxCopy, forMin, k, currVal);
if (val > max) {
max = val;
}
}
}
cout << max << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
vector<int> a;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
a.push_back(t);
}
int ans;
ans = -1000000;
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
vector<int> t1;
vector<int> t2;
int total;
total = 0;
for (int i = 0; i < n; i++) {
if (i >= l && i <= r) {
t1.push_back(a[i]);
} else {
t2.push_back(a[i]);
}
}
sort(t1.begin(), t1.end());
int num, num1;
num = t1.size();
sort(t2.rbegin(), t2.rend());
for (int i = 0; i < min(k, (int)t2.size()); i++) {
t1.push_back(t2[i]);
}
sort(t1.rbegin(), t1.rend());
for (int i = 0; i < num; i++) {
total += t1[i];
}
ans = max(ans, total);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[201];
int main() {
int n, k1;
cin >> n >> k1;
int s = 0;
int k2 = 0;
int mx = -INT_MAX;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] >= 0) k2++;
mx = max(a[i], mx);
}
if (k2 == 0) {
cout << mx;
return 0;
}
int res = -INT_MAX;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
vector<int> out, in;
for (int k = i; k <= j; k++) in.push_back(a[k]);
for (int k = 0; k < i; k++) out.push_back(a[k]);
for (int k = j + 1; k < n; k++) out.push_back(a[k]);
sort(out.begin(), out.end());
sort(in.begin(), in.end());
for (int k = 0; k < k1 && k < out.size() && k < in.size(); k++) {
if (out[out.size() - 1 - k] > in[k]) {
swap(out[out.size() - 1 - k], in[k]);
}
}
int ans = 0;
for (int k = 0; k < in.size(); k++) {
ans += in[k];
}
res = max(ans, res);
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int x, y;
int ar[310];
int temp1[310];
int temp2[310];
bool cmp(int a, int b) { return a > b; }
int main() {
int i, l, r;
int res = -1000000000;
scanf(" %d %d", &n, &k);
for (i = 1; i <= n; i++) scanf(" %d", &ar[i]);
for (l = 1; l <= n; l++)
for (r = l; r <= n; r++) {
x = 0;
y = 0;
int top = 0;
for (i = 1; i <= n; i++) {
if (i < l || i > r)
temp1[++x] = ar[i];
else
temp2[++y] = ar[i];
}
sort(temp1 + 1, temp1 + x + 1, cmp);
sort(temp2 + 1, temp2 + y + 1);
for (i = 1; i <= min(min(y, k), x); i++) {
if (temp1[i] < temp2[i]) break;
swap(temp1[i], temp2[i]);
}
for (i = 1; i <= y; i++) top += temp2[i];
res = max(res, top);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1111;
const int inf = 0x7f7f7f7f;
const int mod = (int)(1e9 + 7);
const long long INF = 1LL << 50;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int mask = 65535;
int a[maxn];
int b[maxn];
int c[maxn];
int ma[maxn][maxn];
int mi[maxn][maxn];
int main() {
ios::sync_with_stdio(false);
int n, i, j, k, m;
int ans = -inf;
cin >> n >> m;
for (i = 0; i < n; ++i) {
cin >> a[i];
ans = max(ans, a[i]);
}
for (i = 0; i < n; ++i) {
int x, y, sum;
for (j = i; j < n; ++j) {
x = y = 0;
sum = 0;
for (k = 0; k < i; ++k) {
b[x++] = a[k];
}
for (k = j + 1; k < n; ++k) {
b[x++] = a[k];
}
for (k = i; k <= j; ++k) {
c[y++] = a[k];
sum += a[k];
}
sort(b, b + x);
sort(c, c + y);
int s = 0, t = 0, tmp;
ans = max(ans, sum);
for (k = 0; k < y && k < m && x - (k + 1) >= 0; ++k) {
s += c[k] - b[x - k - 1];
tmp = sum - s;
ans = max(ans, tmp);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, k1, j1, l, l1;
int num[205], num1[205], num2[205];
int i, max1, sum, j;
int s1, s2, t;
while (scanf("%d%d", &n, &k) != EOF) {
memset(num2, 0, sizeof(num2));
max1 = -10000;
for (i = 1; i <= n; i++) {
scanf("%d", &num[i]);
if (num[i] > max1) max1 = num[i];
}
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
k1 = 0;
j1 = 0;
sum = 0;
for (l = i; l <= j; l++) num1[k1++] = num[l];
for (l = 1; l < i; l++) num2[j1++] = num[l];
for (l = j + 1; l <= n; l++) num2[j1++] = num[l];
sort(num1, num1 + k1);
sort(num2, num2 + j1);
for (l1 = 1, t = 0; l1 <= k && j1 > 0 && l1 < k1 && k1 > 0; l1++) {
if (num2[j1 - 1] > num1[t]) {
num1[t] = num2[j1 - 1];
j1--;
t++;
}
}
for (l1 = 0; l1 < k1; l1++) sum += num1[l1];
max1 = max(max1, sum);
}
}
printf("%d\n", max1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 211;
multiset<int> in, out;
int n, t;
int v[maxn];
int main() {
long long res = -1e18;
scanf("%d%d", &n, &t);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]), out.insert(v[i]);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
in.clear();
out.clear();
for (int k = 1; k < i; k++) out.insert(v[k]);
for (int k = i; k <= j; k++) in.insert(v[k]);
for (int k = j + 1; k < n; k++) out.insert(v[k]);
for (int k = 0; k < t; k++) {
if (out.empty()) break;
if (*in.begin() < *out.rbegin()) {
int y = *out.rbegin();
out.erase(out.find(y));
int x = *in.begin();
in.erase(in.find(x));
in.insert(y), out.insert(x);
} else
break;
}
long long ans = 0;
for (auto it = in.begin(); it != in.end(); it++) ans += *it;
res = max(res, ans);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ar;
pair<int, int> r;
int a, n, k, sum[222], ans, vct, ect, h, iv, ie;
vector<int> v, e;
int main() {
ar.push_back(make_pair(-1111, 0));
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
ar.push_back(make_pair(a, i));
sum[i] = sum[i - 1] + a;
}
sort(ar.begin(), ar.end());
ans = 1 << 29;
ans = -ans;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
vct = ect = 0;
v.clear();
e.clear();
for (int y = 1; y <= n; y++) {
r = ar[y];
if (r.second >= j && r.second <= i) {
if (vct < k) {
v.push_back(r.first);
vct++;
} else
break;
}
}
for (int y = n; y >= 1; y--) {
r = ar[y];
if (r.second >= j && r.second <= i) {
;
} else {
if (ect < k) {
e.push_back(r.first);
ect++;
} else
break;
}
}
h = sum[i] - sum[j - 1];
int qw = h;
iv = 0;
ie = 0;
while (1) {
if (iv >= vct) break;
if (ie >= ect) break;
if (v[iv] > e[ie]) break;
h += e[ie];
h -= v[iv];
iv++;
ie++;
}
ans = max(ans, h);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[205];
long long b[205];
long long c[205];
bool cmp(long long a, long long b) { return a > b; }
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
long long ans = -0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
long long cnt1 = 0;
long long cnt2 = 0;
for (int i0 = 1; i0 <= n; i0++) {
if (i0 < i || i0 > j)
c[++cnt2] = a[i0];
else
b[++cnt1] = a[i0];
}
sort(b + 1, b + cnt1 + 1);
sort(c + 1, c + cnt2 + 1, cmp);
long long maxx = 0;
for (int i0 = 1; i0 <= cnt1; i0++) maxx += b[i0];
for (int i0 = 1; i0 <= cnt1 && i0 <= cnt2 && b[i0] < c[i0] && i0 <= k;
i0++)
maxx += c[i0] - b[i0];
ans = max(ans, maxx);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int always[205];
int chooseFrom[205];
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 = -10000000;
for (int l = 0; l < n; ++l)
for (int r = l + 1; r <= n; ++r) {
for (int i = l; i < r; ++i) always[i - l] = a[i];
int p = 0;
for (int i = 0; i < l; ++i) chooseFrom[p++] = a[i];
for (int i = r; i < n; ++i) chooseFrom[p++] = a[i];
sort(always, always + (r - l));
sort(chooseFrom, chooseFrom + p);
int sum = 0;
for (int i = 0; i < r - l; ++i) sum += always[i];
for (int i = 0; i < k && i < p && i < r - l; ++i) {
if (always[i] < chooseFrom[p - i - 1])
sum += chooseFrom[p - i - 1] - always[i];
}
if (sum > ans) ans = sum;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205];
int tmp[205], tsz;
int tmp1[205], tsz1;
int n, k;
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
int ans = -1000000000;
for (int l = 0; l < n; ++l) {
for (int r = l + 1; r <= n; ++r) {
int sum = 0;
tsz = tsz1 = 0;
for (int i = 0; i < n; ++i) {
if (i >= l && i < r) {
sum += a[i];
tmp1[tsz1++] = a[i];
} else
tmp[tsz++] = a[i];
}
sort(tmp, tmp + tsz);
sort(tmp1, tmp1 + tsz1);
reverse(tmp, tmp + tsz);
int q = min(min(k, tsz), tsz1);
for (int i = 0; i < q; ++i)
if (tmp1[i] < tmp[i]) sum += tmp[i] - tmp1[i];
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[205], sum[205], maxi = -1e9, cur, sz, ex, kkk, kk, c[205], s;
pair<int, int> b[205];
bool ReveRse(pair<int, int> b, pair<int, int> c) { return b.first > c.first; }
int main() {
scanf("%d%d", &n, &kk);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i] = a[i] + sum[i - 1];
if (a[i] > 0) {
b[++sz] = pair<int, int>(a[i], i);
}
}
sort(b + 1, b + sz + 1, ReveRse);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
ex = 0;
kkk = 0;
s = 0;
cur = sum[j] - sum[i - 1];
for (int k = 1; k <= sz && kkk < kk; k++) {
if (b[k].second < i || b[k].second > j) {
ex += b[k].first;
kkk++;
}
}
for (int k = i; k <= j; k++) {
if (a[k] < 0) c[++s] = a[k];
}
sort(c + 1, c + s + 1);
for (int k = 1; k <= min(s, kkk); k++) cur += (-1) * (c[k]);
maxi = max(maxi, cur + ex);
}
}
printf("%d\n", maxi);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.X << ", " << pair.Y << ")";
}
const int N = 1e3;
int a[N];
int main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
int n, k;
cin >> n >> k;
;
vector<pair<int, int> > vec;
for (int i = (1); i <= (n); ++i) {
cin >> a[i];
vec.push_back(make_pair(a[i], i));
}
int best = -N * N;
sort((vec).begin(), (vec).end());
for (int l = (1); l <= (n); ++l) {
for (int r = l; r <= n; r++) {
vector<int> smallest_from;
vector<int> largest_outside;
int sum = 0;
for (int i = (l); i <= (r); ++i) {
sum += a[i];
}
for (int i = int(vec.size()) - 1; i >= 0; i--) {
if (largest_outside.size() == k) {
break;
}
if (vec[i].second < l || vec[i].second > r) {
largest_outside.push_back(vec[i].first);
}
}
for (int i = 0; i < vec.size(); i++) {
if (smallest_from.size() == k) {
break;
}
if (vec[i].second >= l && vec[i].second <= r) {
smallest_from.push_back(vec[i].first);
}
}
int pos_out = 0, pos_from = 0;
while (pos_out < (int)largest_outside.size() &&
pos_from < (int)smallest_from.size() &&
smallest_from[pos_from] < largest_outside[pos_out]) {
sum += largest_outside[pos_out] - smallest_from[pos_from];
pos_from++;
pos_out++;
};
;
;
maxi(best, sum);
}
}
cout << best << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, res, e, a[222], s, ma, mi, k1, k2, kk;
bool c[222];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
e = 100000000;
res = -e;
for (int i = (1), _b = (n); i <= _b; i++) cin >> a[i];
for (int l = (1), _b = (n); l <= _b; l++)
for (int r = (l), _b = (n); r <= _b; r++) {
kk = k;
for (int o = (1), _b = (n); o <= _b; o++) c[o] = true;
s = 0;
for (int o = (l), _b = (r); o <= _b; o++) s = s + a[o];
while (kk--) {
ma = -e;
mi = e;
k1 = k2 = 0;
for (int o = (1), _b = (n); o <= _b; o++)
if (c[o] == true) {
if (l <= o && o <= r && mi > a[o]) {
mi = a[o];
k1 = o;
}
if ((o < l || o > r) && ma < a[o]) {
ma = a[o];
k2 = o;
}
}
res = max(res, s);
if (k1 == 0 || k2 == 0) break;
s = s - mi + ma;
res = max(res, s);
c[k1] = c[k2] = false;
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
scanf("%d%d", &n, &p);
int a[n], maxi = -3000000;
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++) {
vector<int> in, out;
for (int k = 0; k < n; k++) {
if (k >= i && k <= j)
in.push_back(a[k]);
else
out.push_back(a[k]);
}
sort(in.begin(), in.end());
sort(out.rbegin(), out.rend());
int sum = 0;
for (int k = 0; k < in.size(); k++) sum += in[k];
int ptr = 0, inptr = 0, outptr = 0;
while (ptr < p && inptr < in.size() && outptr < out.size() &&
in[inptr] < out[outptr]) {
sum += out[outptr] - in[inptr];
ptr++;
inptr++;
outptr++;
}
maxi = max(maxi, sum);
}
}
cout << maxi << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 210;
int N, K, A[NMax];
vector<int> S, S1;
int main() {
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; i++) scanf("%d", A + i);
int ans1 = -1000000;
for (int l = 1; l <= N; l++) {
for (int r = l; r <= N; r++) {
int ans = 0;
for (int i = l; i <= r; i++) ans += A[i];
S.clear();
S1.clear();
for (int i = l; i <= r; i++) S1.push_back(A[i]);
for (int i = 1; i < l; i++) S.push_back(A[i]);
for (int i = r + 1; i <= N; i++) S.push_back(A[i]);
sort(S.begin(), S.end());
sort(S1.begin(), S1.end());
int cnt = 0;
int p = S.size() - 1;
for (int i = 0; i < S1.size(); i++) {
if (p < 0) break;
if (S[p] > S1[i]) {
ans += S[p] - S1[i];
p--;
cnt++;
} else
break;
if (cnt >= K) break;
}
ans1 = max(ans1, ans);
}
}
printf("%d\n", ans1);
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
int a[222];
vector<int> kiss;
vector<int> miss;
int main() {
int n, m, ans, i, j, k;
while (cin >> n >> m) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
ans = -inf;
for (i = 1; i <= n; i++) {
int sum = 0;
for (j = i; j <= n; j++) {
kiss.clear();
miss.clear();
sum = 0;
for (k = i; k <= j; k++) {
kiss.push_back(a[k]);
sum += a[k];
}
for (k = 1; k <= n; k++) {
if (k < i || k > j) miss.push_back(a[k]);
}
sort(kiss.begin(), kiss.end());
sort(miss.begin(), miss.end());
ans = max(ans, sum);
for (k = 1; k <= m && k <= kiss.size() && k <= miss.size(); k++) {
sum -= kiss[k - 1];
sum += miss[miss.size() - k];
ans = max(ans, sum);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 205;
int n, K, a[nmax], b[nmax], c[nmax];
int main() {
cin >> n >> K;
for (int i = 1; i <= n; i++) cin >> a[i];
int sum = -100000000;
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
int idx1 = 0, idx2 = 0;
for (int i = l; i <= r; i++) b[++idx1] = a[i];
for (int i = 1; i < l; i++) c[++idx2] = a[i];
for (int i = r + 1; i <= n; i++) c[++idx2] = a[i];
sort(b + 1, b + idx1 + 1);
sort(c + 1, c + idx2 + 1);
int ans = 0;
int k = K;
for (int i = l; i <= r; i++) {
if (!idx2 || !k || b[idx1] >= c[idx2])
ans += b[idx1--];
else
ans += c[idx2--], --k;
}
sum = max(sum, ans);
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 201;
int n, m;
int a[maxn];
int ca[maxn], cb[maxn];
int ans = 0;
bool cmp1(int a, int b) { return a < b; }
bool cmp2(int a, int b) { return a > b; }
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 = 1; j <= i; j++) {
int temp = 0;
memset(ca, 0, sizeof(ca));
memset(cb, 0, sizeof(cb));
int l1 = 0;
int l2 = 0;
for (int k = 1; k <= n; k++) {
if (k >= j && k <= i)
ca[++l1] = a[k];
else
cb[++l2] = a[k];
}
sort(ca + 1, ca + 1 + l1, cmp2);
sort(cb + 1, cb + 1 + l2, cmp2);
int now = m;
int s1 = 1;
int s2 = 1;
for (int k = 1; k <= i - j + 1; k++) {
if (now && s2 <= l2) {
if (ca[s1] >= cb[s2])
temp += ca[s1++];
else
temp += cb[s2++], now--;
} else
temp += ca[s1++];
}
if (i == 1 && j == 1)
ans = temp;
else
ans = max(ans, temp);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, sol;
int a[205], b[205], c[205];
int main() {
scanf("%d%d", &n, &K);
for (int i = 0; i < n; i++) scanf("%d", a + i);
sol = a[0];
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int x = 0, y = 0, ac = 0;
for (int k = 0; k < n; k++) {
if (k >= i && k <= j)
b[x++] = a[k], ac += a[k];
else
c[y++] = a[k];
}
sort(b, b + x);
sort(c, c + y);
reverse(c, c + y);
for (int k = 0; k < n; k++) {
if (k >= x || k >= y || k >= K) break;
if (c[k] > b[k]) ac += c[k] - b[k];
}
sol = max(sol, ac);
}
}
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void checkMin(T& r, T v) {
if (r > v) r = v;
}
template <class T>
void checkMax(T& r, T v) {
if (r < v) r = v;
}
const int N = 210;
int d[N];
int main() {
int n, K;
scanf("%d%d", &n, &K);
for (int i = 0; i < n; ++i) scanf("%d", d + i);
int ans = -1 << 30;
for (int L = 0; L < n; ++L) {
for (int R = L; R < n; ++R) {
vector<int> va, vb;
for (int k = 0; k < n; ++k) {
if (k >= L && k <= R)
va.push_back(d[k]);
else
vb.push_back(d[k]);
}
sort(va.begin(), va.end());
sort(vb.begin(), vb.end());
int i = va.size() - 1;
int j = vb.size() - 1;
int ck = K;
int res = 0;
int ct = R - L + 1;
while (i >= 0 && j >= 0 && ct) {
if (vb[j] >= va[i] && ck) {
res += vb[j--];
ck--;
} else {
res += va[i--];
}
--ct;
}
while (ct && i >= 0) {
--ct;
res += va[i--];
}
while (ct && j >= 0 && ck) {
--ct;
res += vb[j--];
ck--;
}
checkMax(ans, res);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int a[N];
priority_queue<int> q;
priority_queue<int, vector<int>, greater<int> > v;
int main() {
int n, k, i, j, x, y, u, ret, temp;
cin >> n >> k;
for (i = 0; i < n; ++i) scanf("%d", &a[i]), q.push(a[i]);
ret = a[0];
for (i = 1; i <= n; ++i)
for (j = 0; j <= n - i; ++j) {
for (x = 0; x < j; ++x) q.push(a[x]);
for (x = j; x < j + i; ++x) v.push(a[x]);
for (x = j + i; x < n; ++x) q.push(a[x]);
for (x = 0; x < k; ++x) {
if (q.empty()) break;
u = q.top();
if (u > v.top())
v.pop(), v.push(u), q.pop();
else
break;
}
temp = 0;
while (!v.empty()) temp += v.top(), v.pop();
while (!q.empty()) q.pop();
ret = max(temp, ret);
}
cout << ret << endl;
}
|
#include <bits/stdc++.h>
double const EPS = 3e-8;
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
const int MX = 205;
int inp[MX];
int main() {
int n, NumofSwap;
n = ({
int a;
read(a);
a;
}),
NumofSwap = ({
int a;
read(a);
a;
});
int i, j, l, r;
for (int i = 0; i < n; i++)
inp[i] = ({
int a;
read(a);
a;
});
int ans = -(1 << 29);
for (l = 0; l < n; l++) {
for (r = l; r < n; r++) {
vector<int> In, Out;
for (i = 0; i < n; i++) {
if (i >= l && i <= r)
In.push_back(inp[i]);
else
Out.push_back(inp[i]);
}
sort(In.begin(), In.end());
sort(Out.begin(), Out.end());
int sum = 0;
for (i = 0; i < In.size(); i++) {
sum += In[i];
}
ans = max(ans, sum);
for (i = 0; i < min(NumofSwap, (int)min(In.size(), Out.size())); i++) {
sum -= In[i];
sum += Out[Out.size() - 1 - i];
ans = max(ans, sum);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, sum[205], ans = -0x8000000, a[205];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> sum[i];
for (int l = 1; l <= n; l++) {
for (int r = l; r <= n; r++) {
for (int i = 1; i <= n; i++) a[i] = sum[i];
for (int j = 1; j <= k; j++) {
int maxn = -0x80000000, minn = 0x7fffffff, maxni = 0, minni = 0;
for (int i = 1; i < l; i++)
if (maxn < a[i]) {
maxn = a[i];
maxni = i;
}
for (int i = l; i <= r; i++)
if (minn > a[i]) {
minn = a[i];
minni = i;
}
for (int i = r + 1; i <= n; i++)
if (maxn < a[i]) {
maxn = a[i];
maxni = i;
}
if (minn < maxn)
swap(a[minni], a[maxni]);
else
break;
}
int tot = 0;
for (int i = l; i <= r; i++) tot += a[i];
ans = max(ans, tot);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300], s[300][300], b[300];
int main() {
int N, K;
while (cin >> N >> K) {
for (int i = 1; i <= N; ++i) cin >> a[i];
for (int i = 1; i <= N; ++i) {
s[i][i] = a[i];
for (int j = i + 1; j <= N; ++j) {
s[i][j] = s[i][j - 1] + a[j];
}
}
int ans = s[1][N];
for (int i = 1; i <= N; ++i)
for (int j = i; j <= N; ++j) {
if (i == 1 && j == N) continue;
priority_queue<int, vector<int>, greater<int> > pa;
priority_queue<int> pb;
for (int k = 1; k <= N; ++k)
if (k < i || k > j)
pb.push(a[k]);
else
pa.push(a[k]);
for (int k = 0; k < K; ++k) {
if (pb.top() > pa.top()) {
int _b = pb.top();
pb.pop();
int _a = pa.top();
pa.pop();
pa.push(_b), pb.push(_a);
}
}
int cur = 0;
while (!pa.empty()) {
cur += pa.top();
pa.pop();
}
ans = max(ans, cur);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class otro {
public:
long x, i;
};
bool operator<(otro a, otro b) {
return (a.x < b.x || (a.x == b.x && a.i == b.i));
}
long arr[210], x, i, j, n, k, s, aux[210], res, r;
otro otr[210];
long ordena(long a, long b, long s) {
long i, cam = 0, j;
for (i = 0; i <= b - a; i++) aux[i] = arr[a + i];
sort(aux, aux + b - a + 1);
j = 0;
for (i = n - 1; i >= 0 && cam < k && j <= b - a; i--)
if (otr[i].i < a || otr[i].i > b) {
s += otr[i].x - aux[j];
if (s > res) res = s;
j++;
cam++;
}
return s;
}
int main() {
res = -200001;
scanf("%ld %ld", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%ld", &arr[i]);
otr[i - 1].i = i;
otr[i - 1].x = arr[i];
}
sort(otr, otr + n);
for (i = 1; i <= n; i++) {
s = 0;
for (j = i; j <= n; j++) {
s += arr[j];
r = ordena(i, j, s);
if (r > res) res = r;
}
}
printf("%ld\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 987654321;
int n, k, sol = -INF, A[210];
int calc(int lo, int hi) {
priority_queue<int> mmax, mmin;
int ret = -INF, sum = 0;
for (int i = 0; i < n; ++i) {
if (i < lo || hi < i) {
mmax.push(A[i]);
} else {
mmin.push(-A[i]);
sum += A[i];
}
}
ret = sum;
int repeat = k;
while (repeat--) {
if (mmax.size() && mmin.size()) {
int a = -mmin.top();
mmin.pop();
int b = mmax.top();
mmax.pop();
sum -= a;
sum += b;
ret = max(ret, sum);
mmax.push(a);
mmin.push(-b);
}
}
return ret;
}
int main() {
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) {
sol = max(sol, calc(i, j));
}
}
printf("%d\n", sol);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, mx;
int a[100010];
vector<int> v, v2, v3;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
mx = -(1000 * 1000 * 1000);
for (__typeof(n) i = (1); i <= (n); i++) {
cin >> a[i];
if (a[i] > mx) mx = a[i];
}
for (__typeof(n) i = (1); i <= (n); i++) {
v.clear();
for (__typeof(n) j = (i); j <= (n); j++) {
int sum = 0;
v.push_back(a[j]);
sort((v).begin(), (v).end());
v2.clear();
for (__typeof(n) l = (1); l <= (n); l++)
if (l < i || l > j) v2.push_back(a[l]);
sort((v2).begin(), (v2).end());
reverse((v2).begin(), (v2).end());
int kp = min(k, ((int)((v).size())));
kp = min(kp, ((int)((v2).size())));
v3.clear();
for (__typeof(kp - 1) i = (0); i <= (kp - 1); i++) {
v3.push_back(v[i]);
v3.push_back(v2[i]);
}
sort((v3).begin(), (v3).end());
reverse((v3).begin(), (v3).end());
for (__typeof(kp - 1) l = (0); l <= (kp - 1); l++) sum += v3[l];
for (__typeof(((int)((v).size())) - 1) l = (kp);
l <= (((int)((v).size())) - 1); l++)
sum += v[l];
if (sum > mx) mx = sum;
}
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, cnt, arr[203], maxi = INT_MIN;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> arr[i];
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
vector<int> v, v2;
for (int kk = 0; kk < n; ++kk) {
if (kk >= i && kk <= j)
v.push_back(arr[kk]);
else
v2.push_back(arr[kk]);
}
sort(v.begin(), v.end());
sort(v2.rbegin(), v2.rend());
int a = v.size(), b = v2.size();
for (int kk = 0; kk < min(k, min(a, b)); ++kk) v[kk] = max(v[kk], v2[kk]);
cnt = 0;
while (v.size()) cnt += v.back(), v.pop_back();
maxi = max(maxi, cnt);
}
}
cout << maxi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int MAX_N = (int)1e5 + 123;
const int N = 1e6 + 123;
const int INF = 1e9 + 1;
const long long INFL = 3e18 + 1;
const double pi = acos(-1.0);
const double eps = 1e-9;
int n, k, pref[201], a[201], ans = -INF;
int doing(int l, int r) {
vector<int> g, t;
for (int i = l; i <= r; i++) g.push_back(a[i]);
for (int i = 1; i <= l - 1; i++) t.push_back(a[i]);
for (int i = r + 1; i <= n; i++) t.push_back(a[i]);
sort(g.begin(), g.end());
sort(t.begin(), t.end());
reverse(t.begin(), t.end());
int cur = pref[r] - pref[l - 1];
int ans = cur;
int sum = 0, sum2 = 0;
for (int i = 1; i <= k; i++) {
if (sum >= g.size() || sum2 >= t.size()) break;
cur -= g[sum], sum++;
cur += t[sum2], sum2++;
ans = max(ans, cur);
}
return ans;
}
inline void boost() {
ios_base ::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
inline void solve() {
boost();
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pref[i] = pref[i - 1] + a[i];
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) ans = max(ans, doing(i, j));
cout << ans;
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[2007], neg, one, two, ans;
multiset<int> inside, outside;
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
ans = -2000000;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
for (int t = i; t <= j; t++) {
inside.insert(a[t]);
}
for (int t = 0; t < i; t++) {
outside.insert(a[t]);
}
for (int t = j + 1; t < n; t++) {
outside.insert(a[t]);
}
for (int t = 0; t < k; t++) {
if (!inside.size() || !outside.size()) break;
one = *inside.begin();
two = *outside.rbegin();
if (one < two) {
inside.insert(two);
outside.erase(outside.find(two));
outside.insert(one);
inside.erase(inside.find(one));
}
}
int tot = 0;
for (multiset<int>::iterator it = inside.begin(); it != inside.end();
it++) {
tot += *it;
}
ans = max(tot, ans);
inside.clear();
outside.clear();
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[205], ans = -99990000;
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++) {
vector<int> u, v;
for (int m = 0; m < n; m++) {
if (m >= i && m <= j)
u.push_back(a[m]);
else
v.push_back(a[m]);
}
sort(u.begin(), u.end());
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int ind = 0, t = k;
while (ind < u.size() && ind < v.size() && u[ind] < v[ind] && t > 0) {
int t2 = u[ind];
u[ind] = v[ind];
v[ind++] = t2;
t--;
}
int s = 0;
for (int i = 0; i < u.size(); i++) s += u[i];
if (s > ans) {
for (int i = 0; i < u.size(); i++) ans = s;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
vector<pair<int, int> > vp;
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
vp.push_back(make_pair(i, j));
}
}
vector<int> res;
int cnt;
for (int i = 0; i < vp.size(); i++) {
cnt = k;
vector<int> in_interval;
vector<int> out_interval;
for (int x = vp[i].first; x <= vp[i].second; x++) {
in_interval.push_back(v[x]);
}
sort(in_interval.begin(), in_interval.end());
for (int y = 0; y < vp[i].first; y++) {
out_interval.push_back(v[y]);
}
for (int z = vp[i].second + 1; z < n; z++) {
out_interval.push_back(v[z]);
}
sort(out_interval.rbegin(), out_interval.rend());
int c = 0;
while (cnt--) {
if (c < in_interval.size() && c < out_interval.size()) {
if (in_interval[c] < out_interval[c])
swap(in_interval[c], out_interval[c]);
else
break;
} else
break;
c++;
}
int sum = 0;
for (int m = 0; m < in_interval.size(); m++) sum += in_interval[m];
res.push_back(sum);
}
sort(res.rbegin(), res.rend());
cout << res[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[201], b[201], p[201], i, j, k, n, K, mx;
int main() {
scanf("%d%d", &n, &K);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
mx = -99999999;
for (i = 1; i <= n; i++) {
int s = 0;
for (j = i; j <= n; j++) {
s += a[j];
b[j - i + 1] = a[j];
sort(b + 1, b + j - i + 2);
int u = 0;
for (k = 1; k < i; k++) p[++u] = a[k];
for (k = j + 1; k <= n; k++) p[++u] = a[k];
sort(p + 1, p + u + 1);
int t = s;
for (k = 1; k <= min(min(K, u), j - i + 1); k++)
t = max(t, t + p[u - k + 1] - b[k]);
mx = max(mx, t);
}
}
printf("%d\n", mx);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e2;
int n, k, a[N], b[N];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int ans = -1e9;
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
int sum = 0;
for (int i = 0; i < n; i++) {
a[i] = b[i];
}
for (int i = l; i <= r; i++) {
sum += a[i];
}
for (int ll = 0; ll < k; ll++) {
int maxv = -20000;
int mino = 20000;
int posv = 0;
int poso = 0;
for (int kk = 0; kk < n; kk++) {
if (kk < l || kk > r) {
if (a[kk] > maxv) {
maxv = a[kk];
posv = kk;
}
} else {
if (a[kk] < mino) {
mino = a[kk];
poso = kk;
}
}
}
if (maxv > mino) {
sum = sum - mino + maxv;
int x = a[poso];
a[poso] = a[posv];
a[posv] = x;
}
}
if (sum > ans) ans = sum;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, kk;
int best = INT_MIN;
scanf("%d %d", &n, &kk);
vector<int> a(n);
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++) {
vector<int> in, out;
for (int k = 0; k < n; k++) {
if (k >= i && k <= j) {
in.push_back(a[k]);
} else {
out.push_back(a[k]);
}
}
sort(in.begin(), in.end());
sort(out.rbegin(), out.rend());
for (int k = 0; k < kk && k < in.size() && k < out.size(); k++) {
if (in[k] < out[k])
swap(in[k], out[k]);
else
break;
}
int total = 0;
for (int k = 0; k < in.size(); k++) total += in[k];
best = max(total, best);
}
}
printf("%d\n", best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int num[203], mark[203];
vector<int> s1, s2;
int cmp(int a, int b) { return a > b; }
int main() {
scanf("%d%d", &n, &k);
mark[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
mark[i] = mark[i - 1] + num[i];
}
int ma = -1000000000;
for (int l = 1; l <= n; l++) {
for (int r = l; r <= n; r++) {
int now = mark[r] - mark[l - 1];
s1.clear();
s2.clear();
for (int i = 1; i < l; i++) s1.push_back(num[i]);
for (int i = r + 1; i <= n; i++) s1.push_back(num[i]);
for (int i = l; i <= r; i++) s2.push_back(num[i]);
sort(s1.begin(), s1.end(), cmp);
sort(s2.begin(), s2.end());
int tmp = 0;
vector<int>::iterator it1, it2;
it1 = s1.begin();
it2 = s2.begin();
for (; it1 != s1.end() && it2 != s2.end() && *it1 > *it2 && tmp < k;
it1++, it2++) {
now = now - *it2 + *it1;
tmp++;
}
ma = max(ma, now);
}
}
printf("%d\n", ma);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int pp[210];
vector<int> n, m;
int main() {
int a, b;
while (cin >> a >> b) {
int ans = -inf;
for (int i = 1; i <= a; i++) cin >> pp[i];
for (int i = 1; i <= a; i++) {
for (int j = i; j <= a; j++) {
n.clear(), m.clear();
for (int t = 1; t <= a; t++) {
if (t <= j && t >= i)
n.push_back(pp[t]);
else
m.push_back(pp[t]);
}
sort(n.begin(), n.end());
sort(m.rbegin(), m.rend());
int b1 = b;
for (int t = 0; t < n.size() && t < m.size() && b1; t++) {
if (n[t] < m[t]) {
swap(n[t], m[t]);
b1--;
} else
break;
}
int sum = 0;
for (int t = 0; t < n.size(); t++) {
sum += n[t];
}
ans = max(sum, ans);
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int sp = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int i, j, x, n, m, k, k1;
cin >> n >> k1;
vector<long long int> v(n), psum(n);
for (auto &it : v) cin >> it;
partial_sum(v.begin(), v.end(), psum.begin());
long long int sum = INT_MIN, in = 0, out = 0, glosum = 0;
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
vector<long long int> s, ss;
for (k = 0; k < n; k++) {
if (k >= i && k <= j)
ss.emplace_back(v[k]);
else
s.emplace_back(v[k]);
}
sort(s.begin(), s.end(), greater<long long int>());
for (m = 0; m < min(k1, (long long int)s.size()); m++)
ss.emplace_back(s[m]);
sort(ss.begin(), ss.end(), greater<long long int>());
long long int var = accumulate(ss.begin(), ss.begin() + j - i + 1, 0LL);
sum = max(sum, var);
}
}
cout << sum << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[210], b[210], c[210];
bool cmp(int x, int y) { return x > y; }
int fin(int l, int r) {
int sum = 0, k1 = 0;
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
for (int i = l; i <= r; i++) {
b[k1++] = a[i];
sum += a[i];
}
if (l == 1 && r == n) {
return sum;
}
sort(b, b + k1);
int kk = 0;
for (int i = 1; i < l; i++) {
c[kk++] = a[i];
}
for (int i = r + 1; i <= n; i++) {
c[kk++] = a[i];
}
sort(c, c + kk, cmp);
for (int i = 0; i < k; i++) {
if (c[i] > b[i]) {
sum -= b[i];
sum += c[i];
} else {
break;
}
}
return sum;
}
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
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++) {
int t = fin(i, j);
ans = max(ans, t);
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, res = -10000000, arr[1000];
vector<int> a, b;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
a.clear();
b.clear();
for (int i = 1; i <= n; i++) {
if (l <= i and i <= r)
a.push_back(arr[i]);
else
b.push_back(arr[i]);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
int son = min(k, (int)min(a.size(), b.size()));
for (int i = 0; i <= son - 1; i++)
if (a[i] < b[i]) swap(a[i], b[i]);
res = max(res, accumulate(a.begin(), a.end(), 0));
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 222, inf = 1111111111;
int n, k, a[max_n];
int main() {
cin >> n >> k;
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) {
vector<int> v1, v2;
v1.clear();
v2.clear();
for (int i = l; i <= r; ++i) {
v1.push_back(a[i]);
}
for (int i = 0; i < l; ++i) {
v2.push_back(a[i]);
}
for (int i = r + 1; i < n; ++i) {
v2.push_back(a[i]);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
int poz1 = 0, poz2 = v2.size() - 1;
while (poz1 < k && poz1 < v1.size() && poz1 >= 0 && poz2 >= 0 &&
poz2 <= v2.size() && v1[poz1] < v2[poz2]) {
v1[poz1] = v2[poz2];
++poz1;
--poz2;
}
int sum = 0;
for (int i = 0; i < v1.size(); ++i) {
sum += v1[i];
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.