text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, nxt, dis;
} e[1000005];
int n, m, num, x = 1, y = 1, tim, h[500005], dep[500005], q[500005];
int dfn[500005], out[500005], ans[500005], dis[500005];
int p[500005], mx[2][2000005], U[500005], V[500005], lazy[2000005];
void cmax(int &a, int b) { a = max(a, b); }
void add(int u, int v, int d) {
e[++num].to = v;
e[num].dis = d;
e[num].nxt = h[u];
h[u] = num;
}
void dfs(int u, int fa) {
int v, i;
dep[u] = dep[fa] + 1;
for (i = h[u]; i; i = e[i].nxt) {
v = e[i].to;
if (v != fa) dfs(v, u);
}
}
void dfs2(int u, int fa) {
int v, i;
dfn[u] = ++tim;
dep[u] = dep[fa] + 1;
for (i = h[u]; i; i = e[i].nxt) {
v = e[i].to;
if (v != fa) {
dis[v] = (dis[u] + e[i].dis) & 1;
dfs2(v, u);
}
}
out[u] = tim;
}
void push_up(int ind) {
mx[0][ind] = max(mx[0][ind << 1], mx[0][ind << 1 | 1]);
mx[1][ind] = max(mx[1][ind << 1], mx[1][ind << 1 | 1]);
}
void push_down(int ind) {
if (lazy[ind]) {
lazy[ind << 1] = !lazy[ind << 1];
lazy[ind << 1 | 1] = !lazy[ind << 1 | 1];
swap(mx[0][ind << 1], mx[1][ind << 1]);
swap(mx[0][ind << 1 | 1], mx[1][ind << 1 | 1]);
lazy[ind] = 0;
}
}
void build(int ind, int L, int R) {
if (L == R) {
mx[dis[p[L]]][ind] = dep[p[L]];
return;
}
int mid = (L + R) >> 1;
build(ind << 1, L, mid);
build(ind << 1 | 1, mid + 1, R);
push_up(ind);
}
void upd(int ind, int L, int R, int l, int r) {
if (l <= L && R <= r) {
lazy[ind] = !lazy[ind];
swap(mx[0][ind], mx[1][ind]);
return;
}
push_down(ind);
int mid = (L + R) >> 1;
if (l <= mid) upd(ind << 1, L, mid, l, r);
if (r > mid) upd(ind << 1 | 1, mid + 1, R, l, r);
push_up(ind);
}
void solve(int r) {
int i, t;
tim = 0;
dis[r] = 0;
memset(mx, 0, sizeof(mx));
memset(lazy, 0, sizeof(lazy));
dfs2(r, 0);
for (i = 1; i <= n; i++) p[dfn[i]] = i;
build(1, 1, n);
for (i = 1; i <= m; i++) {
t = dep[V[q[i]]] > dep[U[q[i]]] ? V[q[i]] : U[q[i]];
upd(1, 1, n, dfn[t], out[t]);
cmax(ans[i], mx[0][1] - 1);
}
}
int main() {
ios::sync_with_stdio(false);
int i, d;
cin >> n;
for (i = 1; i <= n - 1; i++) {
cin >> U[i] >> V[i] >> d;
add(U[i], V[i], d);
add(V[i], U[i], d);
}
dfs(1, 0);
for (i = 1; i <= n; i++)
if (dep[i] > dep[x]) x = i;
dfs(x, 0);
for (i = 1; i <= n; i++)
if (dep[i] > dep[y]) y = i;
cin >> m;
for (i = 1; i <= m; i++) cin >> q[i];
solve(x);
solve(y);
for (i = 1; i <= m; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, ID[500005];
int head[500005], p;
struct edge {
int to, next, w;
int id;
} e[500005 << 1];
void addedge(int u, int v, int w, int id) {
e[++p].to = v;
e[p].w = w;
e[p].id = id;
e[p].next = head[u];
head[u] = p;
e[++p].to = u;
e[p].w = w;
e[p].id = id;
e[p].next = head[v];
head[v] = p;
}
int d[500005], rt;
void dfs(int u, int f) {
d[u] = d[f] + 1;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == f) continue;
dfs(v, u);
}
}
int bel[500005], w[500005];
int lpos[500005], rpos[500005], cnt, tpos[500005];
void dfs2(int u, int f, int id) {
d[u] = d[f] + 1;
lpos[u] = ++cnt;
tpos[cnt] = u;
bel[id] = u;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == f) continue;
if (e[i].w)
w[v] = w[u] + 1;
else
w[v] = w[u];
dfs2(v, u, e[i].id);
}
rpos[u] = cnt;
}
int Ans[500005];
int v0[500005 << 2], v1[500005 << 2], rev[500005 << 2];
void pushup(int rt) {
v0[rt] = max(v0[rt << 1], v0[rt << 1 | 1]);
v1[rt] = max(v1[rt << 1], v1[rt << 1 | 1]);
}
void pushdown(int rt) {
if (rev[rt]) {
swap(v0[rt << 1], v1[rt << 1]);
swap(v0[rt << 1 | 1], v1[rt << 1 | 1]);
rev[rt << 1] ^= 1;
rev[rt << 1 | 1] ^= 1;
rev[rt] = 0;
}
}
void build(int rt, int l, int r) {
rev[rt] = 0;
if (l == r) {
if (w[tpos[l]] & 1)
v1[rt] = d[tpos[l]] - 1, v0[rt] = 0;
else
v0[rt] = d[tpos[l]] - 1, v1[rt] = 0;
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void change(int rt, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
swap(v0[rt], v1[rt]);
rev[rt] ^= 1;
return;
}
pushdown(rt);
int mid = (l + r) >> 1;
if (ql <= mid) change(rt << 1, l, mid, ql, qr);
if (qr > mid) change(rt << 1 | 1, mid + 1, r, ql, qr);
pushup(rt);
}
int query(int rt, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return v0[rt];
int ans = 0, mid = (l + r) >> 1;
pushdown(rt);
if (ql <= mid) ans = max(ans, query(rt << 1, l, mid, ql, qr));
if (qr > mid) ans = max(ans, query(rt << 1 | 1, mid + 1, r, ql, qr));
pushup(rt);
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
addedge(u, v, w, i);
}
dfs(1, 0);
int pos = 0;
for (int i = 1; i <= n; ++i)
if (d[i] > d[pos]) pos = i;
memset(d, 0, sizeof(d));
dfs(pos, 0);
for (int i = 1; i <= n; ++i)
if (d[i] > d[rt]) rt = i;
memset(d, 0, sizeof(d));
dfs2(rt, 0, 0);
build(1, 1, n);
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d", &ID[i]);
change(1, 1, n, lpos[bel[ID[i]]], rpos[bel[ID[i]]]);
Ans[i] = query(1, 1, n, 1, n);
}
for (int i = 1; i <= n; ++i)
if (d[i] > d[rt]) rt = i;
memset(d, 0, sizeof(d));
memset(bel, 0, sizeof(bel));
memset(w, 0, sizeof(w));
memset(lpos, 0, sizeof(lpos));
memset(rpos, 0, sizeof(rpos));
memset(tpos, 0, sizeof(tpos));
cnt = 0;
dfs2(rt, 0, 0);
build(1, 1, n);
for (int i = 1; i <= q; ++i) {
change(1, 1, n, lpos[bel[ID[i]]], rpos[bel[ID[i]]]);
Ans[i] = max(Ans[i], query(1, 1, n, 1, n));
}
for (int i = 1; i <= q; ++i) printf("%d\n", Ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 5e5 + 5;
vector<pair<int, int> > g[mxn];
int n, m, root;
int bg[mxn], ed[mxn], cur;
int dep[mxn];
int pari[mxn];
int ord[mxn];
pair<int, int> edge[mxn];
inline void dfs(int x, int par, int Pa, int deep) {
Pa %= 2;
bg[x] = ++cur;
dep[x] = deep;
pari[x] = Pa;
ord[cur] = x;
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i].first;
if (y != par) dfs(y, x, Pa + g[x][i].second, deep + 1);
}
ed[x] = cur;
}
struct Segt {
int val1[mxn << 3], val2[mxn << 3];
int lazy[mxn << 3];
int le[mxn << 3], ri[mxn << 3];
inline void init() {
memset(val1, -1, sizeof(val1));
memset(val2, -1, sizeof(val2));
memset(lazy, 0, sizeof(lazy));
}
inline void pushdown(int x) {
if (lazy[x]) {
lazy[x] = 0;
swap(val1[x << 1], val2[x << 1]);
swap(val1[x << 1 | 1], val2[x << 1 | 1]);
lazy[x << 1] ^= 1;
lazy[x << 1 | 1] ^= 1;
}
}
inline void pushup(int x) {
val1[x] = -1, val2[x] = -1;
if (val1[x << 1] != -1) val1[x] = max(val1[x], val1[x << 1]);
if (val2[x << 1] != -1) val2[x] = max(val2[x], val2[x << 1]);
if (val1[x << 1 | 1] != -1) val1[x] = max(val1[x], val1[x << 1 | 1]);
if (val2[x << 1 | 1] != -1) val2[x] = max(val2[x], val2[x << 1 | 1]);
}
inline void build(int x, int l, int r) {
le[x] = l, ri[x] = r;
if (l == r) {
if (pari[ord[l]])
val2[x] = dep[ord[l]];
else
val1[x] = dep[ord[l]];
return;
}
int md = l + r >> 1;
build(x << 1, l, md);
build(x << 1 | 1, md + 1, r);
pushup(x);
}
inline void upd(int x, int l, int r, int a, int b) {
if (r < a or b < l) return;
pushdown(x);
if (a <= l and r <= b) {
swap(val1[x], val2[x]);
lazy[x] = 1;
pushdown(x);
return;
}
int md = l + r >> 1;
upd(x << 1, l, md, a, b);
upd(x << 1 | 1, md + 1, r, a, b);
pushup(x);
}
inline int ask() { return val1[1]; }
} seg;
int dist[mxn];
inline void getd(int x, int par = -1, int dis = 0) {
dist[x] = dis;
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i].first;
if (y != par) getd(y, x, dis + 1);
}
}
int root1, root2;
int tans[mxn];
int asks[mxn];
inline void solve() {
scanf("%d", &n);
for (int i = 1, u, v, t; i < n; ++i) {
scanf("%d%d%d", &u, &v, &t);
g[u].push_back(make_pair(v, t));
g[v].push_back(make_pair(u, t));
edge[i] = make_pair(u, v);
}
for (int i = 1; i <= n; ++i) {
if (g[i].size() == 1) {
root = i;
break;
}
}
memset(dist, 0, sizeof(dist));
int mw = root;
getd(root, -1, 0);
for (int i = 1; i <= n; ++i)
if (dist[i] > dist[mw]) mw = i;
root1 = mw;
memset(dist, 0, sizeof(dist));
mw = root1;
getd(root1, -1, 0);
for (int i = 1; i <= n; ++i)
if (dist[i] >= dist[mw]) mw = i;
root2 = mw;
scanf("%d", &m);
dfs(root1, -1, 0, 0);
seg.init();
seg.build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x;
scanf("%d", &x);
asks[i] = x;
int u = edge[x].first, v = edge[x].second;
if (dep[u] > dep[v]) swap(u, v);
seg.upd(1, 1, n, bg[v], ed[v]);
tans[i] = seg.ask();
}
cur = 0;
memset(bg, 0, sizeof(bg));
memset(ed, 0, sizeof(ed));
memset(dep, 0, sizeof(dep));
memset(pari, 0, sizeof(pari));
memset(ord, 0, sizeof(ord));
dfs(root2, -1, 0, 0);
seg.init();
seg.build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x = asks[i];
int u = edge[x].first, v = edge[x].second;
if (dep[u] > dep[v]) swap(u, v);
seg.upd(1, 1, n, bg[v], ed[v]);
printf("%d\n", max(seg.ask(), tans[i]));
}
}
int main() {
ios_base::sync_with_stdio(false);
int T = 1;
for (; T--;) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
const int inf = 1000000001;
vector<pair<int, int> > g[N];
int a[N], b[N], c[N];
int h[N];
void dfs(int v, int pr) {
h[v] = h[pr] + 1;
for (auto cur : g[v]) {
int to = cur.first;
if (to != pr) {
dfs(to, v);
}
}
}
struct Solver {
int type[N];
int h[N];
int root;
int timer = 0;
int tin[N];
int tout[N];
int pos[N];
void dfs1(int v, int pr, int xr) {
tin[v] = ++timer;
type[v] = xr;
h[v] = h[pr] + 1;
pos[tin[v]] = v;
for (auto cur : g[v]) {
int to = cur.first;
if (to != pr) {
dfs1(to, v, xr ^ c[cur.second]);
}
}
tout[v] = timer;
}
int t[N * 4][2];
int w[N * 4];
void build(int v, int l, int r) {
w[v] = 0;
if (l == r) {
t[v][type[pos[l]]] = h[pos[l]];
t[v][type[pos[l]] ^ 1] = -inf;
return;
}
int m = (l + r) / 2;
build(v + v, l, m);
build(v + v + 1, m + 1, r);
t[v][0] = max(t[v + v][0], t[v + v + 1][0]);
t[v][1] = max(t[v + v][1], t[v + v + 1][1]);
}
void push(int v) {
if (w[v]) {
swap(t[v + v][0], t[v + v][1]);
swap(t[v + v + 1][0], t[v + v + 1][1]);
w[v + v] ^= 1;
w[v + v + 1] ^= 1;
w[v] = 0;
}
}
void upd(int v, int l, int r, int L, int R) {
if (l > R || r < L) return;
if (l >= L && r <= R) {
swap(t[v][0], t[v][1]);
w[v] ^= 1;
return;
}
push(v);
int m = (l + r) / 2;
upd(v + v, l, m, L, R);
upd(v + v + 1, m + 1, r, L, R);
t[v][0] = max(t[v + v][0], t[v + v + 1][0]);
t[v][1] = max(t[v + v][1], t[v + v + 1][1]);
}
void Init() {
timer = 0;
h[0] = -1;
dfs1(root, 0, 0);
build(1, 1, timer);
}
void Upd_edge(int ind) {
int v;
if (h[a[ind]] > h[b[ind]])
v = a[ind];
else
v = b[ind];
upd(1, 1, timer, tin[v], tout[v]);
}
int Get_result() { return max(0, t[1][0]); }
};
Solver Sa, Sb;
void solve() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
g[a[i]].push_back({b[i], i});
g[b[i]].push_back({a[i], i});
}
h[0] = -1;
dfs(1, 0);
int a = 1;
for (int i = 2; i <= n; i++) {
if (h[i] > h[a]) a = i;
}
dfs(a, 0);
int b = 1;
for (int i = 2; i <= n; ++i) {
if (h[i] > h[b]) b = i;
}
Sa.root = a;
Sb.root = b;
Sa.Init();
Sb.Init();
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int ind;
cin >> ind;
Sa.Upd_edge(ind);
Sb.Upd_edge(ind);
cout << max(Sa.Get_result(), Sb.Get_result()) << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFL = 1e18;
const long long N = 5e5 + 10;
const long long hMod = 239017;
struct node {
int one, zero;
};
vector<vector<pair<int, int> > > g;
node tree[N * 4], tree2[N * 4];
vector<int> a, name, deep, size_g;
vector<int> a2, name2, deep2, size_g2;
bool met[N * 4];
bool met2[N * 4];
int finish, start, mx = 0, name_kol = 0;
void find_mx(int v, int pr, int k) {
if (k > mx) {
finish = v;
mx = k;
}
for (auto next : g[v])
if (next.first != pr) find_mx(next.first, v, k + 1);
}
void find_diametr() {
find_mx(1, -1, 0);
start = finish;
mx = 0;
find_mx(start, -1, 0);
}
void dfs(int v, int pr, int k, int sum) {
name[v] = ++name_kol;
a[name[v]] = sum % 2;
deep[name[v]] = k;
for (auto next : g[v])
if (next.first != pr) {
dfs(next.first, v, k + 1, sum + next.second);
size_g[name[v]] += size_g[name[next.first]];
}
size_g[name[v]]++;
}
void dfs2(int v, int pr, int k, int sum) {
name2[v] = ++name_kol;
a2[name2[v]] = sum % 2;
deep2[name2[v]] = k;
for (auto next : g[v])
if (next.first != pr) {
dfs2(next.first, v, k + 1, sum + next.second);
size_g2[name2[v]] += size_g2[name2[next.first]];
}
size_g2[name2[v]]++;
}
void build(int v, int tl, int tr) {
if (tl == tr) {
if (a[tl] == 0) {
tree[v].zero = deep[tl];
tree[v].one = -1;
} else {
tree[v].one = deep[tl];
tree[v].zero = -1;
}
} else {
int mid = (tl + tr) / 2;
build(v * 2, tl, mid);
build(v * 2 + 1, mid + 1, tr);
tree[v].one = max(tree[v * 2].one, tree[v * 2 + 1].one);
tree[v].zero = max(tree[v * 2].zero, tree[v * 2 + 1].zero);
}
}
void push(int v, int tl, int tr) {
if (met[v] == 1 && tl != tr) {
swap(tree[v * 2].zero, tree[v * 2].one);
swap(tree[v * 2 + 1].zero, tree[v * 2 + 1].one);
met[v * 2] ^= 1;
met[v * 2 + 1] ^= 1;
}
met[v] = 0;
}
void update(int v, int tl, int tr, int l, int r) {
push(v, tl, tr);
if (tl == l && tr == r) {
met[v] = 1;
swap(tree[v].one, tree[v].zero);
push(v, tl, tr);
return;
}
int mid = (tl + tr) / 2;
if (r <= mid)
update(v * 2, tl, mid, l, r);
else if (l > mid)
update(v * 2 + 1, mid + 1, tr, l, r);
else {
update(v * 2, tl, mid, l, mid);
update(v * 2 + 1, mid + 1, tr, mid + 1, r);
}
tree[v].one = max(tree[v * 2].one, tree[v * 2 + 1].one);
tree[v].zero = max(tree[v * 2].zero, tree[v * 2 + 1].zero);
}
void build2(int v, int tl, int tr) {
if (tl == tr) {
if (a2[tl] == 0) {
tree2[v].zero = deep2[tl];
tree2[v].one = -1;
} else {
tree2[v].one = deep2[tl];
tree2[v].zero = -1;
}
} else {
int mid = (tl + tr) / 2;
build2(v * 2, tl, mid);
build2(v * 2 + 1, mid + 1, tr);
tree2[v].one = max(tree2[v * 2].one, tree2[v * 2 + 1].one);
tree2[v].zero = max(tree2[v * 2].zero, tree2[v * 2 + 1].zero);
}
}
void push2(int v, int tl, int tr) {
if (met2[v] == 1 && tl != tr) {
swap(tree2[v * 2].zero, tree2[v * 2].one);
swap(tree2[v * 2 + 1].zero, tree2[v * 2 + 1].one);
met2[v * 2] ^= 1;
met2[v * 2 + 1] ^= 1;
}
met2[v] = 0;
}
void update2(int v, int tl, int tr, int l, int r) {
push2(v, tl, tr);
if (tl == l && tr == r) {
met2[v] = 1;
swap(tree2[v].one, tree2[v].zero);
push2(v, tl, tr);
return;
}
int mid = (tl + tr) / 2;
if (r <= mid)
update2(v * 2, tl, mid, l, r);
else if (l > mid)
update2(v * 2 + 1, mid + 1, tr, l, r);
else {
update2(v * 2, tl, mid, l, mid);
update2(v * 2 + 1, mid + 1, tr, mid + 1, r);
}
tree2[v].one = max(tree2[v * 2].one, tree2[v * 2 + 1].one);
tree2[v].zero = max(tree2[v * 2].zero, tree2[v * 2 + 1].zero);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
g.resize(n + 1);
vector<pair<int, int> > road, road2;
for (int i = 1; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
g[x].push_back({y, z});
g[y].push_back({x, z});
road.push_back({x, y});
}
find_diametr();
size_g.resize(n + 1);
name.resize(n + 1);
deep.resize(n + 1);
a.resize(n + 1);
size_g2.resize(n + 1);
name2.resize(n + 1);
deep2.resize(n + 1);
a2.resize(n + 1);
dfs(finish, -1, 0, 0);
name_kol = 0;
dfs2(start, -1, 0, 0);
for (int i = 0; i < n - 1; i++) {
road2.push_back({name2[road[i].first], name2[road[i].second]});
}
for (int i = 0; i < n - 1; i++) {
road[i].first = name[road[i].first];
road[i].second = name[road[i].second];
}
build(1, 1, n);
build2(1, 1, n);
int q;
cin >> q;
while (q--) {
int nom;
cin >> nom;
nom--;
int x = road[nom].first;
int y = road[nom].second;
if (deep[x] > deep[y]) swap(x, y);
update(1, 1, n, y, y + size_g[y] - 1);
x = road2[nom].first;
y = road2[nom].second;
if (deep2[x] > deep2[y]) swap(x, y);
update2(1, 1, n, y, y + size_g2[y] - 1);
int ans = max(tree[1].zero, tree2[1].zero);
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5, INF = 1e9;
int n, q, cnt, dex;
vector<pair<int, int>> adj[N];
struct node {
int ans, mx[2], mn[2], x[2], y[2], lazy, d;
node() {
ans = mx[0] = mn[0] = x[0] = y[0] = lazy = d = 0;
mn[1] = INF;
mx[1] = x[1] = y[1] = -INF;
}
void add(int val = 1) {
mx[0] += val;
mn[0] += val;
x[0] -= val;
y[0] -= val;
d += val;
}
void merge(node a, node b) {
ans = max(a.ans, b.ans);
for (int i = 0; i < 2; i++) {
ans = max({ans, b.x[i] + a.mx[i], a.y[i] + b.mx[i]});
mx[i] = max(a.mx[i], b.mx[i]);
mn[i] = min(a.mn[i], b.mn[i]);
x[i] = max({a.x[i], b.x[i], b.mx[i] - 2 * min(a.mn[0], a.mn[1])});
y[i] = max({a.y[i], b.y[i], a.mx[i] - 2 * min(b.mn[0], b.mn[1])});
}
}
void change() {
swap(mx[0], mx[1]);
swap(mn[0], mn[1]);
swap(x[0], x[1]);
swap(y[0], y[1]);
lazy ^= 1;
}
} seg[N << 3];
struct edge {
int l, r, w, u, v;
} e[N];
void shift1(int id) {
seg[id << 1].add(seg[id].d);
seg[id << 1 | 1].add(seg[id].d);
seg[id].d = 0;
}
void build(int l, int r, int st = 0, int en = 2 * n - 1, int id = 1) {
if (l >= en || st >= r) return;
if (l <= st && en <= r) return seg[id].add();
shift1(id);
int mid = st + en >> 1;
build(l, r, st, mid, id << 1);
build(l, r, mid, en, id << 1 | 1);
seg[id].merge(seg[id << 1], seg[id << 1 | 1]);
}
void dfsBuild(int u = 1, int par = -1) {
for (auto [v, id] : adj[u])
if (v ^ par) {
build(e[id].l, e[id].r);
dfsBuild(v, u);
}
}
void dfs(int u = 1, int par = 0) {
for (auto v : adj[u])
if (v.first ^ par) {
e[v.second].l = ++cnt;
dfs(v.first, u);
e[v.second].r = ++cnt;
;
}
}
void shift2(int id) {
if (seg[id].lazy) {
seg[id << 1].change();
seg[id << 1 | 1].change();
seg[id].lazy = 0;
}
}
void update(int l, int r, int st = 0, int en = 2 * n - 1, int id = 1) {
if (l >= en || st >= r) return;
if (l <= st && en <= r) return seg[id].change();
shift2(id);
int mid = st + en >> 1;
update(l, r, st, mid, id << 1);
update(l, r, mid, en, id << 1 | 1);
seg[id].merge(seg[id << 1], seg[id << 1 | 1]);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> e[i].u >> e[i].v >> e[i].w;
adj[e[i].u].push_back({e[i].v, i});
adj[e[i].v].push_back({e[i].u, i});
}
dfs(), dfsBuild();
for (int i = 0; i < n - 1; i++)
if (e[i].w) update(e[i].l, e[i].r);
cin >> q;
while (q--) {
cin >> dex;
dex--;
update(e[dex].l, e[dex].r);
cout << seg[1].ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
double getTime() { return clock() / (double)CLOCKS_PER_SEC; };
const int mod = 1e9 + 7;
const long long INF = 3e18;
const int N = 5e5 + 5;
const int P0 = 437;
const int P1 = 343;
const int d = 400;
const double PI = acos(-1);
vector<pair<int, int> > v[N];
int n, m, L[N], R[N], Q[N], dist[N], was[N], chet[N], Fi[N], La[N], Sz;
vector<int> el;
void dfs1(int pos) {
for (auto x : v[pos]) {
if (!dist[x.first]) {
dist[x.first] = dist[pos] + 1;
dfs1(x.first);
}
}
}
void dfs(int pos, int ch) {
was[pos] = 1;
chet[pos] = ch;
Fi[pos] = ((int)(el).size());
el.emplace_back(pos);
for (auto y : v[pos]) {
int x = y.first, t = y.second;
if (was[x]) continue;
dist[x] = dist[pos] + 1;
dfs(x, ch ^ t);
}
La[pos] = ((int)(el).size());
el.emplace_back(pos);
}
struct Tree {
vector<int> mi, ma, g;
Tree() {
mi.resize(Sz * 4);
ma.resize(Sz * 4);
g.resize(Sz * 4);
}
void Init(int v, int L, int R) {
if (R - L == 1) {
mi[v] = ma[v] = dist[el[L]];
if (chet[el[L]]) mi[v] = ma[v] = -dist[el[L]];
return;
}
int c = (L + R) / 2;
Init(v * 2, L, c);
Init(v * 2 + 1, c, R);
mi[v] = min(mi[v * 2], mi[v * 2 + 1]);
ma[v] = max(ma[v * 2], ma[v * 2 + 1]);
}
void Push(int v) {
if (!g[v]) return;
swap(mi[v * 2], ma[v * 2]);
mi[v * 2] = -mi[v * 2];
ma[v * 2] = -ma[v * 2];
swap(mi[v * 2 + 1], ma[v * 2 + 1]);
mi[v * 2 + 1] = -mi[v * 2 + 1];
ma[v * 2 + 1] = -ma[v * 2 + 1];
g[v * 2] ^= 1;
g[v * 2 + 1] ^= 1;
g[v] = 0;
}
void Upd(int v, int L, int R, int l, int r) {
if (L == l && R == r) {
swap(mi[v], ma[v]);
mi[v] = -mi[v];
ma[v] = -ma[v];
g[v] ^= 1;
return;
}
Push(v);
int c = (L + R) / 2;
if (l < c) Upd(v * 2, L, c, l, min(r, c));
if (c < r) Upd(v * 2 + 1, c, R, max(l, c), r);
mi[v] = min(mi[v * 2], mi[v * 2 + 1]);
ma[v] = max(ma[v * 2], ma[v * 2 + 1]);
}
int GetMa() { return ma[1]; }
};
vector<int> Get(int st) {
for (int i = 0; i < (n); i++) {
dist[i] = 0;
was[i] = 0;
chet[i] = 0;
Fi[i] = 0;
La[i] = 0;
}
el.clear();
dfs(st, 0);
Sz = ((int)(el).size());
Tree T;
T.Init(1, 0, Sz);
vector<int> an(m);
for (int h = 0; h < (m); h++) {
int now = Q[h];
now--;
int from = L[now], to = R[now];
if (dist[from] > dist[to]) swap(from, to);
T.Upd(1, 0, Sz, Fi[to], La[to] + 1);
an[h] = T.GetMa();
}
return an;
}
void solve() {
cin >> n;
for (int i = 0; i < (n - 1); i++) {
int l, r, t;
cin >> l >> r >> t;
l--;
r--;
v[l].emplace_back(r, t);
v[r].emplace_back(l, t);
L[i] = l;
R[i] = r;
}
cin >> m;
for (int i = 0; i < (m); i++) cin >> Q[i];
dist[0] = 1;
dfs1(0);
int first = 0;
for (int i = 0; i < (n); i++)
if (dist[i] > dist[first]) first = i;
for (int i = 0; i < (n); i++) dist[i] = 0;
dist[first] = 1;
dfs1(first);
int second = first;
for (int i = 0; i < (n); i++)
if (dist[i] > dist[second]) second = i;
vector<int> an1 = Get(first), an2 = Get(second);
for (int i = 0; i < (m); i++) cout << max(an1[i], an2[i]) << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int qq = 1;
while (qq--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
struct Node {
Node *l = 0, *r = 0;
int lo, hi;
int mx[2];
bool lz = 0;
Node(int _lo, int _hi) : lo(_lo), hi(_hi) { mx[0] = mx[1] = 0; }
Node(ii v[], int _lo, int _hi) : lo(_lo), hi(_hi) {
mx[0] = mx[1] = 0;
if (lo + 1 < hi) {
int mid = lo + (hi - lo) / 2;
l = new Node(v, lo, mid);
r = new Node(v, mid, hi);
for (int i : {0, 1}) mx[i] = max(l->mx[i], r->mx[i]);
} else {
mx[v[lo].first] = v[lo].second;
}
}
void upd() {
swap(mx[0], mx[1]);
lz ^= 1;
}
void flip(int L, int R) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R) {
upd();
} else {
push(), l->flip(L, R), r->flip(L, R);
for (int i : {0, 1}) mx[i] = max(l->mx[i], r->mx[i]);
}
}
void push() {
if (lo + 1 < hi and lz) {
l->upd(), r->upd();
}
lz = 0;
}
};
const int N = 5e5 + 5;
int n, q;
int l[N], r[N], w[N];
vi g[N];
int d1, d2;
int tym;
ii dis[N];
int IN[N], OUT[N];
int EDGE[N];
ii dis_[N];
void dfs(int u, int daddy, int pe) {
IN[u] = ++tym;
EDGE[pe] = u;
for (int i : g[u]) {
int v = l[i] ^ r[i] ^ u;
if (v != daddy) {
dis[v] = {dis[u].first ^ w[i], dis[u].second + 1};
dfs(v, u, i);
}
}
OUT[u] = tym;
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d %d %d", &l[i], &r[i], &w[i]);
g[l[i]].emplace_back(i);
g[r[i]].emplace_back(i);
}
dis[1] = {0, 0};
dfs(1, 0, 0);
{
int mx = INT_MIN;
for (int i = 1; i <= n; ++i) {
if (dis[i].second > mx) {
d1 = i;
mx = dis[i].second;
}
}
}
42;
vi in[2], out[2], e[2];
Node *t[2];
dis[d1] = {0, 0}, tym = 0;
dfs(d1, 0, 0);
for (int i = 1; i <= n; ++i) {
dis_[IN[i]] = dis[i];
}
42;
t[0] = new Node(dis_, 1, n + 1);
42;
in[0] = vi(IN, IN + 1 + n);
out[0] = vi(OUT, OUT + 1 + n);
e[0] = vi(EDGE, EDGE + 1 + n);
{
int mx = INT_MIN;
for (int i = 1; i <= n; ++i) {
if (dis[i].second > mx) {
d2 = i;
mx = dis[i].second;
}
}
}
dis[d2] = {0, 0}, tym = 0;
dfs(d2, 0, 0);
for (int i = 1; i <= n; ++i) {
dis_[IN[i]] = dis[i];
}
42;
t[1] = new Node(dis_, 1, n + 1);
in[1] = vi(IN, IN + 1 + n);
out[1] = vi(OUT, OUT + 1 + n);
e[1] = vi(EDGE, EDGE + 1 + n);
scanf("%d", &q);
while (q--) {
int id;
scanf("%d", &id);
42;
int ans = 0;
for (int i : {0, 1}) {
42;
t[i]->flip(in[i][e[i][id]], out[i][e[i][id]] + 1);
ans = max(ans, t[i]->mx[0]);
}
42;
42;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int D[500010];
int rt[2];
int node[2][500010];
int dep[2][500010], id[2][500010], dist[2][500010], num[2][500010],
sz[2][500010];
int tot;
vector<pair<int, int> > from[500010];
pair<int, int> dfs(int x, int last, int d = 0) {
pair<int, int> maxj = make_pair(d, x);
for (int i = 0; i < from[x].size(); i++) {
int v = from[x][i].first;
if (v == last) continue;
maxj = max(maxj, dfs(v, x, d + 1));
}
return maxj;
}
void get_node_dep(int x, int last, int *node, int *dep, int *id, int *dist,
int *num, int *sz) {
id[x] = ++tot, num[tot] = x, sz[x] = 1;
for (int i = 0; i < from[x].size(); i++) {
int v = from[x][i].first, d = from[x][i].second;
if (v == last) continue;
node[d] = v, dep[v] = dep[x] + 1, dist[v] = dist[x] ^ D[d];
get_node_dep(v, x, node, dep, id, dist, num, sz);
sz[x] += sz[v];
}
}
struct Segment_tree {
int T1[2000010], T0[2000010], rev[2000010];
void pushup(int now) {
T1[now] = max(T1[now << 1], T1[now << 1 | 1]);
T0[now] = max(T0[now << 1], T0[now << 1 | 1]);
}
void pushdown(int now) {
if (!rev[now]) return;
swap(T0[now << 1], T1[now << 1]), rev[now << 1] ^= 1,
swap(T0[now << 1 | 1], T1[now << 1 | 1]), rev[now << 1 | 1] ^= 1;
rev[now] = 0;
}
void Build(int now, int l, int r, int *num, int *dist, int *dep) {
rev[now] = 0;
if (l == r) {
if (dist[num[l]])
T1[now] = dep[num[l]], T0[now] = -INF;
else
T0[now] = dep[num[l]], T1[now] = -INF;
return;
}
int mid = l + r >> 1;
Build(now << 1, l, mid, num, dist, dep),
Build(now << 1 | 1, mid + 1, r, num, dist, dep);
pushup(now);
}
void Update(int now, int l, int r, int L, int R) {
if (l == L && r == R) {
swap(T0[now], T1[now]), rev[now] ^= 1;
return;
}
pushdown(now);
int mid = l + r >> 1;
if (R <= mid)
Update(now << 1, l, mid, L, R);
else if (L > mid)
Update(now << 1 | 1, mid + 1, r, L, R);
else
Update(now << 1, l, mid, L, mid),
Update(now << 1 | 1, mid + 1, r, mid + 1, R);
pushup(now);
}
int Query() { return T0[1]; }
} seg[2];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, d;
scanf("%d%d%d", &x, &y, &d);
D[i] = d;
from[x].push_back(make_pair(y, i));
from[y].push_back(make_pair(x, i));
}
int q;
scanf("%d", &q);
rt[0] = dfs(1, 1).second, rt[1] = dfs(rt[0], rt[0]).second;
for (int i = 0; i < 2; i++) {
tot = 0,
get_node_dep(rt[i], rt[i], node[i], dep[i], id[i], dist[i], num[i], sz[i]);
seg[i].Build(1, 1, n, num[i], dist[i], dep[i]);
}
while (q--) {
int x;
scanf("%d", &x);
D[x] ^= 1;
for (int i = 0; i < 2; i++) {
int v = node[i][x];
seg[i].Update(1, 1, n, id[i][v], id[i][v] + sz[i][v] - 1);
}
printf("%d\n", max(seg[0].Query(), seg[1].Query()));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int t = 0;
char v = getchar();
while (v < '0') v = getchar();
while (v >= '0') t = (t << 3) + (t << 1) + v - 48, v = getchar();
return t;
}
int n, m, c[500012], h[500012], cnt = 1, de[500012], L[500012], R[500012],
dfst = 0, rev[500012], le[500012], dft = 0,
g[1000012][20], Log[1000012];
struct Edge {
int to, next, s;
} e[500012 << 1];
inline void AddEdge(int x, int y, int v) {
e[++cnt] = (Edge){y, h[x], v};
h[x] = cnt;
}
void dfs(int x, int prt) {
de[x] = de[prt] + 1;
rev[L[x] = ++dfst] = x;
g[le[x] = ++dft][0] = de[x];
int i, y;
for (i = h[x]; i; i = e[i].next)
if ((y = e[i].to) != prt)
c[y] = c[x] ^ e[i].s, dfs(y, x), g[++dft][0] = de[x];
R[x] = dfst;
}
inline int dlc(int x, int y) {
x = le[x];
y = le[y];
(x > y) ? (x ^= y ^= x ^= y) : 0;
int p = Log[y - x + 1];
return min(g[x][p], g[y - (1 << p) + 1][p]);
}
inline int di(int x, int y) { return de[x] + de[y] - (dlc(x, y) << 1); }
struct Dia {
int x, y, v;
inline Dia(int xx = 0, int yy = 0, int vv = 0) {
x = xx;
y = yy;
v = vv;
}
inline Dia operator+(const Dia &b) const {
if (!x) return b;
if (!b.x) return *this;
int ox = x, oy = y, ov = v, v1;
if (b.v > ov) ox = b.x, oy = b.y, ov = b.v;
if ((v1 = di(x, b.x)) > ov) ov = v1, ox = x, oy = b.x;
if ((v1 = di(x, b.y)) > ov) ov = v1, ox = x, oy = b.y;
if ((v1 = di(y, b.x)) > ov) ov = v1, ox = y, oy = b.x;
if ((v1 = di(y, b.y)) > ov) ov = v1, ox = y, oy = b.y;
return Dia(ox, oy, ov);
}
} s[500012 << 2][2];
bool re[500012 << 2];
inline void pus(int x) {
s[x][0] = s[x << 1][0] + s[x << 1 | 1][0];
s[x][1] = s[x << 1][1] + s[x << 1 | 1][1];
}
inline void Add(int x) {
re[x] ^= 1;
swap(s[x][0], s[x][1]);
}
inline void pd(int x) {
if (re[x]) Add(x << 1), Add(x << 1 | 1), re[x] = 0;
}
void build(int p, int l, int r) {
if (l == r) {
int v = c[rev[l]];
s[p][v] = Dia(rev[l], rev[l], 0);
s[p][v ^ 1] = Dia(0, 0, 0);
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
pus(p);
}
void change(int p, int l, int r, int L, int R) {
if ((R < l) || (r < L)) return;
if ((L <= l) && (r <= R)) {
Add(p);
return;
}
pd(p);
int mid = (l + r) >> 1;
change(p << 1, l, mid, L, R);
change(p << 1 | 1, mid + 1, r, L, R);
pus(p);
}
int main() {
Log[0] = -1;
for (int i = 1; i < 1000012; i++) Log[i] = Log[i >> 1] + 1;
n = read();
int i, j, x, y, v;
for (i = 1; i < n; i++) {
x = read(), y = read(), v = read();
AddEdge(x, y, v);
AddEdge(y, x, v);
}
dfs(1, 0);
for (j = 1; j <= Log[dft]; j++)
for (i = 1; i + (1 << j) - 1 <= dft; i++)
g[i][j] = min(g[i][j - 1], g[i + (1 << (j - 1))][j - 1]);
build(1, 1, dfst);
m = read();
while (m--) {
v = read();
v <<= 1;
x = (de[e[v].to] < de[e[v ^ 1].to]) ? (e[v ^ 1].to) : (e[v].to);
change(1, 1, dfst, L[x], R[x]);
printf("%d\n", max(s[1][0].v, s[1][1].v));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 60;
const int mods = 1e9 + 7;
const int inv2 = (mods + 1) >> 1;
const int MAXN = 500005;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
*oT = obuf + SIZE - 1, c;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
inline void getc(char &c) {
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
!isalpha(c) && c != EOF;
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
;
}
inline void reads(char *st) {
char c;
int n = 0;
getc(st[++n]);
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
isalpha(c);
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
st[++n] = c;
st[n + 1] = '\0';
}
template <class I>
inline void read(I &x) {
for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 3) + (x << 1) + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (x < 0) putc('-'), x = -x;
if (!x) putc('0');
while (x) que[++num] = x % 10 + 48, x /= 10;
while (num) putc(que[num--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_Flusher_;
} // namespace FastIO
using FastIO ::print;
using FastIO ::putc;
using FastIO ::read;
using FastIO ::reads;
pair<int, int> E[MAXN];
vector<pair<int, int> > e[MAXN];
int id[MAXN], dfnA[MAXN], dfnB[MAXN], dep[MAXN], depA[MAXN], depB[MAXN],
fnsA[MAXN], fnsB[MAXN], col[MAXN], MX, ID, DFN = 0, A, B;
void dfsA(int x, int father) {
id[dfnA[x] = ++DFN] = x;
if (dep[x] > MX) MX = dep[x], ID = x;
for (auto v : e[x]) {
if (v.first == father) continue;
col[v.first] = col[x] ^ v.second, dep[v.first] = dep[x] + 1,
dfsA(v.first, x);
}
fnsA[x] = DFN;
}
void dfsB(int x, int father) {
id[dfnB[x] = ++DFN] = x;
if (dep[x] > MX) MX = dep[x], ID = x;
for (auto v : e[x]) {
if (v.first == father) continue;
col[v.first] = col[x] ^ v.second, dep[v.first] = dep[x] + 1,
dfsB(v.first, x);
}
fnsB[x] = DFN;
}
struct Segment_Tree {
int tag[MAXN << 2], s[MAXN << 2][2];
void down(int x) {
if (tag[x]) {
tag[x << 1] ^= 1, swap(s[x << 1][0], s[x << 1][1]);
tag[x << 1 | 1] ^= 1, swap(s[x << 1 | 1][0], s[x << 1 | 1][1]);
tag[x] = 0;
}
}
void up(int x) {
s[x][0] = max(s[x << 1][0], s[x << 1 | 1][0]);
s[x][1] = max(s[x << 1][1], s[x << 1 | 1][1]);
}
void build(int x, int l, int r) {
if (l == r) {
s[x][col[id[l]]] = dep[id[l]];
s[x][col[id[l]] ^ 1] = -INF;
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
up(x);
}
void update(int x, int l, int r, int L, int R) {
if (l >= L && r <= R) {
tag[x] ^= 1;
swap(s[x][0], s[x][1]);
return;
}
down(x);
int mid = (l + r) >> 1;
if (R <= mid)
update(x << 1, l, mid, L, R);
else if (L > mid)
update(x << 1 | 1, mid + 1, r, L, R);
else
update(x << 1, l, mid, L, mid),
update(x << 1 | 1, mid + 1, r, mid + 1, R);
up(x);
}
void print(int x, int l, int r) {
if (l == r) {
cout << id[l] << ":" << s[x][0] << endl;
return;
}
int mid = (l + r) >> 1;
down(x);
print(x << 1, l, mid);
print(x << 1 | 1, mid + 1, r);
}
} TA, TB;
signed main() {
int n;
read(n);
for (int i = 1, u, v, c; i < n; ++i) {
read(u), read(v), read(c);
e[u].push_back(make_pair(v, c));
e[v].push_back(make_pair(u, c));
E[i] = make_pair(u, v);
}
DFN = MX = ID = col[1] = dep[1] = 0, dfsA(1, 0), A = ID;
DFN = MX = ID = col[A] = dep[A] = 0, dfsA(A, 0), B = ID;
TA.build(1, 1, n);
for (int i = 1; i <= n; ++i) depA[i] = dep[i];
DFN = MX = ID = col[B] = dep[B] = 0, dfsB(B, 0);
TB.build(1, 1, n);
for (int i = 1; i <= n; ++i) depB[i] = dep[i];
int Case;
read(Case);
while (Case--) {
int x;
read(x);
int u = E[x].first, v = E[x].second;
if (depA[u] < depA[v]) swap(u, v);
TA.update(1, 1, n, dfnA[u], fnsA[u]);
if (depB[u] < depB[v]) swap(u, v);
TB.update(1, 1, n, dfnB[u], fnsB[u]);
print(max(TA.s[1][0], TB.s[1][0])), putc('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = (x << 1) + (x << 3) + c - '0', c = getchar();
return x * f;
}
vector<pair<int, int> > g[N];
namespace TreeDiameter {
int d[N];
void dfs1(int x, int fa) {
d[x] = d[fa] + 1;
for (pair<int, int> now : g[x]) {
int to = now.first;
if (to == fa) continue;
dfs1(to, x);
}
}
pair<int, int> Diameter(int n) {
dfs1(1, 0);
int mx = 0, u, v;
for (int i = 1; i <= n; i++) {
if (d[i] > mx) {
u = i;
mx = d[i];
}
}
dfs1(u, 0);
mx = 0;
for (int i = 1; i <= n; i++) {
if (d[i] > mx) {
v = i;
mx = d[i];
}
}
return {u, v};
}
} // namespace TreeDiameter
struct node {
pair<int, int> dep[N];
int inv_dfn[N];
struct Segment {
int mx[N << 2][2], tag[N << 2];
void pushup(int pos) {
for (int i = 0; i < 2; i++)
mx[pos][i] = max(mx[pos << 1][i], mx[pos << 1 | 1][i]);
}
void pushdown(int pos) {
if (tag[pos]) {
addtag(pos << 1);
addtag(pos << 1 | 1);
tag[pos] = 0;
}
}
void addtag(int pos) {
swap(mx[pos][1], mx[pos][0]);
tag[pos] ^= 1;
}
void update(int ql, int qr, int pos, int l, int r) {
if (ql <= l && r <= qr) {
addtag(pos);
return;
}
pushdown(pos);
int mid = (l + r) >> 1;
if (ql <= mid) update(ql, qr, pos << 1, l, mid);
if (qr > mid) update(ql, qr, pos << 1 | 1, mid + 1, r);
pushup(pos);
}
void build(int pos, int l, int r, pair<int, int> *dep, int *inv_dfn) {
if (l == r) {
int id = inv_dfn[l];
mx[pos][dep[id].first] = dep[id].second;
return;
}
int mid = (l + r) >> 1;
build(pos << 1, l, mid, dep, inv_dfn);
build(pos << 1 | 1, mid + 1, r, dep, inv_dfn);
pushup(pos);
}
} t;
int dfn[N], ed[N], tot;
void dfs(int x, int fa, int z, int d) {
dfn[x] = ++tot;
inv_dfn[tot] = x;
dep[x] = {z, d};
for (pair<int, int> now : g[x]) {
int to = now.first;
int w = now.second;
if (to == fa) continue;
dfs(to, x, (z + w) % 2, d + 1);
}
ed[x] = tot;
}
void init(int x) {
dfs(x, 0, 0, 0);
t.build(1, 1, tot, dep, inv_dfn);
}
int update(int u, int v) {
if (dfn[u] < dfn[v]) swap(u, v);
t.update(dfn[u], ed[u], 1, 1, tot);
return t.mx[1][0];
}
} z1, z2;
int main() {
int n = read();
vector<pair<int, int> > e(n);
for (int i = 1; i < n; i++) {
int u = read(), v = read(), w = read();
e[i] = {u, v};
g[u].push_back({v, w});
g[v].push_back({u, w});
}
pair<int, int> o = TreeDiameter::Diameter(n);
z1.init(o.first), z2.init(o.second);
int Q = read();
while (Q--) {
int id = read();
int ans = max(z1.update(e[id].first, e[id].second),
z2.update(e[id].first, e[id].second));
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, head[500100], cnt;
struct node {
int to, next;
bool tp;
} edge[1001000];
struct SegTree {
int dfn[500100], sz[500100], rev[500100], dep[500100], tot;
bool ini[500100];
int mx[2000100][2];
bool tag[2001000];
void pushdown(int x) {
if (tag[x])
tag[x << 1] ^= 1, swap(mx[x << 1][0], mx[x << 1][1]),
tag[x << 1 | 1] ^= 1, swap(mx[x << 1 | 1][0], mx[x << 1 | 1][1]),
tag[x] = false;
}
void pushup(int x) {
mx[x][0] = max(mx[x << 1][0], mx[x << 1 | 1][0]),
mx[x][1] = max(mx[x << 1][1], mx[x << 1 | 1][1]);
}
void dfs(int x, int fa) {
dfn[x] = ++tot, sz[x] = 1, rev[tot] = x;
for (int i = head[x]; i != -1; i = edge[i].next)
if (edge[i].to != fa)
dep[edge[i].to] = dep[x] + 1, ini[edge[i].to] = ini[x] ^ edge[i].tp,
dfs(edge[i].to, x), sz[x] += sz[edge[i].to];
}
void build(int x, int l, int r) {
if (l == r) {
mx[x][ini[rev[l]]] = dep[rev[l]];
return;
}
build(x << 1, l, ((l + r) >> 1)), build(x << 1 | 1, ((l + r) >> 1) + 1, r),
pushup(x);
}
void modify(int x, int l, int r, int L, int R) {
if (l > R || r < L) return;
if (L <= l && r <= R) {
tag[x] ^= 1, swap(mx[x][0], mx[x][1]);
return;
}
pushdown(x), modify(x << 1, l, ((l + r) >> 1), L, R),
modify(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R), pushup(x);
}
} seg[2];
void ae(int u, int v, bool w) {
edge[cnt].next = head[u], edge[cnt].to = v, edge[cnt].tp = w, head[u] = cnt++;
edge[cnt].next = head[v], edge[cnt].to = u, edge[cnt].tp = w, head[v] = cnt++;
}
pair<int, int> dfs(int x, int fa) {
pair<int, int> ret = make_pair(-1, x);
for (int i = head[x]; i != -1; i = edge[i].next)
if (edge[i].to != fa) ret = max(ret, dfs(edge[i].to, x));
ret.first++;
return ret;
}
int main() {
scanf("%d", &n), memset(head, -1, sizeof(head));
for (int i = 1, x, y, z; i < n; i++) scanf("%d%d%d", &x, &y, &z), ae(x, y, z);
int S = dfs(1, 0).second, T = dfs(S, 0).second;
seg[0].dfs(S, 0), seg[1].dfs(T, 0);
seg[0].build(1, 1, n), seg[1].build(1, 1, n);
scanf("%d", &m);
for (int i = 1, x; i <= m; i++) {
scanf("%d", &x), x--;
int u = edge[x << 1].to, v = edge[x << 1 | 1].to;
if (seg[0].dep[u] < seg[0].dep[v]) swap(u, v);
seg[0].modify(1, 1, n, seg[0].dfn[u], seg[0].dfn[u] + seg[0].sz[u] - 1);
if (seg[1].dep[u] < seg[1].dep[v]) swap(u, v);
seg[1].modify(1, 1, n, seg[1].dfn[u], seg[1].dfn[u] + seg[1].sz[u] - 1);
printf("%d\n", max(seg[0].mx[1][0], seg[1].mx[1][0]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "e:/Codes/lib/prettyprint.hpp"
#else
#define debug(...)
#endif
int32_t main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
int n, k;
string s;
cin >> n >> k >> s;
vector<string> dp(n+1);
auto c = [&](char c, int x) {
return string () = ('a' + (c - 'a' + x + k) % k);
};
for (int i = 0; i < n; ++i) {
if (dp[i+1].size() == 0) dp[i+1] = dp[i] + s[i];
for (int j = -1; j <= 1; ++j) {
dp[i+1] = min(dp[i+1], dp[i] + c(s[i], j));
}
if (i > 0) {
string tmp = dp[i] + s[i];
swap(tmp[i], tmp[i-1]);
dp[i+1] = min(dp[i+1], tmp);
}
if (i+2 > n) continue;
if (dp[i+2].size() == 0) dp[i+2] = dp[i] + s[i] + s[i+1];
for (int j = -1; j <= 1; ++j) {
dp[i+2] = min(dp[i+2], dp[i] + c(s[i+1], j) + s[i]);
}
if (i > 0 && i+1 < n) {
string tmp = dp[i] + s[i+1];
swap(tmp[i], tmp[i-1]);
dp[i+2] = min(dp[i+2], tmp + s[i]);
}
}
debug(dp);
cout << dp[n] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
const bool typetest = 1;
const int N = 1e5 + 5;
int n, a[N];
int k;
string s;
string dp[N];
void Read()
{
cin >> n >> k >> s;
}
char Max(char c)
{
return (c == 'a' || c == 'a' + k - 1) ? 'a' : char(c - 1);
}
void Solve()
{
for (int i = 0; i < n; ++i)
dp[i] = char('z' + 1);
dp[0] = Max(s[0]);
if (n > 1)
{
string v = "";
v.push_back(Max(s[1]));
v.push_back(s[0]);
dp[1] = min(dp[1], v);
v.clear();
v.push_back(Max(s[0]));
v.push_back(Max(s[1]));
}
//cout << dp[0] << " " << dp[1] << '\n';
for (int i = 0; i < n; ++i)
{
// /cout << i << ": " << dp[i] << "\n";
if (i + 1 < n)
{
dp[i + 1] = min(dp[i + 1], dp[i] + Max(s[i + 1]));
dp[i + 1] = min(dp[i + 1], dp[i].substr(0, dp[i].size() - 1) + s[i + 1] + dp[i].back());
}
if (i + 2 < n)
{
dp[i + 2] = min(dp[i + 2], dp[i] + Max(s[i + 2]) + s[i + 1]);
dp[i + 2] = min(dp[i + 2], dp[i].substr(0, dp[i].size() - 1) + s[i + 2] + dp[i].back() + s[i + 1]);
}
}
cout << dp[n - 1] << "\n";
}
int32_t main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t(1);
if (typetest)
cin >> t;
for (int _ = 1; _ <= t; ++_)
{
Read();
Solve();
}
} |
#include <cstdlib>
#include <iostream>
#include <cstdio>
#include <math.h>
#include <cstring>
#include <time.h>
#include <complex>
#include <algorithm>
#include <queue>
#include <unordered_map>
#include <set>
#include <bitset>
#pragma warning(disable:4996)
#define PII std::pair<long long, long long>
#define PTT std::pair<tree *, tree *>
template<typename T> T min(T x, T y)
{
return x < y ? x : y;
}
template<typename T> T max(T x, T y)
{
return x > y ? x : y;
};
const long long INF = 2000000005;// 0000;//autojs.org
const long long mod = 1000000007;// 998244353;//
const long long MAXN = 505;
const long long T = 37;
long long PT[MAXN];
struct TREE {
int l;
int r;
long long h;
TREE *lson;
TREE *rson;
TREE(int L = 1, int R = MAXN)
{
l = L, r = R;
h = 0;
lson = rson = NULL;
}
};
TREE pool[1000000];
int TOP;
long long newtree(int L = 1, int R = MAXN)
{
pool[TOP] = TREE(L, R);
return (long long)(pool + TOP++);
}
struct tree {
int l;
int r;
long long h;
tree *lson;
tree *rson;
tree(int L = 1, int R = MAXN)
{
l = L, r = R;
h = 0;
lson = rson = NULL;
}
void pushup()
{
int mid = (r + l) / 2;
h = lson ? lson->h * PT[r - mid] % mod : 0;
h += rson ? rson->h : 0;
h %= mod;
}
tree *modify(int p, char ch)
{
tree *t = (tree *)newtree();
*t = *this;
if (t->l == t->r)
{
t->h = ch;
return t;
}
int mid = (t->r + t->l) / 2;
if (p <= mid)
t->lson = lson ? lson->modify(p, ch) : tree(l, mid).modify(p, ch);
else
t->rson = rson ? rson->modify(p, ch) : tree(mid + 1, r).modify(p, ch);
t->pushup();
return t;
}
char get(int p)
{
if (l == r)
return (char)h;
int mid = (l + r) / 2;
if (p <= mid)
return lson->get(p);
return rson->get(p);
}
};
int cmp(tree *T1, tree *T2)
{
if (!T1 || !T2)
return T1 ? 1 : (T2 ? -1 : 0);
if (T1->l == T1->r)
return T1->h > T2->h ? -1 : T1->h < T2->h;
if (!T1->lson || !T2->lson || T1->lson->h != T2->lson->h)
return cmp(T1->lson, T2->lson);
return cmp(T1->rson, T2->rson);
}
void recycle()
{
TOP = 0;
}
int N, D;
char a[MAXN], nxt[MAXN];
tree *f[MAXN];
void solve()
{
scanf("%d %d", &N, &D);
scanf("%s", a + 1);
for (int i = 1; i < D; i++)
nxt['a' + i] = 'a' + i - 1;
nxt['a'] = nxt['a' + D - 1] = 'a';
recycle();
memset(f, 0, sizeof(f));
tree *t = NULL;
f[0] = (tree *)newtree();
f[1] = tree().modify(1, nxt[a[1]]);
for (int i = 2; i <= N; i++)
{
f[i] = f[i - 1]->modify(i, nxt[a[i]]);
t = f[i - 1]->modify(i - 1, a[i]), t = t->modify(i, f[i - 1]->get(i - 1));
if (cmp(t, f[i]) == 1)
f[i] = t;
t = f[i - 2]->modify(i - 1, nxt[a[i]]), t = t->modify(i, a[i - 1]);
if (cmp(t, f[i]) == 1)
f[i] = t;
if (i == 2) continue;
t = f[i - 2]->modify(i - 2, a[i]), t = t->modify(i - 1, f[i - 2]->get(i - 2)),
t = t->modify(i, a[i - 1]);
if (cmp(t, f[i]) == 1)
f[i] = t;
}
for (int i = 1; i <= N; i++)
printf("%c", f[N]->get(i));
printf("\n");
}
int main()
{
PT[0] = 1;
for (int i = 1; i < MAXN; i++)
PT[i] = PT[i - 1] * T % mod;
int t;
scanf("%d", &t);
while (t--)
solve();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int tc;
int n,k;
string s;
char best(char x)
{
if(x=='a') return x;
else if(x=='a'+(k-1)) return 'a';
return x-1;
}
int main()
{
ios_base::sync_with_stdio(false);
cin>>tc;
for(int i_=1;i_<=tc;i_++)
{
cin>>n>>k;
cin>>s;
int curr=0;
bool fs=false;
while(curr<n)
{
if( (!(curr!=0 && s[curr]<s[curr-1] && (curr+1==n || s[curr]<=s[curr+1]))) && curr+1!=n && ((curr!=0 && s[curr]>s[curr+1] && s[curr+1]<s[curr-1]) || (best(s[curr])>best(s[curr+1]) && (curr+2==n || best(s[curr+1])<=s[curr+2]) && best(s[curr+1])!=s[curr+1])))
{
swap(s[curr],s[curr+1]);
fs=true;
}
else
{
if(curr!=0 && s[curr]<s[curr-1] && (curr+1==n || s[curr]<=s[curr+1])) swap(s[curr],s[curr-1]);
else s[curr]=best(s[curr]);
curr+=1+fs;
fs=false;
}
}
cout<<s<<endl;
}
return 0;
}
|
#include <cstdio>
#include <utility>
#include <map>
using namespace std;
char s[510], ans[510];
inline void upd(char &p, int &m, char c, char d) {
if (p > c) p = c, m = 0;
if (p == c) m |= 1 << d;
}
void solve() {
int n, k;
scanf("%d%d%s", &n, &k, s);
for (int i = 0; i < n; i++) {
s[i] -= 'a';
}
if (n == 1) {
if (s[0] == k - 1) {
s[0] = 0;
} else if (s[0]) {
s[0]--;
}
s[0] += 'a';
puts(s);
return;
}
int m1 = 1 << 26, m2 = 0;
char pp = -1, p2 = -1;
for (int i = 0; i < n; i++) {
char z, u = s[i];
int n1 = 0, n2 = 0;
if (u == k - 1) {
u = 0;
} else if (u) {
--u;
}
if (m2 && p2 != -1 && s[i] < pp) {
z = s[i];
pp = p2;
p2 = 26;
n1 = m2;
n2 = 0;
} else {
z = pp;
int f = pp == p2;
pp = p2 = 26;
for (int j = 0; j < k; j++) {
if (m1 >> j & 1) {
upd(pp, n1, s[i], j);
if (i + 1 < n) upd(p2, n2, j, s[i]);
upd(pp, n1, j, u);
}
if (f && (m2 >> j & 1)) {
upd(pp, n1, j, s[i]);
upd(pp, n1, u, j);
}
}
if (m1 >> 26 & 1) {
if (i + 1 < n) upd(p2, n2, -1, s[i]);
upd(pp, n1, -1, u);
}
}
if (i > 1) ans[i-2] = z;
m1 = n1;
m2 = n2;
}
ans[n-2] = pp;
for (int i = 0; i < k; i++) {
if ((m1 | m2) >> i & 1) {
ans[n-1] = i;
break;
}
}
for (int i = 0; i < n; i++) {
ans[i] += 'a';
}
ans[n] = 0;
puts(ans);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define endl '\n'
#define all(v) (v).begin(), (v).end()
template<class A, class B> ostream& operator<<(ostream& os, const pair<A,B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template<class T> auto operator<<(ostream& os, T&& x) -> decltype(x.begin(), os) {
os << '{';
for(auto it = x.begin(); it != x.end(); ++it) os << *it << (it == prev(x.end()) ? "" : ", ");
return os << '}';
}
void dump() {}
template<class T,class... Args> void dump(T&& x,Args... args) { cerr<<x<<"; "; dump(args...); }
#ifdef DEBUG
struct Lf{ ~Lf() { cerr << '\n'; } };
#define debug(x...) cerr << (strcmp(#x, "") ? #x ": " : ""), dump(x), Lf(), cerr << ""
#else
#define debug(...) 0&&cerr
#endif
int t, n, k;
void solve() {
cin >> n >> k;
string s; cin >> s;
for (char& c : s) c -= 'a';
vector<string> DP(n+1, "|");
DP[0] = "";
for (int i=0; i<n; ++i) {
int bestUD = (int)s[i];
bestUD = min(bestUD, min((bestUD+1) % k, (bestUD+k-1) % k));
DP[i+1] = min(DP[i+1], DP[i]+char(bestUD));
if (i>0) {
DP[i+1] = min(DP[i+1], DP[i-1]+char(bestUD)+s[i-1]);
DP[i+1] = min(DP[i+1], DP[i].substr(0,i-1)+s[i]+DP[i].back());
}
if (i>1) {
DP[i+1] = min(DP[i+1], DP[i-1].substr(0,i-2)+s[i]+DP[i-1].back()+s[i-1]);
}
}
for (char& c : DP[n]) c += 'a';
cout << DP[n].c_str() << endl;
}
int main() {
ios::sync_with_stdio(false);
for (cin >> t; t--;) solve();
return 0;
} |
#include <bits/stdc++.h>
#define fi first
#define se second
#define o2(x) (x) * (x)
#define mk make_pair
#define eb emplace_back
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define clr(a, b) memset((a), (b), sizeof((a)))
#define rep(i, s, t) for(register int i = (s), LIM=(t); i < LIM; ++i)
#define per(i, s, t) for(register int i = (s), LIM=(t); i >= LIM; --i)
#define GKD std::ios::sync_with_stdio(false);cin.tie(0)
#define my_unique(x) sort(all(x)), x.erase(unique(all(x)), x.end())
using namespace std;
typedef long long LL;
typedef long long int64;
typedef unsigned long long uint64;
typedef pair<int, int> pii;
// mt19937 rng(time(NULL));//std::clock()
// mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count());
// shuffle(arr, arr + n, rng64);
inline int64 read() {
int64 x = 0;int f = 0;char ch = getchar();
while (ch < '0' || ch > '9') f |= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch =
getchar(); return x = f ? -x : x;
}
inline void write(int64 x, bool f = true) {
if (x == 0) {putchar('0'); if(f)putchar('\n');else putchar(' ');return;}
if (x < 0) {putchar('-');x = -x;}
static char s[23];
int l = 0;
while (x != 0)s[l++] = x % 10 + 48, x /= 10;
while (l)putchar(s[--l]);
if(f)putchar('\n');else putchar(' ');
}
int lowbit(int x) { return x & (-x); }
template <class T>
T big(const T &a1, const T &a2) {return a1 > a2 ? a1 : a2;}
template <class T>
T sml(const T &a1, const T &a2) {return a1 < a2 ? a1 : a2;}
template <typename T, typename... R>
T big(const T &f, const R &... r) {return big(f, big(r...));}
template <typename T, typename... R>
T sml(const T &f, const R &... r) {return sml(f, sml(r...));}
void debug_out() { cout << '\n'; }
template <typename T, typename... R>
void debug_out(const T &f, const R &... r) {
cout << f << " ";
debug_out(r...);
}
#ifdef LH_LOCAL
#define debug(...) cout << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__);
#else
#define debug(...) ;
#endif
/*================Header Template==============*/
const int mod = 998244353;// 998244353
int ksm(int a, int64 b, int kmod = mod) {int res = 1;for(;b > 0;b >>= 1, a = (int64)a * a % kmod) if(b &1) res = (int64)res * a % kmod;return res;}
const int INF = 0x3f3f3f3f;
const int MXN = 2e5 + 5;
int n, m;
char s[MXN];
int ori[MXN], dwn[MXN];
/*
origin[i] 表示i位置的字符是否原本就在i。
down[i] 表示i位置的字符能否循环移动。
如果i+1的字符能移动到i，需要保证i+1原本就在i+1。
如果i+2的字符能移动到i，需要保证i+1原本就在i+1。
如果经过合法改变后，从i来的字符是最小的就选i位置保持不变，否则如果从i+1来的字符是最小的就选i+1位置，否则如果从i+2来的字符是最小的就选i+2位置，否则就不变。
*/
void work() {
n = read(), m = read();
rep(i, 0, n) ori[i] = dwn[i] = 0;
scanf("%s", s);
rep(i, 0, n) {
int a = s[i] - 'a', b = (i + 1 < n && ori[i + 1] == 0? s[i + 1] - 'a': INF), c = (i + 2 < n && ori[i + 1] == 0? s[i + 2] - 'a': INF);
//位置i可以循环移动
if(dwn[i] == 0) a = sml(a, (a + 1) % m, (a + m - 1) % m);
//位置i+1可以循环移动
if(b != INF && ori[i] == 0 && dwn[i + 1] == 0 && ori[i + 1] == 0) b = sml(b, (b + 1) % m, (b + m - 1) % m);
if(a <= b && a <= c) {
s[i] = a + 'a';
}else if(b <= a && b <= c) {
swap(s[i], s[i + 1]);
if(s[i] != b + 'a') {//这时候i要必须先做操作R，所以改变后i+1没法循环移动
s[i] = b + 'a';
dwn[i + 1] = 1;
}else {
//这时候i+1位置是不需要经过循环移动来变成更小的元素的，所以i位置是可能保留了一次操作，先不要急着操作，后面再慢慢考虑。
}
if(dwn[i]) dwn[i + 1] = 1;//但是如果原本i本来就没法循环移动，那么改变后i+1也没法循环移动
ori[i + 1] = 1;//i+1肯定不是原位置的啦
}else if(c <= a && c <= b) {
swap(s[i], s[i + 2]);
swap(s[i + 1], s[i + 2]);
//这时候其实i位是可能能保留了一次操作，先不要急着操作，后面再慢慢考虑。
if(dwn[i]) dwn[i + 1] = 1;//但是如果原本i本来就没法循环移动，那么改变后i+1也没法循环移动
ori[i + 1] = 1;//i+1肯定不是原位置的啦
ori[i + 2] = dwn[i + 2] = 1;//原本i+1做了操作R，所以改变后肯定没法做循环移动操作，也不是原位置
}
// debug(i, s)
}
printf("%s\n", s);
}
int main() {
#ifdef LH_LOCAL
freopen("D:/ACM/mtxt/in.txt", "r", stdin);
// freopen("D:/ACM/mtxt/out.txt", "w", stdout);
#endif
for(int cas = 1, tim = read(); cas <= tim; ++ cas) {
// printf("Case #%d:\n", cas);
work();
}
#ifdef LH_LOCAL
cout << "time cost:" << 1.0 * clock() / CLOCKS_PER_SEC << "s" << endl;
#endif
return 0;
} |
# include<bits/stdc++.h>
using namespace std;
# define l long long
# define db double
# define rep(i,a,b) for(l i=a;i<b;i++)
# define vi vector<l>
# define vvi vector<vi>
# define vsi vector<set<l> >
# define pb push_back
# define mp make_pair
# define ss second
# define ff first
# define pii pair<l,l>
# define trvi(v,it) for(vi::iterator it=v.begin();it!=v.end();++it)
# define read(a) freopen(a,"r",stdin)
# define write(a) freopen(a,"w",stdout)
# define io ios::sync_with_stdio(false)
#define ai(n) array<l,n>
const l MOD=1e9+7;
const l N=505;
const l INF=1e12;
l n,k;
string s;
char up(char c) {
l cnt=c-'a';
cnt=(cnt+1)%k;
return 'a'+cnt;
}
char down(char c) {
l cnt=c-'a';
cnt=(cnt-1)%k;
if(cnt<0) {
cnt+=k;
}
return 'a'+cnt;
}
void solve() {
cin>>n>>k;
cin>>s;
vector<string> dp(n+1), dp_gap(n+1);
rep(i,0,n) {
dp[i+1]=dp[i]+up(s[i]);
// dp[i+1]=min(dp[i+1],dp[i]+up(s[i]));
dp[i+1]=min(dp[i+1],dp[i]+down(s[i]));
dp[i+1]=min(dp[i+1],dp[i]+s[i]);
if(i>=1) {
dp[i+1]=min(dp[i+1], dp[i].substr(0,i-1)+s[i]+dp[i].back());
}
dp_gap[i+1] = dp[i] + s[i];
if(i>=1) {
dp[i+1]=min(dp[i+1], dp_gap[i].substr(0,i-1) + s[i] + dp_gap[i].substr(i-1));
dp[i+1]=min(dp[i+1], dp_gap[i].substr(0,i-1) + up(s[i]) + dp_gap[i].substr(i-1));
dp[i+1]=min(dp[i+1], dp_gap[i].substr(0,i-1) + down(s[i]) + dp_gap[i].substr(i-1));
dp[i+1]=min(dp[i+1], dp_gap[i] + s[i]);
}
if(i>=2) {
dp[i+1] = min(dp[i+1], dp_gap[i].substr(0,i-2)+s[i]+dp_gap[i].substr(i-2));
}
}
cout<<dp[n]<<"\n";
return;
}
int main(){
io;
int t;
cin >> t;
rep(i,0,t) {
solve();
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
constexpr int maxn = 600;
char s[maxn];
int a[maxn];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int t;
for(cin >> t; t; t -= 1){
int n, k;
cin >> n >> k >> s;
for(int i = 0; i < n; i += 1) a[i] = s[i] - 'a';
for(int i = 0, p = 0; i < n; i += 1){
if(p){
int fm = a[i];
if(i == n - 1) break;
int sm = a[i + 1];
if(i == n - 2){
if(fm <= sm){
p = 0;
continue;
}
swap(a[i], a[i + 1]);
break;
}
int tm = a[i + 2];
if(fm <= sm and fm <= tm){
p = 0;
continue;
}
if(sm <= tm){
swap(a[i], a[i + 1]);
continue;
}
a[i] = tm;
a[i + 2] = sm;
a[i + 1] = fm;
i += 1;
continue;
}
else{
int fm = min({a[i], (a[i] + k - 1) % k, (a[i] + 1) % k});
if(i == n - 1){
a[i] = fm;
break;
}
int sm = min({a[i + 1], (a[i + 1] + k - 1) % k, (a[i + 1] + 1) % k});
if(i == n - 2){
if(fm <= sm){
a[i] = fm;
continue;
}
if(a[i + 1] == sm){
a[i] = sm;
a[i + 1] = fm;
break;
}
a[i + 1] = a[i];
a[i] = sm;
break;
}
int tm = a[i + 2];
if(fm <= sm and fm <= tm){
a[i] = fm;
continue;
}
if(sm <= tm){
if(a[i + 1] == sm){
a[i] = sm;
a[i + 1] = fm;
p = 1;
continue;
}
a[i + 1] = a[i];
a[i] = sm;
p = 1;
continue;
}
a[i] = tm;
a[i + 2] = a[i + 1];
a[i + 1] = fm;
p = 1;
i += 1;
}
}
for(int i = 0; i < n; i += 1) cout << char(a[i] + 'a');
cout << "\n";
}
return 0;
} |
#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 500
#define mod 998244353
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;
void upd(string &s,string &t)
{
if(s=="" || s>t) s=t;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int cas; cin>>cas; while(cas--)
{
int n,k; cin>>n>>k;
string dp[2][2];
cin>>dp[0][0];
rep(i,0,n-1)
{
dp[(i+1)&1][0]=dp[(i+1)&1][1]="";
if(dp[i&1][0]!="")
{
auto &s=dp[i&1][0];
if(i>0)
{
swap(s[i],s[i-1]);
upd(dp[(i+1)&1][0],s);
swap(s[i],s[i-1]);
}
if(i<n-1)
{
swap(s[i],s[i+1]);
upd(dp[(i+1)&1][1],s);
swap(s[i],s[i+1]);
}
if(s[i]=='a'+k-1) s[i]='a';
if(s[i]>'a') s[i]--;
upd(dp[(i+1)&1][0],s);
}
if(dp[i&1][1]!="")
{
auto &s=dp[i&1][1];
if(i>1)
{
swap(s[i-1],s[i-2]);
upd(dp[(i+1)&1][0],s);
swap(s[i-1],s[i-2]);
}
if(s[i-1]=='a'+k-1) s[i-1]='a';
if(s[i-1]>'a') s[i-1]--;
upd(dp[(i+1)&1][0],s);
}
}
cout<<dp[n&1][0]<<endl;
}
return 0;
} |
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
using namespace std ;
int t , n , k;
const int maxn = 5e5 + 10 ;
char a[maxn] ;
string dp[maxn] ;
char best(char c){
if(c == 'a') return 'a' ;
if(c == 'a' + k - 1) return 'a' ;
return c - 1 ;
}
int main(){
int cnt = 0 ;
cin >> t ;
while(t--){
cin >> n >> k ;
for(int i = 1 ; i <= n ; i++)
cin >> a[i] ;
dp[0] = "" ;
for(int i = 1 ; i <= n ; i++){
dp[i] = dp[i-1] + best(a[i]) ;
if(i > 1){
string str = dp[i-1] ;
char c = str[str.size() - 1] ;
str.pop_back() ;
dp[i] = min(dp[i] , str + a[i] + c) ;
dp[i] = min(dp[i] , dp[i-2] + best(a[i]) + a[i-1]) ;
}
if(i > 2){
string str = dp[i-2] ;
char c = str[str.size() - 1] ;
str.pop_back() ;
dp[i] = min(dp[i] , str + a[i] + c + a[i-1]) ;
}
}
cout << dp[n] << endl ;
}
return 0 ;
} |
#include<bits/stdc++.h>
using namespace std;
//#include<ext/pb_ds/assoc_container.hpp>
//#include<ext/pb_ds/tree_policy.hpp>
// #pragma GCC optimize("-O3")
// #pragma GCC optimize("no-stack-protector")
// #pragma GCC optimize("fast-math")
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
// #pragma GCC target("avx,avx2,fma")
// #pragma GCC optimization ("unroll-loops")
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifndef _LOCAL
~debug() { cerr << endl; } eni(!=) cerr << boolalpha << i; ris; }eni(==) ris << range(begin(i), end(i)); }sim, class b dor(pair < b, c > d) {ris << "(" << d.first << ", " << d.second << ")";}sim dor(rge<c> d) {*this << "[";for (auto it = d.b; it != d.e; ++it)*this << ", " + 2 * (it == d.b) << *it;ris << "]";}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
#define f first
#define vec vector
#define s second
#define p_b push_back
#define pb push_back
////////////////////////////////???????????????CHECK THIS OUT???????????????//////////////////////////////
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<long long,long long> pll;
typedef pair<int,int> pii;
typedef pair<long long,int> pli;
////////////////////////////////???ww????????????CHECK THIS OUT???????????????//////////////////////////////
#define m_p make_pair
#define fast_io cin.tie(0);cout.tie(0);ios_base::sync_with_stdio(0);
#define all(x) x.begin(),x.end()
#define pw(x) (1ll << x)
#define sz(x) (int)x.size()
#define endl "\n"
#define rall(x) x.rbegin(),x.rend()
//using namespace __gnu_pbds;
ld eps = (ld)1 / 1e6;
const ld pi=3.14159265359;
ll inf = 1e18,mod1=1e9+7;
ll sqr(ll a) { return a * a; }
ll qb(ll a) { return a * a * a; }
//template<typename T> bool umax(T& a, T b) {return a<b?a=b,1:0;}
//template<typename T> bool umin(T& a, T b) {return b<a?a=b,1:0;}
bool is_prime(ll val){for(ll i=2;i<=sqrt(val);i++)if(val%i==0)return 0; return 1;}
ll gcd(ll a, ll b) { return !a ? b : gcd(b % a, a); }
ll binpow(ll a, ll b, ll mod) { return b ? (b % 2 ? (a * (sqr(binpow(a, b / 2, mod)) % mod)) % mod : sqr(binpow(a, b / 2, mod)) % mod) : 1; }ll binmult(ll a, ll b, ll mod) { return b ? (b % 2 ? (2 * binmult(a, b / 2, mod) + a) % mod : (2 * binmult(a, b / 2, mod)) % mod) : 0; }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const ll RR=1e4;
const ll tx[8]={1,-1,2,-2,-1,-2};
const ll ty[8]={-2,-2,-1,-1,2,1};
const char rev_to[4]={'E','W','N','S'};
///////////////////fdsfsdfgdsjgdjfsgdsfsdkafsdaokfsdpofdckokfpgjvdsujbgdfpiodjOFCjs;igsd;cpjzckpdoskvgdok;a///////
//const int ppp=73;
//const int M=999999937;
///////////////////fdsfsdfgdsjgdjfsgdsfsdkafsdaokfsdpofdckokfpgjvdsujbgdfpiodjOFCjs;igsd;cpjzckpdoskvgdok;a///////
//const int ppp=73;
const int block=600;
const int OPEN=0;
const int CLOSE=1;
const int STOP=2;
//typedef tree<pii,null_type,less<pii>,rb_tree_tag,tree_order_statistics_node_update> o_st;
auto rnd=bind(uniform_int_distribution<ll>(1,10),mt19937(time(0)));
void bad(){
cout<<"-1";
exit(0);
}
typedef pair<char,int> pci;
signed main()
{
fast_io;
int t;
cin>>t;
while(t--){
int n,k;
cin>>n>>k;
string s;
cin>>s;
vec<string>dp(n+1);
auto bst=[&](char c){
if(c=='a')
return c;
if(c=='a'+k-1)
return 'a';
return char(c-1);
};
auto umin=[&](string &a,string &b){
if(!sz(a))
a=b;
else
a=min(a,b);
return;
};
for(int i=0;i<n;i++){
// st.erase({s[i],-i});
string o=dp[i]+bst(s[i]);
umin(dp[i+1],o);
// dp[i+1]+=bst(s[i]);
/// check for swapping with last
if(sz(dp[i])){
o=dp[i];
o.pop_back();
o+=s[i];
o+=dp[i].back();
umin(dp[i+1],o);
}
/// check for swapping with next
if(i+1<n){
o=dp[i];
o+=bst(s[i+1]);
o+=s[i];
// if(i==1)debug()<<imie(o);
umin(dp[i+2],o);
// if(i==1)debug()<<imie(dp[i+2]);
}
if(sz(dp[i]) && i+1<n){
o=dp[i];
char c=dp[i].back(),b=s[i],a=s[i+1];
o.pop_back();
o+=a;o+=c;o+=b;
umin(dp[i+2],o);
}
// debug()<<imie(dp[i]);
}
cout<<dp[n]<<endl;
}
return 0;
}
/*
1
4
1 4
1 5
1 6
1 7
*/
|
/** Created by: Humberto Yusta
Codeforces User: humbertoyusta
Country: Cuba
Copyright�� */
#include<bits/stdc++.h>
using namespace std;
/// Pragmas:
#pragma GCC optimize("Ofast","unroll-loops","omit-frame-pointer","inline") //Optimization flags
//#pragma GCC option("arch=native","tune=native","no-zero-upper") //Enable AVX
//#pragma GCC target("avx2") //Enable AVX
/// Macros:
#define int long long
#define f first
#define s second
#define db(x) cerr << #x << ": " << (x) << '\n';
#define pb push_back
#define lb lower_bound
#define up upper_bound
#define all(x) x.begin() , x.end()
#define rall(x) x.rbegin() , x.rend()
#define enl '\n'
typedef pair<int,int> ii;
typedef long double ld;
typedef unsigned long long ull;
/// Constraints:
const int maxn = 505;
const int mod = 1000000007;
const int mod2 = 998244353;
const ld eps = 1e-9;
const int inf = ((1ll<<31ll)-1ll);
const int INF = 1ll * mod * mod;
const ld pi = acos(-1);
/// Prime Numbers:
// 2, 173, 179, 181, 197, 311, 331, 737, 1009, 2011, 2027, 3079, 4001, 10037, 10079, 20011, 20089;
// 100003, 100019, 100043, 200003, 200017, 1000003, 1000033, 1000037, 1000081;
// 2000003, 2000029, 2000039, 1000000007, 1000000021, 2000000099;
/// rng
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
/// Functions:
#define lg2(x) 31 - __builtin_clz(x)
#define lgx(x,b) ( log(x) / log(b) )
/// Red-Black Tree Template ---------------------------------
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//typedef tree < long long , null_type , less<long long> , rb_tree_tag , tree_order_statistics_node_update > ordered_set;
/// Quick Pow------------------------------------------------
int qpow(int b,int e){
if( !e ) return 1;
if( e & 1 ) return qpow(b,e-1) * b % mod;
int pwur = qpow(b,e>>1);
return pwur * pwur % mod;
}
int modinv(int x){
return qpow(x,mod-2);
}
/// My Code -------------------------------------------------
int tc,n ,k, mk[maxn];
string s, t, dp[maxn];
map<char,char> nxt, prv;
string norm(char a,char b,char c){
string ans;
ans += c;
ans += a;
ans += b;
return ans;
}
string best(char a,char b,char c){
string ans;
ans += c;
ans += min( a , min( prv[a] , nxt[a] ) );
ans += b;
return ans;
}
string norm(char a,char b){
string ans;
ans += b;
ans += a;
return ans;
}
string best(char a,char b){
string ans;
ans += min( b , min( prv[b] , nxt[b] ) );
ans += a;
return ans;
}
string best(char a){
string ans;
ans += min( a , min( prv[a] , nxt[a] ) );
return ans;
}
int32_t main(){
ios_base::sync_with_stdio(0); cin.tie(0);
cout.setf(ios::fixed); cout.precision(0);
srand(time(NULL));
//freopen("a.in","r",stdin);
//freopen("a.out","w",stdout);
cin >> tc;
while( tc-- ){
cin >> n >> k;
nxt.clear();
prv.clear();
for(int i=0; i<k-1; i++)
nxt[char('a'+i)] = char('a'+i+1);
nxt[char('a'+k-1)] = 'a';
for(int i=1; i<k; i++)
prv[char('a'+i)] = char('a'+i-1);
prv['a'] = char('a'+k-1);
cin >> s;
t.clear();
dp[0] = "";
for(int i=1; i<=n; i++)
dp[i] = char('z'+1);
for(int i=0; i<=n; i++){
if( i >= 1 ){
dp[i] = min( dp[i] , dp[i-1] + best(s[i-1]) );
int bck = dp[i].back();
dp[i].pop_back();
if( i + 1 <= n ) dp[i+1] = min( dp[i+1] , dp[i] + norm( bck , s[i] ) );
if( i + 2 <= n ) dp[i+2] = min( dp[i+2] , dp[i] + norm( bck , s[i] , s[i+1] ) );
dp[i] += bck;
}
if( i + 2 <= n ) dp[i+2] = min( dp[i+2] , dp[i] + best( s[i] , s[i+1] ) );
if( i + 3 <= n ) dp[i+3] = min( dp[i+3] , dp[i] + best( s[i] , s[i+1] , s[i+2] ) );
//db(dp[i])
}
cout << dp[n] << '\n';
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
class Solution {
public:
void solve() {
int n, k;
cin >> n >> k;
auto nxt = [&](char c) {
int d = c - 'a';
return 'a' + (d + 1) % k;
};
auto pre = [&](char c) {
int d = c - 'a';
return 'a' + (d - 1 + k) % k;
};
string s;
cin >> s;
if (n == 1) {
int c = s[0] - 'a' + 1;
if (c == k || c == 1)
printf("a\n");
else
printf("%c\n", 'a' + c - 2);
return;
}
char a = s[0], b = s[1];
char am = pre(a), bm = pre(b), ap = nxt(a), bp = nxt(b);
vector<string> f{{a, b}, {a, bm}, {a, bp}, {am, b}, {am, bm},
{am, bp}, {ap, b}, {ap, bm}, {ap, bp}, {b, a},
{bm, a}, {bp, a}, {b, am}, {b, ap}};
if (n == 2) {
printf("%s\n", (*min_element(f.begin(), f.end())).c_str());
return;
}
vector<string> nf;
char c = s[2];
for (string &fi : f)
fi.push_back(c);
vector<string> g{{a, c, b}, {am, c, b}, {ap, c, b}};
string ans;
for (int i = 2; i < n; ++i) {
set<string> nf, ng;
char flo = 'z', glo = 'z';
if (!f.empty())
flo = (*min_element(f.begin(), f.end()))[0];
if (!g.empty())
glo = (*min_element(g.begin(), g.end()))[0];
for (string fi : f) {
char a = fi[0], b = fi[1], c = fi[2];
if (a > flo)
continue;
char cm = pre(c), cp = nxt(c);
char d = (i + 1 < n) ? s[i + 1] : 'z';
vector<string> fgen{
{a, b, c, d}, {a, b, cm, d}, {a, b, cp, d}, {a, c, b, d}};
for (string fj : fgen) {
if (!nf.empty() && (*nf.begin())[0] > fj[0])
nf.clear();
if (nf.empty() || (*nf.begin())[0] == fj[0])
nf.insert(fj);
}
string gj{a, b, d, c};
if (!ng.empty() && (*ng.begin())[0] > gj[0])
ng.clear();
if (ng.empty() || (*nf.begin())[0] == gj[0])
ng.insert(gj);
}
for (string gi : g) {
char a = gi[0], c = gi[1], b = gi[2];
if (a > glo && c > glo)
continue;
char cm = pre(c), cp = nxt(c);
char d = (i + 1 < n) ? s[i + 1] : 'z';
vector<string> fgen{
{a, c, b, d}, {a, cm, b, d}, {a, cp, b, d}, {c, a, b, d}};
for (string fj : fgen) {
if (!nf.empty() && (*nf.begin())[0] > fj[0])
nf.clear();
if (nf.empty() || (*nf.begin())[0] == fj[0])
nf.insert(fj);
}
}
char tf = (*nf.begin())[0], tg = (*ng.begin())[0];
if (tf < tg)
ng.clear();
if (tf > tg)
nf.clear();
f.clear();
g.clear();
ans.push_back(min(tf, tg));
for (string fi : nf)
f.emplace_back(fi.substr(1, 3));
for (string gi : ng)
g.emplace_back(gi.substr(1, 3));
}
for (string gi : g)
f.emplace_back(gi);
ans += (*min_element(f.begin(), f.end())).substr(0, 2);
printf("%s\n", ans.c_str());
}
};
int main() {
int t;
cin >> t;
while (t--) {
Solution solution = Solution();
solution.solve();
}
} |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define x first
#define y second
#define ld long double
#define ll long long
#define ull unsigned long long
#define us unsigned short
#define lsb(x) ((x) & (-(x)))
using namespace std;
int t, n, k;
string s;
string dp[505];
string f(char c) {
char x = (c == k - 1 + 'a' ? 'a' : char(c - (c != 'a')));
string ans;
ans += x;
return ans;
}
int main() {
ios_base :: sync_with_stdio(false);
cin.tie(0); cout.tie(0);
cin >> t;
for(; t; t--) {
cin >> n >> k >> s;
dp[0] = f(s[0]);
for(int i = 1; i < n; i++) {
dp[i] = dp[i - 1] + f(s[i]);
if(i >= 1) {
string tmp = dp[i - 1] + s[i];
swap(tmp[i], tmp[i - 1]);
dp[i] = min(dp[i], tmp);
}
if(i >= 2) {
string tmp = dp[i - 2] + s[i] + s[i - 1];
swap(tmp[i - 2], tmp[i - 1]);
dp[i] = min(dp[i], tmp);
}
dp[i] = min(dp[i], (i >= 2 ? dp[i - 2] : "") + f(s[i]) + s[i - 1]);
}
cout << dp[n - 1] << "\n";
}
return 0;
}
|
/*
This is code of SuperJ6 for Codeforces.
Don't copy my code during f*kin' contests.
2.71828182845904523536
*/
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define endl '\n'
#define ll long long
#define pi pair<int, int>
#define f first
#define s second
const int mxn = 503;
int n, k;
int a[mxn], vis[mxn];
void swp(int x){
swap(a[x], a[x + 1]), swap(vis[x], vis[x + 1]);
}
void answer(){
cin >> n >> k;
for(int i = 1; i <= n; i++){
char c;
cin >> c;
a[i] = c - 'a', vis[i] = 0;
}
a[0] = -1, a[n + 1] = a[n + 2] = k;
for(int i = 1; i <= n; i++) if(!vis[i]){
vis[i] = 1;
if(!vis[i + 1] && a[i + 1] < a[i] && a[i + 1] < a[i - 1]){
swp(i--);
}else if(a[i] == k - 1){
a[i] = 0;
}else if(a[i] < a[i - 1]){
swp(i - 1);
}else if(!vis[i + 1] && ((a[i + 1] && a[i + 2] >= a[i + 1] - 1 && a[i + 1] < a[i]) || (a[i + 1] == k - 1 && a[i] > 1))){
swp(i--);
}else if(a[i]){
a[i]--;
}
}
for(int i = 1; i <= n; i++) cout << (char)(a[i] + 'a');
cout << endl;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for(int i = 0; i < t; i++) answer();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define debug(x) cerr << "[(" << __LINE__ << ") " << #x << "]: " << (x) << endl;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
string s;
cin >> n >> k >> s;
k += 'a'-1;
int i;
for (i=0; i<n-1; i++) {
if (i > 0 && s[i] < s[i-1] && s[i] <= s[i+1]) swap(s[i], s[i-1]);
else if (i > 0 && s[i+1] < s[i-1]) {
swap(s[i], s[i+1]);
swap(s[i], s[i-1]);
i++;
}
else if (s[i] == k) s[i] = 'a';
else if (s[i] == 'a') continue;
else {
int a = s[i]-1;
int b = s[i+1];
int c = s[i+1];
if (c == k) c = 'a';
else if (c != 'a') c--;
int d = 1e9;
if (i+2 < n) d = s[i+2];
int mn = min({a, b, c, d});
if (a == mn) s[i] = a;
else if (b == mn) {
swap(s[i], s[i+1]);
if (s[i+1] == k) s[i+1] = 'a';
else if (s[i+1] != 'a') s[i+1]--;
i++;
}
else if (c == mn) {
swap(s[i], s[i+1]);
s[i] = c;
i++;
} else {
swap(s[i+1], s[i+2]);
swap(s[i], s[i+1]);
if (s[i+1] == k) s[i+1] = 'a';
else if (s[i+1] != 'a') s[i+1]--;
i+=2;
}
}
}
if (i == n-1) {
if (i > 0 && s[i] < s[i-1]) swap(s[i], s[i-1]);
else if (s[i] == k) s[i] = 'a';
else if (s[i] != 'a') s[i]--;
}
cout << s << "\n";
}
}
|
#include <algorithm>
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
static bool MULTIPLE_CASES = true;
static long long MOD = (long long) 1e9 + 7;
void insist(bool b) { if (!b) abort(); }
int n, k;
char improveLetter(char letter) {
if (letter == k-1 + 'a') return 'a';
if (letter == 'a') return 'a';
return (char) (letter-1);
}
// 0: individual letter improvement
// 1: swap left
// 2: swap right
string performOperation(string copy, int index, int type) {
if (type == 0) {
copy[index] = improveLetter(copy[index]);
} else if (type == 1) {
swap(copy[index], copy[index-1]);
} else if (type == 2) {
swap(copy[index], copy[index+1]);
} else insist(false);
return copy;
}
void solve() {
cin >> n >> k;
string s;
cin >> s;
// dp[i] = best result of i operations s.t. the next operation is on the ith char in position i.
vector<string> dp(n+1);
dp[0] = s;
dp[1] = performOperation(s, 0, 0);
string best = dp[1];
for (int i = 2; i <= n; i++) {
vector<string> options;
options.push_back(performOperation(dp[i-1], i-1, 0));
options.push_back(performOperation(dp[i-1], i-1, 1));
string type2 = performOperation(dp[i-2], i-2, 2);
options.push_back(performOperation(type2, i-2, 0));
if (i > 2) options.push_back(performOperation(type2, i-2, 1));
sort(options.begin(), options.end());
dp[i] = options[0];
if (options[0] < best) best = options[0];
}
cout << best << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
if (MULTIPLE_CASES) {
int tests;
cin >> tests;
while (tests--) solve();
} else {
solve();
}
}
|
#include <bits/stdc++.h>
#define sz 9999
#define mod 1000000007
#define inf INT_MAX
#define mx INT_MAX
#define mn INT_MIN
#define ll long long
#define ff first
#define ss second
using namespace std;
vector<string> t;
void menor(string &a, string b){
if(a > b)
a=b;
}
void solve(){
int n, k, i;
string s;
cin >>n >> k >> s;
t.resize(n+1);
t[0].clear();
for(i=0;i<n;i++){
char m=(s[i]=='a'||s[i]=='a'+k-1?'a':s[i]-1);
t[i+1]=t[i]+m;
if(i)
{
menor(t[i+1], t[i].substr(0, i-1) + s[i] + t[i].back());
menor(t[i+1], t[i-1] + m + s[i-1]);
if(i>1)
menor(t[i+1], t[i-1].substr(0, i-2) + s[i] + t[i-1].back() + s[i-1]);
}
}
cout<<t[n]<<endl;
}
int main(){
int t;
cin >> t;
while(t--)
solve();
}
|
#include <bits/stdc++.h>
#define endl '\n'
#define F first
#define S second
#define all(x) (x).begin(), (x).end()
#define allr(x) (x).rbegin(), (x).rend()
using namespace std;
typedef __int128 LL;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
const int mod = 998244353;
const int inf = 1e9;
const int maxn = 200005;
int main() {
#ifdef ernestico
freopen ("a.in", "r", stdin );
//freopen ("a.out", "w", stdout );
time_t __time = clock();
system("clear");
#endif
ios_base::sync_with_stdio(0); cin.tie(0);
int test; cin >> test;
while ( test-- ) {
int n, k; cin >> n >> k;
string s; cin >> s; s = " " + s;
vector<string> dp(n+3);
char bigc = 'z' + 1;
for ( int i = 1; i <= n; i ++ ) dp[i] += bigc;
auto best = [&] ( char c ) {
int id = c - 'a';
int b = min ( { id, (id+1)%k, (id-1+k)%k } );
return char ( b + 'a' );
};
for ( int i = 1; i <= n; i ++ ) {
dp[i] = min ( dp[i], dp[i-1] + best(s[i]) );
if ( i > 1 ) {
string tmp = dp[i-1];
auto car = tmp.back();
tmp.pop_back();
tmp += s[i];
tmp += car;
dp[i] = min ( dp[i], tmp );
}
if ( i+1 <= n ) {
string tmp = dp[i-1]; tmp += best(s[i+1]); tmp += s[i];
dp[i+1] = min ( dp[i+1], tmp );
if ( i > 1 ) {
tmp = dp[i-1];
auto car = tmp.back();
tmp.pop_back();
tmp += s[i+1]; tmp += car; tmp += s[i];
dp[i+1] = min ( dp[i+1], tmp );
}
}
if ( i+2 <= n ) {
string tmp = dp[i];
auto car = tmp.back();
tmp.pop_back();
tmp += s[i+2];
tmp += car;
tmp += s[i+1];
dp[i+2] = min ( dp[i+2], tmp );
}
}
cout << dp[n] << endl;
}
#ifdef ernestico
cout << "Running Time: " << 1. * ( clock() - __time ) / CLOCKS_PER_SEC << " seconds" << endl;
#endif
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 503;
int n, k;
int a[mxn], vis[mxn];
void swp(int x){ swap(a[x], a[x + 1]), swap(vis[x], vis[x + 1]);}
int main(){
int t;
cin >> t;
while(t--){
cin >> n >> k;
for(int i = 1; i <= n; i++){ char c; cin >> c; a[i] = c - 'a', vis[i] = 0;}
a[0] = -1, a[n + 1] = a[n + 2] = k;
for(int i = 1; i <= n; i++) if(!vis[i]){
vis[i] = 1;
if(!vis[i + 1] && a[i + 1] < a[i] && a[i + 1] < a[i - 1]) swp(i--);
else if(a[i] == k - 1) a[i] = 0;
else if(a[i] < a[i - 1]) swp(i - 1);
else if(!vis[i + 1] && ((a[i + 1] && a[i + 2] >= a[i + 1] - 1 && a[i + 1] < a[i]) || (a[i + 1] == k - 1 && a[i] > 1))) swp(i--);
else if(a[i]) a[i]--;
}
for(int i = 1; i <= n; i++) cout << (char)(a[i] + 'a');
cout << endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define forn(i,s,t) for(register int i=(s);i<=(t);++i)
#define form(i,s,t) for(register int i=(s);i>=(t);--i)
using namespace std;
const int N = 5e2 + 3;
int t, n, k;
string s, trans;
inline void Trs(string& a, const string& b) {if(a.empty() || b < a) a = b;}
int main() {
scanf("%d", &t);
while(t--) {
scanf("%d%d", &n, &k);
cin >> s;
trans = s;
forn(i,0,n - 1) trans[i] = (s[i] == 'a' + k - 1) ? 'a' : (s[i] == 'a' ? 'a' : s[i] - 1);
string dp[2][2];
dp[0][0] = s; int cur = 0;
forn(i,0,n-1) {
cur ^= 1;
dp[0][cur] = dp[1][cur] = "";
if(!dp[0][!cur].empty()) {
string& sta = dp[0][!cur];
Trs(dp[0][cur], sta);
if(i > 0) {
swap(sta[i - 1], sta[i]);
Trs(dp[0][cur], sta);
swap(sta[i - 1], sta[i]);
}
if(i + 1 < n) {
swap(sta[i], sta[i + 1]);
Trs(dp[1][cur], sta);
swap(sta[i], sta[i + 1]);
}
sta[i] = trans[i];
Trs(dp[0][cur], sta);
}
if(!dp[1][!cur].empty()) {
string& sta = dp[1][!cur];
Trs(dp[0][cur], sta);
if(i > 1) {
swap(sta[i - 1], sta[i - 2]);
Trs(dp[0][cur], sta);
swap(sta[i - 1], sta[i - 2]);
}
sta[i - 1] = trans[i];
Trs(dp[0][cur], sta);
}
}
cout << dp[0][cur] << endl;
}
return 0;
}// OJ:: LG |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
char down(char c, int k) {
if (c == 'a') return (char)('a' + k-1);
return (char)(c-1);
}
char up(char c, int k) {
if (c-'a' == k-1) return 'a';
return (char)(c+1);
}
void solve() {
int n, k; cin >> n >> k;
string s; cin >> s;
vector<vector<string>> dpTable(n+1, vector<string>(2, s));
rep(i,0,n) rep(offset,0,2) {
if (i == 0 && offset) continue;
string prev = dpTable[i][offset];
string best = prev;
char c = best[i-offset];
c = min({down(c, k), up(c, k), c});
best[i-offset] = c;
if (i-offset != 0) {
string temp = prev;
swap(temp[i-offset], temp[i-offset-1]);
best = min(best, temp);
}
dpTable[i+1][0] = min(dpTable[i+1][0], best);
if (!offset && i != n-1) {
string temp = prev;
swap(temp[i], temp[i+1]);
dpTable[i+1][1] = temp;
}
}
cout << min(dpTable[n][0], dpTable[n][1]) << endl;
}
int main() {
cin.sync_with_stdio(0); cin.tie(0);
cin.exceptions(cin.failbit);
int t; cin >> t;
while(t--) solve();
}
|
#pragma GCC optimize(2)
#include<iostream>
#include<cstdio>
#include<cstring>
#define N 555
#define upmin(_a,_b) _a=min(_a,_b)
using namespace std;
namespace ywy{
typedef unsigned char byte;
void sget(char *s){
int n=1;char c;while((c=getchar())||23333)if(c>='a'&&c<='z')break;
s[n]=c-'a';n++;while((c=getchar())||23333){
if(c>='a'&&c<='z')s[n]=c-'a',n++;else return;
}
}char str[N],anss[N];int dp[N][2];
inline int getb(int x,int bit){
byte *p=(byte*)&x;return(p[bit]);
}
inline int setb(int x,int bit,int y){
byte *p=(byte*)&x;p[bit]=y;return(x);
}
inline int xchg(int x,int i,int j){
byte *p=(byte*)&x;swap(p[i],p[j]);return(x);
}
void ywymain(){
int t;cin>>t;while(t){
t--;int n,k;cin>>n>>k;sget(str);str[n+1]=str[n+2]=0;
memset(dp,0x7f,sizeof(dp));dp[0][0]=str[1];
for(register int i=1;i<=n;i++){
int minn;if(i>3){
minn=min(getb(dp[i-1][0],3),getb(dp[i-1][1],3));
}else minn=0;if(i>3)putchar(minn+'a');
if(getb(dp[i-1][0],3)==minn){//now str[i] is on bit0
int me=(dp[i-1][0]<<8)|str[i+1];
upmin(dp[i][0],me);
upmin(dp[i][0],setb(me,1,(str[i]+1)%k));
upmin(dp[i][0],setb(me,1,(str[i]+k-1)%k));
if(i!=1)upmin(dp[i][0],xchg(me,1,2));
if(i!=n)upmin(dp[i][1],xchg(me,0,1));
}if(getb(dp[i-1][1],3)==minn){//now str[i] is on bit1
int me=(dp[i-1][1]<<8)|str[i+1];upmin(dp[i][0],me);
upmin(dp[i][0],setb(me,2,(str[i]+1)%k));
upmin(dp[i][0],setb(me,2,(str[i]+k-1)%k));
if(i-1!=1)upmin(dp[i][0],xchg(me,2,3));
upmin(dp[i][0],xchg(me,1,2));
}
}int ans=min(dp[n][0],dp[n][1]);if(n==1){
putchar(getb(ans,1)+'a');
}if(n==2){
putchar(getb(ans,2)+'a');putchar(getb(ans,1)+'a');
}if(n>=3){
putchar(getb(ans,3)+'a');putchar(getb(ans,2)+'a');putchar(getb(ans,1)+'a');
}cout<<endl;
}
}
}
int main(){
ywy::ywymain();return(0);
} |
#include <bits/stdc++.h>
using namespace std;
int w, n, k, pos;
string s;
bool jo(int a) {
return s[a]-k+1=='a';
}
int main()
{
ios_base::sync_with_stdio(false);
cin >> w;
while(w--) {
cin >> n >> k >> s;
for (int i=0; i<n;) {
pos=i;
if (s[i]=='a' || s[i]=='b' || jo(i)) {
s[i]='a';
i++;
continue;
}
if (i+1<n && jo(i+1)) {
s[i+1]='a';
swap(s[i], s[i+1]);
i+=2;
}
else {
if (i+1<n && s[i+1]<s[pos]) pos=i+1;
if (i+2<n && s[i+2]+1<s[pos]) pos=i+2;
if (s[pos]=='a' || pos==i+2) s[i]--;
else s[pos]--;
if (pos==i+1) swap(s[i], s[i+1]);
if (pos==i+2) swap(s[i+2], s[i+1]), swap(s[i], s[i+1]);
i=pos+1;
}
while(i<n) {
if (i+1<n && s[i+1]<min(s[i-1], s[i])) swap(s[i+1], s[i]), swap(s[i-1], s[i]), i+=2;
else if (s[i]<s[i-1]) swap(s[i], s[i-1]), i++;
else break;
}
}
//cout << "valasz ";
cout << s << "\n";
}
return 0;
}
/*
1
5 7
eabba
*/
/*
6
4 2
bbab
7 5
cceddda
6 5
ecdaed
7 4
dcdbdaa
8 3
ccabbaca
5 7
eabba
*/
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
struct pii { ll z; int y; };
int main() {
ios::sync_with_stdio(0);cin.tie(0);
int TC;
cin>>TC;
while(TC--) {
int N, M;
string S;
cin>>N>>M>>S;
auto f=[&](char c) {
return c=='a'+M-1 ? 'a' : char(c-(c!='a'));
};
for(int i=0, p=1; i<N; i++) {
char a=p ? f(S[i]) : S[i];
char b=i+1<N ? p ? f(S[i+1]) : S[i+1] : 'z';
if(i+2<N && S[i+2]<min(a, b)) {
cout<<S[i+2]<<a;
S[i+2]=S[i+1];
p=0;
i+=1;
} else if(b<a) {
S[i+1]=b==S[i+1] ? a : S[i];
cout<<b;
p=0;
} else {
cout<<a;
p=1;
}
}
cout<<'\n';
}
} |
#include <bits/stdc++.h>
using namespace std;
#define per(i,a,b) for(int i=(b)-1;i>=a;i--)
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define de(x) cout<<#x<<" = "<<x<<"\n"
#define dd(x) cout<<#x<<" = "<<x<<" "
#define mes(p) memset(p,0,sizeof(p))
#define all(x) x.begin(),x.end()
#define rson mid+1,r,rt<<1|1
#define sz(x) (int)x.size()
#define lson l,mid,rt<<1
#define mp make_pair
#define pb push_back
//#define ls (rt<<1)
//#define rs (ls|1)
#define se second
#define fi first
typedef pair <int ,int > pii;
typedef pair <double, double> pdd;
typedef vector <int > vi;
typedef long long ll;
typedef double db;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
const int mod = 1e9+7;
const db eps = 1e-10;
const int maxn=2e5+5;
const double pi = acos(-1);
const int N = 505 + 6;
//int a[N], s[N];
string dp[N];
string s;
int main(){
int T;
cin >> T;
while(T--){
int n, k;
cin >> n >> k;
cin >> s;
dp[0] = "";
rep(i, 1, n + 3) dp[i] = dp[i - 1] + 'z';
rep(i, 0, n){
char c = s[i];
char _c = (s[i] - 1 - 'a' + k)%k + 'a';
char c_ = (s[i] + 1 - 'a')%k + 'a';
dp[i + 1] = min(dp[i + 1], dp[i] + min(_c, c_));
if(i == 0 || i == n - 1)
dp[i + 1] = min(dp[i + 1], dp[i] + c);
if(i){
string str = dp[i] + c;
swap(str[i], str[i - 1]);
dp[i + 1] = min(dp[i + 1], str);
}
if(i >= n - 1) continue;
char C = s[i + 1];
char _C = (s[i + 1] - 1 - 'a' + k) % k + 'a';
char C_ = (s[i + 1] + 1 - 'a') % k + 'a';
dp[i + 2] = min(dp[i + 2], dp[i] + min(_C, C_) + c);
if(i){
string str = dp[i];
char p = str[i - 1];
str[i - 1] = C;
str = str + p + c;
dp[i + 2] = min(dp[i + 2], str);
}
}
cout << dp[n] << "\n";
}
return 0;
} |
#include <bits/stdc++.h>
#define forr(i,a,b) for(int i=(a);i<(b);i++)
#define forn(i,n) forr(i,0,n)
#define dforn(i,n) for(int i=n-1;i>=0;i--)
#define forall(it,v) for(auto it=v.begin();it!=v.end();it++)
#define sz(c) ((int)c.size())
#define rsz resize
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define fst first
#define snd second
#ifdef ANARAP
#else
#endif
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
int main()
{
#ifdef ANARAP
freopen("input.in", "r", stdin);
//freopen("output.out", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
forn(T,t)
{
int n,k;
string s,ans="";
cin >> n >> k >> s;
int i = 0;
while(i < n)
{
set<pair<string,char>> ss;
string auxs = "$$";
//cout << i << ":\n";
if(i > 0 && (s[i] < ans.back() || (i+1 < n && s[i+1] < ans.back())))
{
if(i+1 < n && s[i+1] < s[i])
{
swap(s[i+1], ans.back());
ans.pb(s[i+1]);
ans.pb(s[i]);
i+=2;
//cout << "special 2";
}
else
{
swap(s[i], ans.back());
ans.pb(s[i]);
i++;
//cout << "special 1";
}
continue;
}
auxs[0] = s[i];
ss.insert(mp(auxs, '$'));
auxs[0] = s[i]-1;
if(auxs[0] < 'a') auxs[0] = 'a'+k-1;
ss.insert(mp(auxs, '$'));
auxs[0] = s[i]+1;
if(auxs[0] > 'a'+k-1) auxs[0] = 'a';
ss.insert(mp(auxs, '$'));
if(i+1 < n)
{
auxs[0] = s[i+1];
ss.insert(mp(auxs, s[i]));
auxs[0] = s[i+1]-1;
if(auxs[0] < 'a') auxs[0] = 'a'+k-1;
ss.insert(mp(auxs, s[i]));
auxs[0] = s[i+1]+1;
if(auxs[0] > 'a'+k-1) auxs[0] = 'a';
ss.insert(mp(auxs, s[i]));
auxs[0] = s[i+1];
char c = s[i];
if(s[i] == 'a'+k-1) c = 'a';
else if(s[i] > 'a') c--;
ss.insert(mp(auxs, c));
}
if(i+2 < n)
{
auxs[0] = s[i+2];
char c = s[i+1];
auxs[1] = s[i];
if(s[i] == 'a'+k-1) auxs[1] = 'a';
else if(s[i] > 'a') auxs[1]--;
ss.insert(mp(auxs, c));
}
pair<string,char> auxp = *ss.begin();
ans.pb(auxp.fst[0]);
i++;
//cout << "found " << auxs << '\n';
//cout << i << ' ' << ans << '\n';
if(auxp.fst[1] != '$')
{
ans.pb(auxp.fst[1]);
i++;
//cout << i << ' ' << ans << '\n';
}
if(auxp.snd != '$')
{
ans.pb(auxp.snd);
i++;
}
//cout << i << ' ' << ans << '\n';
}
assert(sz(ans) == n);
cout << ans << '\n';
}
return 0;
}
|
/*
aabacad
dcdbdaa
acdbdaa
adcbdaa
aacbdaa
aabcdaa
aabcada
aabacda
aabacad
*/
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int mod=1e9+7;
const int maxm=5e2+10;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55]; int f, qr;
// getchar
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
// print the remaining part
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
// putchar
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<typename A>
inline bool read (A &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;else if(c==EOF)return 0;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15); x *= f;
return 1;
}
inline bool read (char &x) {
while((x=gc())==' '||x=='\n' || x=='\r');
return x!=EOF;
}
inline bool read(char *x){
while((*x=gc())=='\n' || *x==' '||*x=='\r');
if(*x==EOF)return 0;
while(!(*x=='\n'||*x==' '||*x=='\r'||*x==EOF))*(++x)=gc();
*x=0;
return 1;
}
template<typename A,typename ...B>
inline bool read(A &x,B &...y){
return read(x)&&read(y...);
}
template<typename A>
inline bool write (A x) {
if (!x) putc ('0'); if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
return 0;
}
inline bool write (char x) {
putc(x);
return 0;
}
inline bool write(const char *x){
while(*x){putc(*x);++x;}
return 0;
}
inline bool write(char *x){
while(*x){putc(*x);++x;}
return 0;
}
template<typename A,typename ...B>
inline bool write(A x,B ...y){
return write(x)||write(y...);
}
//no need to call flush at the end manually!
struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
}
using io :: read;
using io :: putc;
using io :: write;
char s[maxm];
string dp[maxm];
string Min(string s1,string s2)
{
int n=s1.length(),m=s2.length(),flag=0;
for(int i=0;i<min(n,m);i++)
{
if(s1[i]==s2[i]) continue;
if(s1[i]>s2[i]) flag=1;
else flag=-1;
break;
}
if(flag==0) return n>m?s2:s1;
if(flag==1) return s2;
return s1;
}
int main()
{
int T;
read(T);
while(T--)
{
int n,k;
read(n,k);
read(s+1);
//int n=strlen(s+1);
dp[1]=s[1];
if(s[1]=='a'+k-1||s[1]=='a') dp[1]="a";
else dp[1][0]--;
//cout<<"dp[1]="<<dp[1]<<endl;
for(int i=2;i<=n;i++)
{
string temp="a",t1="a";
t1[0]=s[i];
if(s[i]=='a'+k-1||s[i]=='a') t1="a";
else t1[0]--;
dp[i]=dp[i-1]+t1;
temp=dp[i-1].substr(0,i-2)+s[i]+dp[i-1][i-2];
dp[i]=Min(dp[i],temp);
temp=dp[i-2]+t1+s[i-1];
dp[i]=Min(dp[i],temp);
if(i>2)
{
temp=dp[i-2].substr(0,i-3)+s[i]+dp[i-2][i-3]+s[i-1];
dp[i]=Min(dp[i],temp);
}
//cout<<"dp["<<i<<"]="<<dp[i]<<endl;
}
for(int i=0;i<n;i++) printf("%c",dp[n][i]);
printf("\n");
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int maxn = 500 + 5;
int T, n, k;
string dp[2];
char str[maxn];
int cur = 0;
char idx(char ch)
{
int id = ch - 'a';
if (id + 1 == k || id == 0) return 'a';
return ch - 1;
}
int main()
{
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &k);
scanf("%s", str + 1);
cur = 0;
dp[0].clear(); dp[1].clear();
for (int i = 1; i <= n; ++i) {
string now;
int sz = dp[cur].size();
for (int j = min(3, sz); j >= 1; --j) {
now.push_back(dp[cur][sz - j]);
}
//修改当前字母
string best = now;
best.push_back(idx(str[i]));
if (i > 1) {
//向左交换一次
char c = now.back(); now.pop_back();
now.push_back(str[i]);
now.push_back(c);
if (now < best) best = now;
//i - 1向右交换一次，并且第i次更新值
now.clear();
sz = dp[cur^1].size();
for (int j = min(2, sz); j >= 1; --j) {
now.push_back(dp[cur^1][sz - j]);
}
now.push_back(idx(str[i]));
now.push_back(str[i - 1]);
if (now < best) best = now;
//i - 1向右交换一次，并且第i次向左交换一次
if (i > 2) {
now.clear();
sz = dp[cur^1].size();
for (int j = min(2, sz); j >= 1; --j) {
now.push_back(dp[cur^1][sz - j]);
}
c = now.back(); now.pop_back();
now.push_back(str[i]);
now.push_back(c);
now.push_back(str[i - 1]);
if (now < best) best = now;
}
}
if (dp[cur^=1].size()) dp[cur].pop_back();
if (dp[cur].size()) dp[cur].pop_back();
dp[cur] += best;
}
cout << dp[cur] << endl;
}
} |
#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
const int N=1E6+10;
int read()
{
int a=0;char b=1,c;
do if((c=getchar())==45)b=-1;while(c<48||c>57);
do a=(a<<3)+(a<<1)+(c&15);while((c=getchar())>47&&c<58);
return a*b;
}
void write(int x)
{
if(x<0)putchar('-'),x=-x;
char a[10],s=0;
do a[s++]=x%10|48;while(x/=10);
do putchar(a[--s]);while(s);
}
char a[510],m;
char f(char c)
{
if(c==97||c==m)return 97;
return c-1;
}
int main()
{
for(int x=read();x--;)
{
int n=read();
m=read()+96;
scanf("%s",a+1);
for(int i=1,j=1;i<=n;++i)
{
char k=0,mn=a[i];
if(j&&f(a[i])<mn)mn=f(a[i]),k=1;
if(i<n&&a[i+1]<mn)mn=a[i+1],k=2;
if(j&&i<n&&f(a[i+1])<mn)mn=f(a[i+1]),k=3;
if(i<n-1&&a[i+2]<mn)mn=a[i+2],k=4;
if(!k)j=1;
else if(k==2)a[i+1]=j?f(a[i]):a[i],j=0;
else if(k==3)a[i+1]=a[i],j=0;
else if(k==4)a[i+2]=a[i+1],a[i+1]=j?f(a[i]):a[i],j=0;
a[i]=mn;
if(k==4)++i;
}
puts(a+1);
}
}
|
#include <bits/stdc++.h>
#define IO_OP std::ios::sync_with_stdio(0); std::cin.tie(0);
#define F first
#define S second
#define V vector
#define PB push_back
#define MP make_pair
#define EB emplace_back
#define ALL(v) (v).begin(), (v).end()
#define debug(x) cerr << "Line(" << __LINE__ << ") -> " << #x << " is " << x << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef V<int> vi;
const int INF = 1e9 + 7;
void solve() {
int n, k;
string s;
cin >> n >> k >> s;
V<string> dp(n + 1, string(1, char('z' + 1)));
dp[0] = "";
for(int i = 1; i <= n; i++) {
char c = s[i - 1];
char cc = min({c, char('a' + (c - 'a' + 1) % k), char('a' + (c - 'a' + k - 1) % k)});
// D or U
dp[i] = min(dp[i], dp[i - 1] + cc);
// L
if(i >= 2)
dp[i] = min(dp[i], dp[i - 1].substr(0, i - 2) + c + dp[i - 1].back());
// R + (U or D)
if(i >= 2)
dp[i] = min(dp[i], dp[i - 2] + cc + s[i - 2]);
// RL
if(i >= 3)
dp[i] = min(dp[i], dp[i - 2].substr(0, i - 3) + s[i - 1] + dp[i - 2].back() + s[i - 2]);
}
cout << dp[n] << '\n';
}
signed main()
{
IO_OP;
int t;
cin >> t;
while(t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int k;
char bestChar(char c)
{
return c == 'a' || c - 'a' == k - 1 ? 'a' : c - 1;
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int test;
cin >> test;
while (test--)
{
int n;
string s;
cin >> n >> k >> s;
for (int i = 0; i < n;)
if (i && i + 1 < n && s[i + 1] < s[i] && s[i + 1] < s[i - 1])
{
swap(s[i], s[i + 1]);
swap(s[i], s[i - 1]);
i += 2;
}
else if (i && s[i] < s[i - 1])
{
swap(s[i], s[i - 1]);
i++;
}
else if (i + 2 < n && s[i + 2] < min(bestChar(s[i]), bestChar(s[i + 1])))
{
s[i] = bestChar(s[i]);
i++;
}
else if (i + 1 < n && bestChar(s[i + 1]) < bestChar(s[i]))
{
if (s[i + 1] == 'a')
s[i] = bestChar(s[i]);
swap(s[i], s[i + 1]);
s[i] = bestChar(s[i]);
i += 2;
}
else
{
s[i] = bestChar(s[i]);
i++;
}
cout << s << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, k;
string s;
string dp[N];
void solve() {
cin >> n >> k >> s;
for (int i = 1; i <= n; i++)
dp[i] = char('z' + 1);
for (int i = 0; i < n; i++) {
int c = s[i] - 'a';
int nc = min({c, (c + 1) % k, (c + k - 1) % k});
dp[i + 1] = min(dp[i + 1], dp[i] + char('a' + nc));
if (i > 0) {
dp[i + 1] = min(dp[i + 1], dp[i - 1] + char('a' + nc) + s[i - 1]);
dp[i + 1] = min(dp[i + 1], dp[i].substr(0, i - 1) + s[i] + dp[i].back());
}
if (i > 1) {
dp[i + 1] = min(dp[i + 1], dp[i - 1].substr(0, i - 2) + s[i] + dp[i - 1].back() + s[i - 1]);
}
}
cout << dp[n] << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
} |
#include <bits/stdc++.h>
using namespace std;
#define int ll
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<double> vd;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<pi> vp;
typedef vector<pl> vpl;
int k;
char fl(char c){
if (c == 'a'){
c = 'a' + k - 1;
} else {
--c;
}
return c;
}
char fr(char c){
if (c == 'a' + k - 1)
c = 'a';
else
++c;
return c;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int t;
cin >> t;
for (int e = 0; e < t; ++e){
int n;
cin >> n >> k;
string s;
cin >> s;
vs dp(n+1, "{");
dp[0]="";
for (int i = 0; i < n; ++i){
char L = fl(s[i]), R = fr(s[i]);
char C = min(L, R);
dp[i+1] = min(dp[i+1], dp[i] + C);
dp[i+1] = min(dp[i+1], dp[i] + s[i]);
if (i){
dp[i+1] = min(dp[i+1], dp[i-1] + C + s[i-1]);
dp[i+1] = min(dp[i+1], dp[i].substr(0, i - 1) + s[i] + dp[i].back());
}
if (i > 1){
dp[i+1] = min(dp[i+1], dp[i-1].substr(0, i - 2) + s[i] + dp[i-1].back() + s[i-1]);
}
}
cout << dp[n] << '\n';
}
} |
#include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
char ud(char c, bool isU, int k) {
if (isU) {
c++;
if (c >= 'a' + k) c -= k;
} else {
c--;
if (c < 'a') c += k;
}
return c;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int ttt;
cin >> ttt;
while (ttt--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<string> dp;
string temp = "";
dp.push_back(temp);
for (int i = 0; i < n; i++) {
temp.push_back('z');
dp.push_back(temp);
}
for (int i = 0; i < n; i++) {
//cout << dp[i] << endl;
string temp = dp[i];
temp.push_back(ud(s[i], true, k));
if (temp.compare(dp[i + 1]) < 0) {
dp[i + 1] = temp;
}
temp.pop_back();
temp.push_back(ud(s[i], false, k));
if (temp.compare(dp[i + 1]) < 0) {
dp[i + 1] = temp;
}
temp.pop_back();
if (i) {
temp.push_back(s[i]);
swap(temp[i], temp[i - 1]);
if (temp.compare(dp[i + 1]) < 0) {
dp[i + 1] = temp;
}
temp = dp[i];
}
if (i < n - 1) {
if (i > 0) {
//cout << temp << endl;
temp.push_back(s[i]);
temp.push_back(s[i + 1]);
swap(temp[i], temp[i + 1]);
swap(temp[i], temp[i - 1]);
//cout << i << temp << endl;
if (temp.compare(dp[i + 2]) < 0) {
dp[i + 2] = temp;
}
}
temp = dp[i];
temp.push_back(ud(s[i + 1], true, k));
temp.push_back(s[i]);
if (temp.compare(dp[i + 2]) < 0) {
dp[i + 2] = temp;
}
temp = dp[i];
temp.push_back(ud(s[i + 1], false, k));
temp.push_back(s[i]);
if (temp.compare(dp[i + 2]) < 0) {
dp[i + 2] = temp;
}
temp = dp[i];
temp.push_back(s[i]);
temp.push_back(s[i + 1]);
if (temp.compare(dp[i + 2]) < 0) {
dp[i + 2] = temp;
}
}
if (i == 0 || i == n - 1) {
temp = dp[i];
temp.push_back(s[i]);
if (temp.compare(dp[i + 1]) < 0) {
dp[i + 1] = temp;
}
}
}
cout << dp[n] << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500;
string dp1[MAXN + 1];
string dp2[MAXN + 1];
void relax(string& a, const string& b)
{
if (a.empty() || b < a)
a = b;
}
char improve(char c, int k)
{
if (c == 'a')
return c;
else if (c == 'a' + k - 1)
return 'a';
return (char) (c - 1);
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--)
{
int n, k;
string s;
cin >> n >> k >> s;
fill(dp1, dp1 + n + 1, "");
fill(dp2, dp2 + n + 1, "");
dp1[1] = improve(s[0], k);
dp2[1] = s[0];
for (int i = 1; i <= n - 1; i++)
{
relax(dp1[i + 1], dp1[i] + improve(s[i], k));
relax(dp1[i + 1], dp1[i].substr(0, i - 1) + s[i] + dp1[i][i - 1]);
relax(dp2[i + 1], dp1[i] + s[i]);
relax(dp1[i + 1], dp2[i].substr(0, i - 1) + improve(s[i], k) + dp2[i][i - 1]);
if (i >= 2)
relax(dp1[i + 1], dp2[i].substr(0, i - 2) + s[i] + dp2[i][i - 2] + dp2[i][i - 1]);
relax(dp1[i + 1], dp2[i] + s[i]);
}
cout << dp1[n] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
ios::sync_with_stdio(0);cin.tie(0);
int TC;
cin>>TC;
while(TC--) {
int N, M;
string S;
cin>>N>>M>>S;
auto f=[&](char c) {
return c=='a'+M-1 ? 'a' : char(c-(c!='a'));
};
for(int i=0, p=1; i<N; i++) {
char a=p ? f(S[i]) : S[i];
char b=i+1<N ? p ? f(S[i+1]) : S[i+1] : 'z';
p=0;
if(i+2<N && S[i+2]<min(a, b)) {
cout<<S[i+2]<<a;
S[i+2]=S[i+1];
i++;
} else if(b<a) {
cout<<b;
S[i+1]=b==S[i+1] ? a : S[i];
} else {
cout<<a;
p=1;
}
}
cout<<'\n';
}
} |
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
#define int long long
#define maxn (555)
string d[maxn];
char s[maxn];
signed main()
{
int t; cin >> t; while(t--) {
int n, k; cin >> n >> k;
scanf("%s", s + 1);
for(int i = 0; i <= n; i++) d[i] = "";
for(int i = 1; i <= n; i++) {
// printf("# i = %lld, d[i][0].size() = %lld\n", i, (int)d[i].size());
// U, D, 0
char c = s[i];
char x = 'a' + (c - 'a' + k - 1) % k;
char y = 'a' + (c - 'a' + 1) % k;
c = x < c? x: c;
c = y < c? y: c;
string t = d[i-1] + c;
// cout << "UD0: " << t << endl;
if(d[i].empty() || t < d[i]) d[i] = t;
// L
if(i-1 >= 1) {
string t = d[i-1];
char c = t.back(); t.pop_back();
t += s[i];
t += c;
if(d[i].empty() || t < d[i]) d[i] = t;
// cout << "L : " << t << endl;
}
// R
if(i+1 <= n) {
char c = s[i+1];
char x = 'a' + (c - 'a' + k - 1) % k;
char y = 'a' + (c - 'a' + 1) % k;
c = x < c? x: c;
c = y < c? y: c;
string t = d[i-1];
t += c;
t += s[i];
if(d[i+1].empty() || t < d[i+1]) d[i+1] = t;
if(i-1 >= 1) {
string t = d[i-1];
char c = t.back(); t.pop_back();
t += s[i+1];
t += c;
t += s[i];
if(d[i+1].empty() || t < d[i+1]) d[i+1] = t;
}
// cout << "R : " << t << endl;
}
// cout << "FIN: " << d[i][0] << endl;
}
cout << d[n] << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int tc;
int n,k;
string s;
char best(char x)
{
if(x=='a') return x;
else if(x=='a'+(k-1)) return 'a';
return x-1;
}
int main()
{
ios_base::sync_with_stdio(false);
cin>>tc;
for(int i_=1;i_<=tc;i_++)
{
cin>>n>>k;
cin>>s;
int curr=0;
bool fs=false;
while(curr<n)
{
if( (!(curr!=0 && s[curr]<s[curr-1] && s[curr]<=s[curr+1])) && curr+1!=n && ((curr!=0 && s[curr]>s[curr+1] && s[curr+1]<s[curr-1]) || (best(s[curr])>best(s[curr+1]) && (curr+2==n || best(s[curr+1])<=s[curr+2]) && best(s[curr+1])!=s[curr+1])))
{
swap(s[curr],s[curr+1]);
fs=true;
}
else
{
if(curr!=0 && s[curr]<s[curr-1] && (curr+1==n || s[curr]<=s[curr+1])) swap(s[curr],s[curr-1]);
else s[curr]=best(s[curr]);
curr+=1+fs;
fs=false;
}
}
cout<<s<<endl;
}
return 0;
}
|
#include<algorithm>
#include<iostream>
#include<cstring>
#include<iomanip>
#include<sstream>
#include<cstdio>
#include<string>
#include<vector>
#include<bitset>
#include<queue>
#include<cmath>
#include<stack>
#include<set>
#include<map>
#define rep(i,x,n) for(int i=x;i<=n;i++)
#define per(i,n,x) for(int i=n;i>=x;i--)
#define sz(a) int(a.size())
#define rson mid+1,r,p<<1|1
#define pii pair<int,int>
#define lson l,mid,p<<1
#define ll long long
#define pb push_back
#define mp make_pair
#define se second
#define fi first
using namespace std;
const double eps=1e-8;
const int mod=1e9+7;
const int N=1e5+10;
const int inf=1e9;
int t,n,k;
char s[510];
string dp[510];
int main(){
ios::sync_with_stdio(false);
//freopen("in","r",stdin);
cin>>t;
while(t--){
cin>>n>>k;
cin>>s+1;
rep(i,0,n) dp[i].clear();
rep(i,1,n) dp[i].pb('~');
rep(i,0,n-1){
char c=s[i+1];
c=min({c,char((s[i+1]-'a'+k-1)%k+'a'),char((s[i+1]-'a'+1)%k+'a')});
dp[i+1]=min(dp[i+1],dp[i]+c);
dp[i+1]=min(dp[i+1],dp[i].substr(0,i-1)+s[i+1]+dp[i].back());
c=min({s[i+2],char((s[i+2]-'a'+k-1)%k+'a'),char((s[i+2]-'a'+1)%k+'a')});
dp[i+2]=min(dp[i+2],dp[i]+c+s[i+1]);
if(i==0) continue;
dp[i+2]=min(dp[i+2],dp[i].substr(0,i-1)+s[i+2]+dp[i].back()+s[i+1]);
}
cout<<dp[n]<<endl;
}
return 0;
}
/*
3 11 2
2 33 1
*/
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int sz = 505;
int n, k;
char cz;
bool vis[sz][27][27];
string s, dp[sz][27][27];
char cnv(char x) {
if(x == 'a' || x == cz) return 'a';
return x - 1;
}
string fnc(int i, char pch, char cch) {
if(i >= n) return string(1, pch);
int p = pch - 'a' + 1, c = cch - 'a' + 1;
if(vis[i][p][c]) return dp[i][p][c];
vis[i][p][c] = 1;
string &now = dp[i][p][c];
now.assign(n-i+1, cz);
char nch = s[i+1];
if(i < n-1) {
if(pch < cch && pch < nch) {
if(cnv(cch) < cnv(nch)) now = pch + fnc(i+1, cnv(cch), nch); // 1
else if(cnv(cch) < cnv(nch)) now = pch + (cnv(nch) + fnc(i+2, cch, s[i+2])); // 3
else {
now = pch + fnc(i+1, cnv(cch), nch); // 1
now = min(now, pch + (cnv(nch) + fnc(i+2, cch, s[i+2]))); // 3
}
}
else if(cch < pch && cch < nch) now = cch + fnc(i+1, pch, nch); // 2
else if(nch < cch && nch < pch) now = nch + (pch + fnc(i+2, cch, s[i+2])); // 4
else if(pch == cch && cch == nch) now = pch + fnc(i+1, cnv(cch), nch); // 1
else {
if(pch <= cch) now = pch + fnc(i+1, cnv(cch), nch); // 1
else now = cch + fnc(i+1, pch, nch); // 2
if(pch <= nch) now = min(now, pch + (cnv(nch) + fnc(i+2, cch, s[i+2]))); // 3
else now = min(now, nch + (pch + fnc(i+2, cch, s[i+2]))); // 4
}
}
else {
if(pch <= cch) now = pch + fnc(i+1, cnv(cch), nch);
else now = cch + fnc(i+1, pch, nch);
}
return now;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
int t;
cin >> t;
while(t--) {
cin >> n >> k >> s;
s += 'z'; cz = 'a' + k - 1;
memset(vis, 0, sizeof(vis));
cout << fnc(0, 'a', s[0]).substr(1, n) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define dbg(...) dbs(#__VA_ARGS__, __VA_ARGS__)
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
int idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
void debug(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a)
cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
auto bestChar = [&](char ch) -> char {
int offset = ch - 'a';
offset = min(offset, (offset + 1) % k);
offset = min(offset, (offset + k - 1) % k);
return 'a' + offset;
};
vector<string> dp(n, string(n, 'z'));
dp[0] = bestChar(s[0]);
for (int i = 1; i < n; ++i) {
string prefix = dp[i - 1];
// U/D/nothing at i
dp[i] = prefix + bestChar(s[i]);
// L at i
prefix.pop_back();
dp[i] = min(dp[i], prefix + s[i] + dp[i - 1].back());
// R, (U/D) operation at i - 1, i
prefix = i >= 2 ? dp[i - 2] : "";
dp[i] = min(dp[i], prefix + bestChar(s[i]) + s[i - 1]);
if (i >= 2) {
// R, L operation at i - 1, i
prefix = dp[i - 2];
prefix.pop_back();
dp[i] = min(dp[i], prefix + s[i] + dp[i - 2].back() + s[i - 1]);
}
assert(dp[i].length() == i + 1);
}
cout << dp[n - 1] << "\n";
}
return 0;
} |
#include<iostream>
#include<cstdio>
#include<cstring>
#define N 555
#define upmin(_a,_b) _a=min(_a,_b)
using namespace std;
namespace ywy{
typedef unsigned char byte;
void sget(char *s){
int n=1;char c;while((c=getchar())||23333)if(c>='a'&&c<='z')break;
s[n]=c-'a';n++;while((c=getchar())||23333){
if(c>='a'&&c<='z')s[n]=c-'a',n++;else return;
}
}char str[N],anss[N];int dp[N][2];
inline int getb(int x,int bit){
byte *p=(byte*)&x;return(p[bit]);
}
inline int setb(int x,int bit,int y){
byte *p=(byte*)&x;p[bit]=y;return(x);
}
inline int xchg(int x,int i,int j){
byte *p=(byte*)&x;swap(p[i],p[j]);return(x);
}
void ywymain(){
int t;cin>>t;while(t){
t--;int n,k;cin>>n>>k;sget(str);str[n+1]=str[n+2]=0;
memset(dp,0x7f,sizeof(dp));dp[0][0]=str[1];
for(register int i=1;i<=n;i++){
int minn;if(i>3){
minn=min(getb(dp[i-1][0],3),getb(dp[i-1][1],3));
}else minn=0;if(i>3)putchar(minn+'a');
if(getb(dp[i-1][0],3)==minn){//now str[i] is on bit0
int me=(dp[i-1][0]<<8)|str[i+1];
upmin(dp[i][0],me);
upmin(dp[i][0],setb(me,1,(str[i]+1)%k));
upmin(dp[i][0],setb(me,1,(str[i]+k-1)%k));
if(i!=1)upmin(dp[i][0],xchg(me,1,2));
if(i!=n)upmin(dp[i][1],xchg(me,0,1));
}if(getb(dp[i-1][1],3)==minn){//now str[i] is on bit1
int me=(dp[i-1][1]<<8)|str[i+1];upmin(dp[i][0],me);
upmin(dp[i][0],setb(me,2,(str[i]+1)%k));
upmin(dp[i][0],setb(me,2,(str[i]+k-1)%k));
if(i-1!=1)upmin(dp[i][0],xchg(me,2,3));
upmin(dp[i][0],xchg(me,1,2));
}
}int ans=min(dp[n][0],dp[n][1]);if(n==1){
putchar(getb(ans,1)+'a');
}if(n==2){
putchar(getb(ans,2)+'a');putchar(getb(ans,1)+'a');
}if(n>=3){
putchar(getb(ans,3)+'a');putchar(getb(ans,2)+'a');putchar(getb(ans,1)+'a');
}cout<<endl;
}
}
}
int main(){
ywy::ywymain();return(0);
} |
#include<iostream>
#include<string>//the sourse of string
#include <algorithm>//the sourse of swap
#define N1 510
#define min(a,b) (a<b?a:b)
using namespace std;
int n,k;
string str,ans;//the definition of a string type
char D(char c)
{
return 'a'+((c-'a')-1+k)%k;
}
char U(char c)
{
return 'a'+((c-'a')+1)%k;
}
char best(char c)
{
return min(c,min(D(c),U(c)));
}
int main()
{
int t,idx,res;
char pre;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&k);
cin>>str;
ans="";
idx=0;
while(idx<n)
{
ans+=str[idx];//the plus of string
if(idx>=1)
{
pre=ans[idx-1];
res=0;
if(ans[idx]<ans[idx-1])
{
ans[idx-1]=ans[idx];
res=1;
}
if(idx<n-1&&str[idx+1]<ans[idx-1])
{
ans[idx-1]=str[idx+1];
ans+=str[idx];
res=2;
}
if(res)
ans[idx]=pre;
if(res==1)
{
idx++;
continue;
}
else if(res==2)
{
idx+=2;
continue;
}
}
ans[idx]=best(ans[idx]);
res=0;
if(idx+1<n&&best(str[idx+1])<ans[idx])
{
if(best(str[idx+1])==str[idx+1])
{
ans+=str[idx+1];
swap(ans[idx],ans[idx+1]);
}
else
{
ans[idx]=best(str[idx+1]);
ans+=str[idx];
}
res=1;
}
if(idx<n-2&&str[idx+2]<ans[idx])
{
while(ans.length()<idx+3)
ans+='a';
ans[idx]=str[idx+2];
ans[idx+1]=best(str[idx]);
ans[idx+2]=str[idx+1];
res=2;
}
if(res==0)
idx++;
else if(res==1)
idx+=2;
else
idx+=3;
}
cout<<ans<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
int n,k;
int getMin(int x){
if(x == 0) return 1000;
int up = x == 1 ? k : x-1;
int down = x == k ? 1 : x + 1;
return min(x,min(up,down));
}
int state[maxn];
char str[maxn];
int arr[maxn];
void solve(){
for (int i = 1; i <= n ; ++i){
for (int d = 1 ; d <= k ; ++d){
if(state[i] == 1 && d >= arr[i]) break;
if(state[i] == 2){
if(getMin(arr[i]) == d){
arr[i] = d;
break;
}
if(arr[i+1] == d){
arr[i] = getMin(arr[i]);
swap(arr[i],arr[i+1]);
state[i+1] = 1;
break;
}
if(getMin(arr[i+1]) == d){
arr[i+1] = d;
swap(arr[i],arr[i+1]);
state[i+1] = 1;
break;
}
if(arr[i+2] == d){
swap(arr[i],arr[i+1]);
swap(arr[i],arr[i+2]);
arr[i+1] = getMin(arr[i+1]);
state[i+2] = 1;
i++; break;
}
} else {
if(arr[i+1] == d){
swap(arr[i+1],arr[i]);
state[i+1] = 1;
break;
}
if(arr[i+2] == d){
swap(arr[i],arr[i+1]);
swap(arr[i],arr[i+2]);
state[i+2] = 1;
i++; break;
}
}
}
}
}
int main(){
int t;
cin >> t;
while(t--){
cin >> n >> k;
cin >> str + 1;
//int len = strlen(str);
memset(arr,0,sizeof(arr));
memset(state,0,sizeof(state));
for (int i = 1 ; i <= n ; ++i) arr[i] = str[i] - 'a' + 1;
for (int i = 1 ; i <= n ; ++i) state[i] = 2;
solve();
for (int i = 1; i <= n ; ++i){
putchar((arr[i] + 'a' - 1));
}
putchar('\n');
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long t,n,k,pos;
string s;
bool mode;
char best(int pos){
char c=s[pos];
return min({c,char((c-'a'+1)%k+'a'),char(((c-'a'-1)%k+k)%k+'a')});
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cin>>t;
while(t--){
cin>>n>>k>>s;
mode=false;
pos=0;
while(pos<s.size()){
if(mode==false){
if((pos+1>=s.size() || best(pos)<= best(pos+1)) && (pos+2>=s.size() || best(pos)<=s[pos+2])){
s[pos]=best(pos);
pos++;
mode=false;
}else if(pos+2>=s.size() || best(pos+1)<=s[pos+2]){
if(best(pos+1)==s[pos+1]){
s[pos]=best(pos);
swap(s[pos],s[pos+1]);
pos++;
mode=true;
}else{
s[pos+1]=best(pos+1);
swap(s[pos],s[pos+1]);
mode=true;
pos++;
}
}else{
s[pos]=best(pos);
swap(s[pos+1],s[pos+2]);
swap(s[pos],s[pos+1]);
pos+=2;
mode=true;
}
}else{
if((pos+1>=s.size() || s[pos]<=s[pos+1]) && (pos+2>=s.size() || s[pos]<=s[pos+2])){
pos++;
mode=false;
}else if(pos+2>=s.size() || s[pos+1]<=s[pos+2]){
swap(s[pos],s[pos+1]);
pos++;
mode=true;
}else{
swap(s[pos+1],s[pos+2]);
swap(s[pos],s[pos+1]);
pos+=2;
mode=true;
}
}
//cout<<s<<"\n";
//cout<<pos<<" "<<mode<<" ecco \n";
}
cout<<s<<"\n";
}
return 0;
}
|
#pragma GCC optimize("Ofast")
#pragma GCC target ("sse4")
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<cassert>
#include<complex>
#include<numeric>
#include<array>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
constexpr ll mod = 998244353;
const ll INF = mod * mod;
typedef pair<int, int>P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acosl(-1.0);
ll mod_pow(ll x, ll n, ll m = mod) {
ll res = 1;
while (n) {
if (n & 1)res = res * x % m;
x = x * x % m; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint& a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint& a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint& a, modint b) { a.n = ((ll)a.n * b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, ll n) {
if (n == 0)return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
ll inv(ll a, ll p) {
return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
string dp[501];
void solve() {
int n, k; cin >> n >> k;
string s; cin >> s;
rep(i, n + 1) {
dp[i] = "z";
dp[i][0]++;
}
dp[0] = "";
rep(i, n) {
string nex;
int c = s[i] - 'a';
//U
nex = dp[i]; nex.push_back('a'+(c + 1) % k);
dp[i + 1] = min(dp[i + 1], nex);
//D
nex = dp[i]; nex.push_back('a' + (c + k - 1) % k);
dp[i + 1] = min(dp[i + 1], nex);
//L
if (i > 0) {
nex = dp[i];
char memo = nex.back(); nex.pop_back();
nex.push_back(s[i]);
nex.push_back(memo);
dp[i + 1] = min(dp[i + 1], nex);
}
else {
nex = dp[i];
nex.push_back(s[i]);
dp[i + 1] = min(dp[i + 1], nex);
}
//R but nothing
if (i == n - 1) {
nex = dp[i];
nex.push_back(s[i]);
dp[i + 1] = min(dp[i + 1], nex);
}
//RU or RD
if (i + 2 <= n) {
rep(id, 2) {
int z = s[i + 1] - 'a';
if (id == 0)z += 1;
else z += k - 1;
z %= k;
nex = dp[i];
nex.push_back('a' + z);
nex.push_back(s[i]);
dp[i + 2] = min(dp[i + 2], nex);
}
}
//RL
if (i > 0 && i + 2 <= n) {
nex = dp[i];
char memo = nex.back(); nex.pop_back();
nex.push_back(s[i + 1]);
nex.push_back(memo);
nex.push_back(s[i]);
dp[i + 2] = min(dp[i + 2], nex);
}
if (i + 2 <= n) {
//RR
nex = dp[i]; nex.push_back(s[i]); nex.push_back(s[i + 1]);
dp[i + 2] = min(dp[i + 2], nex);
}
}
//rep(i, n)cout << dp[i] << "\n";
cout << dp[n] << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(15);
//init_f();
//init();
//expr();
int t; cin >> t; rep(i, t)
solve();
return 0;
} |
#include<bits/stdc++.h>
#define si(a) scanf("%d",&a)
#define sl(a) scanf("%lld",&a)
#define sd(a) scanf("%lf",&a)
#define sc(a) scanf("%c",&a)
#define ss(a) scanf("%s",a)
#define pi(a) printf("%d\n",a)
#define pl(a) printf("%lld\n",a)
#define pc(a) putchar(a)
#define ms(a) memset(a,0,sizeof(a))
#define repi(i, a, b) for(register int i=a;i<=b;++i)
#define repd(i, a, b) for(register int i=a;i>=b;--i)
#define reps(s) for(register int i=head[s];i;i=Next[i])
#define ll long long
#define ull unsigned long long
#define vi vector<int>
#define pii pair<int,int>
#define mii unordered_map<int,int>
#define msi unordered_map<string,int>
#define lowbit(x) ((x)&(-(x)))
#define ce(i, r) i==r?'\n':' '
#define pb push_back
#define fi first
#define se second
#define all(x) x.begin(),x.end()
#define INF 0x3f3f3f3f
#define pr(x) cout<<#x<<": "<<x<<endl
inline long long ceil_div(long long a, long long b) { return (a + b - 1) / b; }
using namespace std;
inline int qr() {
int f = 0, fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
return f * fu;
}
int T, n, k;
string f[2][2], g;
inline void update(string &a, string &b) {
if (a.empty() || a > b)a = b;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &k);
cin >> f[0][0];
f[0][1].clear(), g = f[0][0];
for (char &c:g) {
if (c == 'a' + k - 1)c = 'a';
else if (c != 'a')c--;
}
// pr(g);
for (int i = 0; i < n; i++) {
int cur = i & 1 ^1;
f[cur][0].clear(), f[cur][1].clear();
if (!f[!cur][0].empty()) {
string &s = f[!cur][0];
update(f[cur][0], s);
if (i) {
swap(s[i - 1], s[i]);
update(f[cur][0], s);
swap(s[i - 1], s[i]);
}
if (i < n - 1) {
swap(s[i], s[i + 1]);
update(f[cur][1], s);
swap(s[i], s[i + 1]);
}
s[i] = g[i];
update(f[cur][0], s);
}
if (!f[!cur][1].empty()) {
string &s = f[!cur][1];
update(f[cur][0], s);
if (i > 1) {
swap(s[i - 1], s[i - 2]);
update(f[cur][0], s);
swap(s[i - 1], s[i - 2]);
}
s[i - 1] = g[i];
update(f[cur][0], s);
}
}
cout << f[n & 1][0] << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
string make(string str,char a)
{
string st = str;
int l = st.length();
char c = st[l - 1];
st[l - 1] = a;
st += c;
return st;
}
bool operator< (string a, string b)
{
for (int i = 0; i < a.length();i++)
{
if (a[i] < b[i]) return true;
if (a[i] > b[i]) return false;
}
return false;
}
int n, k;
char get(char a)
{
if (a == 'a' + k - 1 || a == 'a') return 'a';
else return (char)(a-1);
}
string dp[505][2];
int main()
{
ios::sync_with_stdio(false);
int T;
cin >> T;
for (;T--;)
{
cin >> n >> k;
string str;
cin >> str;
dp[0][0] = "";
if (str[0] == 'a' + k - 1 || str[0] == 'a') dp[0][0] = "a";
else dp[0][0] = str[0] - 1;
dp[0][1] = "";
for (int i = 1; i < n; i++)
{
string st;
dp[i][0] = dp[i - 1][0] + get(str[i]);
dp[i][1] = dp[i - 1][0];
st = dp[i - 1][1] + get(str[i]) + str[i - 1];
if (st < dp[i][0]) dp[i][0] = st;
st = make(dp[i - 1][0],str[i]);
if (st < dp[i][0]) dp[i][0] = st;
if (i > 1)
{
st = make(dp[i - 2][0],str[i]);
st += str[i - 1];
if (st < dp[i][0]) dp[i][0] = st;
}
}
cout << dp[n - 1][0] << endl;
}
} |
#pragma GCC optimize("O3","Ofast","unroll-loops")
#include <bits/stdc++.h>
using namespace std;
string dp[502][2][26];
vector <int> pr[502][2][26];
int32_t main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int t;
cin>>t;
while(t--)
{
int n,k;
cin>>n>>k;
string s;
cin>>s;
char opt[k];
for(int i=0;i<k;++i)
{
opt[i]=min('a'+i,'a'+max(0,min(i-1,(i+1)%k)));
//cout<<i<<" i "<<opt[i]<<" opt[i] "<<endl;
}
for(int i=0;i<=(n+1);++i) for(int j=0;j<2;++j) for(int k=0;k<26;++k) {pr[i][j][k]={-1,-1,-1};dp[i][j][k]="";}
for(int i=n;i<=n;++i)
{
for(int j=1;j<=1;++j)
{
for(int k=0;k<26;++k)
{
dp[i][j][k]=('a'+k);
pr[i][j][k]={-1,-1,-1};
}
}
}
for(int i=(n-1);i>=0;i--)
{
for(int j=0;j<2;++j)
{
for(int k=0;k<26;++k)
{
if(j==0)
{
dp[i][j][k]=opt[s[i]-'a'];
pr[i][j][k]={i+1,j,k};
if((i+1)<n && opt[s[i+1]-'a']<dp[i][j][k][0] && s[i+1]=='a')
{
dp[i][j][k]=s[i+1];
pr[i][j][k]={i+2,1,opt[s[i]-'a']-'a'};
}
else if((i+1)<n && opt[s[i+1]-'a']<dp[i][j][k][0])
{
dp[i][j][k]=opt[s[i+1]-'a'];
pr[i][j][k]={i+2,1,s[i]-'a'};
}
if((i+2)<n && s[i+2]<dp[i][j][k][0])
{
dp[i][j][k]=s[i+2];
dp[i][j][k]+=opt[s[i]-'a'];
pr[i][j][k]={i+3,1,s[i+1]-'a'};
}
/*if((i+2)<n && s[i+2]==dp[i][j][k][0] && s[i]<dp[i][j][k][1])
{
dp[i][j][k]=s[i+2];
dp[i][j][k]+=s[i];
pr[i][j][k]={i+3,1,s[i+1]-'a'};
}*/
for(int k=1;k<26;++k)
{
dp[i][j][k]=dp[i][j][0];
pr[i][j][k]=pr[i][j][0];
}
break;
}
else
{
dp[i][j][k]=('a'+k);
pr[i][j][k]={i,0,0};
if(s[i]<('a'+k))
{
dp[i][j][k]=s[i];
pr[i][j][k]={i+1,j,k};
}
if((i+1)<n && s[i+1]<dp[i][j][k][0])
{
dp[i][j][k]=s[i+1];
dp[i][j][k]+=('a'+k);
pr[i][j][k]={i+2,j,s[i]-'a'};
}
}
}
}
}
if(s.size()>=5)
{
//cout<<dp[4][0][0]<<" dp "<<endl;
//cout<<pr[4][0][0][0]<<' '<<pr[4][0][0][1]<<' '<<pr[4][0][0][2]<<" pr "<<endl;
}
string ans;
vector <int> v={0,0,0};
while(true)
{
ans+=dp[v[0]][v[1]][v[2]];
v=pr[v[0]][v[1]][v[2]];
if(v[0]==(-1))
{
break;
}
}
cout<<ans<<'\n';
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;
#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());
typedef long long ll;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 500;
int n, k;
char s[MAXN + 1];
char ans[MAXN + 1];
char cycimprove(char c) { if (c == 'a' || c == 'a' + k - 1) return 'a'; else return c - 1; }
void solve() {
REP(i, n) ans[i] = '?'; ans[n] = '\0';
int at = 0;
while (at < n) {
if (at - 1 >= 0) {
if (s[at] < ans[at - 1] && (at + 1 >= n || s[at] <= s[at + 1])) {
ans[at] = ans[at - 1], ans[at - 1] = s[at];
++at;
continue;
} else if (at + 1 < n && s[at + 1] < ans[at - 1]) {
ans[at] = ans[at - 1], ans[at - 1] = s[at + 1], ans[at + 1] = s[at];
at += 2;
continue;
}
}
if (at + 1 >= n || cycimprove(s[at]) <= cycimprove(s[at + 1]) && (at + 2 >= n || cycimprove(s[at]) <= s[at + 2])) {
ans[at] = cycimprove(s[at]);
++at;
continue;
} else if (s[at + 1] == 'a') {
ans[at + 1] = cycimprove(s[at]), ans[at] = s[at + 1];
at += 2;
continue;
} else if (at + 2 >= n || cycimprove(s[at + 1]) <= s[at + 2]) {
ans[at + 1] = s[at], ans[at] = cycimprove(s[at + 1]);
at += 2;
continue;
} else {
ans[at] = s[at + 2], ans[at + 1] = cycimprove(s[at]), ans[at + 2] = s[at + 1];
at += 3;
continue;
}
}
}
void run() {
scanf("%d%d", &n, &k);
scanf("%s", s); assert(strlen(s) == n);
solve();
printf("%s\n", ans);
}
int main() {
int ncase; scanf("%d", &ncase); FORE(i, 1, ncase) run();
return 0;
}
|
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int read() {
int ans = 0, f = 1, c = getchar();
while (c < '0' || c>'9') { if (c == '-') f = -1; c = getchar(); }
while (c >= '0' && c <= '9') { ans = ans * 10 + (c - '0'); c = getchar(); }
return ans * f;
}
int T, n, k;
char nxt[507];
string s, dp[507];
int main() {
T = read();
while (T--) {
n = read(); k = read();
cin >> s;
for (int i = 1; i <= n; i++) {
if (s[i - 1] == 'a') nxt[i] = 'a';
else if (s[i - 1] - 'a' + 1 == k) nxt[i] = 'a';
else nxt[i] = s[i - 1] - 1;
}
dp[0] = "";
for (int i = 1; i <= n; i++) dp[i] = char('z' + 1);
for (int i = 1; i <= n; i++) {
dp[i] = min(dp[i], dp[i - 1] + nxt[i]);
if (i > 1) {
dp[i] = min(dp[i], dp[i - 2] + nxt[i] + s[i - 2]);
dp[i] = min(dp[i], dp[i - 1].substr(0, i - 2) + s[i-1] + dp[i - 1].back());
}
if (i > 2) dp[i] = min(dp[i], dp[i - 2].substr(0, i - 3) + s[i-1] + dp[i - 2].back() + s[i - 2]);
}
cout << dp[n]<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int maxn=600+7;
char a[maxn];
int vis[maxn];
char tolow(char temp, int k){
if(temp=='a')return temp;
if(temp=='a'+k-1)return 'a';
else return temp-1;
}
int main()
{
int t;scanf("%d",&t);
while(t--){
memset(vis,0,sizeof(vis));
memset(a,0,sizeof(a));
int n,k;scanf("%d%d",&n,&k);scanf("%s",a+1);
for(int i=1;i<=n;i++){
if(vis[i]){
if(i+1<=n&&vis[i+1]==0&&i+2>n&&a[i+1]<a[i]){
swap(a[i],a[i+1]);vis[i+1]=1;
continue;
}
if(i+2<=n){
if(vis[i+1]==0&&a[i+2]<a[i+1]&&a[i+2]<a[i]){
int temp1,temp2,temp3;temp1=a[i+2],temp2=a[i],temp3=a[i+1];
a[i]=temp1,a[i+1]=temp2,a[i+2]=temp3;vis[i+1]=1,vis[i+2]=1;
}else if(vis[i+1]==0&&a[i+1]<a[i]&&a[i+1]<=a[i+2]){
swap(a[i],a[i+1]);vis[i+1]=1;
}
continue;
}
continue;
}
char choice1=tolow(a[i],k),choice2=a[i+1],choice3=tolow(a[i+1],k),choice4=a[i+2];
/*if(a[i]<a[i-1]){
cout<<i<<":"<<endl;
swap(a[i],a[i-1]);continue;
}*/
//cout<<i<<":"<<choice1<<","<<choice2<<","<<choice3<<","<<choice4<<endl;
if(i+1>n||((i+2>n)&&choice1<=choice2&&choice1<=choice3)||(choice1<=choice2&&choice1<=choice3&&choice1<=choice4)){
vis[i]=1;a[i]=tolow(a[i],k);
}else if((i+2>n&&choice2<=choice3)||(choice2<=choice3&&choice2<=choice4)){
vis[i]=1;vis[i+1]=1;
char temp1,temp2;temp1=a[i+1],temp2=tolow(a[i],k);
a[i]=temp1,a[i+1]=temp2;
}else if(i+2>n||choice3<=choice4){
vis[i]=1,vis[i+1]=1;
char temp1,temp2;temp1=tolow(a[i+1],k),temp2=a[i];
a[i]=temp1,a[i+1]=temp2;
}else{
vis[i]=1,vis[i+1]=1,vis[i+2]=1;
char temp1,temp2,temp3;temp1=a[i+2],temp2=tolow(a[i],k),temp3=a[i+1];
a[i]=temp1,a[i+1]=temp2,a[i+2]=temp3;
}
}
for(int i=1;i<=n;i++)cout<<a[i];cout<<endl;
}
//system("pause");
return 0;
}
//word harder and be better |
//orz Gold_7
//orz SqwrIwy
//orz yzh1505
//orz yzh2019
//orz new
//orz hejinfan
//orz chenkuowen
//#pragma comment(linker,?STACK:1677721600?
//#pragma GCC optimize("O2")
//#pragma G++ optimize("O2")
//#pragma GCC optimize("O3")
//#pragma G++ optimize("O3")
//#pragma GCC optimize(3,"Ofast","inline")
//#pragma GCC target("avx,avx2")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
//typedef __int128 ll;
typedef unsigned int uint;
typedef unsigned long long ull;
//typedef double db;
typedef long double ld;
typedef pair<int,int> PII;
typedef pair<ll,int> Pli;
typedef pair<ll,ll> Pll;
typedef vector<int> VI;
typedef vector<PII> VII;
//typedef pair<ll,ll>P;
#define fi first
#define se second
#define MP make_pair
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,b) for(register int i=(int)(a);i<=(int)(b);++i)
#define per(i,a,b) for(register int i=(int)(a);i>=(int)(b);--i)
#define REP(i,n) for(int i=0;i<n;++i)
#define lowbit(x) x&(-x)
#define Rand (rand()*(1<<16)+rand())
#define id(x) ((x)<=B?(x):m-n/(x)+1)
#define fors(i) for(auto i:e[x]) if(i!=p)
//#define ls p<<1
//#define rs p<<1|1
//#define FI(n) FastIO::read(n)
//#define FO(n) FastIO::write(n)
//#define Flush FastIO::Fflush()
const int N=1111;
const int M=1111111;
const int MOD=1e9+7;
//const int MOD2=998244353;
//const int inv2=(MOD+1)/2;
const int intINF=int(2e9);
const ll llINF=ll(2e18);
const uint uintINF=~0U;
const int dx[4]={-1,1,0,0};
const int dy[4]={0,0,-1,1};
const long double pi=acos(-1.0L);
const int eps=222222;
int read()
{
int v=0,f=1;
char c=getchar();
while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
return v*f;
}
ll readll()
{
ll v=0,f=1;
char c=getchar();
while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
return v*f;
}
/*void pr128(__int128 x)
{
if(x<0) putchar('-'),x=-x;
if(x<10) return putchar('0'+x),void();
pr128(x/10),putchar('0'+(x%10));
}*/
string ch,t;
int n,k;
void predo()
{
}
void update(string &a,const string &b)
{
if(a.empty()||a>b) a=b;
}
void init()
{
n=read(),k=read();
cin>>ch;
}
void solve()
{
t=ch;
rep(i,0,n-1)
{
if(t[i]=='a'+k-1) t[i]='a';
else if(t[i]!='a') t[i]--;
}
string dp[2][2];
dp[0][0]=ch;
int v=0;
rep(i,0,n-1)
{
v^=1;
dp[v][0]=dp[v][1]="";
if(!dp[v^1][0].empty())
{
auto &s=dp[v^1][0];
update(dp[v][0],s);
if(i>0)
{
swap(s[i],s[i-1]);
update(dp[v][0],s);
swap(s[i],s[i-1]);
}
if(i+1<n)
{
swap(s[i],s[i+1]);
update(dp[v][1],s);
swap(s[i],s[i+1]);
}
s[i]=t[i];
update(dp[v][0],s);
}
if(!dp[v^1][1].empty())
{
auto &s=dp[v^1][1];
update(dp[v][0],s);
if(i>1)
{
swap(s[i-1],s[i-2]);
update(dp[v][0],s);
swap(s[i-1],s[i-2]);
}
s[i-1]=t[i];
update(dp[v][0],s);
}
}
cout<<dp[v][0];
printf("\n");
}
int main()
{
//freopen("1.in","r",stdin);
//freopen("1.out","w",stdout);
predo();
int cas=read();
//int cas=1;
while(cas--)
{
init();
solve();
}
return 0;
}
|
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 5e2 + 5;
int d;
char s[MAXN];
string f[MAXN];
inline char get_mn(char c){ return c == 'a' || c == 'a' + d - 1? 'a': c - 1;}
void solve(void)
{
int n;
scanf("%d%d%s",&n,&d,s+1);
f[1] = get_mn(s[1]);
for(int i=2; i<=n; ++i)
{
f[i] = f[i-1] + s[i];
swap(*(f[i].end() - 1), *(f[i].end() - 2));
f[i] = min(f[i], f[i-1] + get_mn(s[i]));
f[i] = min(f[i], f[i-2] + get_mn(s[i]) + s[i-1]);
if(i > 2)
{
string tmp = f[i-2] + s[i];
swap(*(tmp.end() - 1), *(tmp.end() - 2));
tmp += s[i-1];
f[i] = min(f[i], tmp);
}
}
cout << f[n] << endl;
}
int main(void)
{
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 505;
const int MC = 26;
typedef pair<int, int> pii;
int T, N, K;
int num[MX], rlt[MX];
struct data {
pii prv, cur, nxt, nxtt;
data(pii a = pii(0, 0), pii b = pii(0, 0), pii c = pii(0, 0), pii d = pii(0, 0)) { prv = a, cur = b, nxt = c, nxtt = d; }
inline void R_cur() {
swap(cur, nxt);
}
inline void L_cur() {
if(~prv.first) swap(cur, prv);
}
inline void D_cur() {
cur.second += K - 1;
cur.second %= K;
}
inline void U_cur() {
cur.second ++;
cur.second %= K;
}
inline void R_nxt() {
if(nxt.first < N - 1) swap(nxt, nxtt);
}
inline void L_nxt() {
swap(nxt, cur);
}
inline void D_nxt() {
nxt.second += K - 1;
nxt.second %= K;
}
inline void U_nxt() {
nxt.second ++;
nxt.second %= K;
}
inline void skin() {
prv = cur, cur = nxt, nxt = nxtt;
int ps = max(nxt.first, cur.first) + 1;
if(ps < N) nxtt = pii(ps, num[ps]);
if(prv.first < ps) prv.first = ps - 2;
}
void out() {
cerr << '(' << prv.first << ' ' << prv.second << ' ' << cur.first << ' ' << cur.second << ' ' << nxt.first << ' ' << nxt.second << ' ' << nxtt.first << ' ' << nxtt.second << ")\n";
}
};
bool operator < (data A, data B) {
if(A.prv != B.prv) return A.prv < B.prv;
if(A.cur != B.cur) return A.cur < B.cur;
if(A.nxt != B.nxt) return A.nxt < B.nxt;
return A.nxtt < B.nxtt;
}
bool operator == (data A, data B) {
return A.prv == B.prv && A.cur == B.cur && A.nxt == B.nxt && A.nxtt == B.nxtt;
}
char str[MX];
inline int toint(char c) {
return c - 'a';
}
inline char tochar(int a) {
return 'a' + a;
}
vector<data> V;
void build() {
V.clear();
data d(pii(-1, 0), pii(0, num[0]), pii(1, num[1]), pii(2, num[2])), d1;
d1 = d, d1.R_cur(), V.push_back(d1);
d1 = d, d1.U_cur(), V.push_back(d1);
d1 = d, d1.L_cur(), V.push_back(d1);
d1 = d, d1.D_cur(), V.push_back(d1);
d1 = d, V.push_back(d1);
sort(V.begin(), V.end());
V.erase(unique(V.begin(), V.end()), V.end());
vector<data> v;
v.clear();
for(data u : V) {
if(u.nxt.first == 1) {
d1 = u, d1.R_nxt(), v.push_back(d1);
d1 = u, d1.U_nxt(), v.push_back(d1);
d1 = u, d1.L_nxt(), v.push_back(d1);
d1 = u, d1.D_nxt(), v.push_back(d1);
d1 = u, v.push_back(d1);
} else if(u.cur.first == 1) {
d1 = u, d1.R_cur(), v.push_back(d1);
d1 = u, d1.U_cur(), v.push_back(d1);
d1 = u, d1.L_cur(), v.push_back(d1);
d1 = u, d1.D_cur(), v.push_back(d1);
d1 = u, v.push_back(d1);
} else assert(0);
}
V.clear();
for(data u : v) u.skin(), V.push_back(u);
sort(V.begin(), V.end());
V.erase(unique(V.begin(), V.end()), V.end());
}
void extend(int i) {
data d1;
vector<data> v;
v.clear();
int c = MC, cc = MC;
for(data u : V) c = min(u.prv.second, c);
for(data u : V) {
if(u.cur.first == i) {
d1 = u, d1.R_cur();
if(d1.prv.second < c) v.clear();
if(d1.prv.second <= c) v.push_back(d1), c = min(d1.prv.second, c);
d1 = u, d1.L_cur();
if(d1.prv.second < c) v.clear();
if(d1.prv.second <= c) v.push_back(d1), c = min(d1.prv.second, c);
d1 = u, d1.U_cur();
if(d1.prv.second < c) v.clear();
if(d1.prv.second <= c) v.push_back(d1), c = min(d1.prv.second, c);
d1 = u, d1.D_cur();
if(d1.prv.second < c) v.clear();
if(d1.prv.second <= c) v.push_back(d1), c = min(d1.prv.second, c);
d1 = u, v.push_back(d1);
} else if(u.nxt.first == i) {
if(u.prv.second > c) continue;
d1 = u, d1.R_nxt(), v.push_back(d1);
d1 = u, d1.U_nxt(), v.push_back(d1);
d1 = u, d1.L_nxt(), v.push_back(d1);
d1 = u, d1.D_nxt(), v.push_back(d1);
d1 = u, v.push_back(d1);
};
}
for(data u : v) {
if(u.prv.second == c) cc = min(u.cur.second, cc);
}
rlt[i - 2] = c;
V.clear();
for(data u : v) {
if(u.prv.second != c) continue;
if(u.cur.second != cc && u.nxt.first != i + 1 && i < N) continue;
u.skin(), V.push_back(u);
}
assert(!V.empty());
sort(V.begin(), V.end());
V.erase(unique(V.begin(), V.end()), V.end());
}
void final() {
vector<pii> v;
v.clear();
for(data u : V) {
v.push_back(pii(u.prv.second, u.cur.second));
}
sort(v.begin(), v.end());
rlt[N - 2] = v[0].first, rlt[N - 1] = v[0].second;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("I", "r", stdin);
freopen("O", "w", stdout);
#endif
int i, j;
for(scanf("%d", &T); T --; ) {
scanf("%d%d", &N, &K);
scanf("%s", str);
if(N == 1) {
if(toint(str[0]) == K - 1) str[0] = 'a';
else if(str[0] > 'a') str[0] --;
printf("%s\n", str);
continue;
}
for(i = 0; i < N; i ++) num[i] = toint(str[i]);
build();
for(i = 2; i < N; i ++) extend(i);
final();
for(i = 0; i < N; i ++) putchar(tochar(rlt[i]));
puts("");
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <set>
#include <string>
#include <algorithm>
#include <cmath>
#include <assert.h>
#include <map>
#include <deque>
#include <iomanip>
#include <functional>
#include <unordered_set>
#include <queue>
using namespace std;
typedef long long ll;
typedef long double ld;
void solve()
{
int n, k;
string s;
cin >> n >> k >> s;
vector <string> dp(n + 1, string(1, char('a' + k)));
dp[0] = "";
for (int i = 0; i < n; ++i)
{
char c = s[i];
c = min({ c, char('a' + (c - 'a' - 1 + k) % k), char('a' + (c - 'a' + 1) % k) });
dp[i + 1] = min(dp[i + 1], dp[i] + c);
if (i > 0)
{
dp[i + 1] = min(dp[i + 1], dp[i].substr(0, i - 1) + s[i] + dp[i].back());
dp[i + 1] = min(dp[i + 1], dp[i - 1] + c + s[i - 1]);
}
if (i > 1)
{
dp[i + 1] = min(dp[i + 1], dp[i - 1].substr(0, i - 2) + s[i] + dp[i - 1].back() + s[i - 1]);
}
}
cout << dp[n] << '\n';
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
/*
This is code of SuperJ6 for Codeforces.
Don't copy my code during f*kin' contests.
2.71828182845904523536
*/
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define endl '\n'
#define ll long long
#define pi pair<int, int>
#define f first
#define s second
const int mxn = 503;
int n, k;
int a[mxn], vis[mxn];
void swp(int x){
swap(a[x], a[x + 1]), swap(vis[x], vis[x + 1]);
}
void answer(){
cin >> n >> k;
for(int i = 1; i <= n; i++){
char c;
cin >> c;
a[i] = c - 'a', vis[i] = 0;
}
a[0] = -1, a[n + 1] = a[n + 2] = k;
for(int i = 1; i <= n; i++) if(!vis[i]){
vis[i] = 1;
if(a[i + 1] < a[i] && a[i + 1] < a[i - 1] && !vis[i + 1]){
swp(i--);
}else if(a[i] == k - 1){
a[i] = 0;
}else if(a[i] < a[i - 1]){
swp(i - 1);
}else if(a[i]){
if(vis[i + 1]){
if(a[i + 1] < a[i] - 1) swp(i--);
else a[i]--;
}else{
if((a[i + 1] && a[i + 2] >= a[i + 1] - 1 && a[i + 1] < a[i]) ||
(a[i + 1] == k - 1 && a[i] > 1)) swp(i--);
else a[i]--;
}
}
}
for(int i = 1; i <= n; i++) cout << (char)(a[i] + 'a');
cout << endl;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for(int i = 0; i < t; i++) answer();
return 0;
} |
/*
This is code of SuperJ6 for Codeforces.
Don't copy my code during f*kin' contests.
2.71828182845904523536
*/
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define endl '\n'
#define ll long long
#define pi pair<int, int>
#define f first
#define s second
const int mxn = 503;
int n, k;
int a[mxn], vis[mxn];
void swp(int x){
swap(a[x], a[x + 1]), swap(vis[x], vis[x + 1]);
}
void answer(){
cin >> n >> k;
for(int i = 1; i <= n; i++){
char c;
cin >> c;
a[i] = c - 'a', vis[i] = 0;
}
a[0] = -1, a[n + 1] = a[n + 2] = k;
for(int i = 1; i <= n; i++) if(!vis[i]){
vis[i] = 1;
if(a[i + 1] < a[i] && a[i + 1] < a[i - 1] && !vis[i + 1]){
swp(i--);
}else if(a[i] == k - 1){
a[i] = 0;
}else if(a[i] < a[i - 1]){
swp(i - 1);
}else if(a[i]){
if(!vis[i + 1] && ((a[i + 1] && a[i + 2] >= a[i + 1] - 1 && a[i + 1] < a[i]) ||
(a[i + 1] == k - 1 && a[i] > 1))) swp(i--);
else a[i]--;
}
}
for(int i = 1; i <= n; i++) cout << (char)(a[i] + 'a');
cout << endl;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for(int i = 0; i < t; i++) answer();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
const i64 inf = 1e9;
void run_case()
{
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<string> dp(n + 1);
vector<string> dp_gap(n + 1);
auto UP = [&](char c) -> char {
return (c - 'a' + 1) % k + 'a';
};
auto DOWN = [&](char c) -> char {
return (c - 'a' - 1 + k) % k + 'a';
};
auto set_min = [](string &s, const string &rhs) {
if (s.empty())
{
s = rhs;
}
else if (s > rhs)
{
s = rhs;
}
};
for (int i = 0; i < n; i++)
{
set_min(dp[i + 1], dp[i] + UP(s[i]));
set_min(dp[i + 1], dp[i] + DOWN(s[i]));
set_min(dp[i + 1], dp[i] + s[i]);
if (i >= 1)
{
// op L
set_min(dp[i + 1], dp[i].substr(0, i - 1) + s[i] + dp[i].back());
}
set_min(dp_gap[i + 1], dp[i] + s[i]);
if (i >= 1)
{
// i-1 do op R
set_min(dp[i + 1], dp_gap[i].substr(0, i - 1) + UP(s[i]) + dp_gap[i].back());
set_min(dp[i + 1], dp_gap[i].substr(0, i - 1) + DOWN(s[i]) + dp_gap[i].back());
set_min(dp[i + 1], dp_gap[i].substr(0, i - 1) + s[i] + dp_gap[i].back());
}
if (i >= 2)
{
// i-1 do op R, i do L
set_min(dp[i + 1], dp_gap[i].substr(0, i - 2) + s[i] + dp_gap[i].substr(i - 2));
}
}
cout << dp[n] << "\n";
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
cin >> T;
while (T--)
{
run_case();
}
} |
#include<bits/stdc++.h>
using namespace std;
//typedef __int128 ll;
typedef long long ll;
typedef double db;
typedef pair<int, int> pii;typedef pair<ll, ll> pll;
typedef pair<int,ll> pil;typedef pair<ll,int> pli;
#define Fi first
#define Se second
#define _Out(a) cerr<<#a<<" = "<<(a)<<endl
const int INF = 0x3f3f3f3f, MAXN = 1e6 + 5;
const ll LINF = 0x3f3f3f3f3f3f3f3f, MOD = 1e9+7;
const db Pi = acos(-1), EPS = 1e-6;
void test(){cerr << "\n";}template<typename T,typename...Args>void test(T x,Args...args){cerr<<x<<" ";test(args...);}
inline ll qpow(ll a, ll b){return b?((b&1)?a*qpow(a*a%MOD,b>>1)%MOD:qpow(a*a%MOD,b>>1))%MOD:1;}
inline ll qpow(ll a, ll b,ll c){return b?((b&1)?a*qpow(a*a%c,b>>1,c)%c:qpow(a*a%c,b>>1,c)) %c:1;}
inline ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
inline ll cede(ll a,ll b){if(b<0)return cede(-a,-b);if(a<0)return a/b;return (a+b-1)/b;}
inline ll flde(ll a,ll b){if(b<0)return flde(-a,-b);if(a<0)return (a-b+1)/b;return a/b;}
inline int sign(db x){return x<-EPS ? -1:x>EPS;}
inline int dbcmp(db l,db r){return sign(l - r);}
namespace Fast_IO{ //orz laofu
const int MAXL((1 << 18) + 1);int iof, iotp;
char ioif[MAXL], *ioiS, *ioiT, ioof[MAXL],*iooS=ioof,*iooT=ioof+MAXL-1,ioc,iost[55];
char Getchar(){
if (ioiS == ioiT){
ioiS=ioif;ioiT=ioiS+fread(ioif,1,MAXL,stdin);return (ioiS == ioiT ? EOF : *ioiS++);
}else return (*ioiS++);
}
void Write(){fwrite(ioof,1,iooS-ioof,stdout);iooS=ioof;}
void Putchar(char x){*iooS++ = x;if (iooS == iooT)Write();}
inline int read(){
int x=0;for(iof=1,ioc=Getchar();(ioc<'0'||ioc>'9')&&ioc!=EOF;)iof=ioc=='-'?-1:1,ioc=Getchar();
if(ioc==EOF)Write(),exit(0);
for(x=0;ioc<='9'&&ioc>='0';ioc=Getchar())x=(x<<3)+(x<<1)+(ioc^48);return x*iof;
}
inline long long read_ll(){
long long x=0;for(iof=1,ioc=Getchar();(ioc<'0'||ioc>'9')&&ioc!=EOF;)iof=ioc=='-'?-1:1,ioc=Getchar();
if(ioc==EOF)Write(),exit(0);
for(x=0;ioc<='9'&&ioc>='0';ioc=Getchar())x=(x<<3)+(x<<1)+(ioc^48);return x*iof;
}
void Getstr(char *s, int &l){// isgraph || isalnum || iscntrl || isblank
for(ioc=Getchar();ioc!=EOF&&!isgraph(ioc);)ioc=Getchar();
if(ioc==EOF)Write(),exit(0);
for(l=0;isgraph(ioc);ioc=Getchar())s[l++]=ioc;s[l] = 0;
}
template <class Int>void Print(Int x, char ch = '\0'){
if(!x)Putchar('0');if(x<0)Putchar('-'),x=-x;while(x)iost[++iotp]=x%10+'0',x/=10;
while(iotp)Putchar(iost[iotp--]);if (ch)Putchar(ch);
}
void Putstr(const char *s){for(int i=0;s[i];++i)Putchar(s[i]);}
} // namespace Fast_IO
using namespace Fast_IO;
char str[555];
int a[555],k,n;
bool dp[505][28][2];
int D(int v)
{
return (v-2+k)%k+1;
}
int U(int v)
{
return v%k+1;
}
bool QAQ;
int findminchar(int i,bool ok=0)
{
int ans=a[i];
QAQ=0;
if(ok)ans=INF;
for(int j=0;j<=26;j++)
{
if(dp[i-1][j][0])
{
ans=min(j,ans);
}
if(ok)continue;
if(dp[i-1][j][1])
{
ans=min(ans,min(min(a[i],U(a[i])),D(a[i])));
ans=min(ans,j);
}
}
if(i<=n-1&&ans>a[i+1])QAQ=1,ans=a[i+1];
return ans;
}
void work()
{
memset(dp,0,sizeof dp);
n=read();k=read();
Getstr(str+1,n);
for(int i=1;i<=n;i++)a[i]=str[i]-'a'+1;
dp[0][0][0]=1;
for(int i=1;i<=1+n;i++)
{
int minv=findminchar(i,i==n+1);
if(minv)printf("%c",minv+'a'-1);
if(QAQ)
{
for(int j=0;j<=k;j++)
{
if(dp[i-1][j][0])
{
printf("%c",j+'a'-1);
break;
}
}
dp[i+1][a[i]][0]=1;
i++;
continue;
}
if(i==n+1)break;
for(int j=0;j<=k;j++)
{
if(dp[i-1][j][0])
{
if(j==minv)
{
dp[i][U(a[i])][0]=1;
dp[i][D(a[i])][0]=1;
dp[i][a[i]][0]=1;
dp[i][a[i]][1]=1;
}
if(a[i]==minv)
{
dp[i][j][0]=1;
}
}
if(dp[i-1][j][1])
{
if(j==minv)
{
dp[i][a[i]][0]=1;
}
if(U(a[i])==minv||D(a[i])==minv)
{
dp[i][j][0]=1;
}
if(a[i]==minv)
{
dp[i][j][0]=1;
}
}
}
}
printf("\n");
}
int main()
{
//std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int T=read();for(int cas=1;cas<=T;cas++)
//int T;scanf("%d",&T);for(int i=1;i<=T;i++)
work();
// Write();
}
/**
1
0 0
10 0
1 10
10 10
0 2
4 2
2 0
2 4
1 0
2 0
4 0
6 0
1
2 2
4 1
1 6
2 5
*/ |
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cstring>
#include <string>
#include <utility>
#include <algorithm>
#include <math.h>
#include <complex>
#include <iomanip>
#define endl '\n'
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define all(x) (x).begin(), (x).end()
#define sz(x) (int) (x).size()
#define SQ(x) (x) * (x)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define F0RR(i, a, b) for (int i = (a); i <= (b); i++)
#define R0F(i, a) for (int i = (a) - 1; i >= 0; i--)
#define R0FF(i, a, b) for (int i = (a); i >= (b); i--)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vii;
const int inf = 1 << 29;
const int MAXN = 510;
int T, N, K;
string S;
string dp[MAXN];
int previous_letter(int ch)
{
if (ch == 0)
return K - 1;
return --ch;
}
int next_letter(int ch)
{
if (ch == K - 1)
return 0;
return ++ch;
}
int main()
{
// freopen("sao.in", "r", stdin);
// freopen("sao.out", "w", stdout);
ios::sync_with_stdio(0);
cin.tie(0);
cin >> T;
while (T--)
{
cin >> N >> K >> S;
F0RR(i, 1, N + 1)
dp[i] = "~";
F0R(i, N)
{
int cur_char = S[i] - 'a';
int min_char = min(min(previous_letter(cur_char), next_letter(cur_char)), cur_char);
dp[i + 1] = min(dp[i + 1], dp[i] + (char) (min_char + 'a'));
if (i > 0)
dp[i + 1] = min(dp[i + 1], min(dp[i - 1] + (char) (min_char + 'a') + S[i - 1], dp[i].substr(0, i - 1) + S[i] + dp[i][i - 1]));
if (i > 1)
dp[i + 1] = min(dp[i + 1], dp[i - 1].substr(0, i - 2) + S[i] + dp[i - 1][i - 2] + S[i - 1]);
}
cout << dp[N] << endl;
}
return 0;
} |
#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cstring>
#include<string>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<iomanip>
#include<stack>
#include<cmath>
using namespace std;
#ifndef POJ
#define Cpp11
#endif
#ifdef Cpp11
#define _for(i,a,b) for(auto i = (a);i<(b);++i)
#define _rep(i,a,b) for(auto i = (a);i<=(b);++i)
#define _dep(i,a,b) for(auto i = (a);i>=(b);--i)
#define mt(a,b,c) make_tuple(a,b,c)
#include<ctime>
#include<random>
#include<chrono>
#include<limits>
#include<complex>
#include<unordered_set>
#include<unordered_map>
#include<cassert>
#include<functional>
#include<bitset>
#define IO ios::sync_with_stdio(false);cout.tie(nullptr);cin.tie(nullptr);
#endif
#ifndef Cpp11
#define _for(i,a,b) for(int i = (a);i<(b);++i)
#define _rep(i,a,b) for(int i = (a);i<=(b);++i)
#define _dep(i,a,b) for(int i = (a);i>=(b);--i)
#define IO ios::sync_with_stdio(false);cout.tie(NULL);cin.tie(NULL);
#endif
using namespace std;
#define fr first
#define sc second
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define sci(x) scanf("%d",&(x))
#define scl(x) scanf("%lld",&(x))
#define debugline fprintf(stderr,"-----------------------\n");
#define szint(x) ((int)(x).size())
#ifdef I128IO
typedef __int128 SPLL;
char buff[200];
template<typename T>
void read(T& o)
{
o = 0;
scanf("%s",buff);
//printf("%s\n",buff);
T f = 1;
int i = 0;
if(buff[0]=='-')i++,f = -1;
for(;buff[i];++i)
{
o*=10,o+=buff[i]-'0';
}
o*=f;
}
template<typename T>
void write(T o)
{
int len = 0;
buff[0] = '0';
if(o==0)
{
putchar('0');
return;
}
int f = 1;
if(o<0) f = -1;
o*=f;
for(;o;o/=10) buff[len++] = o%10+'0';
if(f==-1) buff[len++] = '-';
reverse(buff,buff+len);
buff[len++] ='\0';
printf("%s",buff);
}
#endif
#ifdef FIO
char buff[100];
template<typename T>
void read(T& o)
{
o = 0;
scanf("%s",buff);
//printf("%s\n",buff);
T f = 1;
int i = 0;
if(buff[0]=='-')i++,f = -1;
for(;buff[i];++i)
{
o*=10,o+=buff[i]-'0';
}
o*=f;
}
template<typename T>
void write(T o)
{
int len = 0;
buff[0] = '0';
if(o==0)
{
putchar('0');
return;
}
int f = 1;
if(o<0) f = -1;
o*=f;
for(;o;o/=10) buff[len++] = o%10+'0';
if(f==-1) buff[len++] = '-';
reverse(buff,buff+len);
buff[len++] ='\0';
printf("%s",buff);
}
#endif
#define OIreader
#ifdef OIreader
inline int read(){
char ch; bool sign=0; int res=0;
while(!isdigit(ch=getchar()))if(ch=='-')sign=1;
while(isdigit(ch))res=res*10+(ch^48),ch=getchar();
if(sign)return -res; else return res;
}
#endif
#ifdef _Random_
mt19937 __MT(chrono::system_clock::now().time_since_epoch().count());
#endif
#ifndef BigNumber
typedef unsigned long long uLL;
typedef long long LL;
typedef long long ll;
typedef pair<LL,LL> pLL;
typedef vector<LL> vL;
typedef vector<vL> vLL;
#endif
// Sorry,I must be yellow!
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<vii> viii;
typedef pair<int,int> pii;
const int maxn = 500+10;
const LL inf = 1e18;
const int maxm = 10;
const int apsz = 26;
char s[maxn];
int n,k;
string dp[2][2];
inline string solve()
{
int t = 0;
_for(i,0,2)_for(j,0,2) dp[i][j].clear();
dp[t][0] = string(s);
_for(i,0,n)
{
_for(j,0,2) dp[t^1][j].clear();
_for(j,0,2)
{
if(dp[t][j].empty())continue;
string& T = dp[t][j];
int c = T[i-j]-'a';
T[i-j] = min({c,(c+1)%k,(c-1+k)%k})+'a';
if(!dp[t^1][0].empty())dp[t^1][0] = min(T,dp[t^1][0]);
else dp[t^1][0] = T;
T[i-j] = c+'a';
if(i-j>0)
{
swap(T[i-j],T[i-j-1]);
dp[t^1][0] = min(dp[t^1][0],T);
swap(T[i-j],T[i-j-1]);
}
if(j==0&&i<n-1)
{
swap(T[i],T[i+1]);
if(!dp[t^1][1].empty())dp[t^1][1] = min(T,dp[t^1][1]);
else dp[t^1][1] = T;
swap(T[i],T[i+1]);
}
}
t^=1;
}
return dp[t][0];
}
int main(void)
{
int T;
sci(T);
for(;T--;)
{
sci(n),sci(k);
scanf("%s",s);
printf("%s\n",solve().c_str());
}
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
#define FAST ios_base::sync_with_stdio(false); cin.tie(0);
#define pb push_back
#define eb emplace_back
#define ins insert
#define f first
#define s second
#define cbr cerr<<"hi\n"
#define mmst(x, v) memset((x), v, sizeof ((x)))
#define siz(x) ll(x.size())
#define all(x) (x).begin(), (x).end()
#define lbd(x,y) (lower_bound(all(x),y)-x.begin())
#define ubd(x,y) (upper_bound(all(x),y)-x.begin())
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); //can be used by calling rng() or shuffle(A, A+n, rng)
inline long long rand(long long x, long long y) { return rng() % (y+1-x) + x; } //inclusivesss
string inline to_string(char c) {string s(1,c);return s;} template<typename T> inline T gcd(T a,T b){ return a==0?llabs(b):gcd(b%a,a); }
using ll=long long;
using ld=long double;
#define FOR(i,s,e) for(ll i=s;i<=ll(e);++i)
#define DEC(i,s,e) for(ll i=s;i>=ll(e);--i)
using pi=pair<ll,ll>; using spi=pair<ll,pi>; using dpi=pair<pi,pi>;
long long LLINF = 1e18;
int INF = 1e9+1e6;
#define MAXN (200006)
ll t, n, k;
string A;
string dp[506];
int main() {
FAST
cin>>t;
while(t--){
cin>>n>>k>>A;--k;
A='*'+A;
auto change=[&](char c){
if(c=='a'+k)c='a';
else if(c!='a')--c;
return c;
};
char ch;
FOR(i,1,n){
string tmp = dp[i-1];
dp[i] = dp[i-1] + change(A[i]);
if(i>1) dp[i]=min(dp[i],dp[i-2]+change(A[i])+A[i-1]), ch=tmp.back(), tmp.pop_back(), dp[i]=min(dp[i],tmp+A[i]+ch);
if(i>2) {
tmp = dp[i-2];
ch = tmp.back(), tmp.pop_back();
dp[i]=min(dp[i],tmp+A[i]+ch+A[i-1]);
}
}
cout<<dp[n]<<'\n';
}
}
|
#include <bits/stdc++.h>
// #include <climits>
// #include <iostream>
// #include <vector>
// #include <utility>
using namespace std;
#define vt vector
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define fi first
#define se second
#define rep(i,L,R) for (int i = L; i < R; ++i)
#define rrep(i,L,R) for (int i = R; i > L; --i)
#define each(x, a) for (auto& x: a)
#define nndl "\n"
using ul = unsigned long;
using ll = long long;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vi>;
using ii = pair<int, int>;
template<class T> void read(T& x) {
cin >> x;
}
template <class H, class... T>
void read(H& h, T&... t) {
cin >> h;
read(t...);
}
template<class T> void read(vector<T>& v) {
each(x, v)
read(x);
}
template<class A> void write(A x) {
cout << x;
}
template<class H, class... T> void write(const H& h, const T&... t) {
write(h);
write(t...);
}
void print() {
write("\n");
}
template<class H, class... T> void print(const H& h, const T&... t) {
write(h);
if(sizeof...(t))
write(' ');
print(t...);
}
template<class T> void print(vector<T>& v) {
each(x, v)
write(x, " ");
write("\n");
}
// code
char getNext(char c, int k) {
int pos = c - 'a';
return 'a' + (pos + 1) % k;
}
char getPrev(char c, int k) {
int pos = c - 'a';
return 'a' + (pos - 1 + k) % k;
}
void solve() {
int n, k; cin >> n >> k;
string s; cin >> s;
vector<string> dp(n+1, string(1, 'z'+1));
dp[0] = "";
rep(i, 0, n) {
int c = s[i] - 'a';
int nc = min({c, (c + 1) % k, (c - 1 + k) % k});
dp[i+1] = min(dp[i+1], dp[i] + char('a' + nc));
if (i > 0) {
// L
dp[i+1] = min(dp[i+1], dp[i].substr(0, i-1) + s[i] + dp[i].back());
// RU, RD
dp[i+1] = min(dp[i+1], dp[i-1] + char('a' + nc) + s[i-1]);
}
if (i > 1) {
// RL
dp[i+1] = min(dp[i+1], dp[i-1].substr(0, i-2) + s[i] + dp[i-1].back() + s[i-1]);
}
}
cout << dp[n] << nndl;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int t; cin >> t;
while (t--)
solve();
return 0;
} |
#pragma GCC optimize(2)
#include<iostream>
#include<cstdio>
#include<cstring>
#define N 555
#define upmin(_a,_b) _a=min(_a,_b)
using namespace std;
namespace ywy{
typedef unsigned char byte;
void sget(char *s){
int n=1;char c;while((c=getchar())||23333)if(c>='a'&&c<='z')break;
s[n]=c-'a';n++;while((c=getchar())||23333){
if(c>='a'&&c<='z')s[n]=c-'a',n++;else return;
}
}char str[N],anss[N];int dp[N][2];
inline int getb(int x,int bit){
byte *p=(byte*)&x;return(p[bit]);
}
inline int setb(int x,int bit,int y){
byte *p=(byte*)&x;p[bit]=y;return(x);
}
inline int xchg(int x,int i,int j){
byte *p=(byte*)&x;swap(p[i],p[j]);return(x);
}
void ywymain(){
int t;cin>>t;while(t){
t--;int n,k;cin>>n>>k;sget(str);str[n+1]=str[n+2]=0;
memset(dp,0x7f,sizeof(dp));dp[0][0]=str[1];
for(register int i=1;i<=n;i++){
int minn;if(i>3){
minn=min(getb(dp[i-1][0],3),getb(dp[i-1][1],3));
}else minn=0;if(i>3)putchar(minn+'a');
if(getb(dp[i-1][0],3)==minn){//now str[i] is on bit0
int me=(dp[i-1][0]<<8)|str[i+1];
upmin(dp[i][0],me);
upmin(dp[i][0],setb(me,1,(str[i]+1)%k));
upmin(dp[i][0],setb(me,1,(str[i]+k-1)%k));
if(i!=1)upmin(dp[i][0],xchg(me,1,2));
if(i!=n)upmin(dp[i][1],xchg(me,0,1));
}if(getb(dp[i-1][1],3)==minn){//now str[i] is on bit1
int me=(dp[i-1][1]<<8)|str[i+1];upmin(dp[i][0],me);
upmin(dp[i][0],setb(me,2,(str[i]+1)%k));
upmin(dp[i][0],setb(me,2,(str[i]+k-1)%k));
if(i-1!=1)upmin(dp[i][0],xchg(me,2,3));
upmin(dp[i][0],xchg(me,1,2));
}
}int ans=min(dp[n][0],dp[n][1]);if(n==1){
putchar(getb(ans,1)+'a');
}if(n==2){
putchar(getb(ans,2)+'a');putchar(getb(ans,1)+'a');
}if(n>=3){
putchar(getb(ans,3)+'a');putchar(getb(ans,2)+'a');putchar(getb(ans,1)+'a');
}cout<<endl;
}
}
}
#define cgg vcfbcbf
int main(){
ywy::ywymain();return(0);
} |
/*
This is code of SuperJ6 for Codeforces.
Don't copy my code during f*kin' contests.
2.71828182845904523536
*/
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define endl '\n'
#define ll long long
#define pi pair<int, int>
#define f first
#define s second
const int mxn = 503;
int n, k;
int a[mxn], vis[mxn];
void swp(int x){
swap(a[x], a[x + 1]), swap(vis[x], vis[x + 1]);
}
void answer(){
cin >> n >> k;
for(int i = 1; i <= n; i++){
char c;
cin >> c;
a[i] = c - 'a', vis[i] = 0;
}
a[0] = -1, a[n + 1] = a[n + 2] = k;
for(int i = 1; i <= n; i++) if(!vis[i]){
vis[i] = 1;
if(!vis[i + 1] && a[i + 1] < a[i] && a[i + 1] < a[i - 1]){
swp(i--);
}else if(a[i] == k - 1){
a[i] = 0;
}else if(a[i] < a[i - 1]){
swp(i - 1);
}else if(a[i]){
if(!vis[i + 1] && ((a[i + 1] && a[i + 2] >= a[i + 1] - 1 && a[i + 1] < a[i]) ||
(a[i + 1] == k - 1 && a[i] > 1))) swp(i--);
else a[i]--;
}
}
for(int i = 1; i <= n; i++) cout << (char)(a[i] + 'a');
cout << endl;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for(int i = 0; i < t; i++) answer();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mp make_pair
#define fr first
#define sc second
int lg(ll n) {
assert(n > 0);
int ans = -1;
while (n) {
ans++;
n >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
assert(n == (int)s.length());
vector<string> dp(n + 1);
dp[0] = "";
for (int i = 1; i <= n; i++) dp[i] = (char)('z' + 1);
for (int i = 0; i < n; i++) {
int ch = s[i] - 'a';
int best = min({ch, (ch + 1) % k, (ch + k - 1) % k});
dp[i + 1] = min(dp[i + 1], dp[i] + (char)(best + 'a')); // U, D
if (i > 0) {
dp[i + 1] =
min(dp[i + 1], dp[i].substr(0, i - 1) + (char)(ch + 'a') +
dp[i].back()); // L
dp[i + 1] = min(dp[i + 1], dp[i - 1] + (char)(best + 'a') +
s[i - 1]); // RD, RU
}
if (i > 1) { // RL
dp[i + 1] = min(dp[i + 1], dp[i - 1].substr(0, i - 2) + s[i] +
dp[i - 1].back() + s[i - 1]);
}
}
cout << dp[n] << '\n';
}
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
#define N 505
#define rep(i,a,n) for (int i=a;i<=n;i++)
#define per(i,a,n) for (int i=n;i>=a;i--)
#define inf 0x3f3f3f3f
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define fi first
#define se second
#define lowbit(i) ((i)&(-i))
#define VI vector<int>
#define all(x) x.begin(),x.end()
#define SZ(x) ((int)x.size())
using namespace std;
string dp[N];
char s[N];
int ta,na,ka;
char inc(char c){
return (c-'a'+1)%ka+'a';
}
char dec(char c){
return (c-'a'+ka-1)%ka+'a';
}
int main(){
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
scanf("%d",&ta);
while(ta--){
scanf("%d%d",&na,&ka);
scanf("%s",s+1);
dp[0] = "";
rep(i,1,na) dp[i] = dp[i-1]+'z';
rep(i,0,na-1){
if(i<1) dp[i+1] = min({dp[i+1],
dp[i]+inc(s[i+1]),
dp[i]+dec(s[i+1]),
dp[i]+s[i+1]});
else dp[i+1] = min({dp[i+1],
dp[i].substr(0,i-1)+s[i+1]+dp[i].back(),
dp[i]+inc(s[i+1]),
dp[i]+dec(s[i+1]),
dp[i]+s[i+1]});
if(i+2 <= na){
if(i<1) dp[i+2] = min({dp[i+2],
dp[i]+inc(s[i+2])+s[i+1],
dp[i]+dec(s[i+2])+s[i+1]});
else dp[i+2] = min({dp[i+2],
dp[i]+inc(s[i+2])+s[i+1],
dp[i]+dec(s[i+2])+s[i+1],
dp[i].substr(0,i-1)+s[i+2]+dp[i].back()+s[i+1]});
}
// cout << dp[i] << endl;
}
rep(i,1,na) s[i] = dp[na][i-1];
printf("%s\n",s+1);
}
return 0;
}
/*
1
5 7
eabba
*/ |
#include <bits/stdc++.h>
#define fi first
#define se second
#define db double
#define U unsigned
#define P std::pair<int,int>
#define LL long long
#define pb push_back
#define MP std::make_pair
#define all(x) x.begin(),x.end()
#define CLR(i,a) memset(i,a,sizeof(i))
#define FOR(i,a,b) for(int i = a;i <= b;++i)
#define ROF(i,a,b) for(int i = a;i >= b;--i)
#define DEBUG(x) std::cerr << #x << '=' << x << std::endl
const int MAXN = 500+5;
int n,k;
int mn[26];
std::string f[MAXN],str;
inline std::string ctos(char x){
return std::string(1,x);
}
inline void Solve(){
std::cin >> n >> k >> str;str = "0"+str;
mn[0] = 0;FOR(i,1,k-2) mn[i] = i-1;mn[k-1] = 0;
f[0].clear();FOR(i,1,n) f[i] = "{";
FOR(i,0,n-1){
f[i+1] = std::min(f[i+1],f[i]+ctos('a'+mn[str[i+1]-'a']));
if(i) f[i+1] = std::min(f[i+1],f[i].substr(0,i-1)+ctos(str[i+1])+f[i].back());
if(i != n-1) f[i+2] = std::min(f[i+2],f[i]+ctos('a'+mn[str[i+2]-'a'])+ctos(str[i+1]));
if(i && i != n-1) f[i+2] = std::min(f[i+2],f[i].substr(0,i-1)+ctos(str[i+2])+f[i].back()+ctos(str[i+1]));
}
std::cout << f[n] << std::endl;
}
int main(){
std::ios::sync_with_stdio(false);
int T;std::cin >> T;
while(T--) Solve();
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const int M = 510;
int T,n,k;
string s, dp[M];
int main(){
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> T;
while(T--){
cin >> n >> k >> s;
dp[0] = "";
for(int i = 1;i <= n; i++) dp[i] = (char)('z' + 1);
for(int i = 0,ch,nc;i < n; i++){
ch = s[i] - 'a', nc = min(ch,min((ch + 1) % k,(ch + k - 1) % k));
dp[i + 1] = min(dp[i + 1], dp[i] + (char)('a' + nc));
if(i > 0)
dp[i + 1] = min(dp[i + 1],dp[i - 1] + (char)('a' + nc) + s[i - 1]),
dp[i + 1] = min(dp[i + 1],dp[i].substr(0, i - 1) + s[i] + dp[i][(int)dp[i].length() - 1]);
if(i > 1)
dp[i + 1] = min(dp[i + 1],dp[i - 1].substr(0, i - 2) + s[i] + dp[i - 1][(int)dp[i - 1].length() - 1] + s[i - 1]);
}
cout << dp[n] << endl;
}
return 0;
} |
// Problem: F. String and Operations
// Contest: Codeforces - Educational Codeforces Round 99 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1455/problem/F
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#define int long long
#define double long double
using namespace std;
inline int read()
{
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9')
{
if (ch == '-')
w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const int MAXN = 500 + 10;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double eps = 1e-9;
const double PI = acos(-1.0);
int n, m, k;
string str, ans;
char D(char c)
{
return 'a' + ((c - 'a') - 1 + k) % k;
}
char U(char c)
{
return 'a' + ((c - 'a') + 1) % k;
}
char best(char c)
{
return min(c, min(D(c), U(c)));
}
signed main()
{
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
int T = read();
while (T--)
{
n = read(), k = read();
cin >> str;
ans = "";
int idx = 0;
while (idx < n)
{
ans += str[idx];
if (idx - 1 >= 0)
{
char pre = ans[idx - 1];
int res = 0;
if (ans[idx] < ans[idx - 1])
{
ans[idx - 1] = ans[idx];
res = 1;
}
if (idx + 1 < n && str[idx + 1] < ans[idx - 1])
{
ans[idx - 1] = str[idx + 1];
ans += str[idx];
res = 2;
}
if (res) ans[idx] = pre;
if (res == 1)
{
idx++;
continue;
}
else if(res == 2)
{
idx += 2;
continue;
}
}
ans[idx] = best(ans[idx]);
int res = 0;
if (idx + 1 < n && best(str[idx + 1]) < ans[idx])
{
if (best(str[idx + 1]) == str[idx + 1])
{
ans += str[idx + 1];
swap(ans[idx], ans[idx + 1]);
}
else
{
ans[idx] = best(str[idx + 1]);
ans += str[idx];
}
res = 1;
}
if (idx + 2 < n && str[idx + 2] < ans[idx])
{
while (ans.length() < idx + 3) ans += 'a';
ans[idx] = str[idx + 2];
ans[idx + 1] = best(str[idx]);
ans[idx + 2] = str[idx + 1];
res = 2;
}
if (res == 0) idx++;
else if (res == 1) idx += 2;
else idx += 3;
}
cout << ans << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int tt;
for (cin >> tt; tt--;) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<string> dp(n + 1, string(1, char('z' + 1)));
dp[0] = "";
for (int i = 0; i < n; i++) {
int c = s[i] - 'a';
int nc = min({c, (c + 1) % k, (c + k - 1) % k});
dp[i + 1] = dp[i] + char('a' + nc);
if (i > 0) {
dp[i + 1] = min(dp[i + 1], dp[i - 1] + char('a' + nc) + s[i - 1]);
dp[i + 1] = min(dp[i + 1], dp[i].substr(0, i - 1) + s[i] + dp[i].back());
}
if (i > 1) {
dp[i + 1] = min(dp[i + 1], dp[i - 1].substr(0, i - 2) + s[i] + dp[i - 1].back() + s[i - 1]);
}
}
cout << dp[n] << '\n';
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const int INF = 1e8;
int n, k;
char s[N];
int num[N];
int res[N];
int add_one(int a) {
if (a == 0) return a;
if (a >= k) return INF;
if (a < 0) return -INF;
return min((a + k - 1) % k, (a + 1) % k);
}
int main()
{
int TC;
scanf("%d", &TC);
while (TC--) {
scanf("%d %d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
num[i] = s[i] - 'a';
}
int i = 1;
while (i<=n) {
int mid = num[i];
int last, head;
if (i < n)
last = num[i+1];
else
last = INF;
if (i > 1)
head = num[i-1];
else
head = -INF;
int op = 1;
if (mid < head && mid <= last ) {
// mid to first
//printf("%d %d %d\n", head, mid ,last);
swap(num[i-1], num[i]);
//num[i-1] = add_one(mid);
i += 1;
op = 1;
}
else if (last < head && last < mid) {
// last to first
num[i-1] = last;
num[i] = head;
num[i+1] = mid;
i += 2;
op = 2;
} else if(add_one(last) < add_one(mid)) {
if (i + 2 <= n && num[i+2] < add_one(mid) && num[i+2] < add_one(last)) {
num[i] = add_one(mid);
i++;
continue;
}
swap(num[i], num[i+1]);
if (num[i] != 0 )
num[i] = add_one(num[i]);
else
num[i+1] = add_one(num[i+1]);
i += 2;
op = 3;
}
else {
num[i] = add_one(num[i]);
i++;
op = 4;
}
//printf("%d...", op);
//for (int i = 1; i <= n; i++)printf("%c", num[i] + 'a');
//printf("\n");
}
for (int i = 1; i <= n; i++)printf("%c", num[i] + 'a');
printf("\n");
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int k;
char bestChar(char c)
{
return c == 'a' || c - 'a' == k - 1 ? 'a' : c - 1;
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int test;
cin >> test;
while (test--)
{
int n;
string s;
cin >> n >> k >> s;
for (int i = 0; i < n;)
if (i && i + 1 < n && s[i + 1] < s[i] && s[i + 1] < s[i - 1])
{
// move i + 1 to i - 1
swap(s[i], s[i + 1]);
swap(s[i], s[i - 1]);
i += 2;
}
else if (i && s[i] < s[i - 1])
{
swap(s[i], s[i - 1]);
i++;
}
else if (i == n - 1)
{
s[i] = bestChar(s[i]);
break;
}
else if (i + 2 < n && s[i + 2] < min(bestChar(s[i]), bestChar(s[i + 1])))
{
s[i] = bestChar(s[i]);
swap(s[i + 1], s[i + 2]);
swap(s[i + 1], s[i]);
i += 3;
}
else if (i + 1 < n && bestChar(s[i + 1]) < bestChar(s[i]))
{
if (s[i + 1] == 'a')
s[i] = bestChar(s[i]);
swap(s[i], s[i + 1]);
s[i] = bestChar(s[i]);
i += 2;
}
else
{
s[i] = bestChar(s[i]);
i++;
}
cout << s << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int gi() {
int w = 0;
bool q = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 0, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? w : -w;
}
const int N = 510;
long long f[10][N][N], g[10][N][N];
long long h[N][N], H[N][N];
int main() {
int n = gi(), m = gi(), i, j, k, a, b, t, ans;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) f[0][i][j] = -1LL << 60;
while (m--) {
a = gi(), b = gi();
f[0][a][b] = max(f[0][a][b], (long long)gi());
f[0][b][a] = max(f[0][b][a], (long long)gi());
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) g[0][i][j] = f[0][i][j];
for (t = 1; t < 10; t++) {
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
g[t][i][j] = -1LL << 60;
f[t][i][j] = f[t - 1][i][j];
for (k = 1; k <= n; k++) {
g[t][i][j] = max(g[t][i][j], g[t - 1][i][k] + g[t - 1][k][j]);
f[t][i][j] = max(f[t][i][j], g[t - 1][i][k] + f[t - 1][k][j]);
}
}
for (i = 1; i <= n; i++)
if (f[t][i][i] > 0) break;
if (i <= n) break;
}
if (t == 10) return puts("0"), 0;
for (i = 1, ans = 1 << (--t); i <= n; i++)
for (j = 1; j <= n; j++) h[i][j] = g[t][i][j];
while (--t >= 0) {
for (i = 1; i <= n; i++) {
for (k = 1; k <= n; k++)
if (h[i][k] + f[t][k][i] > 0) break;
if (k <= n) break;
}
if (i > n) {
ans |= 1 << t;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
H[i][j] = -1LL << 60;
for (k = 1; k <= n; k++) H[i][j] = max(H[i][j], h[i][k] + g[t][k][j]);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) h[i][j] = H[i][j];
}
}
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 309;
int n, m, a, b, c, d, ans, flag, w[maxn][maxn];
struct Matrix {
int d[maxn][maxn];
Matrix operator*(const Matrix &a) const {
Matrix res;
for (int i = (1); i <= int(n); i++)
for (int j = (1); j <= int(n); j++) {
res.d[i][j] = max(d[i][j], a.d[i][j]);
for (int k = (1); k <= int(n); k++)
res.d[i][j] = max(res.d[i][j], d[i][k] + a.d[k][j]);
}
return res;
}
} A[15], S, T;
int main() {
scanf("%d%d", &n, &m);
memset(S.d, 0xc0, sizeof S.d);
memset(A[0].d, 0xc0, sizeof A[0].d);
for (int i = (1); i <= int(n); i++) S.d[i][i] = 0;
for (int i = (1); i <= int(m); i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
A[0].d[a][b] = c;
A[0].d[b][a] = d;
}
for (int i = (1); i <= int(9); i++) A[i] = A[i - 1] * A[i - 1];
for (int i = (9); i >= (0); i--) {
T = S * A[i];
flag = 0;
for (int j = (1); j <= int(n); j++)
if (T.d[j][j] > 0) flag = 1;
if (flag) continue;
S = T;
ans += 1 << i;
}
if (ans > n)
puts("0");
else
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 305;
const int LOG = 10;
void read(int &num) {
char ch;
bool flag = 0;
while (!isdigit(ch = getchar()))
if (ch == '-') flag = !flag;
for (num = 0; isdigit(ch); num = num * 10 + ch - '0', ch = getchar())
;
num = flag ? -num : num;
}
int n, m;
struct Matrix {
int mz[MAXN][MAXN];
Matrix() { memset(mz, 0x3f, sizeof mz); }
friend Matrix operator*(Matrix X, Matrix Y) {
Matrix Z;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
Z.mz[i][j] = min(Z.mz[i][j], X.mz[i][k] + Y.mz[k][j]);
return Z;
}
} A, tmp, dis[LOG];
int main() {
int u, v, w, rw;
read(n), read(m);
if (n == 1 && m == 0) {
puts("0");
return 0;
}
for (int i = 1; i <= m; i++) {
read(u), read(v), read(w), read(rw);
dis[0].mz[u][v] = -w;
dis[0].mz[v][u] = -rw;
}
for (int i = 1; i <= n; i++) dis[0].mz[i][i] = A.mz[i][i] = 0;
int len;
for (len = 1; (1 << len) <= n; len++) dis[len] = dis[len - 1] * dis[len - 1];
int Ans = 0;
for (int i = len - 1, j; i >= 0; i--) {
tmp = A * dis[i];
for (j = 1; j <= n; j++)
if (tmp.mz[j][j] < 0) break;
if (j == n + 1) A = tmp, Ans += (1 << i);
}
if (Ans > n) Ans = -1;
printf("%d\n", Ans + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e7;
vector<vector<int>> multiply(const vector<vector<int>>& A,
const vector<vector<int>>& B) {
int r = A.size();
int n = A[0].size();
int c = B[0].size();
vector<vector<int>> C(r, vector<int>(c, INF));
for (int i = 0; i < r; ++i)
for (int j = 0; j < c; ++j)
for (int k = 0; k < n; ++k) C[i][j] = min(C[i][j], A[i][k] + B[k][j]);
return C;
}
vector<vector<int>> powMatrix(const vector<vector<int>>& matriz, int e) {
if (e == 1) return matriz;
vector<vector<int>> x = powMatrix(matriz, e / 2);
x = multiply(x, x);
if (e & 1) {
x = multiply(x, matriz);
}
return x;
}
bool evenCycle(const vector<vector<int>>& Pk) {
int n = Pk.size();
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (Pk[i][j] + Pk[j][i] < 0) return true;
return false;
}
bool oddCycle(const vector<vector<int>>& P, const vector<vector<int>>& Pk) {
int n = Pk.size();
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k)
if (P[i][j] + Pk[j][k] + Pk[k][i] < 0) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> P(n, vector<int>(n, INF));
for (int i = 0; i < m; ++i) {
int a, b, c_ab, c_ba;
cin >> a >> b >> c_ab >> c_ba;
P[a - 1][b - 1] = -c_ab;
P[b - 1][a - 1] = -c_ba;
}
int l = 1, r = (n + 1) / 2;
while (l < r) {
int med = (l + r) / 2;
vector<vector<int>> Pk = powMatrix(P, med);
if (evenCycle(Pk) || oddCycle(P, Pk))
r = med;
else
l = med + 1;
}
vector<vector<int>> Pl = powMatrix(P, l);
if (evenCycle(Pl)) {
cout << 2 * l << "\n";
} else if (oddCycle(P, Pl)) {
cout << 2 * l + 1 << "\n";
} else {
cout << "0\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
long long Factorial(long long i) { return i > 1 ? i * Factorial(i - 1) : 1; }
long long Combination(long long n, long long r) {
if (n - r < r) r = n - r;
long long ansn = 1, ansr = 1;
for (long long i = n - r + 1; i <= n; ++i) ansn *= i;
for (long long j = 1; j <= r; ++j) ansr *= j;
return ansn / ansr;
}
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) { return a / gcd(a, b) * b; }
std::vector<int> Eratosthenes(const int len, int *vis) {
memset(vis, 0, sizeof(int) * len);
std::vector<int> prime;
int m = (int)sqrt(len + 0.5);
for (int i = (2); i <= (m); ++i)
if (!vis[i])
for (int j = i * i; j < len; j += i) vis[j] = 1;
for (int i = (2); i < (len); ++i)
if (!vis[i]) prime.push_back(i);
return prime;
}
void phi_table(int n, int *phi) {
for (int i = (2); i <= (n); ++i) phi[i] = 0;
phi[1] = 1;
for (int i = (2); i <= (n); ++i)
if (!phi[i])
for (int j = i; j <= n; j += i) {
if (!phi[j]) phi[j] = j;
phi[j] = phi[j] / i * (i - 1);
}
}
const int M = 8;
const int maxn = 305;
const int INF = 1e9;
int n, m;
int dp[maxn][maxn][maxn], tmp[maxn][maxn], now[maxn][maxn];
int main() {
scanf("%d%d", &n, &m);
for (int d = (0); d <= (M); ++d)
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) dp[d][i][j] = -INF * (i != j);
for (int i = (0); i < (m); ++i) {
int x, y;
scanf("%d%d", &x, &y);
scanf("%d%d", &dp[0][x][y], &dp[0][y][x]);
}
for (int d = (1); d <= (M); ++d) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j)
for (int k = (1); k <= (n); ++k)
if (dp[d - 1][i][j] > -INF && dp[d - 1][j][k] > -INF)
dp[d][i][k] =
std::max(dp[d][i][k], dp[d - 1][i][j] + dp[d - 1][j][k]);
}
int ans = 0;
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) now[i][j] = -INF * (i != j);
for (int d = M; d >= 0; --d) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) tmp[i][j] = -INF * (i != j);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j)
for (int k = (1); k <= (n); ++k)
if (now[i][j] > -INF && dp[d][j][k] > -INF)
tmp[i][k] = std::max(tmp[i][k], now[i][j] + dp[d][j][k]);
int isok = 0;
for (int i = (1); i <= (n); ++i) isok |= (tmp[i][i] > 0);
if (!isok) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) now[i][j] = tmp[i][j];
ans += (1 << d);
}
}
cout << (ans < n ? ans + 1 : 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eqs = 1e-8;
const int max_ = 300 + 7;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
const long long INF = 2e18 + 7;
inline int read() {
int s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
inline void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
int f[13][max_][max_], now[max_][max_], g[max_][max_];
int N, M;
inline void ini() {
int limk = 11;
N = read();
M = read();
memset(f, 128, sizeof(f));
register int k, i, j, A, B, C, D, z;
for (i = 1; i <= M; i++) {
A = read(), B = read(), C = read(), D = read();
f[0][A][B] = ((f[0][A][B]) > (C) ? (f[0][A][B]) : (C));
f[0][B][A] = ((f[0][B][A]) > (D) ? (f[0][B][A]) : (D));
}
for (k = 1; k <= limk; k++) {
for (i = 1; i <= N; i++) {
for (j = 1; j <= N; j++) {
for (z = 1; z <= N; z++) {
if (f[k - 1][i][z] < -inf || f[k - 1][z][j] < -inf) continue;
f[k][i][j] = ((f[k][i][j]) > (f[k - 1][i][z] + f[k - 1][z][j])
? (f[k][i][j])
: (f[k - 1][i][z] + f[k - 1][z][j]));
}
f[k][i][j] =
((f[k][i][j]) > (f[k - 1][i][j]) ? (f[k][i][j]) : (f[k - 1][i][j]));
}
}
}
int ans = 0;
bool flag = 0;
memset(now, 128, sizeof(now));
for (i = 1; i <= N; i++) now[i][i] = 0;
for (k = limk; k >= 0; k--) {
memset(g, 128, sizeof(g));
for (i = 1; i <= N; i++) {
for (j = 1; j <= N; j++) {
for (z = 1; z <= N; z++) {
if (f[k][j][z] < -inf || now[i][j] < -inf) continue;
g[i][z] =
((g[i][z]) > (now[i][j] + f[k][j][z]) ? (g[i][z])
: (now[i][j] + f[k][j][z]));
}
}
}
flag = 0;
for (i = 1; i <= N; i++) {
if (g[i][i] > 0) {
flag = 1;
break;
}
}
if (!flag) {
ans += (1 << k);
for (i = 1; i <= N; i++) {
for (j = 1; j <= N; j++) {
now[i][j] = g[i][j];
}
}
}
}
if (ans == 4095)
cout << "0";
else
cout << ans + 1;
return;
}
signed main() {
ini();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int G[10][310][310];
int T[310][310];
int tmp[310][310];
int n, m;
int f(int k) {
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++) T[j][l] = G[0][j][l];
k--;
for (int i = 0; (1 << i) <= k; i++)
if ((1 << i) & k) {
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++) tmp[j][l] = -1e8;
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++) {
for (int r = 1; r <= n; r++) {
tmp[j][l] = max(tmp[j][l], T[j][r] + G[i][r][l]);
}
}
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++) T[j][l] = tmp[j][l];
}
for (int i = 1; i <= n; i++) {
if (T[i][i] > 0) return 1;
}
return 0;
}
int main() {
scanf("%d %d", &n, &m);
for (int t = 0; 1 << t <= n; t++)
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++) G[t][j][l] = -1e8;
for (int i = 1; i <= n; i++) G[0][i][i] = 0;
for (int i = 1, a, b, c, d; i <= m; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
G[0][a][b] = c;
G[0][b][a] = d;
}
for (int t = 1; 1 << t <= n; t++) {
for (int j = 1; j <= n; j++)
for (int l = 1; l <= n; l++) {
for (int k = 1; k <= n; k++)
G[t][j][l] = max(G[t][j][l], G[t - 1][j][k] + G[t - 1][k][l]);
}
}
int lo = 0, hi = n + 2, mi;
while (lo < hi) {
mi = (lo + hi) / 2;
if (f(mi))
hi = mi;
else
lo = mi + 1;
}
if (lo > n)
printf("0\n");
else
cout << lo << endl;
return 0;
}
|
#include <bits/stdc++.h>
int n;
using namespace std;
const int rozmiar_kubelka = 356;
void dodajElement(int a, long long b, vector<long long> &S) {
a += S.size() / 2;
while (a > 0) {
S[a] += b;
a /= 2;
}
}
long long sumaOdAdoB(int a, int b, vector<long long> &S) {
a += S.size() / 2;
b += S.size() / 2;
long long wynik = 0;
while (a <= b) {
if (a & 1) {
wynik += S[a];
a++;
}
if (!(b & 1)) {
wynik += S[b];
b--;
}
a /= 2;
b /= 2;
}
return wynik;
}
struct matrix {
int tab[310][310];
public:
matrix();
void wypisz();
};
void matrix::wypisz() {
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (n); ++j) cout << tab[i][j] << " ";
cout << endl;
}
}
matrix::matrix() {
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (n); ++j) tab[i][j] = -1000000;
;
}
void mult(matrix &B, matrix &C) {
matrix D = B;
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (n); ++j) {
for (int k = 0; k < (n); ++k) {
D.tab[i][j] = max(D.tab[i][j], B.tab[i][k] + C.tab[k][j]);
}
}
}
B = D;
}
bool czy(matrix &B) {
for (int i = 0; i < (n); ++i)
if (B.tab[i][i] > 0) return true;
return false;
}
int main() {
int m;
scanf("%d%d", &n, &m);
matrix a[10];
for (int i = 0; i < (m); ++i) {
int z, b, c, d;
scanf("%d%d%d%d", &z, &b, &c, &d);
a[0].tab[z - 1][b - 1] = c;
a[0].tab[b - 1][z - 1] = d;
}
for (int i = 0; i < (n); ++i) a[0].tab[i][i] = 0;
for (int i = 0; i < (9); ++i) {
a[i + 1] = a[i];
mult(a[i + 1], a[i]);
}
int it = -1;
for (int i = 0; i < (10); ++i) {
if (czy(a[i])) {
it = i;
break;
}
}
if (it == -1) {
printf("0");
return 0;
}
int ans1, ans2 = 1 << it;
ans1 = 1 << (it - 1);
matrix moja = a[it];
matrix mojaMala = a[it - 1];
for (int i = it - 2; i >= 0; i--) {
matrix res = mojaMala;
mult(res, a[i]);
if (czy(res)) {
moja = res;
ans2 = ans1 + (1 << i);
} else {
mojaMala = res;
ans1 += 1 << i;
}
}
printf("%d", ans2);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 305;
int n, m, f[9][N][N], g[2][N][N];
void clr(int d[N][N]) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i == j)
d[i][j] = 0;
else
d[i][j] = -inf;
}
bool check(int x) {
int cur = 0;
clr(g[cur]);
for (int s = 0; (1 << s) <= n; s++) {
if (!(x >> s & 1)) continue;
cur ^= 1;
clr(g[cur]);
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
g[cur][i][j] = max(g[cur][i][j], g[cur ^ 1][i][k] + f[s][k][j]);
}
for (int i = 1; i <= n; i++)
if (g[cur][i][i] > 0) return true;
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int s = 0; (1 << s) <= n; s++) clr(f[s]);
for (int i = 0; i < m; i++) {
int u, v, a, b;
scanf("%d%d%d%d", &u, &v, &a, &b);
f[0][u][v] = a;
f[0][v][u] = b;
}
for (int s = 1; (1 << s) <= n; s++)
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
f[s][i][j] = max(f[s][i][j], f[s - 1][i][k] + f[s - 1][k][j]);
int l = 1, r = n + 1;
while (l < r) {
int mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l % (n + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int a[9][300][300], b[300][300], c[300][300];
void combine(int a[][300], int b[][300], int c[][300], int n) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) c[i][j] = a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
if (a[i][k] + b[k][j] > c[i][j]) c[i][j] = a[i][k] + b[k][j];
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[0][i][j] = -inf;
for (int i = 0; i < m; i++) {
int x, y, t1, t2;
scanf("%d%d%d%d", &x, &y, &t1, &t2);
x--;
y--;
a[0][x][y] = t1;
a[0][y][x] = t2;
}
for (int i = 1; 1 << i <= n; i++) combine(a[i - 1], a[i - 1], a[i], n);
int ans = 0;
int lg = 0;
while (1 << lg <= n) lg++;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i == j)
b[i][j] = 0;
else
b[i][j] = -inf;
for (int i = lg - 1; i >= 0; i--) {
combine(b, a[i], c, n);
bool flag = false;
for (int j = 0; j < n; j++)
if (c[j][j] > 0) {
flag = true;
break;
}
if (!flag) {
ans += 1 << i;
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) b[j][k] = c[j][k];
}
}
combine(b, a[0], c, n);
bool flag = false;
for (int j = 0; j < n; j++)
if (c[j][j] > 0) {
flag = true;
break;
}
if (!flag) ans = -1;
printf("%d\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300 + 10;
const int maxm = maxn * (maxn - 1);
const int inf = 1e9 + 10;
const int maxk = 10;
int d[maxk][maxn][maxn];
int t[maxn][maxn], nd[maxn][maxn];
int n, m;
void work(int c[][maxn], int a[][maxn], int b[][maxn]) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) c[i][j] = -inf;
for (int k = (1); k <= (n); ++k)
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j)
c[i][j] = max(c[i][j], a[i][k] + b[k][j]);
}
bool judge(int a[][maxn]) {
for (int i = (1); i <= (n); ++i)
if (a[i][i] > 0) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) {
d[0][i][j] = (i == j ? 0 : -inf);
}
int u, v;
for (int i = (1); i <= (m); ++i)
scanf("%d%d", &u, &v), scanf("%d%d", &d[0][u][v], &d[0][v][u]);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) t[i][j] = d[0][i][j];
for (int v = (0); v <= (8); ++v) {
work(d[v + 1], d[v], d[v]);
}
if (!judge(d[9])) {
printf("0\n");
return 0;
}
int ans = 1;
for (int v = 8; v >= 0; --v) {
work(nd, d[v], t);
if (!judge(nd)) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) t[i][j] = nd[i][j];
ans += (1 << v);
}
}
printf("%d\n", ans + 1);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.