text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const long double eps = 1e-10;
const int step[8][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {1, 1}, {1, -1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <typename t, typename t1>
t min1(t a, t1 b) {
return a < b ? a : b;
}
template <typename t, typename... arg>
t min1(t a, arg... arr) {
return min1(a, min1(arr...));
}
template <typename t, typename t1>
t max1(t a, t1 b) {
return a > b ? a : b;
}
template <typename t, typename... arg>
t max1(t a, arg... arr) {
return max1(a, max1(arr...));
}
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / max(abs1(a), abs1(b)) < eps)
return 0;
if (a < b) return -1;
return 1;
}
template <typename t>
inline int jud(t a, t b) {
if (a < b) return -1;
if (a == b) return 0;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
if (na == 0) return 0;
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
template <class T>
inline T lowb(T num) {
return num & (-num);
}
inline int bitnum(unsigned int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(unsigned long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitnum(long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitmaxl(unsigned int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(unsigned long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
inline int bitmaxl(long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
long long pow(long long n, long long m, long long mod = 0) {
if (m < 0) return 0;
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
template <class t1, class t2>
inline void add(t1 &a, t2 b, int mod = -1) {
if (mod == -1) mod = 1000000007;
a += b;
while (a >= mod) a -= mod;
while (a < 0) a += mod;
}
template <class t>
void output1(t arr) {
for (int i = 0; i < (int)arr.size(); i++) cerr << arr[i] << ' ';
cerr << endl;
}
template <class t>
void output2(t arr) {
for (int i = 0; i < (int)arr.size(); i++) output1(arr[i]);
}
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() {
ios_base::sync_with_stdio(0);
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 = 1000000007;
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 d[76][76][76][2];
char a[76], ch[4] = "VK?";
bool removed[76];
int remain;
int dp(int v, int k, int r, int forbid) {
int& res = d[v][k][r][forbid];
if (res != 0x3F3F3F3F) {
return res;
}
if (remain == 0) {
return res = 0;
}
for (int i = 0; i < 3; ++i) {
if (ch[i] == 'K' && forbid) {
continue;
}
int cnt = 0;
for (int j = 0; a[j]; ++j) {
if (!removed[j]) {
if (a[j] == ch[i]) {
removed[j] = true;
--remain;
res = min(res, dp(v + (ch[i] == 'V'), k + (ch[i] == 'K'),
r + (ch[i] == '?'), ch[i] == 'V') +
cnt);
++remain;
removed[j] = false;
break;
}
++cnt;
}
}
}
return res;
}
int main() {
scanf("%d%s", &remain, a);
memset(d, 0x3F, sizeof(d));
for (int i = 0; a[i]; ++i) {
a[i] = a[i] == 'V' || a[i] == 'K' ? a[i] : '?';
}
printf("%d\n", dp(0, 0, 0, 0));
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[76][76][76][2], n, N, M, K;
string s;
int GetCount(char c) {
int ans = 0;
for (int i = 0; i < s.size(); i++) ans += (s[i] == c);
return ans;
}
void PreProcess() {
for (int i = 0; i < s.size(); i++)
if (s[i] != 'V' && s[i] != 'K') s[i] = 'X';
N = GetCount('V');
M = GetCount('K');
K = GetCount('X');
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 GetPosition(char c, int cnt) {
int i;
for (i = 0; i < s.size() && cnt > 0; i++) cnt -= (s[i] == c);
return i - 1;
}
int GetCurrentAns(int pos, int c1, int c2, int c3) {
for (int i = 0; i < pos; i++) {
c1 -= (s[i] == 'V');
c2 -= (s[i] == 'K');
c3 -= (s[i] == 'X');
}
return max(0, -c1) + max(0, -c2) + max(0, -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] +
GetCurrentAns(GetPosition('V', 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] +
GetCurrentAns(GetPosition('K', 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] +
GetCurrentAns(GetPosition('X', 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;
const int N = 80;
int f[N][N][N][3];
char ch[N];
int pos[3][N], s[3];
int cnt[N][3];
int n;
int get(char c) {
if (c == 'V') return 0;
if (c == 'K') return 1;
return 2;
}
void init() {
for (int i = 1; i <= n; i++) {
int t = get(ch[i]);
cnt[i][0] = s[0];
cnt[i][1] = s[1];
cnt[i][2] = s[2];
pos[t][++s[t]] = i;
}
}
int cost(int t, int a, int b, int c) {
if (t == 0) {
int p = pos[t][a];
int b1 = cnt[p][1];
int c1 = cnt[p][2];
return max(b1 - b, 0) + max(c1 - c, 0);
}
if (t == 1) {
int p = pos[t][b];
int a1 = cnt[p][0], c1 = cnt[p][2];
return max(a1 - a, 0) + max(c1 - c, 0);
} else {
int p = pos[t][c];
int a1 = cnt[p][0], b1 = cnt[p][1];
return max(b1 - b, 0) + max(a1 - a, 0);
}
}
void calc_min(int &a, int b) { a = min(a, b); }
int main() {
scanf("%d", &n);
scanf("%s", ch + 1);
init();
memset(f, 0x3f, sizeof f);
f[0][0][0][1] = f[0][0][0][2] = 0;
for (int i = 0; i <= n; i++)
for (int a = 0; a <= min(s[0], i); a++)
for (int b = 0; b <= s[1] && a + b <= i; b++)
for (int t = 0; t <= 2; t++) {
int c = i - a - b;
if (c > s[2]) continue;
if (a < s[0])
calc_min(f[i + 1][a + 1][b][0],
f[i][a][b][t] + cost(0, a + 1, b, c));
if (b < s[1] && t)
calc_min(f[i + 1][a][b + 1][1],
f[i][a][b][t] + cost(1, a, b + 1, c));
if (c < s[2])
calc_min(f[i + 1][a][b][2], f[i][a][b][t] + cost(2, a, b, c + 1));
}
printf("%d\n", min(f[n][s[0]][s[1]][0],
min(f[n][s[0]][s[1]][1], f[n][s[0]][s[1]][2])));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int dp[80][80][80][2];
char s[80];
int sv[80], sk[80], so[80];
int pv[80], pk[80], po[80];
int nv, nk, no;
int main() {
scanf("%d%s", &n, s);
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
sv[i + 1] = sv[i];
sk[i + 1] = sk[i];
so[i + 1] = so[i];
if (s[i] == 'V')
pv[nv++] = i, sv[i + 1]++;
else if (s[i] == 'K')
pk[nk++] = i, sk[i + 1]++;
else
po[no++] = i, so[i + 1]++;
}
for (int v = 0, ThxDem = nv + 1; v < ThxDem; ++v)
for (int k = 0, ThxDem = nk + 1; k < ThxDem; ++k)
for (int o = 0, ThxDem = no + 1; o < ThxDem; ++o)
for (int i = 0, ThxDem = 2; i < ThxDem; ++i) dp[v][k][o][i] = 1 << 20;
dp[0][0][0][0] = 0;
for (int v = 0, ThxDem = nv + 1; v < ThxDem; ++v)
for (int k = 0, ThxDem = nk + 1; k < ThxDem; ++k)
for (int o = 0, ThxDem = no + 1; o < ThxDem; ++o)
for (int i = 0, ThxDem = 2; i < ThxDem; ++i) {
int z = dp[v][k][o][i];
if (v < nv) {
int r = z;
int p = pv[v];
r += max(sk[p] - k, 0) + max(so[p] - o, 0);
dp[v + 1][k][o][1] = min(dp[v + 1][k][o][1], r);
}
if (k < nk && !i) {
int r = z;
int p = pk[k];
r += max(sv[p] - v, 0) + max(so[p] - o, 0);
dp[v][k + 1][o][0] = min(dp[v][k + 1][o][0], r);
}
if (o < no) {
int r = z;
int p = po[o];
r += max(sk[p] - k, 0) + max(sv[p] - v, 0);
dp[v][k][o + 1][0] = min(dp[v][k][o + 1][0], r);
}
}
printf("%d\n", min(dp[nv][nk][no][0], dp[nv][nk][no][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 1;
const int LG = 19;
vector<int> V;
vector<int> X;
vector<int> K;
int dp[76][76][76][2];
int rem(vector<int>& l, int from, int lim) {
int cnt = 0;
for (int i = from; i < l.size() && l[i] < lim; ++i) cnt++;
return cnt;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; ++i) {
if (s[i] == 'K')
K.push_back(i);
else if (s[i] == 'V')
V.push_back(i);
else
X.push_back(i);
}
for (int v = 0; v < n; ++v)
for (int x = 0; x < n; ++x)
for (int k = 0; k < n; ++k)
for (int i = 0; i < 2; ++i) dp[v][x][k][i] = 10000000;
dp[0][0][0][0] = 0;
for (int v = 0; v < V.size() + 1; ++v)
for (int x = 0; x < X.size() + 1; ++x)
for (int k = 0; k < K.size() + 1; ++k)
for (int i = 0; i < 2; ++i) {
auto moving_cost = [&](int where) {
return rem(K, k, where) + rem(V, v, where) + rem(X, x, where);
};
if (v < V.size()) {
dp[v + 1][k][x][1] =
min(dp[v + 1][k][x][1], dp[v][k][x][i] + moving_cost(V[v]));
}
if (k < K.size() && i == 0)
dp[v][k + 1][x][0] =
min(dp[v][k + 1][x][0], dp[v][k][x][i] + moving_cost(K[k]));
if (x < X.size())
dp[v][k][x + 1][0] =
min(dp[v][k][x + 1][0], dp[v][k][x][i] + moving_cost(X[x]));
}
int ans = min(dp[V.size()][K.size()][X.size()][0],
dp[V.size()][K.size()][X.size()][1]);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 80, inf = 1e9 + 7;
int n, dp[maxn][maxn][maxn][3], te[3];
string s;
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++)
s[i] = (s[i] == 'V' ? 'a' : (s[i] == 'K' ? 'b' : 'c'));
for (int i = 0; i < n; i++) te[s[i] - 'a']++;
int i[3];
for (i[0] = 0; i[0] <= te[0]; i[0]++)
for (i[1] = 0; i[1] <= te[1]; i[1]++)
for (i[2] = 0; i[2] <= te[2]; i[2]++)
dp[i[0]][i[1]][i[2]][0] = dp[i[0]][i[1]][i[2]][1] =
dp[i[0]][i[1]][i[2]][2] = inf;
dp[0][0][0][0] = dp[0][0][0][1] = dp[0][0][0][2] = 0;
for (i[0] = 0; i[0] <= te[0]; i[0]++)
for (i[1] = 0; i[1] <= te[1]; i[1]++)
for (i[2] = 0; i[2] <= te[2]; i[2]++) {
int move, p, t[3];
if (i[0]) {
t[0] = t[1] = t[2] = move = 0;
for (p = 0; t[0] < i[0]; p++) {
t[s[p] - 'a']++;
if (t[s[p] - 'a'] > i[s[p] - 'a']) move++;
}
dp[i[0]][i[1]][i[2]][0] =
min(dp[i[0]][i[1]][i[2]][0], dp[i[0] - 1][i[1]][i[2]][0] + move);
dp[i[0]][i[1]][i[2]][0] =
min(dp[i[0]][i[1]][i[2]][0], dp[i[0] - 1][i[1]][i[2]][1] + move);
dp[i[0]][i[1]][i[2]][0] =
min(dp[i[0]][i[1]][i[2]][0], dp[i[0] - 1][i[1]][i[2]][2] + move);
if (i[2])
dp[i[0]][i[1]][i[2]][2] =
min(dp[i[0]][i[1]][i[2]][2],
dp[i[0] - 1][i[1]][i[2]][2] + move + 1);
}
if (i[1]) {
t[0] = t[1] = t[2] = move = 0;
for (p = 0; t[1] < i[1]; p++) {
t[s[p] - 'a']++;
if (t[s[p] - 'a'] > i[s[p] - 'a']) move++;
}
dp[i[0]][i[1]][i[2]][1] =
min(dp[i[0]][i[1]][i[2]][1], dp[i[0]][i[1] - 1][i[2]][1] + move);
dp[i[0]][i[1]][i[2]][1] =
min(dp[i[0]][i[1]][i[2]][1], dp[i[0]][i[1] - 1][i[2]][2] + move);
}
if (i[2]) {
t[0] = t[1] = t[2] = move = 0;
for (p = 0; t[2] < i[2]; p++) {
t[s[p] - 'a']++;
if (t[s[p] - 'a'] > i[s[p] - 'a']) move++;
}
dp[i[0]][i[1]][i[2]][2] =
min(dp[i[0]][i[1]][i[2]][2], dp[i[0]][i[1]][i[2] - 1][0] + move);
dp[i[0]][i[1]][i[2]][2] =
min(dp[i[0]][i[1]][i[2]][2], dp[i[0]][i[1]][i[2] - 1][1] + move);
dp[i[0]][i[1]][i[2]][2] =
min(dp[i[0]][i[1]][i[2]][2], dp[i[0]][i[1]][i[2] - 1][2] + move);
if (i[0])
dp[i[0]][i[1]][i[2]][0] =
min(dp[i[0]][i[1]][i[2]][0],
dp[i[0]][i[1]][i[2] - 1][0] + move + 1);
if (i[1])
dp[i[0]][i[1]][i[2]][1] =
min(dp[i[0]][i[1]][i[2]][1],
dp[i[0]][i[1]][i[2] - 1][1] + move + 1);
}
}
cout << min({dp[te[0]][te[1]][te[2]][0], dp[te[0]][te[1]][te[2]][1],
dp[te[0]][te[1]][te[2]][2]})
<< '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
char s[80];
vector<int> v, k, x;
int dp[80][80][80][2];
int main() {
memset(dp, -1, sizeof(dp));
int n;
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; 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);
}
queue<pair<pair<int, int>, pair<int, int> > > q;
dp[0][0][0][0] = 0;
q.push(pair<pair<int, int>, pair<int, int> >(pair<int, int>(0, 0),
pair<int, int>(0, 0)));
int ans = 1e9;
while (!q.empty()) {
int nv = q.front().first.first;
int nk = q.front().first.second;
int nx = q.front().second.first;
int last = q.front().second.second;
q.pop();
int idx = nv + nk + nx + 1;
if (idx == n + 1) {
ans = min(ans, dp[nv][nk][nx][last]);
continue;
}
if (nv < v.size()) {
int vidx =
v[nv] + max(0, nk - (int)(lower_bound(k.begin(), k.end(), v[nv]) -
k.begin()));
vidx += max(
0, nx - (int)(lower_bound(x.begin(), x.end(), v[nv]) - x.begin()));
int add = vidx - idx;
if (dp[nv + 1][nk][nx][1] == -1 ||
dp[nv + 1][nk][nx][1] > dp[nv][nk][nx][last] + add) {
dp[nv + 1][nk][nx][1] = dp[nv][nk][nx][last] + add;
q.push(pair<pair<int, int>, pair<int, int> >(pair<int, int>(nv + 1, nk),
pair<int, int>(nx, 1)));
}
}
if (nk < k.size() && last == 0) {
int kidx =
k[nk] + max(0, nv - (int)(lower_bound(v.begin(), v.end(), k[nk]) -
v.begin()));
kidx += max(
0, nx - (int)(lower_bound(x.begin(), x.end(), k[nk]) - x.begin()));
int add = kidx - idx;
if (dp[nv][nk + 1][nx][0] == -1 ||
dp[nv][nk + 1][nx][0] > dp[nv][nk][nx][last] + add) {
dp[nv][nk + 1][nx][0] = dp[nv][nk][nx][last] + add;
q.push(pair<pair<int, int>, pair<int, int> >(pair<int, int>(nv, nk + 1),
pair<int, int>(nx, 0)));
}
}
if (nx < x.size()) {
int xidx =
x[nx] + max(0, nv - (int)(lower_bound(v.begin(), v.end(), x[nx]) -
v.begin()));
xidx += max(
0, nk - (int)(lower_bound(k.begin(), k.end(), x[nx]) - k.begin()));
int add = xidx - idx;
if (dp[nv][nk][nx + 1][0] == -1 ||
dp[nv][nk][nx + 1][0] > dp[nv][nk][nx][last] + add) {
dp[nv][nk][nx + 1][0] = dp[nv][nk][nx][last] + add;
q.push(pair<pair<int, int>, pair<int, int> >(
pair<int, int>(nv, nk), pair<int, int>(nx + 1, 0)));
}
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long double pi = acos(-1.0);
const string debug_line = "yolo";
const long double PI = acos((long double)-1.0);
const long double eps = 1e-6;
unsigned long long getRand() {
return ((unsigned long long)rand() << 40) +
((unsigned long long)rand() << 20) + ((unsigned long long)rand());
}
char s[101];
int stepsV[101][101];
int stepsK[101][101];
long long dp[101][101][101][3];
bool visited[101][101][101][3];
int n;
int normieC;
int countV;
int countK;
int timesCalled = 0;
bool visited1[101];
int findChar(int normie, int v, int k, int charType) {
for (int(i) = (0); (i) < (101); ++(i)) visited1[i] = false;
int countNormie = 0;
int countVe = 0;
int countKe = 0;
for (int(i) = (1); (i) < (n + 1); ++(i)) {
if (s[i] != 'V' && s[i] != 'K') {
if (countNormie == normie) {
continue;
}
countNormie++;
visited1[i] = true;
} else if (s[i] == 'V') {
if (countVe == v) {
continue;
}
countVe++;
visited1[i] = true;
} else if (s[i] == 'K') {
if (countKe == k) {
continue;
}
countKe++;
visited1[i] = true;
}
}
int movesNeeded = 0;
if (charType == 0) {
for (int(i) = (1); (i) < (n + 1); ++(i)) {
if (!visited1[i] && s[i] != 'V') {
movesNeeded++;
} else if (s[i] == 'V' && !visited1[i]) {
return movesNeeded;
}
}
} else if (charType == 1) {
for (int(i) = (1); (i) < (n + 1); ++(i)) {
if (!visited1[i] && s[i] != 'K') {
movesNeeded++;
} else if (s[i] == 'K' && !visited1[i]) {
return movesNeeded;
}
}
} else if (charType == 2) {
for (int(i) = (1); (i) < (n + 1); ++(i)) {
if (!visited1[i] && (s[i] == 'V' || s[i] == 'K')) {
movesNeeded++;
} else if ((s[i] != 'V' && s[i] != 'K') && !visited1[i]) {
return movesNeeded;
}
}
}
return INT_MAX;
}
void solve(int index, int v, int k, int lastChar) {
if (index > n) {
visited[index][v][k][lastChar] = true;
dp[index][v][k][lastChar] = INT_MAX;
return;
}
if (index == n) {
visited[index][v][k][lastChar] = true;
if (v == countV && k == countK) {
dp[index][v][k][lastChar] = 0;
return;
} else {
dp[index][v][k][lastChar] = INT_MAX;
return;
}
} else {
if (visited[index][v][k][lastChar]) {
return;
} else {
long long res = INT_MAX;
int posN = findChar(index - (v + k), v, k, 2);
int posV = findChar(index - (v + k), v, k, 0);
int posK = findChar(index - (v + k), v, k, 1);
int min1 = -1;
if (lastChar == 0) {
if (posN != INT_MAX) {
solve(index + 1, v, k, 2);
assert(visited[index + 1][v][k][2]);
res = min(res, posN + dp[index + 1][v][k][2]);
if (res == posN + dp[index + 1][v][k][2]) {
min1 = 2;
}
}
if (posV != INT_MAX) {
solve(index + 1, v + 1, k, 0);
assert(visited[index + 1][v + 1][k][0]);
res = min(res, posV + dp[index + 1][v + 1][k][0]);
if (res == posV + dp[index + 1][v + 1][k][0]) {
min1 = 0;
}
}
} else {
if (posN != INT_MAX) {
solve(index + 1, v, k, 2);
assert(visited[index + 1][v][k][2]);
res = min(res, posN + dp[index + 1][v][k][2]);
if (res == posN + dp[index + 1][v][k][2]) {
min1 = 2;
}
}
if (posV != INT_MAX) {
solve(index + 1, v + 1, k, 0);
assert(visited[index + 1][v + 1][k][0]);
res = min(res, posV + dp[index + 1][v + 1][k][0]);
if (res == posV + dp[index + 1][v + 1][k][0]) {
min1 = 0;
}
}
if (posK != INT_MAX) {
solve(index + 1, v, k + 1, 1);
assert(visited[index + 1][v][k + 1][1]);
res = min(res, posK + dp[index + 1][v][k + 1][1]);
if (res == posK + dp[index + 1][v][k + 1][1]) {
min1 = 1;
}
}
}
dp[index][v][k][lastChar] = res;
visited[index][v][k][lastChar] = true;
return;
}
}
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int(i) = (1); (i) < (n + 1); ++(i)) {
if (s[i] == 'V') {
countV++;
} else if (s[i] == 'K') {
countK++;
} else {
normieC++;
}
}
solve(0, 0, 0, 2);
printf("%lld\n", dp[0][0][0][2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
int f[N][N][N][3];
char ch[N];
int pos[3][N], s[3];
int cnt[N][3];
int n;
int get(char c) {
if (c == 'V') return 0;
if (c == 'K') return 1;
return 2;
}
void init() {
for (int i = 1; i <= n; i++) {
int t = get(ch[i]);
cnt[i][0] = s[0];
cnt[i][1] = s[1];
cnt[i][2] = s[2];
pos[t][++s[t]] = i;
}
}
int cost(int t, int a, int b, int c) {
if (t == 0) {
int p = pos[t][a];
int b1 = cnt[p][1];
int c1 = cnt[p][2];
return abs(b1 - b) + abs(c1 - c);
}
if (t == 1) {
int p = pos[t][b];
int a1 = cnt[p][0], c1 = cnt[p][2];
return abs(a1 - a) + abs(c1 - c);
} else {
int p = pos[t][c];
int a1 = cnt[p][0], b1 = cnt[p][1];
return abs(a1 - a) + abs(b1 - b);
}
}
void calc_min(int &a, int b) { a = min(a, b); }
int main() {
scanf("%d", &n);
scanf("%s", ch + 1);
init();
memset(f, 0x3f, sizeof f);
f[0][0][0][1] = f[0][0][0][2] = 0;
for (int i = 0; i <= n; i++)
for (int a = 0; a <= min(s[0], i); a++)
for (int b = 0; b <= s[1] && a + b <= i; b++)
for (int t = 0; t <= 2; t++) {
int c = i - a - b;
if (c > s[2]) continue;
if (a < s[0])
calc_min(f[i + 1][a + 1][b][0],
f[i][a][b][t] + cost(0, a + 1, b, c));
if (b < s[1] && t)
calc_min(f[i + 1][a][b + 1][1],
f[i][a][b][t] + cost(1, a, b + 1, c));
if (c < s[2])
calc_min(f[i + 1][a][b][2], f[i][a][b][t] + cost(2, a, b, c + 1));
}
printf("%d\n", min(f[n][s[0]][s[1]][0],
min(f[n][s[0]][s[1]][1], f[n][s[0]][s[1]][2])) /
2);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("sse4.2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long N = 80 + 2;
long long n, dp[N][N][N][3], A, B, C;
string s;
inline long long f(long long aa, long long bb, long long cc, char col,
long long num) {
long long cnt = 0, pt = 0, a = 0, b = 0, c = 0, ans = 0;
while (cnt < num) {
if (s[pt] == 'A') {
if (a < aa)
a++;
else
ans++;
} else if (s[pt] == 'B') {
if (b < bb)
b++;
else
ans++;
} else {
if (c < cc)
c++;
else
ans++;
}
if (s[pt] == col) cnt++;
pt++;
}
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
;
cin >> n >> s;
for (long long i = 0; i < n; i++) {
if (s[i] == 'V')
s[i] = 'A', A++;
else if (s[i] == 'K')
s[i] = 'B', B++;
else
s[i] = 'C', C++;
}
for (long long a = 0; a < A + 1; a++) {
for (long long b = 0; b < B + 1; b++) {
for (long long c = 0; c < C + 1; c++) {
long long* d = dp[a][b][c];
if (max(a, max(b, c)) == 0) {
d[0] = d[1] = d[2] = 0;
continue;
}
long long* tmp = dp[a - 1][b][c];
d[0] = (a == 0 ? LLONG_MAX / 2
: min(tmp[0], min(tmp[1], tmp[2])) + f(a, b, c, 'A', a));
tmp = dp[a][b - 1][c];
d[1] =
(b == 0 ? LLONG_MAX / 2 : min(tmp[1], tmp[2]) + f(a, b, c, 'B', b));
tmp = dp[a][b][c - 1];
d[2] = (c == 0 ? LLONG_MAX / 2
: min(tmp[0], min(tmp[1], tmp[2])) + f(a, b, c, 'C', c));
cout << endl;
}
}
}
long long* d = dp[A][B][C];
cout << min(d[0], min(d[1], d[2]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct QuadNum {
long a, b, c, d;
};
long dp[76][76][76][2];
vector<long> pos[3];
inline long count(long v, long k, long x, long p) {
long cnt = p;
for (long i = 0; i < v; i++)
if (pos[0][i] < p) cnt--;
for (long i = 0; i < k; i++)
if (pos[1][i] < p) cnt--;
for (long i = 0; i < x; i++)
if (pos[2][i] < p) cnt--;
return cnt;
}
void solve() {
dp[0][0][0][0] = 0;
queue<QuadNum> q;
q.push({0, 0, 0, 0});
while (!q.empty()) {
long v = q.front().a, k = q.front().b, x = q.front().c, e = q.front().d;
long r = dp[v][k][x][e];
q.pop();
if (e == 0 && k < pos[1].size()) {
long p = count(v, k, x, pos[1][k]);
if (dp[v][k + 1][x][0] > r + p)
dp[v][k + 1][x][0] = r + p, q.push({v, k + 1, x, 0});
}
if (v < pos[0].size()) {
long p = count(v, k, x, pos[0][v]);
if (dp[v + 1][k][x][1] > r + p)
dp[v + 1][k][x][1] = r + p, q.push({v + 1, k, x, 1});
}
if (x < pos[2].size()) {
long p = count(v, k, x, pos[2][x]);
if (dp[v][k][x + 1][0] > r + p)
dp[v][k][x + 1][0] = r + p, q.push({v, k, x + 1, 0});
}
}
}
int main() {
memset(dp, 0x7f, sizeof(dp));
long n;
scanf("%ld", &n);
vector<char> s(n + 1);
scanf("%s", &s[0]);
for (long 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);
solve();
long a = dp[pos[0].size()][pos[1].size()][pos[2].size()][0];
long b = dp[pos[0].size()][pos[1].size()][pos[2].size()][1];
printf("%ld\n", min(a, b));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 75;
int n;
char a[N + 5];
int dp[N + 1][N + 1][N + 1][3];
int grtV[N + 1][N + 1], grtK[N + 1][N + 1], grtA[N + 1][N + 1];
int val(int v, int x, int y, int z) {
return grtV[v][x] + grtK[v][y] + grtA[v][z];
}
int main() {
cin >> n >> a + 1;
vector<int> V, K, A;
for (int i = 1; i <= n; i++)
if (a[i] == 'V')
V.push_back(i);
else if (a[i] == 'K')
K.push_back(i);
else
A.push_back(i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= V.size(); j++)
for (int k = 0; k < j; k++) grtV[i][j] += V[k] > i;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= K.size(); j++)
for (int k = 0; k < j; k++) grtK[i][j] += K[k] > i;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= A.size(); j++)
for (int k = 0; k < j; k++) grtA[i][j] += A[k] > i;
for (int i = 0; i <= V.size(); i++)
for (int j = 0; j <= K.size(); j++)
for (int k = 0; k <= A.size(); k++)
if (i || j || k)
for (int o = 0; o < 3; o++) {
dp[i][j][k][o] = inf;
if (o == 0 && !i || o == 1 && !j || o == 2 && !k) continue;
if (o == 0) {
dp[i][j][k][o] =
min(dp[i][j][k][o],
dp[i - 1][j][k][0] + val(V[i - 1], i - 1, j, k));
dp[i][j][k][o] =
min(dp[i][j][k][o],
dp[i - 1][j][k][1] + val(V[i - 1], i - 1, j, k));
dp[i][j][k][o] =
min(dp[i][j][k][o],
dp[i - 1][j][k][2] + val(V[i - 1], i - 1, j, k));
} else if (o == 1) {
dp[i][j][k][o] =
min(dp[i][j][k][o],
dp[i][j - 1][k][1] + val(K[j - 1], i, j - 1, k));
dp[i][j][k][o] =
min(dp[i][j][k][o],
dp[i][j - 1][k][2] + val(K[j - 1], i, j - 1, k));
} else {
dp[i][j][k][o] =
min(dp[i][j][k][o],
dp[i][j][k - 1][0] + val(A[k - 1], i, j, k - 1));
dp[i][j][k][o] =
min(dp[i][j][k][o],
dp[i][j][k - 1][1] + val(A[k - 1], i, j, k - 1));
dp[i][j][k][o] =
min(dp[i][j][k][o],
dp[i][j][k - 1][2] + val(A[k - 1], i, j, k - 1));
}
}
int *head = dp[V.size()][K.size()][A.size()];
cout << min(min(head[0], head[1]), head[2]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2,fma,tune=native")
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>
using namespace std;
int n, V, K, X, f[80][80][80][2];
char s[80];
vector<int> num[3];
void change_min(int &x, int y) { x = ((x < y) ? x : y); }
int solve(int v, int k, int x, int p) {
int res = 0;
for (int i = v; i < V && num[0][i] < p; i++) ++res;
for (int i = k; i < K && num[1][i] < p; i++) ++res;
for (int i = x; i < X && num[2][i] < p; i++) ++res;
return res;
}
int main() {
scanf("%d\n", &n);
char ch;
for (int i = 1; i <= n; i++) {
ch = getchar();
if (ch == 'V')
num[0].push_back(i);
else if (ch == 'K')
num[1].push_back(i);
else
num[2].push_back(i);
}
V = num[0].size(), K = num[1].size(), X = num[2].size();
memset(f, 0x3f3f3f3f, sizeof(f));
f[0][0][0][0] = 0;
for (int v = 0; v <= V; v++)
for (int k = 0; k <= K; k++)
for (int x = 0; x <= X; x++)
for (int op = 0; op < 2; op++) {
int tmp = f[v][k][x][op];
if (v < V)
change_min(f[v + 1][k][x][1], tmp + solve(v, k, x, num[0][v]));
if (k < K && op != 1)
change_min(f[v][k + 1][x][0], tmp + solve(v, k, x, num[1][k]));
if (x < X)
change_min(f[v][k][x + 1][0], tmp + solve(v, k, x, num[2][x]));
}
printf("%d\n", min(f[V][K][X][0], f[V][K][X][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int cost[80][80][80][3];
int dp[80][80][80][3];
int rek(int i, int j, int k, int last) {
if (i == 0 and j == 0 and k == 0) return 0;
if (dp[i][j][k][last] != -1) return dp[i][j][k][last];
int ret = (1 << 30);
if (i > 0) {
ret = min(ret, rek(i - 1, j, k, 0) + cost[i][j][k][0]);
}
if (j > 0 && last != 0) {
ret = min(ret, rek(i, j - 1, k, 1) + cost[i][j][k][1]);
}
if (k > 0) {
ret = min(ret, rek(i, j, k - 1, 2) + cost[i][j][k][2]);
}
return dp[i][j][k][last] = ret;
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
memset(dp, -1, sizeof dp);
cin >> n >> s;
int V = 0, K = 0, O = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
++V;
else if (s[i] == 'K')
++K;
else
++O;
}
for (int i = 0; i <= V; ++i) {
for (int j = 0; j <= K; ++j) {
for (int x = 0; x <= O; ++x) {
int vv = V - i;
int vk = K - j;
int vo = O - x;
for (int it = 0; it < n; it++) {
if (s[it] == 'V') {
if (vv == 0) {
cost[i][j][x][0] = max(-vk, 0) + max(-vo, 0);
}
vv--;
} else if (s[it] == 'K') {
if (vk == 0) {
cost[i][j][x][1] = max(-vv, 0) + max(-vo, 0);
}
vk--;
} else {
if (vo == 0) {
cost[i][j][x][2] = max(-vv, 0) + max(-vk, 0);
}
vo--;
}
}
}
}
}
cout << rek(V, K, O, 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void Rd(int &res) {
char c;
res = 0;
while (c = getchar(), c < '0')
;
do {
res = (res << 1) + (res << 3) + (c ^ 48);
} while (c = getchar(), c >= '0');
}
const int M = 80;
int n;
int cnt[3][M], pos[3][M];
int dp[M][M][M][2];
char str[M];
inline int cost(int v, int k, int x, int pos) {
return max(0, cnt[0][pos] - v) + max(0, cnt[1][pos] - k) +
max(0, cnt[2][pos] - x) - 1;
}
inline void Check(int &a, int b) {
if (a == -1 || b < a) a = b;
}
int main() {
scanf("%d", &n);
scanf("%s", str + 1);
for (int i = 1; i <= n; i++) {
cnt[0][i] = cnt[0][i - 1] + (str[i] == 'V');
cnt[1][i] = cnt[1][i - 1] + (str[i] == 'K');
cnt[2][i] = cnt[2][i - 1] + (str[i] != 'V' && str[i] != 'K');
if (str[i] == 'V') pos[0][++pos[0][0]] = i;
if (str[i] == 'K') pos[1][++pos[1][0]] = i;
if (str[i] != 'V' && str[i] != 'K') pos[2][++pos[2][0]] = i;
}
memset(dp, -1, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i <= cnt[0][n]; i++)
for (int j = 0; j <= cnt[1][n]; j++)
for (int t = 0; t <= cnt[2][n]; t++)
for (int p = 0; p < 2; p++) {
if (dp[i][j][t][p] == -1) continue;
if (i < cnt[0][n])
Check(dp[i + 1][j][t][1],
dp[i][j][t][p] + cost(i, j, t, pos[0][i + 1]));
if (!p && j < cnt[1][n])
Check(dp[i][j + 1][t][0],
dp[i][j][t][p] + cost(i, j, t, pos[1][j + 1]));
if (t < cnt[2][n])
Check(dp[i][j][t + 1][0],
dp[i][j][t][p] + cost(i, j, t, pos[2][t + 1]));
}
int rs = -1;
if (~dp[cnt[0][n]][cnt[1][n]][cnt[2][n]][0])
Check(rs, dp[cnt[0][n]][cnt[1][n]][cnt[2][n]][0]);
if (~dp[cnt[0][n]][cnt[1][n]][cnt[2][n]][1])
Check(rs, dp[cnt[0][n]][cnt[1][n]][cnt[2][n]][1]);
printf("%d\n", rs);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80, INF = 1e9;
int f[N][N][N][2], cv[N], ck[N], cx[N];
int main() {
int n;
string s;
cin >> n >> s;
s = ' ' + s;
vector<int> V{0}, K{0}, X{0};
for (int i = 1; i <= n; i++) {
cv[i] = cv[i - 1];
ck[i] = ck[i - 1];
cx[i] = cx[i - 1];
if (s[i] == 'V') {
V.push_back(i);
cv[i]++;
} else if (s[i] == 'K') {
K.push_back(i);
ck[i]++;
} else {
X.push_back(i);
cx[i]++;
}
}
fill_n(&f[0][0][0][0], sizeof(f) / sizeof(int), INF);
f[0][0][0][0] = 0;
for (int i = 0; i < V.size(); i++)
for (int j = 0; j < K.size(); j++)
for (int k = 0; k < X.size(); k++)
for (int v = 0; v < 2; v++)
if (f[i][j][k][v] < INF) {
if (i < V.size() - 1)
f[i + 1][j][k][1] =
min(f[i + 1][j][k][1], f[i][j][k][v] +
max(cv[V[i + 1] - 1] - i, 0) +
max(ck[V[i + 1] - 1] - j, 0) +
max(cx[V[i + 1] - 1] - k, 0));
if (j < K.size() - 1 && !v)
f[i][j + 1][k][0] =
min(f[i][j + 1][k][0], f[i][j][k][v] +
max(cv[K[j + 1] - 1] - i, 0) +
max(ck[K[j + 1] - 1] - j, 0) +
max(cx[K[j + 1] - 1] - k, 0));
if (k < X.size() - 1)
f[i][j][k + 1][0] =
min(f[i][j][k + 1][0], f[i][j][k][v] +
max(cv[X[k + 1] - 1] - i, 0) +
max(ck[X[k + 1] - 1] - j, 0) +
max(cx[X[k + 1] - 1] - k, 0));
}
cout << min(f[V.size() - 1][K.size() - 1][X.size() - 1][0],
f[V.size() - 1][K.size() - 1][X.size() - 1][1])
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
int n;
char s[N + 10];
int vcnt, kcnt, xcnt;
bool vis[N + 10];
long long dp[N + 2][N + 2][N + 2][4];
void trans(int v, int k, int x, int t) {
memset(vis, 0, sizeof(vis));
int vcnt = 1, kcnt = 1, xcnt = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == 'V') {
if (vcnt <= v) vis[i] = true, vcnt++;
} else if (s[i] == 'K') {
if (kcnt <= k) vis[i] = true, kcnt++;
} else {
if (xcnt <= x) vis[i] = true, xcnt++;
}
}
int v_blank = 0, k_blank = 0, x_blank = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == 'V' && !vis[i]) break;
if (!vis[i]) v_blank++;
}
for (int i = 1; i <= n; i++) {
if (s[i] == 'K' && !vis[i]) break;
if (!vis[i]) k_blank++;
}
for (int i = 1; i <= n; i++) {
if (s[i] != 'V' && s[i] != 'K' && !vis[i]) break;
if (!vis[i]) x_blank++;
}
dp[v + 1][k][x][1] = min(dp[v + 1][k][x][1], dp[v][k][x][t] + v_blank);
if (t != 1)
dp[v][k + 1][x][2] = min(dp[v][k + 1][x][2], dp[v][k][x][t] + k_blank);
dp[v][k][x + 1][3] = min(dp[v][k][x + 1][3], dp[v][k][x][t] + x_blank);
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++)
if (s[i] == 'V')
vcnt++;
else if (s[i] == 'K')
kcnt++;
else
xcnt++;
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 0; i <= vcnt; i++)
for (int j = 0; j <= kcnt; j++)
for (int k = 0; k <= xcnt; k++) {
if (i == 0 && j == 0 && k == 0)
trans(0, 0, 0, 0);
else
for (int t = 1; t <= 3; t++) trans(i, j, k, t);
}
long long ans = 0x3f3f3f3f3f3f3f3f;
for (int i = 1; i <= 3; i++) ans = min(ans, dp[vcnt][kcnt][xcnt][i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 75 + 2;
const int INF = 1e9;
int n;
int freq[3];
int memo[N][N][N][2];
string s;
vector<int> ls[3];
int getCost(int a, int b, int c, int idx) {
int res = 0;
int j = 0;
for (auto i : {a, b, c}) {
for (int k = i; k < ls[j].size(); k++) {
if (ls[j][k] < idx)
res++;
else
break;
}
j++;
}
return res;
}
int dp(int a, int b, int c, bool v) {
if (a >= ls[0].size() && b >= ls[1].size() && c >= ls[2].size()) return 0;
if (memo[a][b][c][v] != -1) return memo[a][b][c][v];
int ret = INF;
if (a < ls[0].size())
ret = min(ret, dp(a + 1, b, c, 1) + getCost(a, b, c, ls[0][a]));
if (b < ls[1].size() && !v)
ret = min(ret, dp(a, b + 1, c, 0) + getCost(a, b, c, ls[1][b]));
if (c < ls[2].size())
ret = min(ret, dp(a, b, c + 1, 0) + getCost(a, b, c, ls[2][c]));
return memo[a][b][c][v] = ret;
}
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')
ls[0].push_back(i);
else if (s[i] == 'K')
ls[1].push_back(i);
else
ls[2].push_back(i);
}
memset(memo, -1, sizeof(memo));
cout << dp(0, 0, 0, 0) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[76][76][76][2], v, k, x, n;
string s;
int main() {
cin >> n >> s;
for (char a : s)
if (a == 'V')
v++;
else if (a == 'K')
k++;
else
x++;
for (int i1 = v; i1 >= 0; i1--)
for (int i2 = k; i2 >= 0; i2--)
for (int i3 = x; i3 >= 0; i3--)
for (int i4 = 1; i4 >= 0; i4--) {
if (i1 == v && i2 == k && i3 == x) continue;
dp[i1][i2][i3][i4] = 1000000007;
int v1 = 0, k1 = 0, x1 = 0, v2 = -1, k2 = -1, x2 = -1, cur = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'V') {
if (v1 == i1) v2 = cur;
if (v1 >= i1) cur++;
v1++;
} else if (s[i] == 'K') {
if (k1 == i2) k2 = cur;
if (k1 >= i2) cur++;
k1++;
} else {
if (x1 == i3) x2 = cur;
if (x1 >= i3) cur++;
x1++;
}
}
if (i1 != v)
dp[i1][i2][i3][i4] =
min(dp[i1][i2][i3][i4], dp[i1 + 1][i2][i3][1] + v2);
if (i2 != k && i4 == 0)
dp[i1][i2][i3][i4] =
min(dp[i1][i2][i3][i4], dp[i1][i2 + 1][i3][0] + k2);
if (i3 != x)
dp[i1][i2][i3][i4] =
min(dp[i1][i2][i3][i4], dp[i1][i2][i3 + 1][0] + x2);
}
cout << dp[0][0][0][0];
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 77;
int n;
char s[N];
vector<int> v, k, x;
int dp[N][N][N][2];
int count(vector<int> &list, int from, int w) {
int cnt = 0;
for (int i = from; i < list.size(); i++) {
if (list[i] < w) cnt++;
}
return cnt;
}
int cost(int vv, int kk, int xx, int w) {
return count(v, vv, w) + count(k, kk, w) + count(x, xx, w);
}
int main() {
scanf("%d", &n);
scanf("%s", s);
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++)
for (int l = 0; l < 2; l++) dp[i][j][k][l] = 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 p = 0; p <= x.size(); p++) {
for (int c = 0; c < 2; c++) {
if (i < v.size())
dp[i + 1][j][p][1] =
min(dp[i + 1][j][p][1], cost(i, j, p, v[i]) + dp[i][j][p][c]);
if (c == 0 && j < k.size())
dp[i][j + 1][p][0] =
min(dp[i][j + 1][p][0], cost(i, j, p, k[j]) + dp[i][j][p][c]);
if (p < x.size())
dp[i][j][p + 1][0] =
min(dp[i][j][p + 1][0], cost(i, j, p, x[p]) + dp[i][j][p][c]);
}
}
}
}
printf("%d\n", min(dp[v.size()][k.size()][x.size()][0],
dp[v.size()][k.size()][x.size()][1]));
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 76;
char buf[MAXN];
int n, dp[MAXN][MAXN][MAXN][2];
std::vector<int> lv, lk, le;
void gmin(int& x, int y) { x > y ? x = y : 0; }
int calc(int a, int b, int c, int v) {
int res = 0;
for (int i = 0; i < a; ++i) res += lv[i] > v;
for (int i = 0; i < b; ++i) res += lk[i] > v;
for (int i = 0; i < c; ++i) res += le[i] > v;
return res;
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> buf + 1;
for (int i = 1; i <= n; ++i) {
if (buf[i] == 'V')
lv.push_back(i);
else if (buf[i] == 'K')
lk.push_back(i);
else
le.push_back(i);
}
memset(dp, 0x3f, sizeof dp);
int ans = ****dp;
dp[0][0][0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= lv.size(); ++j)
for (int k = 0; k <= lk.size(); ++k)
for (int p = 0; p < 2; ++p) {
int l = i - 1 - j - k;
if (l > le.size()) continue;
if (j != lv.size())
gmin(dp[i][j + 1][k][1], dp[i - 1][j][k][p] + calc(j, k, l, lv[j]));
if (k != lk.size() && !p)
gmin(dp[i][j][k + 1][0], dp[i - 1][j][k][p] + calc(j, k, l, lk[k]));
if (l != le.size())
gmin(dp[i][j][k][0], dp[i - 1][j][k][p] + calc(j, k, l, le[l]));
}
}
for (int i = 0; i < 2; ++i) gmin(ans, dp[n][lv.size()][lk.size()][i]);
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[100];
int f[80][80][80][2];
int fck[80][80], fcv[80][80];
int fvk[80][80], fvc[80][80];
int fkc[80][80], fkv[80][80];
int cv, ck, cc;
int v[80], kk[80], c[80];
inline int min(int x, int y) { return x < y ? x : y; }
inline int max(int x, int y) { return x > y ? x : y; }
int cost(int limit, int i, int j, int k) {
int res = 0;
for (int ii = i + 1; ii <= cv && v[ii] < limit; ii++) res++;
for (int ii = j + 1; ii <= ck && kk[ii] < limit; ii++) res++;
for (int ii = k + 1; ii <= cc && c[ii] < limit; ii++) res++;
return res;
}
int main() {
cin >> n;
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == 'V')
v[++cv] = i;
else if (s[i] == 'K')
kk[++ck] = i;
else
c[++cc] = i;
}
memset(f, 0x7f, sizeof(f));
f[0][0][0][0] = 0;
for (int i = 1; i <= cv; i++)
for (int j = 1; j <= ck; j++) fvk[i][j] = fck[i][j - 1] + (v[i] < kk[j]);
for (int i = 1; i <= cv; i++)
for (int j = 1; j <= cc; j++) fvc[i][j] = fvc[i][j - 1] + (v[i] < c[j]);
for (int i = 1; i <= ck; i++)
for (int j = 1; j <= cv; j++) fkv[i][j] = fkv[i][j - 1] + (kk[i] < v[j]);
for (int i = 1; i <= ck; i++)
for (int j = 1; j <= cc; j++) fkc[i][j] = fkc[i][j - 1] + (kk[i] < c[j]);
for (int i = 1; i <= cc; i++)
for (int j = 1; j <= cv; j++) fcv[i][j] = fcv[i][j - 1] + (c[i] < v[j]);
for (int i = 1; i <= cc; i++)
for (int j = 1; j <= ck; j++) fck[i][j] = fck[i][j - 1] + (c[i] < kk[j]);
for (int i = 0; i <= cv; i++)
for (int j = 0; j <= ck; j++)
for (int k = 0; k <= cc; k++) {
if (i) {
f[i][j][k][1] =
min(f[i][j][k][1], f[i - 1][j][k][0] + cost(v[i], i - 1, j, k));
f[i][j][k][1] =
min(f[i][j][k][1], f[i - 1][j][k][1] + cost(v[i], i - 1, j, k));
}
if (j) {
f[i][j][k][0] =
min(f[i][j][k][0], f[i][j - 1][k][0] + cost(kk[j], i, j - 1, k));
}
if (k) {
f[i][j][k][0] =
min(f[i][j][k][0], f[i][j][k - 1][0] + cost(c[k], i, j, k - 1));
f[i][j][k][0] =
min(f[i][j][k][0], f[i][j][k - 1][1] + cost(c[k], i, j, k - 1));
}
}
int ans = min(f[cv][ck][cc][0], f[cv][ck][cc][1]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
const int inf = 1000000;
int dp[N][N][N][2];
int X[N], Y[N], Z[N];
void up(int &x, int y) { x = min(x, y); }
int cost(int x, int y) { return max(0, x - y); }
int dist(int x, int y) { return abs(x - y); }
int check(int a[], int n, int pos) {
int sum = 0;
for (int i = 1; i <= n; i++)
if (a[i] > pos) sum++;
return sum;
}
int main() {
int n, x = 0, y = 0, z = 0;
char s[N];
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == 'V')
X[++x] = i;
else if (s[i] == 'K')
Y[++y] = i;
else
Z[++z] = i;
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
for (int r = 0; r < 2; r++) dp[i][j][k][r] = inf;
dp[0][0][0][0] = 0;
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++)
for (int k = 0; k <= z; k++)
for (int r = 0; r < 2; r++) {
if (i < x) {
int p = X[i + 1] + check(Y, j, X[i + 1]) + check(Z, k, X[i + 1]);
up(dp[i + 1][j][k][1], dp[i][j][k][r] + dist(p, i + j + k + 1));
}
if (j < y && r != 1) {
int p = Y[j + 1] + check(X, i, Y[j + 1]) + check(Z, k, Y[j + 1]);
up(dp[i][j + 1][k][0], dp[i][j][k][r] + dist(p, i + j + k + 1));
}
if (k < z) {
int p = Z[k + 1] + check(X, i, Z[k + 1]) + check(Y, j, Z[k + 1]);
up(dp[i][j][k + 1][0], dp[i][j][k][r] + dist(p, i + j + k + 1));
}
}
cout << min(dp[x][y][z][0], dp[x][y][z][1]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
int v_tot = 0, k_tot = 0, x_tot = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'K') {
k_tot++;
} else if (s[i] == 'V') {
v_tot++;
} else {
x_tot++;
s[i] = 'X';
}
}
int dp[k_tot + 1][v_tot + 1][x_tot + 1][2];
for (int i = 0; i <= k_tot; i++)
for (int j = 0; j <= v_tot; j++)
for (int k = 0; k <= x_tot; k++) {
dp[i][j][k][0] = INF;
dp[i][j][k][1] = INF;
}
if (s[0] == 'V') dp[0][1][0][1] = 0;
if (s[0] == 'K') dp[1][0][0][0] = 0;
if (s[0] == 'X') dp[0][0][1][0] = 0;
dp[0][0][0][0] = 0;
for (int v = 0; v <= v_tot; v++) {
for (int k = 0; k <= k_tot; k++) {
for (int x = 0; x <= x_tot; x++) {
int i = 0;
int cnt_k = 0, cnt_v = 0, cnt_x = 0;
int not_used = 0;
while (i < n && cnt_k <= k) {
if (s[i] == 'K') cnt_k++;
if (s[i] == 'V') {
if (cnt_v == v)
not_used++;
else
cnt_v++;
}
if (s[i] == 'X') {
if (cnt_x == x)
not_used++;
else
cnt_x++;
}
i++;
}
if (k + 1 <= k_tot) {
dp[k + 1][v][x][0] =
min(dp[k + 1][v][x][0], dp[k][v][x][0] + not_used);
}
i = 0;
cnt_k = 0;
cnt_v = 0;
cnt_x = 0;
not_used = 0;
while (i < n && cnt_v <= v) {
if (s[i] == 'V') {
cnt_v++;
}
if (s[i] == 'K') {
if (cnt_k == k)
not_used++;
else
cnt_k++;
}
if (s[i] == 'X') {
if (cnt_x == x)
not_used++;
else
cnt_x++;
}
i++;
}
if (v + 1 <= v_tot) {
dp[k][v + 1][x][1] =
min(dp[k][v + 1][x][1],
min(dp[k][v][x][0], dp[k][v][x][1]) + not_used);
}
i = 0;
not_used = 0;
cnt_v = 0;
cnt_x = 0;
cnt_k = 0;
while (i < n && cnt_x <= x) {
if (s[i] == 'X') {
cnt_x++;
}
if (s[i] == 'K') {
if (cnt_k == k)
not_used++;
else
cnt_k++;
}
if (s[i] == 'V') {
if (cnt_v == v)
not_used++;
else
cnt_v++;
}
i++;
}
if (x + 1 <= x_tot) {
dp[k][v][x + 1][0] =
min(dp[k][v][x + 1][0],
min(dp[k][v][x][1], dp[k][v][x][0]) + not_used);
}
}
}
}
cout << min(dp[k_tot][v_tot][x_tot][0], dp[k_tot][v_tot][x_tot][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80;
const int INF = 1e6;
char s[N];
int a[N], n, f[N][N][N][3], sum[N][3], b[3];
inline void Min(int &x, int y) {
if (y < x) x = y;
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++)
if (s[i] == 'V')
a[i] = 1;
else if (s[i] == 'K')
a[i] = 2;
for (int i = 1; i <= n; i++) {
sum[i][0] = sum[i - 1][0] + (a[i] == 0);
sum[i][1] = sum[i - 1][1] + (a[i] == 1);
sum[i][2] = sum[i - 1][2] + (a[i] == 2);
}
for (int i = 0; i < 3; i++) b[i] = sum[n][i];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
for (int p = 0; p < 3; p++) f[i][j][k][p] = INF;
f[0][0][0][0] = 0;
for (int i = 0; i <= b[0]; i++)
for (int j = 0; j <= b[1]; j++)
for (int k = 0; k <= b[2]; k++)
for (int last = 0; last < 3; last++) {
if (i < b[0]) {
for (int p = 1; p <= n; p++)
if (sum[p][0] == i + 1) {
Min(f[i + 1][j][k][0], f[i][j][k][last] +
max(0, sum[p][1] - j) +
max(0, sum[p][2] - k));
break;
}
}
if (j < b[1]) {
for (int p = 1; p <= n; p++)
if (sum[p][1] == j + 1) {
Min(f[i][j + 1][k][1], f[i][j][k][last] +
max(0, sum[p][0] - i) +
max(0, sum[p][2] - k));
break;
}
}
if (k < b[2]) {
if (last != 1)
for (int p = 1; p <= n; p++)
if (sum[p][2] == k + 1) {
Min(f[i][j][k + 1][2], f[i][j][k][last] +
max(0, sum[p][0] - i) +
max(0, sum[p][1] - j));
break;
}
}
}
int ans = INF;
ans = min(f[b[0]][b[1]][b[2]][0],
min(f[b[0]][b[1]][b[2]][1], f[b[0]][b[1]][b[2]][2]));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n, ans;
int dp[77][77][77][2];
string s;
vector<int> V, K, O;
void mini(int &a, int b) { a = min(a, b); }
int count_remaining(const vector<int> &List, int from, int limit_val) {
int cnt = 0;
for (int i = from; i < List.size() && List[i] < limit_val; ++i) ++cnt;
return cnt;
}
void init() {
cin >> n;
cin >> 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:
O.push_back(i);
break;
}
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j)
for (int k = 0; k <= n; ++k)
for (int z = 0; z < 2; ++z) dp[i][j][k][z] = INF;
dp[0][0][0][0] = 0;
}
void process() {
for (int v = 0; v <= (int)V.size(); ++v)
for (int k = 0; k <= (int)K.size(); ++k)
for (int o = 0; o <= (int)O.size(); ++o)
for (int type = 0; type < 2; ++type) {
auto moving_cost = [&](int where) {
return count_remaining(V, v, where) + count_remaining(K, k, where) +
count_remaining(O, o, where);
};
int already = dp[v][k][o][type];
if (v < (int)V.size())
mini(dp[v + 1][k][o][1], already + moving_cost(V[v]));
if (k < (int)K.size() && type == 0)
mini(dp[v][k + 1][o][0], already + moving_cost(K[k]));
if (o < (int)O.size())
mini(dp[v][k][o + 1][0], already + moving_cost(O[o]));
}
ans = INF;
for (int i = 0; i < 2; ++i) {
mini(ans, dp[V.size()][K.size()][O.size()][i]);
}
}
int main() {
ios_base::sync_with_stdio(false);
init();
process();
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
using namespace std;
int pk[80];
int pv[80], px[80];
int dp[80][80][80][2];
int vn = 0, kn = 0, xn = 0;
int vs[80], ks[80], xs[80];
int N;
string s;
int get(int num, int flag, int v, int k, int x) {
int ans = 0, tans[3];
tans[0] = max(vs[num] - v, 0);
tans[1] = max(ks[num] - k, 0);
tans[2] = max(xs[num] - x, 0);
for (int i = 0; i <= 2; i++)
if (i != flag) ans += tans[i];
return ans;
}
int main() {
cin >> N;
cin >> s;
for (int i = 0; i < N; i++) {
if (i != 0) {
vs[i] = vs[i - 1];
ks[i] = ks[i - 1];
xs[i] = xs[i - 1];
}
if (s[i] == 'K') {
pk[++kn] = i;
ks[i]++;
} else if (s[i] == 'V') {
pv[++vn] = i;
vs[i]++;
} else {
px[++xn] = i;
xs[i]++;
}
}
memset(dp, inf, sizeof(dp));
dp[0][0][0][0] = 0;
for (int v = 0; v <= vn; v++)
for (int k = 0; k <= kn; k++)
for (int x = 0; x <= xn; x++) {
if (v < vn)
dp[v + 1][k][x][1] = min(
min(dp[v][k][x][0], dp[v][k][x][1]) + get(pv[v + 1], 0, v, k, x),
dp[v + 1][k][x][1]);
if (k < kn)
dp[v][k + 1][x][0] = min(dp[v][k][x][0] + get(pk[k + 1], 1, v, k, x),
dp[v][k + 1][x][0]);
if (x < xn)
dp[v][k][x + 1][0] = min(
min(dp[v][k][x][0], dp[v][k][x][1]) + get(px[x + 1], 2, v, k, x),
dp[v][k][x + 1][0]);
}
cout << min(dp[vn][kn][xn][0], dp[vn][kn][xn][1]) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, V, K, X;
vector<char> S;
int cc[80][80][80][2];
int dp(int v, int k, int x, int la) {
int &ret = cc[v][k][x][la];
if (ret != -1) return ret;
if (v == 0 && k == 0 && x == 0) return ret = 0;
ret = 1e9;
vector<char> tmp;
int vr = V, kr = K, xr = X;
for (int i = 0; i < N; i++) {
if (S[i] == 'V') {
if (vr <= v) tmp.push_back('V');
vr--;
}
if (S[i] == 'K') {
if (kr <= k) tmp.push_back('K');
kr--;
}
if (S[i] == 'X') {
if (xr <= x) tmp.push_back('X');
xr--;
}
}
int vd = 1e9, kd = 1e9, xd = 1e9;
for (int i = 0; i < tmp.size(); i++) {
if (tmp[i] == 'V') vd = min(vd, i);
if (tmp[i] == 'K') kd = min(kd, i);
if (tmp[i] == 'X') xd = min(xd, i);
}
if (v) ret = min(ret, vd + dp(v - 1, k, x, 1));
if (k && !la) ret = min(ret, kd + dp(v, k - 1, x, 0));
if (x) ret = min(ret, xd + dp(v, k, x - 1, 0));
return ret;
}
int main() {
cin >> N;
S.resize(N);
for (int i = 0; i < N; i++) {
cin >> S[i];
if (S[i] != 'V' && S[i] != 'K') S[i] = 'X';
if (S[i] == 'V') V++;
if (S[i] == 'K') K++;
if (S[i] == 'X') X++;
}
memset(cc, -1, sizeof(cc));
cout << dp(V, K, X, 0);
}
|
#include <bits/stdc++.h>
#pragma GCC target("sse4.2")
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("tony_stark", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
const int N = 75 + 7;
const int INF = (int)1e9;
int n, a[N], dp[N][N][N][3], sz[3];
string s;
vector<int> p[3];
signed realMain() {
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;
cin >> n >> s;
for (int i = 1; i <= n; i++) {
if (s[i - 1] == 'V') {
a[i] = 1;
}
if (s[i - 1] == 'K') {
a[i] = 2;
}
p[a[i]].push_back(i);
sz[a[i]]++;
}
dp[0][0][0][0] = 0;
for (int x = 0; x <= sz[0]; x++) {
for (int v = 0; v <= sz[1]; v++) {
for (int k = 0; k <= sz[2]; k++) {
for (int t = 0; t < 3; t++) {
if (dp[x][v][k][t] == INF) continue;
int depe = dp[x][v][k][t];
if (x + 1 <= sz[0]) {
int relax = depe, posi = p[0][x], adi = 0;
for (int i = 0; i < x; i++) adi += (p[0][i] > posi);
for (int i = 0; i < v; i++) adi += (p[1][i] > posi);
for (int i = 0; i < k; i++) adi += (p[2][i] > posi);
posi += adi;
relax += posi - (x + v + k + 1);
dp[x + 1][v][k][0] = min(dp[x + 1][v][k][0], relax);
}
if (v + 1 <= sz[1]) {
int relax = depe, posi = p[1][v], adi = 0;
for (int i = 0; i < x; i++) adi += (p[0][i] > posi);
for (int i = 0; i < v; i++) adi += (p[1][i] > posi);
for (int i = 0; i < k; i++) adi += (p[2][i] > posi);
posi += adi;
relax += posi - (x + v + k + 1);
dp[x][v + 1][k][1] = min(dp[x][v + 1][k][1], relax);
}
if (k + 1 <= sz[2] && t != 1) {
int relax = depe, posi = p[2][k], adi = 0;
for (int i = 0; i < x; i++) adi += (p[0][i] > posi);
for (int i = 0; i < v; i++) adi += (p[1][i] > posi);
for (int i = 0; i < k; i++) adi += (p[2][i] > posi);
posi += adi;
relax += posi - (x + v + k + 1);
dp[x][v][k + 1][2] = min(dp[x][v][k + 1][2], relax);
}
}
}
}
}
int ret = INF;
for (int t = 0; t < 3; t++) {
ret = min(ret, dp[sz[0]][sz[1]][sz[2]][t]);
}
cout << ret << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int INF = 1000000000;
int mem[77][77][77][2];
int mem2[3][77];
string str;
vector<int> items;
int N;
int index(int ch, int n) {
if (n == 0) return 0;
int& cached = mem2[ch][n];
if (cached != -1) return cached;
int c = 0;
int i = 0;
for (auto& item : items) {
if (item == ch) {
c++;
if (c == n) {
cached = i;
return i;
}
}
i++;
}
cached = INF;
return INF;
}
int nonneg(int x) { return max(x, 0); }
int real_index(int k, int v, int x, int ch, int n) {
int cnt[3] = {0};
for (int i = 0; i < N; i++) {
cnt[items[i]]++;
if (items[i] == ch && cnt[items[i]] == n) {
int offset = nonneg(k - cnt[0]) + nonneg(v - cnt[1]) + nonneg(x - cnt[2]);
return i + offset;
}
}
return INF;
}
int dp(int k, int v, int x, bool is_v) {
int& cached = mem[k][v][x][is_v];
if (cached != -1) return cached;
if (k + v + x == N) {
cached = 0;
return cached;
}
int best = INF;
int cur_index = k + v + x;
if (!is_v)
best = min(best, dp(k + 1, v, x, false) + real_index(k, v, x, 0, k + 1) -
cur_index);
best = min(best,
dp(k, v + 1, x, true) + real_index(k, v, x, 1, v + 1) - cur_index);
best = min(
best, dp(k, v, x + 1, false) + real_index(k, v, x, 2, x + 1) - cur_index);
cached = best;
return cached;
}
int main() {
fill_n(&mem2[0][0], 3 * 77, -1);
fill_n(&mem[0][0][0][0], 77 * 77 * 77 * 2, -1);
cin >> N;
cin >> str;
for (auto& x : str) {
switch (x) {
case 'K':
items.push_back(0);
break;
case 'V':
items.push_back(1);
break;
default:
items.push_back(2);
}
}
cout << dp(0, 0, 0, false);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 77;
const int inf = 1e9;
int dp[N][N][N][3];
string s;
int rel[N];
int go(int v, int k, int x, int here) {
int ret = 0;
for (int i = int(0); i < int(here); ++i) {
if (s[i] == 'V' && rel[i] >= v) ret++;
if (s[i] == 'K' && rel[i] >= k) ret++;
if (s[i] == 'X' && rel[i] >= x) ret++;
}
return ret;
}
void mini(int &a, int b) { a = min(a, b); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
cin >> s;
for (char &c : s)
if (c != 'V' && c != 'K') c = 'X';
for (int i = int(0); i < int(n); ++i)
for (int j = int(0); j < int(n); ++j)
for (int k = int(0); k < int(n); ++k)
for (int here = int(0); here < int(3); ++here) dp[i][j][k][here] = inf;
int V = 0, K = 0, X = 0;
for (int i = int(0); i < int(n); ++i) {
if (s[i] == 'V') rel[i] = V++;
if (s[i] == 'K') rel[i] = K++;
if (s[i] == 'X') rel[i] = X++;
}
dp[0][0][0][0] = 0;
dp[0][0][0][1] = 0;
dp[0][0][0][2] = 0;
for (int v = int(0); v < int(V + 1); ++v)
for (int k = int(0); k < int(K + 1); ++k)
for (int x = int(0); x < int(X + 1); ++x)
for (int here = int(0); here < int(3); ++here) {
if (here == 0 && v == 0) continue;
if (here == 1 && k == 0) continue;
if (here == 2 && x == 0) continue;
int vv = v, kk = k, xx = x;
if (here == 0) {
vv--;
int cnt = 0, pos;
for (int i = int(0); i < int(n); ++i)
if (s[i] == 'V') {
cnt++;
if (cnt == v) {
pos = i;
break;
}
}
mini(dp[v][k][x][here], dp[vv][kk][xx][0] + go(vv, kk, xx, pos));
mini(dp[v][k][x][here], dp[vv][kk][xx][1] + go(vv, kk, xx, pos));
mini(dp[v][k][x][here], dp[vv][kk][xx][2] + go(vv, kk, xx, pos));
}
if (here == 1) {
kk--;
int cnt = 0, pos;
for (int i = int(0); i < int(n); ++i)
if (s[i] == 'K') {
cnt++;
if (cnt == k) {
pos = i;
break;
}
}
mini(dp[v][k][x][here], dp[vv][kk][xx][1] + go(vv, kk, xx, pos));
mini(dp[v][k][x][here], dp[vv][kk][xx][2] + go(vv, kk, xx, pos));
}
if (here == 2) {
xx--;
int cnt = 0, pos;
for (int i = int(0); i < int(n); ++i)
if (s[i] == 'X') {
cnt++;
if (cnt == x) {
pos = i;
break;
}
}
mini(dp[v][k][x][here], dp[vv][kk][xx][0] + go(vv, kk, xx, pos));
mini(dp[v][k][x][here], dp[vv][kk][xx][1] + go(vv, kk, xx, pos));
mini(dp[v][k][x][here], dp[vv][kk][xx][2] + go(vv, kk, xx, pos));
}
}
int ans = min(dp[V][K][X][0], min(dp[V][K][X][1], dp[V][K][X][2]));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool chkmin(int &x, int y) { return ((x > y) ? (x = y, 1) : 0); }
bool chkmax(int &x, int y) { return ((x < y) ? (x = y, 1) : 0); }
int n;
char s[82];
int pv[82], sv[82], pvcnt = 0;
int pk[82], sk[82], pkcnt = 0;
int po[82], so[82], pocnt = 0;
int dp[82][82][82][3];
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; i++) {
sk[i] = sk[i - 1];
sv[i] = sv[i - 1];
so[i] = so[i - 1];
if (s[i] == 'V')
pv[++pvcnt] = i, sv[i]++;
else if (s[i] == 'K')
pk[++pkcnt] = i, sk[i]++;
else
po[++pocnt] = i, so[i]++;
}
memset(dp, 63, sizeof(dp));
dp[0][0][0][0] = 0;
for (int o = 0; o <= pocnt; o++)
for (int v = 0; v <= pvcnt; v++)
for (int k = 0; k <= pkcnt; k++) {
for (int f = 0; f < 2; f++) {
if (o != pocnt)
chkmin(dp[o + 1][v][k][0], dp[o][v][k][f] +
max(o - so[po[o + 1] - 1], 0) +
max(v - sv[po[o + 1] - 1], 0) +
max(k - sk[po[o + 1] - 1], 0));
if (v != pvcnt)
chkmin(dp[o][v + 1][k][1], dp[o][v][k][f] +
max(o - so[pv[v + 1] - 1], 0) +
max(v - sv[pv[v + 1] - 1], 0) +
max(k - sk[pv[v + 1] - 1], 0));
if (k != pkcnt && !f)
chkmin(dp[o][v][k + 1][0], dp[o][v][k][f] +
max(o - so[pk[k + 1] - 1], 0) +
max(v - sv[pk[k + 1] - 1], 0) +
max(k - sk[pk[k + 1] - 1], 0));
}
}
printf("%d\n", min(dp[pocnt][pvcnt][pkcnt][0], dp[pocnt][pvcnt][pkcnt][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 80, INF = 0x3f3f3f3f;
char str[MAXN];
vector<int> vs, ks, xs;
int dp[MAXN][MAXN][MAXN][2];
int remain(vector<int> &vec, int start, int lim) {
int res = 0;
for (unsigned i = start; i < vec.size() && vec[i] < lim; i++) res++;
return res;
}
void update(int &dst, int v, int k, int x, int canK, int val) {
int d = remain(vs, v, val) + remain(ks, k, val) + remain(xs, x, val);
dst = min(dst, dp[v][k][x][canK] + d);
}
int main() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(0);
int n;
cin >> n >> str;
for (int i = 0; i < n; i++) {
if (str[i] == 'V')
vs.push_back(i);
else if (str[i] == 'K')
ks.push_back(i);
else
xs.push_back(i);
}
memset(dp, INF, sizeof(dp));
dp[0][0][0][1] = 0;
for (unsigned v = 0; v <= vs.size(); v++) {
for (unsigned k = 0; k <= ks.size(); k++) {
for (unsigned x = 0; x <= xs.size(); x++) {
for (unsigned canK = 0; canK <= 1; canK++) {
if (v < vs.size()) update(dp[v + 1][k][x][0], v, k, x, canK, vs[v]);
if (canK && k < ks.size()) {
update(dp[v][k + 1][x][1], v, k, x, canK, ks[k]);
}
if (x < xs.size()) update(dp[v][k][x + 1][1], v, k, x, canK, xs[x]);
}
}
}
}
int *ans = dp[vs.size()][ks.size()][xs.size()];
cout << min(ans[0], ans[1]) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int T[100];
void upd(int idx, int val) {
idx++;
while (idx < 100) {
T[idx] += val;
idx += idx & -idx;
}
}
int qry(int idx) {
int r = 0;
idx++;
while (idx) {
r += T[idx];
idx -= idx & -idx;
}
return r;
}
int n;
int dp[2][100][100][100];
int nxt[3][100];
char s[100];
int get(int ok, int v, int k, int x) {
int &r = dp[ok][v][k][x];
if (v == n && k == n && x == n) return 0;
if (r + 1) return r;
r = 1e9;
if (v != n) {
upd(v, 1);
r = min(r, get(0, nxt[0][v], k, x) + qry(n) - qry(v));
upd(v, -1);
}
if (k != n && ok) {
upd(k, 1);
r = min(r, get(1, v, nxt[1][k], x) + qry(n) - qry(k));
upd(k, -1);
}
if (x != n) {
upd(x, 1);
r = min(r, get(1, v, k, nxt[2][x]) + qry(n) - qry(x));
upd(x, -1);
}
return r;
}
int main() {
scanf("%d %s", &n, s);
int v = n, k = n, x = n;
for (int i = n - 1; i >= 0; i--) {
nxt[0][i] = v;
nxt[1][i] = k;
nxt[2][i] = x;
if (s[i] == 'V')
v = i;
else if (s[i] == 'K')
k = i;
else
x = i;
}
memset(dp, -1, sizeof(dp));
printf("%d\n", get(1, v, k, x));
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[76][76][76][3];
const int inf = 1e6;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> a(n);
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;
}
}
vector<vector<int>> ls(3);
for (int i = 0; i < n; i++) {
ls[a[i]].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 l = 0; l < 3; l++) {
dp[i][j][k][l] = inf;
}
}
}
}
dp[0][0][0][2] = 0;
int ans = inf;
for (int i = 0; i <= (int)(ls[0]).size(); i++) {
for (int j = 0; j <= (int)(ls[1]).size(); j++) {
for (int k = 0; k <= (int)(ls[2]).size(); k++) {
for (int l = 0; l < 3; l++)
if (dp[i][j][k][l] < inf) {
if (i + j + k == n) {
ans = min(ans, dp[i][j][k][l]);
}
vector<int> cur = {i, j, k};
for (int t = 0; t < 3; t++)
if (cur[t] + 1 <= (int)(ls[t]).size()) {
if (t == 1 && l == 0) {
continue;
}
int val = 0;
for (int f = 0; f < 3; f++)
if (f != t) {
for (int w = 0; w < cur[f]; w++) {
if (ls[f][w] > ls[t][cur[t]]) {
val++;
}
}
}
if (dp[i + (t == 0)][j + (t == 1)][k + (t == 2)][t] >
dp[i][j][k][l] + val) {
dp[i + (t == 0)][j + (t == 1)][k + (t == 2)][t] =
dp[i][j][k][l] + val;
}
}
}
}
}
}
cout << ans << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
int N, arr[maxn], dp[maxn][maxn][maxn][3];
vector<int> pos[3];
bool marked[maxn];
inline int calc(int a, vector<int> &v) {
int cnt = 0;
for (int ck : v) cnt += ck <= a;
return cnt;
}
int solve(int a[3], int lst) {
if (a[0] + a[1] + a[2] == 0) return 0;
if (dp[a[0]][a[1]][a[2]][lst] != -1) return dp[a[0]][a[1]][a[2]][lst];
int res = 0x3f3f3f3f;
memset(marked, 0, sizeof marked);
for (int i = 0; i < 3; i++)
for (int k = 0; k < a[i]; k++) marked[pos[i][k]] = true;
vector<int> v;
for (int i = 1; i <= N; i++)
if (!marked[i]) v.push_back(i);
for (int p = 0; p < 3; p++) {
if (p == 0 && lst == 1 || !a[p]) continue;
int pp = pos[p][--a[p]], cc = calc(pp, v);
res = min(res, solve(a, p) + cc);
a[p]++;
}
return dp[a[0]][a[1]][a[2]][lst] = res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) {
char c;
cin >> c;
if (c == 'V')
arr[i] = 0;
else if (c == 'K')
arr[i] = 1;
else
arr[i] = 2;
pos[arr[i]].push_back(i);
}
memset(dp, -1, sizeof dp);
int res = 0x3f3f3f3f, tmp[3];
for (int i = 0; i < 3; i++) tmp[i] = (int)pos[i].size();
for (int i = 0; i < 3; i++) {
if (!tmp[i]) continue;
tmp[i]--;
res = min(res, solve(tmp, i));
tmp[i]++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt1, cnt2, cnt3;
int f[100][100][100][4];
string s;
int n;
int a[20000];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
cin >> s;
for (int i = 1; i <= n; i++) {
if (s[i - 1] == 'V')
a[i] = 1;
else if (s[i - 1] == 'K')
a[i] = 2;
else
a[i] = 3;
if (a[i] == 1)
cnt1++;
else if (a[i] == 2)
cnt2++;
else if (a[i] == 3)
cnt3++;
}
for (int i = 0; i <= cnt1; i++)
for (int j = 0; j <= cnt2; j++)
for (int k = 0; k <= cnt3; k++)
for (int tp = 1; tp <= 3; tp++) f[i][j][k][tp] = 1e9;
f[0][0][0][3] = 0;
for (int i = 0; i <= cnt1; i++)
for (int j = 0; j <= cnt2; j++)
for (int k = 0; k <= cnt3; k++)
for (int tp = 1; tp <= 3; tp++) {
if (f[i][j][k][tp] == 1e9) continue;
int q1 = 0, q2 = 0, q3 = 0, cnt = -1;
for (int t = 1; t <= n; t++) {
if (a[t] == 1) {
q1++;
if (q1 > i) cnt++;
}
if (a[t] == 2) {
q2++;
if (q2 > j) cnt++;
}
if (a[t] == 3) {
q3++;
if (q3 > k) cnt++;
}
if (q1 == i + 1 && a[t] == 1)
f[i + 1][j][k][1] = min(f[i + 1][j][k][1], f[i][j][k][tp] + cnt);
if (q2 == j + 1 && a[t] == 2 && tp != 1)
f[i][j + 1][k][2] = min(f[i][j + 1][k][2], f[i][j][k][tp] + cnt);
if (q3 == k + 1 && a[t] == 3)
f[i][j][k + 1][3] = min(f[i][j][k + 1][3], f[i][j][k][tp] + cnt);
}
}
cout << min(min(f[cnt1][cnt2][cnt3][1], f[cnt1][cnt2][cnt3][2]),
f[cnt1][cnt2][cnt3][3]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const NMAX = 100;
int const INF = 1 << 30;
int const PC = 99;
int pv[1 + NMAX], pk[1 + NMAX], delim[1 + NMAX], n,
sol[1 + NMAX][1 + NMAX][1 + NMAX][2];
int counter(int a[], int start, int maxx) {
int no = 0;
while (start < a[PC] && a[start] < maxx) {
no++;
start++;
}
return no;
}
int cost(int pos, int i, int j, int k) {
int rez = counter(pv, i, pos) + counter(pk, j, pos) + counter(delim, k, pos);
return rez;
}
void read() {
std ::ios_base ::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
char c;
cin >> c;
if (c == 'V')
pv[pv[PC]++] = i;
else if (c == 'K')
pk[pk[PC]++] = i;
else
delim[delim[PC]++] = i;
}
}
void set_to_inf() {
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 <= 1; l++) sol[i][j][k][l] = INF;
}
void solve() {
sol[0][0][0][0] = 0;
for (int i = 0; i <= pv[PC]; i++) {
for (int j = 0; j <= pk[PC]; j++) {
for (int k = 0; k <= delim[PC]; k++) {
for (int l = 0; l <= 1; l++) {
if (i < pv[PC])
sol[i + 1][j][k][1] = min(sol[i + 1][j][k][1],
sol[i][j][k][l] + cost(pv[i], i, j, k));
if (j < pk[PC] && l == 0)
sol[i][j + 1][k][0] = min(sol[i][j + 1][k][0],
sol[i][j][k][l] + cost(pk[j], i, j, k));
if (k < delim[PC])
sol[i][j][k + 1][0] = min(
sol[i][j][k + 1][0], sol[i][j][k][l] + cost(delim[k], i, j, k));
}
}
}
}
}
void write() {
int answer = INF;
for (int i = 0; i < 2; ++i)
answer = min(answer, sol[pv[PC]][pk[PC]][delim[PC]][i]);
cout << answer;
}
int main() {
read();
set_to_inf();
solve();
write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80, Inf = 0x3f3f3f3f;
int n, f[N][N][N][2];
int pos[3][N], num[3][N];
char s[N];
inline int getid(char ch) {
if (ch == 'V') return 0;
if (ch == 'K') return 1;
return 2;
}
inline int move(int i, int j, int k, int id) {
return max(0, num[0][id] - i) + max(0, num[1][id] - j) +
max(0, num[2][id] - k) - 1;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> s + 1;
for (int i = 1; i <= n; ++i) {
int now = getid(s[i]);
for (int j = 0; j < 3; ++j) num[j][i] = num[j][i - 1];
pos[now][++num[now][i]] = i;
}
memset(f, 0x3f, sizeof f);
f[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 fl = 0; fl < 2; ++fl) {
if (i < num[0][n])
f[i + 1][j][k][1] =
min(f[i + 1][j][k][1],
f[i][j][k][fl] + move(i, j, k, pos[0][i + 1]));
if (j < num[1][n] && !fl)
f[i][j + 1][k][0] =
min(f[i][j + 1][k][0],
f[i][j][k][fl] + move(i, j, k, pos[1][j + 1]));
if (k < num[2][n])
f[i][j][k + 1][0] =
min(f[i][j][k + 1][0],
f[i][j][k][fl] + move(i, j, k, pos[2][k + 1]));
}
cout << min(f[num[0][n]][num[1][n]][num[2][n]][0],
f[num[0][n]][num[1][n]][num[2][n]][1])
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma optimize("-O3")
int dp[76][76][76][2];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string st;
cin >> st;
for (int i = 0; i < 76; i++) {
for (int j = 0; j < 76; j++) {
for (int k = 0; k < 76; k++) {
for (int l = 0; l < 2; l++) {
dp[i][j][k][l] = 1e9;
}
}
}
}
dp[0][0][0][0] = 0;
dp[0][0][0][1] = 0;
vector<vector<int>> v;
v.resize(3);
for (int i = 0; i < st.size(); i++) {
if (st[i] == 'V') {
v[0].push_back(i);
} else if (st[i] == 'K') {
v[1].push_back(i);
} else {
v[2].push_back(i);
}
}
int sz1 = v[0].size();
int sz2 = v[1].size();
int sz3 = v[2].size();
for (int i = 0; i <= sz1; i++) {
for (int j = 0; j <= sz2; j++) {
for (int k = 0; k <= sz3; k++) {
for (int l = 0; l < 2; l++) {
if (l == 0) {
if (k != v[2].size()) {
int pos = v[2][k];
int val = 0;
int ans = 0;
for (auto u : v[0]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - i);
val = 0;
for (auto u : v[1]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - j);
dp[i][j][k + 1][1] =
min(dp[i][j][k + 1][1], dp[i][j][k][0] + ans);
}
if (i != v[0].size()) {
int pos = v[0][i];
int val = 0;
int ans = 0;
for (auto u : v[1]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - j);
val = 0;
for (auto u : v[2]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - k);
dp[i + 1][j][k][0] =
min(dp[i + 1][j][k][0], dp[i][j][k][0] + ans);
}
} else {
if (i != v[0].size()) {
int pos = v[0][i];
int val = 0;
int ans = 0;
for (auto u : v[1]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - j);
val = 0;
for (auto u : v[2]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - k);
dp[i + 1][j][k][0] =
min(dp[i + 1][j][k][0], dp[i][j][k][1] + ans);
}
if (j != v[1].size()) {
int pos = v[1][j];
int val = 0;
int ans = 0;
for (auto u : v[0]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - i);
val = 0;
for (auto u : v[2]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - k);
dp[i][j + 1][k][1] =
min(dp[i][j + 1][k][1], dp[i][j][k][1] + ans);
}
if (k != v[2].size()) {
int pos = v[2][k];
int val = 0;
int ans = 0;
for (auto u : v[0]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - i);
val = 0;
for (auto u : v[1]) {
if (u < pos) {
val++;
}
}
ans += max(0, val - j);
dp[i][j][k + 1][1] =
min(dp[i][j][k + 1][1], dp[i][j][k][1] + ans);
}
}
}
}
}
}
cout << min(dp[sz1][sz2][sz3][0], dp[sz1][sz2][sz3][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const long long int maxn = 79, md = 1e9 + 7, inf = 2e16;
long long int gcd(long long int a, long long int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
long long int tav(long long int n, long long int k) {
long long int res = 1;
while (k > 0) {
if (k & 1) {
res *= n;
res %= md;
}
n *= n;
n %= md;
k >>= 1;
}
return res;
}
long long int a[maxn], dp[maxn][maxn][maxn][3], b[maxn];
vector<long long int> v[3];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, cnt[] = {0, 0, 0};
string s;
cin >> n >> s;
for (long long 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;
}
b[i] = cnt[a[i]]++;
v[a[i]].push_back(i);
}
memset(dp, 63, sizeof(dp));
if (cnt[0]) dp[0][1][0][0] = 2 * v[0][0];
if (cnt[1]) dp[0][0][1][1] = 2 * v[1][0];
if (cnt[2]) dp[0][0][0][2] = 2 * v[2][0];
for (long long int i = 1; i < n; i++) {
for (long long int x = 0; x <= i + 1; x++) {
if (x > cnt[0]) continue;
for (long long int y = 0; x + y <= i + 1; y++) {
if (y > cnt[1]) continue;
long long int z = i + 1 - x - y;
if (z > cnt[2]) continue;
if (x) {
dp[i][x][y][0] =
min(min(dp[i - 1][x - 1][y][0], dp[i - 1][x - 1][y][1]),
dp[i - 1][x - 1][y][2]);
long long int h = v[0][x - 1];
for (long long int j = v[0][x - 1]; j < n; j++) {
if (a[j] == 1 && b[j] < y) h++;
if (a[j] == 2 && b[j] < z) h++;
}
dp[i][x][y][0] += 2 * abs(i - h);
}
if (y) {
dp[i][x][y][1] = min(dp[i - 1][x][y - 1][1], dp[i - 1][x][y - 1][2]);
long long int h = v[1][y - 1];
for (long long int j = v[1][y - 1]; j < n; j++) {
if (a[j] == 0 && b[j] < x) h++;
if (a[j] == 2 && b[j] < z) h++;
}
dp[i][x][y][1] += 2 * abs(i - h);
}
if (z) {
dp[i][x][y][2] = min(min(dp[i - 1][x][y][0], dp[i - 1][x][y][1]),
dp[i - 1][x][y][2]);
long long int h = v[2][z - 1];
for (long long int j = v[2][z - 1]; j < n; j++) {
if (a[j] == 0 && b[j] < x) h++;
if (a[j] == 1 && b[j] < y) h++;
}
dp[i][x][y][2] += 2 * abs(i - h);
}
}
}
}
long long int ans =
min(min(dp[n - 1][cnt[0]][cnt[1]][0], dp[n - 1][cnt[0]][cnt[1]][1]),
dp[n - 1][cnt[0]][cnt[1]][2]) /
2;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int N = 80;
int n, m, k, u, v, x, y, t, a, b, ans;
int A[N], cnt[N][3];
int dp[N][N][N][3];
vector<int> vec[3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
char ch;
cin >> ch;
if (ch == 'V') A[i] = 1;
if (ch == 'K') A[i] = 2;
cnt[i][0] = cnt[i - 1][0];
cnt[i][1] = cnt[i - 1][1];
cnt[i][2] = cnt[i - 1][2];
cnt[i][A[i]]++;
vec[A[i]].push_back(i);
}
memset(dp, 31, sizeof(dp));
for (int i : {0, 1, 2}) dp[0][0][0][i] = 0;
for (int a = 0; a <= cnt[n][0]; a++) {
for (int b = 0; b <= cnt[n][1]; b++) {
for (int c = 0; c <= cnt[n][2]; c++) {
if (a) {
int pos = vec[0][a - 1],
cost = max(cnt[pos][1] - b, 0) + max(cnt[pos][2] - c, 0);
dp[a][b][c][0] = min(dp[a][b][c][0], dp[a - 1][b][c][0] + cost);
dp[a][b][c][0] = min(dp[a][b][c][0], dp[a - 1][b][c][1] + cost);
dp[a][b][c][0] = min(dp[a][b][c][0], dp[a - 1][b][c][2] + cost);
}
if (b) {
int pos = vec[1][b - 1],
cost = max(cnt[pos][0] - a, 0) + max(cnt[pos][2] - c, 0);
dp[a][b][c][1] = min(dp[a][b][c][1], dp[a][b - 1][c][0] + cost);
dp[a][b][c][1] = min(dp[a][b][c][1], dp[a][b - 1][c][1] + cost);
dp[a][b][c][1] = min(dp[a][b][c][1], dp[a][b - 1][c][2] + cost);
}
if (c) {
int pos = vec[2][c - 1],
cost = max(cnt[pos][0] - a, 0) + max(cnt[pos][1] - b, 0);
dp[a][b][c][2] = min(dp[a][b][c][2], dp[a][b][c - 1][0] + cost);
dp[a][b][c][2] = min(dp[a][b][c][2], dp[a][b][c - 1][2] + cost);
}
}
}
}
ans = inf;
for (int i : {0, 1, 2})
ans = min(ans, dp[cnt[n][0]][cnt[n][1]][cnt[n][2]][i]);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[80][80][80][2];
string s;
vector<int> vp, kp, xp;
int calc(int pos, int vi, int ki, int xi) {
int lv = distance(vp.begin(), lower_bound(vp.begin(), vp.end(), pos));
int lk = distance(kp.begin(), lower_bound(kp.begin(), kp.end(), pos));
int lx = distance(xp.begin(), lower_bound(xp.begin(), xp.end(), pos));
return max(lv - vi, 0) + max(lk - ki, 0) + max(lx - xi, 0);
}
int main(int argc, char** argv) {
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
vp.push_back(i);
else if (s[i] == 'K')
kp.push_back(i);
else
xp.push_back(i);
}
for (int v = 0; v <= n; v++) {
for (int k = 0; k <= n; k++) {
for (int x = 0; x <= n; x++) dp[v][k][x][0] = dp[v][k][x][1] = 1 << 29;
}
}
dp[0][0][0][0] = 0;
for (int v = 0; v <= (int)vp.size(); v++) {
for (int k = 0; k <= (int)kp.size(); k++) {
for (int x = 0; x <= (int)xp.size(); x++) {
for (int i = 0; i < 2; i++) {
int cur = dp[v][k][x][i];
if (v < (int)vp.size())
dp[v + 1][k][x][1] =
min(dp[v + 1][k][x][1], cur + calc(vp[v], v, k, x));
if (!i && k < (int)kp.size())
dp[v][k + 1][x][0] =
min(dp[v][k + 1][x][0], cur + calc(kp[k], v, k, x));
if (x < (int)xp.size())
dp[v][k][x + 1][0] =
min(dp[v][k][x + 1][0], cur + calc(xp[x], v, k, x));
}
}
}
}
cout << min(dp[vp.size()][kp.size()][xp.size()][0],
dp[vp.size()][kp.size()][xp.size()][1])
<< '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 77;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
int dp[N][N][N][4], cnt[4], ps[N][4];
char second[N];
vector<int> pos[4];
void U(int i, int j, int k, int nt, int ans) {
if (j > cnt[0] || k > cnt[1] || (i - j - k) > cnt[2]) return;
int id = 0, extra = 0;
if (nt == 0) {
id = j - 1;
} else if (nt == 1) {
id = k - 1;
} else {
id = i - j - k - 1;
}
int id2 = pos[nt][id];
extra = max(0, j - ps[id2][0]) + max(0, k - ps[id2][1]) +
max(0, (i - j - k) - ps[id2][2]);
dp[i][j][k][nt] = min(dp[i][j][k][nt], ans + max(0, (id2 + extra) - i));
}
int main() {
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] = 1e9;
}
}
}
}
dp[0][0][0][2] = 0;
int n;
scanf("%d%s", &n, &second);
string s = second;
s = "." + s;
for (int i = 1; i <= n; i++) {
if (s[i] == 'V') {
s[i] = 'a';
} else if (s[i] == 'K') {
s[i] = 'b';
} else {
s[i] = 'c';
}
for (int t = 0; t < 3; t++) {
ps[i][t] = ps[i - 1][t];
}
ps[i][(int)s[i] - 'a']++;
pos[s[i] - 'a'].push_back(i);
cnt[s[i] - 'a']++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= (i - j); k++) {
if (j > cnt[0] || k > cnt[1] || (i - j - k) > cnt[2]) continue;
for (int t = 0; t < 3; t++) {
for (int nt = 0; nt < 3; nt++) {
if (t == 0 && nt == 1) continue;
int i2 = i + 1, j2 = j + (nt == 0), k2 = k + (nt == 1);
U(i2, j2, k2, nt, dp[i][j][k][t]);
}
}
}
}
}
printf("%d", min({dp[n][cnt[0]][cnt[1]][0], dp[n][cnt[0]][cnt[1]][1],
dp[n][cnt[0]][cnt[1]][2]}));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 77;
int dp[MX][MX][MX][2];
int n, cnt[3][MX];
string str;
vector<int> occK, occV, occR;
int calc(int V, int K, int R, int flag) {
if (V + K + R == n) return 0;
int &ret = dp[V][K][R][flag];
if (ret != -1) return ret;
ret = (1 << 30);
if (V + 1 <= occV.size()) {
int pos = occV[V], remK = K, remR = R;
for (int j = 1; j <= pos; j++)
if (str[j] == 'K')
remK--;
else if (str[j] != 'V')
remR--;
ret = min(ret, max(remK, 0) + max(remR, 0) + calc(V + 1, K, R, 1));
}
if (K + 1 <= occK.size() && !flag) {
int pos = occK[K], remV = V, remR = R;
for (int j = 1; j <= pos; j++)
if (str[j] == 'V')
remV--;
else if (str[j] != 'K')
remR--;
ret = min(ret, max(remV, 0) + max(remR, 0) + calc(V, K + 1, R, 0));
}
if (R + 1 <= occR.size()) {
int pos = occR[R], remV = V, remK = K;
for (int j = 1; j <= pos; j++)
if (str[j] == 'V')
remV--;
else if (str[j] == 'K')
remK--;
ret = min(ret, max(remV, 0) + max(remK, 0) + calc(V, K, R + 1, 0));
}
return ret;
}
int main() {
cin >> n >> str;
str = "#" + str;
for (int j = 1; j <= n; j++) {
if (str[j] == 'V')
occV.push_back(j);
else if (str[j] == 'K')
occK.push_back(j);
else
occR.push_back(j);
}
memset(dp, -1, sizeof(dp));
cout << calc(0, 0, 0, 0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100;
int d[maxN][maxN][maxN][3];
int arr[maxN];
int pos[3][maxN];
int pref[maxN][3];
void prec(int n) {
int cnt[3] = {0, 0, 0};
for (int i = 0; i < n; i++) {
cnt[arr[i]]++;
pos[arr[i]][cnt[arr[i]]] = i + 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
pref[i][j] = (i == 0) ? 0 : pref[i - 1][j];
pref[i][j] += arr[i] == j;
}
}
}
int main(void) {
string s;
int n;
cin >> n;
cin >> s;
for (int i = 0; i < (int)s.size(); i++) {
arr[i] = s[i] == 'K' ? 0 : (s[i] == 'V' ? 1 : 2);
}
prec(n);
int cnt[3] = {0, 0, 0};
int& k = cnt[0];
int& v = cnt[1];
int& x = cnt[2];
for (k = 0; k < n; k++) {
for (v = 0; v < n; v++) {
for (x = 0; x < n; x++) {
if (k + v + x == 0) {
d[k][v][x][0] = 1e9;
d[k][v][x][1] = 1e9;
d[v][v][x][2] = 0;
continue;
}
for (int lst = 0; lst < 3; lst++) {
int p = pos[lst][cnt[lst]] - 1;
if (p == -1) {
d[k][v][x][lst] = 1e9;
continue;
}
int useless = 0;
for (int j = 0; j < 3; j++) {
useless += max(0, pref[p][j] - cnt[j]);
}
if (lst == 0) {
d[k][v][x][lst] = min(d[k - 1][v][x][0], d[k - 1][v][x][2]);
} else if (lst == 1) {
d[k][v][x][lst] = min(min(d[k][v - 1][x][0], d[k][v - 1][x][2]),
d[k][v - 1][x][1]);
} else {
d[k][v][x][lst] = min(min(d[k][v][x - 1][0], d[k][v][x - 1][2]),
d[k][v][x - 1][1]);
}
d[k][v][x][lst] += useless;
}
}
}
}
int ans = 1e9;
for (int j = 0; j < 3; j++) {
ans = min(ans, d[pref[n - 1][0]][pref[n - 1][1]][pref[n - 1][2]][j]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pfx {
int s[3];
};
int operator-(pfx x, pfx y) {
int ret = 0;
for (int(i) = (0); (i) < (3); ++(i)) ret += max(0, x.s[i] - y.s[i]);
return ret;
}
const int maxn = 80;
const int inf = 1ll << 25;
int n, mn = inf, dp[maxn][maxn][maxn][3];
char s[maxn], t[maxn];
pfx vkx[3][maxn];
int main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false);
cin >> n;
pfx tt;
tt.s[0] = tt.s[1] = tt.s[2] = 0;
for (int(i) = (0); (i) < (n); ++(i)) {
char c;
int x;
cin >> c, x = (c == 'V' ? 0 : c == 'K' ? 1 : 2);
++tt.s[x], vkx[x][tt.s[x]] = tt;
}
for (int(v) = (0); (v) < (n + 1); ++(v))
for (int(k) = (0); (k) < (n + 1); ++(k))
for (int(x) = (0); (x) < (n + 1); ++(x))
for (int(i) = (0); (i) < (3); ++(i)) dp[v][k][x][i] = inf;
dp[0][0][0][2] = 0;
for (int(v) = (0); (v) < (n); ++(v))
for (int(k) = (0); (k) < (n); ++(k))
for (int(x) = (0); (x) < (n); ++(x)) {
if (v + k + x >= n) continue;
for (int(i) = (0); (i) < (3); ++(i))
for (int(j) = (0); (j) < (3); ++(j))
if (!(i == 0 && j == 1)) {
pfx nn;
nn.s[0] = v + (j == 0), nn.s[1] = k + (j == 1),
nn.s[2] = x + (j == 2);
if (nn.s[0] > tt.s[0] || nn.s[1] > tt.s[1] || nn.s[2] > tt.s[2])
continue;
dp[nn.s[0]][nn.s[1]][nn.s[2]][j] =
min(dp[nn.s[0]][nn.s[1]][nn.s[2]][j],
dp[v][k][x][i] + (nn - vkx[j][nn.s[j]]));
}
}
for (int(i) = (0); (i) < (3); ++(i))
mn = min(mn, dp[tt.s[0]][tt.s[1]][tt.s[2]][i]);
cout << mn;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(const T &a) {
return a * a;
}
const int MAXN = 100;
const int INF = 1e9;
char s[MAXN];
int len;
int d[MAXN][MAXN][MAXN][2];
vector<pair<int, pair<int, int>>> V, K, C;
void relax(int &x, int y) { x = min(x, y); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
scanf("%d %s", &len, s);
for (int i = 0; i < (len); i++) {
if (s[i] == 'V')
V.push_back({i, {(int)K.size(), i - (int)V.size() - (int)K.size()}});
else if (s[i] == 'K')
K.push_back({i, {(int)V.size(), i - (int)V.size() - (int)K.size()}});
else
C.push_back({i, {(int)V.size(), (int)K.size()}});
}
for (int i = 0; i < (MAXN); i++)
for (int j = 0; j < (MAXN); j++)
for (int k = 0; k < (MAXN); k++)
for (int l = 0; l < (2); l++) d[i][j][k][l] = INF;
d[0][0][0][0] = 0;
for (int i = 0; i < ((int)V.size() + 1); i++) {
for (int j = 0; j < ((int)K.size() + 1); j++) {
for (int pos = 0; pos < (len); pos++) {
if (pos < i + j) continue;
for (int flag = 0; flag < (2); flag++) {
int val = d[i][j][pos][flag];
if (i < (int)V.size()) {
relax(d[i + 1][j][pos + 1][1],
val + abs(j - V[i].second.first) +
abs(pos - i - j - V[i].second.second));
}
if (j < (int)K.size() && !flag) {
relax(d[i][j + 1][pos + 1][0],
val + abs(i - K[j].second.first) +
abs(pos - i - j - K[j].second.second));
}
if (pos - i - j < C.size())
relax(d[i][j][pos + 1][0],
val + abs(i - C[pos - i - j].second.first) +
abs(j - C[pos - i - j].second.second));
}
}
}
}
printf("%d\n", min(d[(int)V.size()][(int)K.size()][len][0],
d[(int)V.size()][(int)K.size()][len][1]) /
2);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 5;
const int mod = 1e9 + 7;
const long long inf = 4e18;
const int del = 728729;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
long long dp[maxn][maxn][maxn][3];
long long mark[maxn], check[maxn];
long long cnt[3];
long long n;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < maxn; i++) {
for (int j = 0; j < maxn; j++) {
for (int k = 0; k < maxn; k++) {
for (int kp = 0; kp < 3; kp++) {
dp[i][j][k][kp] = inf;
}
}
}
}
dp[0][0][0][2] = 0;
cin >> n;
cin >> s;
for (int i = 1; i <= n; i++) {
if (s[i - 1] == 'V') {
mark[i] = 0;
} else if (s[i - 1] == 'K') {
mark[i] = 1;
} else {
mark[i] = 2;
}
check[i] = (++cnt[mark[i]]);
}
for (int i = 0; i <= n; i++) {
for (int v = 0; v <= cnt[0]; v++) {
for (int k = 0; k <= cnt[1]; k++) {
long long x = i - v - k, c;
if (x < 0 || x > cnt[2]) continue;
if (x != 0) {
c = 0;
for (int w = 0; w <= n; w++) {
if (mark[w] == 2 && check[w] == x) break;
c += (mark[w] == 0 && check[w] > v) ||
(mark[w] == 1 && check[w] > k);
}
dp[i][v][k][2] = min(dp[i - 1][v][k][0],
min(dp[i - 1][v][k][1], dp[i - 1][v][k][2])) +
c;
}
if (k != 0) {
c = 0;
for (int w = 0; w <= n; w++) {
if (mark[w] == 1 && check[w] == k) break;
c += (mark[w] == 0 && check[w] > v) ||
(mark[w] == 2 && check[w] > x);
}
dp[i][v][k][1] =
min(dp[i - 1][v][k - 1][1], dp[i - 1][v][k - 1][2]) + c;
}
if (v != 0) {
c = 0;
for (int w = 0; w <= n; w++) {
if (mark[w] == 0 && check[w] == v) break;
c += (mark[w] == 1 && check[w] > k) ||
(mark[w] == 2 && check[w] > x);
}
dp[i][v][k][0] =
min(dp[i - 1][v - 1][k][0],
min(dp[i - 1][v - 1][k][1], dp[i - 1][v - 1][k][2])) +
c;
}
}
}
}
long long ans = min(dp[n][cnt[0]][cnt[1]][0],
min(dp[n][cnt[0]][cnt[1]][1], dp[n][cnt[0]][cnt[1]][2]));
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[75 + 5];
vector<int> v[3];
int f[75 + 5][75 + 5][75 + 5][2];
int main() {
int n, i, j, k, l, cnt;
scanf("%d%s", &n, s);
for (i = 0; i < n; ++i)
if (s[i] == 'V')
v[0].push_back(i);
else if (s[i] == 'K')
v[1].push_back(i);
else
v[2].push_back(i);
for (i = 0; i <= v[0].size(); ++i)
for (j = 0; j <= v[1].size(); ++j)
for (k = 0; k <= v[2].size(); ++k)
if (i || j || k) {
f[i][j][k][0] = f[i][j][k][1] = 0x3FFFFFFF;
if (i) {
f[i][j][k][1] = min(f[i - 1][j][k][0], f[i - 1][j][k][1]);
for (l = 0; l < j; ++l)
if (v[1][l] > v[0][i - 1]) ++f[i][j][k][1];
for (l = 0; l < k; ++l)
if (v[2][l] > v[0][i - 1]) ++f[i][j][k][1];
}
if (j) {
cnt = f[i][j - 1][k][0];
for (l = 0; l < i; ++l)
if (v[0][l] > v[1][j - 1]) ++cnt;
for (l = 0; l < k; ++l)
if (v[2][l] > v[1][j - 1]) ++cnt;
f[i][j][k][0] = min(f[i][j][k][0], cnt);
}
if (k) {
cnt = min(f[i][j][k - 1][0], f[i][j][k - 1][1]);
for (l = 0; l < i; ++l)
if (v[0][l] > v[2][k - 1]) ++cnt;
for (l = 0; l < j; ++l)
if (v[1][l] > v[2][k - 1]) ++cnt;
f[i][j][k][0] = min(f[i][j][k][0], cnt);
}
}
printf("%d", min(f[i - 1][j - 1][k - 1][0], f[i - 1][j - 1][k - 1][1]));
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
const ll inf = 2e9 + 3;
const ll MAXINT = 1e9 + 7;
const double PI = 3.14159265358979323846;
const double pi = acos(-1);
const int N = 300005, M = 2 * N;
map<pair<int, int>, pair<int, bool>> ei;
queue<int> q;
vi adj[300005];
int cntRes = 0, n, k, d, visited[300005], vid;
void solve() {
while (!q.empty()) {
int u = q.front();
q.pop();
visited[u] = vid;
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (visited[v] != vid) {
q.push(v);
visited[v] = vid;
ei[{u, v}].second = true;
ei[{v, u}].second = true;
cntRes--;
}
}
}
}
int main() {
cin >> n >> k >> d;
vid++;
for (int i = 0; i < k; ++i) {
int x;
cin >> x;
--x;
q.push(x);
visited[x] = vid;
}
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
ei[{u, v}] = {i, false};
ei[{v, u}] = {i, false};
}
cntRes = n - 1;
solve();
cout << cntRes << endl;
for (auto it = ei.begin(); it != ei.end(); it++) {
int u = it->first.first, v = it->first.second;
if (!it->second.second) {
cout << it->second.first << " ";
ei[{v, u}].second = true;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void input() {}
void solve() {
long long int n, k, d;
cin >> n >> k >> d;
vector<pair<long long int, long long int>> adj[n + 1];
queue<pair<long long int, long long int>> q;
bool path[n], vis[n + 1];
memset(path, false, sizeof(path));
memset(vis, false, sizeof(vis));
for (long long int i = 0; i < k; i++) {
long long int x;
cin >> x;
q.push(make_pair(x, 0));
vis[x] = true;
}
for (long long int i = 0; i < n - 1; i++) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(make_pair(y, i + 1));
adj[y].push_back(make_pair(x, i + 1));
}
while (!q.empty()) {
long long int pos = q.front().first, num = q.front().second;
q.pop();
for (auto x : adj[pos]) {
if (!vis[x.first]) {
path[x.second] = true;
vis[x.first] = true;
q.push(make_pair(x.first, x.second));
}
}
}
long long int cnt = 0;
for (long long int i = 1; i < n; i++) {
if (!path[i]) {
cnt++;
}
}
cout << cnt << "\n";
for (long long int i = 1; i < n; i++) {
if (!path[i]) {
cout << i << " ";
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
input();
int t = 1, i = 1;
while (t--) {
solve();
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > g;
int n, k, d;
vector<int> disc, dist;
set<int> st, cities;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int x, y, ans;
queue<pair<int, int> > q;
while (cin >> n >> k >> d) {
while (!q.empty()) q.pop();
cities.clear();
for (int i = 0; i < k; i++) {
cin >> x;
x--;
cities.insert(x);
}
dist = vector<int>(n, 0);
disc = vector<int>(n, 0);
for (auto it = cities.begin(); it != cities.end(); it++) {
x = (*it);
dist[x] = 0;
disc[x] = 1;
q.push(pair<int, int>(x, -1));
}
g = vector<vector<pair<int, int> > >(n);
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
x--;
y--;
g[x].push_back(pair<int, int>(y, i));
g[y].push_back(pair<int, int>(x, i));
}
st.clear();
while (!q.empty()) {
int v = q.front().first;
int p = q.front().second;
q.pop();
for (int i = 0; i < (int)g[v].size(); i++) {
int u = g[v][i].first;
int id = g[v][i].second;
if (u == p) continue;
if (!disc[u]) {
dist[u] = dist[v] + 1;
disc[u] = 1;
q.push(pair<int, int>(u, v));
} else
st.insert(id);
}
}
cout << (int)st.size() << '\n';
for (auto it = st.begin(); it != st.end(); it++) cout << " " << (*it) + 1;
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3e5 + 11;
queue<int> q;
vector<int> adj[maxN];
int vis[maxN];
int aa[maxN], bb[maxN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
memset(vis, -1, sizeof(vis));
for (int i = 0; i < k; i++) {
int x;
cin >> x;
if (vis[x] == -1) q.push(x), vis[x] = x;
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
aa[i] = a;
bb[i] = b;
adj[a].push_back(b);
adj[b].push_back(a);
}
while (!q.empty()) {
int x = q.front();
q.pop();
for (int y : adj[x]) {
if (vis[y] == -1) {
vis[y] = vis[x];
q.push(y);
}
}
}
vector<int> ans;
for (int i = 0; i < n - 1; i++) {
if (vis[aa[i]] != vis[bb[i]]) ans.push_back(i + 1);
}
cout << ans.size() << "\n";
for (int y : ans) cout << y << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = (int)2e9 + 5;
const int MOD = (int)1e9 + 7;
const long double Pi = 3.141592653589793238;
const int N = (int)1e6 + 5;
vector<pair<long long, int> > adj[N];
int qu[N], dis[N], fnt = 1, bck = 0, n, k, maxd, res = 0;
bool used[N];
int main() {
int node1, node2;
cin >> n >> k >> maxd;
for (int i = (int)(1); i <= (int)(n); i++) dis[i] = OO;
for (int i = (int)(1); i <= (int)(k); i++) {
scanf("%i", &node1);
dis[node1] = 0;
qu[++bck] = node1;
}
for (int i = (int)(1); i <= (int)(n - 1); i++) {
scanf("%i %i", &node1, &node2);
adj[node1].push_back(pair<long long, int>(node2, i));
adj[node2].push_back(pair<long long, int>(node1, i));
}
memset(used, false, sizeof(used));
while (fnt <= bck) {
int cur = qu[fnt++], nx, id;
if (dis[cur] == maxd) continue;
for (int i = (int)(0); i <= (int)((int)(adj[cur].size()) - 1); i++) {
nx = adj[cur][i].first;
id = adj[cur][i].second;
if (dis[nx] == OO) {
used[id] = true;
qu[++bck] = nx;
dis[nx] = dis[cur] + 1;
}
}
}
for (int i = (int)(1); i <= (int)(n - 1); i++)
if (!used[i]) res++;
cout << res << endl;
for (int i = (int)(1); i <= (int)(n - 1); i++)
if (!used[i]) printf("%i ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / gcd(a, b));
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int ddx[] = {0, 0, 1, 1, 1, -1, -1, -1}, ddy[] = {1, -1, 1, 0, -1, 1, 0, -1};
int n, k, d;
bool cc[300001], chk[300001];
vector<int> v[300001];
int col[300001], a[300001], b[300001], dist[300001];
int main() {
fill(dist, dist + 300001, 987654321);
scanf("%d%d%d", &n, &k, &d);
for (int(i) = (1); (i) <= (k); (i) += (1)) {
int x;
scanf("%d", &x);
cc[x] = 1;
}
for (int(i) = (1); (i) <= (n - 1); (i) += (1)) {
scanf("%d%d", a + i, b + i);
v[a[i]].push_back(b[i]);
v[b[i]].push_back(a[i]);
}
queue<int> q;
for (int(i) = (1); (i) <= (n); (i) += (1))
if (cc[i]) col[i] = i, dist[i] = 0, q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int next : v[x]) {
if (dist[x] + 1 < dist[next]) {
dist[next] = dist[x] + 1;
col[next] = col[x];
q.push(next);
}
}
}
vector<int> ans;
for (int(i) = (1); (i) <= (n - 1); (i) += (1))
if (col[a[i]] != col[b[i]]) ans.push_back(i);
printf("%d\n", ans.size());
for (int x : ans) printf("%d ", x);
}
|
#include <bits/stdc++.h>
using namespace std;
std::vector<pair<int, int>> adjlist[300007];
queue<pair<int, int>> Q;
std::vector<int> res;
int x, u, v, n, d, k, s = 0, vis[300007];
int main() {
std::cin >> n >> k >> d;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < k; i++) std::cin >> x, Q.push({x, -1});
for (int i = 0; i < n - 1; i++) {
std::cin >> u >> v;
adjlist[u].push_back({v, i + 1});
adjlist[v].push_back({u, i + 1});
}
while (!Q.empty()) {
int cur = Q.front().first;
int from = Q.front().second;
Q.pop();
if (vis[cur]) continue;
vis[cur] = 1;
for (auto e : adjlist[cur]) {
if (e.first == from) continue;
if (vis[e.first])
res.push_back(e.second);
else
Q.push({e.first, cur});
}
}
std::cout << res.size() << '\n';
for (int e : res) std::cout << e << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
bool mark[300 * 1000 + 5];
queue<int> q;
vector<pair<int, int> > adj[300 * 1000 + 5];
int par[300 * 1000 + 5];
set<int> st;
int main() {
int n, k, d;
cin >> n >> k >> d;
int x, y;
for (int i = 0; i < k; i++) {
cin >> x;
if (!mark[x]) {
mark[x] = true;
par[x] = -1;
q.push(x);
}
}
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
adj[x].push_back({y, i + 1});
adj[y].push_back({x, i + 1});
}
while (!q.empty()) {
x = q.front();
q.pop();
for (auto [y, idx] : adj[x]) {
if (mark[y]) {
if (y != par[x]) st.insert(idx);
} else {
par[y] = x;
mark[y] = true;
q.push(y);
}
}
}
cout << (int)st.size() << '\n';
for (auto idx : st) cout << idx << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e5 + 7;
int n, k, d;
vector<pair<int, int> > adj[MAX];
set<int> ans, v;
bool visited[MAX], used[MAX];
queue<pair<int, int> > q;
void func() {
for (auto j : v) {
q.push(make_pair(j, d));
visited[j] = true;
}
while (!q.empty()) {
pair<int, int> temp = q.front();
q.pop();
if (temp.second <= 0) continue;
for (auto j : adj[temp.first])
if (!visited[j.second]) {
visited[j.second] = true;
ans.erase(j.first);
q.push(make_pair(j.second, temp.second - 1));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> d;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
v.insert(x);
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(make_pair(i, v));
adj[v].push_back(make_pair(i, u));
ans.insert(i);
}
func();
cout << ans.size() << endl;
for (auto j : ans) cout << j << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
queue<pair<int, int> > DFS;
vector<vector<pair<int, int> > > g;
int N, K, D;
cin >> N >> K >> D;
vector<bool> p;
p.assign(N + 1, false);
g.assign(N + 1, vector<pair<int, int> >());
int a, b;
for (int k = 0; k < K; k++) {
scanf("%d", &a);
p[a] = true;
DFS.push(pair<int, int>(0, a));
}
for (int n = 0; n < N - 1; n++) {
scanf("%d %d", &a, &b);
g[a].push_back(pair<int, int>(b, n + 1));
g[b].push_back(pair<int, int>(a, n + 1));
}
vector<bool> v;
v.assign(N + 1, 0);
int res = 0;
vector<int> del;
pair<int, int> tp;
while (!DFS.empty()) {
tp = DFS.front();
DFS.pop();
if (v[tp.second]) {
continue;
}
v[tp.second] = 1;
a = tp.second;
for (int n = 0; n < g[a].size(); n++) {
if (g[a][n].first == tp.first) {
continue;
}
if (v[g[a][n].first]) {
del.push_back(g[a][n].second);
res++;
} else {
DFS.push(pair<int, int>(a, g[a][n].first));
}
}
}
cout << res << endl;
for (int x = 0; x < del.size(); x++) {
if (x != 0) {
cout << " ";
}
cout << del[x];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct rw_t {
int e;
int i;
rw_t() {
this->i = 0;
this->e = 0;
}
rw_t(int i, int e) {
this->i = i;
this->e = e;
}
};
struct nd_t {
bool c;
std::vector<rw_t> nb;
};
int n = 0;
int k = 0;
int d = 0;
const int nums_max(300010);
std::vector<nd_t> grs(nums_max);
std::vector<int> rs(nums_max);
long long res = 0;
void dfs(int index) {}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin >> n >> k >> d;
for (int i = 1; i <= n; ++i) {
grs[i].c = false;
}
std::deque<int> nxt;
int v;
for (int i = 1; i <= k; ++i) {
cin >> v;
nxt.push_back(v);
grs[v].c = true;
}
int r1, r2;
for (int i = 1; i < n; ++i) {
cin >> r1;
cin >> r2;
grs[r1].nb.push_back(rw_t(i, r2));
grs[r2].nb.push_back(rw_t(i, r1));
}
while (!nxt.empty()) {
nd_t& nd = grs[nxt.front()];
nxt.pop_front();
for (int i = 0; i < nd.nb.size(); ++i) {
int ni = nd.nb[i].e;
nd_t& nb = grs[ni];
if (nb.c) continue;
nb.c = true;
rs[nd.nb[i].i]++;
nxt.push_back(ni);
}
}
for (int i = 1; i < n; ++i) {
if (rs[i] == 0) res++;
}
cout << res << "\n";
for (int i = 1; i < n; ++i) {
if (rs[i] == 0) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct G {
int n, m;
int Next[650003];
int head[300003];
int ver[650003];
int tot;
void clear(int x) {
tot = 0;
memset(head, 0, (x + 3) * sizeof(int));
}
void add(int x, int y) { ver[++tot] = y, Next[tot] = head[x], head[x] = tot; }
} g;
int k, d;
int pc[300003];
struct edge {
int x;
int y;
} eg[650003];
int vis[300003];
void bfs() {
queue<pair<int, int>> q;
int in = 1;
set<int> s;
for (int i = (1); i < k + 1; i++) {
if (s.count(pc[i])) continue;
s.insert(pc[i]);
q.push({pc[i], in});
vis[pc[i]] = in++;
}
while (!q.empty()) {
int x = q.front().first;
int c = q.front().second;
q.pop();
for (int i = g.head[x]; i; i = g.Next[i]) {
int y = g.ver[i];
if (vis[y]) continue;
vis[y] = c;
q.push({y, c});
}
}
}
int main() {
scanf("%d%d%d", &g.n, &k, &d);
for (int i = (1); i < k + 1; i++) scanf("%d", &pc[i]);
g.m = g.n - 1;
for (int i = (1); i < g.m + 1; i++) {
scanf("%d%d", &eg[i].x, &eg[i].y);
g.add(eg[i].x, eg[i].y);
g.add(eg[i].y, eg[i].x);
}
bfs();
vector<int> ans;
for (int i = (1); i < g.m + 1; i++) {
if (vis[eg[i].x] != vis[eg[i].y]) ans.push_back(i);
}
printf("%d\n", ans.size());
for (auto p : ans) printf("%d ", p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300010];
int head[300010], suc[300010 * 2], v[300010 * 2], en = 1, ban[300010], cnt;
void addedge(int from, int to) {
en++;
v[en] = to;
suc[en] = head[from];
head[from] = en;
en++;
v[en] = from;
suc[en] = head[to];
head[to] = en;
}
int vis[300010], dis, st[300010], t;
int q[300010], f, r;
void bfs() {
int i, u;
while (f <= r) {
u = q[f++];
for (i = head[u]; i; i = suc[i])
if (!vis[v[i]]) {
vis[v[i]] = vis[u];
q[++r] = v[i];
} else if (vis[v[i]] != vis[u])
ban[i / 2] = 1;
}
}
int main() {
int i, j, k;
int ans, n, m;
scanf("%d%d%d", &n, &m, &dis);
f = 1;
r = 0;
for (i = 1; i <= m; i++) {
scanf("%d", &j);
st[++t] = j;
if (!vis[j]) q[++r] = j;
vis[j] = i;
}
for (i = 1; i < n; i++) {
scanf("%d%d", &j, &k);
addedge(j, k);
}
bfs();
for (i = 1; i < n; i++) cnt += ban[i];
printf("%d\n", cnt);
for (i = 1; i < n; i++)
if (ban[i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool police[300010];
int st[300010], to[300010 * 2], nxt[300010 * 2], id[300010 * 2];
int road[300010];
bool reach[300010];
vector<int> del;
void dp(int fa, int now, int d) {
if (!police[now]) {
road[now] = 0;
reach[now] = false;
int rr = d * 2;
int unreach = 0;
for (int i = st[now]; i != -1; i = nxt[i])
if (to[i] != fa) {
int v = to[i];
dp(now, v, d);
if (reach[v]) {
if (road[v] + 1 <= d) {
rr = min(rr, road[v] + 1);
} else {
del.push_back(id[i]);
}
} else
unreach = max(unreach, road[v] + 1);
}
if (unreach + rr <= d) {
reach[now] = true;
road[now] = rr;
bool ck = false;
for (int i = st[now]; i != -1; i = nxt[i])
if (to[i] != fa) {
int v = to[i];
if (reach[v] && road[v] + 1 <= d) {
if (road[v] + 1 != rr)
del.push_back(id[i]);
else {
if (ck) del.push_back(id[i]);
ck = true;
}
}
}
} else {
road[now] = unreach;
for (int i = st[now]; i != -1; i = nxt[i])
if (to[i] != fa) {
int v = to[i];
if (reach[v] && road[v] + 1 <= d) del.push_back(id[i]);
}
}
} else {
road[now] = 0;
reach[now] = true;
for (int i = st[now]; i != -1; i = nxt[i])
if (to[i] != fa) {
int v = to[i];
dp(now, v, d);
if (reach[v]) del.push_back(id[i]);
}
}
return;
}
int main() {
int n, k, d, a, b;
scanf("%d %d %d", &n, &k, &d);
for (int i = 1; i <= n; i++) {
police[i] = false;
st[i] = -1;
}
for (int i = 0; i < k; i++) {
scanf("%d", &a);
police[a] = true;
}
int p = 0;
for (int i = 1; i < n; i++) {
scanf("%d %d", &a, &b);
id[p] = i;
to[p] = b;
nxt[p] = st[a];
st[a] = p++;
id[p] = i;
to[p] = a;
nxt[p] = st[b];
st[b] = p++;
}
del.clear();
dp(-1, 1, d);
printf("%d\n", del.size());
for (int i = 0; i < del.size(); i++) {
if (i != 0) printf(" ");
printf("%d", del[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
vector<pair<int, int> > g[(300003)];
vector<int> v;
int N, a, b, P[(300003)], V[(300003)], M, D, Q[(300003)], e;
void bfs() {
for (int i(0); i < N; i++)
if (P[i]) V[Q[e++] = i] = i;
for (int i(0); i < e; i++)
for (auto &h : g[Q[i]])
if (V[h.first] == V[Q[i]])
continue;
else if (~V[h.first])
v.push_back(h.second);
else
V[Q[e++] = h.first] = V[Q[i]];
}
int main(void) {
scanf("%d%d%d", &N, &M, &D), (memset(V, -1, sizeof(V)));
for (int i(0); i < M; i++) scanf("%d", &a), ++P[--a];
for (int i(0); i < N - 1; i++)
scanf("%d%d", &a, &b), g[--a].push_back({--b, i}), g[b].push_back({a, i});
bfs(), sort(v.begin(), v.end()),
v.resize(unique(v.begin(), v.end()) - v.begin());
printf("%lu\n", v.size());
for (auto &h : v) printf("%d ", h + 1);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
queue<pair<int, int>> Q;
vector<int> G[N];
bool vis[N];
int c[N], P[N], R[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, d;
cin >> n >> k >> d;
int cnt = 0;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
if (!vis[x]) {
Q.push({x, x});
c[x] = x;
vis[x] = true;
cnt++;
}
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
P[i] = x;
R[i] = y;
}
while (!Q.empty()) {
int u = Q.front().first;
int col = Q.front().second;
Q.pop();
for (int v : G[u])
if (!vis[v]) {
Q.push({v, col});
c[v] = col;
vis[v] = true;
}
}
cout << cnt - 1 << endl;
for (int i = 1; i <= n - 1; i++)
if (c[P[i]] != c[R[i]]) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, d;
set<pair<int, int> > s;
pair<int, int> a[300005];
vector<int> g[300005];
bool used[300005];
void bfs(vector<int> v) {
queue<int> q;
for (int i : v) {
q.push(i);
}
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i : g[cur]) {
if (!used[i]) {
q.push(i);
used[i] = true;
s.insert({min(i, cur), max(i, cur)});
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, x, y;
cin >> n >> m >> d;
vector<int> v;
for (i = 1; i <= m; i++) {
cin >> x;
v.push_back(x);
used[x] = true;
}
for (i = 1; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
a[i] = {min(x, y), max(x, y)};
}
bfs(v);
vector<int> ans;
for (i = 1; i < n; i++) {
if (!s.count(a[i])) {
ans.push_back(i);
}
}
cout << ans.size() << endl;
for (auto i : ans) {
cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void solve() {
int n, k, d;
cin >> n >> k >> d;
vector<int> dist(n, -1);
vector<vector<pair<int, int>>> za(n);
vector<int> keep(n - 1), par(n);
queue<int> q;
for (int i = (0); i < (k); ++i) {
int p;
cin >> p;
--p;
dist[p] = 0;
q.push(p);
par[p] = -1;
}
for (int i = (0); i < (n - 1); ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
za[x].emplace_back(y, i);
za[y].emplace_back(x, i);
}
int res = 0;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (auto edge : za[cur]) {
int u = edge.first;
int edge_no = edge.second;
if (dist[u] == -1) {
++res;
dist[u] = dist[cur] + 1;
keep[edge_no] = 1;
q.push(u);
}
}
}
vector<int> shut;
for (int i = (0); i < (n - 1); ++i) {
if (keep[i] == 0) {
shut.push_back(i + 1);
}
}
cout << ((int)((shut).size())) << endl;
for (auto s : shut) {
cout << s << ' ';
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 3e5 + 50;
bool vis[maxn];
int st[maxn], d[maxn];
int n, k, dis, cnt = 0;
struct node {
int to, w;
node() {}
node(int to, int w) : to(to), w(w) {}
};
vector<node> G[maxn];
queue<int> q;
void bfs() {
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); i++) {
node tmp = G[u][i];
int v = tmp.to, edg = tmp.w;
if (d[v] == -1) {
d[v] = d[u] + 1;
q.push(v);
if (d[v] <= dis) vis[edg] = true;
++cnt;
}
}
}
}
int main() {
memset(d, -1, sizeof(d));
memset(vis, false, sizeof(vis));
scanf("%d%d%d", &n, &k, &dis);
for (int i = 1; i <= k; i++) {
int u;
scanf("%d", &u);
d[u] = 0;
q.push(u);
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(node(v, i));
G[v].push_back(node(u, i));
}
bfs();
printf("%d\n", n - 1 - cnt);
for (int i = 1; i <= n - 1; i++) {
if (!vis[i]) printf("%d\n", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int n, m, d, x, y;
vector<pair<int, int> > v[500005];
bool used[500005];
vector<int> q;
int pred[500005];
bool used2[500005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> d;
for (int i = 1; i <= m; ++i) {
cin >> x;
q.push_back(x);
used2[x] = true;
}
for (int i = 1; i < n; ++i) {
cin >> x >> y;
v[x].push_back(make_pair(y, i));
v[y].push_back(make_pair(x, i));
}
for (int i = 1; i <= q.size(); ++i) {
x = q[i - 1];
if (used[x]) continue;
if (used2[x]) pred[x] = 0;
used[x] = true;
for (int j = 0; j < v[x].size(); ++j) {
int to = v[x][j].first;
if (to != pred[x]) {
if (used[to]) {
s.insert(v[x][j].second);
} else if (pred[to] == 0) {
q.push_back(to);
pred[to] = x;
}
}
}
}
cout << s.size() << '\n';
while (!s.empty()) {
cout << *s.begin() << " ";
s.erase(s.begin());
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int n, k, d, a, b, book[maxn], vis[maxn];
vector<int> edge[maxn];
vector<int> BH[maxn];
queue<int> q;
vector<int> ans;
int main() {
memset(book, 0, sizeof(book));
memset(vis, 0, sizeof(vis));
cin >> n >> k >> d;
for (int i = 1; i <= k; i++) {
cin >> a;
book[a] = 1;
}
for (int i = 1; i < n; i++) {
cin >> a >> b;
edge[a].push_back(b);
edge[b].push_back(a);
BH[a].push_back(i);
BH[b].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (book[i]) {
q.push(i);
}
}
int cnt = 0;
while (!q.empty()) {
int p = q.front();
q.pop();
for (int i = 0; i < edge[p].size(); i++) {
int y = edge[p][i];
int x = BH[p][i];
if (!book[y]) {
book[y] = 1;
vis[x] = 1;
q.push(y);
} else if (!vis[x]) {
ans.push_back(x);
}
}
}
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) {
i == ans.size() - 1 ? cout << ans[i] << "\n" : cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 3e5 + 10;
int p[M], n, k, d, ans, way[M];
bool vis[M], de[M];
struct TnT {
TnT(int v, int id) : v(v), id(id) {}
int v, id;
};
vector<TnT> vc[M];
queue<int> q;
int main() {
scanf("%d%d%d", &n, &k, &d);
memset(vis, false, sizeof(vis));
q.empty();
for (int i = 1; i <= k; i++) {
scanf("%d", &p[i]);
vis[p[i]] = true;
q.push(p[i]);
}
for (int i = 1; i < n; i++) {
way[i] = 0;
int x, y;
scanf("%d%d", &x, &y);
vc[x].push_back(TnT(y, i));
vc[y].push_back(TnT(x, i));
}
ans = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < vc[u].size(); i++) {
if (!vis[vc[u][i].v]) {
way[vc[u][i].id] = 1;
q.push(vc[u][i].v);
vis[vc[u][i].v] = true;
}
}
}
for (int i = 1; i < n; i++) {
if (!way[i]) {
ans++;
}
}
printf("%d\n", ans);
for (int i = 1; i < n; i++) {
if (!way[i]) {
printf("%d ", i);
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:1048576")
using namespace std;
int IT_MAX = 1 << 17;
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 1234567890123456789ll;
const double PI = acos(-1);
const double ERR = 1e-10;
vector<pair<int, int> > Ve;
vector<int> conn[300050];
bool dchk[300050];
int rev[300050];
int main() {
int N, K, D, i;
scanf("%d %d %d", &N, &K, &D);
for (i = 1; i <= K; i++) {
int t;
scanf("%d", &t);
dchk[t] = true;
}
for (i = 1; i < N; i++) {
int t1, t2;
scanf("%d %d", &t1, &t2);
conn[t1].push_back(t2);
conn[t2].push_back(t1);
Ve.emplace_back(t1, t2);
}
vector<int> Vu;
for (i = 1; i <= N; i++) {
if (dchk[i]) {
Vu.push_back(i);
rev[i] = i;
}
}
for (i = 0; i < Vu.size(); i++) {
for (auto it : conn[Vu[i]]) {
if (dchk[it]) continue;
dchk[it] = true;
rev[it] = rev[Vu[i]];
Vu.push_back(it);
}
}
vector<int> Va;
for (i = 0; i < Ve.size(); i++) {
int t1 = Ve[i].first, t2 = Ve[i].second;
if (rev[t1] != rev[t2]) Va.push_back(i + 1);
}
printf("%d\n", (int)Va.size());
for (auto it : Va) printf("%d ", it);
return !printf("\n");
}
|
#include <bits/stdc++.h>
int mod = 1000000007;
using namespace std;
using namespace std;
int n, k, d;
vector<vector<int> > adj(300005);
map<pair<int, int>, int> m;
bool isP[300005];
vector<int> ps;
vector<int> ans;
queue<int> q;
bool visited[300005];
int parent[300005];
bool isTaken[300005];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n >> k >> d;
memset(isP, 0, sizeof(isP));
memset(visited, 0, sizeof(visited));
memset(parent, -1, sizeof(parent));
memset(isTaken, 0, sizeof(isTaken));
for (int i = 0; i < k; i++) {
int x;
cin >> x;
if (isP[x] == false) ps.push_back(x);
isP[x] = true;
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
m[make_pair(x, y)] = i;
m[make_pair(y, x)] = i;
}
for (int i = 0; i < ps.size(); i++) {
q.push(ps[i]);
visited[ps[i]] = true;
}
while (!q.empty()) {
int v = q.front();
q.pop();
vector<int>::iterator it = adj[v].begin();
for (; it != adj[v].end(); it++) {
if (*it == parent[v]) continue;
if (!visited[*it]) {
q.push(*it);
visited[*it] = true;
parent[*it] = v;
continue;
}
if (visited[*it] && !isTaken[m[make_pair(*it, v)]]) {
ans.push_back(m[make_pair(v, *it)]);
isTaken[m[make_pair(v, *it)]] = true;
}
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k, d;
queue<long long> q;
cin >> n >> k >> d;
vector<long long> dis(n + 1, 1e9);
map<pair<long long, long long>, long long> mp;
vector<pair<long long, long long>> edges;
vector<long long> g[n + 1];
for (long long i = 0; i < k; i++) {
long long v;
cin >> v;
dis[v] = 0;
q.push(v);
}
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
edges.push_back({min(u, v), max(u, v)});
}
while (q.size()) {
long long v = q.front();
q.pop();
for (auto x : g[v]) {
if (dis[x] > d) {
dis[x] = dis[v] + 1;
q.push(x);
mp[{min(x, v), max(x, v)}] = 1;
}
}
}
vector<long long> ans;
for (long long i = 0; i < edges.size(); i++) {
if (mp[edges[i]] == 0) {
ans.push_back(i + 1);
}
}
cout << ans.size() << '\n';
for (auto x : ans) cout << x << ' ';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1};
const int dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
const int N = (int)3e5 + 5, INF = 0x3f3f3f3f, ALPHA = 26, mod = (int)1e9 + 7;
int n, k, d;
vector<int> v[N];
set<int> c;
queue<int> q;
int vis[N];
vector<pair<int, int> > ed;
inline void bfs() {
for (auto u : c) {
vis[u] = u;
q.push(u);
}
while (!q.empty()) {
int a = q.front();
q.pop();
for (auto u : v[a]) {
if (vis[u]) continue;
vis[u] = vis[a];
q.push(u);
}
}
}
int main() {
ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
cin >> n >> k >> d;
for (int i = 1; i <= (int)k; ++i) {
int x;
cin >> x;
c.insert(x);
}
for (int i = 1; i <= (int)n - 1; ++i) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
ed.push_back({x, y});
}
bfs();
int cnt = 0;
for (auto u : ed)
if (vis[u.first] != vis[u.second]) cnt++;
cout << cnt << "\n";
for (int i = 0; i <= (int)n - 2; ++i)
if (vis[ed[i].first] != vis[ed[i].second]) cout << i + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct rw_t {
int b;
int e;
int c;
int i;
rw_t() {
this->i = 0;
this->b = 0;
this->e = 0;
this->c = 0;
}
rw_t(int i, int b, int e) {
this->i = i;
this->b = b;
this->e = e;
this->c = 0;
}
};
struct nd_t {
bool c;
bool ps;
int d;
int pr;
int i;
std::vector<rw_t> nb;
};
int n = 0;
int k = 0;
int d = 0;
const int nums_max(500000);
std::vector<nd_t> grs(nums_max);
std::set<int> pps;
std::vector<rw_t> rs(nums_max);
long long res = 0;
void dfs(int index) {}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin >> n >> k >> d;
for (int i = 1; i <= n; ++i) {
grs[i].i = i;
grs[i].pr = 0;
grs[i].c = false;
grs[i].ps = false;
}
int v;
for (int i = 1; i <= k; ++i) {
cin >> v;
pps.insert(v);
grs[v].ps = true;
grs[v].c = true;
grs[v].pr = v;
grs[v].d = 0;
}
int r1, r2;
for (int i = 1; i < n; ++i) {
rw_t& r = rs[i];
r.i = i;
cin >> r.b;
cin >> r.e;
grs[r.b].nb.push_back(rw_t(i, r.b, r.e));
grs[r.e].nb.push_back(rw_t(i, r.e, r.b));
}
std::deque<int> nxt;
for (auto i = pps.begin(), ie = pps.end(); i != ie; ++i) nxt.push_back(*i);
while (!nxt.empty()) {
nd_t& nd = grs[nxt.front()];
nxt.pop_front();
for (int i = 0; i < nd.nb.size(); ++i) {
int ni = nd.nb[i].e;
if (ni == nd.pr) continue;
nd_t& nb = grs[ni];
if (nb.c) continue;
nb.pr = nd.i;
nb.c = true;
nb.d = nd.d + 1;
rs[nd.nb[i].i].c++;
if (nb.d < d) {
nxt.push_back(ni);
}
}
}
for (int i = 1; i < n; ++i) {
rw_t& r = rs[i];
if (r.c == 0) res++;
}
cout << res << "\n";
for (int i = 1; i < n; ++i) {
rw_t& r = rs[i];
if (r.c == 0) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, k, d, x, u, v, tot;
int ans[N];
bool vis[N];
int cnt = 1, head[N];
struct edge {
int next, to, f;
} e[N << 1];
struct node {
int id, d;
};
queue<node> q;
inline void add(int u, int v) {
cnt++;
e[cnt].next = head[u];
e[cnt].to = v;
head[u] = cnt;
}
inline void bfs() {
while (q.size()) {
node now = q.front();
q.pop();
u = now.id;
for (register int i = head[u]; i; i = e[i].next)
if (!e[i].f) {
e[i].f = e[i ^ 1].f = 1;
if (vis[e[i].to])
ans[++tot] = i / 2;
else if (now.d < d) {
vis[e[i].to] = true;
q.push((node){e[i].to, now.d + 1});
}
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
for (register int i = 1; i <= k; ++i) {
scanf("%d", &x);
vis[x] = true;
q.push((node){x, 0});
}
for (register int i = 1; i < n; ++i)
scanf("%d%d", &u, &v), add(u, v), add(v, u);
bfs();
printf("%d\n", tot);
for (register int i = 1; i <= tot; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct road {
int next, num;
} temp;
struct point {
int id, s;
};
vector<road> G[300005];
int vis[300005];
int visroad[300005];
int ans, res[300005];
queue<point> Q;
point hh, t, tt;
int main() {
hh.s = 0;
int m, n, k, cont = 0, c, d;
scanf("%d%d%d", &m, &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &hh.id);
if (!vis[hh.id]) Q.push(hh);
vis[hh.id] = 1;
}
for (int i = 1; i <= m - 1; i++) {
scanf("%d%d", &c, &d);
temp.num = i;
temp.next = d;
G[c].push_back(temp);
temp.next = c;
G[d].push_back(temp);
}
while (!Q.empty()) {
t = Q.front();
Q.pop();
tt.s = t.s + 1;
int len = G[t.id].size();
for (int i = 0; i < len; i++) {
int next = G[t.id][i].next;
if (visroad[G[t.id][i].num]) continue;
if (vis[next]) {
visroad[G[t.id][i].num] = 1;
res[cont++] = G[t.id][i].num;
} else if (t.s < k) {
vis[next] = 1;
tt.id = next;
Q.push(tt);
visroad[G[t.id][i].num] = 1;
}
}
}
printf("%d\n", cont);
for (int i = 0; i < cont; i++) {
printf("%d ", res[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300300;
int dist[maxn], dad[maxn];
int d;
queue<int> visited;
vector<int> g[maxn];
map<pair<int, int>, int> input;
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k >> d;
memset(dist, -1, sizeof dist);
memset(dad, -1, sizeof dad);
while (k--) {
int point;
cin >> point;
point--;
dist[point] = 0;
}
for (int e = 0; e < n - 1; e++) {
int x, y;
cin >> x >> y;
x--;
y--;
if (x > y) swap(x, y);
input[make_pair(x, y)] = e + 1;
g[x].push_back(y);
g[y].push_back(x);
}
for (int e = 0; e < n; e++)
if (dist[e] == 0) visited.push(e);
vector<int> ans;
set<int> haha;
while (!visited.empty()) {
int cur = visited.front();
visited.pop();
for (auto &it : g[cur]) {
if (dist[it] == -1 && dist[cur] != d) {
dist[it] = dist[cur] + 1;
dad[it] = cur;
visited.push(it);
} else {
if (it != dad[cur]) {
int a = it, b = cur;
if (a > b) swap(a, b);
haha.insert(input[make_pair(a, b)]);
}
}
}
}
for (auto it : haha) ans.push_back(it);
cout << ans.size() << endl;
for (int e = 0; e < ans.size(); e++) cout << ans[e] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int A[maxn], dis[maxn];
bool vis[maxn];
vector<int> lad[maxn];
int main() {
int k, u, v, n, t;
memset(dis, -1, sizeof(dis));
memset(vis, 0, sizeof(vis));
cin >> n >> k >> t;
for (int i = 0; i < k; ++i) cin >> A[i];
sort(A, A + k);
k = unique(A, A + k) - A;
map<pair<int, int>, int> mp;
vector<int> ans;
for (int i = 0; i < n - 1; ++i) {
cin >> u >> v;
--u, --v;
lad[u].push_back(v);
lad[v].push_back(u);
mp[{u, v}] = i + 1;
mp[{v, u}] = i + 1;
}
queue<int> Q;
for (int i = 0; i < k; ++i) {
A[i]--;
Q.push(A[i]);
dis[A[i]] = 0;
}
while (not Q.empty()) {
int x = Q.front();
Q.pop();
vis[x] = 1;
for (int y : lad[x]) {
if (vis[y]) continue;
if (dis[y] == -1) {
dis[y] = dis[x] + 1;
Q.push(y);
} else if (mp.count({x, y}))
ans.push_back(mp[{x, y}]);
}
}
cout << ans.size() << endl;
for (int id : ans) cout << id << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3 * 100 * 1000 + 5;
vector<int> g[mxN];
int vis[mxN];
void solve() {
int n, k, d;
cin >> n >> k >> d;
queue<pair<int, int>> q;
for (int i = 0; i < k; i++) {
int p;
cin >> p;
p--;
if (!vis[p]) {
vis[p] = 1;
q.push({p, d});
}
}
map<pair<int, int>, int> mp;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
mp[{min(u, v), max(u, v)}] = i;
g[u].push_back(v);
g[v].push_back(u);
}
set<int> ans;
vector<int> par(n);
while ((int)q.size()) {
int sz = q.size();
while (sz--) {
int cur, depth;
tie(cur, depth) = q.front();
q.pop();
depth--;
for (auto to : g[cur]) {
if (vis[to]) {
if (to != par[cur]) ans.insert(mp[{min(cur, to), max(cur, to)}]);
} else {
par[to] = cur;
vis[to] = 1;
q.push({to, depth});
}
}
}
}
cout << (int)ans.size() << endl;
for (auto edge : ans) {
cout << edge << " ";
}
cout << endl;
}
int query = 0;
int main() {
int q = 1;
if (query) cin >> q;
while (q--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 300003;
int n, k, d, x, y;
queue<int> q;
vector<int> ans;
vector<pair<int, int> > G[NMax];
int viz[NMax], tata[NMax], V[NMax], v1[NMax], mu[NMax];
bool cmp(int x, int y) { return (mu[x] < mu[y]); }
int main() {
cin >> n >> k >> d;
for (int i = 1; i <= k; ++i) {
cin >> x;
q.push(x);
viz[x] = x;
tata[x] = x;
}
for (int i = 1; i < n; ++i) {
cin >> x >> y;
G[x].push_back(make_pair(y, i));
G[y].push_back(make_pair(x, i));
}
queue<int> Q;
Q.push(1);
v1[1] = 1;
while (!Q.empty()) {
int nod = Q.front();
Q.pop();
for (int i = 0; i < G[nod].size(); ++i) {
if (!v1[G[nod][i].first]) {
mu[G[nod][i].first] = G[nod][i].second;
v1[G[nod][i].first] = 1;
Q.push(G[nod][i].first);
}
}
}
while (!q.empty()) {
int nod = q.front();
q.pop();
for (int i = 0; i < G[nod].size(); ++i) {
if (!viz[G[nod][i].first]) {
tata[G[nod][i].first] = nod;
viz[G[nod][i].first] = viz[nod];
q.push(G[nod][i].first);
}
}
}
q.push(1);
V[1] = 1;
while (!q.empty()) {
int nod = q.front();
q.pop();
for (int i = 0; i < G[nod].size(); ++i) {
if (!V[G[nod][i].first]) {
if (viz[G[nod][i].first] != viz[nod]) ans.push_back(G[nod][i].first);
q.push(G[nod][i].first);
V[G[nod][i].first] = 1;
}
}
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end(), cmp);
for (int i = 0; i < ans.size(); ++i) {
cout << mu[ans[i]] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
vector<int> g[N];
int n, k, d;
int cmp[N];
int u[N], v[N];
int main() {
queue<int> q;
cin >> n >> k >> d;
for (int i = 0; i < k; i++) {
int p;
cin >> p;
cmp[p] = p;
q.push(p);
}
for (int i = 1; i <= n - 1; i++) {
cin >> u[i] >> v[i];
g[u[i]].push_back(v[i]);
g[v[i]].push_back(u[i]);
}
while (not q.empty()) {
int u = q.front();
q.pop();
for (auto v : g[u]) {
if (cmp[v] == 0) {
cmp[v] = cmp[u];
q.push(v);
}
}
}
vector<int> ans;
for (int i = 1; i <= n - 1; i++) {
if (cmp[u[i]] != cmp[v[i]]) ans.push_back(i);
}
cout << ans.size() << '\n';
for (auto x : ans) cout << x << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, pred[400000];
vector<pair<int, int> > a[400000];
vector<int> ans;
bool b[400000], rebr[400000];
queue<int> q;
int main() {
ios_base::sync_with_stdio(false);
int i, x, y;
scanf("%d%d%d", &n, &k, &d);
for (i = 1; i <= n; i++) {
b[i] = false;
rebr[i] = false;
}
for (i = 1; i <= k; i++) {
scanf("%d", &x);
if (!b[x]) {
b[x] = true;
q.push(x);
}
}
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
a[x].push_back(make_pair(y, i));
a[y].push_back(make_pair(x, i));
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (i = 0; i < a[v].size(); i++) {
int to = a[v][i].first;
if (b[to]) {
if (to != pred[v] && !rebr[a[v][i].second]) {
ans.push_back(a[v][i].second);
rebr[a[v][i].second] = true;
}
} else {
q.push(to);
pred[to] = v;
b[to] = true;
}
}
}
printf("%d\n", ans.size());
for (i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, u, v, dep[300005];
vector<vector<int>> adj;
vector<int> ans;
queue<int> bf;
map<pair<int, int>, int> gt, vis;
int main() {
memset(dep, 0, sizeof(dep));
scanf("%d%d%d", &n, &k, &d);
adj.resize(n + 1);
for (int i = 0; i < k; i++) {
scanf("%d", &u);
bf.push(u);
dep[u] = 1;
}
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
gt[{u, v}] = i + 1;
gt[{v, u}] = i + 1;
}
while (bf.size()) {
int sz = bf.size();
while (sz--) {
int fr = bf.front();
bf.pop();
for (int i = 0; i < adj[fr].size(); i++) {
if (vis[{adj[fr][i], fr}]) continue;
vis[{adj[fr][i], fr}] = 1;
vis[{fr, adj[fr][i]}] = 1;
if (dep[adj[fr][i]] == 0) {
bf.push(adj[fr][i]);
dep[adj[fr][i]] = 1;
} else {
ans.push_back(gt[{fr, adj[fr][i]}]);
}
}
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, d, i, u, v, curr, count;
cin >> n >> k >> d;
vector<vector<int> > edge(n + 1, vector<int>(0)), path(n + 1, vector<int>(0));
vector<bool> visited(n + 1, false), path_flag(n, false);
deque<int> q;
for (i = 0; i < k; i++) {
cin >> u;
visited[u] = true;
q.push_back(u);
}
for (i = 1; i <= n - 1; i++) {
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
path[u].push_back(i);
path[v].push_back(i);
}
for (i = 1; i <= n; i++) edge[i].push_back(-1);
count = 0;
while (!q.empty()) {
curr = q.front();
for (i = 0; edge[curr][i] != -1; i++) {
if (visited[edge[curr][i]] == false) {
visited[edge[curr][i]] = true;
path_flag[path[curr][i]] = true;
count++;
q.push_back(edge[curr][i]);
}
}
q.pop_front();
}
cout << (n - 1 - count) << '\n';
for (i = 1; i <= n - 1; i++)
if (path_flag[i] == false) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
struct Edge {
int from, to, nex, f;
} edge[N];
int h[N], idx;
int n, k, d;
void add(int u, int v) {
Edge E = {u, v, h[u], 0};
edge[idx] = E;
h[u] = idx++;
}
void init() {
memset(h, -1, sizeof(h));
idx = 0;
}
struct node {
int id, d;
bool operator<(const node &t) const { return d > t.d; }
};
priority_queue<node> q;
int vis[N], flag[N], res[N];
int ans;
void bfs() {
while (!q.empty()) {
auto nw = q.top();
q.pop();
flag[nw.id] = 0;
if (nw.d > d) continue;
for (int i = h[nw.id]; ~i; i = edge[i].nex) {
int v = edge[i].to;
if (edge[i].f) continue;
edge[i].f = edge[i ^ 1].f = 1;
if (vis[v]) res[++ans] = i / 2 + 1;
if (!flag[v]) q.push({v, nw.d + 1}), flag[v] = vis[v] = 1;
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
init();
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
q.push({x, 0});
vis[x] = 1;
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
add(x, y);
add(y, x);
}
bfs();
cout << ans << endl;
for (int i = 1; i <= ans; i++) printf("%d ", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[300005];
map<pair<int, int>, int> f;
int n, k, d, u, v, ans, p[300005], Ans[2 * 300005], q[300005], fa[300005];
bool vis[300005];
int main() {
scanf("%d%d%d", &n, &k, &d);
int s = 1, t = 1;
for (int i = 1; i <= k; i++) {
scanf("%d", &p[i]);
if (!vis[p[i]]) {
vis[p[i]] = 1;
q[t++] = p[i];
}
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
if (u > v) swap(u, v);
f[make_pair(u, v)] = i;
}
while (s != t) {
int u = q[s++];
for (int v : G[u])
if (!vis[v]) {
fa[v] = u;
vis[v] = 1;
q[t++] = v;
} else if (fa[u] != v)
Ans[++ans] = f[make_pair(min(u, v), max(u, v))];
}
sort(Ans + 1, Ans + 1 + ans);
ans = unique(Ans + 1, Ans + 1 + ans) - Ans - 1;
cout << ans << endl;
for (int i = 1; i <= ans; i++) cout << Ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
bool u[300005];
struct Point {
Point(int cx, int cd) {
x = cx;
d = cd;
}
int x, d;
};
vector<Point> v[300005];
int num[300005];
void add(int x, int y, int i) {
Point p(y, i);
v[x].push_back(p);
p.x = x;
v[y].push_back(p);
}
bool vis[300005];
int ans[300005], ao;
queue<Point> q;
void bfs() {
while (q.size()) {
Point a = q.front();
q.pop();
for (int i = 0; i < v[a.x].size(); i++) {
int ad = v[a.x][i].x;
Point b(ad, a.d - 1);
if (b.d > num[b.x]) {
num[b.x] = b.d;
if (b.d > 0) q.push(b);
}
}
}
}
void bfs2(int s, int k) {
Point p(s, k);
q.push(p);
while (q.size()) {
Point a = q.front();
q.pop();
for (int i = 0; i < v[a.x].size(); i++) {
int ad = v[a.x][i].x, bno = v[a.x][i].d;
Point b(ad, a.d - 1);
if (b.d == num[b.x] && u[b.x] == 0) {
u[b.x] = 1;
vis[bno] = 1;
q.push(b);
} else if (vis[bno] == 0) {
vis[bno] = 1;
ans[ao++] = bno;
}
}
}
}
int main() {
int n, m, k, x, y;
while (~scanf("%d%d%d", &n, &m, &k)) {
memset(u, 0, sizeof(u));
memset(num, -1, sizeof(num));
for (int i = 0; i < m; i++) {
scanf("%d", &x);
u[x] = 1;
num[x] = k;
Point tmp(x, k);
q.push(tmp);
}
for (int i = 1; i <= n; i++) v[i].clear();
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y, i);
}
bfs();
memset(vis, 0, sizeof(vis));
ao = 0;
for (int i = 1; i <= n; i++) {
if (u[i] == 1) {
bfs2(i, num[i]);
}
}
printf("%d\n", ao);
for (int i = 0; i < ao; i++) {
printf("%d", ans[i]);
if (i == ao - 1)
printf("\n");
else
printf(" ");
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 300050;
std::queue<int> Q;
int pre[N], nxt[N * 2], to[N * 2], cnt = 0;
inline void addEdge(int u, int v) {
to[cnt] = v;
nxt[cnt] = pre[u];
pre[u] = cnt++;
}
inline int readInt() {
int ans = 0;
char c;
do c = getchar();
while (!isdigit(c));
while (isdigit(c)) {
ans = ans * 10 + c - '0';
c = getchar();
}
return ans;
}
int vis[N];
bool used[N];
int main() {
int n, k, x, y;
memset(pre, -1, sizeof pre);
n = readInt();
k = readInt();
readInt();
while (!Q.empty()) Q.pop();
memset(vis, -1, sizeof vis);
for (int i = 0; i < k; ++i) {
x = readInt();
Q.push(--x);
vis[x] = -2;
}
for (int i = 1; i < n; ++i) {
x = readInt();
y = readInt();
addEdge(--x, --y);
addEdge(y, x);
}
while (!Q.empty()) {
x = Q.front();
Q.pop();
for (int i = pre[x]; ~i; i = nxt[i])
if (to[i] != vis[x] && vis[to[i]] == -1) {
used[i / 2 + 1] = true;
vis[to[i]] = x;
Q.push(to[i]);
}
}
int ansc = 0;
for (int i = 1; i < n; ++i)
if (!used[i]) ++ansc;
printf("%d\n", ansc);
for (int i = 1; i < n; ++i)
if (!used[i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
long long int gcd(long long int a, long long int b) {
return (a ? gcd(b % a, a) : b);
}
long long int modPow(long long int a, long long int b, long long int MOD) {
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % MOD;
}
b /= 2;
y = (y * y) % MOD;
}
return x;
}
long long int modInverse(long long int a, long long int p) {
return modPow(a, p - 2, p);
}
using namespace std;
const int N = 3e5 + 5;
vector<pair<int, int> > adj[N];
int node_visited[N];
int edge_not_in_answer[N];
vector<int> ans;
int ispolice[N];
queue<int> myq;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, d, i, j, p, u, v;
cin >> n >> k >> d;
for (int i = (1); i <= (k); i++) {
cin >> p;
ispolice[p]++;
myq.push(p);
node_visited[p]++;
}
for (int i = (1); i <= (n - 1); i++) {
cin >> u >> v;
adj[u].push_back({v, i});
adj[v].push_back({u, i});
}
while (!myq.empty()) {
v = myq.front();
myq.pop();
for (int i = 0; i < (adj[v].size()); i++) {
if (!node_visited[adj[v][i].first]) {
node_visited[adj[v][i].first] = 1;
edge_not_in_answer[adj[v][i].second] = 1;
myq.push(adj[v][i].first);
}
}
}
for (int i = (1); i <= (n - 1); i++) {
if (!edge_not_in_answer[i]) ans.push_back(i);
}
cout << ans.size() << endl;
for (int i = 0; i < (ans.size()); i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 5e5 + 1;
int n, k, dd, v[N], a[N], b[N], d[N];
map<int, int> mp[N], viss[N];
vector<int> g[N];
vector<int> an;
bool vis[N];
queue<int> q;
void bfs() {
while (!q.empty()) {
int x = q.front();
q.pop();
if (d[x] == dd) continue;
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i];
if (!vis[y]) {
d[y] = d[x] + 1;
vis[y] = 1;
q.push(y);
viss[x][y] = 1;
viss[y][x] = 1;
}
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &dd);
for (int i = 0; i < k; ++i) {
int x;
scanf("%d", &x);
v[--x] = 1;
q.push(x);
d[x] = 0;
vis[x] = 1;
}
for (int i = 0, u, v; i < n - 1; ++i) {
scanf("%d%d", &u, &v);
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
mp[u][v] = i + 1;
mp[v][u] = i + 1;
a[i] = u, b[i] = v;
}
bfs();
for (int i = 0; i < n - 1; ++i) {
if (!viss[a[i]][b[i]]) an.push_back(i + 1);
}
printf("%d\n", an.size());
for (auto i : an) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e5 + 10;
set<int> s;
vector<int> g[MAX];
map<pair<int, int>, int> mp;
int n, k, d, p[MAX];
void bfs() {
queue<int> q;
vector<int> d(MAX, MAX);
for (int i = 0; i < k; i++) {
q.push(p[i]);
d[p[i]] = 0;
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : g[u]) {
if (d[v] > d[u] + 1) {
q.push(v);
d[v] = d[u] + 1;
s.erase(mp[{u, v}]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> d;
for (int i = 0; i < k; i++) {
cin >> p[i];
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
mp[{u, v}] = i, mp[{v, u}] = i;
s.insert(i);
}
bfs();
cout << s.size() << "\n";
for (int x : s) cout << x << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
int dx[] = {-1, 0, 0, 1, -1, -1, 1, 1};
int dy[] = {0, -1, +1, 0, -1, +1, -1, +1};
int n, k, d;
int dist[303030];
int v[303030];
vector<pair<int, int> > g[303030];
int u[303030];
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin.tie(0);
cin >> n >> k >> d;
queue<int> Q;
for (int(i) = 0; (i) < (303030); (i)++) dist[i] = -1;
for (int(i) = 0; (i) < (k); (i)++) {
int x;
cin >> x;
Q.push(x);
dist[x] = d;
}
memset(u, 0, sizeof(u));
;
for (int(i) = 0; (i) < (n - 1); (i)++) {
int x, y;
cin >> x >> y;
g[x].push_back(pair<int, int>(y, i));
g[y].push_back(pair<int, int>(x, i));
}
int ans = n - 1;
while (!Q.empty()) {
int z = Q.front();
Q.pop();
if (dist[z] == 0) continue;
for (__typeof(g[z].begin()) e = g[z].begin(); e != g[z].end(); e++) {
if (dist[e->first] < 0) {
dist[e->first] = dist[z] - 1;
Q.push(e->first);
u[e->second] = 1;
ans--;
}
}
}
cout << ans << '\n';
for (int(i) = 0; (i) < (n - 1); (i)++)
if (u[i] == 0) cout << i + 1 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, d, x;
cin >> n >> k >> d;
set<int> po;
vector<pair<int, int> > adj[n + 5];
int pos[n + 5];
for (int i = 1; i <= n; i++) pos[i] = i;
bool vis[n + 5];
memset(vis, false, sizeof(vis));
for (int i = 0; i < k; i++) {
cin >> x;
po.insert(x);
}
int u, v;
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].push_back({v, i});
adj[v].push_back({u, i});
}
queue<int> q;
for (auto i : po) {
q.push(i);
vis[i] = true;
}
int fr;
set<int> idx;
while (!q.empty()) {
if (idx.size() == po.size() - 1) break;
fr = q.front();
q.pop();
for (auto i : adj[fr]) {
if (!vis[i.first]) {
pos[i.first] = pos[fr];
vis[i.first] = true;
q.push(i.first);
} else {
if (pos[i.first] == pos[fr])
continue;
else {
idx.insert(i.second);
}
}
}
}
cout << idx.size() << "\n";
for (auto i : idx) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, x, y, sm[300005];
bool bo[300005], l[300005];
vector<pair<int, int> > v[300005];
vector<int> p;
queue<int> q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> k >> d;
for (int i = 0; i < k; ++i) {
cin >> x;
bo[x] = 1;
sm[x] = x;
q.push(x);
}
for (int i = 1; i < n; ++i) {
cin >> x >> y;
v[x].push_back({y, i});
v[y].push_back({x, i});
}
while (q.size()) {
int dg = q.front();
q.pop();
for (int i = 0; i < v[dg].size(); ++i) {
if (!bo[v[dg][i].first]) {
bo[v[dg][i].first] = 1;
sm[v[dg][i].first] = sm[dg];
q.push(v[dg][i].first);
} else if (sm[v[dg][i].first] != sm[dg] && !l[v[dg][i].second]) {
l[v[dg][i].second] = 1;
p.push_back(v[dg][i].second);
}
}
}
cout << p.size() << endl;
for (int i = 0; i < p.size(); ++i) {
cout << p[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
deque<int> sp;
int head[300005], cnt, vis[300005];
struct f {
int to, nex, yes;
} edge[600005];
void add(int u, int v) {
edge[cnt].to = v;
edge[cnt].yes = 0;
edge[cnt].nex = head[u];
head[u] = cnt++;
}
int main() {
int n, m, k, i, j, x, y;
scanf("%d%d%d", &n, &m, &k);
memset(vis, 0, sizeof(vis));
for (i = 1; i <= m; i++) {
scanf("%d", &x);
sp.push_back(x);
vis[x] = 1;
}
memset(head, -1, sizeof(head));
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
while (!sp.empty()) {
int f = sp.front();
sp.pop_front();
for (i = head[f]; ~i; i = edge[i].nex) {
int v = edge[i].to;
if (edge[i].yes) continue;
edge[i].yes = edge[i ^ 1].yes = 1;
if (vis[v]) {
ans.push_back(i / 2 + 1);
continue;
}
vis[v] = vis[f] + 1;
sp.push_back(v);
}
}
int d = ans.size();
printf("%d\n", d);
for (i = 0; i < d; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.