text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 1;
int g[N], m[N];
int n, k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
int x;
memset((g), (0), sizeof(g));
memset((m), (0), sizeof(m));
for (int i = (int)0; i < (int)n; ++i) cin >> x, ++g[x];
long long ans = 0;
for (int i = N - 1; i; --i) {
ans += g[i];
if (ans >= k) {
cout << i;
return 0;
}
g[i >> 1] += g[i] + m[i];
m[i - (i >> 1)] += g[i] + m[i];
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool desc_sort(const int& lhs, const int& rhs) { return lhs > rhs; }
bool desc_pii_sort(const pair<int, int>& lhs, const pair<int, int>& rhs) {
return lhs > rhs;
}
bool second_sort(const pair<int, int>& lhs, const pair<int, int>& rhs) {
pair<int, int> a, b;
a.first = lhs.second;
a.second = lhs.first;
b.first = rhs.second;
b.second = rhs.first;
return a < b;
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, set<T> second) {
os << "{ ";
for (auto s : second) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream& operator<<(ostream& os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
inline long long fast_expo(long long base, long long power,
long long modulo = 1e0) {
base %= modulo;
if (base < 0LL) base += modulo;
long long x = base, cnt = power, ans = 1LL;
while (cnt) {
if (cnt & 1LL) ans = (ans * x) % modulo;
x = (x * x) % modulo;
cnt >>= 1LL;
}
return ans;
}
inline long long inv(long long base, long long modulo = 1e0) {
return fast_expo(base, modulo - 2LL, modulo);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum < k) {
cout << "-1\n";
return 0;
}
sort(a, a + n, desc_sort);
int start = 1;
int end = 10000001;
while (start < end) {
int mid;
mid = (start + end) / 2;
vector<int> dp;
dp.assign(10000001, 0);
dp[0] = 0;
if (mid <= 1) dp[1] = 1;
for (int i = 2; i <= 10000000; i++) {
if (i < mid)
dp[i] = 0;
else if (i & 1) {
dp[i] = max(1, dp[i / 2] + dp[i / 2 + 1]);
} else {
dp[i] = max(1, dp[i / 2] + dp[i / 2]);
}
}
long long cc = 0;
for (int i = 0; i < n; i++) {
cc += dp[a[i]];
}
if (cc >= k) {
start = mid + 1;
} else {
end = mid;
}
}
cout << start - 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int a[10000002];
int b[10000002];
int i, j;
long long n, k;
long long num;
int main() {
scanf("%I64d%I64d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &j);
a[j]++;
}
for (i = 10000000; i > 0; i--) {
num += a[i];
a[i / 2] += a[i] + b[i];
b[i - i / 2] += a[i] + b[i];
if (num >= k) {
printf("%d", i);
return 0;
}
}
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 1;
int a[10000001], b[10000001];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k, sum = 0, p;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> p;
a[p]++;
}
for (long long int i = 1e7; i > 0; --i) {
sum += a[i];
a[i / 2] += a[i] + b[i];
b[i - i / 2] += a[i] + b[i];
if (sum >= k) {
cout << i << '\n';
return 0;
}
}
cout << "-1\n";
}
|
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
const int maxN = 1000005;
const int maxA = 10000005;
int n, k;
long long a[maxN];
int dp[maxA];
int main(int argc, char** argv) {
scanf("%d %d", &n, &k);
long long mx = 0, sum = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
mx = max(mx, a[i]);
sum += a[i];
}
if (sum < k) {
puts("-1");
return 0;
}
int l = 1, r = mx, m;
while (l < r) {
m = (l + r + 1) >> 1;
memset(dp, 0, sizeof(dp));
for (int i = m; i <= mx; i++) {
if ((i / 2) >= m)
dp[i] = dp[i / 2] + dp[i - (i / 2)];
else
dp[i] = 1;
}
long long cnt = 0;
for (int i = 0; i < n; i++) cnt += (long long)dp[a[i]];
if (cnt >= k)
l = m;
else
r = m - 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
const int maxN = 1000005;
const int maxA = 10000005;
int n, k;
int a[maxN];
long long cnt[maxA], sub[maxA];
int main(int argc, char** argv) {
scanf("%d %d", &n, &k);
int mx = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
mx = max(mx, a[i]);
cnt[a[i]]++;
}
long long tot = 0;
for (int i = mx; i; i--) {
tot += cnt[i] - sub[i];
cnt[i / 2] += cnt[i];
cnt[(i + 1) / 2] += cnt[i];
sub[(i + 1) / 2] += cnt[i];
if (tot >= k) {
printf("%d\n", i);
return 0;
}
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const INF = 1e9 + 7;
long long const LLINF = 1e18 + 7;
long double const eps = 1e-8;
long double const PI = acos(-1);
long long const p_hash = 257;
long long const mod = 1e9 + 9;
bool operator==(pair<int, int> const& a, pair<int, int> const& b) {
return (a.first == b.first && a.second == b.second);
}
pair<int, int> operator+(pair<int, int> const& a, pair<int, int> const& b) {
return {a.first + b.first, a.second + b.second};
}
pair<int, int> operator-(pair<int, int> const& a, pair<int, int> const& b) {
return {a.first - b.first, a.second - b.second};
}
long long dp[10000010];
long long a[2000020];
long long n, k;
inline bool ok(int const& nd) {
for (int i = nd; i <= 1e7; i++) {
if (i / 2 >= nd)
dp[i] = dp[i / 2] + dp[i - i / 2];
else
dp[i] = 1;
}
long long res = 0;
for (int i = 0; i < n; i++)
if (a[i] >= nd) res += dp[a[i]];
return (res >= k);
}
int main() {
scanf("%lld%lld", &n, &k);
long long mass = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
mass += a[i];
}
if (mass < k) {
printf("-1");
return 0;
}
cerr << ok(7);
int l = 0, r = 1e7 + 1;
while (r - l > 1) {
int m = (l + r) / 2;
if (ok(m))
l = m;
else
r = m;
}
if (ok(r))
printf("%d", r);
else
printf("%d", l);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long n, m, a, b, c, k, temp, x, y;
const int MAXN = 100000 + 11;
inline long long max(long long a, long long b) { return ((a > b) ? a : b); }
inline long long min(long long a, long long b) { return ((a > b) ? b : a); }
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
inline vector<long long> read(int n) {
vector<long long> v(n);
for (int i = 0; i < v.size(); i++) cin >> v[i];
return v;
}
long long dp[20000001];
bool check(const long long &mid, const vector<long long> &v) {
if (mid == 0) return true;
for (int i = 0; i < mid; i++) dp[i] = 0;
for (int i = mid; i < 2 * mid; i++) dp[i] = 1;
for (int i = 2 * mid; i < 10000001; i++) dp[i] = dp[i / 2] + dp[(i + 1) / 2];
long long sum = 0;
for (int i = 0; i < v.size(); i++) {
sum += dp[v[i]];
if (sum >= k) return true;
}
return false;
}
void solveforthiscase(const int &test) {
cin >> n >> k;
vector<long long> v = read(n);
long long l = 0, r = 1e7, mid;
int loop = 0;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid, v))
l = mid + 1;
else
r = mid - 1;
}
if (!r) r = -1;
cout << r;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t start, end;
start = clock();
int test = 1;
for (int i = 1; i <= test; i++) solveforthiscase(i);
end = clock();
long double t_t = (long double)(end - start) / (long double)(CLOCKS_PER_SEC);
if (false) cerr << (long double)t_t * 1000 << " ms ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int X = 1e7 + 5;
int n, k;
int amt[X], inc[X];
void solve() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
amt[x]++;
}
for (int i = 0; i < X; i++) {
inc[i] = amt[i];
}
long long cur_cnt = 0;
for (int i = X - 1; i >= 1; i--) {
cur_cnt += inc[i];
if (cur_cnt >= k) {
cout << i << '\n';
return;
}
int a = i / 2;
int b = a + (i & 1);
amt[a] += amt[i];
amt[b] += amt[i];
inc[a] += amt[i];
}
cout << -1 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
for (int t = 1; t <= T; t++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 5;
int a[N], b[N];
long long n = 0, k = 0;
int main() {
scanf("%I64d%I64d", &n, &k);
int t = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &t);
++a[t];
}
long long cnt = 0;
for (int i = 1e7; i >= 1; --i) {
cnt += 1LL * a[i];
if (cnt >= k) {
printf("%d", i);
return 0;
}
a[i / 2] += a[i] + b[i];
b[i - i / 2] += a[i] + b[i];
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int n, k;
int arr[MAXN];
vector<int> pai[MAXN];
int deets[10000015];
int get(int a) { return deets[a]; }
int main() {
deets[0] = -1;
for (int i = 1; i <= 10000000; i++) {
if (!(i & (i - 1)))
deets[i] = deets[i - 1] + 1;
else
deets[i] = deets[i - 1];
}
scanf("%d %d\n", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
for (int i = 1; i <= n; i++) {
int kt = arr[i];
int num0 = 1, num1 = 0;
while (1) {
pai[i].push_back(num1);
if (kt == 1) break;
if (kt & 1) {
int cp_num0 = num0;
int cp_num1 = num1;
kt /= 2;
num0 = cp_num0;
num1 = cp_num0 + 2 * cp_num1;
} else {
int cp_num0 = num0;
int cp_num1 = num1;
kt /= 2;
num0 = 2 * cp_num0 + cp_num1;
num1 = cp_num1;
}
}
reverse(pai[i].begin(), pai[i].end());
}
int lo = 0, hi = 1e7;
while (hi > lo) {
int mid = (hi + lo + 1) / 2;
long long tot = 0;
for (int i = 1; i <= n; i++) {
if (mid > arr[i]) continue;
if (mid == 1) {
tot += arr[i];
continue;
}
int maxi = 1 << (get(arr[i] / mid));
int lak = get(arr[i] / (mid - 1));
int ke = pai[i][pai[i].size() - 1 - lak];
maxi = max(maxi, ke);
tot += maxi;
}
if (tot >= k) {
lo = mid;
} else
hi = mid - 1;
}
if (lo == 0)
cout << -1 << '\n';
else
cout << lo << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5, M = 1e7 + 5;
long long n, a[N], k, dp[M];
int main() {
scanf("%I64d %I64d", &n, &k);
long long sgm = 0, mx = 0;
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
sgm += (long long)a[i];
dp[a[i]]++;
mx = max(mx, a[i]);
}
if (sgm < k) {
printf("-1");
return 0;
}
long long ans = 0;
for (long long i = mx; i >= 1; i--) {
ans += dp[i];
if ((i << 1ll) <= mx) ans -= dp[i << 1ll];
if ((i << 1ll) - 1 <= mx && i > 1) ans -= dp[(i << 1ll) - 1];
if (ans >= k) {
printf("%I64d", i);
return 0;
}
dp[i >> 1ll] += dp[i];
dp[(i + 1) >> 1ll] += dp[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[10000005];
long long use[10000005];
int main() {
long long sum = 0;
long long n, k, max = 0, totol = 0, temp;
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &temp);
a[temp]++;
max = max > temp ? max : temp;
}
for (long long i = max; i >= 1; i--) {
totol += a[i];
totol -= use[i];
if (totol >= k) {
cout << i << endl;
return 0;
} else {
a[i >> 1] += a[i];
a[(i + 1) >> 1] += a[i];
use[(i + 1) >> 1] += a[i];
}
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 5;
long long n, k, a[N], R[N], counter, x;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> x, a[x]++;
for (int i = N - 1; i >= 1; i--) {
counter += a[i];
a[i / 2] += a[i] + R[i];
R[i / 2 + i % 2] += a[i] + R[i];
if (counter >= k) return cout << i, 0;
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, K;
int A[1010101];
long long cnt[10101010];
long long cnt2[10101010];
int solve() {
for (int i = 0; i < N; i++) cnt[A[i]]++;
long long sm = 0;
for (int i = 10101010; i >= 1; i--) {
sm += cnt[i];
if (K <= sm) return i;
cnt[i] += cnt2[i];
cnt2[(i + 1) / 2] += cnt[i];
cnt[i / 2] += cnt[i];
}
return -1;
}
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) scanf("%d", &A[i]);
sort(A, A + N, greater<int>());
cout << solve() << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class htpe, class cmp>
using heap = priority_queue<htpe, vector<htpe>, cmp>;
template <class htpe>
using min_heap = heap<htpe, greater<htpe> >;
template <class htpe>
using max_heap = heap<htpe, less<htpe> >;
const int INF = 1791791791;
const long long INFLL = 1791791791791791791ll;
template <size_t buf_size>
class FastInput {
char buf[buf_size];
size_t clen = 0;
size_t cpos = 0;
FILE *infl;
bool cl = false;
public:
inline bool isEof() {
if (cpos == clen) {
cpos = 0;
clen = fread(buf, 1ul, buf_size, infl);
return clen == 0;
} else
return false;
}
inline int nextChar() { return isEof() ? -1 : buf[cpos++]; }
inline bool seekEof() {
int res = nextChar();
while (res == ' ' || res == '\n') res = nextChar();
if (res == -1) return true;
assert(cpos != 0);
cpos--;
return false;
}
inline char readChar() {
int res = nextChar();
while (res == ' ' || res == '\n') res = nextChar();
assert(res != -1);
return (char)res;
}
inline void copyWord(char *wbuf) {
int w = readChar();
while (w != ' ' && w != '\n' && w != -1) {
*(wbuf++) = (char)w;
w = nextChar();
}
}
inline string readString() {
int w = readChar();
std::string res;
while (w != ' ' && w != '\n' && w != -1) {
res.push_back((char)w);
w = nextChar();
}
return res;
}
template <class rint_t = int>
rint_t readInt() {
int sgn = readChar();
rint_t res = 0, b = 1;
if (sgn == '-')
b = -1;
else if (sgn != '+')
res = sgn - '0';
int w = nextChar();
while (w != ' ' && w != '\n' && w != -1) {
res *= 10;
res += w - '0';
w = nextChar();
}
return b * res;
}
FastInput(const string &filename = "stdin") {
cl = filename != "stdin";
if (filename == "stdin")
infl = stdin;
else
infl = fopen(filename.c_str(), "r");
}
~FastInput() {
if (cl) fclose(infl);
}
};
template <size_t buf_size>
class FastOutput {
char buf[buf_size];
int cpos = 0;
FILE *outfl;
bool lf, cl;
public:
inline void flush() {
fwrite(buf, cpos, 1, outfl);
cpos = 0;
}
inline void putChar(char c) {
if (cpos == buf_size) flush();
buf[cpos++] = c;
}
inline void putBuf(const char *to_w) {
while (*to_w != 0) putChar(*(to_w++));
}
inline void writeString(const string &s, const char *after = " ") {
putBuf(s.c_str());
putBuf(after);
}
template <class rint_t>
inline void writeInt(rint_t x, const char *after = " ") {
char to_w[100];
int cur = 0;
if (x == 0)
putBuf("0");
else {
if (x < 0) {
putChar('-');
x = -x;
}
while (x > 0) {
to_w[cur++] = (x % 10) + '0';
x /= 10;
}
reverse(to_w, to_w + cur);
to_w[cur] = 0;
putBuf(to_w);
}
putBuf(after);
}
inline void writeEndl() { putChar('\n'); }
FastOutput(const string &filename = "stdout", bool lflush = true) {
lf = lflush;
cl = filename != "stdout";
if (filename == "stdout")
outfl = stdout;
else
outfl = fopen(filename.c_str(), "w");
memset(buf, 0, sizeof(buf));
}
~FastOutput() {
flush();
if (cl) fclose(outfl);
}
};
FastInput<4096> fin;
FastOutput<4096> fout;
const int maxb = 1e7 + 179;
long long cnum[2 * maxb];
int main() {
int n = fin.readInt();
int k = fin.readInt();
for (int i = 0; i < ((int)(n)); ++i) cnum[fin.readInt()]++;
long long csum = 0;
for (int ans = maxb - 1; ans >= 1; ans--) {
csum += cnum[ans];
for (int i = 2 * ans + 1; i >= 2 * ans; i--) {
cnum[i / 2] += cnum[i];
cnum[(i + 1) / 2] += cnum[i];
csum -= cnum[i];
if (i / 2 >= ans) csum += cnum[i];
if ((i + 1) / 2 >= ans) csum += cnum[i];
}
if (csum >= k) {
fout.writeInt(ans, "\n");
return 0;
}
}
fout.writeInt(-1, "\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e7 + 5;
long long sum[N], suffix[2 * N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
sum[x] += 1;
}
for (long long i = N; i >= 2; i--) {
sum[i / 2] += sum[i];
sum[(i + 1) / 2] += sum[i];
}
for (int i = N; i >= 2; i--) {
suffix[i] = suffix[i + 1] + sum[i];
if (suffix[i] - suffix[i * 2 - 1] >= k) {
printf("%d\n", i);
return 0;
}
}
if (sum[1] >= k)
puts("1");
else
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, ma;
int A[1000005];
int dp[10000005];
bool ok(int val) {
int nr = 0;
for (int i = 1; i <= ma; i++) {
dp[i] = 0;
if (val <= i) dp[i] = 1;
if (i % 2)
dp[i] = max(dp[i], dp[i >> 1] + dp[(i + 1) >> 1]);
else
dp[i] = max(dp[i], 2 * dp[i >> 1]);
}
for (int i = 1; i <= N; i++) {
nr += dp[A[i]];
if (nr >= K) return 1;
}
return 0;
}
int main() {
bool notthesamecode = 1;
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> A[i];
ma = max(ma, A[i]);
}
int st = 0, dr = (1e7 + 10), mid;
while (st < dr) {
mid = (st + dr + 1) / 2;
if (ok(mid))
st = mid;
else
dr = mid - 1;
}
if (!st)
cout << -1;
else
cout << st;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int M = 1e7 + 5;
int n, k, mx;
int a[N], cnt[M];
int check(int x) {
for (int i = 0; i < x; i++) cnt[i] = 0;
cnt[x] = 1;
for (int i = x + 1; i <= mx; i++) {
cnt[i] = 1;
int couldBe = cnt[i / 2] + cnt[i / 2 + (i % 2)];
cnt[i] = max(cnt[i], couldBe);
}
long long have = 0;
for (int i = 1; i <= n; i++) {
have += cnt[a[i]];
if (have >= k) return 1;
}
return 0;
}
int binsearch(int lo, int hi) {
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
if (check(mid))
lo = mid;
else
hi = mid - 1;
}
return lo;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
long long sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
mx = max(mx, a[i]);
}
if (sum < k) {
cout << -1;
return 0;
}
int ans = binsearch(1, mx);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int ex[] = {1, -1, 0, 0};
int wye[] = {0, 0, 1, -1};
using namespace std;
int n, k, a[1000005], mp[10000005];
inline int process(int cur, int num) {
if (mp[cur] > -1) return mp[cur];
if (cur < num) return 0;
int num1 = cur >> 1, num2 = (cur + 1) >> 1;
if ((num1 < num && num2 < num) || cur == num) return 1;
return mp[cur] = process(num1, num) + process(num2, num);
}
bool check(int num) {
long long int lol, pop = 0;
memset(mp, -1, sizeof(mp));
for (long long int i = 1; i <= n; i++) {
if (a[i] < num) break;
if (num == 1)
lol = 1ll * a[i];
else
lol = 1ll * process(a[i], num);
pop += lol;
}
if (pop >= 1ll * k)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1, greater<int>());
int lo = 1, hi = 1e7 + 5, mid, an = -1;
while (lo <= hi) {
mid = (lo + hi) >> 1;
if (check(mid)) {
an = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
printf("%d\n", an);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
template <typename first, typename second>
ostream& operator<<(ostream& os, const pair<first, second>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream& operator<<(ostream& os, const map<first, second>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello&... rest) {
cerr << arg << ' ';
faltu(rest...);
}
const int mx = 1e7 + 5;
int n, k;
long long b[mx], c[mx];
int lim = 1e7 + 3;
bool check(int key) {
for (int i = key; i <= lim; ++i) c[i] = b[i];
long long cnt = 0;
for (int i = lim; i >= key; --i) {
int x = i / 2, y = i - x;
if (cnt >= k) return 1;
if ((x < key && y < key) || i == 1) {
cnt += c[i];
continue;
}
c[x] += c[i];
c[y] += c[i];
}
return (cnt >= k);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
long long sum = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
sum += x;
++b[x];
}
if (sum < k) {
cout << -1 << '\n';
return 0;
}
int lo = 1, hi = lim, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (check(mid))
lo = mid + 1;
else
hi = mid - 1;
}
if (hi == 0) hi = -1;
cout << hi << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1000004];
long long int k;
int dp[10000005];
inline int func(int x, int div) {
if (dp[div] != -1) return dp[div];
if (div < x) return 0;
int ret = 0, p1, p2;
p1 = div >> 1;
p2 = (div + 1) >> 1;
if ((p1 < x && p2 < x) || div == x) return 1;
return dp[div] = func(x, p1) + func(x, p2);
}
bool valid(int x) {
int i;
long long int tot = 0LL;
memset(dp, -1, sizeof(dp));
for (i = n; i >= 1; i--) {
if (a[i] < x) break;
long long int temp = func(x, a[i]);
tot += temp;
}
return tot >= k;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int i;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int low = 1, high = (long long int)1e7 + 1, mid, ans = -1;
while (low <= high) {
mid = (low + high) >> 1;
if (valid(mid)) {
ans = mid;
}
if (valid(mid)) {
low = mid + 1;
} else if (!valid(mid)) {
high = mid - 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 2e5 + 10;
long long a[10000010];
long long n, k;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
long long sum = 0, mx = 0;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
a[x]++;
sum += x;
mx = max(mx, x);
}
if (sum < k) {
cout << -1 << endl;
return 0;
}
int ans = 1;
int cnt = n;
while (ans <= mx) {
if (a[mx] == 0) {
mx--;
continue;
} else {
while (cnt - a[ans] >= k) {
cnt -= a[ans];
ans++;
}
if (mx % 2 == 0) {
cnt -= a[mx];
if (ans <= mx / 2) cnt += 2 * a[mx];
a[mx / 2] += 2 * a[mx];
a[mx] = 0;
} else {
cnt -= a[mx];
if (ans <= mx / 2) cnt += a[mx];
if (ans <= mx / 2 + 1) cnt += a[mx];
a[mx / 2] += a[mx];
a[mx / 2 + 1] += a[mx];
a[mx] = 0;
}
mx--;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void out(int a) { printf("%d\n", a); }
inline void out(int a, int b) { printf("%d %d\n", a, b); }
inline void outf(double a) { printf("%3.lf\n", a); }
inline void outf(double a, double b) { printf("%3.lf %3.lf\n", a, b); }
inline void base() {
ios_base::sync_with_stdio(false);
cin.tie(0);
}
long long data[1000005];
long long dp[10000005];
long long calc(long long a, long long bs) {
if (a < bs) return 0;
if (a == bs) return 1;
if (dp[a] != -1) return dp[a];
long long ret = 0;
if (a % 2 == 0) {
ret = 2 * calc(a / 2, bs);
if (ret == 0) return dp[a] = 1;
} else {
ret = calc(a / 2, bs) + calc(a / 2 + 1, bs);
if (ret == 0) return dp[a] = 1;
}
return dp[a] = ret;
}
long long n, k;
int find(int x) {
int l = 0, r = n;
while (l < r) {
int m = (l + r) / 2;
if (data[m] < x)
l = m + 1;
else
r = m;
}
return l;
}
int main() {
scanf("%I64d%I64d", &n, &k);
long long l = 0, r = 0;
for (int(i) = 0; (i) < (n); (i)++) {
scanf("%I64d", &data[i]);
r += data[i];
}
sort(data, data + n);
r /= k;
r++;
if (r == 1) {
cout << -1 << endl;
return 0;
}
while (l < r) {
long long mid = (l + r) / 2;
int j = find(mid);
long long tot = 0;
memset(dp, -1, sizeof dp);
for (int(i) = (j); (i) <= (n - 1); (i)++) {
tot += calc(data[i], mid);
if (tot >= k) break;
}
if (tot >= k)
l = mid + 1;
else
r = mid;
}
if (l == 1)
printf("-1\n");
else
printf("%I64d\n", l - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace io {
template <typename First, typename Second>
ostream &operator<<(ostream &os, const pair<First, Second> &p) {
return os << p.first << " " << p.second;
}
template <typename First, typename Second>
ostream &operator<<(ostream &os, const map<First, Second> &mp) {
for (auto it : mp) {
os << it << endl;
}
return os;
}
template <typename First>
ostream &operator<<(ostream &os, const vector<First> &v) {
bool space = false;
for (First x : v) {
if (space) os << " ";
space = true;
os << x;
}
return os;
}
template <typename First>
ostream &operator<<(ostream &os, const set<First> &st) {
bool space = false;
for (First x : st) {
if (space) os << " ";
space = true;
os << x;
}
return os;
}
template <typename First>
ostream &operator<<(ostream &os, const multiset<First> &st) {
bool space = false;
for (First x : st) {
if (space) os << " ";
space = true;
os << x;
}
return os;
}
template <typename First, typename Second>
istream &operator>>(istream &is, pair<First, Second> &p) {
return is >> p.first >> p.second;
}
template <typename First>
istream &operator>>(istream &is, vector<First> &v) {
for (First &x : v) {
is >> x;
}
return is;
}
long long fastread() {
char c;
long long d = 1, x = 0;
do c = getchar();
while (c == ' ' || c == '\n');
if (c == '-') c = getchar(), d = -1;
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return d * x;
}
static bool sep = false;
using std::to_string;
string to_string(bool x) { return (x ? "true" : "false"); }
string to_string(const string &s) { return "\"" + s + "\""; }
string to_string(const char *s) { return "\"" + string(s) + "\""; }
string to_string(const char &c) {
string s;
s += c;
return "\'" + s + "\'";
}
template <typename First, typename Second>
string to_string(pair<First, Second> p) {
return "{" + to_string(p.first) + ", " + to_string(p.second) + "}";
}
template <typename Type>
string to_string(vector<Type> v) {
bool sep = false;
string s = "[";
for (Type x : v) {
if (sep) s += ", ";
sep = true;
s += to_string(x);
}
s += "]";
return s;
}
template <typename Collection>
string to_string(Collection collection) {
bool sep = false;
string s = "{";
for (auto x : collection) {
if (sep) s += ", ";
sep = true;
s += to_string(x);
}
s += "}";
return s;
}
void print() {
cerr << endl;
sep = false;
}
template <typename First, typename... Other>
void print(First first, Other... other) {
if (sep) cerr << " | ";
sep = true;
cerr << to_string(first);
print(other...);
}
} // namespace io
using namespace io;
const long long INF = (long long)1e9 + 10;
const long long MAXN = (long long)1e6 + 10;
long long cnt[MAXN * 10 + 10], a[MAXN];
long long f(long long m, long long k, long long n) {
if (m <= 0) return 0;
for (long long i = 1; i <= n; i++) {
cnt[a[i]]++;
}
long long ret = 0;
for (long long i = 10 * MAXN; i >= m; i--) {
if (i / 2 >= m) {
cnt[i / 2] += cnt[i];
cnt[(i + 1) / 2] += cnt[i];
} else {
ret += cnt[i];
if (ret >= k) return 1;
}
}
return 0;
}
void solution(istream &cin, ostream &cout, const long long &test_case) {
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
long long l = -1, r = MAXN * 10;
while (r - l > 1) {
long long m = (l + r) >> 1;
if (f(m, k, n)) {
l = m;
} else {
r = m;
}
fill(cnt, cnt + MAXN * 10, 0);
}
cout << l << endl;
}
int32_t main() {
ios::sync_with_stdio(0);
long long t = 1;
for (long long i = 1; i <= t; i++) solution(cin, cout, i);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1e6 + 10);
const int M = (1e7 + 10);
int num[N];
int n, k;
int maxx;
long long check[M];
long long sum = 0;
int main() {
ios::sync_with_stdio(false);
bool flag = false;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> num[i];
check[num[i]]++;
maxx = max(num[i], maxx);
}
for (int i = maxx; i > 0; i--) {
sum += check[i];
if (i * 2 <= maxx) {
sum -= check[i * 2];
}
if (i * 2 - 1 <= maxx && i != 1) {
sum -= check[i * 2 - 1];
}
if (sum >= k) {
cout << i << endl;
flag = true;
break;
}
check[i / 2] += check[i];
check[(i + 1) / 2] += check[i];
}
if (!flag) cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
char s[200];
vector<int> pos[3];
int dp[200][200][200][3];
int main() {
int n = 0;
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == 'V')
pos[0].push_back(i);
else if (s[i] == 'K')
pos[1].push_back(i);
else
pos[2].push_back(i);
}
for (int s = 1; s <= n; s++) {
for (int i = 0; i <= pos[0].size() && i <= s; i++) {
for (int j = 0; j + i <= s && j <= pos[1].size(); j++) {
int k = s - i - j;
if (k > pos[2].size()) continue;
for (int t = 0; t < 3; t++) dp[i][j][k][t] = INF;
if (i > 0) {
int v = 0;
int p = pos[0][i - 1];
for (int y = 0; y < j; y++)
if (p < pos[1][y]) v++;
for (int z = 0; z < k; z++)
if (p < pos[2][z]) v++;
for (int t = 0; t < 3; t++)
dp[i][j][k][0] = min(dp[i - 1][j][k][t], dp[i][j][k][0]);
dp[i][j][k][0] += v;
}
if (j > 0) {
int v = 0;
int p = pos[1][j - 1];
for (int x = 0; x < i; x++)
if (p < pos[0][x]) v++;
for (int z = 0; z < k; z++)
if (p < pos[2][z]) v++;
for (int t = 1; t < 3; t++)
dp[i][j][k][1] = min(dp[i][j - 1][k][t], dp[i][j][k][1]);
dp[i][j][k][1] += v;
}
if (k > 0) {
int v = 0;
int p = pos[2][k - 1];
for (int x = 0; x < i; x++)
if (p < pos[0][x]) v++;
for (int y = 0; y < j; y++)
if (p < pos[1][y]) v++;
for (int t = 0; t < 3; t++)
dp[i][j][k][2] = min(dp[i][j][k - 1][t], dp[i][j][k][2]);
dp[i][j][k][2] += v;
}
}
}
}
int ans = INF;
for (int i = 0; i < 3; i++)
ans = min(ans, dp[pos[0].size()][pos[1].size()][pos[2].size()][i]);
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int Pow(long long int a, long long int b, long long int md,
long long int ans = 1) {
for (; b; b >>= 1, a = a * a % md)
if (b & 1) ans = ans * a % md;
return ans % md;
}
const long long int MAXN = 110;
const long long int INF = 1e18;
const long long int MOD = 1e9 + 7;
long long int dp[MAXN][MAXN][MAXN][3], A[MAXN], n;
vector<long long int> pos[3];
char C[MAXN];
int main() {
scanf("%lld%s", &n, C + 1);
for (long long int i = 1; i <= n; i++) {
if (C[i] == 'V')
pos[0].push_back(i);
else if (C[i] == 'K')
pos[1].push_back(i);
else
pos[2].push_back(i);
}
fill(&dp[0][0][0][0], &dp[0][0][0][0] + MAXN * MAXN * MAXN * 3, INF);
dp[0][0][0][0] = 0;
for (long long int i = 0; i <= (long long int)pos[0].size(); i++) {
for (long long int j = 0; j <= (long long int)pos[1].size(); j++) {
for (long long int k = 0; k <= (long long int)pos[2].size(); k++) {
for (long long int t = 0; t < 2; t++) {
if (i + 1 <= (long long int)pos[0].size()) {
long long int c1 =
max(lower_bound((pos[0]).begin(), (pos[0]).end(), pos[0][i]) -
pos[0].begin() - i,
0LL);
long long int c2 =
max(lower_bound((pos[1]).begin(), (pos[1]).end(), pos[0][i]) -
pos[1].begin() - j,
0LL);
long long int c3 =
max(lower_bound((pos[2]).begin(), (pos[2]).end(), pos[0][i]) -
pos[2].begin() - k,
0LL);
dp[i + 1][j][k][1] =
min(dp[i + 1][j][k][1], dp[i][j][k][t] + c1 + c2 + c3);
}
if (j + 1 <= (long long int)pos[1].size() && !t) {
long long int c1 =
max(lower_bound((pos[0]).begin(), (pos[0]).end(), pos[1][j]) -
pos[0].begin() - i,
0LL);
long long int c2 =
max(lower_bound((pos[1]).begin(), (pos[1]).end(), pos[1][j]) -
pos[1].begin() - j,
0LL);
long long int c3 =
max(lower_bound((pos[2]).begin(), (pos[2]).end(), pos[1][j]) -
pos[2].begin() - k,
0LL);
dp[i][j + 1][k][0] =
min(dp[i][j + 1][k][0], dp[i][j][k][t] + c1 + c2 + c3);
}
if (k + 1 <= (long long int)pos[2].size()) {
long long int c1 =
max(lower_bound((pos[0]).begin(), (pos[0]).end(), pos[2][k]) -
pos[0].begin() - i,
0LL);
long long int c2 =
max(lower_bound((pos[1]).begin(), (pos[1]).end(), pos[2][k]) -
pos[1].begin() - j,
0LL);
long long int c3 =
max(lower_bound((pos[2]).begin(), (pos[2]).end(), pos[2][k]) -
pos[2].begin() - k,
0LL);
dp[i][j][k + 1][0] =
min(dp[i][j][k + 1][0], dp[i][j][k][t] + c1 + c2 + c3);
}
}
}
}
}
printf("%lld\n",
min(dp[(long long int)pos[0].size()][(long long int)pos[1].size()]
[(long long int)pos[2].size()][0],
dp[(long long int)pos[0].size()][(long long int)pos[1].size()]
[(long long int)pos[2].size()][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 80;
int n;
vector<int> a[3];
int cnt[MAXN][3];
int f[MAXN][MAXN][MAXN][3];
int solve(int i, int j, int k, int last) {
if (i + j + k == 0) return 1;
int b[3] = {i, j, k};
if (b[last] <= 0) return INT_MAX;
if (f[i][j][k][last]) return f[i][j][k][last];
int ret = INT_MAX >> 1;
--b[last];
for (int li = last == 1; li < 3; ++li)
ret = min(ret, solve(b[0], b[1], b[2], li) - 1);
int *loc = cnt[a[last][b[last]]];
ret += abs(loc[0] - i) + abs(loc[1] - j) + abs(loc[2] - k);
return f[i][j][k][last] = ret + 1;
}
char s[MAXN];
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; ++i) {
copy_n(cnt[i - 1], 3, cnt[i]);
int t = s[i] == 'V' ? 0 : s[i] == 'K' ? 1 : 2;
++cnt[i][t];
a[t].push_back(i);
}
int ans = INT_MAX;
for (int i = 0; i < 3; ++i)
ans = min(ans, solve(a[0].size(), a[1].size(), a[2].size(), i));
printf("%d\n", ans - 1 >> 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long p = 239;
const int ma = 16 * 1024;
int n, dp[76][76][76][3];
vector<int> pos[3];
string s;
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
pos[0].push_back(i);
else if (s[i] == 'K')
pos[1].push_back(i);
else
pos[2].push_back(i);
}
for (int i = 0; i < (int)pos[0].size() + 1; i++) {
for (int j = 0; j < (int)pos[1].size() + 1; j++) {
for (int k = 0; k < (int)pos[2].size() + 1; k++) {
if (i + j + k == 0) continue;
int cnti = i - 1, cntj = j - 1, cntk = k - 1;
for (int p = 0; p < j; p++) {
if (i && pos[1][p] < pos[0][i - 1]) cnti++;
if (k && pos[1][p] < pos[2][k - 1]) cntk++;
}
for (int p = 0; p < i; p++) {
if (j && pos[0][p] < pos[1][j - 1]) cntj++;
if (k && pos[0][p] < pos[2][k - 1]) cntk++;
}
for (int p = 0; p < k; p++) {
if (i && pos[2][p] < pos[0][i - 1]) cnti++;
if (j && pos[2][p] < pos[1][j - 1]) cntj++;
}
for (int q = 0; q < 3; q++) dp[i][j][k][q] = int(1e9);
if (i)
dp[i][j][k][0] = min(dp[i - 1][j][k][0],
min(dp[i - 1][j][k][1], dp[i - 1][j][k][2])) +
max(pos[0][i - 1] - cnti, 0);
if (j)
dp[i][j][k][1] = min(dp[i][j - 1][k][1], dp[i][j - 1][k][2]) +
max(pos[1][j - 1] - cntj, 0);
if (k)
dp[i][j][k][2] = min(dp[i][j][k - 1][0],
min(dp[i][j][k - 1][1], dp[i][j][k - 1][2])) +
max(pos[2][k - 1] - cntk, 0);
}
}
}
cout << min(min(dp[(int)pos[0].size()][(int)pos[1].size()][(int)pos[2].size()]
[0],
dp[(int)pos[0].size()][(int)pos[1].size()][(int)pos[2].size()]
[1]),
dp[(int)pos[0].size()][(int)pos[1].size()][(int)pos[2].size()][2])
<< "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &first, T2 second) {
if (first > second) first = second;
}
template <typename T1, typename T2>
inline void chkmax(T1 &first, T2 second) {
if (first < second) first = second;
}
const string FileName = "input";
const int INF = 2e9;
const int MAXN = 1 << 18;
int n;
string s;
int dp[80][80][80][2];
int main() {
srand(time(0));
ios::sync_with_stdio(0);
cin >> n >> s;
for (int V = 0; V <= n; ++V) {
for (int K = 0; V + K <= n; ++K) {
for (int Q = 0; V + K + Q <= n; ++Q) {
dp[V][K][Q][0] = dp[V][K][Q][1] = 1e9;
}
}
}
dp[0][0][0][0] = 0;
for (int V = 0; V <= n; ++V) {
for (int K = 0; V + K <= n; ++K) {
for (int Q = 0; V + K + Q < n; ++Q) {
if (dp[V][K][Q][0] == 1e9 && dp[V][K][Q][1] == 1e9) {
continue;
}
int v = V, k = K, q = Q;
int c = 0;
int v1 = -1, k1 = -1, q1 = -1;
for (int i = 0; i < n; ++i) {
if (s[i] == 'V') {
if (v == 0) v1 = c;
if (v <= 0) ++c;
--v;
} else if (s[i] == 'K') {
if (k == 0) k1 = c;
if (k <= 0) ++c;
--k;
} else {
if (q == 0) q1 = c;
if (q <= 0) ++c;
--q;
}
}
int res = min(dp[V][K][Q][0], dp[V][K][Q][1]);
if (v1 != -1) chkmin(dp[V + 1][K][Q][1], res + v1);
if (k1 != -1) chkmin(dp[V][K + 1][Q][0], dp[V][K][Q][0] + k1);
if (q1 != -1) chkmin(dp[V][K][Q + 1][0], res + q1);
}
}
}
int ans = 1e9;
for (int V = 0; V <= n; ++V) {
for (int K = 0; V + K <= n; ++K) {
int Q = n - V - K;
chkmin(ans, dp[V][K][Q][0]);
chkmin(ans, dp[V][K][Q][1]);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const int N = 80;
int cnt[3], id[3][N], sum[3][N];
int dp[N][N][N][2], n;
std::string s;
void down(int &x, int y) { x = std::min(x, y); }
int calc(int i, int j, int k, int id) {
int ret = 0;
if (sum[0][id] > i) ret += sum[0][id] - i;
if (sum[1][id] > j) ret += sum[1][id] - j;
if (sum[2][id] > k) ret += sum[2][id] - k;
return ret;
}
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> s;
for (int i = 0; i < n; ++i)
if (s[i] == 'V')
s[i] = 0;
else if (s[i] == 'K')
s[i] = 1;
else
s[i] = 2;
for (int i = 1; i < n; ++i) {
for (int j = 0; j < 3; ++j) sum[j][i] = sum[j][i - 1];
++sum[s[i - 1]][i];
}
for (int i = 0; i < n; ++i) id[s[i]][cnt[s[i]]++] = i;
std::memset(dp, 0x3f, sizeof dp);
dp[0][0][0][0] = 0;
for (int i = 0; i <= cnt[0]; ++i)
for (int j = 0; j <= cnt[1]; ++j)
for (int k = 0; k <= cnt[2]; ++k)
for (int l = 0; l < 2; ++l) {
int v = dp[i][j][k][l];
if (i < cnt[0]) down(dp[i + 1][j][k][1], v + calc(i, j, k, id[0][i]));
if (j < cnt[1] && !l)
down(dp[i][j + 1][k][0], v + calc(i, j, k, id[1][j]));
if (k < cnt[2]) down(dp[i][j][k + 1][0], v + calc(i, j, k, id[2][k]));
}
std::cout << std::min(dp[cnt[0]][cnt[1]][cnt[2]][0],
dp[cnt[0]][cnt[1]][cnt[2]][1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
using namespace std;
const long long N = 100, OO = 1e9 + 7, M = 1e9 + 7, P = 6151, T = 1010,
SQ = 280, lg = 30;
char a[N];
bool b[N];
long long dp[N][N][N][2], n, V, K, X;
long long solve(long long v, long long k, long long x, long long lv) {
if (v + k + x == n) return 0;
if (dp[v][k][x][lv] != -1) return dp[v][k][x][lv];
long long r = OO;
if (v < V) {
long long f = 0, i;
for (i = 0; i < n; i++) {
if (b[i]) continue;
if (a[i] == 'V') break;
f++;
}
b[i] = true;
r = min(r, f + solve(v + 1, k, x, 1));
b[i] = false;
}
if (k < K and lv == 0) {
long long f = 0, i;
for (i = 0; i < n; i++) {
if (b[i]) continue;
if (a[i] == 'K') break;
f++;
}
b[i] = true;
r = min(r, f + solve(v, k + 1, x, 0));
b[i] = false;
}
if (x < X) {
long long f = 0, i;
for (i = 0; i < n; i++) {
if (b[i]) continue;
if (a[i] == 'X') break;
f++;
}
b[i] = true;
r = min(r, f + solve(v, k, x + 1, 0));
b[i] = false;
}
dp[v][k][x][lv] = r;
return r;
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
memset(dp, -1, sizeof dp);
string s;
cin >> n >> s;
for (long long i = 0; i < n; i++) {
if (s[i] == 'V' or s[i] == 'K') {
a[i] = s[i];
if (s[i] == 'V')
V++;
else
K++;
} else {
a[i] = 'X';
X++;
}
}
cout << solve(0, 0, 0, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int MAXN = 80;
const int MOD = 1e9 + 7;
int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
long long pw(long long a, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int n, cv, ck, cx, dp[MAXN][MAXN][MAXN][5];
char s[MAXN];
bool vis[MAXN];
void gao(int a, int b, int c, int t) {
int cnt, nv, nk, nx;
nv = nk = nx = 0;
memset(vis, false, sizeof(vis));
cnt = 0;
for (int i = 0; i < n && cnt < a; i++)
if (s[i] == 'V') vis[i] = true, cnt++;
cnt = 0;
for (int i = 0; i < n && cnt < b; i++)
if (s[i] == 'K') vis[i] = true, cnt++;
cnt = 0;
for (int i = 0; i < n && cnt < c; i++)
if (s[i] != 'V' && s[i] != 'K') vis[i] = true, cnt++;
for (int i = 0; i < n; i++) {
if (s[i] == 'V' && !vis[i]) break;
if (!vis[i]) nv++;
}
for (int i = 0; i < n; i++) {
if (s[i] == 'K' && !vis[i]) break;
if (!vis[i]) nk++;
}
for (int i = 0; i < n; i++) {
if (s[i] != 'V' && s[i] != 'K' && !vis[i]) break;
if (!vis[i]) nx++;
}
dp[a + 1][b][c][1] = min(dp[a + 1][b][c][1], dp[a][b][c][t] + nv);
if (t != 1) dp[a][b + 1][c][2] = min(dp[a][b + 1][c][2], dp[a][b][c][t] + nk);
dp[a][b][c + 1][3] = min(dp[a][b][c + 1][3], dp[a][b][c][t] + nx);
}
int main() {
scanf("%d%s", &n, s);
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
cv++;
else if (s[i] == 'K')
ck++;
else
cx++;
}
memset(dp, INF, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i <= cv; i++)
for (int j = 0; j <= ck; j++)
for (int k = 0; k <= cx; k++) {
if (!i && !j && !k) {
gao(0, 0, 0, 0);
continue;
}
for (int t = 1; t <= 3; t++) gao(i, j, k, t);
}
int ans = INF;
for (int t = 1; t <= 3; t++) ans = min(ans, dp[cv][ck][cx][t]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 75 + 10, INF = 0x3f3f3f3f;
int n, dp[N][N][N][2], cnt[3], pos[3][N], used[N];
char s[N];
void init() {
memset(dp, 0x3f, sizeof(dp));
memset(cnt, 0, sizeof(cnt));
memset(used, 0, sizeof(used));
dp[0][0][0][0] = 0;
}
int cal(int bou) {
int res = 0;
for (int i = 0; i < 3; i++)
for (int j = used[i] + 1; j <= cnt[i] && pos[i][j] < bou; j++) res++;
return res;
}
int main() {
while (~scanf("%d%s", &n, s)) {
init();
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
pos[0][++cnt[0]] = i;
else if (s[i] == 'K')
pos[1][++cnt[1]] = i;
else
pos[2][++cnt[2]] = i;
}
int &v = used[0], &k = used[1], &x = used[2];
for (v = 0; v <= cnt[0]; v++) {
for (k = 0; k <= cnt[1]; k++)
for (x = 0; x <= cnt[2]; x++)
for (int t = 0; t < 2; t++) {
int cost = dp[v][k][x][t];
if (cost == INF) continue;
if (v < cnt[0])
dp[v + 1][k][x][1] =
min(dp[v + 1][k][x][1], cost + cal(pos[0][v + 1]));
if (k < cnt[1] && t == 0)
dp[v][k + 1][x][0] =
min(dp[v + 1][k][x][0], cost + cal(pos[1][k + 1]));
if (x < cnt[2])
dp[v][k][x + 1][0] =
min(dp[v][k][x + 1][0], cost + cal(pos[2][x + 1]));
}
}
printf("%d\n",
min(dp[cnt[0]][cnt[1]][cnt[2]][0], dp[cnt[0]][cnt[1]][cnt[2]][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
const int inf = 0x3f3f3f3f;
int n;
char s[N];
vector<int> a[3];
vector<int> cnt[3][3];
void pp(int &x, int y) { x = min(x, y); }
int dp[N][N][N][3];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == 'V')
a[0].push_back(i);
else if (s[i] == 'K')
a[1].push_back(i);
else
a[2].push_back(i);
}
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
for (int i = 0; i < (int)a[x].size(); i++) {
if (x == y) continue;
cnt[x][y].push_back(0);
for (int j = 0; j < (int)a[y].size(); j++)
if (a[y][j] < a[x][i]) cnt[x][y][i]++;
}
}
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= (int)a[0].size(); j++)
for (int k = 0; k <= (int)a[1].size(); k++)
for (int l = 0; l < 3; l++) dp[i][j][k][l] = inf;
dp[0][0][0][2] = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= (int)a[0].size(); j++) {
for (int k = 0; k <= (int)a[1].size(); k++) {
for (int l = 0; l < 3; l++) {
if (dp[i][j][k][l] == inf) continue;
int x = i - j - k;
if (j < (int)a[0].size()) {
int v = max(0, k - cnt[0][1][j]) + max(0, x - cnt[0][2][j]);
pp(dp[i + 1][j + 1][k][0],
dp[i][j][k][l] + abs(a[0][j] + v - (i + 1)));
}
if (l != 0 && k < (int)a[1].size()) {
int v = max(0, j - cnt[1][0][k]) + max(0, x - cnt[1][2][k]);
pp(dp[i + 1][j][k + 1][1],
dp[i][j][k][l] + abs(a[1][k] + v - (i + 1)));
}
if (x < (int)a[2].size()) {
int v = max(0, j - cnt[2][0][x]) + max(0, k - cnt[2][1][x]);
pp(dp[i + 1][j][k][2], dp[i][j][k][l] + abs(a[2][x] + v - (i + 1)));
}
}
}
}
}
int ans = inf;
for (int i = 0; i < 3; i++)
pp(ans, dp[n][(int)a[0].size()][(int)a[1].size()][i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int N = 85;
int n, f[N][N][N][2], pos[3][N], cnt[3], num[3][N];
string s;
int getType(char c) {
if (c == 'V') return 1;
if (c == 'K') return 2;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
cin >> s;
for (int i = 0; i < n; ++i) {
int t = getType(s[i]);
pos[t][cnt[t]] = i;
++cnt[t];
}
for (int x = 0; x < (3); ++x)
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (i); ++j) {
int t = getType(s[j]);
if (t == x) ++num[x][i];
}
}
for (int i = 0; i < (N); ++i)
for (int j = 0; j < (N); ++j)
for (int w = 0; w < (N); ++w)
for (int x = 0; x < (2); ++x) f[i][j][w][x] = inf;
f[0][0][0][0] = 0;
for (int x = 0; x < (cnt[0] + 1); ++x)
for (int y = 0; y < (cnt[1] + 1); ++y)
for (int z = 0; z < (cnt[2] + 1); ++z)
for (int w = 0; w < (2); ++w) {
if (f[x][y][z][w] == inf) {
continue;
}
f[x + 1][y][z][0] = min(
f[x + 1][y][z][0],
f[x][y][z][w] + abs(x + y + z -
(pos[0][x] + max(0, y - num[1][pos[0][x]]) +
max(0, z - num[2][pos[0][x]]))));
f[x][y + 1][z][1] = min(
f[x][y + 1][z][1],
f[x][y][z][w] + abs(x + y + z -
(pos[1][y] + max(0, x - num[0][pos[1][y]]) +
max(0, z - num[2][pos[1][y]]))));
if (!w)
f[x][y][z + 1][0] = min(
f[x][y][z + 1][0],
f[x][y][z][w] + abs(x + y + z -
(pos[2][z] + max(0, x - num[0][pos[2][z]]) +
max(0, y - num[1][pos[2][z]]))));
}
cout << min(f[cnt[0]][cnt[1]][cnt[2]][0], f[cnt[0]][cnt[1]][cnt[2]][1])
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[80];
int posv[80], posk[80], posa[80], sumv[80], sumk[80], suma[80], cnta, cntv,
cntk;
int dp[80][80][80][2];
int main() {
scanf("%d", &n);
scanf(" %s", s + 1);
for (int i = 1; i < (n + 1); i++) {
suma[i] = suma[i - 1];
sumv[i] = sumv[i - 1];
sumk[i] = sumk[i - 1];
if (s[i] == 'V') {
sumv[i] += 1;
cntv++;
posv[cntv] = i;
} else if (s[i] == 'K') {
sumk[i] += 1;
cntk++;
posk[cntk] = i;
} else {
suma[i] += 1;
cnta++;
posa[cnta] = i;
}
}
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i < (cntv + 1); i++) {
for (int j = 0; j < (cntk + 1); j++) {
for (int k = 0; k < (cnta + 1); k++) {
int pos = i + j + k + 1;
if (i < cntv) {
dp[i + 1][j][k][1] =
min(dp[i + 1][j][k][1], dp[i][j][k][0] +
max(0, sumk[posv[i + 1]] - j) +
max(0, suma[posv[i + 1]] - k));
dp[i + 1][j][k][1] =
min(dp[i + 1][j][k][1], dp[i][j][k][1] +
max(0, sumk[posv[i + 1]] - j) +
max(0, suma[posv[i + 1]] - k));
}
if (j < cntk)
dp[i][j + 1][k][0] =
min(dp[i][j + 1][k][0], dp[i][j][k][0] +
max(0, sumv[posk[j + 1]] - i) +
max(0, suma[posk[j + 1]] - k));
if (k < cnta) {
dp[i][j][k + 1][0] =
min(dp[i][j][k + 1][0], dp[i][j][k][0] +
max(0, sumv[posa[k + 1]] - i) +
max(0, sumk[posa[k + 1]] - j));
dp[i][j][k + 1][0] =
min(dp[i][j][k + 1][0], dp[i][j][k][1] +
max(0, sumv[posa[k + 1]] - i) +
max(0, sumk[posa[k + 1]] - j));
}
}
}
}
printf("%d\n", min(dp[cntv][cntk][cnta][1], dp[cntv][cntk][cnta][0]));
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int maxn = 80, inf = 1e9 + 10;
int n, k, dp[maxn][maxn][maxn][3], c[3];
char s[maxn];
int t[maxn];
void smin(int &a, int b) { a = min(a, b); }
int32_t main() {
scanf("%d%s", &n, s);
for (int i = 0; i < n; i++) {
if (s[i] == 'V') {
s[i] = 0;
c[0]++;
} else if (s[i] == 'K') {
s[i] = 1;
c[1]++;
} else {
s[i] = 2;
c[2]++;
}
}
for (int i = 0; i < c[0] + 1; i++) {
for (int j = 0; j < c[1] + 1; j++) {
for (int k = 0; k < c[2] + 1; k++) {
for (int l = 0; l < 3; l++) {
dp[i][j][k][l] = inf;
}
}
}
}
dp[0][0][0][0] = 0;
dp[0][0][0][1] = 0;
dp[0][0][0][2] = 0;
for (int i = 0; i < c[0] + 1; i++) {
for (int j = 0; j < c[1] + 1; j++) {
for (int k = 0; k < c[2] + 1; k++) {
for (int l = 0; l < 3; l++) {
int e[3] = {i, j, k}, f = 0;
for (int o = 0; o < n; o++) {
if (e[s[o]] <= 0) {
if (s[o] == 0) {
smin(dp[i + 1][j][k][s[o]], o - f + dp[i][j][k][l]);
}
if (s[o] == 1 && l != 0) {
smin(dp[i][j + 1][k][s[o]], o - f + dp[i][j][k][l]);
}
if (s[o] == 2) {
smin(dp[i][j][k + 1][s[o]], o - f + dp[i][j][k][l]);
}
} else {
f++;
}
e[s[o]]--;
}
}
}
}
}
int ans = inf;
for (int i = 0; i < 3; i++) {
smin(ans, dp[c[0]][c[1]][c[2]][i]);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
inline int getc() {
char c = getchar();
while (c < 'A' || c > 'Z') c = getchar();
if (c == 'V') return 0;
if (c == 'K') return 1;
return 2;
}
const int N = 76;
const int orz = 1000000000;
int n, l0, l1, l2, S0[N], S1[N], S2[N];
int f[N][N][N][3];
inline void up(int &x, int y) {
if (y < x) x = y;
}
inline int b0(int x, int l) {
int B = l++, r = l0, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (S0[mid] > x)
r = mid - 1;
else
l = mid + 1;
}
return r - B;
}
inline int b1(int x, int l) {
int B = l++, r = l1, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (S1[mid] > x)
r = mid - 1;
else
l = mid + 1;
}
return r - B;
}
inline int b2(int x, int l) {
int B = l++, r = l2, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (S2[mid] > x)
r = mid - 1;
else
l = mid + 1;
}
return r - B;
}
inline int calc(int tp, int ps, int la, int lb) {
if (tp == 0) return b1(ps, la) + b2(ps, lb);
if (tp == 1) return b0(ps, la) + b2(ps, lb);
return b0(ps, la) + b1(ps, lb);
}
int main() {
int i, j, k, t, x;
n = read();
for (i = 1; i <= n; i++) {
x = getc();
if (!x)
S0[++l0] = i;
else if (x == 1)
S1[++l1] = i;
else
S2[++l2] = i;
}
for (i = 0; i <= l0; i++)
for (j = 0; j <= l1; j++)
for (k = 0; k <= l2; k++)
for (t = 0; t <= 2; t++) f[i][j][k][t] = orz;
f[0][0][0][2] = 0;
for (i = 0; i <= l0; i++)
for (j = 0; j <= l1; j++)
for (k = 0; k <= l2; k++)
for (t = 0; t <= 2; t++)
if (f[i][j][k][t] != orz) {
x = f[i][j][k][t];
if (i != l0) up(f[i + 1][j][k][0], x + calc(0, S0[i + 1], j, k));
if (j != l1 && t)
up(f[i][j + 1][k][1], x + calc(1, S1[j + 1], i, k));
if (k != l2) up(f[i][j][k + 1][2], x + calc(2, S2[k + 1], i, j));
}
int ans = orz;
for (t = 0; t <= 2; t++) up(ans, f[l0][l1][l2][t]);
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, func(long long, long long, long long, long long, long long),
ff(long long, char, long long, long long, long long);
char str[100];
int *dp;
int vs = 0, ks = 0, os = 0, mn, mv, mk, mo;
long long find(long long, long long, long long, long long, long long);
long long assign(long long, long long, long long, long long, long long,
long long);
int main() {
scanf("%lld", &n);
scanf(" %s", str);
long long size_ = strlen(str);
for (int i = 0; i < size_; i++) {
if (str[i] != 'V' && str[i] != 'K') str[i] = 'O';
if (str[i] == 'V')
vs++;
else if (str[i] == 'K')
ks++;
else
os++;
}
mn = (vs + 1) * (ks + 1) * (os + 1) * 2;
mv = (ks + 1) * (os + 1) * 2;
mk = (os + 1) * 2;
mo = 2;
dp =
(int *)malloc((n + 1) * (vs + 1) * (ks + 1) * (os + 1) * 2 * sizeof(int));
for (int i = 0; i < (n + 1) * (vs + 1) * (ks + 1) * (os + 1) * 2; i++)
dp[i] = -1;
cout << func(0, 0, 0, 0, 0);
}
long long fin(long long idx, long long v, long long k, long long o,
long long prev_) {
return *(dp + idx * mn + v * mv + k * mk + o * mo + prev_);
}
long long assign(long long idx, long long v, long long k, long long o,
long long prev_, long long val) {
return dp[idx * mn + v * mv + k * mk + o * mo + prev_] = (int)val;
}
long long func(long long idx, long long v, long long k, long long o,
long long prev_) {
if (v < 0 || k < 0 || o < 0 || idx > n) return 1000000009ll;
if (idx == n && v + k + o == 0) {
return 0;
}
long long x = fin(idx, v, k, o, prev_);
if (x != -1) return x;
long long a = func(idx, v - 1, k, o, 1) + ff(idx - 1, 'V', v, k, o);
long long b = prev_ ? 1000000009ll
: (func(idx, v, k - 1, o, 0) + ff(idx - 1, 'K', v, k, o));
long long c = func(idx, v, k, o - 1, 0) + ff(idx - 1, 'O', v, k, o);
long long d = func(idx + 1, v + (str[idx] == 'V'), k + (str[idx] == 'K'),
o + (str[idx] != 'V' && str[idx] != 'K'), prev_);
long long e = (prev_ && str[idx] == 'K')
? 1000000009ll
: (func(idx + 1, v, k, o, str[idx] == 'V') + (v + k + o));
return assign(idx, v, k, o, prev_, min({a, b, c, d, e}));
}
long long ff(long long idx, char ch, long long v, long long k, long long o) {
if (v < 0 || k < 0 || o < 0 || idx < 0) return 0;
if (ch == 'V' && v == 0)
return (k >= 0 ? k : 0) + (o >= 0 ? o : 0);
else if (ch == 'K' && k == 0)
return (v >= 0 ? v : 0) + (o >= 0 ? o : 0);
else if (ch == 'O' && o == 0)
return (v >= 0 ? v : 0) + (k >= 0 ? k : 0);
long long ans = 0;
for (int i = idx; i >= 0; i--) {
if (str[i] == 'V')
v--;
else if (str[i] == 'K')
k--;
else
o--;
if (ch == 'V' && v == 0)
return (k >= 0 ? k : 0) + (o >= 0 ? o : 0);
else if (ch == 'K' && k == 0)
return (v >= 0 ? v : 0) + (o >= 0 ? o : 0);
else if (ch == 'O' && o == 0)
return (v >= 0 ? v : 0) + (k >= 0 ? k : 0);
}
cout << " " << v << " " << k << " " << o << "SDDF\n";
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100];
int dp[100][100][100][5];
int ss[100];
int main() {
int n;
scanf("%d %s", &n, s);
int all = 0x3f3f3f3f, vn = 0, kn = 0, xn = 0;
memset(dp, 0x3f3f3f3f, sizeof(dp));
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
ss[i] = 1, vn++;
else if (s[i] == 'K')
ss[i] = 2, kn++;
else
ss[i] = 0, xn++;
}
for (int i = 0; i < 3; i++) dp[0][0][0][i] = 0;
for (int v = 0; v <= vn; v++) {
for (int k = 0; k <= kn; k++) {
for (int x = 0; x <= xn; x++) {
if (x + k + v == n) continue;
int cnt[3];
cnt[0] = x;
cnt[1] = v;
cnt[2] = k;
int pos[3] = {0, 0, 0};
int tot = 0;
for (int i = 0; i < n; i++) {
if (cnt[ss[i]])
cnt[ss[i]]--;
else {
tot++;
if (!pos[ss[i]]) pos[ss[i]] = tot;
}
}
for (int i = 0; i < 3; i++) {
if (dp[v][k][x][i] == 0x3f3f3f3f) continue;
dp[v + 1][k][x][1] =
min(dp[v + 1][k][x][1], dp[v][k][x][i] + pos[1] - 1);
dp[v][k][x + 1][0] =
min(dp[v][k][x + 1][0], dp[v][k][x][i] + pos[0] - 1);
if (i != 1)
dp[v][k + 1][x][2] =
min(dp[v][k + 1][x][2], dp[v][k][x][i] + pos[2] - 1);
}
}
}
}
all = min(all, dp[vn][kn][xn][0]);
all = min(all, dp[vn][kn][xn][1]);
all = min(all, dp[vn][kn][xn][2]);
printf("%d\n", all);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 76;
char s[N];
int n, a[N][3], b[N][3], dp[N][N][N][2];
int main() {
scanf("%d%s", &n, s);
for (int i = 1; i <= n; ++i) {
if (s[i - 1] == 'V') {
a[i][0] = a[i - 1][0] + 1;
a[i][1] = a[i - 1][1];
a[i][2] = a[i - 1][2];
b[a[i][0]][0] = i;
} else if (s[i - 1] == 'K') {
a[i][0] = a[i - 1][0];
a[i][1] = a[i - 1][1] + 1;
a[i][2] = a[i - 1][2];
b[a[i][1]][1] = i;
} else {
a[i][0] = a[i - 1][0];
a[i][1] = a[i - 1][1];
a[i][2] = a[i - 1][2] + 1;
b[a[i][2]][2] = i;
}
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i <= a[n][0]; ++i)
for (int j = 0; j <= a[n][1]; ++j)
for (int k = 0; k <= a[n][2]; ++k) {
if (i > 0)
dp[i][j][k][1] =
min(dp[i][j][k][1],
min(dp[i - 1][j][k][0], dp[i - 1][j][k][1]) +
abs(b[i][0] - min(i, a[b[i][0]][0]) -
min(j, a[b[i][0]][1]) - min(k, a[b[i][0]][2])));
if (j > 0)
dp[i][j][k][0] =
min(dp[i][j][k][0],
dp[i][j - 1][k][0] +
abs(b[j][1] - min(i, a[b[j][1]][0]) -
min(j, a[b[j][1]][1]) - min(k, a[b[j][1]][2])));
if (k > 0)
dp[i][j][k][0] =
min(dp[i][j][k][0],
min(dp[i][j][k - 1][0], dp[i][j][k - 1][1]) +
abs(b[k][2] - min(i, a[b[k][2]][0]) -
min(j, a[b[k][2]][1]) - min(k, a[b[k][2]][2])));
}
printf("%d", min(dp[a[n][0]][a[n][1]][a[n][2]][0],
dp[a[n][0]][a[n][1]][a[n][2]][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 80;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
int n;
string s;
int a[maxn];
int dp[maxn][maxn][maxn][2];
vector<int> pos[3];
int calc(int a, int b, int c, int d) {
int ans = 0;
while (a < pos[0].size() and pos[0][a] < d) ans++, a++;
while (b < pos[1].size() and pos[1][b] < d) ans++, b++;
while (c < pos[2].size() and pos[2][c] < d) ans++, c++;
return (ans);
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> s;
for (int i = 0; i < n; i++)
a[i] = ((s[i] == 'K') ? 1 : ((s[i] == 'V') ? 0 : 2)),
pos[a[i]].push_back(i);
memset(dp, 15, sizeof dp);
dp[0][0][0][0] = 0;
int v = pos[0].size(), k = pos[1].size(), o = n - v - k;
for (int i = 0; i <= v; i++)
for (int j = 0; j <= k; j++)
for (int h = 0; h <= o; h++)
for (int l = 0; l < 2; l++) {
int Dp = dp[i][j][h][l];
if (i < v)
dp[i + 1][j][h][1] =
min(dp[i + 1][j][h][1], Dp + calc(i, j, h, pos[0][i]));
if (j < k and !l)
dp[i][j + 1][h][0] =
min(Dp + calc(i, j, h, pos[1][j]), dp[i][j + 1][h][0]);
if (h < o)
dp[i][j][h + 1][0] =
min(Dp + calc(i, j, h, pos[2][h]), dp[i][j][h + 1][0]);
}
cout << min(dp[v][k][o][0], dp[v][k][o][1]);
return (0);
}
|
#include <bits/stdc++.h>
int n, p[110][3], c[110][3], f[110][110][110][2], V, K, X;
char s[110];
int min(int a, int b) { return a < b ? a : b; }
int r(int o, int v, int k, int x) {
return o - min(c[o][0], v) - min(c[o][1], k) - min(c[o][2], x);
}
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) c[i][j] = c[i - 1][j];
if (s[i] == 'V')
V++, p[V][0] = i, c[i][0]++;
else if (s[i] == 'K')
K++, p[K][1] = i, c[i][1]++;
else
X++, p[X][2] = i, c[i][2]++;
}
memset(f, 0x3f, sizeof(f));
f[0][0][0][0] = 0;
for (int i = 0; i <= V; i++)
for (int j = 0; j <= K; j++)
for (int k = 0; k <= X; k++) {
int Q = min(f[i][j][k][0], f[i][j][k][1]);
f[i + 1][j][k][1] =
min(f[i + 1][j][k][1], Q + r(p[i + 1][0], i + 1, j, k));
f[i][j + 1][k][0] =
min(f[i][j + 1][k][0], f[i][j][k][0] + r(p[j + 1][1], i, j + 1, k));
f[i][j][k + 1][0] =
min(f[i][j][k + 1][0], Q + r(p[k + 1][2], i, j, k + 1));
}
printf("%d", min(f[V][K][X][0], f[V][K][X][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string a;
int tot[3];
vector<int> v[3];
int dp[77][77][77][3];
int cnt_before[77][3];
int f(int i, int j, int t, int sr) {
int ret = sr;
ret -= min(cnt_before[sr][0], i);
ret -= min(cnt_before[sr][1], j);
ret -= min(cnt_before[sr][2], t);
return ret;
}
void input() {
cin >> n;
cin >> a;
for (int i = 0; i < n; ++i) {
if (a[i] == 'V') {
a[i] = 'a';
} else if (a[i] == 'K') {
a[i] = 'b';
} else {
a[i] = 'c';
}
++tot[(a[i] - 'a')];
v[(a[i] - 'a')].push_back(i);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
++cnt_before[i][(a[j] - 'a')];
}
}
}
void solve() {
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
for (int t = 0; t <= n; ++t) {
for (int z = 0; z < 3; ++z) {
dp[i][j][t][z] = 1000000007;
}
}
}
}
dp[0][0][0][2] = 0;
for (int i = 0; i <= tot[0]; ++i) {
for (int j = 0; j <= tot[1]; ++j) {
for (int t = 0; t <= tot[2]; ++t) {
for (int z = 0; z < 3; ++z) {
if (dp[i][j][t][z] == 1000000007) {
continue;
}
if (i < tot[0]) {
dp[i + 1][j][t][0] =
min(dp[i + 1][j][t][0], dp[i][j][t][z] + f(i, j, t, v[0][i]));
}
if (j < tot[1] && z != 0) {
dp[i][j + 1][t][1] =
min(dp[i][j + 1][t][1], dp[i][j][t][z] + f(i, j, t, v[1][j]));
}
if (t < tot[2]) {
dp[i][j][t + 1][2] =
min(dp[i][j][t + 1][2], dp[i][j][t][z] + f(i, j, t, v[2][t]));
}
}
}
}
}
int ans = 1000000007;
for (int i = 0; i < 3; ++i) {
ans = min(ans, dp[tot[0]][tot[1]][tot[2]][i]);
}
cout << ans << "\n";
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class _Tp>
void ckmax(_Tp &a, _Tp b) {
if (a < b) a = b;
}
template <class _Tp>
void ckmin(_Tp &a, _Tp b) {
if (a > b) a = b;
}
template <class _Tp>
_Tp gcd(_Tp a, _Tp b) {
return (b == 0) ? (a) : (gcd(b, a % b));
}
int read() {
char ch = getchar();
bool f = 1;
int x = 0;
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') f = 0, ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch & 15);
ch = getchar();
}
return f ? x : -x;
}
const int inf = 1000000000;
const long long Inf = 1000000000000000000ll;
int n;
char s[100];
bool vis[100];
int f[100][100][100][4];
void upt(int &x, int y) { x = min(x, y); }
void trans(int v, int k, int x, int t) {
memset(vis, 0, sizeof(vis));
int cnt = 1;
for (register int i = 1; i <= n && cnt <= v; ++i)
if (s[i] == 'V') cnt++, vis[i] = 1;
cnt = 1;
for (register int i = 1; i <= n && cnt <= k; ++i)
if (s[i] == 'K') cnt++, vis[i] = 1;
cnt = 1;
for (register int i = 1; i <= n && cnt <= x; ++i)
if (s[i] != 'V' && s[i] != 'K') cnt++, vis[i] = 1;
int v_ = 0, k_ = 0, x_ = 0;
for (register int i = 1; i <= n; ++i) {
if (s[i] == 'V' && !vis[i]) break;
if (!vis[i]) ++v_;
}
for (register int i = 1; i <= n; ++i) {
if (s[i] == 'K' && !vis[i]) break;
if (!vis[i]) ++k_;
}
for (register int i = 1; i <= n; ++i) {
if (s[i] != 'V' && s[i] != 'K' && !vis[i]) break;
if (!vis[i]) ++x_;
}
upt(f[v + 1][k][x][1], f[v][k][x][t] + v_);
if (t != 1) upt(f[v][k + 1][x][2], f[v][k][x][t] + k_);
upt(f[v][k][x + 1][3], f[v][k][x][t] + x_);
}
int main() {
n = read();
scanf("%s", s + 1);
int cntv = 0, cntk = 0, cntx = 0;
for (register int i = 1; i <= n; ++i) {
if (s[i] == 'V')
cntv++;
else if (s[i] == 'K')
cntk++;
else
cntx++;
}
memset(f, 0x3f, sizeof(f));
f[0][0][0][0] = 0;
for (register int i = 0; i <= cntv; ++i)
for (register int j = 0; j <= cntk; ++j)
for (register int k = 0; k <= cntx; ++k)
if (i == 0 && j == 0 && k == 0)
trans(0, 0, 0, 0);
else {
for (register int t = 1; t <= 3; ++t) trans(i, j, k, t);
}
int ans = 1000000000;
for (register int i = 1; i <= 3; ++i) ans = min(ans, f[cntv][cntk][cntx][i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int MAX_N = 75 + 10, INF = 0x3f3f3f3f;
char s[MAX_N];
int n, tv, tk, tx, f[MAX_N][MAX_N][MAX_N][2];
void check(int p, int &v, int &k, int &x) {
if (s[p] == 'V')
++v;
else if (s[p] == 'K')
++k;
else
++x;
}
void trans(int v, int k, int x, int op) {
int sv, sk, sx, cv, ck, cx;
sv = sk = sx = 0;
if (k + 1 <= tk && !op) {
cv = ck = cx = 0;
for (int i = 0; i < n; ++i) {
check(i, cv, ck, cx);
if (cv > v && s[i] == 'V') ++sk;
if (cx > x && s[i] == 'X') ++sk;
if (ck == k + 1) break;
}
f[v][k + 1][x][0] = std::min(f[v][k][x][op] + sk, f[v][k + 1][x][0]);
}
if (v + 1 <= tv) {
cv = ck = cx = 0;
for (int i = 0; i < n; ++i) {
check(i, cv, ck, cx);
if (ck > k && s[i] == 'K') ++sv;
if (cx > x && s[i] == 'X') ++sv;
if (cv == v + 1) break;
}
f[v + 1][k][x][1] = std::min(f[v][k][x][op] + sv, f[v + 1][k][x][1]);
}
if (x + 1 <= tx) {
cv = ck = cx = 0;
for (int i = 0; i < n; ++i) {
check(i, cv, ck, cx);
if (ck > k && s[i] == 'K') ++sx;
if (cv > v && s[i] == 'V') ++sx;
if (cx == x + 1) break;
}
f[v][k][x + 1][0] = std::min(f[v][k][x][op] + sx, f[v][k][x + 1][0]);
}
}
int main() {
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; ++i) {
check(i, tv, tk, tx);
if (s[i] != 'V' && s[i] != 'K') s[i] = 'X';
}
for (int v = 0; v <= tv; ++v)
for (int k = 0; k <= tk; ++k)
for (int x = 0; x <= tx; ++x) f[v][k][x][0] = f[v][k][x][1] = INF;
f[0][0][0][0] = 0;
for (int i = 0; i <= n; ++i)
for (int v = 0; v <= std::min(i, tv); ++v)
for (int k = 0; k <= std::min(i - v, tk); ++k) {
int x = i - v - k;
if (v > tv || k > tk || x > tx) continue;
for (int op = 0; op < 2; ++op)
if (f[v][k][x][op] < INF) trans(v, k, x, op);
}
printf("%d\n", std::min(f[tv][tk][tx][0], f[tv][tk][tx][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 90;
int n;
string s;
int dp[MAXN][MAXN][MAXN][5];
int cv, ck, ce;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
cv++;
else if (s[i] == 'K')
ck++;
else
ce++, s[i] = 'X';
}
for (int i = 0; i <= cv; i++)
for (int j = 0; j <= ck; j++)
for (int k = 0; k <= ce; k++)
for (int b = 0; b < 3; b++) dp[i][j][k][b] = INT_MAX / 2;
dp[0][0][0][0] = 0, dp[0][0][0][1] = 0, dp[0][0][0][2] = 0;
for (int i = 0; i <= cv; i++) {
for (int j = 0; j <= ck; j++) {
for (int k = 0; k <= ce; k++) {
for (int b = 0; b < 3; b++) {
int ip = i, jp = j, kp = k;
int id = 0;
for (int h = 0; h < n; h++) {
if (s[h] == 'V' && ip <= 0) {
dp[i + 1][j][k][0] =
min(dp[i + 1][j][k][0], h - id + dp[i][j][k][b]);
} else if (s[h] == 'V')
id++;
if (s[h] == 'K' && jp <= 0 && b != 0) {
dp[i][j + 1][k][1] =
min(dp[i][j + 1][k][1], h - id + dp[i][j][k][b]);
} else if (s[h] == 'K' && jp > 0)
id++;
if (s[h] == 'X' && kp <= 0) {
dp[i][j][k + 1][2] =
min(dp[i][j][k + 1][2], h - id + dp[i][j][k][b]);
} else if (s[h] == 'X')
id++;
if (s[h] == 'V')
ip--;
else if (s[h] == 'K')
jp--;
else
kp--;
}
}
}
}
}
int ans = INT_MAX / 2;
for (int i = 0; i < 3; i++) ans = min(ans, dp[cv][ck][ce][i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
int f[N][N][N][2], s[N][3];
int kn, vn, xn, pv[N], pk[N], px[N];
char ch[N];
int n;
void upd(int &x, int y) { x = min(x, y); }
int get(int d, int f, int v, int k, int x) {
int tot = 0, cnt[3];
cnt[0] = max(s[d][0] - v, 0);
cnt[1] = max(s[d][1] - k, 0);
cnt[2] = max(s[d][2] - x, 0);
for (register int i = (0); i <= (2); ++i)
if (i != f) tot += cnt[i];
return tot;
}
signed main() {
scanf("%d", &n);
scanf("%s", ch + 1);
bool flag = 0;
for (register int i = (1); i <= (n); ++i) {
s[i][0] = s[i - 1][0];
s[i][1] = s[i - 1][1];
s[i][2] = s[i - 1][2];
if (ch[i] == 'V')
s[i][0]++, pv[++vn] = i;
else if (ch[i] == 'K')
s[i][1]++, pk[++kn] = i;
else
s[i][2]++, px[++xn] = i;
if (ch[i] == 'K' && ch[i - 1] == 'V') flag = 1;
}
if (!flag) {
printf("0\n");
return 0;
}
memset(f, 0x3f, sizeof(f));
f[0][0][0][0] = 0;
for (register int v = (0); v <= (vn); ++v)
for (register int k = (0); k <= (kn); ++k)
for (register int x = (0); x <= (xn); ++x) {
if (v < vn)
upd(f[v + 1][k][x][1],
min(f[v][k][x][0], f[v][k][x][1]) + get(pv[v + 1], 0, v, k, x));
if (k < kn)
upd(f[v][k + 1][x][0], f[v][k][x][0] + get(pk[k + 1], 1, v, k, x));
if (x < xn)
upd(f[v][k][x + 1][0],
min(f[v][k][x][0], f[v][k][x][1]) + get(px[x + 1], 2, v, k, x));
}
int ans = min(f[vn][kn][xn][0], f[vn][kn][xn][1]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > pos(4);
int dp[76][76][76][2], freq[76][4], n, N, M, K;
string s;
void PreProcess() {
for (int i = 1; i <= 3; i++) pos[i].push_back(0);
for (int i = 0; i < s.size(); i++) {
int j;
if (s[i] == 'V')
j = 1;
else if (s[i] == 'K')
j = 2;
else
j = 3;
for (int x = 1; x < 4; x++) freq[i + 1][x] = freq[i][x];
freq[i + 1][j]++;
pos[j].push_back(i + 1);
}
N = freq[n][1];
M = freq[n][2];
K = freq[n][3];
for (int i = 0; i <= N; i++)
for (int j = 0; j <= M; j++)
for (int k = 0; k <= K; k++)
for (int x = 0; x < 2; x++) dp[i][j][k][x] = 1E9;
dp[0][0][0][0] = dp[0][0][0][1] = 0;
}
int Cost(int pos, int c1, int c2, int c3) {
return max(0, freq[pos - 1][1] - c1) + max(0, freq[pos - 1][2] - c2) +
max(0, freq[pos - 1][3] - c3);
}
int main() {
int ans = 1E9;
cin >> n >> s;
PreProcess();
for (int i = 0; i <= N; i++)
for (int j = 0; j <= M; j++)
for (int k = 0; k <= K; k++)
for (int x = 0; x < 2; x++) {
if (i < N)
dp[i + 1][j][k][1] =
min(dp[i + 1][j][k][1],
dp[i][j][k][x] + Cost(pos[1][i + 1], i, j, k));
if (x == 0 && j < M)
dp[i][j + 1][k][0] =
min(dp[i][j + 1][k][0],
dp[i][j][k][x] + Cost(pos[2][j + 1], i, j, k));
if (k < K)
dp[i][j][k + 1][0] =
min(dp[i][j][k + 1][0],
dp[i][j][k][x] + Cost(pos[3][k + 1], i, j, k));
}
for (int x = 0; x < 2; x++) ans = min(ans, dp[N][M][K][x]);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int dp[2][76][76][76];
vector<int> v, k, x;
int rec(int i, int j, int h, int z) {
if (i + j + h == n) return 0;
if (dp[z][i][j][h] != -1) return dp[z][i][j][h];
int an = 1e7;
if (!z && j < k.size()) {
int cnt = 0;
for (int g = i; g < v.size() && v[g] < k[j]; g++) cnt++;
for (int g = h; g < x.size() && x[g] < k[j]; g++) cnt++;
an = min(an, rec(i, j + 1, h, 0) + cnt);
}
int cnt = 0;
if (h < x.size()) {
for (int g = i; g < v.size() && v[g] < x[h]; g++) cnt++;
for (int g = j; g < k.size() && k[g] < x[h]; g++) cnt++;
an = min(an, rec(i, j, h + 1, 0) + cnt);
}
cnt = 0;
if (i < v.size()) {
for (int g = h; g < x.size() && x[g] < v[i]; g++) cnt++;
for (int g = j; g < k.size() && k[g] < v[i]; g++) cnt++;
an = min(an, rec(i + 1, j, h, 1) + cnt);
}
return dp[z][i][j][h] = an;
}
int main() {
memset(dp, -1, sizeof dp);
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> s;
for (int i = 1; i <= n; i++) {
if (s[i - 1] == 'V')
v.push_back(i);
else if (s[i - 1] == 'K')
k.push_back(i);
else
x.push_back(i);
}
cout << rec(0, 0, 0, 0) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int inf = 100000;
const int N = 80;
int n, a[N], dp[N][N][N][3], pos[3][N], cnt[3], ans, before[N][3];
string s;
int main() {
ios::sync_with_stdio(false);
cin >> n;
cin >> s;
for (int i = 0; i < n; i++)
if (s[i] != 'V' && s[i] != 'K') s[i] = 'X';
for (int i = n - 1; i >= 0; i--) {
if (s[i] == 'V') a[i] = 0;
if (s[i] == 'K') a[i] = 1;
if (s[i] == 'X') a[i] = 2;
pos[a[i]][cnt[a[i]]] = i;
cnt[a[i]]++;
}
for (int i = n - 2; i >= 0; i--) {
for (int last = 0; last < 3; last++) before[i][last] = before[i + 1][last];
before[i][a[i + 1]]++;
}
for (int v = 0; v <= cnt[0]; v++)
for (int k = 0; k <= cnt[1]; k++)
for (int x = 0; x <= cnt[2]; x++)
for (int last = 0; last < 3; last++) dp[v][k][x][last] = inf;
for (int last = 0; last < 3; last++) dp[0][0][0][last] = 0;
if (cnt[0] > 0) dp[1][0][0][0] = n - 1 - pos[0][0];
if (cnt[1] > 0) dp[0][1][0][1] = n - 1 - pos[1][0];
if (cnt[2] > 0) dp[0][0][1][2] = n - 1 - pos[2][0];
for (int v = 0; v <= cnt[0]; v++)
for (int k = 0; k <= cnt[1]; k++)
for (int x = 0; x <= cnt[2]; x++)
for (int last = 0; last < 3; last++) {
if (last == 0 && v == 0) continue;
if (last == 1 && k == 0) continue;
if (last == 2 && x == 0) continue;
int curPos = n - v - k - x;
int usedLast;
if (last == 0) usedLast = v;
if (last == 1) usedLast = k;
if (last == 2) usedLast = x;
for (int wasLast = 0; wasLast < 3; wasLast++) {
if (last == 0 && wasLast == 1) continue;
if (wasLast == 0 && v == 0) continue;
if (wasLast == 1 && k == 0) continue;
if (wasLast == 2 && x == 0) continue;
if (wasLast == last) {
if (last == 0 && v == 1) continue;
if (last == 1 && k == 1) continue;
if (last == 2 && x == 1) continue;
}
int beforeUs = 0;
int add, myPos = pos[last][usedLast - 1];
int wasBefore[3];
wasBefore[0] = v;
wasBefore[1] = k;
wasBefore[2] = x;
wasBefore[last]--;
for (int i = 0; i < 3; i++)
beforeUs += max(wasBefore[i], before[myPos][i]);
myPos = n - beforeUs - 1;
add = max(0, curPos - myPos);
if (last == 0)
dp[v][k][x][last] =
min(dp[v][k][x][last], dp[v - 1][k][x][wasLast] + add);
if (last == 1)
dp[v][k][x][last] =
min(dp[v][k][x][last], dp[v][k - 1][x][wasLast] + add);
if (last == 2)
dp[v][k][x][last] =
min(dp[v][k][x][last], dp[v][k][x - 1][wasLast] + add);
}
}
ans = inf;
for (int last = 0; last < 3; last++)
ans = min(ans, dp[cnt[0]][cnt[1]][cnt[2]][last]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 80;
int dp[N][N][N][2], pos[3][N], use[3], cnt[3], n;
char s[N];
void Min(int &x, int y) {
if (y < x) x = y;
}
int cal(int x) {
int sum = 0;
for (int i = 0; i <= 2; i++)
for (int j = use[i] + 1; pos[i][j] < x && j <= cnt[i]; j++) sum++;
return sum;
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == 'V')
pos[0][++cnt[0]] = i;
else if (s[i] == 'K')
pos[1][++cnt[1]] = i;
else
pos[2][++cnt[2]] = i;
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int v = 0; v <= cnt[0]; v++, use[0]++)
for (int k = 0; k <= cnt[1]; k++) {
use[1] = k;
for (int i = 0; i <= cnt[2]; i++) {
use[2] = i;
for (int t = 0; t <= 1; t++) {
int ret = dp[v][k][i][t];
if (v < cnt[0]) Min(dp[v + 1][k][i][1], ret + cal(pos[0][v + 1]));
if (k < cnt[1] && t != 1)
Min(dp[v][k + 1][i][0], ret + cal(pos[1][k + 1]));
if (i < cnt[2]) Min(dp[v][k][i + 1][0], ret + cal(pos[2][i + 1]));
}
}
}
printf("%d\n", std::min(dp[cnt[0]][cnt[1]][cnt[2]][0],
dp[cnt[0]][cnt[1]][cnt[2]][1]));
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
int n, s[77], f[77][77][77][3], idx[3][77], cnt[3], ccnt[3][77],
ans = 0x3f3f3f3f;
char tmp[77];
int main() {
scanf("%d", &n);
scanf("%s", tmp);
for (int i = 1; i <= n; ++i) {
s[i] = tmp[i - 1] == 'V' ? 2 : (tmp[i - 1] == 'K' ? 1 : 0);
++cnt[s[i]], idx[s[i]][cnt[s[i]]] = i;
ccnt[0][i] = cnt[0];
ccnt[1][i] = cnt[1];
ccnt[2][i] = cnt[2];
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j)
for (int k = 0; k <= n; ++k)
for (int t = 0; t < 3; ++t) f[i][j][k][t] = 0x3f3f3f3f;
f[0][0][0][0] = f[0][0][0][1] = f[0][0][0][2] = 0;
for (int i = 0; i <= n; ++i)
for (int j = std::max(0, i - cnt[0] - cnt[1]); j <= min(i, cnt[2]); ++j)
for (int k = std::max(0, i - cnt[2] - cnt[1]); k <= min(i - j, cnt[0]);
++k) {
f[i + 1][j][k][1] = min(f[i + 1][j][k][1],
f[i][j][k][0] + idx[1][i + 1 - j - k] - i - 1 +
max(0, j - ccnt[2][idx[1][i + 1 - j - k]]) +
max(0, k - ccnt[0][idx[1][i + 1 - j - k]]));
f[i + 1][j][k][1] = min(f[i + 1][j][k][1],
f[i][j][k][1] + idx[1][i + 1 - j - k] - i - 1 +
max(0, j - ccnt[2][idx[1][i + 1 - j - k]]) +
max(0, k - ccnt[0][idx[1][i + 1 - j - k]]));
f[i + 1][j][k + 1][0] =
min(f[i + 1][j][k + 1][0],
f[i][j][k][0] + idx[0][k + 1] - i - 1 +
max(0, j - ccnt[2][idx[0][k + 1]]) +
max(0, i - j - k - ccnt[1][idx[0][k + 1]]));
f[i + 1][j][k + 1][0] =
min(f[i + 1][j][k + 1][0],
f[i][j][k][1] + idx[0][k + 1] - i - 1 +
max(0, j - ccnt[2][idx[0][k + 1]]) +
max(0, i - j - k - ccnt[1][idx[0][k + 1]]));
f[i + 1][j][k + 1][0] =
min(f[i + 1][j][k + 1][0],
f[i][j][k][2] + idx[0][k + 1] - i - 1 +
max(0, j - ccnt[2][idx[0][k + 1]]) +
max(0, i - j - k - ccnt[1][idx[0][k + 1]]));
f[i + 1][j + 1][k][2] =
min(f[i + 1][j + 1][k][2],
f[i][j][k][2] + idx[2][j + 1] - i - 1 +
max(0, k - ccnt[0][idx[2][j + 1]]) +
max(0, i - j - k - ccnt[1][idx[2][j + 1]]));
f[i + 1][j + 1][k][2] =
min(f[i + 1][j + 1][k][2],
f[i][j][k][0] + idx[2][j + 1] - i - 1 +
max(0, k - ccnt[0][idx[2][j + 1]]) +
max(0, i - j - k - ccnt[1][idx[2][j + 1]]));
f[i + 1][j + 1][k][2] =
min(f[i + 1][j + 1][k][2],
f[i][j][k][1] + idx[2][j + 1] - i - 1 +
max(0, k - ccnt[0][idx[2][j + 1]]) +
max(0, i - j - k - ccnt[1][idx[2][j + 1]]));
}
for (int j = std::max(0, n - cnt[0] - cnt[1]); j <= min(n, cnt[2]); ++j) {
for (int k = std::max(0, n - cnt[2] - cnt[1]); k <= min(n - j, cnt[0]); ++k)
for (int t = 0; t < 3; ++t) ans = min(ans, f[n][j][k][t]);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, dp[80][80][80][2], V, K;
char cr[3] = {'A', 'V', 'K'};
char a[80];
int get_pos(int CNT, int v, int k, char c) {
int cnt[200];
cnt['A'] = CNT - v - k;
cnt['V'] = v;
cnt['K'] = k;
int i, pos = 0, dpos = 0;
for (pos = 1; pos <= N; pos++)
if (a[pos] == c) {
if (cnt[c] == 0)
break;
else
cnt[c]--;
}
for (int o = 0; o < 3; o++) {
if (cr[o] == c) continue;
for (i = 1; i <= N && cnt[cr[o]]; i++)
if (a[i] == cr[o]) {
cnt[cr[o]]--;
if (i > pos) dpos++;
}
}
return pos + dpos;
}
int main() {
cin >> N;
int i, j, v, k;
for (i = 1; i <= N; i++) {
cin >> a[i];
if (a[i] != 'V' && a[i] != 'K') a[i] = 'A';
if (a[i] == 'V')
V++;
else if (a[i] == 'K')
K++;
}
for (i = 0; i <= V; i++)
for (j = 0; j <= K; j++) dp[N + 1][i][j][0] = dp[N + 1][i][j][1] = N * N;
dp[N + 1][0][0][0] = dp[N + 1][0][0][1] = 0;
int A = N - V - K;
for (i = N; i > 0; i--) {
for (v = 0; v <= V; v++)
for (k = 0; k <= K; k++) {
dp[i][v][k][0] = dp[i][v][k][1] = N * N;
if (V - v + K - k > i - 1) continue;
int r_a = A - (i - 1 - (V - v) - (K - k));
if (r_a > 0) {
dp[i][v][k][0] =
min(dp[i][v][k][0],
get_pos(i - 1, V - v, K - k, 'A') - i + dp[i + 1][v][k][0]);
dp[i][v][k][1] =
min(dp[i][v][k][1],
get_pos(i - 1, V - v, K - k, 'A') - i + dp[i + 1][v][k][0]);
}
if (v != 0) {
dp[i][v][k][0] =
min(dp[i][v][k][0], get_pos(i - 1, V - v, K - k, 'V') - i +
dp[i + 1][v - 1][k][1]);
dp[i][v][k][1] =
min(dp[i][v][k][1], get_pos(i - 1, V - v, K - k, 'V') - i +
dp[i + 1][v - 1][k][1]);
}
if (k != 0)
dp[i][v][k][0] =
min(dp[i][v][k][0], get_pos(i - 1, V - v, K - k, 'K') - i +
dp[i + 1][v][k - 1][0]);
}
}
cout << dp[1][V][K][0] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[80][80][80][3], len;
char str[80];
int solve(int V, int K, int EX, int lst) {
if (V + K + EX == len) return 0;
int &ret = dp[V][K][EX][lst];
if (ret != -1) return ret;
ret = 0x3f3f3f3f;
int cv = -1, ck = -1, cex = -1, c = 0, i, TV = V, TK = K, TEX = EX;
for (i = 0; str[i]; i++) {
if (str[i] == 'V' && V) {
V--;
continue;
} else if (str[i] == 'K' && K) {
K--;
continue;
} else if (str[i] != 'V' && str[i] != 'K' && EX) {
EX--;
continue;
}
if (str[i] == 'V' && cv == -1)
cv = c;
else if (str[i] == 'K' && ck == -1)
ck = c;
else if (str[i] != 'V' && str[i] != 'K' && cex == -1)
cex = c;
c++;
}
if (cv != -1) ret = min(ret, solve(TV + 1, TK, TEX, 0) + cv);
if (ck != -1 && lst) ret = min(ret, solve(TV, TK + 1, TEX, 1) + ck);
if (cex != -1) ret = min(ret, solve(TV, TK, TEX + 1, 2) + cex);
return ret;
}
int main() {
scanf("%d", &len);
scanf("%s", str);
memset(dp, -1, sizeof(dp));
cout << solve(0, 0, 0, 2) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kN = 75 + 5;
const int kInf = 1e9;
int dp[kN][kN][kN][2];
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
string s;
cin >> n >> s;
vector<int> V, K, X;
for (int i = 0; i < n; ++i) {
if (s[i] == 'V')
V.push_back(i);
else if (s[i] == 'K')
K.push_back(i);
else
X.push_back(i);
}
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= n; ++k) {
dp[i][j][k][0] = dp[i][j][k][1] = kInf;
}
}
}
dp[0][0][0][0] = dp[0][0][0][1] = 0;
for (int v = 0; v <= V.size(); ++v) {
for (int k = 0; k <= K.size(); ++k) {
for (int x = 0; x <= X.size(); ++x) {
for (int is_v = 0; is_v <= 1; ++is_v) {
int cur_cost = dp[v][k][x][is_v];
auto CountLeft = [](vector<int>& A, int from, int last) {
int cnt = 0;
for (int i = from; i < A.size() && A[i] < last; ++i) {
++cnt;
}
return cnt;
};
auto ComputeCost = [&](int& ind) {
return CountLeft(V, v, ind) + CountLeft(K, k, ind) +
CountLeft(X, x, ind);
};
if (v < V.size()) {
dp[v + 1][k][x][1] =
min(dp[v + 1][k][x][1], cur_cost + ComputeCost(V[v]));
}
if (k < K.size() && !is_v) {
dp[v][k + 1][x][0] =
min(dp[v][k + 1][x][0], cur_cost + ComputeCost(K[k]));
}
if (x < X.size()) {
dp[v][k][x + 1][0] =
min(dp[v][k][x + 1][0], cur_cost + ComputeCost(X[x]));
}
}
}
}
}
cout << min(dp[V.size()][K.size()][X.size()][0],
dp[V.size()][K.size()][X.size()][1])
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e7;
const int N = 77;
int dp[N][N][N][3];
vector<int> pos[3];
vector<int> lft[3][3];
void relax(int& x, int y) { x = min(x, y); }
void solve() {
int n;
cin >> n;
string buff;
cin >> buff;
for (int i = 0; i < n; i++) {
int ind;
if (buff[i] == 'V')
ind = 0;
else if (buff[i] == 'K')
ind = 1;
else
ind = 2;
pos[ind].push_back(i);
for (int j = 0; j < 3; j++) lft[ind][j].push_back(pos[j].size());
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
for (int t = 0; t < 3; t++) dp[i][j][k][t] = INF;
dp[0][0][0][1] = 0;
int c[3];
for (c[0] = 0; c[0] <= pos[0].size(); c[0]++)
for (c[1] = 0; c[1] <= pos[1].size(); c[1]++)
for (c[2] = 0; c[2] <= pos[2].size(); c[2]++)
for (int lst = 0; lst < 3; lst++) {
int val = dp[c[0]][c[1]][c[2]][lst];
if (val == INF) continue;
for (int nxt = 0; nxt < 3; nxt++) {
if (c[nxt] == pos[nxt].size()) continue;
if (lst == 0 && nxt == 1) continue;
int cur = c[0] + c[1] + c[2];
int got = pos[nxt][c[nxt]];
for (int j = 0; j < 3; j++) {
if (j == nxt) continue;
if (c[j] > lft[nxt][j][c[nxt]]) got += c[j] - lft[nxt][j][c[nxt]];
}
int cost = 0;
if (got > cur) cost += got - cur;
c[nxt]++;
relax(dp[c[0]][c[1]][c[2]][nxt], val + cost);
c[nxt]--;
}
}
int ans = INF;
for (int t = 0; t < 3; t++)
ans = min(ans, dp[pos[0].size()][pos[1].size()][pos[2].size()][t]);
cout << ans << endl;
}
int main() {
solve();
(void)0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 80;
int dp[maxn][maxn][maxn][2];
char s[maxn];
int a[maxn];
int n;
vector<int> cnt[maxn];
int pos[maxn][3];
int main() {
scanf("%d %s", &n, s + 1);
for (int i = 0; i <= n; ++i) {
if (s[i] == 'V')
a[i] = 0;
else if (s[i] == 'K')
a[i] = 1;
else
a[i] = 2;
cnt[i].resize(3, 0);
}
for (int i = 1; i <= n; i++) {
cnt[i] = cnt[i - 1];
cnt[i][a[i]]++;
pos[cnt[i][a[i]]][a[i]] = i;
}
for (int i = 0; i <= cnt[n][0]; i++) {
for (int j = 0; j <= cnt[n][1]; j++) {
for (int k = 0; k <= cnt[n][2]; k++) {
dp[i][j][k][0] = dp[i][j][k][1] = 1e9;
}
}
}
dp[0][0][0][1] = 0;
for (int i = 0; i <= cnt[n][0]; i++) {
for (int j = 0; j <= cnt[n][1]; j++) {
for (int k = 0; k <= cnt[n][2]; k++) {
if (i < cnt[n][0]) {
int p = pos[i + 1][0];
int c = max(0, cnt[p][1] - j) + max(0, cnt[p][2] - k);
dp[i + 1][j][k][0] =
min(dp[i + 1][j][k][0], min(dp[i][j][k][0], dp[i][j][k][1]) + c);
}
if (j < cnt[n][1]) {
int p = pos[j + 1][1];
int c = max(0, cnt[p][0] - i) + max(0, cnt[p][2] - k);
dp[i][j + 1][k][1] = min(dp[i][j + 1][k][1], dp[i][j][k][1] + c);
}
if (k < cnt[n][2]) {
int p = pos[k + 1][2];
int c = max(0, cnt[p][0] - i) + max(0, cnt[p][1] - j);
dp[i][j][k + 1][1] =
min(dp[i][j][k + 1][1], min(dp[i][j][k][0], dp[i][j][k][1]) + c);
}
}
}
}
int res = min(dp[cnt[n][0]][cnt[n][1]][cnt[n][2]][0],
dp[cnt[n][0]][cnt[n][1]][cnt[n][2]][1]);
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 100000000;
int f0[100], f1[100], f2[100], f[100][4], F0[100][100][100], F1[100][100][100],
F2[100][100][100];
int n;
char S[100];
int main() {
scanf("%d", &n);
scanf("%s", S);
int a0 = 0, a1 = 0, a2 = 0;
for (int i = 0; i < n; i++) {
if (S[i] == 'V') {
a0++;
f0[a0] = i;
} else if (S[i] == 'K') {
a1++;
f1[a1] = i;
} else {
a2++;
f2[a2] = i;
}
f[i][0] = a0;
f[i][1] = a1;
f[i][2] = a2;
}
for (int i = 0; i <= a0; i++)
for (int j = 0; j <= a1; j++)
for (int k = 0; k <= a2; k++) {
if (!i && !j && !k) {
continue;
}
if (i == 0)
F0[i][j][k] = inf;
else {
int K = f0[i];
F0[i][j][k] =
F0[i - 1][j][k] + max(f[K][1] - j, 0) + max(f[K][2] - k, 0);
F0[i][j][k] = min(F0[i][j][k], F1[i - 1][j][k] + max(f[K][1] - j, 0) +
max(f[K][2] - k, 0));
F0[i][j][k] = min(F0[i][j][k], F2[i - 1][j][k] + max(f[K][1] - j, 0) +
max(f[K][2] - k, 0));
}
if (j == 0)
F1[i][j][k] = inf;
else {
int K = f1[j];
F1[i][j][k] =
F1[i][j - 1][k] + max(f[K][0] - i, 0) + max(f[K][2] - k, 0);
F1[i][j][k] = min(F1[i][j][k], F2[i][j - 1][k] + max(f[K][0] - i, 0) +
max(f[K][2] - k, 0));
}
if (k == 0)
F2[i][j][k] = inf;
else {
int K = f2[k];
F2[i][j][k] =
F0[i][j][k - 1] + max(f[K][0] - i, 0) + max(f[K][1] - j, 0);
F2[i][j][k] = min(F2[i][j][k], F1[i][j][k - 1] + max(f[K][0] - i, 0) +
max(f[K][1] - j, 0));
F2[i][j][k] = min(F2[i][j][k], F2[i][j][k - 1] + max(f[K][0] - i, 0) +
max(f[K][1] - j, 0));
}
}
int ans = min(min(F0[a0][a1][a2], F1[a0][a1][a2]), F2[a0][a1][a2]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
vector<int> v, k, o;
int n;
char st[100];
long long f[77][77][77][2];
int main() {
n = read();
memset(f, 127, sizeof(f));
scanf("%s", st + 1);
for (int i = 1; i <= n; i++)
if (st[i] == 'V')
v.push_back(i);
else if (st[i] == 'K')
k.push_back(i);
else
o.push_back(i);
f[0][0][0][0] = 0;
for (int i = 0; i <= v.size(); i++)
for (int j = 0; j <= k.size(); j++)
for (int l = 0; l <= o.size(); l++)
for (int c = 0; c <= 2; c++) {
if ((!i) && (!c)) continue;
if ((!j) && c == 1) continue;
if ((!l) && c == 2) continue;
int pos, num = 0;
if (!c)
pos = v[i - 1];
else if (c == 1)
pos = k[j - 1];
else
pos = o[l - 1];
for (int m = i; m < v.size() && v[m] < pos; m++) num++;
for (int m = j; m < k.size() && k[m] < pos; m++) num++;
for (int m = l; m < o.size() && o[m] < pos; m++) num++;
if (c == 0)
for (int m = 0; m <= 1; m++)
f[i][j][l][1] = min(f[i][j][l][1], f[i - 1][j][l][m] + num);
if (c == 1)
for (int m = 0; m <= 0; m++)
f[i][j][l][0] = min(f[i][j][l][0], f[i][j - 1][l][m] + num);
if (c == 2)
for (int m = 0; m <= 1; m++)
f[i][j][l][0] = min(f[i][j][l][0], f[i][j][l - 1][m] + num);
}
int a = v.size(), b = k.size(), c = o.size();
cout << min(f[a][b][c][0], f[a][b][c][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const long long oo = 1 << 30;
const long long loo = 1ll << 62;
const long long mods = 998244353;
const long long MAXN = 200005;
const long long INF = 0x3f3f3f3f;
inline long long read() {
long long f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
char st[80];
vector<long long> V, K, O;
long long f[80][80][80][2];
long long get(long long x, long long y, long long z, long long pos) {
long long num = 0;
for (long long i = 0; i < x; i++)
if (V[i] > pos) num++;
for (long long i = 0; i < y; i++)
if (K[i] > pos) num++;
for (long long i = 0; i < z; i++)
if (O[i] > pos) num++;
return num;
}
signed main() {
long long n = read();
scanf("%s", st);
for (long long i = 0; i < n; i++) {
if (st[i] == 'V')
V.push_back(i);
else if (st[i] == 'K')
K.push_back(i);
else
O.push_back(i);
}
for (long long i = 0; i <= V.size(); i++)
for (long long j = 0; j <= K.size(); j++)
for (long long k = 0; k <= O.size(); k++)
f[i][j][k][0] = f[i][j][k][1] = INF;
f[0][0][0][0] = 0;
for (long long i = 0; i <= V.size(); i++)
for (long long j = 0; j <= K.size(); j++)
for (long long k = 0; k <= O.size(); k++) {
if (i < V.size())
upmin(f[i + 1][j][k][1], f[i][j][k][0] + get(i, j, k, V[i]));
if (i < V.size())
upmin(f[i + 1][j][k][1], f[i][j][k][1] + get(i, j, k, V[i]));
if (j < K.size())
upmin(f[i][j + 1][k][0], f[i][j][k][0] + get(i, j, k, K[j]));
if (k < O.size())
upmin(f[i][j][k + 1][0], f[i][j][k][0] + get(i, j, k, O[k]));
if (k < O.size())
upmin(f[i][j][k + 1][0], f[i][j][k][1] + get(i, j, k, O[k]));
}
printf("%d\n", min(f[V.size()][K.size()][O.size()][0],
f[V.size()][K.size()][O.size()][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
vector<int> v, k, x;
int dp[100][100][100][2];
inline int solve(int xx, int y, int z, int zz) {
int res = 0;
for (int i = y; i < v.size() && v[i] < xx; ++i) ++res;
for (int i = z; i < k.size() && k[i] < xx; ++i) ++res;
for (int i = zz; i < x.size() && x[i] < xx; ++i) ++res;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> s;
for (int i = 1; i <= n; ++i) {
if (s[i - 1] == 'V')
v.push_back(i);
else if (s[i - 1] == 'K')
k.push_back(i);
else
x.push_back(i);
}
for (int i = 0; i <= v.size(); ++i)
for (int j = 0; j <= k.size(); ++j)
for (int ii = 0; ii <= x.size(); ++ii)
for (int zz = 0; zz < 2; ++zz) dp[i][j][ii][zz] = 1e9;
dp[0][0][0][0] = 0;
for (int i = 0; i <= v.size(); ++i) {
for (int j = 0; j <= k.size(); ++j) {
for (int ii = 0; ii <= x.size(); ++ii) {
for (int jj = 0; jj < 2; ++jj)
if (dp[i][j][ii][jj] != 1e9) {
int res = dp[i][j][ii][jj];
if (i < v.size())
dp[i + 1][j][ii][1] =
min(dp[i + 1][j][ii][1], res + solve(v[i], i, j, ii));
if (j < k.size() && !jj)
dp[i][j + 1][ii][0] =
min(dp[i][j + 1][ii][0], res + solve(k[j], i, j, ii));
if (ii < x.size())
dp[i][j][ii + 1][0] =
min(dp[i][j][ii + 1][0], res + solve(x[ii], i, j, ii));
}
}
}
}
int ans = dp[v.size()][k.size()][x.size()][0];
ans = min(ans, dp[v.size()][k.size()][x.size()][1]);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[80];
int posv[80], posk[80], posa[80], sumv[80], sumk[80], suma[80], cnta, cntv,
cntk;
int dp[80][80][80][2];
int main() {
scanf("%d", &n);
scanf(" %s", s + 1);
for (int i = 1; i < (n + 1); i++) {
suma[i] = suma[i - 1];
sumv[i] = sumv[i - 1];
sumk[i] = sumk[i - 1];
if (s[i] == 'V') {
sumv[i] += 1;
cntv++;
posv[cntv] = i;
} else if (s[i] == 'K') {
sumk[i] += 1;
cntk++;
posk[cntk] = i;
} else {
suma[i] += 1;
cnta++;
posa[cnta] = i;
}
}
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i < (cntv + 1); i++) {
for (int j = 0; j < (cntk + 1); j++) {
for (int k = 0; k < (cnta + 1); k++) {
int pos = i + j + k + 1;
if (i < cntv) {
dp[i + 1][j][k][1] = min(dp[i + 1][j][k][1],
dp[i][j][k][0] + abs(sumk[posv[i + 1]] - j) +
abs(suma[posv[i + 1]] - k));
dp[i + 1][j][k][1] = min(dp[i + 1][j][k][1],
dp[i][j][k][1] + abs(sumk[posv[i + 1]] - j) +
abs(suma[posv[i + 1]] - k));
}
if (j < cntk) {
dp[i][j + 1][k][0] = min(dp[i][j + 1][k][0],
dp[i][j][k][0] + abs(sumv[posk[j + 1]] - i) +
abs(suma[posk[j + 1]] - k));
}
if (k < cnta) {
dp[i][j][k + 1][0] = min(dp[i][j][k + 1][0],
dp[i][j][k][0] + abs(sumv[posa[k + 1]] - i) +
abs(sumk[posa[k + 1]] - j));
dp[i][j][k + 1][0] = min(dp[i][j][k + 1][0],
dp[i][j][k][1] + abs(sumv[posa[k + 1]] - i) +
abs(sumk[posa[k + 1]] - j));
}
}
}
}
printf("%d\n", min(dp[cntv][cntk][cnta][1], dp[cntv][cntk][cnta][0]) / 2);
}
|
#include <bits/stdc++.h>
using namespace std;
int fastio() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
cin.tie(nullptr);
return 0;
}
int __fastio = fastio();
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p);
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
string sep = "{";
for (auto e : v) os << sep << e, sep = ", ";
return os << "}";
}
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
const int MAXN = 80;
const int inf = 1000 << 20;
int DP[MAXN][MAXN][MAXN][2];
int cnts[3][MAXN];
int main() {
int n;
string s;
cin >> n >> s;
vector<int> pos[3];
;
for (int i = 0; i < n; ++i) {
int type;
if (s[i] == 'V')
type = 0;
else if (s[i] == 'K')
type = 1;
else
type = 2;
pos[type].push_back(i);
for (int j = 0; j < 3; ++j) {
cnts[j][i + 1] = cnts[j][i];
}
++cnts[type][i + 1];
};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
for (int w = 0; w < 2; ++w) {
DP[i][j][k][w] = inf;
}
}
}
}
DP[0][0][0][1] = 0;
int ans = inf;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
for (int w = 0; w < 2; ++w) {
if (DP[i][j][k][w] < inf)
;
for (int nxt = 0; nxt < 3; ++nxt) {
int used[] = {j, k, i - j - k};
if (used[nxt] >= pos[nxt].size()) continue;
if (nxt == 1 && w == 0) {
continue;
}
int p = pos[nxt][used[nxt]];
int inversions = 0;
for (int t = 0; t < 3; ++t) {
inversions += max(0, cnts[t][p] - used[t]);
}
int v = DP[i][j][k][w] + inversions;
max(0, pos[nxt][used[nxt]] - i);
++used[nxt];
int nj = used[0];
int nk = used[1];
int& nv = DP[i + 1][nj][nk][nxt > 0];
if (v < inf)
;
nv = min(nv, v);
if (i + 1 == n) {
ans = min(ans, v);
}
}
}
}
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int GLL(long long& x) { return scanf("%lld", &x); }
int GI(int& x) { return scanf("%d", &x); }
const int MAXN = 80;
int dp[MAXN][MAXN][MAXN][2];
const int MAXC = 26;
int charcnt[MAXC];
int n;
string s;
int getPos(char c, int i, int j, int k) {
int prevc = j;
int prekc = k;
int prexc = i - j - k;
int pos = 1;
memset(charcnt, 0, sizeof charcnt);
for (int m = 1; m <= (int)(n); m++) {
charcnt[s[m] - 'A']++;
if (charcnt[c - 'A'] <
(c == 'V' ? prevc + 1 : (c == 'K' ? prekc + 1 : prexc + 1))) {
pos++;
} else {
if (s[m] != c && s[m] == 'V' && charcnt['V' - 'A'] <= prevc) {
pos++;
}
if (s[m] != c && s[m] == 'K' && charcnt['K' - 'A'] <= prekc) {
pos++;
}
if (s[m] != c && s[m] == 'X' && charcnt['X' - 'A'] <= prexc) {
pos++;
}
}
}
return pos;
}
int main() {
GI(n);
cin >> s;
int vc = 0;
int kc = 0;
int xc = 0;
for (auto& c : s) {
if (c == 'V') {
vc++;
} else if (c == 'K') {
kc++;
} else {
c = 'X';
xc++;
}
}
s = 'X' + s;
for (int i = 0; i < (int)(MAXN); i++)
for (int j = 0; j < (int)(MAXN); j++)
for (int k = 0; k < (int)(MAXN); k++)
for (int l = 0; l < (int)(2); l++) dp[i][j][k][l] = 2000000000;
dp[0][0][0][0] = 0;
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(i + 1); j++) {
for (int k = 0; k < (int)(i + 1); k++) {
for (int l = 0; l < (int)(2); l++) {
if (dp[i][j][k][l] >= 2000000000) continue;
if (vc - j > 0) {
int pos = getPos('V', i, j, k);
dp[i + 1][j + 1][k][1] =
min(dp[i + 1][j + 1][k][1], dp[i][j][k][l] + pos - (i + 1));
}
if (kc - k > 0 && l == 0) {
int pos = getPos('K', i, j, k);
dp[i + 1][j][k + 1][0] =
min(dp[i + 1][j][k + 1][0], dp[i][j][k][l] + pos - (i + 1));
}
if (xc - (i - j - k) > 0) {
int pos = getPos('X', i, j, k);
dp[i + 1][j][k][0] =
min(dp[i + 1][j][k][0], dp[i][j][k][l] + pos - (i + 1));
}
}
}
}
}
cout << min(dp[n][vc][kc][0], dp[n][vc][kc][1]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 80, T = 3, INF = 1e9;
string s;
long long n;
struct occ {
long long a[T];
long long &operator[](long long i) { return a[i]; }
};
bool operator==(occ a, occ b) {
for (long long t = 0; t < (long long)(T); t++)
if (a[t] != b[t]) return false;
return true;
}
occ tot;
long long mem[T][N][N][N];
string repr(occ cur) {
string my;
occ cnt{0, 0, 0};
for (long long i = 0; i < (long long)(n); i++) {
long long tt = s[i] - 'A';
cnt[tt]++;
if (cnt[tt] > cur[tt]) my += s[i];
}
return my;
}
long long dp(occ cur, long long t) {
long long &res = mem[t][cur[0]][cur[1]][cur[2]];
if (res == -1) {
res = INF;
if (cur == tot)
res = 0;
else {
occ take = cur;
if (t == 2) take[t]++;
for (; take[t] <= tot[t]; take[t]++) {
occ cnt{0, 0, 0};
long long cost = 0;
for (long long i = 0; i < (long long)(n); i++) {
long long tt = s[i] - 'A';
if (cnt[tt] < take[tt])
cnt[tt]++;
else {
cost += take[t] - max(cnt[t], cur[t]);
}
}
long long here = cost + dp(take, (t + 1) % T);
if (res > here) {
res = here;
}
}
}
}
return res;
}
signed main() {
while (cin >> n >> s) {
tot = {0, 0, 0};
for (long long i = 0; i < (long long)(n); i++) {
if (s[i] == 'K')
s[i] = 'A';
else if (s[i] == 'V')
s[i] = 'B';
else
s[i] = 'C';
tot[s[i] - 'A']++;
}
fill(**mem[0], **mem[T], -1);
cout << dp({0, 0, 0}, 0) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> vv, vk, vx;
const int N = 77;
const int INF = 0x3f3f3f3f;
int dp[N][N][N][2];
int count_remaining(const vector<int> &vat, int from, int to) {
int cnt = 0;
for (int i = from; i < (int)vat.size() && vat[i] < to; ++i) {
++cnt;
}
return cnt;
}
int moving_cost(int where, int v, int k, int x) {
return count_remaining(vv, v, where) + count_remaining(vk, k, where) +
count_remaining(vx, x, where);
}
void chk_min(int &a, int b) { a = min(a, b); }
int main() {
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; ++i) {
if (s[i] == 'V') {
vv.push_back(i);
} else if (s[i] == 'K') {
vk.push_back(i);
} else {
vx.push_back(i);
}
}
for (int a = 0; a <= n; ++a) {
for (int b = 0; b <= n; ++b) {
for (int c = 0; c <= n; ++c) {
for (int d = 0; d < 2; ++d) {
dp[a][b][c][d] = INF;
}
}
}
}
dp[0][0][0][0] = 0;
int sz_v = vv.size();
int sz_k = vk.size();
int sz_x = vx.size();
for (int v = 0; v <= sz_v; ++v) {
for (int k = 0; k <= sz_k; ++k) {
for (int x = 0; x <= sz_x; ++x) {
for (int type = 0; type < 2; ++type) {
int atual = dp[v][k][x][type];
if (v < sz_v) {
chk_min(dp[v + 1][k][x][1], atual + moving_cost(vv[v], v, k, x));
}
if (k < sz_k && type == 0) {
chk_min(dp[v][k + 1][x][0], atual + moving_cost(vk[k], v, k, x));
}
if (x < sz_x) {
chk_min(dp[v][k][x + 1][0], atual + moving_cost(vx[x], v, k, x));
}
}
}
}
}
int answer = INF;
for (int i = 0; i < 2; ++i) {
chk_min(answer, dp[sz_v][sz_k][sz_x][i]);
}
cout << answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[3][80][80][80];
int f[3][80];
int f0, f1, f2;
int p[3][80];
char str[80];
int main() {
int n;
scanf("%d%s", &n, str);
for (int i = 0; i < n; i++) {
if (str[i] == 'V') {
f[1][i]++, f1++;
p[1][f1] = i;
} else if (str[i] == 'K') {
f[2][i]++, f2++;
p[2][f2] = i;
} else {
f[0][i]++, f0++;
p[0][f0] = i;
}
for (int j = 0; j < 3; j++) f[j][i + 1] = f[j][i];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
for (int l = 0; l < 3; l++) dp[l][i][j][k] = 9999999;
dp[0][f0][f1][f2] = 0;
for (int i = f0; i >= 0; i--)
for (int j = f1; j >= 0; j--)
for (int k = f2; k >= 0; k--)
for (int l = 0; l < 3; l++) {
if (dp[l][i][j][k] == 9999999) continue;
for (int m = 0; m < 3; m++) {
if (l == 1 && m == 2) continue;
if (m == 0 && i > 0) {
int pos = p[0][f0 - i + 1];
int tot = max(f[1][pos] - f1 + j, 0) + max(f[2][pos] - f2 + k, 0);
dp[m][i - 1][j][k] =
min(dp[m][i - 1][j][k], dp[l][i][j][k] + tot);
} else if (m == 1 && j > 0) {
int pos = p[1][f1 - j + 1];
int tot = max(f[0][pos] - f0 + i, 0) + max(f[2][pos] - f2 + k, 0);
dp[m][i][j - 1][k] =
min(dp[m][i][j - 1][k], dp[l][i][j][k] + tot);
} else if (m == 2 && k > 0) {
int pos = p[2][f2 - k + 1];
int tot = max(f[0][pos] - f0 + i, 0) + max(f[1][pos] - f1 + j, 0);
dp[m][i][j][k - 1] =
min(dp[m][i][j][k - 1], dp[l][i][j][k] + tot);
}
}
}
int ans = 9999999;
for (int i = 0; i < 3; i++) ans = min(ans, dp[i][0][0][0]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 77;
int vi[N], ki[N], other[N];
int dp[N][N][N][2], n;
int x, y, z;
string s;
int sol(int ind, int v, int k, int prev) {
if (ind + v + k == n) {
return 0;
}
int &ret = dp[ind][v][k][prev];
if (ret != -1) return ret;
pair<int, int> index[3];
int pv, pk, po, cv, ck, co;
string temp;
pv = 0, pk = 0, po = 0;
cv = ck = co = -1;
int cost = 0;
for (int i = 0; i < n; ++i) {
int *a, *b, *c;
if (s[i] == 'V')
a = &pv, b = &v, c = &cv;
else if (s[i] == 'K')
a = &pk, b = &k, c = &ck;
else
a = &po, b = &ind, c = &co;
*a = *a + 1;
if (*a > *b) {
if (*c == -1) *c = cost;
++cost;
}
}
ret = 1e9;
if (cv >= 0) ret = min(ret, cv + sol(ind, v + 1, k, 1));
if (ck >= 0 && prev == 0) ret = min(ret, ck + sol(ind, v, k + 1, 0));
if (co >= 0) ret = min(ret, co + sol(ind + 1, v, k, 0));
return ret;
}
int main() {
memset(dp, -1, sizeof(dp));
int i;
cin >> n >> s;
cout << sol(0, 0, 0, 0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 80;
int dp[maxn][maxn][maxn][3];
char str[maxn];
int n;
int arr[maxn], cnt[3];
int bef[3][maxn][3];
int main() {
scanf("%d%s", &n, str);
for (int i = 0; i < n; i++) {
if (str[i] == 'V')
arr[i] = 0;
else if (str[i] == 'K')
arr[i] = 1;
else
arr[i] = 2;
for (int j = 0; j < 3; j++) bef[arr[i]][cnt[arr[i]]][j] = cnt[j];
cnt[arr[i]]++;
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0][2] = 0;
for (int i = 0; i < n; i++) {
for (int s0 = 0; s0 <= min(i, cnt[0]); s0++)
for (int s1 = 0; s0 + s1 <= i && s1 <= cnt[1]; s1++)
for (int last = 0; last < 3; last++) {
int s2 = i - s0 - s1;
if (s0 < cnt[0]) {
int sbef = max(0, bef[0][s0][1] - s1) + max(0, bef[0][s0][2] - s2);
dp[i + 1][s0 + 1][s1][0] =
min(dp[i + 1][s0 + 1][s1][0], dp[i][s0][s1][last] + sbef);
}
if (s1 < cnt[1] && last != 0) {
int sbef = max(0, bef[1][s1][0] - s0) + max(0, bef[1][s1][2] - s2);
dp[i + 1][s0][s1 + 1][1] =
min(dp[i + 1][s0][s1 + 1][1], dp[i][s0][s1][last] + sbef);
}
if (s2 < cnt[2]) {
int sbef = max(0, bef[2][s2][0] - s0) + max(0, bef[2][s2][1] - s1);
dp[i + 1][s0][s1][2] =
min(dp[i + 1][s0][s1][2], dp[i][s0][s1][last] + sbef);
}
}
}
int ans = 1000000000;
for (int i = 0; i < 3; i++) ans = min(dp[n][cnt[0]][cnt[1]][i], ans);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, O, V, K, p, t;
int f[80][80][80][2], sum[3][80];
char str[80];
vector<int> ve[3];
int main() {
scanf("%d", &n);
scanf("%s", str + 1);
for (int i = 1; i <= n; ++i) {
if (str[i] == 'V')
++V, ve[0].push_back(i);
else if (str[i] == 'K')
++K, ve[1].push_back(i);
else
++O, ve[2].push_back(i);
sum[0][i] = V;
sum[1][i] = K;
sum[2][i] = O;
}
memset(f, 0x3f, sizeof(f));
f[0][0][0][1] = 0;
for (int i = 0; i <= V; ++i)
for (int j = 0; j <= K; ++j)
for (int k = 0; k <= O; ++k) {
if (i < V) {
p = ve[0][i];
t = i + 1 + max(j, sum[1][p]) + max(k, sum[2][p]) - (i + 1) - j - k;
f[i + 1][j][k][0] = min(f[i + 1][j][k][0], f[i][j][k][0] + t);
f[i + 1][j][k][0] = min(f[i + 1][j][k][0], f[i][j][k][1] + t);
}
if (j < K) {
p = ve[1][j];
t = max(i, sum[0][p]) + j + 1 + max(k, sum[2][p]) - i - (j + 1) - k;
f[i][j + 1][k][1] = min(f[i][j + 1][k][1], f[i][j][k][1] + t);
}
if (k < O) {
p = ve[2][k];
t = max(i, sum[0][p]) + max(j, sum[1][p]) + (k + 1) - i - j - (k + 1);
f[i][j][k + 1][1] = min(f[i][j][k + 1][1], f[i][j][k][0] + t);
f[i][j][k + 1][1] = min(f[i][j][k + 1][1], f[i][j][k][1] + t);
}
}
printf("%d\n", min(f[V][K][O][0], f[V][K][O][1]));
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n;
string second;
int a[100];
vector<int> g[202];
int dp[77][77][77][4];
int calc(vector<int> &a, int n, vector<int> &b, int m, vector<int> &c, int k) {
n = a.size() - n;
m = (int)b.size() - m;
k = (int)c.size() - k;
int x = a[n];
int cnt = 0;
for (int i = m; i < b.size(); i++)
if (b[i] < x) cnt++;
for (int i = k; i < c.size(); i++)
if (c[i] < x) cnt++;
return cnt;
}
int get(int a, int b, int c, int ty) {
if (a + b + c == 0) return 0;
int &res = dp[a][b][c][ty];
if (res != -1) return res;
res = inf;
if (a > 0) {
if (ty != 1)
res = min(res, get(a - 1, b, c, 0) + calc(g[0], a, g[1], b, g[2], c));
}
if (b > 0) {
res = min(res, get(a, b - 1, c, 1) + calc(g[1], b, g[0], a, g[2], c));
}
if (c > 0) {
res = min(res, get(a, b, c - 1, 2) + calc(g[2], c, g[1], b, g[0], a));
}
return res;
}
int main() {
cin >> n >> second;
for (int i = 0; i < n; i++) {
if (second[i] == 'V')
a[i] = 1;
else if (second[i] == 'K')
a[i] = 0;
else
a[i] = 2;
g[a[i]].push_back(i);
}
memset(dp, -1, sizeof dp);
cout << get(g[0].size(), g[1].size(), g[2].size(), 3) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n;
int A[100];
string second;
int dp[88][88][88][4];
int k[3] = {0, 0, 0};
int can(int a, int b) {
if (a == 0 && b == 1) return false;
return true;
}
int calc(int a, int b, int c, int last) {
if (a > k[0] || b > k[1] || c > k[2]) return inf;
if (a == k[0] && b == k[1] && c == k[2]) return 0;
int &res = dp[a][b][c][last];
if (res != -1) return res;
int tmp[3] = {a, b, c};
vector<int> cur;
for (int i = 0; i < n; i++) {
if (tmp[A[i]] == 0)
cur.push_back(A[i]);
else
tmp[A[i]]--;
}
tmp[0] = a;
tmp[1] = b;
tmp[2] = c;
res = inf;
for (int i = 0; i < cur.size(); i++) {
int t = cur[i];
tmp[t]++;
if (can(last, t)) res = min(res, i + calc(tmp[0], tmp[1], tmp[2], t));
tmp[t]--;
}
return res;
}
int main() {
cin >> n >> second;
for (int i = 0; i < n; i++) {
if (second[i] == 'V')
A[i] = 0;
else if (second[i] == 'K')
A[i] = 1;
else
A[i] = 2;
}
for (int i = 0; i < n; i++) {
k[A[i]]++;
}
memset(dp, -1, sizeof dp);
printf("%d\n", calc(0, 0, 0, 2));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
vector<int> V, K, X;
int dp[100][100][100][2];
inline int min(int x1, int x2) { return x1 < x2 ? x1 : x2; }
int count(int sv, int sk, int sx, int end) {
int ans = 0;
for (int i = sv; i < V.size() && V[i] < end; i++) ans++;
for (int i = sk; i < K.size() && K[i] < end; i++) ans++;
for (int i = sx; i < X.size() && X[i] < end; i++) ans++;
return ans;
}
int main() {
int n;
cin >> n >> s;
for (int i = 0; i < n; i++) switch (s[i]) {
case 'V':
V.push_back(i);
break;
case 'K':
K.push_back(i);
break;
default:
X.push_back(i);
break;
}
for (int v = 0; v <= V.size(); v++)
for (int k = 0; k <= K.size(); k++)
for (int x = 0; x <= X.size(); x++)
for (int last = 0; last < 2; last++) dp[v][k][x][last] = 1e9;
dp[0][0][0][0] = 0;
for (int v = 0; v <= V.size(); v++)
for (int k = 0; k <= K.size(); k++)
for (int x = 0; x <= X.size(); x++)
for (int last = 0; last < 2; last++) {
if (v < V.size())
dp[v + 1][k][x][1] = min(dp[v + 1][k][x][1],
dp[v][k][x][last] + count(v, k, x, V[v]));
if (k < K.size() && last == 0)
dp[v][k + 1][x][0] = min(dp[v][k + 1][x][0],
dp[v][k][x][last] + count(v, k, x, K[k]));
if (x < X.size())
dp[v][k][x + 1][0] = min(dp[v][k][x + 1][0],
dp[v][k][x][last] + count(v, k, x, X[x]));
}
int ans = 1e9;
ans = min(dp[V.size()][K.size()][X.size()][0],
dp[V.size()][K.size()][X.size()][1]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 123;
void run();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
run();
return 0;
}
const int N = 80;
int n;
string s;
int a[N];
int dp[N][N][N][2];
vector<int> p[3];
int calc(int v, int k, int x, int pos) {
int res = 0;
int cnt[3] = {0, 0, 0};
for (int i = 0; i < pos; i++) {
cnt[a[i]]++;
}
res += max(cnt[0], v);
res += max(cnt[1], k);
res += max(cnt[2], x);
return abs(res - (v + k + x));
}
void run() {
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'V') {
a[i] = 0;
} else if (s[i] == 'K') {
a[i] = 1;
} else {
a[i] = 2;
}
p[a[i]].push_back(i);
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int t = 0; t < N; t++) {
for (int k = 0; k < 2; k++) {
dp[i][j][t][k] = INF;
}
}
}
}
dp[0][0][0][0] = 0;
for (int v = 0; v <= (int)(p[0]).size(); v++) {
for (int k = 0; k <= (int)(p[1]).size(); k++) {
for (int x = 0; x <= (int)(p[2]).size(); x++) {
for (int t = 0; t < 2; t++) {
if (v != (int)(p[0]).size()) {
dp[v + 1][k][x][1] = min(dp[v + 1][k][x][1],
dp[v][k][x][t] + calc(v, k, x, p[0][v]));
}
if (!t && k != (int)(p[1]).size()) {
dp[v][k + 1][x][0] = min(dp[v][k + 1][x][0],
dp[v][k][x][t] + calc(v, k, x, p[1][k]));
}
if (x != (int)(p[2]).size()) {
dp[v][k][x + 1][0] = min(dp[v][k][x + 1][0],
dp[v][k][x][t] + calc(v, k, x, p[2][x]));
}
}
}
}
}
cout << min(
dp[(int)(p[0]).size()][(int)(p[1]).size()][(int)(p[2]).size()][0],
dp[(int)(p[0]).size()][(int)(p[1]).size()][(int)(p[2]).size()][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 233;
char s[N];
int dp[N][N][N][2], k[N], v[N], x[N], lk, lv, lx, vv[N], kk[N], xx[N];
int main() {
int ls;
scanf("%d", &ls);
scanf("%s", s + 1);
lk = lv = lx = 0;
for (int i = 1; i <= ls; ++i) {
vv[i] = vv[i - 1];
kk[i] = kk[i - 1];
xx[i] = xx[i - 1];
if (s[i] == 'V')
v[++lv] = i, vv[i]++;
else if (s[i] == 'K')
k[++lk] = i, kk[i]++;
else
x[++lx] = i, xx[i]++;
}
v[lv + 1] = k[lk + 1] = x[lx + 1] = ls + 1;
for (int iv = 0; iv <= lv; ++iv)
for (int ik = 0; ik <= lk; ++ik)
for (int ix = 0; ix <= lx; ++ix)
dp[iv][ik][ix][0] = dp[iv][ik][ix][1] = 1e9;
dp[0][0][0][0] = 0;
for (int iv = 0; iv <= lv; ++iv)
for (int ik = 0; ik <= lk; ++ik)
for (int ix = 0; ix <= lx; ++ix) {
int jpv = 0, jpk = 0, jpx = 0;
if (v[iv] > k[ik]) jpv += kk[v[iv]] - ik;
if (v[iv] > x[ix]) jpv += xx[v[iv]] - ix;
if (k[ik] > v[iv]) jpk += vv[k[ik]] - iv;
if (k[ik] > x[ix]) jpk += xx[k[ik]] - ix;
if (x[ix] > v[iv]) jpx += vv[x[ix]] - iv;
if (x[ix] > k[ik]) jpx += kk[x[ix]] - ik;
if (iv)
dp[iv][ik][ix][1] =
min(dp[iv - 1][ik][ix][1], dp[iv - 1][ik][ix][0]) + jpv;
if (ik) dp[iv][ik][ix][0] = dp[iv][ik - 1][ix][0] + jpk;
if (ix)
dp[iv][ik][ix][0] =
min(dp[iv][ik][ix][0],
min(dp[iv][ik][ix - 1][0], dp[iv][ik][ix - 1][1]) + jpx);
}
printf("%d\n", min(dp[lv][lk][lx][0], dp[lv][lk][lx][1]));
return 0;
}
|
#include <bits/stdc++.h>
int n, i, j, k, who, prevx[88], prevk[88], prekx[88], prekv[88], prexv[88],
prexk[88], cx, ck, cv, dp[88][88][88][3];
char s[111];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (i = 1; i <= n; i++) {
if (s[i] == 'V') {
cv++;
prevx[cv] = cx;
prevk[cv] = ck;
} else if (s[i] == 'K') {
ck++;
prekx[ck] = cx;
prekv[ck] = cv;
} else {
cx++;
prexv[cx] = cv;
prexk[cx] = ck;
}
}
for (i = 0; i <= cv; i++)
for (j = 0; j <= ck; j++)
for (k = 0; k <= cx; k++)
for (who = 0; who <= 2; who++) dp[i][j][k][who] = 1000000000;
dp[0][0][0][2] = 0;
for (i = 0; i <= cv; i++)
for (j = 0; j <= ck; j++)
for (k = 0; k <= cx; k++) {
if (i) {
dp[i][j][k][0] =
(dp[i][j][k][0] < dp[i - 1][j][k][0] +
(0 > prevk[i] - j ? 0 : prevk[i] - j) +
(0 > prevx[i] - k ? 0 : prevx[i] - k)
? dp[i][j][k][0]
: dp[i - 1][j][k][0] +
(0 > prevk[i] - j ? 0 : prevk[i] - j) +
(0 > prevx[i] - k ? 0 : prevx[i] - k));
dp[i][j][k][0] =
(dp[i][j][k][0] < dp[i - 1][j][k][1] +
(0 > prevk[i] - j ? 0 : prevk[i] - j) +
(0 > prevx[i] - k ? 0 : prevx[i] - k)
? dp[i][j][k][0]
: dp[i - 1][j][k][1] +
(0 > prevk[i] - j ? 0 : prevk[i] - j) +
(0 > prevx[i] - k ? 0 : prevx[i] - k));
dp[i][j][k][0] =
(dp[i][j][k][0] < dp[i - 1][j][k][2] +
(0 > prevk[i] - j ? 0 : prevk[i] - j) +
(0 > prevx[i] - k ? 0 : prevx[i] - k)
? dp[i][j][k][0]
: dp[i - 1][j][k][2] +
(0 > prevk[i] - j ? 0 : prevk[i] - j) +
(0 > prevx[i] - k ? 0 : prevx[i] - k));
}
if (j) {
dp[i][j][k][1] =
(dp[i][j][k][1] < dp[i][j - 1][k][1] +
(0 > prekv[j] - i ? 0 : prekv[j] - i) +
(0 > prekx[j] - k ? 0 : prekx[j] - k)
? dp[i][j][k][1]
: dp[i][j - 1][k][1] +
(0 > prekv[j] - i ? 0 : prekv[j] - i) +
(0 > prekx[j] - k ? 0 : prekx[j] - k));
dp[i][j][k][1] =
(dp[i][j][k][1] < dp[i][j - 1][k][2] +
(0 > prekv[j] - i ? 0 : prekv[j] - i) +
(0 > prekx[j] - k ? 0 : prekx[j] - k)
? dp[i][j][k][1]
: dp[i][j - 1][k][2] +
(0 > prekv[j] - i ? 0 : prekv[j] - i) +
(0 > prekx[j] - k ? 0 : prekx[j] - k));
}
if (k) {
dp[i][j][k][2] =
(dp[i][j][k][2] < dp[i][j][k - 1][0] +
(0 > prexv[k] - i ? 0 : prexv[k] - i) +
(0 > prexk[k] - j ? 0 : prexk[k] - j)
? dp[i][j][k][2]
: dp[i][j][k - 1][0] +
(0 > prexv[k] - i ? 0 : prexv[k] - i) +
(0 > prexk[k] - j ? 0 : prexk[k] - j));
dp[i][j][k][2] =
(dp[i][j][k][2] < dp[i][j][k - 1][1] +
(0 > prexv[k] - i ? 0 : prexv[k] - i) +
(0 > prexk[k] - j ? 0 : prexk[k] - j)
? dp[i][j][k][2]
: dp[i][j][k - 1][1] +
(0 > prexv[k] - i ? 0 : prexv[k] - i) +
(0 > prexk[k] - j ? 0 : prexk[k] - j));
dp[i][j][k][2] =
(dp[i][j][k][2] < dp[i][j][k - 1][2] +
(0 > prexv[k] - i ? 0 : prexv[k] - i) +
(0 > prexk[k] - j ? 0 : prexk[k] - j)
? dp[i][j][k][2]
: dp[i][j][k - 1][2] +
(0 > prexv[k] - i ? 0 : prexv[k] - i) +
(0 > prexk[k] - j ? 0 : prexk[k] - j));
}
}
printf("%d",
((dp[cv][ck][cx][0] < dp[cv][ck][cx][1]
? dp[cv][ck][cx][0]
: dp[cv][ck][cx][1]) < dp[cv][ck][cx][2]
? (dp[cv][ck][cx][0] < dp[cv][ck][cx][1] ? dp[cv][ck][cx][0]
: dp[cv][ck][cx][1])
: dp[cv][ck][cx][2]));
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const long long maxn = 70 + 10, N = 2e6 + 90, SQ = 300, base = 1999,
mod = 1e9 + 7, INF = 1e9 + 1, lg = 25;
const long double eps = 1e-4;
long long n, dp[maxn][maxn][maxn][2], sz1, sz2, sz3;
string s;
inline void pre() {
for (long long i = 0; i < n; ++i) {
if (s[i] == 'V') {
sz1++;
}
if (s[i] == 'K') {
sz2++;
}
if (s[i] != 'V' && s[i] != 'K') {
s[i] = 'X';
sz3++;
}
}
for (long long i = 0; i <= n; ++i) {
for (long long j = 0; j <= n; ++j) {
for (long long k = 0; k <= n; ++k) {
dp[i][j][k][0] = dp[i][j][k][1] = INF;
}
}
}
dp[0][0][0][0] = 0;
}
inline void find_first(long long &id1, long long &id2, long long &id3,
long long i, long long j, long long k) {
long long c1 = 0, c2 = 0, c3 = 0;
string tmp = "";
for (long long id = 0; id < n; ++id) {
if (s[id] == 'V') {
c1++;
if (c1 > i) {
tmp += s[id];
}
}
if (s[id] == 'K') {
c2++;
if (c2 > j) {
tmp += s[id];
}
}
if (s[id] == 'X') {
c3++;
if (c3 > k) {
tmp += s[id];
}
}
}
for (long long id = 0; id < (long long)tmp.size(); ++id) {
if (tmp[id] == 'V' && id1 == -1) {
id1 = id;
}
if (tmp[id] == 'K' && id2 == -1) {
id2 = id;
}
if (tmp[id] == 'X' && id3 == -1) {
id3 = id;
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> s;
pre();
for (long long i = 0; i <= sz1; ++i) {
for (long long j = 0; j <= sz2; ++j) {
for (long long k = 0; k <= sz3; ++k) {
long long id1 = -1, id2 = -1, id3 = -1;
find_first(id1, id2, id3, i, j, k);
if (id1 != -1) {
dp[i + 1][j][k][1] = min(dp[i + 1][j][k][1], dp[i][j][k][0] + id1);
dp[i + 1][j][k][1] = min(dp[i + 1][j][k][1], dp[i][j][k][1] + id1);
}
if (id2 != -1) {
dp[i][j + 1][k][0] = min(dp[i][j + 1][k][0], dp[i][j][k][0] + id2);
}
if (id3 != -1) {
dp[i][j][k + 1][0] = min(dp[i][j][k + 1][0], dp[i][j][k][0] + id3);
dp[i][j][k + 1][0] = min(dp[i][j][k + 1][0], dp[i][j][k][1] + id3);
}
}
}
}
cout << min(dp[sz1][sz2][sz3][0], dp[sz1][sz2][sz3][1]) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
int cntV, cntK, cntX, cntVK[N], cntVX[N], cntKV[N], cntKX[N], cntXV[N],
cntXK[N], f[N][N][N][2], n;
char s[N];
void update(int& x, int y) {
if (x > y) x = y;
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++)
if (s[i] == 'V') {
cntV++;
cntVK[cntV] = cntK;
cntVX[cntV] = cntX;
} else if (s[i] == 'K') {
cntK++;
cntKV[cntK] = cntV;
cntKX[cntK] = cntX;
} else {
cntX++;
cntXV[cntX] = cntV;
cntXK[cntX] = cntK;
}
memset(f, 0x3f, sizeof(f));
f[0][0][0][0] = 0;
for (int i = 0; i <= cntV; i++)
for (int j = 0; j <= cntK; j++)
for (int k = 0; k <= cntX; k++)
for (int msk = 0; msk < 2; msk++) {
if (i < cntV)
update(f[i + 1][j][k][1], f[i][j][k][msk] +
max(0, cntVK[i + 1] - j) +
max(0, cntVX[i + 1] - k));
if (j < cntK && !msk)
update(f[i][j + 1][k][0], f[i][j][k][msk] +
max(0, cntKV[j + 1] - i) +
max(0, cntKX[j + 1] - k));
if (k < cntX)
update(f[i][j][k + 1][0], f[i][j][k][msk] +
max(0, cntXV[k + 1] - i) +
max(0, cntXK[k + 1] - j));
}
printf("%d\n", min(f[cntV][cntK][cntX][0], f[cntV][cntK][cntX][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char str[80];
int len, vcnt[80], kcnt[80], xcnt[80], vnxt[80], knxt[80], xnxt[80],
dp[77][77][77][2];
vector<int> vpos, kpos, xpos;
void go(vector<int>& pos, int nxt[]) {
if (pos.empty()) {
nxt[0] = -1;
return;
}
nxt[0] = pos[0];
for (int i = 1; i < pos.size(); i++) {
nxt[pos[i - 1]] = pos[i];
}
nxt[pos.back()] = -1;
}
int dfs(int v, int k, int x, int lastv) {
int& ret = dp[v][k][x][lastv];
if (ret != -1) return ret;
ret = 1e9;
if (vnxt[v] == -1 && knxt[k] == -1 && xnxt[x] == -1) {
return ret = 0;
}
if (knxt[k] != -1 && lastv == 0) {
int mv = 0;
if (v < knxt[k]) mv += vcnt[knxt[k]] - vcnt[v];
if (x < knxt[k]) mv += xcnt[knxt[k]] - xcnt[x];
ret = min(ret, mv + dfs(v, knxt[k], x, 0));
}
if (vnxt[v] != -1) {
int mv = 0;
if (k < vnxt[v]) mv += kcnt[vnxt[v]] - kcnt[k];
if (x < vnxt[v]) mv += xcnt[vnxt[v]] - xcnt[x];
ret = min(ret, mv + dfs(vnxt[v], k, x, 1));
}
if (xnxt[x] != -1) {
int mv = 0;
if (v < xnxt[x]) mv += vcnt[xnxt[x]] - vcnt[v];
if (k < xnxt[x]) mv += kcnt[xnxt[x]] - kcnt[k];
ret = min(ret, mv + dfs(v, k, xnxt[x], 0));
}
return ret;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
scanf("%s", str + 1);
len = strlen(str + 1);
for (int i = 1; i <= len; i++) {
vcnt[i] = vcnt[i - 1];
kcnt[i] = kcnt[i - 1];
xcnt[i] = xcnt[i - 1];
if (str[i] == 'V') {
++vcnt[i];
vpos.push_back(i);
} else if (str[i] == 'K') {
++kcnt[i];
kpos.push_back(i);
} else {
xcnt[i]++;
xpos.push_back(i);
}
}
go(vpos, vnxt);
go(kpos, knxt);
go(xpos, xnxt);
int ans = dfs(0, 0, 0, 0);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
const int oo = 1e9;
int dp[N][N][N][2];
int cnt[N][3], n;
int V, K, O;
string str;
int cost(int v, int k, int o, int f, int t) {
if (t == 1 and f) return oo;
int ret = 0;
for (auto u : str) {
if (u == 'V')
v--;
else if (u == 'K')
k--;
else
o--;
if (t == 0 and v == 0) break;
if (t == 1 and k == 0) break;
if (t == 2 and o == 0) break;
}
return abs(v) + abs(k) + abs(o);
}
int recur(int v, int k, int o, int f) {
if (v > V || k > K || o > O) return oo;
if (v + k + o == n) return 0;
int &ret = dp[v][k][o][f];
if (ret != -1) return ret;
ret = oo;
ret = min(ret, cost(v + 1, k, o, f, 0) + recur(v + 1, k, o, 1));
ret = min(ret, cost(v, k + 1, o, f, 1) + recur(v, k + 1, o, 0));
ret = min(ret, cost(v, k, o + 1, f, 2) + recur(v, k, o + 1, 0));
return ret;
}
int main() {
cin >> n >> str;
for (auto c : str) {
if (c == 'V')
V++;
else if (c == 'K')
K++;
else
O++;
}
memset(dp, -1, sizeof dp);
cout << recur(0, 0, 0, 0) / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 77, oo = 1000000000;
int i, j, k, l, n, m, n0, n1, n2, ans;
int a0[N], a1[N], a2[N], s0[N], s1[N], s2[N], f[N][N][N][3];
char s[N];
int min(const int &x, const int &y) {
if (x < y) return x;
return y;
}
int max(const int &x, const int &y) {
if (x < y) return y;
return x;
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (i = 1; i <= n; i++) {
if (s[i] == 'V') a0[++n0] = i, s0[i]++;
if (s[i] == 'K') a1[++n1] = i, s1[i]++;
if (s[i] != 'V' && s[i] != 'K') a2[++n2] = i, s2[i]++;
s0[i] += s0[i - 1];
s1[i] += s1[i - 1];
s2[i] += s2[i - 1];
}
memset(f, 60, sizeof f);
f[0][0][0][2] = 0;
for (i = 0; i <= n0; i++)
for (j = 0; j <= n1; j++)
for (k = 0; k <= n2; k++)
if (i != n0 || j != n1 || k != n2)
for (l = 0; l < 3; l++)
if (f[i][j][k][l] < oo) {
if (i < n0)
f[i + 1][j][k][0] =
min(f[i + 1][j][k][0], f[i][j][k][l] +
max(0, j - s1[a0[i + 1]]) +
max(0, k - s2[a0[i + 1]]));
if (j < n1 && l != 0)
f[i][j + 1][k][1] =
min(f[i][j + 1][k][1], f[i][j][k][l] +
max(0, i - s0[a1[j + 1]]) +
max(0, k - s2[a1[j + 1]]));
if (k < n2)
f[i][j][k + 1][2] =
min(f[i][j][k + 1][2], f[i][j][k][l] +
max(0, i - s0[a2[k + 1]]) +
max(0, j - s1[a2[k + 1]]));
}
ans = oo;
for (i = 0; i < 3; i++) ans = min(ans, f[n0][n1][n2][i]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
struct ofl {
long double value;
int precision;
inline ofl(long double value, int precision)
: value(value), precision(precision) {}
};
const int seed = hash<string>()("alex256");
const int inf = (int)1e9 + 7;
const int64_t llInf = (int64_t)2e18 + 256;
const int mod = (int)1e9 + 7;
const long double pi = 3.141592653589793238462643383279502884197169399375105821;
const string luck = "🍀";
const char* errText = "error :(";
template <typename T1, typename T2>
inline istream& operator>>(istream& is, pair<T1, T2>& p) {
return is >> p.first >> p.second;
}
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << p.first << " " << p.second;
}
template <typename T>
inline istream& operator>>(istream& is, vector<T>& v) {
for (int i = 0; i < (int)(v.size()); i++) {
is >> v[i];
}
return is;
}
template <typename T>
inline ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < (int)(v.size()); i++) {
if (i) {
os << " ";
}
os << v[i];
}
return os;
}
inline ostream& operator<<(ostream& os, const ofl& o) {
return os << fixed << setprecision(o.precision) << o.value;
}
inline bool iosOptimize() {
ios_base::sync_with_stdio(false);
return true;
}
bool iosOptimized = iosOptimize();
template <typename T>
inline T get() {
T value;
cin >> value;
return value;
}
template <>
inline char get() {
char c = '\0';
while (c <= ' ') {
cin >> c;
}
return c;
}
inline string getLn() {
string s;
getline(cin, s);
return s;
}
template <typename T, size_t Count>
struct VectorPacker {};
template <typename T>
struct VectorPacker<T, 0> {};
template <typename T>
inline vector<T> getVector(int size) {
vector<T> res(size);
cin >> res;
return res;
}
template <typename T, typename U, typename... Args>
inline typename VectorPacker<T, sizeof...(Args) + 1>::T getVector(
U size, Args... sizes) {
typename VectorPacker<T, sizeof...(Args) + 1>::T res(size);
for (int i = 0; i < (int)size; i++) {
res[i] = getVector<T>(sizes...);
}
return res;
}
inline void put() {}
template <typename T, typename... Args>
inline void put(const T& value, const Args&... vals) {
cout << value;
put(vals...);
}
template <typename... Args>
inline void putLn(const Args&... vals) {
put(vals...);
cout << "\n";
}
namespace std {
template <typename T1, typename T2>
struct hash<pair<T1, T2> > {
inline size_t operator()(const pair<T1, T2>& p) const {
return hash<T1>()(p.first) ^ hash<T2>()(p.second);
}
};
}; // namespace std
mt19937_64 rnd(seed);
inline void error(const char* text = errText) {
;
exit(256);
}
template <typename T1, typename T2>
inline void umax(T1& a, const T2& b) {
if (a < b) {
a = b;
}
}
template <typename T1, typename T2>
inline void umin(T1& a, const T2& b) {
if (a > b) {
a = b;
}
}
int64_t gcd(int64_t a, int64_t b) { return b ? gcd(b, a % b) : a; }
int64_t extGcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {
if (!a) {
x = 0;
y = 1;
return b;
}
int64_t x1, y1, d = extGcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
inline int addMod(int a, int b, int m = mod) { return ((int64_t)a + b) % m; }
inline int subMod(int a, int b, int m = mod) {
return ((int64_t)a + m - b) % m;
}
inline int mulMod(int a, int b, int m = mod) { return ((int64_t)a * b) % m; }
inline int divMod(int a, int b, int m = mod) {
int64_t x, y;
int64_t g = extGcd(b, m, x, y);
if (g != 1) {
;
exit(42);
}
x = (x % m + m) % m;
return mulMod(a, x, m);
}
int n = get<int>();
string s = get<string>();
int dp[80][80][80][3];
signed main() {
vector<int> q(n);
for (int i = 0; i < n; i++) {
if (s[i] == 'V') {
q[i] = 0;
} else if (s[i] == 'K') {
q[i] = 1;
} else {
q[i] = 2;
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= n; k++) {
for (int l = 0; l < 3; l++) {
dp[i][j][k][l] = inf;
}
}
}
}
int ans = inf;
dp[0][0][0][2] = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= n; k++) {
for (int l = 0; l < 3; l++) {
if (i + j + k == n) {
umin(ans, dp[i][j][k][l]);
}
if (dp[i][j][k][l] == inf) {
continue;
}
int ktr[3] = {i, j, k};
int add[3] = {i, j, k};
int beforeThis = 0;
for (int m = 0; m < n; m++) {
int qur = q[m];
if (ktr[qur] == 0) {
if (!(l == 0 && qur == 1)) {
add[qur]++;
umin(dp[add[0]][add[1]][add[2]][qur],
dp[i][j][k][l] + beforeThis);
add[qur]--;
}
beforeThis++;
} else {
ktr[qur]--;
}
}
}
}
}
}
putLn(ans);
return 0;
}
|
#include <bits/stdc++.h>
struct State {
int v;
int k;
int x;
bool is_v_last;
State(const int v, const int k, const int x, const bool is_v_last)
: v(v), k(k), x(x), is_v_last(is_v_last) {}
bool operator==(const State& other) const {
return v == other.v && k == other.k && x == other.x &&
is_v_last == other.is_v_last;
}
};
struct MyStateHash {
const size_t operator()(const State& other) const {
return std::hash<int>()(other.v) ^ std::hash<int>()(other.k) ^
std::hash<int>()(other.x) ^ std::hash<bool>()(other.is_v_last);
}
};
struct Counts {
int v;
int k;
int x;
Counts(const int v, const int k, const int x) : v(v), k(k), x(x) {}
};
size_t get_id(const int v, const int k, const int x, bool is_v_last,
const int string_size) {
return 2 * string_size * string_size * v + 2 * string_size * k + 2 * x +
(is_v_last ? 1 : 0);
}
void update_score(std::vector<int>& state_score, const size_t state,
const size_t base_state, const int new_value) {
if (state_score[base_state] != -1) {
int old_state_value = state_score[base_state];
if (state_score[state] == -1 ||
state_score[state] > new_value + old_state_value) {
state_score[state] = new_value + old_state_value;
}
}
}
int main() {
int string_size;
std::cin >> string_size;
std::vector<Counts> counts;
std::vector<int> v_indices;
std::vector<int> k_indices;
std::vector<int> x_indices;
Counts cur_counts(0, 0, 0);
for (size_t i = 0; i < string_size; ++i) {
char letter;
std::cin >> letter;
if (letter == 'K') {
++cur_counts.k;
k_indices.push_back(i);
} else if (letter == 'V') {
++cur_counts.v;
v_indices.push_back(i);
} else {
++cur_counts.x;
x_indices.push_back(i);
}
counts.push_back(cur_counts);
}
std::vector<int> state_score(string_size * string_size * string_size * 3, -1);
state_score[0] = 0;
state_score[1] = 0;
for (int n = 0; n <= string_size; ++n) {
for (int k = 0; k <= std::min(n, cur_counts.k); ++k) {
for (int v = 0; v <= std::min(n - k, cur_counts.v); ++v) {
for (int x = 0; x <= std::min(n - k - v, cur_counts.x); ++x) {
if (k > 0) {
int index = k_indices[k - 1];
Counts count = counts[index];
update_score(state_score, get_id(v, k, x, false, string_size),
get_id(v, k - 1, x, false, string_size),
(index - v - k - x + 1 + std::max(0, v - count.v) +
std::max(0, x - count.x)));
}
if (v > 0) {
int index = v_indices[v - 1];
Counts count = counts[index];
update_score(state_score, get_id(v, k, x, true, string_size),
get_id(v - 1, k, x, false, string_size),
(index - v - k - x + 1 + std::max(0, k - count.k) +
std::max(0, x - count.x)));
update_score(state_score, get_id(v, k, x, true, string_size),
get_id(v - 1, k, x, true, string_size),
(index - v - k - x + 1 + std::max(0, k - count.k) +
std::max(0, x - count.x)));
}
if (x > 0) {
int index = x_indices[x - 1];
Counts count = counts[index];
update_score(state_score, get_id(v, k, x, false, string_size),
get_id(v, k, x - 1, false, string_size),
(index - v - k - x + 1 + std::max(0, k - count.k) +
std::max(0, v - count.v)));
update_score(state_score, get_id(v, k, x, false, string_size),
get_id(v, k, x - 1, true, string_size),
(index - v - k - x + 1 + std::max(0, k - count.k) +
std::max(0, v - count.v)));
}
}
}
}
}
int result = -1;
for (int is_v_last = 0; is_v_last < 2; ++is_v_last) {
long long int id = get_id(cur_counts.v, cur_counts.k, cur_counts.x,
is_v_last, string_size);
if (state_score[id] != -1) {
if (result == -1 || result > state_score[id]) {
result = state_score[id];
}
}
}
std::cout << result << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, d[2][77][77][77], cnt[3][77], calc, pos;
vector<long long> v[3];
char c[111];
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> c[i];
for (long long j = 0; j < 3; j++) cnt[j][i] = cnt[j][i - 1];
if (c[i] == 'V')
cnt[0][i]++, v[0].push_back(i);
else if (c[i] == 'K')
cnt[1][i]++, v[1].push_back(i);
else
cnt[2][i]++, v[2].push_back(i);
}
for (long long i = 0; i <= n; i++)
for (long long j = 0; j <= n; j++)
for (long long k = 0; k <= n; k++) d[0][i][j][k] = d[1][i][j][k] = 2e9;
d[0][0][0][0] = 0;
for (long long i = 0; i <= cnt[0][n]; i++)
for (long long j = 0; j <= cnt[1][n]; j++)
for (long long k = 0; k <= cnt[2][n]; k++)
if (min(d[0][i][j][k], d[1][i][j][k]) < 2e9) {
if (i < cnt[0][n]) {
pos = v[0][i];
calc = pos - i - 1 - min(cnt[1][pos], j) - min(cnt[2][pos], k);
d[1][i + 1][j][k] = min(d[1][i + 1][j][k],
min(d[0][i][j][k], d[1][i][j][k]) + calc);
}
if (j < cnt[1][n]) {
pos = v[1][j];
calc = pos - j - 1 - min(cnt[0][pos], i) - min(cnt[2][pos], k);
d[0][i][j + 1][k] = min(d[0][i][j + 1][k], d[0][i][j][k] + calc);
}
if (k < cnt[2][n]) {
pos = v[2][k];
calc = pos - k - 1 - min(cnt[1][pos], j) - min(cnt[0][pos], i);
d[0][i][j][k + 1] = min(d[0][i][j][k + 1],
min(d[0][i][j][k], d[1][i][j][k]) + calc);
}
}
cout << min(d[0][cnt[0][n]][cnt[1][n]][cnt[2][n]],
d[1][cnt[0][n]][cnt[1][n]][cnt[2][n]]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
vector<int> V;
vector<int> K;
vector<int> X;
int dp[N][N][N][2];
int cnt(int v, int k, int x, int lim) {
int res = 0;
for (int i = v; i < V.size() && V[i] < lim; i++) res++;
for (int i = k; i < K.size() && K[i] < lim; i++) res++;
for (int i = x; i < X.size() && X[i] < lim; i++) res++;
return res;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
for (int w = 0; w < 2; w++) {
dp[i][j][k][w] = 2e9;
}
}
}
}
for (int i = 0; i < n; i++) {
char c;
cin >> c;
if (c == 'V')
V.push_back(i);
else if (c == 'K')
K.push_back(i);
else
X.push_back(i);
}
dp[0][0][0][0] = 0;
for (int v = 0; v <= V.size(); v++) {
for (int k = 0; k <= K.size(); k++) {
for (int x = 0; x <= X.size(); x++) {
for (int w = 0; w < 2; w++) {
int a = dp[v][k][x][w];
if (v < V.size())
dp[v + 1][k][x][1] =
min(dp[v + 1][k][x][1], a + cnt(v, k, x, V[v]));
if (k < K.size() && w == 0)
dp[v][k + 1][x][0] =
min(dp[v][k + 1][x][0], a + cnt(v, k, x, K[k]));
if (x < X.size())
dp[v][k][x + 1][0] =
min(dp[v][k][x + 1][0], a + cnt(v, k, x, X[x]));
}
}
}
}
cout << min(dp[V.size()][K.size()][X.size()][0],
dp[V.size()][K.size()][X.size()][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long linf = (long long)1e18;
template <class TAT>
inline void read(TAT &res) {
char c;
res = 0;
bool neg = false;
while (c = getchar(), c != '-' && (c < '0' || c > '9'))
;
if (c == '-') neg = true, c = getchar();
do res = (res * 10) + (c ^ 48);
while (c = getchar(), c >= '0' && c <= '9');
if (neg) res = -res;
}
template <class TAT>
inline void print(TAT first) {
if (first == 0) {
putchar('0');
return;
}
if (first < 0) {
putchar('-');
first = -first;
}
static char stk[30];
int top = 0;
while (first) stk[++top] = first % 10 ^ 48, first /= 10;
while (top) putchar(stk[top--]);
}
namespace Program {
const int N = 75;
int n;
char str[N + 5];
int dp[N + 5][N + 5][N + 5][2];
int seqv[N + 5], seqk[N + 5], seqx[N + 5];
int sumv[N + 5], sumk[N + 5], sumx[N + 5];
inline void chkMin(int &first, int second) {
if (first > second) first = second;
}
void Main() {
;
;
scanf("%d %s", &n, str + 1);
;
;
int cntv = 0, cntk = 0, cntx = 0;
sumv[0] = sumk[0] = sumx[0] = 0;
for (int i = 1, i_END_ = n + 1; i < i_END_; ++i) {
sumv[i] = sumv[i - 1];
sumk[i] = sumk[i - 1];
sumx[i] = sumx[i - 1];
if (str[i] == 'V')
seqv[++cntv] = i, ++sumv[i];
else if (str[i] == 'K')
seqk[++cntk] = i, ++sumk[i];
else
seqx[++cntx] = i, ++sumx[i];
}
for (int v = 0, v_END_ = cntv + 1; v < v_END_; ++v)
for (int k = 0, k_END_ = cntk + 1; k < k_END_; ++k)
for (int first = 0, x_END_ = cntx + 1; first < x_END_; ++first)
for (int f = 0, f_END_ = 2; f < f_END_; ++f) dp[v][k][first][f] = inf;
dp[0][0][0][0] = 0;
for (int v = 0, v_END_ = cntv + 1; v < v_END_; ++v)
for (int k = 0, k_END_ = cntk + 1; k < k_END_; ++k)
for (int first = 0, x_END_ = cntx + 1; first < x_END_; ++first) {
if (dp[v][k][first][0])
;
;
if (dp[v][k][first][1])
;
;
int p;
if (v < cntv) {
int t = p = seqv[v + 1];
if (sumv[p - 1] < v) t += v - sumv[p - 1];
if (sumk[p - 1] < k) t += k - sumk[p - 1];
if (sumx[p - 1] < first) t += first - sumx[p - 1];
chkMin(dp[v + 1][k][first][1],
t - (v + k + first + 1) +
min(dp[v][k][first][0], dp[v][k][first][1]));
}
if (k < cntk) {
int t = p = seqk[k + 1];
if (sumv[p - 1] < v) t += v - sumv[p - 1];
if (sumk[p - 1] < k) t += k - sumk[p - 1];
if (sumx[p - 1] < first) t += first - sumx[p - 1];
chkMin(dp[v][k + 1][first][0],
t - (v + k + first + 1) + dp[v][k][first][0]);
}
if (first < cntx) {
int t = p = seqx[first + 1];
if (sumv[p - 1] < v) t += v - sumv[p - 1];
if (sumk[p - 1] < k) t += k - sumk[p - 1];
if (sumx[p - 1] < first) t += first - sumx[p - 1];
chkMin(dp[v][k][first + 1][0],
t - (v + k + first + 1) +
min(dp[v][k][first][0], dp[v][k][first][1]));
}
};
;
;
;
;
;
printf("%d\n", min(dp[cntv][cntk][cntx][0], dp[cntv][cntk][cntx][1]));
}
} // namespace Program
int main() {
srand(time(NULL));
Program::Main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
const int inf = 0x3f3f3f3f;
int n, dp[N][N][N][3];
vector<int> V[3];
char s[N];
int a[3];
int cost(int x, int y, int z, int p) {
int ret = 0;
int g = 0;
if (p == 0) {
g = V[0][x];
} else if (p == 1) {
g = V[1][y];
} else {
g = V[2][z];
}
int h = g;
for (int i = 0; i < x; i++) {
if (V[0][i] > h) {
g++;
}
}
for (int i = 0; i < y; i++) {
if (V[1][i] > h) {
g++;
}
}
for (int i = 0; i < z; i++) {
if (V[2][i] > h) {
g++;
}
}
return g - x - y - z - 1;
}
inline void Min(int &a, int b) {
if (a > b) a = b;
}
int main() {
int x;
while (~scanf("%d", &n)) {
scanf("%s", s);
for (int i = 0; i < 3; i++) {
V[i].clear();
}
for (int i = 0; i < n; i++) {
if (s[i] == 'V') {
x = 0;
} else if (s[i] == 'K') {
x = 1;
} else {
x = 2;
}
V[x].push_back(i + 1);
}
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i < 3; i++) {
a[i] = V[i].size();
}
dp[0][0][0][2] = 0;
for (int i = 0; i <= a[0]; i++) {
for (int j = 0; j <= a[1]; j++) {
for (int k = 0; k <= a[2]; k++) {
for (int l = 0; l < 3; l++) {
if (dp[i][j][k][l] == inf) continue;
if (i < a[0]) {
Min(dp[i + 1][j][k][0], dp[i][j][k][l] + cost(i, j, k, 0));
}
if (j < a[1] && l != 0) {
Min(dp[i][j + 1][k][1], dp[i][j][k][l] + cost(i, j, k, 1));
}
if (k < a[2]) {
Min(dp[i][j][k + 1][2], dp[i][j][k][l] + cost(i, j, k, 2));
}
}
}
}
}
printf("%d\n", min(dp[a[0]][a[1]][a[2]][0],
min(dp[a[0]][a[1]][a[2]][1], dp[a[0]][a[1]][a[2]][2])));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
const int inf = 1e6 + 10;
int dp[N][N][N][2];
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, V = 0, K = 0, A = 0;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
V++;
else if (s[i] == 'K')
K++;
else
A++;
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++) dp[i][j][k][0] = dp[i][j][k][1] = inf;
dp[0][0][0][0] = 0;
for (int i = 0; i <= V; i++) {
for (int j = 0; j <= K; j++) {
for (int k = 0; k <= A; k++) {
int cnt_v = 0, cnt_k = 0, cnt_a = 0, cost_v = inf, cost_k = inf,
cost_a = inf, tot = 0;
for (int p = 0; p < n; p++) {
if (s[p] == 'V') {
if (cnt_v < i)
cnt_v++;
else
cost_v = min(cost_v, tot++);
} else if (s[p] == 'K') {
if (cnt_k < j)
cnt_k++;
else
cost_k = min(cost_k, tot++);
} else {
if (cnt_a < k)
cnt_a++;
else
cost_a = min(cost_a, tot++);
}
}
dp[i + 1][j][k][1] = min({dp[i + 1][j][k][1], dp[i][j][k][0] + cost_v,
dp[i][j][k][1] + cost_v});
dp[i][j + 1][k][0] = min({dp[i][j + 1][k][0], dp[i][j][k][0] + cost_k});
dp[i][j][k + 1][0] = min({dp[i][j][k + 1][0], dp[i][j][k][0] + cost_a,
dp[i][j][k][1] + cost_a});
}
}
}
cout << min(dp[V][K][A][0], dp[V][K][A][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 77, INF = 1e7;
int N, DP[Nmax][Nmax][Nmax][3];
char S[Nmax];
vector<int> Poz[3];
int main() {
cin >> N >> (S + 1);
for (int i = 1; i <= N; ++i) {
if (S[i] != 'V' && S[i] != 'K') S[i] = 'X';
if (S[i] == 'V')
Poz[0].push_back(i);
else if (S[i] == 'K')
Poz[1].push_back(i);
else
Poz[2].push_back(i);
}
for (int i = 0; i <= N; ++i)
for (int j = 0; j <= N; ++j)
for (int k = 0; k <= N; ++k)
for (int la = 0; la < 3; ++la) DP[i][j][k][la] = INF;
auto Move = [&](int who, int i, int j, int k) {
int dist = 0;
for (int t = i; t < (int)Poz[0].size() && Poz[0][t] < who; ++t) dist++;
for (int t = j; t < (int)Poz[1].size() && Poz[1][t] < who; ++t) dist++;
for (int t = k; t < (int)Poz[2].size() && Poz[2][t] < who; ++t) dist++;
return dist;
};
DP[0][0][0][2] = 0;
for (int i = 0; i <= Poz[0].size(); i++) {
for (int j = 0; j <= Poz[1].size(); ++j) {
for (int k = 0; k <= Poz[2].size(); k++) {
for (int la = 0; la < 3; ++la) {
if (i < Poz[0].size()) {
int who = Poz[0][i];
DP[i + 1][j][k][0] =
min(DP[i + 1][j][k][0], DP[i][j][k][la] + Move(who, i, j, k));
}
if (j < Poz[1].size() && la != 0) {
int who = Poz[1][j];
DP[i][j + 1][k][1] =
min(DP[i][j + 1][k][1], DP[i][j][k][la] + Move(who, i, j, k));
}
if (k < Poz[2].size()) {
int who = Poz[2][k];
DP[i][j][k + 1][2] =
min(DP[i][j][k + 1][2], DP[i][j][k][la] + Move(who, i, j, k));
}
}
}
}
}
int ans = INF;
for (int la = 0; la < 3; ++la)
ans = min(ans, DP[Poz[0].size()][Poz[1].size()][Poz[2].size()][la]);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 80;
const int inf = 0x3f3f3f3f;
int n;
char str[maxn];
int pos[3][maxn];
int pre[3][maxn];
int dp[maxn][maxn][maxn][2];
int d(int v, int k, int x, int f) {
if ((v | k | x | f) == 0) return 0;
int& ans = dp[v][k][x][f];
if (ans != -1) return ans;
ans = inf;
if (f) {
int p = pos[0][v];
int add =
max(0, pre[0][p] - v) + max(0, pre[1][p] - k) + max(0, pre[2][p] - x);
if (v) {
ans = min(ans, d(v - 1, k, x, 0) + add);
ans = min(ans, d(v - 1, k, x, 1) + add);
return ans;
} else
return ans = inf;
} else {
if (k) {
int p = pos[1][k];
int add =
max(0, pre[0][p] - v) + max(0, pre[1][p] - k) + max(0, pre[2][p] - x);
ans = min(ans, d(v, k - 1, x, 0) + add);
}
if (x) {
int p = pos[2][x];
int add =
max(0, pre[0][p] - v) + max(0, pre[1][p] - k) + max(0, pre[2][p] - x);
ans = min(ans, d(v, k, x - 1, 0) + add);
ans = min(ans, d(v, k, x - 1, 1) + add);
}
return ans;
}
}
void init() {
int v = 0, k = 0, x = 0;
scanf("%d %s", &n, str);
for (int i = 0; i < n; i++) {
pre[0][i] = v;
pre[1][i] = k;
pre[2][i] = x;
if (str[i] == 'V') {
v++;
pos[0][v] = i;
} else if (str[i] == 'K') {
k++;
pos[1][k] = i;
} else {
x++;
pos[2][x] = i;
}
}
memset(dp, -1, sizeof(dp));
printf("%d\n", min(d(v, k, x, 0), d(v, k, x, 1)));
}
int main() {
init();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int upd(int& a, int b) { return a = min(a, b); }
inline int _abs(int x) { return x > 0 ? x : -x; }
char c;
int n, cnt[3], type[80];
int pos[3][80], leq[3][80];
int dp[80][80][80][80];
void getpos(void) {
for (int p = 0; p <= 2; p++) {
cnt[p] = 0;
for (int y = 1; y <= n; y++) {
while (y <= n && type[y] != p) y++;
if (y <= n) pos[p][++cnt[p]] = y;
}
leq[p][0] = 0;
for (int i = 1; i <= n; i++) leq[p][i] = leq[p][i - 1] + (type[i] == p);
}
return;
}
void trans(int i, int j, int k, int lst) {
int p0 = pos[0][i], p1 = pos[1][j], p2 = pos[2][k];
if (i > 0)
upd(dp[0][i][j][k],
dp[lst][i - 1][j][k] + _abs(j - leq[1][p0]) + _abs(k - leq[2][p0]));
if (j > 0)
upd(dp[1][i][j][k],
dp[lst][i][j - 1][k] + _abs(i - leq[0][p1]) + _abs(k - leq[2][p1]));
if (k > 0 && lst != 1)
upd(dp[2][i][j][k],
dp[lst][i][j][k - 1] + _abs(i - leq[0][p2]) + _abs(j - leq[1][p2]));
return;
}
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf(" %c", &c);
type[i] = (c == 'V' ? 1 : (c == 'K' ? 2 : 0));
}
getpos();
memset(dp, 0x1f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i <= cnt[0]; i++)
for (int j = 0; j <= cnt[1]; j++)
for (int k = 0; k <= cnt[2]; k++)
for (int lst = 0; lst <= 2; lst++) trans(i, j, k, lst);
int ans = n * n;
for (int i = 0; i <= 2; i++) upd(ans, dp[i][cnt[0]][cnt[1]][cnt[2]]);
printf("%d\n", ans >> 1);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
int mod = 1e9 + 7;
int inf = 2e9;
long long int linf = 1000000ll * 10000 * 10000;
const int maxn = 5e5 + 20;
int dp[80][80][80][3];
int A[80];
int V = 0, K = 1, X = 2;
int n;
inline int cost(int i, int j, int k, int c) {
int cnt[] = {i, j, k};
int res = 0;
for (int i = 0; i < n; i++) {
if (cnt[A[i]] > 0) {
cnt[A[i]]--;
} else {
if (A[i] == c) {
return res;
} else {
res++;
}
}
}
return maxn;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int cnt[] = {0, 0, 0};
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] != 'V' && s[i] != 'K') {
A[i] = 2;
} else {
if (s[i] == 'V') {
A[i] = 0;
} else {
A[i] = 1;
}
}
cnt[A[i]]++;
}
for (int i = 0; i < 80; i++) {
for (int j = 0; j < 80; j++) {
for (int k = 0; k < 80; k++) {
for (int z = 0; z < 3; z++) {
dp[i][j][k][z] = maxn;
}
}
}
}
dp[1][0][0][V] = cost(0, 0, 0, V);
dp[0][1][0][K] = cost(0, 0, 0, K);
dp[0][0][1][X] = cost(0, 0, 0, X);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if (i + j > n) continue;
for (int k = 0; k <= n; k++) {
if (i + j + k > n) continue;
for (int c = 0; c < 3; c++) {
if (dp[i][j][k][c] >= maxn) continue;
if (dp[i + 1][j][k][V] > dp[i][j][k][c] + cost(i, j, k, V)) {
dp[i + 1][j][k][V] = dp[i][j][k][c] + cost(i, j, k, V);
}
if (dp[i][j][k + 1][X] > dp[i][j][k][c] + cost(i, j, k, X)) {
dp[i][j][k + 1][X] = dp[i][j][k][c] + cost(i, j, k, X);
}
if (c != V) {
if (dp[i][j + 1][k][K] > dp[i][j][k][c] + cost(i, j, k, K)) {
dp[i][j + 1][k][K] = dp[i][j][k][c] + cost(i, j, k, K);
}
}
}
}
}
}
int ans = inf;
for (int c = 0; c < 3; c++) {
ans = min(ans, dp[cnt[0]][cnt[1]][cnt[2]][c]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 80, INF = 1000000009;
int n;
char a[N];
int dp[N][N][N][3];
void solv() {
scanf("%d", &n);
scanf(" %s", (a + 1));
for (int i = 1; i <= n; ++i) {
if (a[i] == 'V')
a[i] = 0;
else if (a[i] == 'K')
a[i] = 1;
else
a[i] = 2;
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
for (int k = 0; k < N; ++k) {
for (int v = 0; v < 3; ++v) {
dp[i][j][k][v] = INF;
}
}
}
}
dp[0][0][0][2] = 0;
vector<int> ve[3];
int q[3] = {};
for (int i = 1; i <= n; ++i) {
q[a[i]]++;
ve[a[i]].push_back(i);
}
int i[3];
for (i[0] = 0; i[0] <= q[0]; ++i[0]) {
for (i[1] = 0; i[1] <= q[1]; ++i[1]) {
for (i[2] = 0; i[2] <= q[2]; ++i[2]) {
for (int v = 0; v < 3; ++v) {
if (dp[i[0]][i[1]][i[2]][v] == INF) continue;
for (int u = 0; u < 3; ++u) {
if (v == 0 && u == 1) continue;
if (i[u] + 1 > q[u]) continue;
int j = ve[u][i[u]];
int qq[3] = {};
for (int k = 1; k < j; ++k) {
qq[a[k]]++;
}
int d =
j - 1 - min(i[0], qq[0]) - min(i[1], qq[1]) - min(i[2], qq[2]);
if (u == 0)
dp[i[0] + 1][i[1]][i[2]][u] =
min(dp[i[0] + 1][i[1]][i[2]][u], dp[i[0]][i[1]][i[2]][v] + d);
else if (u == 1)
dp[i[0]][i[1] + 1][i[2]][u] =
min(dp[i[0]][i[1] + 1][i[2]][u], dp[i[0]][i[1]][i[2]][v] + d);
else if (u == 2)
dp[i[0]][i[1]][i[2] + 1][u] =
min(dp[i[0]][i[1]][i[2] + 1][u], dp[i[0]][i[1]][i[2]][v] + d);
}
}
}
}
}
printf("%d\n", min(min(dp[q[0]][q[1]][q[2]][0], dp[q[0]][q[1]][q[2]][1]),
dp[q[0]][q[1]][q[2]][2]));
}
int main() {
solv();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[80][80][80][4], cnt[80][4], t;
vector<int> a[4];
string s;
const int oo = 10000;
void load() {}
int solve(int t, int i, int j, int k) {
return max(i - cnt[t - 1][0], 0) + max(j - cnt[t - 1][1], 0) +
max(k - cnt[t - 1][2], 0) + t - (i + j + k + 1);
}
void process() {
cin >> n;
cin >> s;
s = ' ' + s;
a[0].push_back(0);
a[1].push_back(0);
a[2].push_back(0);
for (int i = 1; i <= n; ++i) {
copy_n(cnt[i - 1], 3, cnt[i]);
if (s[i] == 'V')
++cnt[i][0], t = 0;
else if (s[i] == 'K')
++cnt[i][1], t = 1;
else
++cnt[i][2], t = 2;
a[t].push_back(i);
}
memset(dp, oo, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i < a[0].size(); ++i)
for (int j = 0; j < a[1].size(); ++j)
for (int k = 0; k <= a[2].size(); ++k) {
if (i < a[0].size() - 1)
dp[i + 1][j][k][1] =
min(dp[i + 1][j][k][1], min(dp[i][j][k][0], dp[i][j][k][1]) +
solve(a[0][i + 1], i, j, k));
if (j < a[1].size() - 1)
dp[i][j + 1][k][0] = min(
dp[i][j + 1][k][0], dp[i][j][k][0] + solve(a[1][j + 1], i, j, k));
if (k < a[2].size() - 1)
dp[i][j][k + 1][0] =
min(dp[i][j][k + 1][0], min(dp[i][j][k][0], dp[i][j][k][1]) +
solve(a[2][k + 1], i, j, k));
}
cout << min(dp[a[0].size() - 1][a[1].size() - 1][a[2].size() - 1][0],
dp[a[0].size() - 1][a[1].size() - 1][a[2].size() - 1][1]);
return;
}
int main() {
load();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
string fs;
int CONST = 10000000;
int main() {
cin >> n;
cin >> s;
fs = "";
int v = 0;
int x = 0;
int k = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'V') {
v++;
fs += s[i];
} else if (s[i] == 'K') {
k++;
fs += s[i];
} else {
x++;
fs += "X";
}
}
int dp[v + 1][x + 1][k + 1][2];
for (int i = 0; i <= v; i++) {
for (int j = 0; j <= x; j++) {
for (int l = 0; l <= k; l++) {
for (int m = 0; m <= 1; m++) {
dp[i][j][l][m] = CONST;
}
}
}
}
dp[0][0][0][0] = 0;
dp[0][0][0][1] = 1;
for (int i = 0; i <= v; i++) {
for (int j = 0; j <= x; j++) {
for (int l = 0; l <= k; l++) {
if (i > 0) {
int xx = 0;
int kk = 0;
int vv = 0;
for (int m = 0; m < n; m++) {
if (fs[m] == 'X') xx++;
if (fs[m] == 'K') kk++;
if (fs[m] == 'V') vv++;
if (vv >= i) break;
}
int pl = max(0, xx - j) + max(0, kk - l);
dp[i][j][l][1] = min(dp[i][j][l][1], dp[i - 1][j][l][1] + pl);
dp[i][j][l][1] = min(dp[i][j][l][1], dp[i - 1][j][l][0] + pl);
}
if (j > 0) {
int xx = 0;
int kk = 0;
int vv = 0;
for (int m = 0; m < n; m++) {
if (fs[m] == 'X') xx++;
if (fs[m] == 'K') kk++;
if (fs[m] == 'V') vv++;
if (xx >= j) break;
}
int pl = max(0, vv - i) + max(0, kk - l);
dp[i][j][l][0] = min(dp[i][j][l][0], dp[i][j - 1][l][0] + pl);
dp[i][j][l][0] = min(dp[i][j][l][0], dp[i][j - 1][l][1] + pl);
}
if (l > 0) {
int xx = 0;
int kk = 0;
int vv = 0;
for (int m = 0; m < n; m++) {
if (fs[m] == 'X') xx++;
if (fs[m] == 'K') kk++;
if (fs[m] == 'V') vv++;
if (kk >= l) break;
}
int pl = max(0, xx - j) + max(0, vv - i);
dp[i][j][l][0] = min(dp[i][j][l][0], dp[i][j][l - 1][0] + pl);
}
}
}
}
int ans = CONST;
for (int i = 0; i <= v; i++) {
for (int j = 0; j <= x; j++) {
for (int l = 0; l <= k; l++) {
if (i + j + l == n) {
ans = min(ans, dp[i][j][l][0]);
ans = min(ans, dp[i][j][l][1]);
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 77;
const int INF = 1e9;
int n;
char str[maxn];
int dp[maxn][maxn][maxn][2];
int cv[maxn];
int ck[maxn];
int cx[maxn];
int vp[maxn];
int kp[maxn];
int xp[maxn];
bool ban[maxn];
void ckMin(int &a, int b) {
if (b < a) {
a = b;
}
}
int main() {
cin >> n;
scanf("%s", str + 1);
for (int i = 1; i <= n; i++) {
if (str[i] == 'V') {
cv[i] = cv[i - 1] + 1;
ck[i] = ck[i - 1];
cx[i] = cx[i - 1];
vp[cv[i]] = i;
} else if (str[i] == 'K') {
cv[i] = cv[i - 1];
ck[i] = ck[i - 1] + 1;
cx[i] = cx[i - 1];
kp[ck[i]] = i;
} else {
cv[i] = cv[i - 1];
ck[i] = ck[i - 1];
cx[i] = cx[i - 1] + 1;
xp[cx[i]] = i;
}
}
for (int i = 0; i < maxn; i++) {
for (int j = 0; j < maxn; j++) {
for (int k = 0; k < maxn; k++) {
dp[i][j][k][0] = dp[i][j][k][1] = INF;
}
}
}
dp[0][0][0][0] = 0;
for (int i = 0; i <= cv[n]; i++) {
for (int j = 0; j <= ck[n]; j++) {
for (int k = 0; k <= cx[n]; k++) {
int pos = i + j + k;
int dis;
if (i < cv[n]) {
dis = 0;
dis += max(0, ck[vp[i + 1]] - j);
dis += max(0, cx[vp[i + 1]] - k);
ckMin(dp[i + 1][j][k][1], dp[i][j][k][0] + dis);
ckMin(dp[i + 1][j][k][1], dp[i][j][k][1] + dis);
}
if (j < ck[n]) {
dis = 0;
dis += max(0, cv[kp[j + 1]] - i);
dis += max(0, cx[kp[j + 1]] - k);
ckMin(dp[i][j + 1][k][0], dp[i][j][k][0] + dis);
}
if (k < cx[n]) {
dis = 0;
dis += max(0, cv[xp[k + 1]] - i);
dis += max(0, ck[xp[k + 1]] - j);
ckMin(dp[i][j][k + 1][0], dp[i][j][k][0] + dis);
ckMin(dp[i][j][k + 1][0], dp[i][j][k][1] + dis);
}
}
}
}
cout << min(dp[cv[n]][ck[n]][cx[n]][0], dp[cv[n]][ck[n]][cx[n]][1]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static int N;
static int pos[3][100], num[3][100], dp[100][100][100][2];
static char S[100];
inline int move(int i, int j, int k, int p) {
return max(0, num[0][p] - i) + max(0, num[1][p] - j) + max(0, num[2][p] - k) -
1;
}
int main() {
scanf("%d%s", &N, S + 1);
for (int i = 1; i <= N; i++) {
num[0][i] = num[0][i - 1];
num[1][i] = num[1][i - 1];
num[2][i] = num[2][i - 1];
if (S[i] == 'V')
pos[0][num[0][i]++] = i;
else if (S[i] == 'K')
pos[1][num[1][i]++] = i;
else
pos[2][num[2][i]++] = i;
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i <= num[0][N]; i++)
for (int j = 0; j <= num[1][N]; j++)
for (int k = 0; k <= num[2][N]; k++)
for (int is_v = 0; is_v < 2; is_v++) {
if (i < num[0][N])
dp[i + 1][j][k][1] =
min(dp[i + 1][j][k][1],
dp[i][j][k][is_v] + move(i, j, k, pos[0][i]));
if (j < num[1][N] && !is_v)
dp[i][j + 1][k][0] =
min(dp[i][j + 1][k][0],
dp[i][j][k][is_v] + move(i, j, k, pos[1][j]));
if (k < num[2][N])
dp[i][j][k + 1][0] =
min(dp[i][j][k + 1][0],
dp[i][j][k][is_v] + move(i, j, k, pos[2][k]));
}
printf("%d\n", min(dp[num[0][N]][num[1][N]][num[2][N]][0],
dp[num[0][N]][num[1][N]][num[2][N]][1]));
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.