{"model_name":"gpt-5.5-medium","codes":{"1":{"ahc001":"#include \nusing namespace std;\n\nstruct Timer {\n chrono::high_resolution_clock::time_point st;\n Timer() : st(chrono::high_resolution_clock::now()) {}\n double elapsed() const {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nstruct Rect {\n int a, b, c, d;\n};\n\nint n;\nvector xs, ys;\nvector rs;\nmt19937 rng(1234567);\nTimer timer_;\n\nlong long area(const Rect& r) {\n return 1LL * (r.c - r.a) * (r.d - r.b);\n}\n\ndouble score_area(long long s, long long r) {\n if (s <= 0) return 0.0;\n double mn = (double)min(s, r);\n double mx = (double)max(s, r);\n double q = mn / mx;\n return 1.0 - (1.0 - q) * (1.0 - q);\n}\n\ndouble evaluate(const vector& rects) {\n double sum = 0.0;\n for (int i = 0; i < n; i++) {\n const auto& e = rects[i];\n bool ok = (e.a <= xs[i] && xs[i] + 1 <= e.c && e.b <= ys[i] && ys[i] + 1 <= e.d);\n if (!ok) continue;\n sum += score_area(area(e), rs[i]);\n }\n return sum;\n}\n\nbool overlap1d(int l1, int r1, int l2, int r2) {\n return max(l1, l2) < min(r1, r2);\n}\n\n/* ---------- recursive slicing construction ---------- */\n\nstruct SplitCand {\n int axis; // 0:x, 1:y\n int k;\n int cut;\n double cost;\n};\n\nlong long sum_r(const vector& ids) {\n long long s = 0;\n for (int id : ids) s += rs[id];\n return s;\n}\n\nvoid build_rec(\n const vector& ids,\n int L, int B, int R, int T,\n vector& out,\n int topK\n) {\n int m = (int)ids.size();\n if (m == 1) {\n out[ids[0]] = {L, B, R, T};\n return;\n }\n\n long long totalTarget = 0;\n for (int id : ids) totalTarget += rs[id];\n\n long long regionArea = 1LL * (R - L) * (T - B);\n vector cands;\n\n for (int axis = 0; axis < 2; axis++) {\n vector v = ids;\n if (axis == 0) {\n sort(v.begin(), v.end(), [&](int p, int q) {\n if (xs[p] != xs[q]) return xs[p] < xs[q];\n return ys[p] < ys[q];\n });\n } else {\n sort(v.begin(), v.end(), [&](int p, int q) {\n if (ys[p] != ys[q]) return ys[p] < ys[q];\n return xs[p] < xs[q];\n });\n }\n\n vector pref(m + 1, 0);\n for (int i = 0; i < m; i++) pref[i + 1] = pref[i] + rs[v[i]];\n\n for (int k = 1; k < m; k++) {\n int coordL = (axis == 0 ? xs[v[k - 1]] : ys[v[k - 1]]);\n int coordR = (axis == 0 ? xs[v[k]] : ys[v[k]]);\n if (coordL >= coordR) continue;\n\n int start = (axis == 0 ? L : B);\n int end = (axis == 0 ? R : T);\n int otherLen = (axis == 0 ? T - B : R - L);\n int len = end - start;\n\n int lo = coordL + 1;\n int hi = coordR;\n lo = max(lo, start + 1);\n hi = min(hi, end - 1);\n if (lo > hi) continue;\n\n long double ratio = (long double)pref[k] / (long double)totalTarget;\n int desired = (int)llround((long double)start + ratio * len);\n int cut = min(max(desired, lo), hi);\n\n long long leftArea = 1LL * (cut - start) * otherLen;\n long long rightArea = regionArea - leftArea;\n long long leftTarget = pref[k];\n long long rightTarget = totalTarget - leftTarget;\n\n double scale = (double)regionArea / (double)totalTarget;\n double er1 = fabs((double)leftArea / (double)leftTarget - scale);\n double er2 = fabs((double)rightArea / (double)rightTarget - scale);\n double cost = er1 * ((double)leftTarget / totalTarget)\n + er2 * ((double)rightTarget / totalTarget);\n\n // If a child is already a leaf, slightly prefer good actual leaf area.\n if (k == 1) {\n int id = v[0];\n cost += 0.08 * (1.0 - score_area(leftArea, rs[id]));\n }\n if (m - k == 1) {\n int id = v[m - 1];\n cost += 0.08 * (1.0 - score_area(rightArea, rs[id]));\n }\n\n cands.push_back({axis, k, cut, cost});\n }\n }\n\n if (cands.empty()) {\n // This should practically never happen for distinct points.\n // Fallback: split by index with a legal-looking middle cut.\n vector v = ids;\n sort(v.begin(), v.end(), [&](int p, int q) {\n if (xs[p] != xs[q]) return xs[p] < xs[q];\n return ys[p] < ys[q];\n });\n int k = m / 2;\n int cut = (L + R) / 2;\n if (cut <= L) cut = L + 1;\n if (cut >= R) cut = R - 1;\n vector A(v.begin(), v.begin() + k), C(v.begin() + k, v.end());\n build_rec(A, L, B, cut, T, out, topK);\n build_rec(C, cut, B, R, T, out, topK);\n return;\n }\n\n sort(cands.begin(), cands.end(), [](const SplitCand& x, const SplitCand& y) {\n return x.cost < y.cost;\n });\n\n int pick = 0;\n if (topK > 1) {\n int lim = min(topK, cands.size());\n double u = uniform_real_distribution(0.0, 1.0)(rng);\n // biased toward better candidates\n pick = min(lim - 1, (int)(u * u * lim));\n }\n\n SplitCand ch = cands[pick];\n\n vector v = ids;\n if (ch.axis == 0) {\n sort(v.begin(), v.end(), [&](int p, int q) {\n if (xs[p] != xs[q]) return xs[p] < xs[q];\n return ys[p] < ys[q];\n });\n } else {\n sort(v.begin(), v.end(), [&](int p, int q) {\n if (ys[p] != ys[q]) return ys[p] < ys[q];\n return xs[p] < xs[q];\n });\n }\n\n vector left(v.begin(), v.begin() + ch.k);\n vector right(v.begin() + ch.k, v.end());\n\n if (ch.axis == 0) {\n build_rec(left, L, B, ch.cut, T, out, topK);\n build_rec(right, ch.cut, B, R, T, out, topK);\n } else {\n build_rec(left, L, B, R, ch.cut, out, topK);\n build_rec(right, L, ch.cut, R, T, out, topK);\n }\n}\n\nvector build_slicing(int topK) {\n vector res(n);\n vector ids(n);\n iota(ids.begin(), ids.end(), 0);\n build_rec(ids, 0, 0, 10000, 10000, res, topK);\n return res;\n}\n\n/* ---------- local improvement: shrink oversized rectangles, expand undersized ones ---------- */\n\nbool shrink_pass(vector& rects, bool randomOrder, double deadline) {\n vector ord(n);\n iota(ord.begin(), ord.end(), 0);\n if (randomOrder) shuffle(ord.begin(), ord.end(), rng);\n\n bool moved = false;\n\n for (int id : ord) {\n if (timer_.elapsed() > deadline) break;\n\n Rect cur = rects[id];\n long long A = area(cur);\n double curScore = score_area(A, rs[id]);\n\n Rect best = cur;\n double bestGain = 1e-15;\n\n auto try_delta = [&](int dir, int maxd) {\n if (maxd <= 0) return;\n int len = (dir < 2 ? cur.d - cur.b : cur.c - cur.a);\n if (len <= 0) return;\n\n vector ds;\n long long excess = A - rs[id];\n if (excess > 0) {\n long long q = excess / len;\n for (long long z : {q - 1, q, q + 1, q + 2}) {\n if (1 <= z && z <= maxd) ds.push_back((int)z);\n }\n }\n ds.push_back(maxd);\n ds.push_back(1);\n sort(ds.begin(), ds.end());\n ds.erase(unique(ds.begin(), ds.end()), ds.end());\n\n for (int dlt : ds) {\n Rect nr = cur;\n if (dir == 0) nr.a += dlt; // shrink left\n if (dir == 1) nr.c -= dlt; // shrink right\n if (dir == 2) nr.b += dlt; // shrink bottom\n if (dir == 3) nr.d -= dlt; // shrink top\n if (!(nr.a < nr.c && nr.b < nr.d)) continue;\n if (!(nr.a <= xs[id] && xs[id] + 1 <= nr.c && nr.b <= ys[id] && ys[id] + 1 <= nr.d)) continue;\n\n double ns = score_area(area(nr), rs[id]);\n double gain = ns - curScore;\n if (gain > bestGain) {\n bestGain = gain;\n best = nr;\n }\n }\n };\n\n try_delta(0, xs[id] - cur.a);\n try_delta(1, cur.c - (xs[id] + 1));\n try_delta(2, ys[id] - cur.b);\n try_delta(3, cur.d - (ys[id] + 1));\n\n if (bestGain > 1e-14) {\n rects[id] = best;\n moved = true;\n }\n }\n\n return moved;\n}\n\nint max_expand_delta(const vector& rects, int id, int dir) {\n const Rect& r = rects[id];\n int lim = 0;\n\n if (dir == 0) { // left\n lim = r.a;\n for (int j = 0; j < n; j++) if (j != id) {\n const Rect& o = rects[j];\n if (overlap1d(r.b, r.d, o.b, o.d) && o.c <= r.a) {\n lim = min(lim, r.a - o.c);\n }\n }\n } else if (dir == 1) { // right\n lim = 10000 - r.c;\n for (int j = 0; j < n; j++) if (j != id) {\n const Rect& o = rects[j];\n if (overlap1d(r.b, r.d, o.b, o.d) && o.a >= r.c) {\n lim = min(lim, o.a - r.c);\n }\n }\n } else if (dir == 2) { // down\n lim = r.b;\n for (int j = 0; j < n; j++) if (j != id) {\n const Rect& o = rects[j];\n if (overlap1d(r.a, r.c, o.a, o.c) && o.d <= r.b) {\n lim = min(lim, r.b - o.d);\n }\n }\n } else { // up\n lim = 10000 - r.d;\n for (int j = 0; j < n; j++) if (j != id) {\n const Rect& o = rects[j];\n if (overlap1d(r.a, r.c, o.a, o.c) && o.b >= r.d) {\n lim = min(lim, o.b - r.d);\n }\n }\n }\n\n return lim;\n}\n\nbool expand_pass(vector& rects, bool randomOrder, double deadline) {\n vector ord(n);\n iota(ord.begin(), ord.end(), 0);\n if (randomOrder) shuffle(ord.begin(), ord.end(), rng);\n\n bool moved = false;\n\n for (int id : ord) {\n if (timer_.elapsed() > deadline) break;\n\n Rect cur = rects[id];\n long long A = area(cur);\n double curScore = score_area(A, rs[id]);\n\n Rect best = cur;\n double bestGain = 1e-15;\n\n for (int dir = 0; dir < 4; dir++) {\n int maxd = max_expand_delta(rects, id, dir);\n if (maxd <= 0) continue;\n\n int len = (dir < 2 ? cur.d - cur.b : cur.c - cur.a);\n if (len <= 0) continue;\n\n vector ds;\n long long need = rs[id] - A;\n if (need > 0) {\n long long q = need / len;\n for (long long z : {q - 1, q, q + 1, q + 2}) {\n if (1 <= z && z <= maxd) ds.push_back((int)z);\n }\n }\n ds.push_back(maxd);\n ds.push_back(1);\n sort(ds.begin(), ds.end());\n ds.erase(unique(ds.begin(), ds.end()), ds.end());\n\n for (int dlt : ds) {\n Rect nr = cur;\n if (dir == 0) nr.a -= dlt;\n if (dir == 1) nr.c += dlt;\n if (dir == 2) nr.b -= dlt;\n if (dir == 3) nr.d += dlt;\n\n double ns = score_area(area(nr), rs[id]);\n double gain = ns - curScore;\n\n // tiny random tie breaker\n gain += uniform_real_distribution(0.0, 1e-16)(rng);\n\n if (gain > bestGain) {\n bestGain = gain;\n best = nr;\n }\n }\n }\n\n if (bestGain > 1e-14) {\n rects[id] = best;\n moved = true;\n }\n }\n\n return moved;\n}\n\nvoid shrink_only(vector& rects, double deadline) {\n for (int it = 0; it < 20 && timer_.elapsed() < deadline; it++) {\n bool mv = shrink_pass(rects, false, deadline);\n if (!mv) break;\n }\n}\n\nvoid improve_solution(vector& rects, double deadline) {\n for (int it = 0; timer_.elapsed() < deadline; it++) {\n bool moved = false;\n moved |= shrink_pass(rects, true, deadline);\n moved |= expand_pass(rects, true, deadline);\n if (!moved) break;\n }\n}\n\n/* ---------- main ---------- */\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> n;\n xs.resize(n);\n ys.resize(n);\n rs.resize(n);\n for (int i = 0; i < n; i++) {\n cin >> xs[i] >> ys[i] >> rs[i];\n }\n\n vector best(n);\n for (int i = 0; i < n; i++) {\n best[i] = {xs[i], ys[i], xs[i] + 1, ys[i] + 1};\n }\n double bestScore = evaluate(best);\n\n auto consider_best = [&](const vector& sol) {\n double sc = evaluate(sol);\n if (sc > bestScore) {\n bestScore = sc;\n best = sol;\n }\n };\n\n vector>> tops;\n\n auto insert_top = [&](vector sol) {\n double sc = evaluate(sol);\n tops.push_back({sc, sol});\n sort(tops.begin(), tops.end(), [](auto& p, auto& q) {\n return p.first > q.first;\n });\n if ((int)tops.size() > 8) tops.pop_back();\n consider_best(sol);\n };\n\n // Generate many slicing partitions.\n int cnt = 0;\n while (timer_.elapsed() < 3.20) {\n int topK;\n if (cnt == 0) topK = 1;\n else if (cnt % 4 == 0) topK = 3;\n else if (cnt % 4 == 1) topK = 5;\n else topK = 10;\n\n vector sol = build_slicing(topK);\n shrink_only(sol, 3.20);\n insert_top(sol);\n cnt++;\n }\n\n sort(tops.begin(), tops.end(), [](auto& p, auto& q) {\n return p.first > q.first;\n });\n\n // Improve best slicing candidates.\n int m = (int)tops.size();\n for (int i = 0; i < m && timer_.elapsed() < 4.72; i++) {\n vector sol = tops[i].second;\n double remain = 4.72 - timer_.elapsed();\n double deadline = timer_.elapsed() + remain / max(1, m - i);\n improve_solution(sol, deadline);\n consider_best(sol);\n }\n\n // One extra expansion-only solution from unit rectangles, useful for some cases.\n if (timer_.elapsed() < 4.90) {\n vector sol(n);\n for (int i = 0; i < n; i++) {\n sol[i] = {xs[i], ys[i], xs[i] + 1, ys[i] + 1};\n }\n improve_solution(sol, 4.90);\n consider_best(sol);\n }\n\n for (int i = 0; i < n; i++) {\n cout << best[i].a << ' ' << best[i].b << ' ' << best[i].c << ' ' << best[i].d << '\\n';\n }\n\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x;\n XorShift(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int n) {\n return (int)(next() % n);\n }\n double nextDouble() {\n return (next() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nconstexpr int N = 50;\nconstexpr int V = N * N;\n\nint si, sj;\nint tile_id[V];\nint point_val[V];\n\nint nb[V][4];\nchar nb_dir[V][4];\n\nstruct Path {\n int score = 0;\n vector cells;\n string moves;\n};\n\nstruct Params {\n double wp;\n double wd;\n double w1;\n double w2;\n double noise;\n double randomMoveProb;\n};\n\nParams make_params(XorShift &rng) {\n int mode = rng.nextInt(8);\n Params p;\n\n if (mode == 0) {\n // score-heavy\n p = {1.8, 4.0, 0.20, 0.08, 30.0, 0.02};\n } else if (mode == 1) {\n // Warnsdorff-like: prefer low onward degree\n p = {1.0, -22.0, 0.10, 0.05, 45.0, 0.03};\n } else if (mode == 2) {\n // balanced\n p = {1.2, 8.0, 0.35, 0.10, 55.0, 0.04};\n } else if (mode == 3) {\n // strongly randomized\n p = {1.0, 0.0, 0.15, 0.05, 120.0, 0.12};\n } else if (mode == 4) {\n // low-degree explorer\n p = {0.8, -35.0, 0.05, 0.03, 60.0, 0.04};\n } else if (mode == 5) {\n // future-option preserving\n p = {1.0, 18.0, 0.45, 0.15, 45.0, 0.02};\n } else if (mode == 6) {\n // high score but avoid immediate dead ends\n p = {2.4, -8.0, 0.25, 0.08, 40.0, 0.02};\n } else {\n // almost random greedy\n p = {0.9, 2.0, 0.10, 0.04, 160.0, 0.15};\n }\n\n double a = 0.75 + rng.nextDouble() * 0.7;\n p.wp *= a;\n p.wd *= 0.75 + rng.nextDouble() * 0.7;\n p.w1 *= 0.7 + rng.nextDouble() * 0.8;\n p.w2 *= 0.7 + rng.nextDouble() * 0.8;\n p.noise *= 0.7 + rng.nextDouble() * 0.8;\n\n return p;\n}\n\nint choose_next(\n int pos,\n const vector &seen,\n int mark,\n const Params &par,\n XorShift &rng,\n char &out_dir\n) {\n int cand[4];\n char cdir[4];\n int cnt = 0;\n\n for (int k = 0; k < 4; k++) {\n int to = nb[pos][k];\n if (to < 0) continue;\n int tid = tile_id[to];\n if (seen[tid] == mark) continue;\n cand[cnt] = to;\n cdir[cnt] = nb_dir[pos][k];\n cnt++;\n }\n\n if (cnt == 0) return -1;\n if (cnt == 1) {\n out_dir = cdir[0];\n return cand[0];\n }\n\n if (rng.nextDouble() < par.randomMoveProb) {\n int id = rng.nextInt(cnt);\n out_dir = cdir[id];\n return cand[id];\n }\n\n double best_score = -1e100;\n int best_id = 0;\n\n for (int idx = 0; idx < cnt; idx++) {\n int to = cand[idx];\n int tid_to = tile_id[to];\n\n int degree1 = 0;\n int best_next_point = 0;\n double best_look2 = 0.0;\n\n for (int k = 0; k < 4; k++) {\n int v1 = nb[to][k];\n if (v1 < 0) continue;\n int tid1 = tile_id[v1];\n if (tid1 == tid_to) continue;\n if (seen[tid1] == mark) continue;\n\n degree1++;\n best_next_point = max(best_next_point, point_val[v1]);\n\n int degree2 = 0;\n int best_p2 = 0;\n for (int l = 0; l < 4; l++) {\n int v2 = nb[v1][l];\n if (v2 < 0) continue;\n int tid2 = tile_id[v2];\n if (tid2 == tid_to || tid2 == tid1) continue;\n if (seen[tid2] == mark) continue;\n degree2++;\n best_p2 = max(best_p2, point_val[v2]);\n }\n\n double look2 = point_val[v1] + 8.0 * degree2 + 0.25 * best_p2;\n best_look2 = max(best_look2, look2);\n }\n\n double eval = 0.0;\n eval += par.wp * point_val[to];\n eval += par.wd * degree1;\n eval += par.w1 * best_next_point;\n eval += par.w2 * best_look2;\n eval += par.noise * (rng.nextDouble() - 0.5);\n\n if (eval > best_score) {\n best_score = eval;\n best_id = idx;\n }\n }\n\n out_dir = cdir[best_id];\n return cand[best_id];\n}\n\nPath build_path_from_prefix(\n const Path *base,\n int prefix_len,\n vector &seen,\n int mark,\n XorShift &rng\n) {\n Path cur;\n cur.cells.reserve(V);\n cur.moves.reserve(V);\n\n if (base == nullptr) {\n int start = si * N + sj;\n cur.cells.push_back(start);\n cur.score = point_val[start];\n seen[tile_id[start]] = mark;\n } else {\n prefix_len = max(prefix_len, 1);\n prefix_len = min(prefix_len, (int)base->cells.size());\n\n cur.cells.assign(base->cells.begin(), base->cells.begin() + prefix_len);\n cur.moves.assign(base->moves.begin(), base->moves.begin() + max(0, prefix_len - 1));\n\n cur.score = 0;\n for (int c : cur.cells) {\n cur.score += point_val[c];\n seen[tile_id[c]] = mark;\n }\n }\n\n Params par = make_params(rng);\n\n while (true) {\n int pos = cur.cells.back();\n char d = '?';\n int nxt = choose_next(pos, seen, mark, par, rng, d);\n if (nxt < 0) break;\n\n seen[tile_id[nxt]] = mark;\n cur.cells.push_back(nxt);\n cur.moves.push_back(d);\n cur.score += point_val[nxt];\n }\n\n return cur;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> si >> sj;\n\n int max_tid = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int x;\n cin >> x;\n int id = i * N + j;\n tile_id[id] = x;\n max_tid = max(max_tid, x);\n }\n }\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> point_val[i * N + j];\n }\n }\n\n for (int i = 0; i < V; i++) {\n for (int k = 0; k < 4; k++) {\n nb[i][k] = -1;\n nb_dir[i][k] = '?';\n }\n }\n\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dc[4] = {'U', 'D', 'L', 'R'};\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int id = i * N + j;\n for (int k = 0; k < 4; k++) {\n int ni = i + di[k];\n int nj = j + dj[k];\n if (0 <= ni && ni < N && 0 <= nj && nj < N) {\n nb[id][k] = ni * N + nj;\n nb_dir[id][k] = dc[k];\n }\n }\n }\n }\n\n uint64_t seed = 123456789;\n seed ^= (uint64_t)(si * 51 + sj + 1) * 1000003ULL;\n for (int i = 0; i < V; i++) {\n seed ^= (uint64_t)(tile_id[i] + 1) * 11995408973635179863ULL;\n seed ^= (uint64_t)(point_val[i] + 7) * 10150724397891781847ULL;\n seed = seed * 6364136223846793005ULL + 1442695040888963407ULL;\n }\n\n XorShift rng(seed);\n\n vector seen(max_tid + 1, 0);\n int mark = 1;\n\n Path best;\n vector pool;\n const int POOL_SIZE = 18;\n\n auto consider = [&](const Path &p) {\n if (p.score > best.score) {\n best = p;\n }\n\n if ((int)pool.size() < POOL_SIZE) {\n pool.push_back(p);\n } else {\n int worst = 0;\n for (int i = 1; i < (int)pool.size(); i++) {\n if (pool[i].score < pool[worst].score) worst = i;\n }\n if (p.score > pool[worst].score) {\n pool[worst] = p;\n }\n }\n };\n\n auto start_time = chrono::steady_clock::now();\n const double TIME_LIMIT = 1.90;\n\n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n\n mark++;\n if (mark == INT_MAX) {\n fill(seen.begin(), seen.end(), 0);\n mark = 1;\n }\n\n Path cur;\n\n bool fresh = pool.empty() || rng.nextInt(100) < 25;\n\n if (fresh) {\n cur = build_path_from_prefix(nullptr, 0, seen, mark, rng);\n } else {\n const Path *base;\n if (rng.nextInt(100) < 65) {\n base = &best;\n } else {\n base = &pool[rng.nextInt((int)pool.size())];\n }\n\n int L = (int)base->cells.size();\n int prefix_len = 1;\n\n if (L <= 1) {\n prefix_len = 1;\n } else {\n double u = rng.nextDouble();\n double x;\n int typ = rng.nextInt(100);\n\n if (typ < 50) {\n // keep a long prefix, rebuild only the tail\n x = sqrt(u);\n } else if (typ < 82) {\n // uniform cut\n x = u;\n } else {\n // sometimes change early decisions\n x = u * u;\n }\n\n prefix_len = 1 + (int)(x * (L - 1));\n prefix_len = min(prefix_len, L - 1);\n prefix_len = max(prefix_len, 1);\n }\n\n cur = build_path_from_prefix(base, prefix_len, seen, mark, rng);\n }\n\n consider(cur);\n }\n\n cout << best.moves << '\\n';\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nstatic constexpr int N = 30;\nstatic constexpr int HEDGE = 30 * 29;\nstatic constexpr int VEDGE = 29 * 30;\nstatic constexpr int E = HEDGE + VEDGE;\nstatic constexpr int VAR = 60;\n\nstruct Obs {\n array x;\n long long y;\n};\n\nvector observations;\n\ndouble hcost[N], vcost[N];\ndouble offset_edge[E];\nint edge_count[E];\n\nuint64_t rng_state = 88172645463325252ull;\n\nuint64_t xorshift() {\n rng_state ^= rng_state << 7;\n rng_state ^= rng_state >> 9;\n return rng_state;\n}\n\ndouble clamp_double(double x, double lo, double hi) {\n return max(lo, min(hi, x));\n}\n\nint hid(int i, int j) {\n return i * 29 + j;\n}\n\nint vid(int i, int j) {\n return HEDGE + i * 30 + j;\n}\n\ndouble smooth_offset_h(int i, int j) {\n double num = 0.0;\n double den = 5.0;\n\n for (int dj = -2; dj <= 2; dj++) {\n int nj = j + dj;\n if (nj < 0 || nj >= 29) continue;\n\n int id = hid(i, nj);\n double w = (3 - abs(dj)) * edge_count[id];\n num += offset_edge[id] * w;\n den += w;\n }\n\n return num / den;\n}\n\ndouble smooth_offset_v(int i, int j) {\n double num = 0.0;\n double den = 5.0;\n\n for (int di = -2; di <= 2; di++) {\n int ni = i + di;\n if (ni < 0 || ni >= 29) continue;\n\n int id = vid(ni, j);\n double w = (3 - abs(di)) * edge_count[id];\n num += offset_edge[id] * w;\n den += w;\n }\n\n return num / den;\n}\n\ndouble model_weight_raw(int id) {\n double w;\n\n if (id < HEDGE) {\n int i = id / 29;\n int j = id % 29;\n w = hcost[i] + smooth_offset_h(i, j);\n } else {\n int x = id - HEDGE;\n int i = x / 30;\n int j = x % 30;\n w = vcost[j] + smooth_offset_v(i, j);\n }\n\n return clamp_double(w, 800.0, 9500.0);\n}\n\ndouble model_weight_for_search(int id, int turn) {\n double learned = model_weight_raw(id);\n\n double rel = ((double)turn - 50.0) / 500.0;\n rel = clamp_double(rel, 0.0, 1.0);\n\n double w = 5000.0 * (1.0 - rel) + learned * rel;\n return clamp_double(w, 800.0, 9500.0);\n}\n\nvoid solve_row_col_model() {\n static double a[VAR][VAR + 1];\n\n for (int i = 0; i < VAR; i++) {\n for (int j = 0; j <= VAR; j++) {\n a[i][j] = 0.0;\n }\n }\n\n const double lambda = 200.0;\n\n for (int i = 0; i < VAR; i++) {\n a[i][i] += lambda;\n }\n\n for (const auto& ob : observations) {\n vector> nz;\n int len = 0;\n\n for (int i = 0; i < VAR; i++) {\n if (ob.x[i]) {\n nz.push_back({i, ob.x[i]});\n len += ob.x[i];\n }\n }\n\n double r = (double)ob.y - 5000.0 * len;\n\n for (auto [i, xi] : nz) {\n a[i][VAR] += xi * r;\n for (auto [j, xj] : nz) {\n a[i][j] += (double)xi * xj;\n }\n }\n }\n\n for (int col = 0; col < VAR; col++) {\n int piv = col;\n for (int row = col + 1; row < VAR; row++) {\n if (fabs(a[row][col]) > fabs(a[piv][col])) {\n piv = row;\n }\n }\n\n if (piv != col) {\n for (int j = col; j <= VAR; j++) {\n swap(a[piv][j], a[col][j]);\n }\n }\n\n double div = a[col][col];\n if (fabs(div) < 1e-9) continue;\n\n for (int j = col; j <= VAR; j++) {\n a[col][j] /= div;\n }\n\n for (int row = 0; row < VAR; row++) {\n if (row == col) continue;\n\n double factor = a[row][col];\n if (fabs(factor) < 1e-12) continue;\n\n for (int j = col; j <= VAR; j++) {\n a[row][j] -= factor * a[col][j];\n }\n }\n }\n\n for (int i = 0; i < 30; i++) {\n hcost[i] = clamp_double(5000.0 + a[i][VAR], 1000.0, 9000.0);\n }\n\n for (int j = 0; j < 30; j++) {\n vcost[j] = clamp_double(5000.0 + a[30 + j][VAR], 1000.0, 9000.0);\n }\n}\n\nstring manhattan_path(int si, int sj, int ti, int tj, bool horizontal_first) {\n string res;\n\n auto add_vertical = [&]() {\n if (si < ti) {\n while (si < ti) {\n res.push_back('D');\n si++;\n }\n } else {\n while (si > ti) {\n res.push_back('U');\n si--;\n }\n }\n };\n\n auto add_horizontal = [&]() {\n if (sj < tj) {\n while (sj < tj) {\n res.push_back('R');\n sj++;\n }\n } else {\n while (sj > tj) {\n res.push_back('L');\n sj--;\n }\n }\n };\n\n if (horizontal_first) {\n add_horizontal();\n add_vertical();\n } else {\n add_vertical();\n add_horizontal();\n }\n\n return res;\n}\n\nvoid extract_features(\n int si,\n int sj,\n const string& path,\n array& feat,\n vector& edges\n) {\n feat.fill(0);\n edges.clear();\n\n int i = si;\n int j = sj;\n\n for (char c : path) {\n if (c == 'R') {\n int id = hid(i, j);\n edges.push_back(id);\n feat[i]++;\n j++;\n } else if (c == 'L') {\n int id = hid(i, j - 1);\n edges.push_back(id);\n feat[i]++;\n j--;\n } else if (c == 'D') {\n int id = vid(i, j);\n edges.push_back(id);\n feat[30 + j]++;\n i++;\n } else if (c == 'U') {\n int id = vid(i - 1, j);\n edges.push_back(id);\n feat[30 + j]++;\n i--;\n }\n }\n}\n\ndouble estimated_path_cost(int si, int sj, const string& path, int turn) {\n int i = si;\n int j = sj;\n double cost = 0.0;\n\n for (char c : path) {\n if (c == 'R') {\n cost += model_weight_for_search(hid(i, j), turn);\n j++;\n } else if (c == 'L') {\n cost += model_weight_for_search(hid(i, j - 1), turn);\n j--;\n } else if (c == 'D') {\n cost += model_weight_for_search(vid(i, j), turn);\n i++;\n } else {\n cost += model_weight_for_search(vid(i - 1, j), turn);\n i--;\n }\n }\n\n return cost;\n}\n\nstring choose_early_path(int si, int sj, int ti, int tj, int turn) {\n string p1 = manhattan_path(si, sj, ti, tj, true);\n string p2 = manhattan_path(si, sj, ti, tj, false);\n\n if (p1 == p2) return p1;\n\n if (turn < 60) {\n return (xorshift() & 1) ? p1 : p2;\n }\n\n double c1 = estimated_path_cost(si, sj, p1, turn);\n double c2 = estimated_path_cost(si, sj, p2, turn);\n\n int eps = (turn < 150 ? 20 : 8);\n if ((int)(xorshift() % 100) < eps) {\n return (c1 < c2) ? p2 : p1;\n }\n\n return (c1 < c2) ? p1 : p2;\n}\n\nstring dijkstra_path(int si, int sj, int ti, int tj, int turn) {\n const double INF = 1e100;\n\n vector dist(900, INF);\n vector parent(900, -1);\n vector pchar(900, '?');\n\n auto node = [](int i, int j) {\n return i * 30 + j;\n };\n\n priority_queue, vector>, greater>> pq;\n\n int s = node(si, sj);\n int t = node(ti, tj);\n\n dist[s] = 0.0;\n pq.push({0.0, s});\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n\n if (d != dist[u]) continue;\n if (u == t) break;\n\n int i = u / 30;\n int j = u % 30;\n\n auto relax = [&](int ni, int nj, char c, int eid) {\n int v = node(ni, nj);\n double nd = d + model_weight_for_search(eid, turn);\n\n if (nd < dist[v]) {\n dist[v] = nd;\n parent[v] = u;\n pchar[v] = c;\n pq.push({nd, v});\n }\n };\n\n if (i > 0) relax(i - 1, j, 'U', vid(i - 1, j));\n if (i + 1 < 30) relax(i + 1, j, 'D', vid(i, j));\n if (j > 0) relax(i, j - 1, 'L', hid(i, j - 1));\n if (j + 1 < 30) relax(i, j + 1, 'R', hid(i, j));\n }\n\n string res;\n int cur = t;\n\n while (cur != s) {\n res.push_back(pchar[cur]);\n cur = parent[cur];\n }\n\n reverse(res.begin(), res.end());\n return res;\n}\n\nvoid update_edge_offsets(long long y, const vector& edges, int turn) {\n if (edges.empty()) return;\n\n double pred = 0.0;\n for (int id : edges) {\n pred += model_weight_raw(id);\n }\n\n double err = (double)y - pred;\n double alpha = 0.18 / (1.0 + turn / 1200.0);\n double add = alpha * err / (double)edges.size();\n\n for (int id : edges) {\n offset_edge[id] += add;\n offset_edge[id] = clamp_double(offset_edge[id], -4000.0, 4000.0);\n edge_count[id]++;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n for (int i = 0; i < 30; i++) {\n hcost[i] = 5000.0;\n vcost[i] = 5000.0;\n }\n\n for (int i = 0; i < E; i++) {\n offset_edge[i] = 0.0;\n edge_count[i] = 0;\n }\n\n for (int turn = 0; turn < 1000; turn++) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) {\n return 0;\n }\n\n string path;\n\n if (turn < 180) {\n path = choose_early_path(si, sj, ti, tj, turn);\n } else {\n path = dijkstra_path(si, sj, ti, tj, turn);\n }\n\n array feat;\n vector edges;\n extract_features(si, sj, path, feat, edges);\n\n cout << path << endl;\n cout.flush();\n\n long long result;\n if (!(cin >> result)) {\n return 0;\n }\n\n Obs ob;\n ob.x = feat;\n ob.y = result;\n observations.push_back(ob);\n\n if (turn < 300 || turn % 5 == 4 || turn >= 900) {\n solve_row_col_model();\n }\n\n update_edge_offsets(result, edges, turn);\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic constexpr int N = 20;\nstatic constexpr int C = 400;\nstatic constexpr int ALPHA = 8;\nstatic constexpr long long BIG = 2000000000LL;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n XorShift() {}\n XorShift(uint64_t seed) : x(seed) {}\n uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int n) {\n return (int)(next() % n);\n }\n double nextDouble() {\n return (next() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Evaluator {\n int M;\n vector s;\n vector board;\n\n // placement id = sid * 800 + idx\n // idx: dir * 400 + start_cell\n vector mis;\n vector> hist;\n vector val;\n vector> inc; // code = pid * 8 + required_char\n\n long long obj = 0;\n int covered = 0;\n\n long long nearTable[13] = {\n 0,\n 1000000,\n 300000,\n 100000,\n 30000,\n 10000,\n 3000,\n 1000,\n 300,\n 100,\n 30,\n 10,\n 0\n };\n\n Evaluator() {}\n\n Evaluator(const vector& _s, const vector& _board) {\n s = _s;\n M = (int)s.size();\n board = _board;\n build();\n }\n\n inline int cellH(int i, int j, int p) const {\n return i * N + ((j + p) % N);\n }\n\n inline int cellV(int i, int j, int p) const {\n return ((i + p) % N) * N + j;\n }\n\n inline long long calcVal(int sid) const {\n if (hist[sid][0] > 0) {\n return BIG + min(hist[sid][0], 1000);\n }\n for (int d = 1; d <= 12; d++) {\n if (hist[sid][d] > 0) {\n return nearTable[d] + min(hist[sid][d], 1000);\n }\n }\n return 0;\n }\n\n inline int placementCell(int sid, int idx, int p) const {\n int dir = idx / 400;\n int st = idx % 400;\n int i = st / N;\n int j = st % N;\n if (dir == 0) return cellH(i, j, p);\n else return cellV(i, j, p);\n }\n\n void build() {\n int P = M * 800;\n mis.assign(P, 0);\n hist.assign(M, {});\n val.assign(M, 0);\n inc.assign(C, {});\n\n int totalLen = 0;\n for (auto& t : s) totalLen += (int)t.size();\n int reservePerCell = max(1, M * 2 * 12);\n for (int c = 0; c < C; c++) inc[c].reserve(reservePerCell);\n\n for (int sid = 0; sid < M; sid++) {\n int len = (int)s[sid].size();\n\n for (int idx = 0; idx < 800; idx++) {\n int pid = sid * 800 + idx;\n int mm = 0;\n\n for (int p = 0; p < len; p++) {\n int cell = placementCell(sid, idx, p);\n int req = s[sid][p] - 'A';\n if (board[cell] != req) mm++;\n inc[cell].push_back(pid * 8 + req);\n }\n\n mis[pid] = (unsigned char)mm;\n hist[sid][mm]++;\n }\n }\n\n obj = 0;\n covered = 0;\n for (int sid = 0; sid < M; sid++) {\n val[sid] = calcVal(sid);\n obj += val[sid];\n if (hist[sid][0] > 0) covered++;\n }\n }\n\n long long applyChange(int cell, int nc) {\n int oc = board[cell];\n if (oc == nc) return 0;\n\n long long deltaObj = 0;\n\n for (int code : inc[cell]) {\n int req = code & 7;\n if (req != oc && req != nc) continue;\n\n int pid = code >> 3;\n int sid = pid / 800;\n\n long long oldVal = val[sid];\n bool oldCov = hist[sid][0] > 0;\n\n int oldMis = mis[pid];\n hist[sid][oldMis]--;\n\n int nm = oldMis;\n if (req == oc) nm++;\n if (req == nc) nm--;\n\n mis[pid] = (unsigned char)nm;\n hist[sid][nm]++;\n\n bool newCov = hist[sid][0] > 0;\n if (oldCov && !newCov) covered--;\n if (!oldCov && newCov) covered++;\n\n long long newVal = calcVal(sid);\n val[sid] = newVal;\n deltaObj += newVal - oldVal;\n }\n\n board[cell] = (unsigned char)nc;\n obj += deltaObj;\n return deltaObj;\n }\n\n int minMismatchOfString(int sid) const {\n for (int d = 0; d <= 12; d++) {\n if (hist[sid][d] > 0) return d;\n }\n return 13;\n }\n\n int bestPlacementIndex(int sid, XorShift& rng) const {\n int best = 100;\n int cnt = 0;\n int bestIdx = 0;\n\n int base = sid * 800;\n for (int idx = 0; idx < 800; idx++) {\n int mm = mis[base + idx];\n if (mm < best) {\n best = mm;\n cnt = 1;\n bestIdx = idx;\n } else if (mm == best) {\n cnt++;\n if (rng.nextInt(cnt) == 0) bestIdx = idx;\n }\n }\n return bestIdx;\n }\n\n long long stampPlacement(int sid, int idx, vector>& changed) {\n changed.clear();\n long long delta = 0;\n int len = (int)s[sid].size();\n\n for (int p = 0; p < len; p++) {\n int cell = placementCell(sid, idx, p);\n int req = s[sid][p] - 'A';\n if (board[cell] != req) {\n int old = board[cell];\n changed.push_back({cell, old});\n delta += applyChange(cell, req);\n }\n }\n return delta;\n }\n\n void revertChanges(vector>& changed) {\n for (int i = (int)changed.size() - 1; i >= 0; i--) {\n applyChange(changed[i].first, changed[i].second);\n }\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto startTime = chrono::steady_clock::now();\n\n int inputN, M;\n cin >> inputN >> M;\n\n vector s(M);\n for (int i = 0; i < M; i++) cin >> s[i];\n\n XorShift rng(123456789);\n\n vector freq(ALPHA, 1);\n for (auto& t : s) {\n for (char ch : t) freq[ch - 'A']++;\n }\n vector pref(ALPHA);\n pref[0] = freq[0];\n for (int i = 1; i < ALPHA; i++) pref[i] = pref[i - 1] + freq[i];\n int fsum = pref.back();\n\n auto randomChar = [&]() {\n int r = rng.nextInt(fsum);\n return (unsigned char)(lower_bound(pref.begin(), pref.end(), r + 1) - pref.begin());\n };\n\n vector board(C);\n for (int i = 0; i < C; i++) board[i] = randomChar();\n\n auto placementCellRaw = [&](int idx, int p) {\n int dir = idx / 400;\n int st = idx % 400;\n int i = st / N;\n int j = st % N;\n if (dir == 0) return i * N + ((j + p) % N);\n else return ((i + p) % N) * N + j;\n };\n\n auto conflictOfPlacement = [&](const string& t, int idx) {\n int conf = 0;\n int len = (int)t.size();\n for (int p = 0; p < len; p++) {\n int cell = placementCellRaw(idx, p);\n int req = t[p] - 'A';\n if (board[cell] != req) conf++;\n }\n return conf;\n };\n\n auto stampRaw = [&](const string& t, int idx) {\n int len = (int)t.size();\n for (int p = 0; p < len; p++) {\n int cell = placementCellRaw(idx, p);\n board[cell] = (unsigned char)(t[p] - 'A');\n }\n };\n\n vector order(M);\n iota(order.begin(), order.end(), 0);\n\n // Initial construction by repeated stamping.\n int initPasses = 6;\n for (int pass = 0; pass < initPasses; pass++) {\n if (pass == initPasses - 1) {\n sort(order.begin(), order.end(), [&](int a, int b) {\n return s[a].size() < s[b].size(); // long strings later\n });\n } else {\n shuffle(order.begin(), order.end(), std::mt19937((unsigned)rng.next()));\n }\n\n for (int sid : order) {\n int bestConf = 100;\n int bestIdx = 0;\n int cnt = 0;\n\n for (int idx = 0; idx < 800; idx++) {\n int conf = conflictOfPlacement(s[sid], idx);\n if (conf < bestConf) {\n bestConf = conf;\n bestIdx = idx;\n cnt = 1;\n } else if (conf == bestConf) {\n cnt++;\n if (rng.nextInt(cnt) == 0) bestIdx = idx;\n }\n }\n stampRaw(s[sid], bestIdx);\n }\n }\n\n Evaluator ev(s, board);\n\n auto elapsedSec = [&]() {\n return chrono::duration(chrono::steady_clock::now() - startTime).count();\n };\n\n const double searchLimit = 2.65;\n int iter = 0;\n double elapsed = 0.0;\n\n vector> changed;\n\n while (true) {\n if ((iter & 15) == 0) {\n elapsed = elapsedSec();\n if (elapsed > searchLimit) break;\n }\n\n double progress = min(1.0, elapsed / searchLimit);\n double temp = 200000.0 * (1.0 - progress) + 2000.0 * progress;\n\n if (ev.covered < M && iter % 5 == 0) {\n // Macro repair: force an uncovered string to match at its closest placement.\n int bestSid = -1;\n int bestMM = 100;\n int cnt = 0;\n\n for (int sid = 0; sid < M; sid++) {\n if (ev.hist[sid][0] == 0) {\n int mm = ev.minMismatchOfString(sid);\n if (mm < bestMM) {\n bestMM = mm;\n bestSid = sid;\n cnt = 1;\n } else if (mm == bestMM) {\n cnt++;\n if (rng.nextInt(cnt) == 0) bestSid = sid;\n }\n }\n }\n\n if (bestSid != -1) {\n int idx = ev.bestPlacementIndex(bestSid, rng);\n long long delta = ev.stampPlacement(bestSid, idx, changed);\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (delta > -BIG / 2) {\n double prob = exp((double)delta / temp);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (!accept) ev.revertChanges(changed);\n }\n } else {\n // Single-cell local search.\n int cell = rng.nextInt(C);\n int old = ev.board[cell];\n\n long long bestDelta = 0;\n int bestChar = old;\n\n for (int nc = 0; nc < ALPHA; nc++) {\n if (nc == old) continue;\n long long d = ev.applyChange(cell, nc);\n ev.applyChange(cell, old);\n\n if (d > bestDelta) {\n bestDelta = d;\n bestChar = nc;\n }\n }\n\n if (bestChar != old) {\n ev.applyChange(cell, bestChar);\n } else {\n int nc = rng.nextInt(ALPHA);\n if (nc == old) nc = (nc + 1) % ALPHA;\n\n long long d = ev.applyChange(cell, nc);\n bool accept = false;\n if (d >= 0) accept = true;\n else if (d > -BIG / 2) {\n double prob = exp((double)d / temp);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (!accept) ev.applyChange(cell, old);\n }\n }\n\n iter++;\n }\n\n // If all strings are covered, greedily replace unnecessary cells by dots.\n if (ev.covered == M) {\n vector cells(C);\n iota(cells.begin(), cells.end(), 0);\n shuffle(cells.begin(), cells.end(), std::mt19937((unsigned)rng.next()));\n\n for (int cell : cells) {\n int old = ev.board[cell];\n if (old == 8) continue;\n\n ev.applyChange(cell, 8);\n if (ev.covered < M) {\n ev.applyChange(cell, old);\n }\n }\n }\n\n for (int i = 0; i < N; i++) {\n string out;\n for (int j = 0; j < N; j++) {\n int v = ev.board[i * N + j];\n if (v == 8) out.push_back('.');\n else out.push_back(char('A' + v));\n }\n cout << out << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct Timer {\n chrono::steady_clock::time_point st;\n Timer() { st = chrono::steady_clock::now(); }\n double elapsed() const {\n return chrono::duration(chrono::steady_clock::now() - st).count();\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Timer timer;\n\n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n\n vector> id(N, vector(N, -1));\n vector ri, rj, cost;\n int R = 0;\n int startRid = -1;\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n id[i][j] = R++;\n ri.push_back(i);\n rj.push_back(j);\n cost.push_back(grid[i][j] - '0');\n if (i == si && j == sj) startRid = id[i][j];\n }\n }\n }\n\n int W = (R + 63) >> 6;\n\n auto setbit = [&](vector& bs, int x) {\n bs[x >> 6] |= 1ULL << (x & 63);\n };\n auto getbit_flat = [&](const vector& flat, int idx, int x) -> bool {\n return (flat[(ll)idx * W + (x >> 6)] >> (x & 63)) & 1ULL;\n };\n\n vector hid(R), vid(R);\n vector> hCells, vCells;\n\n for (int i = 0; i < N; i++) {\n int j = 0;\n while (j < N) {\n if (grid[i][j] == '#') {\n j++;\n continue;\n }\n vector cells;\n while (j < N && grid[i][j] != '#') {\n cells.push_back(id[i][j]);\n j++;\n }\n int h = (int)hCells.size();\n for (int x : cells) hid[x] = h;\n hCells.push_back(cells);\n }\n }\n\n for (int j = 0; j < N; j++) {\n int i = 0;\n while (i < N) {\n if (grid[i][j] == '#') {\n i++;\n continue;\n }\n vector cells;\n while (i < N && grid[i][j] != '#') {\n cells.push_back(id[i][j]);\n i++;\n }\n int v = (int)vCells.size();\n for (int x : cells) vid[x] = v;\n vCells.push_back(cells);\n }\n }\n\n // coverBits[x] := road cells visible from road cell x\n vector coverBits((ll)R * W, 0);\n\n for (int x = 0; x < R; x++) {\n uint64_t* bs = &coverBits[(ll)x * W];\n for (int y : hCells[hid[x]]) bs[y >> 6] |= 1ULL << (y & 63);\n for (int y : vCells[vid[x]]) bs[y >> 6] |= 1ULL << (y & 63);\n }\n\n vector fullMask(W, 0);\n for (int x = 0; x < R; x++) fullMask[x >> 6] |= 1ULL << (x & 63);\n\n auto coversAll = [&](const vector& bs) -> bool {\n for (int w = 0; w < W; w++) {\n if ((bs[w] & fullMask[w]) != fullMask[w]) return false;\n }\n return true;\n };\n\n auto pop_and = [&](const uint64_t* a, const vector& b) -> int {\n int res = 0;\n for (int w = 0; w < W; w++) res += __builtin_popcountll(a[w] & b[w]);\n return res;\n };\n\n auto erase_cover_from_uncovered = [&](vector& uncovered, int x) {\n const uint64_t* bs = &coverBits[(ll)x * W];\n for (int w = 0; w < W; w++) uncovered[w] &= ~bs[w];\n };\n\n // Greedy set cover. Start square is observed for free.\n vector uncovered = fullMask;\n erase_cover_from_uncovered(uncovered, startRid);\n\n vector selectedFlag(R, 0);\n vector selected;\n\n auto anyUncovered = [&]() -> bool {\n for (uint64_t x : uncovered) if (x) return true;\n return false;\n };\n\n while (anyUncovered()) {\n int best = -1;\n int bestGain = -1;\n int bestTie = -1;\n\n for (int x = 0; x < R; x++) {\n if (selectedFlag[x]) continue;\n const uint64_t* bs = &coverBits[(ll)x * W];\n int gain = pop_and(bs, uncovered);\n if (gain <= 0) continue;\n\n int tie = -abs(ri[x] - si) - abs(rj[x] - sj);\n if (gain > bestGain || (gain == bestGain && tie > bestTie)) {\n bestGain = gain;\n bestTie = tie;\n best = x;\n }\n }\n\n if (best == -1) break;\n selectedFlag[best] = 1;\n selected.push_back(best);\n erase_cover_from_uncovered(uncovered, best);\n }\n\n // Remove redundant selected cells using coverage counts.\n vector cnt(R, 0);\n\n auto addCoverCount = [&](int x, int delta) {\n const uint64_t* bs = &coverBits[(ll)x * W];\n for (int w = 0; w < W; w++) {\n uint64_t v = bs[w];\n while (v) {\n int b = __builtin_ctzll(v);\n int y = (w << 6) + b;\n if (y < R) cnt[y] += delta;\n v &= v - 1;\n }\n }\n };\n\n addCoverCount(startRid, 1);\n for (int x : selected) addCoverCount(x, 1);\n\n vector selected2;\n for (int idx = (int)selected.size() - 1; idx >= 0; idx--) {\n int x = selected[idx];\n bool removable = true;\n const uint64_t* bs = &coverBits[(ll)x * W];\n for (int w = 0; w < W && removable; w++) {\n uint64_t v = bs[w];\n while (v) {\n int b = __builtin_ctzll(v);\n int y = (w << 6) + b;\n if (y < R && cnt[y] <= 1) {\n removable = false;\n break;\n }\n v &= v - 1;\n }\n }\n if (removable) {\n addCoverCount(x, -1);\n } else {\n selected2.push_back(x);\n }\n }\n reverse(selected2.begin(), selected2.end());\n selected.swap(selected2);\n\n // Nodes for TSP: node 0 is start.\n vector nodeRid;\n nodeRid.push_back(startRid);\n for (int x : selected) {\n if (x != startRid) nodeRid.push_back(x);\n }\n\n int M = (int)nodeRid.size();\n\n // Road graph.\n vector>> adj(R);\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n\n for (int x = 0; x < R; x++) {\n int i = ri[x], j = rj[x];\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d], nj = j + dj[d];\n if (0 <= ni && ni < N && 0 <= nj && nj < N && id[ni][nj] != -1) {\n int y = id[ni][nj];\n adj[x].push_back({y, cost[y]});\n }\n }\n }\n\n const int INF = 1e9;\n vector> distMat(M, vector(M, INF));\n vector> prevNode(M, vector(R, -1));\n\n for (int s = 0; s < M; s++) {\n int src = nodeRid[s];\n vector dist(R, INF);\n vector pre(R, -1);\n\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n\n while (!pq.empty()) {\n auto [cd, v] = pq.top();\n pq.pop();\n if (cd != dist[v]) continue;\n\n for (auto [to, w] : adj[v]) {\n int nd = cd + w;\n if (nd < dist[to]) {\n dist[to] = nd;\n pre[to] = (short)v;\n pq.push({nd, to});\n }\n }\n }\n\n prevNode[s].swap(pre);\n for (int t = 0; t < M; t++) {\n distMat[s][t] = dist[nodeRid[t]];\n }\n }\n\n auto cycleCost = [&](const vector& cyc) -> ll {\n ll res = 0;\n int m = (int)cyc.size();\n for (int i = 0; i < m; i++) {\n res += distMat[cyc[i]][cyc[(i + 1) % m]];\n }\n return res;\n };\n\n vector cycle;\n\n if (M == 1) {\n cycle = {0};\n } else if (M <= 380) {\n // Cheapest insertion.\n cycle = {0};\n vector unused;\n for (int i = 1; i < M; i++) unused.push_back(i);\n\n while (!unused.empty()) {\n int bestUIdx = -1;\n int bestPos = -1;\n int bestDelta = INF;\n\n for (int ui = 0; ui < (int)unused.size(); ui++) {\n int x = unused[ui];\n int m = (int)cycle.size();\n\n for (int p = 0; p < m; p++) {\n int a = cycle[p];\n int b = cycle[(p + 1) % m];\n int delta = distMat[a][x] + distMat[x][b] - distMat[a][b];\n\n if (delta < bestDelta) {\n bestDelta = delta;\n bestUIdx = ui;\n bestPos = p;\n }\n }\n }\n\n int x = unused[bestUIdx];\n cycle.insert(cycle.begin() + bestPos + 1, x);\n unused.erase(unused.begin() + bestUIdx);\n }\n } else {\n // Fallback nearest neighbor for very large selected sets.\n vector used(M, 0);\n cycle = {0};\n used[0] = 1;\n int cur = 0;\n\n for (int step = 1; step < M; step++) {\n int best = -1;\n int bd = INF;\n for (int x = 1; x < M; x++) {\n if (!used[x] && distMat[cur][x] < bd) {\n bd = distMat[cur][x];\n best = x;\n }\n }\n used[best] = 1;\n cycle.push_back(best);\n cur = best;\n }\n }\n\n ll curCost = cycleCost(cycle);\n\n // Relocation local search.\n if ((int)cycle.size() <= 700) {\n bool improved = true;\n while (improved && timer.elapsed() < 2.05) {\n improved = false;\n int m = (int)cycle.size();\n ll bestDelta = 0;\n int bestI = -1, bestPos = -1;\n\n for (int i = 1; i < m; i++) {\n int x = cycle[i];\n int a = cycle[i - 1];\n int b = cycle[(i + 1) % m];\n\n ll removeDelta = (ll)distMat[a][b] - distMat[a][x] - distMat[x][b];\n\n for (int pos = 0; pos < m; pos++) {\n if (pos == i || pos == i - 1) continue;\n\n int c = cycle[pos];\n int d = cycle[(pos + 1) % m];\n\n ll delta = removeDelta + (ll)distMat[c][x] + distMat[x][d] - distMat[c][d];\n\n if (delta < bestDelta) {\n bestDelta = delta;\n bestI = i;\n bestPos = pos;\n }\n }\n }\n\n if (bestI != -1) {\n int x = cycle[bestI];\n cycle.erase(cycle.begin() + bestI);\n\n int insertIdx;\n if (bestPos < bestI) insertIdx = bestPos + 1;\n else insertIdx = bestPos;\n\n cycle.insert(cycle.begin() + insertIdx, x);\n curCost += bestDelta;\n improved = true;\n }\n }\n }\n\n auto reconstructPath = [&](int srcNode, int dstNode) {\n vector path;\n int src = nodeRid[srcNode];\n int dst = nodeRid[dstNode];\n\n int cur = dst;\n while (cur != src) {\n path.push_back(cur);\n cur = prevNode[srcNode][cur];\n if (cur < 0) break;\n }\n path.push_back(src);\n reverse(path.begin(), path.end());\n return path;\n };\n\n struct EdgeCache {\n int M, W, R;\n const vector& nodeRid;\n const vector>& prevNode;\n const vector& coverBits;\n vector data;\n vector done;\n\n EdgeCache(\n int M_,\n int W_,\n int R_,\n const vector& nodeRid_,\n const vector>& prevNode_,\n const vector& coverBits_\n )\n : M(M_), W(W_), R(R_), nodeRid(nodeRid_),\n prevNode(prevNode_), coverBits(coverBits_) {\n data.assign((ll)M * M * W, 0);\n done.assign((ll)M * M, 0);\n }\n\n uint64_t* get(int a, int b) {\n ll idx = (ll)a * M + b;\n uint64_t* ret = &data[idx * W];\n if (done[idx]) return ret;\n done[idx] = 1;\n\n int src = nodeRid[a];\n int dst = nodeRid[b];\n\n vector path;\n int cur = dst;\n while (cur != src) {\n path.push_back(cur);\n cur = prevNode[a][cur];\n if (cur < 0) break;\n }\n path.push_back(src);\n\n for (int x : path) {\n const uint64_t* bs = &coverBits[(ll)x * W];\n for (int w = 0; w < W; w++) ret[w] |= bs[w];\n }\n return ret;\n }\n };\n\n // Remove redundant waypoints if visibility remains complete.\n if (M <= 520 && timer.elapsed() < 2.25) {\n EdgeCache cache(M, W, R, nodeRid, prevNode, coverBits);\n\n while ((int)cycle.size() > 1 && timer.elapsed() < 2.72) {\n int m = (int)cycle.size();\n\n vector pref((ll)(m + 1) * W, 0);\n vector suff((ll)(m + 1) * W, 0);\n\n for (int e = 0; e < m; e++) {\n uint64_t* ec = cache.get(cycle[e], cycle[(e + 1) % m]);\n for (int w = 0; w < W; w++) {\n pref[(ll)(e + 1) * W + w] = pref[(ll)e * W + w] | ec[w];\n }\n }\n\n for (int e = m - 1; e >= 0; e--) {\n uint64_t* ec = cache.get(cycle[e], cycle[(e + 1) % m]);\n for (int w = 0; w < W; w++) {\n suff[(ll)e * W + w] = suff[(ll)(e + 1) * W + w] | ec[w];\n }\n }\n\n int bestP = -1;\n ll bestSave = 0;\n vector tmp(W);\n\n for (int p = 1; p < m; p++) {\n int prv = cycle[p - 1];\n int x = cycle[p];\n int nxt = cycle[(p + 1) % m];\n\n ll save = (ll)distMat[prv][x] + distMat[x][nxt] - distMat[prv][nxt];\n if (save <= bestSave) continue;\n\n uint64_t* ec = cache.get(prv, nxt);\n\n for (int w = 0; w < W; w++) {\n tmp[w] =\n pref[(ll)(p - 1) * W + w] |\n suff[(ll)(p + 1) * W + w] |\n ec[w];\n }\n\n bool ok = true;\n for (int w = 0; w < W; w++) {\n if ((tmp[w] & fullMask[w]) != fullMask[w]) {\n ok = false;\n break;\n }\n }\n\n if (ok) {\n bestSave = save;\n bestP = p;\n }\n }\n\n if (bestP == -1) break;\n cycle.erase(cycle.begin() + bestP);\n curCost -= bestSave;\n }\n }\n\n // Output actual move sequence.\n string ans;\n\n auto moveChar = [&](int a, int b) -> char {\n int da = ri[b] - ri[a];\n int db = rj[b] - rj[a];\n if (da == -1) return 'U';\n if (da == 1) return 'D';\n if (db == -1) return 'L';\n return 'R';\n };\n\n int m = (int)cycle.size();\n for (int e = 0; e < m; e++) {\n int a = cycle[e];\n int b = cycle[(e + 1) % m];\n vector path = reconstructPath(a, b);\n\n for (int k = 1; k < (int)path.size(); k++) {\n ans.push_back(moveChar(path[k - 1], path[k]));\n }\n }\n\n cout << ans << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nstruct Record {\n int task;\n int dur;\n};\n\nint N, M, K, R;\nvector> D;\nvector> children_;\nvector remdep;\nvector status_; // -1:not started, 0:running, 1:done\n\nvector> skill_est;\nvector> records_;\nvector member_task;\nvector member_start;\n\nvector bottom_priority;\nvector min_cost, avg_cost;\nvector reach_score;\n\nconst int MAX_SKILL = 70;\n\ndouble base_skill;\nconst double PRIOR_COMP = 0.008;\nconst double PRIOR_NORM = 0.003;\nconst double NORM_TARGET = 40.0;\n\ninline double obsPenalty(int w, int t) {\n static const double p1[5] = {\n 0.0,\n -log(4.0 / 7.0),\n -log(3.0 / 7.0),\n -log(2.0 / 7.0),\n -log(1.0 / 7.0)\n };\n\n if (t == 1) {\n if (w <= 4) return p1[w];\n double x = w - 4;\n return 3.0 + 2.0 * x * x;\n } else {\n if (w == 0) {\n return 5.0 + 1.0 * t * t;\n }\n int lo = max(1, t - 3);\n int hi = t + 3;\n if (w < lo) {\n double x = lo - w;\n return 2.0 * x * x;\n }\n if (w > hi) {\n double x = w - hi;\n return 2.0 * x * x;\n }\n return 1.0 + 0.05 * abs(w - t);\n }\n}\n\ninline int calcWTaskSkill(int task, const vector& s) {\n int w = 0;\n for (int k = 0; k < K; k++) {\n if (D[task][k] > s[k]) w += D[task][k] - s[k];\n }\n return w;\n}\n\ninline double expectedDurationFromW(int w) {\n if (w == 0) return 1.0;\n if (w == 1) return 13.0 / 7.0;\n if (w == 2) return 17.0 / 7.0;\n if (w == 3) return 22.0 / 7.0;\n return (double)w;\n}\n\ninline double expectedDuration(int task, int mem) {\n int w = 0;\n const auto& s = skill_est[mem];\n for (int k = 0; k < K; k++) {\n if (D[task][k] > s[k]) w += D[task][k] - s[k];\n }\n return expectedDurationFromW(w);\n}\n\nvoid optimizeMember(int mem) {\n auto& recs = records_[mem];\n if (recs.empty()) return;\n\n vector& s = skill_est[mem];\n int Rm = (int)recs.size();\n\n vector curW(Rm, 0);\n for (int r = 0; r < Rm; r++) {\n curW[r] = calcWTaskSkill(recs[r].task, s);\n }\n\n double sumsq = 0.0;\n for (int k = 0; k < K; k++) sumsq += 1.0 * s[k] * s[k];\n\n int passes = 3;\n for (int pass = 0; pass < passes; pass++) {\n bool changed_any = false;\n\n for (int k = 0; k < K; k++) {\n int old = s[k];\n\n double bestObj = 1e100;\n int bestVal = old;\n\n double oldCompPrior = PRIOR_COMP * (old - base_skill) * (old - base_skill);\n\n for (int val = 0; val <= MAX_SKILL; val++) {\n double obj = 0.0;\n\n for (int r = 0; r < Rm; r++) {\n int task = recs[r].task;\n int oldContrib = max(0, D[task][k] - old);\n int newContrib = max(0, D[task][k] - val);\n int nw = curW[r] - oldContrib + newContrib;\n obj += obsPenalty(nw, recs[r].dur);\n }\n\n double compPrior = PRIOR_COMP * (val - base_skill) * (val - base_skill);\n\n double nsumsq = sumsq - 1.0 * old * old + 1.0 * val * val;\n double norm = sqrt(nsumsq);\n double normPrior = PRIOR_NORM * (norm - NORM_TARGET) * (norm - NORM_TARGET);\n\n obj += compPrior + normPrior;\n\n if (obj < bestObj) {\n bestObj = obj;\n bestVal = val;\n }\n }\n\n if (bestVal != old) {\n for (int r = 0; r < Rm; r++) {\n int task = recs[r].task;\n curW[r] -= max(0, D[task][k] - old);\n curW[r] += max(0, D[task][k] - bestVal);\n }\n sumsq = sumsq - 1.0 * old * old + 1.0 * bestVal * bestVal;\n s[k] = bestVal;\n changed_any = true;\n }\n }\n\n if (!changed_any) break;\n }\n}\n\nvoid precomputeReachScore() {\n vector dp(N, 0.0);\n for (int i = N - 1; i >= 0; i--) {\n double v = 0.0;\n for (int c : children_[i]) {\n v += 1.0 + dp[c];\n if (v > 1e6) {\n v = 1e6;\n break;\n }\n }\n dp[i] = v;\n }\n\n reach_score.assign(N, 0.0);\n for (int i = 0; i < N; i++) {\n reach_score[i] = log1p(dp[i]);\n }\n}\n\nvoid recomputePriorities() {\n min_cost.assign(N, 0.0);\n avg_cost.assign(N, 0.0);\n\n for (int i = 0; i < N; i++) {\n if (status_[i] == 1) {\n min_cost[i] = avg_cost[i] = 0.0;\n continue;\n }\n\n double mn = 1e100;\n double sum = 0.0;\n for (int j = 0; j < M; j++) {\n double e = expectedDuration(i, j);\n mn = min(mn, e);\n sum += e;\n }\n min_cost[i] = mn;\n avg_cost[i] = sum / M;\n }\n\n bottom_priority.assign(N, 0.0);\n\n for (int i = N - 1; i >= 0; i--) {\n if (status_[i] == 1) {\n bottom_priority[i] = 0.0;\n continue;\n }\n\n double nodeCost = 0.7 * min_cost[i] + 0.3 * avg_cost[i];\n double mx = 0.0;\n for (int c : children_[i]) {\n mx = max(mx, bottom_priority[c]);\n }\n bottom_priority[i] = nodeCost + mx;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> M >> K >> R;\n\n D.assign(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) cin >> D[i][k];\n }\n\n children_.assign(N, {});\n remdep.assign(N, 0);\n\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n children_[u].push_back(v);\n remdep[v]++;\n }\n\n base_skill = 35.0 / sqrt((double)K);\n int init_skill = max(0, (int)round(base_skill));\n\n skill_est.assign(M, vector(K, init_skill));\n records_.assign(M, {});\n\n status_.assign(N, -1);\n member_task.assign(M, -1);\n member_start.assign(M, -1);\n\n precomputeReachScore();\n\n for (int day = 1; day <= 2000; day++) {\n recomputePriorities();\n\n vector free_members;\n for (int j = 0; j < M; j++) {\n if (member_task[j] == -1) free_members.push_back(j);\n }\n\n vector ready;\n for (int i = 0; i < N; i++) {\n if (status_[i] == -1 && remdep[i] == 0) ready.push_back(i);\n }\n\n sort(ready.begin(), ready.end(), [&](int a, int b) {\n if (bottom_priority[a] != bottom_priority[b]) {\n return bottom_priority[a] > bottom_priority[b];\n }\n if (reach_score[a] != reach_score[b]) {\n return reach_score[a] > reach_score[b];\n }\n return a < b;\n });\n\n vector> assignments;\n\n while (!free_members.empty()) {\n int bestFi = -1;\n int bestTask = -1;\n double bestScore = -1e100;\n\n int limit = min((int)ready.size(), 300);\n\n for (int fi = 0; fi < (int)free_members.size(); fi++) {\n int mem = free_members[fi];\n\n for (int idx = 0; idx < limit; idx++) {\n int task = ready[idx];\n if (status_[task] != -1) continue;\n\n double pred = expectedDuration(task, mem);\n\n double score =\n bottom_priority[task]\n + 0.15 * reach_score[task]\n - 0.70 * pred\n + 0.20 * (avg_cost[task] - pred);\n\n if (score > bestScore) {\n bestScore = score;\n bestFi = fi;\n bestTask = task;\n }\n }\n }\n\n if (bestFi == -1) break;\n\n int mem = free_members[bestFi];\n\n status_[bestTask] = 0;\n member_task[mem] = bestTask;\n member_start[mem] = day;\n\n assignments.push_back({mem, bestTask});\n\n free_members.erase(free_members.begin() + bestFi);\n }\n\n cout << assignments.size();\n for (auto [mem, task] : assignments) {\n cout << ' ' << mem + 1 << ' ' << task + 1;\n }\n cout << '\\n' << flush;\n\n int cnt;\n if (!(cin >> cnt)) return 0;\n if (cnt == -1) return 0;\n\n for (int i = 0; i < cnt; i++) {\n int f;\n cin >> f;\n --f;\n\n int task = member_task[f];\n if (task < 0) continue;\n\n int dur = day - member_start[f] + 1;\n\n status_[task] = 1;\n member_task[f] = -1;\n member_start[f] = -1;\n\n records_[f].push_back({task, dur});\n optimizeMember(f);\n\n for (int c : children_[task]) {\n remdep[c]--;\n }\n }\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int ax, ay, cx, cy;\n int score;\n};\n\nstruct Node {\n int x, y;\n int id; // -1 for depot\n int type; // 0 pickup, 1 delivery\n};\n\nstruct InsertInfo {\n int cost;\n int pgap;\n int dgap;\n};\n\nstruct State {\n vector route;\n vector selected;\n vector used;\n int cost;\n};\n\nstatic const int N = 1000;\nstatic const int K = 50;\nstatic const int DEP = 400;\nstatic const int INF = 1e9;\n\nvector ords;\nchrono::steady_clock::time_point start_time;\n\ninline double elapsed() {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\ninline int mdist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\ninline int ndist(const Node& a, const Node& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\n\ninline Node pickupNode(int id) {\n return Node{ords[id].ax, ords[id].ay, id, 0};\n}\n\ninline Node deliveryNode(int id) {\n return Node{ords[id].cx, ords[id].cy, id, 1};\n}\n\nint routeCost(const vector& route) {\n int res = 0;\n for (int i = 0; i + 1 < (int)route.size(); i++) {\n res += ndist(route[i], route[i + 1]);\n }\n return res;\n}\n\nInsertInfo bestInsert(const vector& route, int oid) {\n const int L = (int)route.size();\n const int px = ords[oid].ax;\n const int py = ords[oid].ay;\n const int dx = ords[oid].cx;\n const int dy = ords[oid].cy;\n\n int best = INF;\n int bestP = -1;\n int bestD = -1;\n\n for (int i = 0; i <= L - 2; i++) {\n const Node& A = route[i];\n const Node& B = route[i + 1];\n\n int directAB = ndist(A, B);\n\n // delivery immediately after pickup\n int val = mdist(A.x, A.y, px, py)\n + mdist(px, py, dx, dy)\n + mdist(dx, dy, B.x, B.y)\n - directAB;\n\n if (val < best) {\n best = val;\n bestP = i;\n bestD = i;\n }\n\n int addPickup = mdist(A.x, A.y, px, py)\n + mdist(px, py, B.x, B.y)\n - directAB;\n\n for (int j = i + 1; j <= L - 2; j++) {\n const Node& C = route[j];\n const Node& D = route[j + 1];\n\n int addDelivery = mdist(C.x, C.y, dx, dy)\n + mdist(dx, dy, D.x, D.y)\n - ndist(C, D);\n\n val = addPickup + addDelivery;\n\n if (val < best) {\n best = val;\n bestP = i;\n bestD = j;\n }\n }\n }\n\n return InsertInfo{best, bestP, bestD};\n}\n\nvoid applyInsert(vector& route, int oid, const InsertInfo& ins) {\n vector nr;\n nr.reserve(route.size() + 2);\n\n Node P = pickupNode(oid);\n Node D = deliveryNode(oid);\n\n for (int i = 0; i < (int)route.size(); i++) {\n nr.push_back(route[i]);\n\n if (i == ins.pgap) {\n nr.push_back(P);\n if (ins.dgap == ins.pgap) {\n nr.push_back(D);\n }\n }\n\n if (ins.dgap > ins.pgap && i == ins.dgap) {\n nr.push_back(D);\n }\n }\n\n route.swap(nr);\n}\n\nvector removeOrder(const vector& route, int oid) {\n vector nr;\n nr.reserve(route.size() - 2);\n for (const auto& v : route) {\n if (v.id != oid) nr.push_back(v);\n }\n return nr;\n}\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n\n uint32_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n\n double nextDouble() {\n return (next() + 0.5) / 4294967296.0;\n }\n};\n\nXorShift rng;\n\nState constructGreedy(const vector& pool, int randomTop) {\n Node depot{DEP, DEP, -1, -1};\n\n State st;\n st.route = {depot, depot};\n st.used.assign(N, 0);\n st.selected.clear();\n st.cost = 0;\n\n struct Choice {\n int cost;\n int oid;\n InsertInfo ins;\n };\n\n for (int step = 0; step < K; step++) {\n vector top;\n\n for (int oid : pool) {\n if (st.used[oid]) continue;\n\n InsertInfo ins = bestInsert(st.route, oid);\n Choice ch{ins.cost, oid, ins};\n\n if ((int)top.size() < randomTop) {\n top.push_back(ch);\n } else {\n int worst = 0;\n for (int i = 1; i < (int)top.size(); i++) {\n if (top[i].cost > top[worst].cost) worst = i;\n }\n if (ch.cost < top[worst].cost) top[worst] = ch;\n }\n }\n\n sort(top.begin(), top.end(), [](const Choice& a, const Choice& b) {\n return a.cost < b.cost;\n });\n\n int idx = 0;\n if (randomTop > 1 && top.size() > 1) {\n int lim = (int)top.size();\n double u = rng.nextDouble();\n idx = min(lim - 1, (int)(u * u * lim)); // biased toward better choices\n }\n\n Choice ch = top[idx];\n applyInsert(st.route, ch.oid, ch.ins);\n st.used[ch.oid] = 1;\n st.selected.push_back(ch.oid);\n st.cost += ch.ins.cost;\n }\n\n st.cost = routeCost(st.route);\n return st;\n}\n\nvoid pairReinsertOptimize(State& st) {\n bool improved = true;\n int pass = 0;\n\n while (improved && pass < 5) {\n improved = false;\n pass++;\n\n for (int oid : st.selected) {\n vector rem = removeOrder(st.route, oid);\n int remCost = routeCost(rem);\n\n InsertInfo ins = bestInsert(rem, oid);\n int newCost = remCost + ins.cost;\n\n if (newCost < st.cost) {\n st.route.swap(rem);\n applyInsert(st.route, oid, ins);\n st.cost = newCost;\n improved = true;\n }\n }\n }\n}\n\nvoid replaceOptimize(State& st, const vector& candList, double limitTime) {\n while (elapsed() < limitTime) {\n int bestNewCost = st.cost;\n int bestRemove = -1;\n int bestAdd = -1;\n\n int checks = 0;\n bool timeout = false;\n\n for (int remOid : st.selected) {\n vector remRoute = removeOrder(st.route, remOid);\n int remCost = routeCost(remRoute);\n\n for (int addOid : candList) {\n if (st.used[addOid]) continue;\n\n InsertInfo ins = bestInsert(remRoute, addOid);\n int newCost = remCost + ins.cost;\n\n if (newCost < bestNewCost) {\n bestNewCost = newCost;\n bestRemove = remOid;\n bestAdd = addOid;\n }\n\n if ((++checks & 255) == 0 && elapsed() > limitTime) {\n timeout = true;\n break;\n }\n }\n\n if (timeout) break;\n }\n\n if (bestRemove == -1) break;\n\n vector remRoute = removeOrder(st.route, bestRemove);\n InsertInfo ins = bestInsert(remRoute, bestAdd);\n st.route.swap(remRoute);\n applyInsert(st.route, bestAdd, ins);\n\n st.used[bestRemove] = 0;\n st.used[bestAdd] = 1;\n\n for (int& x : st.selected) {\n if (x == bestRemove) {\n x = bestAdd;\n break;\n }\n }\n\n st.cost = routeCost(st.route);\n pairReinsertOptimize(st);\n\n if (timeout) break;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n start_time = chrono::steady_clock::now();\n\n ords.resize(N);\n\n for (int i = 0; i < N; i++) {\n cin >> ords[i].ax >> ords[i].ay >> ords[i].cx >> ords[i].cy;\n\n int centerSum = mdist(DEP, DEP, ords[i].ax, ords[i].ay)\n + mdist(DEP, DEP, ords[i].cx, ords[i].cy);\n int pairDist = mdist(ords[i].ax, ords[i].ay, ords[i].cx, ords[i].cy);\n\n ords[i].score = centerSum + pairDist / 2;\n }\n\n vector allIds(N);\n iota(allIds.begin(), allIds.end(), 0);\n\n vector sortedIds = allIds;\n sort(sortedIds.begin(), sortedIds.end(), [](int a, int b) {\n return ords[a].score < ords[b].score;\n });\n\n // Deterministic greedy using all orders.\n State best = constructGreedy(allIds, 1);\n pairReinsertOptimize(best);\n\n // Randomized constructions using promising orders.\n vector pool;\n int poolSize = min(N, 700);\n for (int i = 0; i < poolSize; i++) pool.push_back(sortedIds[i]);\n\n while (elapsed() < 1.05) {\n State cur = constructGreedy(pool, 6);\n pairReinsertOptimize(cur);\n\n if (cur.cost < best.cost) {\n best = cur;\n }\n }\n\n // Try replacing selected orders.\n replaceOptimize(best, sortedIds, 1.85);\n\n pairReinsertOptimize(best);\n\n cout << K;\n for (int oid : best.selected) {\n cout << ' ' << oid + 1;\n }\n cout << '\\n';\n\n cout << best.route.size();\n for (const Node& v : best.route) {\n cout << ' ' << v.x << ' ' << v.y;\n }\n cout << '\\n';\n\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstatic constexpr int N = 400;\nstatic constexpr int M = 1995;\nstatic constexpr int SAMPLES = 24;\nstatic constexpr long long INF = (1LL << 60);\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n\n uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n\n int randint(int l, int r) {\n return l + int(next() % uint64_t(r - l + 1));\n }\n};\n\nstruct DSU {\n int p[N];\n int sz[N];\n\n void init() {\n for (int i = 0; i < N; i++) {\n p[i] = i;\n sz[i] = 1;\n }\n }\n\n int find(int x) const {\n while (p[x] != x) x = p[x];\n return x;\n }\n\n bool same(int a, int b) const {\n return find(a) == find(b);\n }\n\n bool unite(int a, int b) {\n int ra = find(a);\n int rb = find(b);\n if (ra == rb) return false;\n if (sz[ra] < sz[rb]) swap(ra, rb);\n p[rb] = ra;\n sz[ra] += sz[rb];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector x(N), y(N);\n for (int i = 0; i < N; i++) {\n cin >> x[i] >> y[i];\n }\n\n vector u(M), v(M), d(M);\n for (int i = 0; i < M; i++) {\n cin >> u[i] >> v[i];\n\n long long dx = x[u[i]] - x[v[i]];\n long long dy = y[u[i]] - y[v[i]];\n d[i] = int(floor(sqrt(double(dx * dx + dy * dy)) + 0.5));\n }\n\n XorShift rng;\n\n vector> sampled_w(SAMPLES, vector(M));\n vector> order(SAMPLES, vector(M));\n\n for (int s = 0; s < SAMPLES; s++) {\n for (int i = 0; i < M; i++) {\n sampled_w[s][i] = rng.randint(d[i], 3 * d[i]);\n order[s][i] = i;\n }\n\n sort(order[s].begin(), order[s].end(), [&](int a, int b) {\n if (sampled_w[s][a] != sampled_w[s][b]) {\n return sampled_w[s][a] < sampled_w[s][b];\n }\n return a < b;\n });\n }\n\n DSU accepted;\n accepted.init();\n\n int accepted_edges = 0;\n\n for (int cur = 0; cur < M; cur++) {\n int len;\n cin >> len;\n\n int answer = 0;\n\n if (!accepted.same(u[cur], v[cur])) {\n int base_components = N - accepted_edges;\n\n long long sum_delta = 0;\n bool reject_impossible = false;\n\n for (int s = 0; s < SAMPLES; s++) {\n DSU dsu_reject = accepted;\n DSU dsu_accept = accepted;\n\n int comp_reject = base_components;\n int comp_accept = base_components;\n\n long long cost_reject = 0;\n long long cost_accept = len;\n\n if (dsu_accept.unite(u[cur], v[cur])) {\n comp_accept--;\n }\n\n for (int pos = 0; pos < M; pos++) {\n if (comp_reject == 1 && comp_accept == 1) break;\n\n int e = order[s][pos];\n if (e <= cur) continue;\n\n int a = u[e];\n int b = v[e];\n int w = sampled_w[s][e];\n\n if (comp_reject > 1 && dsu_reject.unite(a, b)) {\n cost_reject += w;\n comp_reject--;\n }\n\n if (comp_accept > 1 && dsu_accept.unite(a, b)) {\n cost_accept += w;\n comp_accept--;\n }\n }\n\n if (comp_reject > 1) {\n reject_impossible = true;\n break;\n }\n\n if (comp_accept > 1) {\n cost_accept = INF;\n }\n\n sum_delta += cost_accept - cost_reject;\n }\n\n if (reject_impossible || sum_delta < 0) {\n answer = 1;\n accepted.unite(u[cur], v[cur]);\n accepted_edges++;\n }\n }\n\n cout << answer << '\\n' << flush;\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nstruct Pet {\n int x, y, t;\n};\n\nstruct Human {\n int x, y;\n};\n\nstruct Task {\n int sx, sy; // standing cell\n int wx, wy; // wall cell\n};\n\nint N, M;\nvector pets;\nvector humans;\n\nbool wall_[31][31];\n\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char mvChar[4] = {'U', 'D', 'L', 'R'};\nconst char buildChar[4] = {'u', 'd', 'l', 'r'};\n\nint ori_, S_;\nint x1_, x2_, y1_, y2_;\nvector tasks;\n\nbool inBoard(int x, int y) {\n return 1 <= x && x <= 30 && 1 <= y && y <= 30;\n}\n\nbool insideRegion(int x, int y) {\n return x1_ <= x && x <= x2_ && y1_ <= y && y <= y2_;\n}\n\nbool passable(int x, int y) {\n return inBoard(x, y) && !wall_[x][y];\n}\n\npair regionRangeX(int ori, int S) {\n if (ori == 0 || ori == 1) return {1, S};\n return {31 - S, 30};\n}\n\npair regionRangeY(int ori, int S) {\n if (ori == 0 || ori == 2) return {1, S};\n return {31 - S, 30};\n}\n\nbool insideRegionParam(int x, int y, int ori, int S) {\n auto rx = regionRangeX(ori, S);\n auto ry = regionRangeY(ori, S);\n return rx.first <= x && x <= rx.second && ry.first <= y && y <= ry.second;\n}\n\nint distToRegion(int x, int y, int ori, int S) {\n auto rx = regionRangeX(ori, S);\n auto ry = regionRangeY(ori, S);\n int dx = 0, dy = 0;\n if (x < rx.first) dx = rx.first - x;\n if (x > rx.second) dx = x - rx.second;\n if (y < ry.first) dy = ry.first - y;\n if (y > ry.second) dy = y - ry.second;\n return dx + dy;\n}\n\nvoid selectRegion() {\n double bestVal = -1e100;\n int bestOri = 0, bestS = 10;\n\n for (int ori = 0; ori < 4; ori++) {\n for (int S = 8; S <= 18; S++) {\n int pcnt = 0;\n for (auto &p : pets) {\n if (insideRegionParam(p.x, p.y, ori, S)) pcnt++;\n }\n\n double avgDist = 0;\n for (auto &h : humans) {\n avgDist += distToRegion(h.x, h.y, ori, S);\n }\n avgDist /= M;\n\n double expected = (double)(S * S) / 900.0 * pow(0.5, pcnt);\n double val = expected - 0.002 * avgDist - 0.0005 * S;\n\n if (val > bestVal) {\n bestVal = val;\n bestOri = ori;\n bestS = S;\n }\n }\n }\n\n ori_ = bestOri;\n S_ = bestS;\n\n auto rx = regionRangeX(ori_, S_);\n auto ry = regionRangeY(ori_, S_);\n x1_ = rx.first;\n x2_ = rx.second;\n y1_ = ry.first;\n y2_ = ry.second;\n}\n\nvoid makeTasks() {\n tasks.clear();\n\n int S = S_;\n\n if (ori_ == 0) {\n // top-left\n for (int c = 1; c <= S; c++) {\n tasks.push_back({S, c, S + 1, c});\n }\n for (int r = 1; r <= S; r++) {\n tasks.push_back({r, S, r, S + 1});\n }\n } else if (ori_ == 1) {\n // top-right\n int L = 31 - S;\n for (int c = L; c <= 30; c++) {\n tasks.push_back({S, c, S + 1, c});\n }\n for (int r = 1; r <= S; r++) {\n tasks.push_back({r, L, r, L - 1});\n }\n } else if (ori_ == 2) {\n // bottom-left\n int U = 31 - S;\n for (int c = 1; c <= S; c++) {\n tasks.push_back({U, c, U - 1, c});\n }\n for (int r = U; r <= 30; r++) {\n tasks.push_back({r, S, r, S + 1});\n }\n } else {\n // bottom-right\n int U = 31 - S;\n int L = 31 - S;\n for (int c = L; c <= 30; c++) {\n tasks.push_back({U, c, U - 1, c});\n }\n for (int r = U; r <= 30; r++) {\n tasks.push_back({r, L, r, L - 1});\n }\n }\n}\n\nbool allHumansInside() {\n for (auto &h : humans) {\n if (!insideRegion(h.x, h.y)) return false;\n }\n return true;\n}\n\nint petsInside() {\n int cnt = 0;\n for (auto &p : pets) {\n if (insideRegion(p.x, p.y)) cnt++;\n }\n return cnt;\n}\n\nbool allTasksDone() {\n for (auto &t : tasks) {\n if (!wall_[t.wx][t.wy]) return false;\n }\n return true;\n}\n\nchar dirFromTo(int x1, int y1, int x2, int y2, bool build) {\n for (int d = 0; d < 4; d++) {\n if (x1 + dx[d] == x2 && y1 + dy[d] == y2) {\n return build ? buildChar[d] : mvChar[d];\n }\n }\n return '.';\n}\n\nbool validBuildTarget(\n int x,\n int y,\n const bool occH[31][31],\n const bool occP[31][31]\n) {\n if (!inBoard(x, y)) return false;\n if (occH[x][y]) return false;\n if (occP[x][y]) return false;\n\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (inBoard(nx, ny) && occP[nx][ny]) return false;\n }\n\n return true;\n}\n\nchar bfsMove(\n int sx,\n int sy,\n const vector> &targets,\n const bool avoid[31][31],\n bool restrictInside\n) {\n if (targets.empty()) return '.';\n\n bool isTarget[31][31] = {};\n for (auto [x, y] : targets) {\n if (inBoard(x, y)) isTarget[x][y] = true;\n }\n\n if (isTarget[sx][sy]) return '.';\n\n int dist[31][31];\n char first[31][31];\n\n for (int i = 1; i <= 30; i++) {\n for (int j = 1; j <= 30; j++) {\n dist[i][j] = -1;\n first[i][j] = '.';\n }\n }\n\n queue> q;\n dist[sx][sy] = 0;\n q.push({sx, sy});\n\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n\n if (isTarget[x][y]) {\n return first[x][y];\n }\n\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n\n if (!inBoard(nx, ny)) continue;\n if (!passable(nx, ny)) continue;\n if (avoid[nx][ny]) continue;\n if (restrictInside && !insideRegion(nx, ny)) continue;\n if (dist[nx][ny] != -1) continue;\n\n dist[nx][ny] = dist[x][y] + 1;\n first[nx][ny] = (x == sx && y == sy) ? mvChar[d] : first[x][y];\n q.push({nx, ny});\n }\n }\n\n return '.';\n}\n\nvector> allInsideCells() {\n vector> res;\n for (int x = x1_; x <= x2_; x++) {\n for (int y = y1_; y <= y2_; y++) {\n if (passable(x, y)) res.push_back({x, y});\n }\n }\n return res;\n}\n\npair centerCell() {\n return {(x1_ + x2_) / 2, (y1_ + y2_) / 2};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n pets.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].x >> pets[i].y >> pets[i].t;\n }\n\n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].x >> humans[i].y;\n }\n\n memset(wall_, false, sizeof(wall_));\n\n selectRegion();\n makeTasks();\n\n bool startedBuild = false;\n\n for (int turn = 0; turn < 300; turn++) {\n bool occH[31][31] = {};\n bool occP[31][31] = {};\n\n for (auto &h : humans) occH[h.x][h.y] = true;\n for (auto &p : pets) occP[p.x][p.y] = true;\n\n string ans(M, '.');\n bool avoid[31][31] = {};\n\n bool humansIn = allHumansInside();\n\n if (!humansIn) {\n vector> targets = allInsideCells();\n for (int i = 0; i < M; i++) {\n ans[i] = bfsMove(humans[i].x, humans[i].y, targets, avoid, false);\n }\n } else {\n if (!startedBuild) {\n if (petsInside() == 0 || turn >= 100) {\n startedBuild = true;\n }\n }\n\n if (!startedBuild) {\n auto c = centerCell();\n vector> targets = {c};\n for (int i = 0; i < M; i++) {\n ans[i] = bfsMove(humans[i].x, humans[i].y, targets, avoid, true);\n }\n } else if (!allTasksDone()) {\n bool scheduledWall[31][31] = {};\n\n // First, humans already standing at task positions try to build.\n for (int i = 0; i < M; i++) {\n int hx = humans[i].x;\n int hy = humans[i].y;\n\n for (auto &t : tasks) {\n if (wall_[t.wx][t.wy]) continue;\n if (t.sx != hx || t.sy != hy) continue;\n if (scheduledWall[t.wx][t.wy]) continue;\n if (!validBuildTarget(t.wx, t.wy, occH, occP)) continue;\n\n ans[i] = dirFromTo(hx, hy, t.wx, t.wy, true);\n scheduledWall[t.wx][t.wy] = true;\n avoid[t.wx][t.wy] = true;\n break;\n }\n }\n\n // Then move idle humans to useful task positions.\n vector> goodTargets;\n vector> fallbackTargets;\n\n for (auto &t : tasks) {\n if (wall_[t.wx][t.wy]) continue;\n if (scheduledWall[t.wx][t.wy]) continue;\n\n fallbackTargets.push_back({t.sx, t.sy});\n\n if (validBuildTarget(t.wx, t.wy, occH, occP)) {\n goodTargets.push_back({t.sx, t.sy});\n }\n }\n\n if (goodTargets.empty()) goodTargets = fallbackTargets;\n\n for (int i = 0; i < M; i++) {\n if (ans[i] != '.') continue;\n\n bool restrict = insideRegion(humans[i].x, humans[i].y);\n ans[i] = bfsMove(\n humans[i].x,\n humans[i].y,\n goodTargets,\n avoid,\n restrict\n );\n }\n } else {\n auto c = centerCell();\n vector> targets = {c};\n for (int i = 0; i < M; i++) {\n ans[i] = bfsMove(humans[i].x, humans[i].y, targets, avoid, true);\n }\n }\n }\n\n cout << ans << endl;\n cout.flush();\n\n // Apply human actions and created walls.\n for (int i = 0; i < M; i++) {\n char a = ans[i];\n\n if (a == 'U' || a == 'D' || a == 'L' || a == 'R') {\n for (int d = 0; d < 4; d++) {\n if (a == mvChar[d]) {\n humans[i].x += dx[d];\n humans[i].y += dy[d];\n }\n }\n } else if (a == 'u' || a == 'd' || a == 'l' || a == 'r') {\n for (int d = 0; d < 4; d++) {\n if (a == buildChar[d]) {\n int wx = humans[i].x + dx[d];\n int wy = humans[i].y + dy[d];\n if (inBoard(wx, wy)) wall_[wx][wy] = true;\n }\n }\n }\n }\n\n // Read and apply pet movements.\n for (int i = 0; i < N; i++) {\n string s;\n if (!(cin >> s)) return 0;\n\n if (s == \".\") continue;\n\n for (char c : s) {\n if (c == 'U') pets[i].x--;\n else if (c == 'D') pets[i].x++;\n else if (c == 'L') pets[i].y--;\n else if (c == 'R') pets[i].y++;\n }\n }\n }\n\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nstatic const int N = 20;\nstatic const int V = 400;\nstatic const int MAXL = 200;\n\nint si_, sj_, ti_, tj_;\ndouble p_fail, p_succ;\nstring hwall[20], vwall[19];\n\nint start_id, target_id;\nint nxt_cell[4][V];\nint dist_to_t[V];\nfloat potential_value[MAXL + 1][V];\n\nconst string DIRS = \"UDLR\";\nint di[4] = {-1, 1, 0, 0};\nint dj[4] = {0, 0, -1, 1};\n\nint id(int i, int j) {\n return i * N + j;\n}\n\npair pos(int x) {\n return {x / N, x % N};\n}\n\nstruct Node {\n array prob;\n double score;\n double eval;\n string path;\n};\n\ndouble evaluate_string(const string& s) {\n static double cur[V], nxt[V];\n\n for (int i = 0; i < V; i++) cur[i] = 0.0;\n cur[start_id] = 1.0;\n\n double score = 0.0;\n\n for (int t = 0; t < (int)s.size(); t++) {\n int dir;\n if (s[t] == 'U') dir = 0;\n else if (s[t] == 'D') dir = 1;\n else if (s[t] == 'L') dir = 2;\n else dir = 3;\n\n for (int i = 0; i < V; i++) nxt[i] = 0.0;\n\n double arrive = 0.0;\n double remain_mass = 0.0;\n\n for (int c = 0; c < V; c++) {\n double pr = cur[c];\n if (pr < 1e-18) continue;\n\n int to = nxt_cell[dir][c];\n\n if (to == target_id) {\n arrive += pr * p_succ;\n nxt[c] += pr * p_fail;\n } else if (to == c) {\n nxt[c] += pr;\n } else {\n nxt[c] += pr * p_fail;\n nxt[to] += pr * p_succ;\n }\n }\n\n score += arrive * (400 - t);\n\n for (int i = 0; i < V; i++) {\n cur[i] = nxt[i];\n remain_mass += cur[i];\n }\n\n if (remain_mass < 1e-18) break;\n }\n\n return score;\n}\n\nvoid build_graph() {\n for (int x = 0; x < V; x++) {\n auto [i, j] = pos(x);\n\n // U\n if (i == 0 || vwall[i - 1][j] == '1') nxt_cell[0][x] = x;\n else nxt_cell[0][x] = id(i - 1, j);\n\n // D\n if (i == N - 1 || vwall[i][j] == '1') nxt_cell[1][x] = x;\n else nxt_cell[1][x] = id(i + 1, j);\n\n // L\n if (j == 0 || hwall[i][j - 1] == '1') nxt_cell[2][x] = x;\n else nxt_cell[2][x] = id(i, j - 1);\n\n // R\n if (j == N - 1 || hwall[i][j] == '1') nxt_cell[3][x] = x;\n else nxt_cell[3][x] = id(i, j + 1);\n }\n}\n\nvoid bfs_distance() {\n const int INF = 1e9;\n fill(dist_to_t, dist_to_t + V, INF);\n\n queue q;\n dist_to_t[target_id] = 0;\n q.push(target_id);\n\n while (!q.empty()) {\n int v = q.front();\n q.pop();\n\n for (int d = 0; d < 4; d++) {\n int to = nxt_cell[d][v];\n if (to == v) continue;\n if (dist_to_t[to] > dist_to_t[v] + 1) {\n dist_to_t[to] = dist_to_t[v] + 1;\n q.push(to);\n }\n }\n }\n}\n\nvoid build_potential() {\n for (int t = 0; t <= MAXL; t++) {\n for (int c = 0; c < V; c++) {\n int d = dist_to_t[c];\n\n if (d > MAXL - t) {\n potential_value[t][c] = 0.0f;\n continue;\n }\n\n double estimated_turn = t + d / p_succ;\n double val = 401.0 - estimated_turn;\n if (val < 0.0) val = 0.0;\n\n potential_value[t][c] = (float)val;\n }\n }\n}\n\nstring beam_search() {\n const int BEAM_WIDTH = 250;\n\n vector beam;\n beam.reserve(BEAM_WIDTH);\n\n Node init;\n init.prob.fill(0.0f);\n init.prob[start_id] = 1.0f;\n init.score = 0.0;\n init.eval = potential_value[0][start_id];\n init.path = \"\";\n beam.push_back(init);\n\n for (int depth = 0; depth < MAXL; depth++) {\n vector cand;\n cand.reserve(beam.size() * 4);\n\n for (const Node& par : beam) {\n for (int dir = 0; dir < 4; dir++) {\n Node ch;\n ch.prob.fill(0.0f);\n\n float arrive = 0.0f;\n\n for (int c = 0; c < V; c++) {\n float pr = par.prob[c];\n if (pr < 1e-12f) continue;\n\n int to = nxt_cell[dir][c];\n\n if (to == target_id) {\n arrive += pr * (float)p_succ;\n ch.prob[c] += pr * (float)p_fail;\n } else if (to == c) {\n ch.prob[c] += pr;\n } else {\n ch.prob[c] += pr * (float)p_fail;\n ch.prob[to] += pr * (float)p_succ;\n }\n }\n\n int nt = depth + 1;\n ch.score = par.score + arrive * (400 - depth);\n\n double pot = 0.0;\n for (int c = 0; c < V; c++) {\n float pr = ch.prob[c];\n if (pr < 1e-12f) continue;\n pot += pr * potential_value[nt][c];\n }\n\n ch.eval = ch.score + pot;\n ch.path = par.path;\n ch.path.push_back(DIRS[dir]);\n\n cand.push_back(std::move(ch));\n }\n }\n\n if ((int)cand.size() > BEAM_WIDTH) {\n nth_element(\n cand.begin(),\n cand.begin() + BEAM_WIDTH,\n cand.end(),\n [](const Node& a, const Node& b) {\n if (a.eval != b.eval) return a.eval > b.eval;\n return a.score > b.score;\n }\n );\n cand.resize(BEAM_WIDTH);\n }\n\n beam.swap(cand);\n }\n\n int best = 0;\n for (int i = 1; i < (int)beam.size(); i++) {\n if (beam[i].score > beam[best].score) best = i;\n }\n\n return beam[best].path;\n}\n\nvoid local_improve(string& ans, chrono::steady_clock::time_point start_time) {\n auto elapsed = [&]() {\n return chrono::duration(chrono::steady_clock::now() - start_time).count();\n };\n\n double best_score = evaluate_string(ans);\n\n bool improved = true;\n\n while (improved && elapsed() < 1.85) {\n improved = false;\n\n for (int pos = 0; pos < (int)ans.size(); pos++) {\n if (elapsed() > 1.88) break;\n\n char original = ans[pos];\n char best_char = original;\n double local_best = best_score;\n\n for (char c : DIRS) {\n if (c == original) continue;\n\n ans[pos] = c;\n double sc = evaluate_string(ans);\n\n if (sc > local_best + 1e-10) {\n local_best = sc;\n best_char = c;\n }\n\n if (elapsed() > 1.88) break;\n }\n\n ans[pos] = best_char;\n\n if (best_char != original) {\n best_score = local_best;\n improved = true;\n }\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto start_time = chrono::steady_clock::now();\n\n cin >> si_ >> sj_ >> ti_ >> tj_ >> p_fail;\n p_succ = 1.0 - p_fail;\n\n for (int i = 0; i < 20; i++) cin >> hwall[i];\n for (int i = 0; i < 19; i++) cin >> vwall[i];\n\n start_id = id(si_, sj_);\n target_id = id(ti_, tj_);\n\n build_graph();\n bfs_distance();\n build_potential();\n\n string ans = beam_search();\n\n local_improve(ans, start_time);\n\n if ((int)ans.size() > MAXL) ans.resize(MAXL);\n\n cout << ans << '\\n';\n\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nstatic constexpr int N = 30;\nstatic constexpr int V = N * N;\nstatic constexpr int MAXP = 2000;\n\nstruct XorShift {\n uint64_t x = chrono::steady_clock::now().time_since_epoch().count();\n uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int n) {\n return (int)(next() % n);\n }\n double nextDouble() {\n return (next() >> 11) * (1.0 / 9007199254740992.0);\n }\n} rng;\n\nint parent_[MAXP], sz_[MAXP], open_[MAXP];\nint sidePid[V][4];\n\nint findp(int x) {\n while (parent_[x] != x) {\n parent_[x] = parent_[parent_[x]];\n x = parent_[x];\n }\n return x;\n}\n\nvoid unite(int a, int b) {\n int ra = findp(a), rb = findp(b);\n if (ra == rb) return;\n if (sz_[ra] < sz_[rb]) swap(ra, rb);\n parent_[rb] = ra;\n sz_[ra] += sz_[rb];\n}\n\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nconst int pieceCntOf[8] = {1,1,1,1,2,2,1,1};\nconst int A[8][2] = {\n {0, -1},\n {0, -1},\n {2, -1},\n {1, -1},\n {0, 2},\n {0, 1},\n {0, -1},\n {1, -1},\n};\nconst int B[8][2] = {\n {1, -1},\n {3, -1},\n {3, -1},\n {2, -1},\n {1, 3},\n {3, 2},\n {2, -1},\n {3, -1},\n};\n\nstruct Eval {\n long long actual = 0;\n int l1 = 0;\n int l2 = 0;\n double energy = 0;\n};\n\nEval evaluate(const uint8_t state[V]) {\n memset(sidePid, -1, sizeof(sidePid));\n\n int pc = 0;\n\n for (int k = 0; k < V; k++) {\n int t = state[k];\n int c = pieceCntOf[t];\n\n for (int p = 0; p < c; p++) {\n int id = pc++;\n parent_[id] = id;\n sz_[id] = 1;\n open_[id] = 0;\n\n int a = A[t][p];\n int b = B[t][p];\n sidePid[k][a] = id;\n sidePid[k][b] = id;\n }\n }\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int k = i * N + j;\n\n if (j + 1 < N) {\n int a = sidePid[k][2];\n int b = sidePid[k + 1][0];\n if (a != -1 && b != -1) unite(a, b);\n }\n\n if (i + 1 < N) {\n int a = sidePid[k][3];\n int b = sidePid[k + N][1];\n if (a != -1 && b != -1) unite(a, b);\n }\n }\n }\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int k = i * N + j;\n\n for (int d = 0; d < 4; d++) {\n int id = sidePid[k][d];\n if (id == -1) continue;\n\n int ni = i + di[d];\n int nj = j + dj[d];\n\n bool bad = false;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) {\n bad = true;\n } else {\n int nk = ni * N + nj;\n int od = (d + 2) & 3;\n if (sidePid[nk][od] == -1) bad = true;\n }\n\n if (bad) {\n open_[findp(id)]++;\n }\n }\n }\n }\n\n Eval res;\n double compBonus = 0.0;\n\n for (int id = 0; id < pc; id++) {\n int r = findp(id);\n if (r != id) continue;\n\n int s = sz_[r];\n int op = open_[r];\n\n compBonus += (double)s * s / (op + 1);\n\n if (op == 0) {\n if (s > res.l1) {\n res.l2 = res.l1;\n res.l1 = s;\n } else if (s > res.l2) {\n res.l2 = s;\n }\n }\n }\n\n if (res.l2 > 0) res.actual = 1LL * res.l1 * res.l2;\n\n res.energy =\n (double)res.actual\n + 1.50 * res.l1 * res.l1\n + 1.50 * res.l2 * res.l2\n + 0.05 * compBonus;\n\n return res;\n}\n\nint rotateTile(int t, int r) {\n if (t < 4) return (t + r) & 3;\n if (t < 6) return 4 + ((t - 4 + r) & 1);\n return 6 + ((t - 6 + r) & 1);\n}\n\nint outsideCountState(int k, int t) {\n int i = k / N;\n int j = k % N;\n\n bool has[4] = {};\n for (int p = 0; p < pieceCntOf[t]; p++) {\n has[A[t][p]] = true;\n has[B[t][p]] = true;\n }\n\n int cnt = 0;\n for (int d = 0; d < 4; d++) {\n if (!has[d]) continue;\n int ni = i + di[d];\n int nj = j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) cnt++;\n }\n return cnt;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto timeStart = chrono::steady_clock::now();\n\n string input[30];\n for (int i = 0; i < N; i++) cin >> input[i];\n\n uint8_t base[V];\n\n int dom[V][4], domCnt[V];\n int initDom[V][4], initDomCnt[V];\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int k = i * N + j;\n int t = input[i][j] - '0';\n base[k] = t;\n\n vector states;\n if (t < 4) {\n states = {0, 1, 2, 3};\n } else if (t < 6) {\n states = {4, 5};\n } else {\n states = {6, 7};\n }\n\n domCnt[k] = (int)states.size();\n for (int a = 0; a < domCnt[k]; a++) dom[k][a] = states[a];\n\n int bestOut = 100;\n for (int s : states) bestOut = min(bestOut, outsideCountState(k, s));\n\n initDomCnt[k] = 0;\n for (int s : states) {\n if (outsideCountState(k, s) == bestOut) {\n initDom[k][initDomCnt[k]++] = s;\n }\n }\n }\n }\n\n uint8_t cur[V], best[V], startState[V];\n\n Eval bestEval;\n Eval bestEnergyEval;\n bestEval.actual = -1;\n bestEnergyEval.energy = -1e100;\n\n constexpr int INIT_TRIALS = 2500;\n\n for (int tr = 0; tr < INIT_TRIALS; tr++) {\n for (int k = 0; k < V; k++) {\n if ((rng.next() & 15) == 0) {\n cur[k] = dom[k][rng.nextInt(domCnt[k])];\n } else {\n cur[k] = initDom[k][rng.nextInt(initDomCnt[k])];\n }\n }\n\n Eval ev = evaluate(cur);\n\n if (ev.energy > bestEnergyEval.energy) {\n bestEnergyEval = ev;\n memcpy(startState, cur, V);\n }\n\n if (\n ev.actual > bestEval.actual ||\n (ev.actual == bestEval.actual && ev.energy > bestEval.energy)\n ) {\n bestEval = ev;\n memcpy(best, cur, V);\n }\n }\n\n memcpy(cur, startState, V);\n Eval curEval = evaluate(cur);\n\n bool restarted = false;\n\n const double TL = 1.92;\n const double T0 = 25000.0;\n const double T1 = 20.0;\n\n int iter = 0;\n\n while (true) {\n iter++;\n\n if ((iter & 255) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - timeStart).count();\n if (elapsed >= TL) break;\n\n double progress = elapsed / TL;\n if (!restarted && progress > 0.68) {\n memcpy(cur, best, V);\n curEval = evaluate(cur);\n restarted = true;\n }\n }\n\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - timeStart).count();\n double progress = min(1.0, elapsed / TL);\n double temp = T0 * pow(T1 / T0, progress);\n\n int m = 1;\n int r100 = rng.nextInt(100);\n if (r100 < 7) m = 2;\n if (r100 == 0) m = 3;\n\n int pos[3];\n uint8_t oldVal[3];\n\n for (int x = 0; x < m; x++) {\n while (true) {\n int k = rng.nextInt(V);\n bool used = false;\n for (int y = 0; y < x; y++) {\n if (pos[y] == k) used = true;\n }\n if (!used) {\n pos[x] = k;\n break;\n }\n }\n\n int k = pos[x];\n oldVal[x] = cur[k];\n\n int nd;\n do {\n nd = dom[k][rng.nextInt(domCnt[k])];\n } while (nd == cur[k]);\n\n cur[k] = nd;\n }\n\n Eval ne = evaluate(cur);\n double diff = ne.energy - curEval.energy;\n\n bool accept = false;\n if (diff >= 0) {\n accept = true;\n } else {\n double p = exp(diff / temp);\n if (rng.nextDouble() < p) accept = true;\n }\n\n if (\n ne.actual > bestEval.actual ||\n (ne.actual == bestEval.actual && ne.energy > bestEval.energy)\n ) {\n bestEval = ne;\n memcpy(best, cur, V);\n }\n\n if (accept) {\n curEval = ne;\n } else {\n for (int x = 0; x < m; x++) {\n cur[pos[x]] = oldVal[x];\n }\n }\n }\n\n string ans;\n ans.reserve(V);\n\n for (int k = 0; k < V; k++) {\n int b = base[k];\n int target = best[k];\n\n int rr = 0;\n for (int r = 0; r < 4; r++) {\n if (rotateTile(b, r) == target) {\n rr = r;\n break;\n }\n }\n ans.push_back(char('0' + rr));\n }\n\n cout << ans << '\\n';\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nusing ull = unsigned long long;\n\nint N, T, M;\nint FULLV;\n\nstruct Eval {\n int s; // largest tree component size\n int maxComp; // largest connected component size\n int cyc; // cycle excess\n};\n\nstruct Node {\n array b;\n int parent;\n short blank;\n short e;\n short s;\n unsigned char prev;\n ull hash;\n};\n\nstruct Cand {\n array b;\n int parent;\n short blank;\n short e;\n short s;\n short maxComp;\n short cyc;\n unsigned char prev;\n ull hash;\n long long h;\n};\n\null zob[100][16];\n\ninline int hexval(char c) {\n if ('0' <= c && c <= '9') return c - '0';\n return c - 'a' + 10;\n}\n\ninline bool edge_adj(const array& b, int x, int y) {\n if (y == x - 1) return (b[x] & 1) && (b[y] & 4);\n if (y == x + 1) return (b[x] & 4) && (b[y] & 1);\n if (y == x - N) return (b[x] & 2) && (b[y] & 8);\n if (y == x + N) return (b[x] & 8) && (b[y] & 2);\n return false;\n}\n\nint local_edges(const array& b, int a, int c) {\n int cells[2] = {a, c};\n int keys[8];\n int kc = 0;\n int res = 0;\n\n for (int ii = 0; ii < 2; ii++) {\n int x = cells[ii];\n int r = x / N, col = x % N;\n\n int neigh[4];\n int nc = 0;\n if (r > 0) neigh[nc++] = x - N;\n if (r + 1 < N) neigh[nc++] = x + N;\n if (col > 0) neigh[nc++] = x - 1;\n if (col + 1 < N) neigh[nc++] = x + 1;\n\n for (int k = 0; k < nc; k++) {\n int y = neigh[k];\n int u = min(x, y), v = max(x, y);\n int key = u * 100 + v;\n\n bool seen = false;\n for (int t = 0; t < kc; t++) {\n if (keys[t] == key) {\n seen = true;\n break;\n }\n }\n if (seen) continue;\n\n keys[kc++] = key;\n if (edge_adj(b, x, y)) res++;\n }\n }\n return res;\n}\n\nint total_edges(const array& b) {\n int e = 0;\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n int p = r * N + c;\n if (b[p] == 0) continue;\n if (c + 1 < N && b[p + 1] != 0) {\n if ((b[p] & 4) && (b[p + 1] & 1)) e++;\n }\n if (r + 1 < N && b[p + N] != 0) {\n if ((b[p] & 8) && (b[p + N] & 2)) e++;\n }\n }\n }\n return e;\n}\n\nstruct DSU {\n int p[100], sz[100], ed[100];\n\n void init(const array& b) {\n for (int i = 0; i < M; i++) {\n if (b[i]) {\n p[i] = i;\n sz[i] = 1;\n ed[i] = 0;\n } else {\n p[i] = -1;\n sz[i] = 0;\n ed[i] = 0;\n }\n }\n }\n\n int find(int x) {\n while (p[x] != x) {\n p[x] = p[p[x]];\n x = p[x];\n }\n return x;\n }\n\n void add_edge(int a, int b) {\n int ra = find(a), rb = find(b);\n if (ra == rb) {\n ed[ra]++;\n return;\n }\n if (sz[ra] < sz[rb]) swap(ra, rb);\n p[rb] = ra;\n sz[ra] += sz[rb];\n ed[ra] += ed[rb] + 1;\n }\n};\n\nEval eval_board(const array& b) {\n DSU d;\n d.init(b);\n\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n int p = r * N + c;\n if (b[p] == 0) continue;\n\n if (c + 1 < N && b[p + 1] != 0) {\n if ((b[p] & 4) && (b[p + 1] & 1)) {\n d.add_edge(p, p + 1);\n }\n }\n if (r + 1 < N && b[p + N] != 0) {\n if ((b[p] & 8) && (b[p + N] & 2)) {\n d.add_edge(p, p + N);\n }\n }\n }\n }\n\n Eval ev{0, 0, 0};\n\n for (int i = 0; i < M; i++) {\n if (b[i] == 0) continue;\n if (d.find(i) != i) continue;\n\n ev.maxComp = max(ev.maxComp, d.sz[i]);\n\n if (d.ed[i] == d.sz[i] - 1) {\n ev.s = max(ev.s, d.sz[i]);\n } else if (d.ed[i] >= d.sz[i]) {\n ev.cyc += d.ed[i] - d.sz[i] + 1;\n }\n }\n\n return ev;\n}\n\ninline long long heuristic_score(const Cand& c) {\n long long h = 0;\n h += 20000LL * c.s;\n h += 7000LL * c.e;\n h += 500LL * c.maxComp;\n h -= 10000LL * c.cyc;\n h += (long long)(c.hash & 1023ULL);\n return h;\n}\n\nstring restore_path(const vector& pool, int idx) {\n string res;\n while (pool[idx].parent != -1) {\n res.push_back((char)pool[idx].prev);\n idx = pool[idx].parent;\n }\n reverse(res.begin(), res.end());\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> T;\n M = N * N;\n FULLV = M - 1;\n\n mt19937_64 rng(123456789);\n for (int i = 0; i < 100; i++) {\n for (int v = 0; v < 16; v++) {\n zob[i][v] = rng();\n }\n }\n\n array init{};\n int initBlank = -1;\n ull initHash = 0;\n\n for (int r = 0; r < N; r++) {\n string s;\n cin >> s;\n for (int c = 0; c < N; c++) {\n int p = r * N + c;\n int v = hexval(s[c]);\n init[p] = (unsigned char)v;\n if (v == 0) initBlank = p;\n initHash ^= zob[p][v];\n }\n }\n\n auto start_time = chrono::steady_clock::now();\n\n int W;\n if (N == 6) W = 2400;\n else if (N == 7) W = 1700;\n else if (N == 8) W = 1150;\n else if (N == 9) W = 800;\n else W = 560;\n\n vector pool;\n pool.reserve((size_t)W * (T + 2) + 10);\n\n Node root;\n root.b = init;\n root.parent = -1;\n root.blank = initBlank;\n root.e = total_edges(init);\n root.prev = 0;\n root.hash = initHash;\n\n Eval rootEv = eval_board(init);\n root.s = rootEv.s;\n\n pool.push_back(root);\n\n if (rootEv.s == FULLV) {\n cout << \"\\n\";\n return 0;\n }\n\n vector beam;\n beam.push_back(0);\n\n int bestIdx = 0;\n int bestS = rootEv.s;\n\n const char mvChar[4] = {'U', 'D', 'L', 'R'};\n const int inv[256] = {\n 0\n };\n\n auto inverse_move = [](char c) -> char {\n if (c == 'U') return 'D';\n if (c == 'D') return 'U';\n if (c == 'L') return 'R';\n if (c == 'R') return 'L';\n return 0;\n };\n\n for (int step = 1; step <= T; step++) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 2.85) break;\n\n vector cand;\n cand.reserve(beam.size() * 3 + 10);\n\n for (int idx : beam) {\n const Node& nd = pool[idx];\n int z = nd.blank;\n int r = z / N, c = z % N;\n\n for (int dir = 0; dir < 4; dir++) {\n char mc = mvChar[dir];\n if (nd.prev && inverse_move((char)nd.prev) == mc) continue;\n\n int nz = -1;\n if (mc == 'U') {\n if (r == 0) continue;\n nz = z - N;\n } else if (mc == 'D') {\n if (r + 1 == N) continue;\n nz = z + N;\n } else if (mc == 'L') {\n if (c == 0) continue;\n nz = z - 1;\n } else {\n if (c + 1 == N) continue;\n nz = z + 1;\n }\n\n Cand x;\n x.b = nd.b;\n\n int before = local_edges(x.b, z, nz);\n\n unsigned char tile = x.b[nz];\n x.b[z] = tile;\n x.b[nz] = 0;\n\n int after = local_edges(x.b, z, nz);\n\n x.e = nd.e - before + after;\n x.parent = idx;\n x.blank = nz;\n x.prev = (unsigned char)mc;\n x.s = 0;\n x.maxComp = 0;\n x.cyc = 0;\n x.h = 0;\n\n ull h = nd.hash;\n h ^= zob[z][0];\n h ^= zob[nz][tile];\n h ^= zob[z][tile];\n h ^= zob[nz][0];\n x.hash = h;\n\n cand.push_back(std::move(x));\n }\n }\n\n if (cand.empty()) break;\n\n sort(cand.begin(), cand.end(), [](const Cand& a, const Cand& b) {\n if (a.hash != b.hash) return a.hash < b.hash;\n return a.e > b.e;\n });\n\n int write = 0;\n for (int i = 0; i < (int)cand.size();) {\n int j = i + 1;\n int best = i;\n while (j < (int)cand.size() && cand[j].hash == cand[i].hash) {\n if (cand[j].e > cand[best].e) best = j;\n j++;\n }\n cand[write++] = std::move(cand[best]);\n i = j;\n }\n cand.resize(write);\n\n int preLimit = min((int)cand.size(), max(W, 2 * W));\n if ((int)cand.size() > preLimit) {\n nth_element(cand.begin(), cand.begin() + preLimit, cand.end(),\n [](const Cand& a, const Cand& b) {\n return a.e > b.e;\n });\n cand.resize(preLimit);\n }\n\n for (Cand& x : cand) {\n Eval ev = eval_board(x.b);\n x.s = ev.s;\n x.maxComp = ev.maxComp;\n x.cyc = ev.cyc;\n x.h = heuristic_score(x);\n\n if (x.s > bestS) {\n Node tmp;\n tmp.b = x.b;\n tmp.parent = x.parent;\n tmp.blank = x.blank;\n tmp.e = x.e;\n tmp.s = x.s;\n tmp.prev = x.prev;\n tmp.hash = x.hash;\n pool.push_back(tmp);\n bestIdx = (int)pool.size() - 1;\n bestS = x.s;\n }\n\n if (x.s == FULLV) {\n Node tmp;\n tmp.b = x.b;\n tmp.parent = x.parent;\n tmp.blank = x.blank;\n tmp.e = x.e;\n tmp.s = x.s;\n tmp.prev = x.prev;\n tmp.hash = x.hash;\n pool.push_back(tmp);\n cout << restore_path(pool, (int)pool.size() - 1) << '\\n';\n return 0;\n }\n }\n\n sort(cand.begin(), cand.end(), [](const Cand& a, const Cand& b) {\n if (a.h != b.h) return a.h > b.h;\n return a.e > b.e;\n });\n\n int keep = min(W, (int)cand.size());\n vector nextBeam;\n nextBeam.reserve(keep);\n\n for (int i = 0; i < keep; i++) {\n Node nd;\n nd.b = cand[i].b;\n nd.parent = cand[i].parent;\n nd.blank = cand[i].blank;\n nd.e = cand[i].e;\n nd.s = cand[i].s;\n nd.prev = cand[i].prev;\n nd.hash = cand[i].hash;\n\n pool.push_back(nd);\n int ni = (int)pool.size() - 1;\n nextBeam.push_back(ni);\n\n if (nd.s > bestS) {\n bestS = nd.s;\n bestIdx = ni;\n }\n }\n\n beam.swap(nextBeam);\n }\n\n cout << restore_path(pool, bestIdx) << '\\n';\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n};\n\nstruct Line {\n // a*x + b*y = c, usually (a,b) is a unit normal\n double a, b, c;\n};\n\nstruct EvalResult {\n int matched;\n int diff;\n array hist;\n long long value() const {\n return 10000LL * matched - diff;\n }\n};\n\nstruct Key {\n uint64_t lo, hi;\n bool operator==(const Key& other) const {\n return lo == other.lo && hi == other.hi;\n }\n};\n\nstruct KeyHash {\n size_t operator()(const Key& k) const {\n uint64_t x = k.lo ^ (k.hi + 0x9e3779b97f4a7c15ULL + (k.lo << 6) + (k.lo >> 2));\n x ^= x >> 30;\n x *= 0xbf58476d1ce4e5b9ULL;\n x ^= x >> 27;\n x *= 0x94d049bb133111ebULL;\n x ^= x >> 31;\n return (size_t)x;\n }\n};\n\nstatic const double PI = acos(-1.0);\nstatic const double R = 10000.0;\n\nint N, K;\narray targetA;\nvector pts;\n\nchrono::steady_clock::time_point start_time;\n\ndouble elapsed_sec() {\n return chrono::duration(chrono::steady_clock::now() - start_time).count();\n}\n\nEvalResult make_eval_from_hist(const array& hist) {\n EvalResult res;\n res.hist = hist;\n res.matched = 0;\n res.diff = 0;\n for (int d = 1; d <= 10; d++) {\n res.matched += min(targetA[d], hist[d]);\n res.diff += abs(targetA[d] - hist[d]);\n }\n return res;\n}\n\nEvalResult eval_grid(double theta, const vector& cutsU, const vector& cutsV) {\n int gx = (int)cutsU.size() + 1;\n int gy = (int)cutsV.size() + 1;\n vector cnt(gx * gy, 0);\n\n double cs = cos(theta), sn = sin(theta);\n\n for (const auto& p : pts) {\n double u = p.x * cs + p.y * sn;\n double v = -p.x * sn + p.y * cs;\n int ix = int(upper_bound(cutsU.begin(), cutsU.end(), u) - cutsU.begin());\n int iy = int(upper_bound(cutsV.begin(), cutsV.end(), v) - cutsV.begin());\n cnt[ix * gy + iy]++;\n }\n\n array hist{};\n hist.fill(0);\n for (int c : cnt) {\n if (1 <= c && c <= 10) hist[c]++;\n }\n return make_eval_from_hist(hist);\n}\n\nEvalResult eval_lines(const vector& lines) {\n unordered_map mp;\n mp.reserve(pts.size() * 2);\n\n int L = (int)lines.size();\n\n for (const auto& p : pts) {\n uint64_t lo = 0, hi = 0;\n for (int i = 0; i < L; i++) {\n const auto& ln = lines[i];\n double v = ln.a * p.x + ln.b * p.y - ln.c;\n if (v > 0) {\n if (i < 64) lo |= (1ULL << i);\n else hi |= (1ULL << (i - 64));\n }\n }\n mp[{lo, hi}]++;\n }\n\n array hist{};\n hist.fill(0);\n for (auto& kv : mp) {\n int c = kv.second;\n if (1 <= c && c <= 10) hist[c]++;\n }\n return make_eval_from_hist(hist);\n}\n\nvector uniform_cuts(int g) {\n vector cuts;\n cuts.reserve(max(0, g - 1));\n for (int i = 1; i < g; i++) {\n cuts.push_back(-R + 2.0 * R * i / g);\n }\n return cuts;\n}\n\nvector random_dirichlet_cuts(int g, double alpha, mt19937& rng) {\n vector w(g);\n if (alpha > 500.0) {\n for (int i = 0; i < g; i++) w[i] = 1.0;\n } else {\n gamma_distribution gamma(alpha, 1.0);\n for (int i = 0; i < g; i++) {\n w[i] = max(1e-9, gamma(rng));\n }\n }\n\n double sum = accumulate(w.begin(), w.end(), 0.0);\n vector cuts;\n cuts.reserve(max(0, g - 1));\n\n double cur = -R;\n for (int i = 0; i + 1 < g; i++) {\n cur += 2.0 * R * w[i] / sum;\n cuts.push_back(cur);\n }\n sort(cuts.begin(), cuts.end());\n return cuts;\n}\n\nvector build_grid_lines(double theta, const vector& cutsU, const vector& cutsV) {\n vector lines;\n lines.reserve(cutsU.size() + cutsV.size());\n\n double cs = cos(theta), sn = sin(theta);\n\n // u = x cos(theta) + y sin(theta)\n for (double c : cutsU) {\n lines.push_back({cs, sn, c});\n }\n\n // v = -x sin(theta) + y cos(theta)\n for (double c : cutsV) {\n lines.push_back({-sn, cs, c});\n }\n\n return lines;\n}\n\nint nearest_safe_integer(double x, const unordered_set& forbidden) {\n int base = (int)llround(x);\n for (int d = 0; d <= 30000; d++) {\n int c1 = base + d;\n if (c1 >= -1000000000 && c1 <= 1000000000 && !forbidden.count(c1)) return c1;\n int c2 = base - d;\n if (d && c2 >= -1000000000 && c2 <= 1000000000 && !forbidden.count(c2)) return c2;\n }\n return base;\n}\n\nbool collinear_with_any_point(long long x1, long long y1, long long x2, long long y2) {\n long long dx = x2 - x1;\n long long dy = y2 - y1;\n for (const auto& p : pts) {\n __int128 v = (__int128)dx * (p.y - y1) - (__int128)dy * (p.x - x1);\n if (v == 0) return true;\n }\n return false;\n}\n\narray line_to_integer_points(\n const Line& ln,\n const unordered_set& forbiddenX,\n const unordered_set& forbiddenY\n) {\n double a = ln.a, b = ln.b, c = ln.c;\n\n const long long BIG = 100000000LL;\n\n long long x1, y1, x2, y2;\n\n // Exactly vertical-ish / horizontal-ish lines are output safely.\n if (fabs(b) < 1e-12 && fabs(a) > 0.999999999) {\n int xi = nearest_safe_integer(c / a, forbiddenX);\n x1 = xi; y1 = -BIG;\n x2 = xi; y2 = BIG;\n } else if (fabs(a) < 1e-12 && fabs(b) > 0.999999999) {\n int yi = nearest_safe_integer(c / b, forbiddenY);\n x1 = -BIG; y1 = yi;\n x2 = BIG; y2 = yi;\n } else {\n // Point on line closest to origin: c*(a,b), direction (-b,a)\n double px = a * c;\n double py = b * c;\n double dx = -b;\n double dy = a;\n\n x1 = llround(px + BIG * dx);\n y1 = llround(py + BIG * dy);\n x2 = llround(px - BIG * dx);\n y2 = llround(py - BIG * dy);\n }\n\n if (x1 == x2 && y1 == y2) x2++;\n\n // Avoid cutting exactly through a strawberry center.\n for (int t = 0; t < 20 && collinear_with_any_point(x1, y1, x2, y2); t++) {\n if (abs(x2 + 1) <= 1000000000LL) x2++;\n else y2++;\n }\n\n x1 = max(-1000000000LL, min(1000000000LL, x1));\n y1 = max(-1000000000LL, min(1000000000LL, y1));\n x2 = max(-1000000000LL, min(1000000000LL, x2));\n y2 = max(-1000000000LL, min(1000000000LL, y2));\n\n if (x1 == x2 && y1 == y2) {\n if (x2 < 1000000000LL) x2++;\n else x2--;\n }\n\n return {x1, y1, x2, y2};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n start_time = chrono::steady_clock::now();\n\n cin >> N >> K;\n targetA.fill(0);\n\n int M = 0;\n for (int d = 1; d <= 10; d++) {\n cin >> targetA[d];\n M += targetA[d];\n }\n\n pts.resize(N);\n unordered_set forbiddenX, forbiddenY;\n forbiddenX.reserve(N * 2);\n forbiddenY.reserve(N * 2);\n\n for (int i = 0; i < N; i++) {\n cin >> pts[i].x >> pts[i].y;\n forbiddenX.insert(pts[i].x);\n forbiddenY.insert(pts[i].y);\n }\n\n mt19937 rng(1234567);\n\n vector bestLines;\n long long bestValue = LLONG_MIN;\n\n auto try_grid = [&](double theta, const vector& cu, const vector& cv) {\n int k = (int)cu.size() + (int)cv.size();\n if (k > K) return;\n\n EvalResult er = eval_grid(theta, cu, cv);\n long long val = er.value();\n\n if (val > bestValue) {\n bestValue = val;\n bestLines = build_grid_lines(theta, cu, cv);\n }\n };\n\n auto try_lines = [&](const vector& lines) {\n if ((int)lines.size() > K) return;\n\n EvalResult er = eval_lines(lines);\n long long val = er.value();\n\n if (val > bestValue) {\n bestValue = val;\n bestLines = lines;\n }\n };\n\n // Main expected number of grid intervals.\n double baseProduct = 4.0 * M / PI;\n\n vector factors = {0.50, 0.65, 0.80, 1.00, 1.20, 1.50, 1.80, 2.10};\n vector aspects = {0.55, 0.70, 0.85, 1.00, 1.18, 1.42, 1.80};\n vector thetas = {0.0, PI / 16, PI / 8, 3 * PI / 16, PI / 4};\n\n // Deterministic uniform grids.\n for (double fac : factors) {\n for (double asp : aspects) {\n double prod = max(1.0, baseProduct * fac);\n int gx = max(1, (int)llround(sqrt(prod * asp)));\n int gy = max(1, (int)llround(sqrt(prod / asp)));\n\n while (gx + gy - 2 > K) {\n if (gx > gy) gx--;\n else gy--;\n }\n\n if (gx < 1 || gy < 1) continue;\n\n auto cu = uniform_cuts(gx);\n auto cv = uniform_cuts(gy);\n\n for (double th : thetas) {\n try_grid(th, cu, cv);\n }\n }\n }\n\n // A few 3-direction arrangements.\n for (int rep = 0; rep < 30 && elapsed_sec() < 2.2; rep++) {\n double hbase = sqrt(max(1.0, M / 3.0));\n double scale = 0.70 + 0.04 * rep;\n int g = max(2, (int)llround(hbase * scale));\n g = min(g, 34); // 3*(g-1) <= 99\n\n double th0 = (rep % 10) * PI / 30.0;\n vector lines;\n for (int f = 0; f < 3; f++) {\n double th = th0 + f * PI / 3.0;\n double a = cos(th), b = sin(th);\n auto cuts = uniform_cuts(g);\n for (double c : cuts) lines.push_back({a, b, c});\n }\n try_lines(lines);\n }\n\n vector alphaList = {0.30, 0.45, 0.70, 1.00, 1.50, 2.50, 5.00, 1000.0};\n uniform_real_distribution ur01(0.0, 1.0);\n uniform_real_distribution urTheta(0.0, PI / 2);\n\n // Randomized search over non-uniform rotated grids.\n int iter = 0;\n while (elapsed_sec() < 2.75) {\n iter++;\n\n double logFac = log(0.45) + ur01(rng) * (log(2.30) - log(0.45));\n double logAsp = log(0.45) + ur01(rng) * (log(2.20) - log(0.45));\n double fac = exp(logFac);\n double asp = exp(logAsp);\n\n double prod = max(1.0, baseProduct * fac);\n int gx = max(1, (int)llround(sqrt(prod * asp)));\n int gy = max(1, (int)llround(sqrt(prod / asp)));\n\n while (gx + gy - 2 > K) {\n if (gx > gy) gx--;\n else gy--;\n }\n\n if (gx < 1 || gy < 1) continue;\n\n double alphaX = alphaList[rng() % alphaList.size()];\n double alphaY = alphaList[rng() % alphaList.size()];\n\n vector cu = random_dirichlet_cuts(gx, alphaX, rng);\n vector cv = random_dirichlet_cuts(gy, alphaY, rng);\n\n double th = urTheta(rng);\n try_grid(th, cu, cv);\n\n // Occasionally try 3-direction random non-uniform lines.\n if (iter % 13 == 0 && elapsed_sec() < 2.55) {\n double hbase = sqrt(max(1.0, M / 3.0));\n double sc = exp(log(0.55) + ur01(rng) * (log(1.65) - log(0.55)));\n int g = max(2, min(34, (int)llround(hbase * sc)));\n\n vector lines;\n double th0 = ur01(rng) * PI / 3.0;\n double alpha = alphaList[rng() % alphaList.size()];\n\n for (int f = 0; f < 3; f++) {\n double thf = th0 + f * PI / 3.0;\n double a = cos(thf), b = sin(thf);\n auto cuts = random_dirichlet_cuts(g, alpha, rng);\n for (double c : cuts) lines.push_back({a, b, c});\n }\n try_lines(lines);\n }\n }\n\n if (bestLines.empty()) {\n // Fallback: simple 25x25 grid.\n auto cu = uniform_cuts(25);\n auto cv = uniform_cuts(25);\n bestLines = build_grid_lines(0.0, cu, cv);\n }\n\n if ((int)bestLines.size() > K) bestLines.resize(K);\n\n cout << bestLines.size() << '\\n';\n for (const auto& ln : bestLines) {\n auto e = line_to_integer_points(ln, forbiddenX, forbiddenY);\n cout << e[0] << ' ' << e[1] << ' ' << e[2] << ' ' << e[3] << '\\n';\n }\n\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstatic constexpr int MAXN = 61;\n\nint N, M;\nint W[MAXN][MAXN];\nvector> initialDots;\n\nstruct Timer {\n chrono::steady_clock::time_point st;\n Timer() { st = chrono::steady_clock::now(); }\n double elapsed() const {\n return chrono::duration(chrono::steady_clock::now() - st).count();\n }\n};\n\nstruct XorShift {\n uint64_t x;\n XorShift(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int mod) {\n if (mod <= 0) return 0;\n return (int)(next() % mod);\n }\n};\n\nstruct Move {\n int x1, y1, x2, y2, x3, y3, x4, y4;\n};\n\nstruct State {\n bool dot[MAXN][MAXN];\n bool seg[4][MAXN][MAXN];\n vector ops;\n long long totalWeight;\n\n void init() {\n memset(dot, 0, sizeof(dot));\n memset(seg, 0, sizeof(seg));\n ops.clear();\n ops.reserve(N * N);\n totalWeight = 0;\n for (auto [x, y] : initialDots) {\n dot[x][y] = true;\n totalWeight += W[x][y];\n }\n }\n\n int segType(int x1, int y1, int x2, int y2, int &sx, int &sy) const {\n int dx = x2 - x1;\n int dy = y2 - y1;\n if (dy == 0) {\n sx = min(x1, x2);\n sy = y1;\n return 0; // horizontal\n }\n if (dx == 0) {\n sx = x1;\n sy = min(y1, y2);\n return 1; // vertical\n }\n if (dx == dy) {\n sx = min(x1, x2);\n sy = min(y1, y2);\n return 2; // slope +1\n }\n sx = min(x1, x2);\n sy = min(y1, y2);\n return 3; // slope -1\n }\n\n bool unitUsed(int x1, int y1, int x2, int y2) const {\n int sx, sy;\n int t = segType(x1, y1, x2, y2, sx, sy);\n return seg[t][sx][sy];\n }\n\n void markUnit(int x1, int y1, int x2, int y2) {\n int sx, sy;\n int t = segType(x1, y1, x2, y2, sx, sy);\n seg[t][sx][sy] = true;\n }\n\n bool edgeFree(int ax, int ay, int bx, int by) const {\n int dx = (bx > ax) - (bx < ax);\n int dy = (by > ay) - (by < ay);\n int len = max(abs(bx - ax), abs(by - ay));\n\n int x = ax, y = ay;\n for (int i = 0; i < len; i++) {\n int nx = x + dx;\n int ny = y + dy;\n if (unitUsed(x, y, nx, ny)) return false;\n x = nx;\n y = ny;\n }\n return true;\n }\n\n void markEdge(int ax, int ay, int bx, int by) {\n int dx = (bx > ax) - (bx < ax);\n int dy = (by > ay) - (by < ay);\n int len = max(abs(bx - ax), abs(by - ay));\n\n int x = ax, y = ay;\n for (int i = 0; i < len; i++) {\n int nx = x + dx;\n int ny = y + dy;\n markUnit(x, y, nx, ny);\n x = nx;\n y = ny;\n }\n }\n\n bool rectEdgesFree(const Move &m) const {\n return edgeFree(m.x1, m.y1, m.x2, m.y2)\n && edgeFree(m.x2, m.y2, m.x3, m.y3)\n && edgeFree(m.x3, m.y3, m.x4, m.y4)\n && edgeFree(m.x4, m.y4, m.x1, m.y1);\n }\n\n void apply(const Move &m) {\n markEdge(m.x1, m.y1, m.x2, m.y2);\n markEdge(m.x2, m.y2, m.x3, m.y3);\n markEdge(m.x3, m.y3, m.x4, m.y4);\n markEdge(m.x4, m.y4, m.x1, m.y1);\n\n dot[m.x1][m.y1] = true;\n totalWeight += W[m.x1][m.y1];\n ops.push_back(m);\n }\n};\n\nstruct Param {\n int wcoef;\n int pcoef;\n int noise;\n};\n\nstruct Result {\n long long score;\n vector ops;\n};\n\nint dx8[8] = {1, 0, -1, 0, 1, -1, -1, 1};\nint dy8[8] = {0, 1, 0, -1, 1, 1, -1, -1};\n\n// Adjacent perpendicular direction pairs.\n// 0:E 1:N 2:W 3:S 4:NE 5:NW 6:SW 7:SE\npair dirPairs[8] = {\n {0, 1}, {1, 2}, {2, 3}, {3, 0},\n {4, 5}, {5, 6}, {6, 7}, {7, 4}\n};\n\ninline bool inside(int x, int y) {\n return 0 <= x && x < N && 0 <= y && y < N;\n}\n\ninline int enc(int x, int y) {\n return x * N + y;\n}\n\ninline int stepLen(int ax, int ay, int bx, int by) {\n return max(abs(ax - bx), abs(ay - by));\n}\n\nResult simulate(const Param ¶m, uint64_t seed, const Timer &timer, double deadline) {\n State st;\n st.init();\n XorShift rng(seed);\n\n static short nearestDot[8][MAXN][MAXN];\n\n while (true) {\n if (timer.elapsed() > deadline) break;\n\n // Build nearest visible dot table for 8 directions.\n for (int d = 0; d < 8; d++) {\n int xs = dx8[d] > 0 ? N - 1 : 0;\n int xe = dx8[d] > 0 ? -1 : N;\n int xi = dx8[d] > 0 ? -1 : 1;\n\n int ys = dy8[d] > 0 ? N - 1 : 0;\n int ye = dy8[d] > 0 ? -1 : N;\n int yi = dy8[d] > 0 ? -1 : 1;\n\n for (int x = xs; x != xe; x += xi) {\n for (int y = ys; y != ye; y += yi) {\n int nx = x + dx8[d];\n int ny = y + dy8[d];\n if (!inside(nx, ny)) {\n nearestDot[d][x][y] = -1;\n } else if (st.dot[nx][ny]) {\n nearestDot[d][x][y] = enc(nx, ny);\n } else {\n nearestDot[d][x][y] = nearestDot[d][nx][ny];\n }\n }\n }\n }\n\n bool found = false;\n long long bestEval = LLONG_MIN;\n Move best{};\n\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (st.dot[x][y]) continue;\n\n for (auto [d1, d2] : dirPairs) {\n int e2 = nearestDot[d1][x][y];\n int e4 = nearestDot[d2][x][y];\n if (e2 < 0 || e4 < 0) continue;\n\n int x2 = e2 / N, y2 = e2 % N;\n int x4 = e4 / N, y4 = e4 % N;\n\n int x3 = x2 + x4 - x;\n int y3 = y2 + y4 - y;\n if (!inside(x3, y3)) continue;\n if (!st.dot[x3][y3]) continue;\n\n int e3 = enc(x3, y3);\n if (nearestDot[d2][x2][y2] != e3) continue;\n if (nearestDot[d1][x4][y4] != e3) continue;\n\n Move mv{x, y, x2, y2, x3, y3, x4, y4};\n if (!st.rectEdgesFree(mv)) continue;\n\n int perim = stepLen(x, y, x2, y2)\n + stepLen(x2, y2, x3, y3)\n + stepLen(x3, y3, x4, y4)\n + stepLen(x4, y4, x, y);\n\n long long eval = 1LL * W[x][y] * param.wcoef\n - 1LL * perim * param.pcoef\n + rng.nextInt(param.noise);\n\n if (!found || eval > bestEval || (eval == bestEval && rng.nextInt(2))) {\n found = true;\n bestEval = eval;\n best = mv;\n }\n }\n }\n }\n\n if (!found) break;\n st.apply(best);\n }\n\n return Result{st.totalWeight, st.ops};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> M;\n\n initialDots.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> initialDots[i].first >> initialDots[i].second;\n }\n\n int c = (N - 1) / 2;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n W[x][y] = (x - c) * (x - c) + (y - c) * (y - c) + 1;\n }\n }\n\n Timer timer;\n const double DEADLINE = 4.75;\n\n vector params = {\n {1000, 0, 0},\n {1000, 20, 20000},\n {1000, 80, 50000},\n {1000, 200, 100000},\n {1000, -20, 50000},\n {1000, -80, 100000},\n {1000, 0, 200000},\n {1000, 400, 200000},\n };\n\n Result best{-1, {}};\n\n int run = 0;\n while (timer.elapsed() < DEADLINE) {\n Param p = params[run % params.size()];\n uint64_t seed = 123456789ULL + 1000003ULL * run + 998244353ULL * N + M;\n Result res = simulate(p, seed, timer, DEADLINE);\n\n if (res.score > best.score) {\n best = std::move(res);\n }\n\n run++;\n }\n\n cout << best.ops.size() << '\\n';\n for (const auto &m : best.ops) {\n cout << m.x1 << ' ' << m.y1 << ' '\n << m.x2 << ' ' << m.y2 << ' '\n << m.x3 << ' ' << m.y3 << ' '\n << m.x4 << ' ' << m.y4 << '\\n';\n }\n\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstruct XorShift {\n uint32_t x;\n XorShift(uint32_t seed = 2463534242u) : x(seed) {}\n uint32_t next() {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n }\n int randint(int n) {\n return (int)(next() % n);\n }\n};\n\nusing Board = array;\n\nint F[101];\nint cntFlavor[4];\n\nint anchorR[4], anchorC[4];\nint distCell[4][100];\nint targetCell[100];\n\nconst int cornerR[4] = {0, 0, 9, 9};\nconst int cornerC[4] = {0, 9, 0, 9};\n\nchar dirChar[4] = {'F', 'B', 'L', 'R'};\n\nBoard tiltBoard(const Board& b, int dir) {\n Board nb{};\n nb.fill(0);\n\n if (dir == 0) { // F\n for (int c = 0; c < 10; c++) {\n int w = 0;\n for (int r = 0; r < 10; r++) {\n unsigned char v = b[r * 10 + c];\n if (v) nb[w++ * 10 + c] = v;\n }\n }\n } else if (dir == 1) { // B\n for (int c = 0; c < 10; c++) {\n int w = 9;\n for (int r = 9; r >= 0; r--) {\n unsigned char v = b[r * 10 + c];\n if (v) nb[w-- * 10 + c] = v;\n }\n }\n } else if (dir == 2) { // L\n for (int r = 0; r < 10; r++) {\n int w = 0;\n for (int c = 0; c < 10; c++) {\n unsigned char v = b[r * 10 + c];\n if (v) nb[r * 10 + w++] = v;\n }\n }\n } else { // R\n for (int r = 0; r < 10; r++) {\n int w = 9;\n for (int c = 9; c >= 0; c--) {\n unsigned char v = b[r * 10 + c];\n if (v) nb[r * 10 + w--] = v;\n }\n }\n }\n\n return nb;\n}\n\nvoid placeCandy(Board& b, int p, int flavor) {\n int k = 0;\n for (int i = 0; i < 100; i++) {\n if (b[i] == 0) {\n k++;\n if (k == p) {\n b[i] = (unsigned char)flavor;\n return;\n }\n }\n }\n}\n\nlong long componentRawScore(const Board& b) {\n bool vis[100] = {};\n long long res = 0;\n\n for (int s = 0; s < 100; s++) {\n if (b[s] == 0 || vis[s]) continue;\n\n int flav = b[s];\n int q[100];\n int head = 0, tail = 0;\n q[tail++] = s;\n vis[s] = true;\n int sz = 0;\n\n while (head < tail) {\n int v = q[head++];\n sz++;\n int r = v / 10;\n int c = v % 10;\n\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr < 0 || nr >= 10 || nc < 0 || nc >= 10) continue;\n int ni = nr * 10 + nc;\n if (!vis[ni] && b[ni] == flav) {\n vis[ni] = true;\n q[tail++] = ni;\n }\n }\n }\n\n res += 1LL * sz * sz;\n }\n\n return res;\n}\n\nlong long evalBoard(const Board& b) {\n bool vis[100] = {};\n long long comp = 0;\n\n for (int s = 0; s < 100; s++) {\n if (b[s] == 0 || vis[s]) continue;\n\n int flav = b[s];\n int q[100];\n int head = 0, tail = 0;\n q[tail++] = s;\n vis[s] = true;\n int sz = 0;\n\n while (head < tail) {\n int v = q[head++];\n sz++;\n int r = v / 10;\n int c = v % 10;\n\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr < 0 || nr >= 10 || nc < 0 || nc >= 10) continue;\n int ni = nr * 10 + nc;\n if (!vis[ni] && b[ni] == flav) {\n vis[ni] = true;\n q[tail++] = ni;\n }\n }\n }\n\n comp += 1LL * sz * sz;\n }\n\n int sameAdj = 0;\n int diffAdj = 0;\n int pref = 0;\n\n for (int r = 0; r < 10; r++) {\n for (int c = 0; c < 10; c++) {\n int id = r * 10 + c;\n int fl = b[id];\n if (fl == 0) continue;\n\n pref += 18 - distCell[fl][id];\n if (targetCell[id] == fl) pref += 12;\n\n if (r + 1 < 10) {\n int fl2 = b[(r + 1) * 10 + c];\n if (fl2) {\n if (fl2 == fl) sameAdj++;\n else diffAdj++;\n }\n }\n if (c + 1 < 10) {\n int fl2 = b[r * 10 + c + 1];\n if (fl2) {\n if (fl2 == fl) sameAdj++;\n else diffAdj++;\n }\n }\n }\n }\n\n return comp * 100 + sameAdj * 200 - diffAdj * 50 + pref * 30;\n}\n\nvoid buildTarget() {\n for (int fl = 1; fl <= 3; fl++) {\n for (int id = 0; id < 100; id++) {\n int r = id / 10;\n int c = id % 10;\n distCell[fl][id] = abs(r - anchorR[fl]) + abs(c - anchorC[fl]);\n }\n }\n\n fill(targetCell, targetCell + 100, 0);\n\n struct Item {\n int dist;\n int fl;\n int id;\n };\n\n vector items;\n items.reserve(300);\n\n for (int id = 0; id < 100; id++) {\n for (int fl = 1; fl <= 3; fl++) {\n items.push_back({distCell[fl][id], fl, id});\n }\n }\n\n sort(items.begin(), items.end(), [](const Item& a, const Item& b) {\n if (a.dist != b.dist) return a.dist < b.dist;\n if (a.fl != b.fl) return a.fl < b.fl;\n return a.id < b.id;\n });\n\n int rem[4];\n for (int fl = 1; fl <= 3; fl++) rem[fl] = cntFlavor[fl];\n\n for (auto& it : items) {\n if (targetCell[it.id] == 0 && rem[it.fl] > 0) {\n targetCell[it.id] = it.fl;\n rem[it.fl]--;\n }\n }\n}\n\nint choosePolicyDir(const Board& b) {\n int bestDir = 0;\n long long bestVal = LLONG_MIN;\n\n for (int d = 0; d < 4; d++) {\n Board nb = tiltBoard(b, d);\n long long val = evalBoard(nb);\n if (val > bestVal) {\n bestVal = val;\n bestDir = d;\n }\n }\n\n return bestDir;\n}\n\nlong long simulatePolicyGame(uint32_t seed) {\n XorShift rng(seed);\n Board b{};\n b.fill(0);\n\n for (int t = 1; t <= 100; t++) {\n int p = rng.randint(101 - t) + 1;\n placeCandy(b, p, F[t]);\n\n if (t < 100) {\n int d = choosePolicyDir(b);\n b = tiltBoard(b, d);\n }\n }\n\n return componentRawScore(b);\n}\n\nlong long simulateRollout(Board b, int nextT, uint32_t seed) {\n XorShift rng(seed);\n\n for (int t = nextT; t <= 100; t++) {\n int p = rng.randint(101 - t) + 1;\n placeCandy(b, p, F[t]);\n\n if (t < 100) {\n int d = choosePolicyDir(b);\n b = tiltBoard(b, d);\n }\n }\n\n return componentRawScore(b);\n}\n\nvoid selectCornerAssignment() {\n double bestScore = -1.0;\n int bestCorner[4] = {0, 0, 1, 2};\n\n vector seeds;\n for (int i = 0; i < 5; i++) {\n seeds.push_back(1234567u + i * 1000003u);\n }\n\n for (int mask = 0; mask < (1 << 4); mask++) {\n if (__builtin_popcount((unsigned)mask) != 3) continue;\n\n vector cs;\n for (int i = 0; i < 4; i++) {\n if (mask >> i & 1) cs.push_back(i);\n }\n\n sort(cs.begin(), cs.end());\n do {\n for (int fl = 1; fl <= 3; fl++) {\n int cid = cs[fl - 1];\n anchorR[fl] = cornerR[cid];\n anchorC[fl] = cornerC[cid];\n }\n\n buildTarget();\n\n long long sum = 0;\n for (uint32_t seed : seeds) {\n sum += simulatePolicyGame(seed);\n }\n\n double avg = (double)sum / seeds.size();\n\n if (avg > bestScore) {\n bestScore = avg;\n for (int fl = 1; fl <= 3; fl++) {\n bestCorner[fl] = cs[fl - 1];\n }\n }\n\n } while (next_permutation(cs.begin(), cs.end()));\n }\n\n for (int fl = 1; fl <= 3; fl++) {\n int cid = bestCorner[fl];\n anchorR[fl] = cornerR[cid];\n anchorC[fl] = cornerC[cid];\n }\n\n buildTarget();\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto startTime = chrono::steady_clock::now();\n\n for (int i = 1; i <= 100; i++) {\n cin >> F[i];\n cntFlavor[F[i]]++;\n }\n\n selectCornerAssignment();\n\n Board board{};\n board.fill(0);\n\n XorShift rolloutRng(987654321u);\n\n for (int t = 1; t <= 100; t++) {\n int p;\n if (!(cin >> p)) return 0;\n\n placeCandy(board, p, F[t]);\n\n Board cand[4];\n long long baseEval[4];\n\n for (int d = 0; d < 4; d++) {\n cand[d] = tiltBoard(board, d);\n baseEval[d] = evalBoard(cand[d]);\n }\n\n int rem = 100 - t;\n int maxSamples = 0;\n\n if (rem > 0) {\n if (rem > 75) maxSamples = 4;\n else if (rem > 50) maxSamples = 7;\n else if (rem > 25) maxSamples = 12;\n else maxSamples = 25;\n }\n\n long long total[4] = {};\n int samples = 0;\n\n const double TIME_LIMIT = 1.85;\n\n for (; samples < maxSamples; samples++) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - startTime).count();\n if (elapsed > TIME_LIMIT) break;\n\n uint32_t seed = rolloutRng.next();\n\n for (int d = 0; d < 4; d++) {\n total[d] += simulateRollout(cand[d], t + 1, seed);\n }\n }\n\n int bestDir = 0;\n\n if (samples > 0) {\n long long bestTotal = LLONG_MIN;\n for (int d = 0; d < 4; d++) {\n if (total[d] > bestTotal ||\n (total[d] == bestTotal && baseEval[d] > baseEval[bestDir])) {\n bestTotal = total[d];\n bestDir = d;\n }\n }\n } else {\n long long bestVal = LLONG_MIN;\n for (int d = 0; d < 4; d++) {\n if (baseEval[d] > bestVal) {\n bestVal = baseEval[d];\n bestDir = d;\n }\n }\n }\n\n board = cand[bestDir];\n\n cout << dirChar[bestDir] << endl;\n }\n\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nusing ull = unsigned long long;\nusing Row = array;\n\nstruct FastRNG {\n uint64_t x;\n FastRNG(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int n) {\n return (int)(next() % n);\n }\n double nextDouble() {\n return (next() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline bool getBitRow(const vector& rows, int i, int j) {\n return (rows[i][j >> 6] >> (j & 63)) & 1ULL;\n}\nstatic inline void setBitRow(vector& rows, int i, int j) {\n rows[i][j >> 6] |= 1ULL << (j & 63);\n rows[j][i >> 6] |= 1ULL << (i & 63);\n}\nstatic inline void setBitVec(vector& v, int idx) {\n v[idx >> 6] |= 1ULL << (idx & 63);\n}\nstatic inline int popcountXor(const vector& a, const vector& b) {\n int s = 0;\n for (size_t i = 0; i < a.size(); i++) s += __builtin_popcountll(a[i] ^ b[i]);\n return s;\n}\n\nstruct Canon {\n vector bits;\n vector degOrd;\n vector rows;\n string str;\n};\n\nCanon canonicalizeRows(const vector& rows, int N, bool needStr = true) {\n int L = N * (N - 1) / 2;\n int W = (L + 63) >> 6;\n\n vector deg(N, 0);\n for (int i = 0; i < N; i++) {\n deg[i] = __builtin_popcountll(rows[i][0]) + __builtin_popcountll(rows[i][1]);\n }\n\n vector nds(N, 0);\n for (int i = 0; i < N; i++) {\n long long s = 0;\n for (int j = 0; j < N; j++) {\n if (i != j && getBitRow(rows, i, j)) s += deg[j];\n }\n nds[i] = s;\n }\n\n vector ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n if (deg[a] != deg[b]) return deg[a] < deg[b];\n if (nds[a] != nds[b]) return nds[a] < nds[b];\n return a < b;\n });\n\n Canon c;\n c.bits.assign(W, 0);\n c.degOrd.resize(N);\n c.rows.assign(N, Row{0ULL, 0ULL});\n if (needStr) c.str.reserve(L);\n\n int idx = 0;\n for (int a = 0; a < N; a++) {\n c.degOrd[a] = deg[ord[a]];\n for (int b = a + 1; b < N; b++, idx++) {\n bool e = getBitRow(rows, ord[a], ord[b]);\n if (e) {\n setBitVec(c.bits, idx);\n setBitRow(c.rows, a, b);\n if (needStr) c.str.push_back('1');\n } else {\n if (needStr) c.str.push_back('0');\n }\n }\n }\n return c;\n}\n\nstruct GraphCode {\n vector bits;\n vector degOrd;\n vector rows;\n string out;\n};\n\nstruct Codebook {\n int mode = 0; // 0: threshold/canonical, 1: edge count\n int N = 4;\n int M = 0;\n double eps = 0.0;\n double alpha = 0.0;\n\n vector code;\n vector edgeGraphs;\n vector edgeCnt;\n};\n\nGraphCode makeThresholdCandidate(int N, uint64_t mask, bool fromMask, FastRNG& rng) {\n vector rows(N, Row{0ULL, 0ULL});\n vector bit(N, 0);\n\n if (fromMask) {\n for (int j = 1; j < N; j++) bit[j] = (mask >> (j - 1)) & 1ULL;\n } else {\n for (int j = 1; j < N; j++) bit[j] = rng.nextInt(2);\n }\n\n for (int j = 1; j < N; j++) {\n if (bit[j]) {\n for (int i = 0; i < j; i++) setBitRow(rows, i, j);\n }\n }\n\n Canon c = canonicalizeRows(rows, N, true);\n\n GraphCode g;\n g.bits = std::move(c.bits);\n g.degOrd = std::move(c.degOrd);\n g.rows = std::move(c.rows);\n g.out = std::move(c.str);\n return g;\n}\n\nint candidateDistance(const GraphCode& a, const GraphCode& b) {\n int ham = popcountXor(a.bits, b.bits);\n int l1 = 0;\n for (size_t i = 0; i < a.degOrd.size(); i++) {\n l1 += abs(a.degOrd[i] - b.degOrd[i]);\n }\n return ham + l1;\n}\n\nCodebook generateThresholdBook(int M, double eps, int N, FastRNG& rng) {\n int L = N * (N - 1) / 2;\n\n vector pool;\n int targetK = max(220, 4 * M);\n targetK = min(targetK, 500);\n\n unordered_set seen;\n seen.reserve(targetK * 2 + 10);\n\n if (N - 1 <= 12) {\n uint64_t total = 1ULL << (N - 1);\n for (uint64_t mask = 0; mask < total; mask++) {\n auto g = makeThresholdCandidate(N, mask, true, rng);\n if (seen.insert(g.out).second) pool.push_back(std::move(g));\n }\n } else {\n int attempts = 0;\n while ((int)pool.size() < targetK && attempts < targetK * 40) {\n attempts++;\n auto g = makeThresholdCandidate(N, 0, false, rng);\n if (seen.insert(g.out).second) pool.push_back(std::move(g));\n }\n }\n\n Codebook book;\n book.mode = 0;\n book.N = N;\n book.M = M;\n book.eps = eps;\n\n double V = max(1e-9, (N - 1) * eps * (1.0 - eps));\n double logodds = log((1.0 - eps) / eps);\n book.alpha = min(0.08, 1.0 / max(1e-9, 2.0 * V * logodds));\n\n if ((int)pool.size() < M) return book;\n\n int K = (int)pool.size();\n vector used(K, 0);\n vector minD(K, INT_MAX);\n\n int first = rng.nextInt(K);\n for (int it = 0; it < M; it++) {\n int best = -1;\n if (it == 0) {\n best = first;\n } else {\n int bestVal = -1;\n for (int i = 0; i < K; i++) {\n if (!used[i] && minD[i] > bestVal) {\n bestVal = minD[i];\n best = i;\n }\n }\n }\n\n used[best] = 1;\n book.code.push_back(std::move(pool[best]));\n\n for (int i = 0; i < K; i++) {\n if (!used[i]) {\n int d = candidateDistance(book.code.back(), pool[i]);\n if (d < minD[i]) minD[i] = d;\n }\n }\n }\n\n return book;\n}\n\nCodebook generateEdgeBook(int M, double eps, int N) {\n int L = N * (N - 1) / 2;\n\n Codebook book;\n book.mode = 1;\n book.N = N;\n book.M = M;\n book.eps = eps;\n book.edgeGraphs.resize(M);\n book.edgeCnt.resize(M);\n\n for (int k = 0; k < M; k++) {\n int e = (M == 1 ? 0 : (int)llround((long double)k * L / (M - 1)));\n e = min(e, L);\n book.edgeCnt[k] = e;\n string s(L, '0');\n for (int i = 0; i < e; i++) s[i] = '1';\n book.edgeGraphs[k] = std::move(s);\n }\n return book;\n}\n\nint decodeRowsThreshold(const Codebook& book, const vector& rows) {\n int N = book.N;\n Canon h = canonicalizeRows(rows, N, false);\n\n int best = 0;\n double bestScore = 1e100;\n\n for (int k = 0; k < book.M; k++) {\n const auto& g = book.code[k];\n int ham = popcountXor(h.bits, g.bits);\n\n double sse = 0.0;\n for (int i = 0; i < N; i++) {\n double expected = book.eps * (N - 1) + (1.0 - 2.0 * book.eps) * g.degOrd[i];\n double d = h.degOrd[i] - expected;\n sse += d * d;\n }\n\n double score = ham + book.alpha * sse;\n if (score < bestScore) {\n bestScore = score;\n best = k;\n }\n }\n\n return best;\n}\n\nvector parseGraphRows(const string& s, int N) {\n vector rows(N, Row{0ULL, 0ULL});\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++, idx++) {\n if (s[idx] == '1') setBitRow(rows, i, j);\n }\n }\n return rows;\n}\n\nint decodeString(const Codebook& book, const string& s) {\n if (book.mode == 1) {\n int m = 0;\n for (char c : s) if (c == '1') m++;\n\n int L = book.N * (book.N - 1) / 2;\n int best = 0;\n double bestDiff = 1e100;\n for (int k = 0; k < book.M; k++) {\n double expCnt = book.eps * L + (1.0 - 2.0 * book.eps) * book.edgeCnt[k];\n double diff = abs(m - expCnt);\n if (diff < bestDiff) {\n bestDiff = diff;\n best = k;\n }\n }\n return best;\n } else {\n auto rows = parseGraphRows(s, book.N);\n return decodeRowsThreshold(book, rows);\n }\n}\n\nvector noisyPermutedRows(const GraphCode& g, int N, double eps, FastRNG& rng) {\n vector perm(N);\n iota(perm.begin(), perm.end(), 0);\n for (int i = N - 1; i >= 1; i--) {\n int j = rng.nextInt(i + 1);\n swap(perm[i], perm[j]);\n }\n\n vector h(N, Row{0ULL, 0ULL});\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n bool e = getBitRow(g.rows, i, j);\n if (rng.nextDouble() < eps) e = !e;\n if (e) setBitRow(h, perm[i], perm[j]);\n }\n }\n return h;\n}\n\nint simulateThresholdErrors(const Codebook& book, int T, FastRNG& rng) {\n int err = 0;\n for (int t = 0; t < T; t++) {\n int s = rng.nextInt(book.M);\n auto h = noisyPermutedRows(book.code[s], book.N, book.eps, rng);\n int pred = decodeRowsThreshold(book, h);\n if (pred != s) err++;\n }\n return err;\n}\n\nint simulateEdgeErrors(const Codebook& book, int T, FastRNG& rng) {\n int L = book.N * (book.N - 1) / 2;\n int err = 0;\n\n for (int t = 0; t < T; t++) {\n int s = rng.nextInt(book.M);\n int e = book.edgeCnt[s];\n int cnt = 0;\n\n for (int i = 0; i < e; i++) {\n bool bit = true;\n if (rng.nextDouble() < book.eps) bit = !bit;\n if (bit) cnt++;\n }\n for (int i = e; i < L; i++) {\n bool bit = false;\n if (rng.nextDouble() < book.eps) bit = !bit;\n if (bit) cnt++;\n }\n\n int best = 0;\n double bestDiff = 1e100;\n for (int k = 0; k < book.M; k++) {\n double expCnt = book.eps * L + (1.0 - 2.0 * book.eps) * book.edgeCnt[k];\n double diff = abs(cnt - expCnt);\n if (diff < bestDiff) {\n bestDiff = diff;\n best = k;\n }\n }\n if (best != s) err++;\n }\n return err;\n}\n\nint ceilLog2Int(int x) {\n int p = 1, r = 0;\n while (p < x) p <<= 1, r++;\n return r;\n}\n\nint minNForEdges(int M) {\n for (int n = 4; n <= 100; n++) {\n if (n * (n - 1) / 2 >= M - 1) return n;\n }\n return 100;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int M;\n double eps;\n cin >> M >> eps;\n\n FastRNG rng(123456789ULL + M * 1009ULL + (int)llround(eps * 100) * 9176ULL);\n\n Codebook bestBook;\n double bestValue = -1.0;\n\n if (eps < 1e-12) {\n int N = minNForEdges(M);\n bestBook = generateEdgeBook(M, eps, N);\n } else {\n int minTh = max(4, ceilLog2Int(M) + 1);\n int low = max(minTh, (int)floor(4 + 0.15 * M + 20.0 * eps));\n low = min(low, 100);\n\n vector Ns;\n for (int n = low; n <= 100; n += 5) Ns.push_back(n);\n if (Ns.empty() || Ns.back() != 100) Ns.push_back(100);\n\n for (int N : Ns) {\n Codebook book = generateThresholdBook(M, eps, N, rng);\n if ((int)book.code.size() != M) continue;\n\n int T = (M >= 80 ? 70 : 90);\n int err = simulateThresholdErrors(book, T, rng);\n\n double p = (err + 1.0) / (T + 2.0);\n double value = exp(100.0 * log(max(1e-12, 1.0 - 0.1 * p))) / N;\n\n if (value > bestValue) {\n bestValue = value;\n bestBook = std::move(book);\n }\n }\n\n if (eps <= 0.12) {\n int minE = minNForEdges(M);\n for (int N = minE; N <= 100; N += 5) {\n Codebook book = generateEdgeBook(M, eps, N);\n int T = 180;\n int err = simulateEdgeErrors(book, T, rng);\n\n double p = (err + 1.0) / (T + 2.0);\n double value = exp(100.0 * log(max(1e-12, 1.0 - 0.1 * p))) / N;\n\n if (value > bestValue) {\n bestValue = value;\n bestBook = std::move(book);\n }\n }\n }\n\n if (bestValue < 0) {\n bestBook = generateThresholdBook(M, eps, 100, rng);\n }\n }\n\n cout << bestBook.N << '\\n';\n if (bestBook.mode == 1) {\n for (int k = 0; k < M; k++) cout << bestBook.edgeGraphs[k] << '\\n';\n } else {\n for (int k = 0; k < M; k++) cout << bestBook.code[k].out << '\\n';\n }\n cout.flush();\n\n for (int q = 0; q < 100; q++) {\n string H;\n cin >> H;\n int ans = decodeString(bestBook, H);\n cout << ans << '\\n';\n cout.flush();\n }\n\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nusing ll = long long;\nconst ll INF = (1LL << 60);\n\nstruct Timer {\n chrono::steady_clock::time_point st;\n Timer() { st = chrono::steady_clock::now(); }\n double elapsed() const {\n return chrono::duration(chrono::steady_clock::now() - st).count();\n }\n};\n\nstruct DSU {\n vector p, sz;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n sz.assign(n, 1);\n iota(p.begin(), p.end(), 0);\n }\n int root(int x) {\n while (p[x] != x) {\n p[x] = p[p[x]];\n x = p[x];\n }\n return x;\n }\n bool unite(int a, int b) {\n a = root(a);\n b = root(b);\n if (a == b) return false;\n if (sz[a] < sz[b]) swap(a, b);\n p[b] = a;\n sz[a] += sz[b];\n return true;\n }\n};\n\nstruct Edge {\n int u, v;\n int w;\n int mx, my;\n ll len2;\n};\n\nstruct Adj {\n int to, w, id;\n};\n\nint N, M, D, K;\nvector edges;\nvector> g;\nvector X, Y;\nvector degv;\nmt19937 rng(1234567);\n\nuint64_t morton_key(int x, int y) {\n uint64_t r = 0;\n for (int i = 0; i < 12; i++) {\n r |= uint64_t((x >> i) & 1) << (2 * i);\n r |= uint64_t((y >> i) & 1) << (2 * i + 1);\n }\n return r;\n}\n\nvoid dijkstra_fill(int s, const vector* assign, int ban_day, vector& dist) {\n fill(dist.begin(), dist.end(), INF);\n priority_queue, vector>, greater>> pq;\n dist[s] = 0;\n pq.push({0, s});\n while (!pq.empty()) {\n auto [du, u] = pq.top();\n pq.pop();\n if (du != dist[u]) continue;\n for (const auto& e : g[u]) {\n if (assign && (*assign)[e.id] == ban_day) continue;\n ll nd = du + e.w;\n if (nd < dist[e.to]) {\n dist[e.to] = nd;\n pq.push({nd, e.to});\n }\n }\n }\n}\n\nbool connected_day(const vector& assign, int day) {\n if (M - count(assign.begin(), assign.end(), day) < N - 1) return false;\n DSU uf(N);\n for (int i = 0; i < M; i++) {\n if (assign[i] != day) uf.unite(edges[i].u, edges[i].v);\n }\n int r = uf.root(0);\n for (int i = 1; i < N; i++) {\n if (uf.root(i) != r) return false;\n }\n return true;\n}\n\nbool all_connected(const vector& assign) {\n for (int d = 0; d < D; d++) {\n if (!connected_day(assign, d)) return false;\n }\n return true;\n}\n\nbool can_add_removal_keep_connected(const vector& assign, int day, int eid) {\n DSU uf(N);\n int rem = 0;\n for (int i = 0; i < M; i++) {\n if (assign[i] == day || i == eid) {\n rem++;\n } else {\n uf.unite(edges[i].u, edges[i].v);\n }\n }\n if (M - rem < N - 1) return false;\n int r = uf.root(0);\n for (int i = 1; i < N; i++) {\n if (uf.root(i) != r) return false;\n }\n return true;\n}\n\nvoid repair_isolated(vector& assign) {\n vector load(D, 0);\n vector> vc(N, vector(D, 0));\n for (int i = 0; i < M; i++) {\n int d = assign[i];\n load[d]++;\n vc[edges[i].u][d]++;\n vc[edges[i].v][d]++;\n }\n\n bool changed = true;\n int loop = 0;\n while (changed && loop++ < 20) {\n changed = false;\n for (int v = 0; v < N; v++) {\n for (int d = 0; d < D; d++) {\n if (vc[v][d] < degv[v]) continue;\n\n int eid = -1;\n for (auto& a : g[v]) {\n if (assign[a.id] == d) {\n eid = a.id;\n break;\n }\n }\n if (eid == -1) continue;\n\n int u = edges[eid].u;\n int w = edges[eid].v;\n int best = -1;\n for (int nd = 0; nd < D; nd++) {\n if (nd == d) continue;\n if (load[nd] >= K) continue;\n if (vc[u][nd] + 1 >= degv[u]) continue;\n if (vc[w][nd] + 1 >= degv[w]) continue;\n best = nd;\n break;\n }\n if (best == -1) {\n for (int nd = 0; nd < D; nd++) {\n if (nd != d && load[nd] < K) {\n best = nd;\n break;\n }\n }\n }\n if (best != -1) {\n assign[eid] = best;\n load[d]--;\n load[best]++;\n vc[u][d]--;\n vc[w][d]--;\n vc[u][best]++;\n vc[w][best]++;\n changed = true;\n }\n }\n }\n }\n}\n\nvoid repair_connectivity(vector& assign, const Timer& timer, double limit_time) {\n vector load(D, 0);\n for (int x : assign) load[x]++;\n\n for (int iter = 0; iter < 200 && timer.elapsed() < limit_time; iter++) {\n bool changed = false;\n\n for (int day = 0; day < D && timer.elapsed() < limit_time; day++) {\n DSU uf(N);\n int rem = 0;\n for (int i = 0; i < M; i++) {\n if (assign[i] == day) rem++;\n else uf.unite(edges[i].u, edges[i].v);\n }\n int r0 = uf.root(0);\n bool ok = true;\n for (int i = 1; i < N; i++) {\n if (uf.root(i) != r0) {\n ok = false;\n break;\n }\n }\n if (ok) continue;\n\n vector cand;\n cand.reserve(rem);\n for (int i = 0; i < M; i++) {\n if (assign[i] == day && uf.root(edges[i].u) != uf.root(edges[i].v)) {\n cand.push_back(i);\n }\n }\n shuffle(cand.begin(), cand.end(), rng);\n\n bool moved = false;\n for (int eid : cand) {\n int best_day = -1;\n int best_cost = INT_MAX;\n\n for (int nd = 0; nd < D; nd++) {\n if (nd == day) continue;\n if (load[nd] >= K) continue;\n\n int cost = load[nd];\n if (!can_add_removal_keep_connected(assign, nd, eid)) {\n cost += 1000000;\n }\n if (cost < best_cost) {\n best_cost = cost;\n best_day = nd;\n }\n }\n\n if (best_day != -1) {\n assign[eid] = best_day;\n load[day]--;\n load[best_day]++;\n changed = true;\n moved = true;\n break;\n }\n }\n\n if (moved) break;\n }\n\n if (!changed) break;\n if (all_connected(assign)) break;\n }\n}\n\nvector make_order(int type) {\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n\n if (type == 0) {\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return morton_key(edges[a].mx, edges[a].my) < morton_key(edges[b].mx, edges[b].my);\n });\n } else if (type == 1) {\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return morton_key(edges[a].mx, edges[a].my) > morton_key(edges[b].mx, edges[b].my);\n });\n } else if (type == 2) {\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n if (edges[a].mx != edges[b].mx) return edges[a].mx < edges[b].mx;\n return edges[a].my < edges[b].my;\n });\n } else if (type == 3) {\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n if (edges[a].my != edges[b].my) return edges[a].my < edges[b].my;\n return edges[a].mx < edges[b].mx;\n });\n } else if (type == 4) {\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return edges[a].mx + edges[a].my < edges[b].mx + edges[b].my;\n });\n } else if (type == 5) {\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return edges[a].mx - edges[a].my < edges[b].mx - edges[b].my;\n });\n } else if (type == 6) {\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return edges[a].len2 > edges[b].len2;\n });\n } else {\n int A = uniform_int_distribution(-1000, 1000)(rng);\n int B = uniform_int_distribution(-1000, 1000)(rng);\n if (A == 0 && B == 0) A = 1;\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n ll va = 1LL * A * edges[a].mx + 1LL * B * edges[a].my;\n ll vb = 1LL * A * edges[b].mx + 1LL * B * edges[b].my;\n if (va != vb) return va < vb;\n return a < b;\n });\n }\n return ord;\n}\n\nvector construct_cyclic(int type) {\n vector ord = make_order(type);\n vector perm(D);\n iota(perm.begin(), perm.end(), 0);\n shuffle(perm.begin(), perm.end(), rng);\n\n int shift = uniform_int_distribution(0, D - 1)(rng);\n vector assign(M);\n for (int i = 0; i < M; i++) {\n assign[ord[i]] = perm[(i + shift) % D];\n }\n repair_isolated(assign);\n return assign;\n}\n\nvector construct_greedy(int type) {\n vector ord;\n if (type == 100) {\n ord.resize(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng);\n } else {\n ord = make_order(type);\n }\n\n vector target(D, M / D);\n for (int i = 0; i < M % D; i++) target[i]++;\n shuffle(target.begin(), target.end(), rng);\n\n vector assign(M, -1);\n vector load(D, 0);\n vector> vc(N, vector(D, 0));\n\n const int G = 18;\n vector> cell(D, vector(G * G, 0));\n\n auto cid = [&](int eid) {\n int cx = min(G - 1, max(0, edges[eid].mx * G / 2001));\n int cy = min(G - 1, max(0, edges[eid].my * G / 2001));\n return pair(cx, cy);\n };\n\n for (int eid : ord) {\n int u = edges[eid].u;\n int v = edges[eid].v;\n auto [cx, cy] = cid(eid);\n\n int best = -1;\n int best_cost = INT_MAX;\n\n for (int pass = 0; pass < 2; pass++) {\n best = -1;\n best_cost = INT_MAX;\n\n for (int d = 0; d < D; d++) {\n if (load[d] >= target[d]) continue;\n\n if (pass == 0) {\n if (vc[u][d] + 1 >= degv[u]) continue;\n if (vc[v][d] + 1 >= degv[v]) continue;\n }\n\n int near = 0;\n for (int dx = -1; dx <= 1; dx++) {\n for (int dy = -1; dy <= 1; dy++) {\n int nx = cx + dx;\n int ny = cy + dy;\n if (0 <= nx && nx < G && 0 <= ny && ny < G) {\n near += cell[d][nx * G + ny];\n }\n }\n }\n\n int cost = 0;\n cost += (vc[u][d] + vc[v][d]) * 100000;\n cost += near * 700;\n cost += load[d] * 5;\n cost += uniform_int_distribution(0, 999)(rng);\n\n if (cost < best_cost) {\n best_cost = cost;\n best = d;\n }\n }\n\n if (best != -1) break;\n }\n\n if (best == -1) {\n for (int d = 0; d < D; d++) {\n if (load[d] < target[d]) {\n best = d;\n break;\n }\n }\n }\n\n assign[eid] = best;\n load[best]++;\n vc[u][best]++;\n vc[v][best]++;\n cell[best][cx * G + cy]++;\n }\n\n repair_isolated(assign);\n return assign;\n}\n\nll evaluate_schedule(\n const vector& assign,\n int S,\n const vector& sources,\n const vector>& base_dist\n) {\n vector load(D, 0);\n for (int x : assign) {\n if (x < 0 || x >= D) return (ll)4e18;\n load[x]++;\n }\n for (int d = 0; d < D; d++) {\n if (load[d] > K) return (ll)4e18;\n }\n\n // Connectivity is extremely important because unreachable pairs cost 1e9.\n if (!all_connected(assign)) {\n return (ll)3e18;\n }\n\n ll score = 0;\n vector dist(N);\n\n for (int day = 0; day < D; day++) {\n for (int si = 0; si < S; si++) {\n int s = sources[si];\n dijkstra_fill(s, &assign, day, dist);\n const auto& bd = base_dist[si];\n for (int v = 0; v < N; v++) {\n if (v == s) continue;\n if (dist[v] >= INF / 2) {\n score += 1000000000LL - bd[v];\n } else {\n score += dist[v] - bd[v];\n }\n }\n }\n }\n\n return score;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Timer timer;\n\n cin >> N >> M >> D >> K;\n edges.resize(M);\n g.assign(N, {});\n degv.assign(N, 0);\n\n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n --u;\n --v;\n edges[i].u = u;\n edges[i].v = v;\n edges[i].w = w;\n g[u].push_back({v, w, i});\n g[v].push_back({u, w, i});\n degv[u]++;\n degv[v]++;\n }\n\n X.resize(N);\n Y.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i];\n }\n\n for (int i = 0; i < M; i++) {\n int u = edges[i].u;\n int v = edges[i].v;\n edges[i].mx = X[u] + X[v];\n edges[i].my = Y[u] + Y[v];\n ll dx = X[u] - X[v];\n ll dy = Y[u] - Y[v];\n edges[i].len2 = dx * dx + dy * dy;\n }\n\n vector vertices(N);\n iota(vertices.begin(), vertices.end(), 0);\n shuffle(vertices.begin(), vertices.end(), rng);\n\n int Smax = min(N, 96);\n int Ssmall = min(Smax, (D >= 20 ? 24 : 32));\n int Sfinal = min(Smax, 80);\n\n vector sources(vertices.begin(), vertices.begin() + Smax);\n\n vector> base_dist(Smax, vector(N));\n for (int i = 0; i < Smax; i++) {\n dijkstra_fill(sources[i], nullptr, -1, base_dist[i]);\n }\n\n vector>> top;\n\n auto add_candidate = [&](vector assign) {\n if (!all_connected(assign) && timer.elapsed() < 4.8) {\n repair_connectivity(assign, timer, 4.9);\n }\n\n ll sc = evaluate_schedule(assign, Ssmall, sources, base_dist);\n\n if ((int)top.size() < 8) {\n top.push_back({sc, assign});\n sort(top.begin(), top.end(), [](auto& a, auto& b) {\n return a.first < b.first;\n });\n } else if (sc < top.back().first) {\n top.back() = {sc, assign};\n sort(top.begin(), top.end(), [](auto& a, auto& b) {\n return a.first < b.first;\n });\n }\n };\n\n // Deterministic initial candidates.\n for (int t = 0; t < 10 && timer.elapsed() < 4.5; t++) {\n add_candidate(construct_cyclic(t % 8));\n }\n for (int t = 0; t < 10 && timer.elapsed() < 4.5; t++) {\n add_candidate(construct_greedy(t % 8));\n }\n\n int iter = 0;\n while (timer.elapsed() < 4.9) {\n vector cand;\n if (iter % 3 == 0) {\n cand = construct_greedy(100);\n } else if (iter % 3 == 1) {\n cand = construct_greedy(8 + iter);\n } else {\n cand = construct_cyclic(8 + iter);\n }\n add_candidate(std::move(cand));\n iter++;\n }\n\n if (top.empty()) {\n vector fallback(M);\n for (int i = 0; i < M; i++) fallback[i] = i % D;\n repair_isolated(fallback);\n top.push_back({0, fallback});\n }\n\n vector best = top[0].second;\n ll best_score = top[0].first;\n\n // Re-evaluate promising candidates with more samples.\n for (auto& p : top) {\n if (timer.elapsed() > 5.55) break;\n ll sc = evaluate_schedule(p.second, Sfinal, sources, base_dist);\n if (sc < best_score || best_score >= (ll)3e18) {\n best_score = sc;\n best = p.second;\n }\n }\n\n // Final emergency repair if possible.\n if (!all_connected(best) && timer.elapsed() < 5.75) {\n repair_connectivity(best, timer, 5.85);\n }\n\n // Ensure capacity, though constructions should already satisfy it.\n vector load(D, 0);\n for (int x : best) load[x]++;\n for (int i = 0; i < M; i++) {\n if (load[best[i]] <= K) continue;\n for (int d = 0; d < D; d++) {\n if (load[d] < K) {\n load[best[i]]--;\n best[i] = d;\n load[d]++;\n break;\n }\n }\n }\n\n for (int i = 0; i < M; i++) {\n if (i) cout << ' ';\n cout << best[i] + 1;\n }\n cout << '\\n';\n\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstruct Rod {\n vector cells;\n};\n\nstruct Candidate {\n vector rods;\n vector lens;\n int volume = 0;\n};\n\nstruct Params {\n int extra;\n int contW;\n int futW;\n int randAmp;\n uint32_t seed;\n};\n\nint D;\nstring f_[2][14], r_[2][14];\n\ninline int idx3(int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\nvector> solve_min_edge_cover(\n const vector& X,\n const vector& Y,\n int w[14][14]\n) {\n int nx = (int)X.size();\n int ny = (int)Y.size();\n vector> res;\n\n if (nx >= ny) {\n int A = nx, B = ny;\n int M = 1 << B;\n const int NEG = -1e9;\n\n vector dp(M, NEG), ndp(M, NEG);\n vector> pre(A + 1, vector(M, -1));\n vector> choice(A + 1, vector(M, -1));\n\n dp[0] = 0;\n for (int t = 0; t < A; t++) {\n fill(ndp.begin(), ndp.end(), NEG);\n for (int mask = 0; mask < M; mask++) {\n if (dp[mask] <= NEG / 2) continue;\n for (int j = 0; j < B; j++) {\n int nm = mask | (1 << j);\n int val = dp[mask] + w[X[t]][Y[j]];\n if (val > ndp[nm]) {\n ndp[nm] = val;\n pre[t + 1][nm] = mask;\n choice[t + 1][nm] = j;\n }\n }\n }\n dp.swap(ndp);\n }\n\n int mask = M - 1;\n for (int t = A; t >= 1; t--) {\n int j = choice[t][mask];\n int old = pre[t][mask];\n res.push_back({X[t - 1], Y[j]});\n mask = old;\n }\n } else {\n int A = ny, B = nx;\n int M = 1 << B;\n const int NEG = -1e9;\n\n vector dp(M, NEG), ndp(M, NEG);\n vector> pre(A + 1, vector(M, -1));\n vector> choice(A + 1, vector(M, -1));\n\n dp[0] = 0;\n for (int t = 0; t < A; t++) {\n fill(ndp.begin(), ndp.end(), NEG);\n for (int mask = 0; mask < M; mask++) {\n if (dp[mask] <= NEG / 2) continue;\n for (int j = 0; j < B; j++) {\n int nm = mask | (1 << j);\n int val = dp[mask] + w[X[j]][Y[t]];\n if (val > ndp[nm]) {\n ndp[nm] = val;\n pre[t + 1][nm] = mask;\n choice[t + 1][nm] = j;\n }\n }\n }\n dp.swap(ndp);\n }\n\n int mask = M - 1;\n for (int t = A; t >= 1; t--) {\n int j = choice[t][mask];\n int old = pre[t][mask];\n res.push_back({X[j], Y[t - 1]});\n mask = old;\n }\n }\n\n return res;\n}\n\nCandidate build_candidate(int id, const Params& param) {\n mt19937 rng(param.seed);\n\n vector occ(D * D * D, 0);\n bool prev[14][14] = {};\n\n for (int z = 0; z < D; z++) {\n vector X, Y;\n for (int x = 0; x < D; x++) {\n if (f_[id][z][x] == '1') X.push_back(x);\n }\n for (int y = 0; y < D; y++) {\n if (r_[id][z][y] == '1') Y.push_back(y);\n }\n\n int w[14][14] = {};\n for (int x : X) {\n for (int y : Y) {\n int val = 0;\n if (prev[x][y]) val += param.contW;\n if (z + 1 < D && f_[id][z + 1][x] == '1' && r_[id][z + 1][y] == '1') {\n val += param.futW;\n }\n if (param.randAmp > 0) val += (int)(rng() % param.randAmp);\n w[x][y] = val;\n }\n }\n\n auto base = solve_min_edge_cover(X, Y, w);\n\n bool sel[14][14] = {};\n int cnt = 0;\n for (auto [x, y] : base) {\n if (!sel[x][y]) {\n sel[x][y] = true;\n cnt++;\n }\n }\n\n int maxEdges = (int)X.size() * (int)Y.size();\n int target = min(maxEdges, max((int)X.size(), (int)Y.size()) + param.extra);\n\n vector> add;\n for (int x : X) {\n for (int y : Y) {\n if (sel[x][y]) continue;\n int sc = 0;\n if (prev[x][y]) sc += 100000;\n if (z + 1 < D && f_[id][z + 1][x] == '1' && r_[id][z + 1][y] == '1') {\n sc += 10000;\n }\n sc += (int)(rng() % 1000);\n add.push_back({sc, x, y});\n }\n }\n\n sort(add.rbegin(), add.rend());\n for (auto [sc, x, y] : add) {\n if (cnt >= target) break;\n sel[x][y] = true;\n cnt++;\n }\n\n memset(prev, 0, sizeof(prev));\n for (int x : X) {\n for (int y : Y) {\n if (sel[x][y]) {\n occ[idx3(x, y, z)] = 1;\n prev[x][y] = true;\n }\n }\n }\n }\n\n Candidate cand;\n\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n int z = 0;\n while (z < D) {\n if (!occ[idx3(x, y, z)]) {\n z++;\n continue;\n }\n\n Rod rod;\n while (z < D && occ[idx3(x, y, z)]) {\n rod.cells.push_back(idx3(x, y, z));\n z++;\n }\n\n cand.volume += (int)rod.cells.size();\n cand.lens.push_back((int)rod.cells.size());\n cand.rods.push_back(move(rod));\n }\n }\n }\n\n return cand;\n}\n\nlong double eval_score(const Candidate& a, const Candidate& b) {\n priority_queue p, q;\n for (int x : a.lens) p.push(x);\n for (int x : b.lens) q.push(x);\n\n long double score = 0;\n\n for (int len = D; len >= 1; len--) {\n while (!p.empty() && !q.empty() && p.top() >= len && q.top() >= len) {\n int x = p.top(); p.pop();\n int y = q.top(); q.pop();\n\n score += 1.0L / len;\n\n if (x - len > 0) p.push(x - len);\n if (y - len > 0) q.push(y - len);\n }\n }\n\n while (!p.empty()) {\n score += p.top();\n p.pop();\n }\n while (!q.empty()) {\n score += q.top();\n q.pop();\n }\n\n return score;\n}\n\nstruct Piece {\n int len;\n int rod;\n int off;\n\n bool operator<(const Piece& other) const {\n if (len != other.len) return len < other.len;\n if (rod != other.rod) return rod < other.rod;\n return off < other.off;\n }\n};\n\nvoid mark_piece(\n vector& arr,\n const Candidate& cand,\n const Piece& p,\n int useLen,\n int blockId\n) {\n const Rod& rod = cand.rods[p.rod];\n for (int i = 0; i < useLen; i++) {\n arr[rod.cells[p.off + i]] = blockId;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> D;\n for (int i = 0; i < 2; i++) {\n for (int z = 0; z < D; z++) cin >> f_[i][z];\n for (int z = 0; z < D; z++) cin >> r_[i][z];\n }\n\n vector params;\n vector extras = {0, 1, 2, 4, 7, 1000};\n\n uint32_t baseSeed = 123456789;\n for (int e : extras) {\n for (int rep = 0; rep < 2; rep++) {\n Params p;\n p.extra = e;\n p.contW = 1000;\n p.futW = 100;\n p.randAmp = 50;\n p.seed = baseSeed + e * 1009 + rep * 9176;\n params.push_back(p);\n }\n }\n\n vector cand[2];\n for (int id = 0; id < 2; id++) {\n for (auto p : params) {\n p.seed += id * 998244353u;\n cand[id].push_back(build_candidate(id, p));\n }\n }\n\n int bestA = 0, bestB = 0;\n long double bestScore = 1e100L;\n\n for (int i = 0; i < (int)cand[0].size(); i++) {\n for (int j = 0; j < (int)cand[1].size(); j++) {\n long double sc = eval_score(cand[0][i], cand[1][j]);\n if (sc < bestScore) {\n bestScore = sc;\n bestA = i;\n bestB = j;\n }\n }\n }\n\n const Candidate& A = cand[0][bestA];\n const Candidate& B = cand[1][bestB];\n\n vector out1(D * D * D, 0), out2(D * D * D, 0);\n\n priority_queue pq1, pq2;\n for (int i = 0; i < (int)A.rods.size(); i++) {\n pq1.push({(int)A.rods[i].cells.size(), i, 0});\n }\n for (int i = 0; i < (int)B.rods.size(); i++) {\n pq2.push({(int)B.rods[i].cells.size(), i, 0});\n }\n\n int blockId = 0;\n\n for (int len = D; len >= 1; len--) {\n while (!pq1.empty() && !pq2.empty() && pq1.top().len >= len && pq2.top().len >= len) {\n Piece a = pq1.top(); pq1.pop();\n Piece b = pq2.top(); pq2.pop();\n\n blockId++;\n mark_piece(out1, A, a, len, blockId);\n mark_piece(out2, B, b, len, blockId);\n\n if (a.len - len > 0) {\n pq1.push({a.len - len, a.rod, a.off + len});\n }\n if (b.len - len > 0) {\n pq2.push({b.len - len, b.rod, b.off + len});\n }\n }\n }\n\n while (!pq1.empty()) {\n Piece a = pq1.top(); pq1.pop();\n blockId++;\n mark_piece(out1, A, a, a.len, blockId);\n }\n\n while (!pq2.empty()) {\n Piece b = pq2.top(); pq2.pop();\n blockId++;\n mark_piece(out2, B, b, b.len, blockId);\n }\n\n cout << blockId << '\\n';\n\n for (int i = 0; i < D * D * D; i++) {\n if (i) cout << ' ';\n cout << out1[i];\n }\n cout << '\\n';\n\n for (int i = 0; i < D * D * D; i++) {\n if (i) cout << ' ';\n cout << out2[i];\n }\n cout << '\\n';\n\n return 0;\n}","ahc020":"#include \nusing namespace std;\n\nstruct DSU {\n vector p, sz;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n sz.assign(n, 1);\n iota(p.begin(), p.end(), 0);\n }\n int find(int x) {\n while (p[x] != x) x = p[x] = p[p[x]];\n return x;\n }\n bool unite(int a, int b) {\n a = find(a), b = find(b);\n if (a == b) return false;\n if (sz[a] < sz[b]) swap(a, b);\n p[b] = a;\n sz[a] += sz[b];\n return true;\n }\n};\n\nstruct Edge {\n int u, v;\n long long w;\n};\n\nstatic const long long INF = (1LL << 60);\n\nint N, M, K;\nvector X, Y;\nvector edges;\nvector A, Bp;\n\nvector> cdist; // ceil euclidean distance station-resident\nvector>> sortedRes;\n\nvector> fw;\nvector> nxtv;\nvector> directEdge;\n\nchrono::steady_clock::time_point st_time;\n\ndouble elapsed_sec() {\n return chrono::duration(chrono::steady_clock::now() - st_time).count();\n}\n\nint ceil_sqrt_ll(long long x) {\n long long r = sqrt((long double)x);\n while (r * r < x) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= x) --r;\n return (int)r;\n}\n\nvoid add_path_edges(int s, int t, vector& sel) {\n while (s != t) {\n int to = nxtv[s][t];\n if (to < 0) break;\n int eid = directEdge[s][to];\n if (eid < 0) break;\n sel[eid] = 1;\n s = to;\n }\n}\n\nlong long prune_and_cost(vector sel, const vector& P) {\n vector terminal(N, 0);\n terminal[0] = 1;\n for (int i = 0; i < N; i++) if (P[i] > 0) terminal[i] = 1;\n\n vector>> g(N);\n vector deg(N, 0);\n for (int e = 0; e < M; e++) if (sel[e]) {\n int u = edges[e].u, v = edges[e].v;\n g[u].push_back({v, e});\n g[v].push_back({u, e});\n deg[u]++;\n deg[v]++;\n }\n\n queue q;\n for (int i = 0; i < N; i++) {\n if (!terminal[i] && deg[i] <= 1) q.push(i);\n }\n\n while (!q.empty()) {\n int v = q.front();\n q.pop();\n if (terminal[v] || deg[v] != 1) continue;\n\n for (auto [to, eid] : g[v]) {\n if (!sel[eid]) continue;\n sel[eid] = 0;\n deg[v]--;\n deg[to]--;\n if (!terminal[to] && deg[to] == 1) q.push(to);\n break;\n }\n }\n\n long long cost = 0;\n for (int e = 0; e < M; e++) if (sel[e]) cost += edges[e].w;\n return cost;\n}\n\npair> build_best_tree(const vector& P) {\n long long bestCost = INF;\n vector bestB(M, 0);\n\n auto consider = [&](vector sel) {\n vector terminal(N, 0);\n terminal[0] = 1;\n for (int i = 0; i < N; i++) if (P[i] > 0) terminal[i] = 1;\n\n vector>> g(N);\n vector deg(N, 0);\n for (int e = 0; e < M; e++) if (sel[e]) {\n int u = edges[e].u, v = edges[e].v;\n g[u].push_back({v, e});\n g[v].push_back({u, e});\n deg[u]++;\n deg[v]++;\n }\n\n queue q;\n for (int i = 0; i < N; i++) {\n if (!terminal[i] && deg[i] <= 1) q.push(i);\n }\n\n while (!q.empty()) {\n int v = q.front();\n q.pop();\n if (terminal[v] || deg[v] != 1) continue;\n\n for (auto [to, eid] : g[v]) {\n if (!sel[eid]) continue;\n sel[eid] = 0;\n deg[v]--;\n deg[to]--;\n if (!terminal[to] && deg[to] == 1) q.push(to);\n break;\n }\n }\n\n long long cost = 0;\n vector B(M, 0);\n for (int e = 0; e < M; e++) {\n if (sel[e]) {\n cost += edges[e].w;\n B[e] = 1;\n }\n }\n if (cost < bestCost) {\n bestCost = cost;\n bestB = B;\n }\n };\n\n // 1. MST on metric closure of terminals\n {\n vector terms;\n terms.push_back(0);\n for (int i = 1; i < N; i++) if (P[i] > 0) terms.push_back(i);\n\n vector sel(M, 0);\n int T = (int)terms.size();\n\n if (T >= 2) {\n vector minD(T, INF);\n vector par(T, -1);\n vector used(T, 0);\n minD[0] = 0;\n\n for (int it = 0; it < T; it++) {\n int v = -1;\n for (int i = 0; i < T; i++) {\n if (!used[i] && (v == -1 || minD[i] < minD[v])) v = i;\n }\n if (v == -1) break;\n used[v] = 1;\n\n if (par[v] != -1) {\n add_path_edges(terms[v], terms[par[v]], sel);\n }\n\n for (int to = 0; to < T; to++) {\n if (!used[to] && fw[terms[v]][terms[to]] < minD[to]) {\n minD[to] = fw[terms[v]][terms[to]];\n par[to] = v;\n }\n }\n }\n }\n consider(sel);\n }\n\n // 2. Union of shortest paths from root\n {\n vector sel(M, 0);\n for (int i = 1; i < N; i++) {\n if (P[i] > 0) add_path_edges(0, i, sel);\n }\n consider(sel);\n }\n\n // 3. Ordinary graph MST, then prune\n {\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return edges[a].w < edges[b].w;\n });\n\n DSU dsu(N);\n vector sel(M, 0);\n for (int eid : ord) {\n if (dsu.unite(edges[eid].u, edges[eid].v)) {\n sel[eid] = 1;\n }\n }\n consider(sel);\n }\n\n return {bestCost, bestB};\n}\n\nlong long total_cost(const vector& P) {\n long long radio = 0;\n for (int p : P) radio += 1LL * p * p;\n auto tr = build_best_tree(P);\n return radio + tr.first;\n}\n\nbool compute_covered(const vector& P, vector& covered) {\n covered.assign(K, 0);\n int cnt = 0;\n for (int k = 0; k < K; k++) {\n for (int i = 0; i < N; i++) {\n if (P[i] > 0 && cdist[i][k] <= P[i]) {\n covered[k] = 1;\n cnt++;\n break;\n }\n }\n }\n return cnt == K;\n}\n\nvoid reduce_powers(vector& P) {\n vector coverCnt(K, 0);\n for (int i = 0; i < N; i++) if (P[i] > 0) {\n for (int k = 0; k < K; k++) {\n if (cdist[i][k] <= P[i]) coverCnt[k]++;\n }\n }\n\n bool changed = true;\n int loop = 0;\n while (changed && loop < 10) {\n loop++;\n changed = false;\n\n for (int i = 0; i < N; i++) {\n int old = P[i];\n if (old == 0) continue;\n\n int req = 0;\n for (int k = 0; k < K; k++) {\n if (cdist[i][k] <= old && coverCnt[k] == 1) {\n req = max(req, cdist[i][k]);\n }\n }\n\n if (req < old) {\n for (int k = 0; k < K; k++) {\n if (cdist[i][k] <= old && cdist[i][k] > req) {\n coverCnt[k]--;\n }\n }\n P[i] = req;\n changed = true;\n }\n }\n }\n}\n\nbool greedy_complete(vector& P, double alpha, int banned = -1) {\n vector covered(K, 0);\n int uncovered = 0;\n\n for (int k = 0; k < K; k++) {\n bool ok = false;\n for (int i = 0; i < N; i++) {\n if (P[i] > 0 && cdist[i][k] <= P[i]) {\n ok = true;\n break;\n }\n }\n covered[k] = ok;\n if (!ok) uncovered++;\n }\n\n vector connPen(N, 0.0);\n for (int i = 0; i < N; i++) connPen[i] = alpha * (double)fw[0][i];\n\n while (uncovered > 0) {\n int bestI = -1, bestR = -1, bestGain = 0;\n double bestScore = 1e100;\n\n for (int i = 0; i < N; i++) {\n if (i == banned) continue;\n\n int old = P[i];\n int gain = 0;\n const auto& vec = sortedRes[i];\n\n for (int idx = 0; idx < (int)vec.size();) {\n int r = vec[idx].first;\n if (r > 5000) break;\n\n int add = 0;\n while (idx < (int)vec.size() && vec[idx].first == r) {\n int k = vec[idx].second;\n if (r > old && !covered[k]) add++;\n idx++;\n }\n\n if (r <= old) continue;\n gain += add;\n if (gain > 0) {\n double delta = (double)r * r - (double)old * old;\n if (old == 0) delta += connPen[i];\n double score = delta / gain;\n\n if (score < bestScore ||\n (abs(score - bestScore) < 1e-9 && gain > bestGain)) {\n bestScore = score;\n bestI = i;\n bestR = r;\n bestGain = gain;\n }\n }\n }\n }\n\n if (bestI == -1) return false;\n\n P[bestI] = bestR;\n for (auto [r, k] : sortedRes[bestI]) {\n if (r > bestR) break;\n if (!covered[k]) {\n covered[k] = 1;\n uncovered--;\n }\n }\n }\n\n return true;\n}\n\nvector initial_nearest_solution() {\n vector P(N, 0);\n for (int k = 0; k < K; k++) {\n int bi = -1;\n int bd = 1e9;\n for (int i = 0; i < N; i++) {\n if (cdist[i][k] <= 5000 && cdist[i][k] < bd) {\n bd = cdist[i][k];\n bi = i;\n }\n }\n if (bi == -1) {\n for (int i = 0; i < N; i++) {\n if (cdist[i][k] < bd) {\n bd = cdist[i][k];\n bi = i;\n }\n }\n }\n P[bi] = max(P[bi], bd);\n }\n reduce_powers(P);\n return P;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n st_time = chrono::steady_clock::now();\n\n cin >> N >> M >> K;\n\n X.resize(N);\n Y.resize(N);\n for (int i = 0; i < N; i++) cin >> X[i] >> Y[i];\n\n edges.resize(M);\n for (int i = 0; i < M; i++) {\n int u, v;\n long long w;\n cin >> u >> v >> w;\n --u;\n --v;\n edges[i] = {u, v, w};\n }\n\n A.resize(K);\n Bp.resize(K);\n for (int k = 0; k < K; k++) cin >> A[k] >> Bp[k];\n\n // Floyd-Warshall and path reconstruction\n fw.assign(N, vector(N, INF));\n nxtv.assign(N, vector(N, -1));\n directEdge.assign(N, vector(N, -1));\n\n for (int i = 0; i < N; i++) {\n fw[i][i] = 0;\n nxtv[i][i] = i;\n }\n\n for (int e = 0; e < M; e++) {\n int u = edges[e].u, v = edges[e].v;\n long long w = edges[e].w;\n if (w < fw[u][v]) {\n fw[u][v] = fw[v][u] = w;\n nxtv[u][v] = v;\n nxtv[v][u] = u;\n directEdge[u][v] = directEdge[v][u] = e;\n }\n }\n\n for (int k = 0; k < N; k++) {\n for (int i = 0; i < N; i++) if (fw[i][k] < INF) {\n for (int j = 0; j < N; j++) if (fw[k][j] < INF) {\n long long nd = fw[i][k] + fw[k][j];\n if (nd < fw[i][j]) {\n fw[i][j] = nd;\n nxtv[i][j] = nxtv[i][k];\n }\n }\n }\n }\n\n // Station-resident distances\n cdist.assign(N, vector(K));\n sortedRes.assign(N, {});\n\n for (int i = 0; i < N; i++) {\n sortedRes[i].reserve(K);\n for (int k = 0; k < K; k++) {\n long long dx = X[i] - A[k];\n long long dy = Y[i] - Bp[k];\n int d = ceil_sqrt_ll(dx * dx + dy * dy);\n cdist[i][k] = d;\n if (d <= 5000) sortedRes[i].push_back({d, k});\n }\n sort(sortedRes[i].begin(), sortedRes[i].end());\n }\n\n vector bestP = initial_nearest_solution();\n long long bestS = total_cost(bestP);\n double bestAlpha = 0.2;\n\n vector alphas = {0.0, 0.03, 0.07, 0.12, 0.2, 0.35, 0.6, 1.0, 1.7};\n\n for (double alpha : alphas) {\n if (elapsed_sec() > 1.25) break;\n\n vector P(N, 0);\n bool ok = greedy_complete(P, alpha, -1);\n if (!ok) continue;\n\n reduce_powers(P);\n long long S = total_cost(P);\n\n if (S < bestS) {\n bestS = S;\n bestP = P;\n bestAlpha = alpha;\n }\n }\n\n // Local search: remove one active station and repair coverage\n double repairAlpha = max(0.12, min(0.6, bestAlpha));\n\n while (elapsed_sec() < 1.82) {\n bool improved = false;\n vector candBestP;\n long long candBestS = bestS;\n\n vector active;\n for (int i = 0; i < N; i++) if (bestP[i] > 0) active.push_back(i);\n\n sort(active.begin(), active.end(), [&](int a, int b) {\n return bestP[a] < bestP[b];\n });\n\n for (int rem : active) {\n if (elapsed_sec() > 1.86) break;\n\n vector P = bestP;\n P[rem] = 0;\n\n if (!greedy_complete(P, repairAlpha, rem)) continue;\n reduce_powers(P);\n\n long long S = total_cost(P);\n if (S < candBestS) {\n candBestS = S;\n candBestP = P;\n improved = true;\n }\n }\n\n if (improved) {\n bestS = candBestS;\n bestP = candBestP;\n } else {\n break;\n }\n }\n\n // Safety repair\n vector covered;\n if (!compute_covered(bestP, covered)) {\n greedy_complete(bestP, 0.0, -1);\n reduce_powers(bestP);\n }\n\n auto tree = build_best_tree(bestP);\n vector ansB = tree.second;\n\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << bestP[i];\n }\n cout << '\\n';\n\n for (int e = 0; e < M; e++) {\n if (e) cout << ' ';\n cout << ansB[e];\n }\n cout << '\\n';\n\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconstexpr int N = 30;\nconstexpr int M = N * (N + 1) / 2;\n\nstruct Op {\n int u, v;\n};\n\nint ID[N][N];\nint X[M], Y[M];\n\nvector> adjEdges; // all 6-neighbour undirected edges, once\nvector> downEdges; // directed condition edges: parent -> child\nvector> incidentDown; // down-edge indices incident to each vertex\n\narray initialA;\nint initialE;\n\nint calcE(const array& a) {\n int e = 0;\n for (auto [p, c] : downEdges) if (a[p] > a[c]) e++;\n return e;\n}\n\nstruct State {\n array a;\n vector ops;\n int E = 0;\n};\n\nint deltaSwapLocal(const array& a, int u, int v) {\n int ids[16], cnt = 0;\n auto add = [&](int e) {\n for (int i = 0; i < cnt; i++) if (ids[i] == e) return;\n ids[cnt++] = e;\n };\n for (int e : incidentDown[u]) add(e);\n for (int e : incidentDown[v]) add(e);\n\n int before = 0, after = 0;\n for (int k = 0; k < cnt; k++) {\n auto [p, c] = downEdges[ids[k]];\n before += (a[p] > a[c]);\n\n int vp = (p == u ? a[v] : (p == v ? a[u] : a[p]));\n int vc = (c == u ? a[v] : (c == v ? a[u] : a[c]));\n after += (vp > vc);\n }\n // positive means E decreases\n return before - after;\n}\n\nvoid applySwap(State& s, int u, int v) {\n int d = deltaSwapLocal(s.a, u, v);\n s.E -= d;\n swap(s.a[u], s.a[v]);\n s.ops.push_back({u, v});\n}\n\nvector yOrder(int x, int type) {\n vector ys;\n for (int y = 0; y <= x; y++) ys.push_back(y);\n\n if (type == 1) {\n reverse(ys.begin(), ys.end());\n } else if (type == 2) {\n if (x & 1) reverse(ys.begin(), ys.end());\n } else if (type == 3) {\n sort(ys.begin(), ys.end(), [&](int a, int b) {\n int da = abs(2 * a - x);\n int db = abs(2 * b - x);\n if (da != db) return da < db;\n return a < b;\n });\n }\n return ys;\n}\n\n// Floyd-like heap construction on the triangular heap.\nState runHeapify(State s, int yType) {\n for (int x = N - 2; x >= 0; x--) {\n auto ys = yOrder(x, yType);\n for (int sy : ys) {\n int cx = x, cy = sy;\n int cur = ID[cx][cy];\n\n while (cx + 1 < N) {\n int c1 = ID[cx + 1][cy];\n int c2 = ID[cx + 1][cy + 1];\n int ch = (s.a[c1] < s.a[c2] ? c1 : c2);\n\n if (s.a[cur] > s.a[ch]) {\n applySwap(s, cur, ch);\n cur = ch;\n cx = X[cur];\n cy = Y[cur];\n } else {\n break;\n }\n }\n }\n }\n return s;\n}\n\n// One-step repeated bubbling.\nState runScanBubble(State s, int rowType, int yType, int limitOps) {\n while (s.E > 0 && (int)s.ops.size() < limitOps) {\n bool changed = false;\n\n vector rows;\n if (rowType == 0) {\n for (int x = N - 2; x >= 0; x--) rows.push_back(x);\n } else {\n for (int x = 0; x <= N - 2; x++) rows.push_back(x);\n }\n\n for (int x : rows) {\n auto ys = yOrder(x, yType);\n for (int y : ys) {\n if ((int)s.ops.size() >= limitOps) break;\n\n int p = ID[x][y];\n int c1 = ID[x + 1][y];\n int c2 = ID[x + 1][y + 1];\n int ch = (s.a[c1] < s.a[c2] ? c1 : c2);\n\n if (s.a[p] > s.a[ch]) {\n applySwap(s, p, ch);\n changed = true;\n }\n }\n }\n\n if (!changed) break;\n }\n return s;\n}\n\n// Greedy among currently violating parent-child edges.\nState runViolationGreedy(State s, int mode, int limitOps) {\n while (s.E > 0 && (int)s.ops.size() < limitOps) {\n int bu = -1, bv = -1;\n long long bk1 = LLONG_MIN, bk2 = LLONG_MIN, bk3 = LLONG_MIN;\n\n for (auto [p, c] : downEdges) {\n if (s.a[p] <= s.a[c]) continue;\n\n int imp = deltaSwapLocal(s.a, p, c);\n int diff = s.a[p] - s.a[c];\n\n long long k1, k2, k3;\n if (mode == 0) {\n k1 = imp;\n k2 = diff;\n k3 = -X[p];\n } else if (mode == 1) {\n k1 = diff;\n k2 = imp;\n k3 = -X[p];\n } else if (mode == 2) {\n k1 = -s.a[c]; // smaller child value first\n k2 = imp;\n k3 = diff;\n } else {\n k1 = -X[p]; // upper violations first\n k2 = imp;\n k3 = diff;\n }\n\n if (k1 > bk1 || (k1 == bk1 && (k2 > bk2 || (k2 == bk2 && k3 > bk3)))) {\n bk1 = k1;\n bk2 = k2;\n bk3 = k3;\n bu = p;\n bv = c;\n }\n }\n\n if (bu == -1) break;\n applySwap(s, bu, bv);\n }\n return s;\n}\n\nvector reduceOps(const vector& ops) {\n vector st;\n st.reserve(ops.size());\n\n auto sameEdge = [](const Op& a, const Op& b) {\n return (a.u == b.u && a.v == b.v) || (a.u == b.v && a.v == b.u);\n };\n\n for (auto op : ops) {\n if (!st.empty() && sameEdge(st.back(), op)) {\n st.pop_back();\n } else {\n st.push_back(op);\n }\n }\n return st;\n}\n\nbool validateOps(const vector& ops) {\n if ((int)ops.size() > 10000) return false;\n\n array a = initialA;\n for (auto [u, v] : ops) {\n bool ok = false;\n for (auto [x, y] : adjEdges) {\n if ((x == u && y == v) || (x == v && y == u)) {\n ok = true;\n break;\n }\n }\n if (!ok) return false;\n swap(a[u], a[v]);\n }\n return calcE(a) == 0;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int id = 0;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n ID[x][y] = id;\n X[id] = x;\n Y[id] = y;\n id++;\n }\n }\n\n incidentDown.assign(M, {});\n\n // Build edges.\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n int u = ID[x][y];\n\n // horizontal\n if (y + 1 <= x) {\n int v = ID[x][y + 1];\n adjEdges.push_back({u, v});\n }\n\n // downward two neighbours\n if (x + 1 < N) {\n int v1 = ID[x + 1][y];\n int v2 = ID[x + 1][y + 1];\n\n adjEdges.push_back({u, v1});\n adjEdges.push_back({u, v2});\n\n int e1 = (int)downEdges.size();\n downEdges.push_back({u, v1});\n incidentDown[u].push_back(e1);\n incidentDown[v1].push_back(e1);\n\n int e2 = (int)downEdges.size();\n downEdges.push_back({u, v2});\n incidentDown[u].push_back(e2);\n incidentDown[v2].push_back(e2);\n }\n }\n }\n\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n cin >> initialA[ID[x][y]];\n }\n }\n\n initialE = calcE(initialA);\n\n State base;\n base.a = initialA;\n base.E = initialE;\n\n vector bestOps;\n bool haveBest = false;\n\n auto tryCandidate = [&](const State& s) {\n if (s.E != 0) return;\n\n vector ops = reduceOps(s.ops);\n if ((int)ops.size() > 10000) return;\n\n // Validation is cheap here and protects against bugs in reduction.\n if (!validateOps(ops)) return;\n\n if (!haveBest || ops.size() < bestOps.size()) {\n bestOps = move(ops);\n haveBest = true;\n }\n };\n\n // 1. Guaranteed candidates: triangular heapify with several row orders.\n for (int t = 0; t < 4; t++) {\n State s = runHeapify(base, t);\n tryCandidate(s);\n }\n\n // Fallback should already exist, but keep safety.\n if (!haveBest) {\n State s = runHeapify(base, 0);\n bestOps = s.ops;\n haveBest = true;\n }\n\n int bestLimit = min(10000, (int)bestOps.size() - 1);\n\n // 2. Repeated one-step bubble variants.\n if (bestLimit > 0) {\n for (int rowType = 0; rowType < 2; rowType++) {\n for (int yType = 0; yType < 4; yType++) {\n State s = runScanBubble(base, rowType, yType, bestLimit);\n tryCandidate(s);\n bestLimit = min(10000, (int)bestOps.size() - 1);\n if (bestLimit <= 0) break;\n }\n if (bestLimit <= 0) break;\n }\n }\n\n // 3. Greedy among violating vertical edges.\n bestLimit = min(10000, (int)bestOps.size() - 1);\n if (bestLimit > 0) {\n for (int mode = 0; mode < 4; mode++) {\n State s = runViolationGreedy(base, mode, bestLimit);\n tryCandidate(s);\n bestLimit = min(10000, (int)bestOps.size() - 1);\n if (bestLimit <= 0) break;\n }\n }\n\n // 4. Prefix of local E-reducing swaps over all adjacent edges,\n // periodically completed by heapify.\n bestLimit = min(10000, (int)bestOps.size() - 1);\n if (bestLimit > 0) {\n State cur = base;\n int maxSteps = min(700, bestLimit);\n\n for (int step = 1; step <= maxSteps; step++) {\n int bu = -1, bv = -1;\n int bestImp = 0;\n long long bestPot = LLONG_MIN;\n int bestDiff = -1;\n\n for (auto [u, v] : adjEdges) {\n int imp = deltaSwapLocal(cur.a, u, v);\n if (imp <= 0) continue;\n\n long long pot =\n 1LL * (X[v] - X[u]) * (cur.a[u] - cur.a[v]);\n int diff = abs(cur.a[u] - cur.a[v]);\n\n if (imp > bestImp ||\n (imp == bestImp &&\n (pot > bestPot || (pot == bestPot && diff > bestDiff)))) {\n bestImp = imp;\n bestPot = pot;\n bestDiff = diff;\n bu = u;\n bv = v;\n }\n }\n\n if (bu == -1) break;\n\n applySwap(cur, bu, bv);\n\n if (cur.E == 0) {\n tryCandidate(cur);\n break;\n }\n\n if (step <= 30 || step % 20 == 0 || step == maxSteps) {\n for (int t = 0; t < 4; t++) {\n State completed = runHeapify(cur, t);\n tryCandidate(completed);\n }\n bestLimit = min(10000, (int)bestOps.size() - 1);\n if ((int)cur.ops.size() >= bestLimit) break;\n }\n }\n }\n\n cout << bestOps.size() << '\\n';\n for (auto [u, v] : bestOps) {\n cout << X[u] << ' ' << Y[u] << ' ' << X[v] << ' ' << Y[v] << '\\n';\n }\n\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint D, N;\nint ENT;\nvector freeIds;\nbool obstacleCell[100];\nint labelAt[100]; // -1 empty, >=0 occupied label\nint rankOfCell[100];\nbool usedLabel[100];\n\nint dr[4] = {-1, 1, 0, 0};\nint dc[4] = {0, 0, -1, 1};\n\nint id_of(int r, int c) {\n return r * D + c;\n}\n\npair rc_of(int id) {\n return {id / D, id % D};\n}\n\nbool inside(int r, int c) {\n return 0 <= r && r < D && 0 <= c && c < D;\n}\n\nvector neighbors(int id) {\n auto [r, c] = rc_of(id);\n vector res;\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr, nc)) res.push_back(id_of(nr, nc));\n }\n return res;\n}\n\n// Check whether filling cand keeps all remaining empty cells reachable from entrance.\nbool legal_fill(int cand) {\n int totalEmptyAfter = 0;\n for (int id : freeIds) {\n if (id != cand && labelAt[id] == -1) totalEmptyAfter++;\n }\n\n queue q;\n bool vis[100] = {};\n vis[ENT] = true;\n q.push(ENT);\n\n int reached = 0;\n\n while (!q.empty()) {\n int v = q.front();\n q.pop();\n\n for (int to : neighbors(v)) {\n if (vis[to]) continue;\n if (obstacleCell[to]) continue;\n if (to == cand) continue;\n if (to != ENT && labelAt[to] != -1) continue;\n\n vis[to] = true;\n q.push(to);\n if (to != ENT) reached++;\n }\n }\n\n return reached == totalEmptyAfter;\n}\n\nbool is_accessible_container(int id, const bool emptyCell[]) {\n for (int to : neighbors(id)) {\n if (emptyCell[to]) return true;\n }\n return false;\n}\n\n// Estimate final inversions if current arriving label t is placed at cand.\n// Future labels are optimistically assigned to remaining empty cells in rank order.\nint evaluate_candidate(\n int cand,\n int t,\n const vector& emptySorted,\n const vector& remLabels\n) {\n int val[100];\n fill(val, val + 100, -1);\n\n for (int id : freeIds) {\n if (labelAt[id] >= 0) val[id] = labelAt[id];\n }\n val[cand] = t;\n\n int p = 0;\n for (int id : emptySorted) {\n if (id == cand) continue;\n val[id] = remLabels[p++];\n }\n\n bool emptyCell[100] = {};\n bool occ[100] = {};\n\n emptyCell[ENT] = true;\n for (int id : freeIds) occ[id] = true;\n\n vector seq;\n seq.reserve(freeIds.size());\n\n for (int step = 0; step < (int)freeIds.size(); step++) {\n int best = -1;\n int bestVal = 1e9;\n\n for (int id : freeIds) {\n if (!occ[id]) continue;\n if (!is_accessible_container(id, emptyCell)) continue;\n\n if (val[id] < bestVal ||\n (val[id] == bestVal && rankOfCell[id] < rankOfCell[best])) {\n bestVal = val[id];\n best = id;\n }\n }\n\n // Should never happen if the graph is connected.\n if (best == -1) {\n for (int id : freeIds) {\n if (occ[id]) {\n best = id;\n bestVal = val[id];\n break;\n }\n }\n }\n\n seq.push_back(bestVal);\n occ[best] = false;\n emptyCell[best] = true;\n }\n\n int inv = 0;\n int M = seq.size();\n for (int i = 0; i < M; i++) {\n for (int j = i + 1; j < M; j++) {\n if (seq[i] > seq[j]) inv++;\n }\n }\n return inv;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> D >> N;\n\n ENT = id_of(0, (D - 1) / 2);\n\n fill(obstacleCell, obstacleCell + 100, false);\n fill(labelAt, labelAt + 100, -1);\n fill(usedLabel, usedLabel + 100, false);\n\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n obstacleCell[id_of(r, c)] = true;\n }\n\n for (int r = 0; r < D; r++) {\n for (int c = 0; c < D; c++) {\n int id = id_of(r, c);\n if (id == ENT) continue;\n if (obstacleCell[id]) continue;\n freeIds.push_back(id);\n }\n }\n\n int M = freeIds.size();\n\n // Compute BFS distance from entrance.\n const int INF = 1e9;\n vector dist(D * D, INF);\n queue q;\n dist[ENT] = 0;\n q.push(ENT);\n\n while (!q.empty()) {\n int v = q.front();\n q.pop();\n\n for (int to : neighbors(v)) {\n if (obstacleCell[to]) continue;\n if (dist[to] != INF) continue;\n dist[to] = dist[v] + 1;\n q.push(to);\n }\n }\n\n int center = (D - 1) / 2;\n\n sort(freeIds.begin(), freeIds.end(), [&](int a, int b) {\n auto [ra, ca] = rc_of(a);\n auto [rb, cb] = rc_of(b);\n\n tuple ka = {\n dist[a],\n abs(ca - center),\n ra,\n ca\n };\n tuple kb = {\n dist[b],\n abs(cb - center),\n rb,\n cb\n };\n return ka < kb;\n });\n\n for (int i = 0; i < M; i++) {\n rankOfCell[freeIds[i]] = i;\n }\n\n // Arrival phase.\n for (int step = 0; step < M; step++) {\n int t;\n cin >> t;\n\n vector emptySorted;\n for (int id : freeIds) {\n if (labelAt[id] == -1) emptySorted.push_back(id);\n }\n sort(emptySorted.begin(), emptySorted.end(), [&](int a, int b) {\n return rankOfCell[a] < rankOfCell[b];\n });\n\n vector remLabels;\n for (int x = 0; x < M; x++) {\n if (!usedLabel[x] && x != t) remLabels.push_back(x);\n }\n\n vector legal;\n for (int id : emptySorted) {\n if (legal_fill(id)) legal.push_back(id);\n }\n\n // Fallback, should not be needed.\n if (legal.empty()) {\n legal = emptySorted;\n }\n\n int bestCell = legal[0];\n long long bestScore = (1LL << 60);\n\n for (int cand : legal) {\n int inv = evaluate_candidate(cand, t, emptySorted, remLabels);\n\n long long mismatch = abs(rankOfCell[cand] - t);\n long long score = inv * 1000LL + mismatch;\n\n if (score < bestScore) {\n bestScore = score;\n bestCell = cand;\n }\n }\n\n labelAt[bestCell] = t;\n usedLabel[t] = true;\n\n auto [r, c] = rc_of(bestCell);\n cout << r << ' ' << c << endl; // endl flushes\n }\n\n // Removal phase: always remove the smallest currently reachable label.\n bool emptyCell[100] = {};\n bool occ[100] = {};\n\n emptyCell[ENT] = true;\n for (int id : freeIds) occ[id] = true;\n\n for (int step = 0; step < M; step++) {\n int best = -1;\n int bestLabel = 1e9;\n\n for (int id : freeIds) {\n if (!occ[id]) continue;\n if (!is_accessible_container(id, emptyCell)) continue;\n\n if (labelAt[id] < bestLabel) {\n bestLabel = labelAt[id];\n best = id;\n }\n }\n\n // Should not happen.\n if (best == -1) {\n for (int id : freeIds) {\n if (occ[id]) {\n best = id;\n break;\n }\n }\n }\n\n auto [r, c] = rc_of(best);\n cout << r << ' ' << c << '\\n';\n\n occ[best] = false;\n emptyCell[best] = true;\n }\n\n cout.flush();\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nstatic const int MAXN = 50;\nstatic const int MAXC = 101;\nstatic const int INF = 1e9;\n\nint n, m;\nbool allowedAdj[MAXC][MAXC];\n\nstruct State {\n vector> g;\n int cnt[MAXC]{};\n int edgeCnt[MAXC][MAXC]{};\n\n int stamp[MAXN][MAXN]{};\n int curStamp = 1;\n\n State() {\n g.assign(n, vector(n, 0));\n memset(cnt, 0, sizeof(cnt));\n memset(edgeCnt, 0, sizeof(edgeCnt));\n memset(stamp, 0, sizeof(stamp));\n }\n\n static void norm(int &a, int &b) {\n if (a > b) swap(a, b);\n }\n\n void addEdgeCount(int a, int b, int v) {\n if (a == b) return;\n norm(a, b);\n edgeCnt[a][b] += v;\n }\n\n void init(const vector> &src) {\n g = src;\n memset(cnt, 0, sizeof(cnt));\n memset(edgeCnt, 0, sizeof(edgeCnt));\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cnt[g[i][j]]++;\n }\n }\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = g[i][j];\n\n if (i == 0) addEdgeCount(c, 0, 1);\n if (i == n - 1) addEdgeCount(c, 0, 1);\n if (j == 0) addEdgeCount(c, 0, 1);\n if (j == n - 1) addEdgeCount(c, 0, 1);\n\n if (i + 1 < n) addEdgeCount(c, g[i + 1][j], 1);\n if (j + 1 < n) addEdgeCount(c, g[i][j + 1], 1);\n }\n }\n }\n\n bool inside(int r, int c) const {\n return 0 <= r && r < n && 0 <= c && c < n;\n }\n\n bool adjacentZeroOrOutside(int r, int c) const {\n if (r == 0 || r == n - 1 || c == 0 || c == n - 1) return true;\n static int dr[4] = {-1, 1, 0, 0};\n static int dc[4] = {0, 0, -1, 1};\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr, nc) && g[nr][nc] == 0) return true;\n }\n return false;\n }\n\n bool oldColorConnectedAfterRemoval(int r, int c, int col) {\n vector> starts;\n static int dr[4] = {-1, 1, 0, 0};\n static int dc[4] = {0, 0, -1, 1};\n\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr, nc) && g[nr][nc] == col) {\n starts.push_back({nr, nc});\n }\n }\n\n if (starts.size() <= 1) return true;\n\n curStamp++;\n if (curStamp == INT_MAX) {\n memset(stamp, 0, sizeof(stamp));\n curStamp = 1;\n }\n\n queue> q;\n q.push(starts[0]);\n stamp[starts[0].first][starts[0].second] = curStamp;\n\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n\n for (int k = 0; k < 4; k++) {\n int nx = x + dr[k], ny = y + dc[k];\n if (!inside(nx, ny)) continue;\n if (nx == r && ny == c) continue;\n if (stamp[nx][ny] == curStamp) continue;\n if (g[nx][ny] != col) continue;\n\n stamp[nx][ny] = curStamp;\n q.push({nx, ny});\n }\n }\n\n for (auto [x, y] : starts) {\n if (stamp[x][y] != curStamp) return false;\n }\n return true;\n }\n\n struct Delta {\n int a, b, d;\n };\n\n void addDelta(vector &ds, int a, int b, int d) const {\n if (a == b) return;\n if (a > b) swap(a, b);\n\n for (auto &x : ds) {\n if (x.a == a && x.b == b) {\n x.d += d;\n return;\n }\n }\n ds.push_back({a, b, d});\n }\n\n vector makeDelta(int r, int c, int to) const {\n vector ds;\n int from = g[r][c];\n\n static int dr[4] = {-1, 1, 0, 0};\n static int dc[4] = {0, 0, -1, 1};\n\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n int nb = 0;\n if (0 <= nr && nr < n && 0 <= nc && nc < n) {\n nb = g[nr][nc];\n }\n\n addDelta(ds, from, nb, -1);\n addDelta(ds, to, nb, +1);\n }\n\n return ds;\n }\n\n bool validChange(int r, int c, int to) {\n int from = g[r][c];\n if (from == to) return false;\n if (from == 0) return false;\n\n if (cnt[from] <= 1) return false;\n\n if (to == 0) {\n if (!adjacentZeroOrOutside(r, c)) return false;\n } else {\n bool touches = false;\n static int dr[4] = {-1, 1, 0, 0};\n static int dc[4] = {0, 0, -1, 1};\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr, nc) && g[nr][nc] == to) {\n touches = true;\n break;\n }\n }\n if (!touches) return false;\n }\n\n if (!oldColorConnectedAfterRemoval(r, c, from)) return false;\n\n auto ds = makeDelta(r, c, to);\n for (auto &x : ds) {\n int now = edgeCnt[x.a][x.b] + x.d;\n if (allowedAdj[x.a][x.b]) {\n if (now <= 0) return false;\n } else {\n if (now != 0) return false;\n }\n }\n\n return true;\n }\n\n void applyChange(int r, int c, int to) {\n int from = g[r][c];\n auto ds = makeDelta(r, c, to);\n\n for (auto &x : ds) {\n edgeCnt[x.a][x.b] += x.d;\n }\n\n cnt[from]--;\n cnt[to]++;\n g[r][c] = to;\n }\n\n vector computeDistanceToZero() const {\n vector dist(n * n, INF);\n queue q;\n\n auto id = [&](int r, int c) {\n return r * n + c;\n };\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int v = id(i, j);\n if (g[i][j] == 0) {\n dist[v] = 0;\n q.push(v);\n } else if (i == 0 || i == n - 1 || j == 0 || j == n - 1) {\n dist[v] = 1;\n q.push(v);\n }\n }\n }\n\n static int dr[4] = {-1, 1, 0, 0};\n static int dc[4] = {0, 0, -1, 1};\n\n while (!q.empty()) {\n int v = q.front();\n q.pop();\n int r = v / n, c = v % n;\n\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (!inside(nr, nc)) continue;\n int nv = id(nr, nc);\n if (dist[nv] > dist[v] + 1) {\n dist[nv] = dist[v] + 1;\n q.push(nv);\n }\n }\n }\n\n return dist;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> n >> m;\n\n vector> original(n, vector(n));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> original[i][j];\n }\n }\n\n memset(allowedAdj, 0, sizeof(allowedAdj));\n\n auto addAllowed = [&](int a, int b) {\n if (a == b) return;\n if (a > b) swap(a, b);\n allowedAdj[a][b] = true;\n };\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = original[i][j];\n\n if (i == 0) addAllowed(c, 0);\n if (i == n - 1) addAllowed(c, 0);\n if (j == 0) addAllowed(c, 0);\n if (j == n - 1) addAllowed(c, 0);\n\n if (i + 1 < n) addAllowed(c, original[i + 1][j]);\n if (j + 1 < n) addAllowed(c, original[i][j + 1]);\n }\n }\n\n State st;\n st.init(original);\n\n vector> best = st.g;\n int bestZero = st.cnt[0];\n\n mt19937 rng(123456789);\n\n auto startTime = chrono::steady_clock::now();\n auto elapsed = [&]() {\n return chrono::duration(chrono::steady_clock::now() - startTime).count();\n };\n\n vector cells(n * n);\n iota(cells.begin(), cells.end(), 0);\n\n auto updateBest = [&]() {\n if (st.cnt[0] > bestZero) {\n bestZero = st.cnt[0];\n best = st.g;\n }\n };\n\n auto peelPass = [&]() {\n bool changed = false;\n shuffle(cells.begin(), cells.end(), rng);\n\n for (int idx = 0; idx < (int)cells.size(); idx++) {\n if ((idx & 255) == 0 && elapsed() > 1.85) break;\n\n int v = cells[idx];\n int r = v / n, c = v % n;\n if (st.g[r][c] == 0) continue;\n if (!st.adjacentZeroOrOutside(r, c)) continue;\n\n if (st.validChange(r, c, 0)) {\n st.applyChange(r, c, 0);\n changed = true;\n }\n }\n\n updateBest();\n return changed;\n };\n\n auto recolorPass = [&]() {\n bool changed = false;\n auto dist = st.computeDistanceToZero();\n\n shuffle(cells.begin(), cells.end(), rng);\n stable_sort(cells.begin(), cells.end(), [&](int a, int b) {\n return dist[a] < dist[b];\n });\n\n static int dr[4] = {-1, 1, 0, 0};\n static int dc[4] = {0, 0, -1, 1};\n\n for (int idx = 0; idx < (int)cells.size(); idx++) {\n if ((idx & 127) == 0 && elapsed() > 1.85) break;\n\n int v = cells[idx];\n int r = v / n, c = v % n;\n int from = st.g[r][c];\n if (from == 0) continue;\n\n vector> cand;\n bool used[MAXC]{};\n\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (!st.inside(nr, nc)) continue;\n\n int to = st.g[nr][nc];\n if (to == 0 || to == from) continue;\n if (used[to]) continue;\n\n int nd = dist[nr * n + nc];\n int cd = dist[r * n + c];\n\n if (nd < cd) {\n used[to] = true;\n cand.push_back({nd, to});\n }\n }\n\n sort(cand.begin(), cand.end());\n\n for (auto [_, to] : cand) {\n if (st.validChange(r, c, to)) {\n st.applyChange(r, c, to);\n changed = true;\n break;\n }\n }\n }\n\n return changed;\n };\n\n auto randomRecolorPass = [&]() {\n bool changed = false;\n shuffle(cells.begin(), cells.end(), rng);\n\n static int dr[4] = {-1, 1, 0, 0};\n static int dc[4] = {0, 0, -1, 1};\n\n int applied = 0;\n\n for (int idx = 0; idx < (int)cells.size(); idx++) {\n if ((idx & 127) == 0 && elapsed() > 1.85) break;\n if (applied >= 200) break;\n\n int v = cells[idx];\n int r = v / n, c = v % n;\n int from = st.g[r][c];\n if (from == 0) continue;\n\n vector cand;\n bool used[MAXC]{};\n\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (!st.inside(nr, nc)) continue;\n int to = st.g[nr][nc];\n if (to == 0 || to == from) continue;\n if (used[to]) continue;\n used[to] = true;\n cand.push_back(to);\n }\n\n shuffle(cand.begin(), cand.end(), rng);\n\n for (int to : cand) {\n if (st.validChange(r, c, to)) {\n st.applyChange(r, c, to);\n changed = true;\n applied++;\n break;\n }\n }\n }\n\n return changed;\n };\n\n while (elapsed() < 1.85) {\n bool any = false;\n\n any |= peelPass();\n if (elapsed() > 1.85) break;\n\n any |= recolorPass();\n if (elapsed() > 1.85) break;\n\n any |= peelPass();\n if (elapsed() > 1.85) break;\n\n updateBest();\n\n if (!any) {\n bool r = randomRecolorPass();\n if (!r) break;\n }\n }\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j) cout << ' ';\n cout << best[i][j];\n }\n cout << '\\n';\n }\n\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nstruct QueryManager {\n int N, D, Q;\n int used = 0;\n\n QueryManager(int N_, int D_, int Q_) : N(N_), D(D_), Q(Q_) {}\n\n char query(const vector& L, const vector& R) {\n if (used >= Q) return '?';\n\n cout << L.size() << ' ' << R.size();\n for (int x : L) cout << ' ' << x;\n for (int x : R) cout << ' ' << x;\n cout << endl;\n cout.flush();\n\n string s;\n if (!(cin >> s)) exit(0);\n\n used++;\n return s[0];\n }\n\n char query_single(int a, int b) {\n vector L{a}, R{b};\n return query(L, R);\n }\n};\n\nint ceil_log2_int(int x) {\n int r = 0;\n int p = 1;\n while (p < x) {\n p <<= 1;\n r++;\n }\n return r;\n}\n\nstruct Solver {\n int N, D, Q;\n QueryManager qm;\n\n vector estWeight;\n vector order;\n\n vector> bins;\n vector estSum;\n vector answer;\n\n mt19937 rng;\n\n Solver(int N_, int D_, int Q_)\n : N(N_), D(D_), Q(Q_), qm(N_, D_, Q_), rng(1234567 + N_ * 1009 + D_ * 917 + Q_) {}\n\n bool heavier_single(int a, int b) {\n char c = qm.query_single(a, b);\n return c == '>';\n }\n\n vector merge_sort_rec(const vector& v) {\n int n = (int)v.size();\n if (n <= 1) return v;\n\n int mid = n / 2;\n vector L(v.begin(), v.begin() + mid);\n vector R(v.begin() + mid, v.end());\n\n L = merge_sort_rec(L);\n R = merge_sort_rec(R);\n\n vector res;\n res.reserve(n);\n\n int i = 0, j = 0;\n while (i < (int)L.size() && j < (int)R.size()) {\n if (heavier_single(L[i], R[j])) {\n res.push_back(L[i++]);\n } else {\n res.push_back(R[j++]);\n }\n }\n while (i < (int)L.size()) res.push_back(L[i++]);\n while (j < (int)R.size()) res.push_back(R[j++]);\n\n return res;\n }\n\n void exact_sort_items() {\n order.resize(N);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n order = merge_sort_rec(order);\n }\n\n void approximate_sort_items(int targetQueries) {\n order.resize(N);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n\n vector gaps;\n for (int g = N / 2; g >= 1; g /= 2) gaps.push_back(g);\n\n while (qm.used < targetQueries) {\n bool anySwap = false;\n\n for (int gap : gaps) {\n for (int i = gap; i < N && qm.used < targetQueries; i++) {\n int a = order[i - gap];\n int b = order[i];\n\n char c = qm.query_single(a, b);\n if (c == '<') {\n swap(order[i - gap], order[i]);\n anySwap = true;\n }\n }\n if (qm.used >= targetQueries) break;\n }\n\n // If it already looks sorted, still spend useful adjacent comparisons.\n if (!anySwap) {\n for (int i = 1; i < N && qm.used < targetQueries; i++) {\n int a = order[i - 1];\n int b = order[i];\n char c = qm.query_single(a, b);\n if (c == '<') swap(order[i - 1], order[i]);\n }\n }\n }\n }\n\n void make_estimated_weights() {\n vector H(N + 1, 0.0);\n for (int i = 1; i <= N; i++) H[i] = H[i - 1] + 1.0 / i;\n\n estWeight.assign(N, 0.0);\n\n // Expected k-th largest value of Exp(1) samples is H_N - H_k.\n for (int k = 0; k < N; k++) {\n int item = order[k];\n estWeight[item] = H[N] - H[k];\n }\n }\n\n int compare_bins_by_est(int a, int b) {\n const double eps = 1e-12;\n if (estSum[a] + eps < estSum[b]) return -1;\n if (estSum[a] > estSum[b] + eps) return 1;\n return 0;\n }\n\n int compare_bins(int a, int b, bool allowQuery = true) {\n if (a == b) return 0;\n\n if (allowQuery && qm.used < Q) {\n char c = qm.query(bins[a], bins[b]);\n if (c == '<') return -1;\n if (c == '>') return 1;\n return 0;\n } else {\n return compare_bins_by_est(a, b);\n }\n }\n\n void build_partition() {\n bins.assign(D, {});\n estSum.assign(D, 0.0);\n answer.assign(N, 0);\n\n for (int i = 0; i < D; i++) {\n int item = order[i];\n bins[i].push_back(item);\n estSum[i] += estWeight[item];\n answer[item] = i;\n }\n\n vector binOrder(D);\n iota(binOrder.begin(), binOrder.end(), 0);\n\n sort(binOrder.begin(), binOrder.end(), [&](int a, int b) {\n return estSum[a] < estSum[b];\n });\n\n for (int idx = D; idx < N; idx++) {\n int item = order[idx];\n\n int b = binOrder.front();\n binOrder.erase(binOrder.begin());\n\n bins[b].push_back(item);\n estSum[b] += estWeight[item];\n answer[item] = b;\n\n int lo = 0, hi = (int)binOrder.size();\n while (lo < hi) {\n int mid = (lo + hi) / 2;\n int cmp = compare_bins(b, binOrder[mid], true);\n if (cmp <= 0) hi = mid;\n else lo = mid + 1;\n }\n binOrder.insert(binOrder.begin() + lo, b);\n }\n }\n\n bool find_min_max_bins(int& mn, int& mx) {\n if (qm.used + 2 * (D - 1) > Q) return false;\n\n mn = 0;\n mx = 0;\n\n for (int b = 1; b < D; b++) {\n int c1 = compare_bins(b, mn, true);\n if (c1 < 0) mn = b;\n\n int c2 = compare_bins(b, mx, true);\n if (c2 > 0) mx = b;\n }\n\n return true;\n }\n\n void local_improve() {\n int iteration = 0;\n\n while (qm.used < Q && iteration < 10000) {\n iteration++;\n\n int lo, hi;\n if (!find_min_max_bins(lo, hi)) break;\n if (lo == hi) break;\n if ((int)bins[hi].size() <= 1) break;\n\n vector cand = bins[hi];\n sort(cand.begin(), cand.end(), [&](int a, int b) {\n return estWeight[a] > estWeight[b];\n });\n\n bool moved = false;\n\n for (int x : cand) {\n if (qm.used >= Q) break;\n if ((int)bins[hi].size() <= 1) break;\n\n vector leftSet;\n leftSet.reserve(bins[hi].size() - 1);\n for (int y : bins[hi]) {\n if (y != x) leftSet.push_back(y);\n }\n\n if (leftSet.empty()) continue;\n\n vector rightSet = bins[lo];\n rightSet.push_back(x);\n\n char c = qm.query(leftSet, rightSet);\n\n // If after moving x, the old heavy bin is still not lighter,\n // this is a safe balancing move.\n if (c == '>' || c == '=') {\n auto it = find(bins[hi].begin(), bins[hi].end(), x);\n if (it != bins[hi].end()) bins[hi].erase(it);\n\n bins[lo].push_back(x);\n estSum[hi] -= estWeight[x];\n estSum[lo] += estWeight[x];\n answer[x] = lo;\n\n moved = true;\n break;\n }\n }\n\n if (!moved) break;\n }\n }\n\n void spend_remaining_queries() {\n while (qm.used < Q) {\n qm.query_single(0, 1);\n }\n }\n\n void output_answer() {\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << answer[i];\n }\n cout << endl;\n cout.flush();\n }\n\n void solve() {\n int lgN = ceil_log2_int(N);\n int mergeWorst = N * lgN - (1 << lgN) + 1;\n if (mergeWorst < 0) mergeWorst = N * lgN;\n\n int lgD = ceil_log2_int(D);\n int constructionCostApprox = max(0, N - D) * max(1, lgD);\n\n bool useExactSort = false;\n if (Q >= mergeWorst + D) useExactSort = true;\n\n if (useExactSort) {\n exact_sort_items();\n } else {\n int reserve = min(constructionCostApprox, Q / 3);\n int target = max(0, Q - reserve);\n approximate_sort_items(target);\n }\n\n make_estimated_weights();\n\n build_partition();\n\n if (qm.used < Q) {\n local_improve();\n }\n\n spend_remaining_queries();\n\n output_answer();\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, D, Q;\n cin >> N >> D >> Q;\n\n Solver solver(N, D, Q);\n solver.solve();\n\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstruct Op {\n int v, to;\n};\n\nstruct Result {\n vector ops;\n int energy = INT_MAX;\n bool valid = false;\n};\n\nstatic const int N = 200;\nstatic const int M = 10;\nstatic const int EMPTY_VAL = 1000;\n\nint seg_max(const vector& a) {\n int mx = 0;\n for (int x : a) mx = max(mx, x);\n return mx;\n}\n\nint stack_min_value(const vector& st) {\n if (st.empty()) return EMPTY_VAL;\n int mn = EMPTY_VAL;\n for (int x : st) mn = min(mn, x);\n return mn;\n}\n\nbool has_good_destination(const vector>& stacks, int src, const vector& vals) {\n int mx = seg_max(vals);\n for (int d = 0; d < M; d++) {\n if (d == src) continue;\n if (stacks[d].empty()) return true;\n if (stacks[d].back() > mx) return true;\n }\n return false;\n}\n\nint choose_destination(\n const vector>& stacks,\n int src,\n const vector& vals,\n int policy,\n mt19937& rng,\n double noise_amp\n) {\n int mx = seg_max(vals);\n\n uniform_real_distribution dist(0.0, noise_amp);\n\n int best = -1;\n double best_score = 1e100;\n\n for (int d = 0; d < M; d++) {\n if (d == src) continue;\n\n int h = (int)stacks[d].size();\n bool empty = stacks[d].empty();\n\n int top = empty ? EMPTY_VAL : stacks[d].back();\n int mn = stack_min_value(stacks[d]);\n\n bool good_top = empty || top > mx;\n bool good_all = empty || mn > mx;\n\n double score = 0.0;\n\n switch (policy % 8) {\n case 0:\n // Basic: prefer smallest top larger than block max.\n if (good_top) score = top * 100.0 + h;\n else score = 1e6 - top * 100.0 + h;\n break;\n\n case 1:\n // Prefer low height, but still prioritize good destinations.\n score = (good_top ? 0.0 : 100000.0) + h * 100.0 + top;\n break;\n\n case 2:\n // Stronger condition: all boxes in destination are larger.\n if (good_all) score = mn * 100.0 + h;\n else if (good_top) score = 200000.0 + top * 100.0 + h;\n else score = 1e6 - mn * 50.0 - top * 10.0 + h;\n break;\n\n case 3:\n // Prefer smallest positive gap top - max.\n if (good_top) score = (top - mx) * 100.0 + h * 5.0;\n else score = 1e6 + (mx - top) * 100.0 + h;\n break;\n\n case 4:\n // Mostly balance heights.\n score = h * 100.0 + (good_top ? 0.0 : 10.0);\n break;\n\n case 5:\n // Try using taller stacks if destination is good.\n if (good_top) score = top * 100.0 - h * 20.0;\n else score = 1e6 - top * 100.0 - h * 10.0;\n break;\n\n case 6:\n // Prefer large top labels.\n score = (good_top ? 0.0 : 500000.0) - top * 100.0 + h * 10.0;\n break;\n\n case 7:\n // Prefer destinations whose minimum label is large.\n score = (good_top ? 0.0 : 300000.0) - mn * 100.0 - top * 10.0 + h;\n break;\n }\n\n if (noise_amp > 0.0) score += dist(rng);\n\n if (score < best_score) {\n best_score = score;\n best = d;\n }\n }\n\n return best;\n}\n\nResult simulate(\n const vector>& initial,\n int split_mode,\n int policy,\n bool merge_when_no_good,\n uint32_t seed,\n double noise_amp\n) {\n mt19937 rng(seed);\n\n vector> stacks = initial;\n vector ops;\n int energy = 0;\n\n for (int cur = 1; cur <= N; cur++) {\n int s = -1, pos = -1;\n\n for (int i = 0; i < M; i++) {\n for (int j = 0; j < (int)stacks[i].size(); j++) {\n if (stacks[i][j] == cur) {\n s = i;\n pos = j;\n }\n }\n }\n\n if (s == -1) {\n return Result{};\n }\n\n while (pos != (int)stacks[s].size() - 1) {\n if ((int)ops.size() >= 5000) return Result{};\n\n int h = (int)stacks[s].size();\n int l;\n\n bool force_whole = ((int)ops.size() > 4500);\n\n if (force_whole || split_mode == 0) {\n // Move the whole suffix above cur.\n l = pos + 1;\n } else if (split_mode == 2) {\n // Move one box at a time.\n l = h - 1;\n } else {\n // Move a maximal decreasing run from the top.\n l = h - 1;\n while (l - 1 > pos && stacks[s][l - 1] > stacks[s][l]) {\n l--;\n }\n\n vector tmp(stacks[s].begin() + l, stacks[s].end());\n\n if (merge_when_no_good && !has_good_destination(stacks, s, tmp)) {\n l = pos + 1;\n }\n }\n\n vector vals(stacks[s].begin() + l, stacks[s].end());\n\n int d = choose_destination(stacks, s, vals, policy, rng, noise_amp);\n if (d < 0 || d == s) return Result{};\n\n ops.push_back({vals.front(), d + 1});\n energy += (int)vals.size() + 1;\n\n stacks[s].erase(stacks[s].begin() + l, stacks[s].end());\n stacks[d].insert(stacks[d].end(), vals.begin(), vals.end());\n\n if ((int)ops.size() > 5000) return Result{};\n }\n\n // Now cur is on top.\n if (stacks[s].empty() || stacks[s].back() != cur) {\n return Result{};\n }\n\n ops.push_back({cur, 0});\n stacks[s].pop_back();\n\n if ((int)ops.size() > 5000) return Result{};\n }\n\n Result res;\n res.ops = move(ops);\n res.energy = energy;\n res.valid = true;\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m;\n\n vector> initial(M);\n\n for (int i = 0; i < M; i++) {\n initial[i].resize(N / M);\n for (int j = 0; j < N / M; j++) {\n cin >> initial[i][j];\n }\n }\n\n uint32_t base_seed = 123456789;\n for (int i = 0; i < M; i++) {\n for (int x : initial[i]) {\n base_seed = base_seed * 1000003u + (uint32_t)x;\n }\n }\n\n Result best;\n\n auto try_result = [&](const Result& r) {\n if (!r.valid) return;\n if ((int)r.ops.size() > 5000) return;\n\n if (!best.valid ||\n r.energy < best.energy ||\n (r.energy == best.energy && r.ops.size() < best.ops.size())) {\n best = r;\n }\n };\n\n // Deterministic variants.\n for (int split = 0; split < 3; split++) {\n for (int policy = 0; policy < 8; policy++) {\n for (int merge = 0; merge < 2; merge++) {\n Result r = simulate(\n initial,\n split,\n policy,\n merge,\n base_seed + split * 1000 + policy * 100 + merge,\n 0.0\n );\n try_result(r);\n }\n }\n }\n\n // Randomized variants.\n mt19937 rng(base_seed ^ 0x9e3779b9u);\n\n for (int t = 0; t < 250; t++) {\n int split;\n int r = (int)(rng() % 100);\n if (r < 20) split = 0;\n else if (r < 85) split = 1;\n else split = 2;\n\n int policy = rng() % 8;\n bool merge = rng() & 1;\n\n double noise;\n int nr = rng() % 5;\n if (nr == 0) noise = 5.0;\n else if (nr == 1) noise = 20.0;\n else if (nr == 2) noise = 100.0;\n else if (nr == 3) noise = 500.0;\n else noise = 2000.0;\n\n Result res = simulate(\n initial,\n split,\n policy,\n merge,\n base_seed + 100000u + t * 17u,\n noise\n );\n\n try_result(res);\n }\n\n // Fallback should always exist, but just in case.\n if (!best.valid) {\n best = simulate(initial, 0, 1, false, base_seed, 0.0);\n }\n\n for (const auto& op : best.ops) {\n cout << op.v << ' ' << op.to << '\\n';\n }\n\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstruct Edge {\n int to;\n char c;\n};\n\nstatic const uint16_t INF16 = 65535;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto time_start = chrono::steady_clock::now();\n auto elapsed = [&]() -> double {\n return chrono::duration(chrono::steady_clock::now() - time_start).count();\n };\n\n int N;\n cin >> N;\n\n vector h(N - 1), v(N);\n for (int i = 0; i < N - 1; i++) cin >> h[i];\n for (int i = 0; i < N; i++) cin >> v[i];\n\n int V = N * N;\n vector dirt(V);\n long long sumD = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> dirt[i * N + j];\n sumD += dirt[i * N + j];\n }\n }\n double avgD = (double)sumD / V;\n\n auto id = [&](int i, int j) {\n return i * N + j;\n };\n\n vector> g(V);\n\n auto add_edge = [&](int a, int b, char c1, char c2) {\n g[a].push_back({b, c1});\n g[b].push_back({a, c2});\n };\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i + 1 < N && h[i][j] == '0') {\n add_edge(id(i, j), id(i + 1, j), 'D', 'U');\n }\n if (j + 1 < N && v[i][j] == '0') {\n add_edge(id(i, j), id(i, j + 1), 'R', 'L');\n }\n }\n }\n\n // all-pairs shortest paths\n vector dist((size_t)V * V, INF16);\n vector q(V);\n\n for (int s = 0; s < V; s++) {\n uint16_t* ds = &dist[(size_t)s * V];\n int head = 0, tail = 0;\n ds[s] = 0;\n q[tail++] = s;\n\n while (head < tail) {\n int cur = q[head++];\n uint16_t nd = ds[cur] + 1;\n for (auto &e : g[cur]) {\n if (ds[e.to] == INF16) {\n ds[e.to] = nd;\n q[tail++] = e.to;\n }\n }\n }\n }\n\n int maxDist = 0;\n for (int i = 0; i < V; i++) {\n for (int j = 0; j < V; j++) {\n maxDist = max(maxDist, (int)dist[(size_t)i * V + j]);\n }\n }\n\n vector alphas = {1.0, 1.5, 2.0, 3.0};\n vector> denom(alphas.size(), vector(maxDist + 2));\n for (int a = 0; a < (int)alphas.size(); a++) {\n for (int d = 0; d <= maxDist + 1; d++) {\n denom[a][d] = pow((double)d, alphas[a]);\n }\n }\n\n auto score_route = [&](const string &route) -> long double {\n int L = (int)route.size();\n if (L == 0 || L > 100000) return 1e100L;\n\n vector> times(V);\n int cur = 0;\n times[0].push_back(0);\n\n for (int t = 1; t <= L; t++) {\n char c = route[t - 1];\n bool moved = false;\n for (auto &e : g[cur]) {\n if (e.c == c) {\n cur = e.to;\n moved = true;\n break;\n }\n }\n if (!moved) return 1e100L;\n\n if (t < L) {\n times[cur].push_back(t);\n }\n }\n\n if (cur != 0) return 1e100L;\n\n long double total = 0.0L;\n\n for (int x = 0; x < V; x++) {\n if (times[x].empty()) return 1e100L;\n\n auto &ts = times[x];\n long long ss = 0;\n\n for (int k = 0; k + 1 < (int)ts.size(); k++) {\n long long gap = ts[k + 1] - ts[k];\n ss += gap * (gap - 1);\n }\n\n long long gap = L - ts.back() + ts.front();\n ss += gap * (gap - 1);\n\n total += (long double)dirt[x] * ss / (2.0L * L);\n }\n\n return total;\n };\n\n string bestRoute;\n long double bestScore = 1e100L;\n\n auto consider = [&](const string &route) {\n if (route.empty() || route.size() > 100000) return;\n long double sc = score_route(route);\n if (sc < bestScore) {\n bestScore = sc;\n bestRoute = route;\n }\n };\n\n // DFS baseline routes\n for (int mode = 0; mode < 4; mode++) {\n vector used(V, 0);\n string route;\n\n function dfs = [&](int cur) {\n used[cur] = 1;\n\n vector es = g[cur];\n\n if (mode == 1) {\n sort(es.begin(), es.end(), [&](const Edge &a, const Edge &b) {\n return dirt[a.to] > dirt[b.to];\n });\n } else if (mode == 2) {\n sort(es.begin(), es.end(), [&](const Edge &a, const Edge &b) {\n return dirt[a.to] < dirt[b.to];\n });\n } else if (mode == 3) {\n sort(es.begin(), es.end(), [&](const Edge &a, const Edge &b) {\n return a.c < b.c;\n });\n }\n\n for (auto &e : es) {\n if (!used[e.to]) {\n route.push_back(e.c);\n dfs(e.to);\n\n for (auto &r : g[e.to]) {\n if (r.to == cur) {\n route.push_back(r.c);\n break;\n }\n }\n }\n }\n };\n\n dfs(0);\n consider(route);\n }\n\n uint32_t rng = 123456789;\n auto rnd01 = [&]() {\n rng ^= rng << 13;\n rng ^= rng >> 17;\n rng ^= rng << 5;\n return (rng & 0xffff) / 65536.0;\n };\n\n auto generate_route = [&](int cap, int covAlphaIdx, int patAlphaIdx, double coverBiasMul, bool noise) {\n string route;\n route.reserve(min(100000, max(cap, V * 2)));\n\n vector last(V, 0);\n vector visited(V, 0);\n int visitedCnt = 1;\n visited[0] = 1;\n\n int cur = 0;\n int t = 0;\n\n auto append_path = [&](int target) {\n while (cur != target) {\n uint16_t dc = dist[(size_t)cur * V + target];\n\n int bestNext = -1;\n char bestChar = '?';\n long long bestVal = LLONG_MIN;\n\n for (auto &e : g[cur]) {\n if (dist[(size_t)e.to * V + target] + 1 == dc) {\n long long val = 0;\n if (!visited[e.to]) val += (long long)4e18 / 4;\n val += (long long)dirt[e.to] * (t - last[e.to] + 1);\n\n if (val > bestVal) {\n bestVal = val;\n bestNext = e.to;\n bestChar = e.c;\n }\n }\n }\n\n if (bestNext == -1) return;\n\n route.push_back(bestChar);\n cur = bestNext;\n t++;\n\n last[cur] = t;\n if (!visited[cur]) {\n visited[cur] = 1;\n visitedCnt++;\n }\n }\n };\n\n double coverBias = avgD * coverBiasMul;\n\n // Phase 1: visit all cells\n while (visitedCnt < V) {\n int target = -1;\n double bestVal = -1.0;\n\n for (int x = 0; x < V; x++) {\n if (visited[x]) continue;\n\n int ds = dist[(size_t)cur * V + x];\n double val = (coverBias + dirt[x]) / denom[covAlphaIdx][ds + 1];\n\n if (noise) val *= 0.9 + 0.2 * rnd01();\n\n if (val > bestVal) {\n bestVal = val;\n target = x;\n }\n }\n\n if (target == -1) break;\n append_path(target);\n\n if ((int)route.size() > 100000) break;\n }\n\n // Phase 2: patrol high-dirt / long-unvisited cells\n int limit = cap;\n if (limit <= 0) limit = (int)route.size();\n\n int iter = 0;\n while ((int)route.size() + dist[(size_t)cur * V + 0] < limit &&\n (int)route.size() < 100000) {\n if ((++iter & 255) == 0 && elapsed() > 1.82) break;\n\n int target = -1;\n double bestVal = -1.0;\n\n for (int x = 0; x < V; x++) {\n int ds = dist[(size_t)cur * V + x];\n if (ds == 0) continue;\n\n int ret = dist[(size_t)x * V + 0];\n if ((int)route.size() + ds + ret > limit) continue;\n if ((int)route.size() + ds + ret > 100000) continue;\n\n int age = t - last[x];\n double val = (double)dirt[x] * (age + 1) / denom[patAlphaIdx][ds + 1];\n\n if (noise) val *= 0.9 + 0.2 * rnd01();\n\n if (val > bestVal) {\n bestVal = val;\n target = x;\n }\n }\n\n if (target == -1) break;\n append_path(target);\n }\n\n append_path(0);\n return route;\n };\n\n struct Param {\n int cap;\n int covA;\n int patA;\n double bias;\n bool noise;\n };\n\n vector params;\n\n // Coverage-only variants\n params.push_back({0, 3, 1, 20.0, false});\n params.push_back({0, 2, 1, 20.0, false});\n params.push_back({0, 2, 1, 0.0, false});\n params.push_back({0, 1, 1, 0.0, false});\n\n vector caps = {\n V * 2,\n V * 3,\n V * 5,\n V * 8,\n V * 13,\n 30000,\n 60000,\n 100000\n };\n\n for (int &x : caps) {\n x = min(100000, max(1, x));\n }\n sort(caps.begin(), caps.end());\n caps.erase(unique(caps.begin(), caps.end()), caps.end());\n\n for (int cap : caps) {\n params.push_back({cap, 2, 1, 10.0, false});\n }\n\n params.push_back({30000, 2, 0, 10.0, false});\n params.push_back({30000, 2, 2, 10.0, false});\n params.push_back({60000, 2, 0, 10.0, false});\n params.push_back({100000, 2, 0, 10.0, false});\n\n params.push_back({60000, 2, 1, 10.0, true});\n params.push_back({100000, 2, 1, 10.0, true});\n\n for (auto &p : params) {\n if (elapsed() > 1.84) break;\n string r = generate_route(p.cap, p.covA, p.patA, p.bias, p.noise);\n consider(r);\n }\n\n // Absolute safety fallback, should practically never be needed.\n if (bestRoute.empty()) {\n vector used(V, 0);\n string route;\n\n function dfs = [&](int cur) {\n used[cur] = 1;\n for (auto &e : g[cur]) {\n if (!used[e.to]) {\n route.push_back(e.c);\n dfs(e.to);\n for (auto &r : g[e.to]) {\n if (r.to == cur) {\n route.push_back(r.c);\n break;\n }\n }\n }\n }\n };\n\n dfs(0);\n bestRoute = route;\n }\n\n cout << bestRoute << '\\n';\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int n) {\n return (int)(next() % n);\n }\n double nextDouble() {\n return (next() >> 11) * (1.0 / (1ULL << 53));\n }\n};\n\nint N, M;\nint si, sj;\nvector Agrid;\nvector t;\nvector> occ[26];\nint mindist_ch[26][26];\n\nint manhattan(pair a, pair b) {\n return abs(a.first - b.first) + abs(a.second - b.second);\n}\n\nint overlap_word(const string& a, const string& b) {\n for (int k = 4; k >= 1; --k) {\n bool ok = true;\n for (int i = 0; i < k; ++i) {\n if (a[5 - k + i] != b[i]) {\n ok = false;\n break;\n }\n }\n if (ok) return k;\n }\n return 0;\n}\n\nint overlap_suffix_string(const string& s, const string& w) {\n int lim = min(4, s.size());\n for (int k = lim; k >= 1; --k) {\n bool ok = true;\n for (int i = 0; i < k; ++i) {\n if (s[(int)s.size() - k + i] != w[i]) {\n ok = false;\n break;\n }\n }\n if (ok) return k;\n }\n return 0;\n}\n\nlong long pathCost(const vector& p, const vector>& W, const vector& startCost) {\n long long c = startCost[p[0]];\n for (int i = 0; i + 1 < (int)p.size(); ++i) c += W[p[i]][p[i + 1]];\n return c;\n}\n\nlong long contrib(const vector& p, int idx, const vector>& W, const vector& startCost) {\n int n = (int)p.size();\n if (idx == -1) return startCost[p[0]];\n if (0 <= idx && idx + 1 < n) return W[p[idx]][p[idx + 1]];\n return 0;\n}\n\nlong long deltaSwap(const vector& p, int a, int b, const vector>& W, const vector& startCost) {\n if (a == b) return 0;\n if (a > b) swap(a, b);\n\n vector ids = {-1, a - 1, a, b - 1, b};\n sort(ids.begin(), ids.end());\n ids.erase(unique(ids.begin(), ids.end()), ids.end());\n\n long long oldv = 0, newv = 0;\n for (int id : ids) oldv += contrib(p, id, W, startCost);\n\n vector q = p;\n swap(q[a], q[b]);\n\n for (int id : ids) newv += contrib(q, id, W, startCost);\n return newv - oldv;\n}\n\nvector greedyOrder(const vector>& W, const vector& startCost, const vector>& ov) {\n vector best;\n long long bestCost = (1LL << 60);\n\n for (int st = 0; st < M; ++st) {\n vector p;\n vector used(M, 0);\n p.reserve(M);\n p.push_back(st);\n used[st] = 1;\n\n for (int step = 1; step < M; ++step) {\n int last = p.back();\n int bj = -1;\n pair bestKey = {INT_MAX, INT_MAX};\n\n for (int j = 0; j < M; ++j) if (!used[j]) {\n // primary: estimated cost, secondary: larger overlap\n pair key = {W[last][j], -ov[last][j]};\n if (key < bestKey) {\n bestKey = key;\n bj = j;\n }\n }\n\n used[bj] = 1;\n p.push_back(bj);\n }\n\n long long c = pathCost(p, W, startCost);\n if (c < bestCost) {\n bestCost = c;\n best = p;\n }\n }\n\n return best;\n}\n\nstring buildStringFromOrder(const vector& ord) {\n string s;\n\n for (int id : ord) {\n if (s.find(t[id]) != string::npos) continue;\n\n if (s.empty()) {\n s = t[id];\n } else {\n int k = overlap_suffix_string(s, t[id]);\n s += t[id].substr(k);\n }\n }\n\n // Safety fallback.\n for (int i = 0; i < M; ++i) {\n if (s.find(t[i]) == string::npos) {\n int k = overlap_suffix_string(s, t[i]);\n s += t[i].substr(k);\n }\n }\n\n return s;\n}\n\npair>> solveTypingDP(const string& s) {\n const int INF = 1e9;\n int L = (int)s.size();\n\n vector> par(L);\n vector dp_prev, dp_cur;\n\n for (int pos = 0; pos < L; ++pos) {\n int c = s[pos] - 'A';\n int C = (int)occ[c].size();\n\n dp_cur.assign(C, INF);\n par[pos].assign(C, -1);\n\n if (pos == 0) {\n pair start = {si, sj};\n for (int i = 0; i < C; ++i) {\n dp_cur[i] = manhattan(start, occ[c][i]) + 1;\n }\n } else {\n int pc = s[pos - 1] - 'A';\n int P = (int)occ[pc].size();\n\n for (int i = 0; i < C; ++i) {\n for (int j = 0; j < P; ++j) {\n int val = dp_prev[j] + manhattan(occ[pc][j], occ[c][i]) + 1;\n if (val < dp_cur[i]) {\n dp_cur[i] = val;\n par[pos][i] = j;\n }\n }\n }\n }\n\n dp_prev.swap(dp_cur);\n }\n\n int bestIdx = 0;\n int bestCost = INF;\n for (int i = 0; i < (int)dp_prev.size(); ++i) {\n if (dp_prev[i] < bestCost) {\n bestCost = dp_prev[i];\n bestIdx = i;\n }\n }\n\n vector> path(L);\n int idx = bestIdx;\n for (int pos = L - 1; pos >= 0; --pos) {\n int c = s[pos] - 'A';\n path[pos] = occ[c][idx];\n idx = par[pos][idx];\n }\n\n return {bestCost, path};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto timeStart = chrono::steady_clock::now();\n\n cin >> N >> M;\n cin >> si >> sj;\n\n Agrid.resize(N);\n for (int i = 0; i < N; ++i) cin >> Agrid[i];\n\n t.resize(M);\n for (int i = 0; i < M; ++i) cin >> t[i];\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n occ[Agrid[i][j] - 'A'].push_back({i, j});\n }\n }\n\n for (int a = 0; a < 26; ++a) {\n for (int b = 0; b < 26; ++b) {\n int best = 1e9;\n for (auto pa : occ[a]) {\n for (auto pb : occ[b]) {\n best = min(best, manhattan(pa, pb));\n }\n }\n mindist_ch[a][b] = best;\n }\n }\n\n vector> ov(M, vector(M, 0));\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < M; ++j) {\n if (i != j) ov[i][j] = overlap_word(t[i], t[j]);\n }\n }\n\n vector> W(M, vector(M, 1e8));\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < M; ++j) if (i != j) {\n int o = ov[i][j];\n int prev = t[i][4] - 'A';\n int cost = 0;\n for (int k = o; k < 5; ++k) {\n int c = t[j][k] - 'A';\n cost += mindist_ch[prev][c] + 1;\n prev = c;\n }\n W[i][j] = cost;\n }\n }\n\n vector startCost(M, 0);\n pair startPos = {si, sj};\n for (int i = 0; i < M; ++i) {\n int cost = 1e9;\n int c0 = t[i][0] - 'A';\n for (auto p : occ[c0]) {\n cost = min(cost, manhattan(startPos, p) + 1);\n }\n for (int k = 1; k < 5; ++k) {\n int a = t[i][k - 1] - 'A';\n int b = t[i][k] - 'A';\n cost += mindist_ch[a][b] + 1;\n }\n startCost[i] = cost;\n }\n\n vector perm = greedyOrder(W, startCost, ov);\n long long curCost = pathCost(perm, W, startCost);\n vector bestPerm = perm;\n long long bestCost = curCost;\n\n // Additional pure-overlap candidate.\n vector> Wover(M, vector(M, 1000000));\n vector zeroStart(M, 0);\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < M; ++j) if (i != j) {\n Wover[i][j] = 5 - ov[i][j];\n }\n }\n vector overlapPerm = greedyOrder(Wover, zeroStart, ov);\n\n // Simulated annealing / local search on estimated typing cost.\n XorShift rng;\n vector np;\n np.reserve(M);\n\n const double TL = 1.78;\n int iter = 0;\n while (true) {\n if ((iter & 1023) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - timeStart).count();\n if (elapsed > TL) break;\n }\n ++iter;\n\n double progress = min(1.0, chrono::duration(chrono::steady_clock::now() - timeStart).count() / TL);\n double temp = 18.0 * pow(0.03 / 18.0, progress);\n\n if (rng.nextInt(100) < 55) {\n int a = rng.nextInt(M);\n int b = rng.nextInt(M);\n if (a == b) continue;\n\n long long d = deltaSwap(perm, a, b, W, startCost);\n if (d <= 0 || rng.nextDouble() < exp(-(double)d / temp)) {\n swap(perm[a], perm[b]);\n curCost += d;\n\n if (curCost < bestCost) {\n bestCost = curCost;\n bestPerm = perm;\n }\n }\n } else {\n int a = rng.nextInt(M);\n int b = rng.nextInt(M);\n if (a == b) continue;\n\n np = perm;\n int val = np[a];\n np.erase(np.begin() + a);\n np.insert(np.begin() + b, val);\n\n long long ncost = pathCost(np, W, startCost);\n long long d = ncost - curCost;\n\n if (d <= 0 || rng.nextDouble() < exp(-(double)d / temp)) {\n perm.swap(np);\n curCost = ncost;\n\n if (curCost < bestCost) {\n bestCost = curCost;\n bestPerm = perm;\n }\n }\n }\n }\n\n vector candidates;\n candidates.push_back(buildStringFromOrder(bestPerm));\n candidates.push_back(buildStringFromOrder(overlapPerm));\n\n // A simple lexicographic-order fallback, surprisingly useful in rare cases.\n vector lexPerm(M);\n iota(lexPerm.begin(), lexPerm.end(), 0);\n candidates.push_back(buildStringFromOrder(lexPerm));\n\n int answerCost = INT_MAX;\n vector> answerPath;\n\n sort(candidates.begin(), candidates.end());\n candidates.erase(unique(candidates.begin(), candidates.end()), candidates.end());\n\n for (const string& s : candidates) {\n auto res = solveTypingDP(s);\n if (res.first < answerCost) {\n answerCost = res.first;\n answerPath = move(res.second);\n }\n }\n\n if ((int)answerPath.size() > 5000) {\n answerPath.resize(5000);\n }\n\n for (auto [i, j] : answerPath) {\n cout << i << ' ' << j << '\\n';\n }\n\n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstatic const int MAXC = 400;\n\nint N, M, C;\ndouble EPSV;\nint MAX_OPS;\nint op_cnt = 0;\n\nstruct Placement {\n vector cells;\n bitset mask;\n};\n\nstruct Obs {\n bitset mask;\n int k;\n double target;\n double weight;\n bool drill;\n int cell;\n int value;\n};\n\nstruct State {\n vector pos;\n double score;\n bitset uni;\n};\n\nvector>> shapes;\nvector> placements;\nvector observations;\n\nvector drilled; // -1 unknown, otherwise exact v(i,j)\n\nmt19937 rng(1234567);\nauto time_start = chrono::steady_clock::now();\n\ndouble elapsed_ms() {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - time_start).count();\n}\n\nint id_of(int i, int j) {\n return i * N + j;\n}\n\npair coord_of(int id) {\n return {id / N, id % N};\n}\n\nint ask_query(const vector& cells) {\n cout << \"q \" << cells.size();\n for (int id : cells) {\n auto [i, j] = coord_of(id);\n cout << ' ' << i << ' ' << j;\n }\n cout << endl;\n cout.flush();\n\n int res;\n if (!(cin >> res)) exit(0);\n op_cnt++;\n return res;\n}\n\nbool ask_answer(bitset mask) {\n for (int id = 0; id < C; id++) {\n if (drilled[id] > 0) mask.set(id);\n }\n\n vector ans;\n for (int id = 0; id < C; id++) {\n if (mask.test(id)) ans.push_back(id);\n }\n\n cout << \"a \" << ans.size();\n for (int id : ans) {\n auto [i, j] = coord_of(id);\n cout << ' ' << i << ' ' << j;\n }\n cout << endl;\n cout.flush();\n\n int res;\n if (!(cin >> res)) exit(0);\n op_cnt++;\n if (res == 1) exit(0);\n return false;\n}\n\nvoid add_divination_observation(const vector& cells, int y) {\n Obs obs;\n obs.mask.reset();\n for (int id : cells) obs.mask.set(id);\n obs.k = (int)cells.size();\n obs.drill = false;\n obs.cell = -1;\n obs.value = -1;\n\n double a = 1.0 - 2.0 * EPSV;\n double target = (y - obs.k * EPSV) / max(1e-9, a);\n target = max(0.0, min(target, (double)M * obs.k));\n\n double var = obs.k * EPSV * (1.0 - EPSV) + 0.35;\n double weight = a * a / max(1e-9, var);\n\n obs.target = target;\n obs.weight = weight;\n observations.push_back(obs);\n}\n\nvoid add_drill_observation(int cell, int val) {\n Obs obs;\n obs.mask.reset();\n obs.mask.set(cell);\n obs.k = 1;\n obs.target = val;\n obs.weight = 10000.0;\n obs.drill = true;\n obs.cell = cell;\n obs.value = val;\n observations.push_back(obs);\n}\n\nvoid do_divination(const vector& cells) {\n if ((int)cells.size() < 2) return;\n int y = ask_query(cells);\n add_divination_observation(cells, y);\n}\n\nint do_drill(int cell) {\n vector q = {cell};\n int v = ask_query(q);\n drilled[cell] = v;\n add_drill_observation(cell, v);\n return v;\n}\n\nvoid build_placements() {\n placements.assign(M, {});\n\n for (int m = 0; m < M; m++) {\n int imax = 0, jmax = 0;\n for (auto [i, j] : shapes[m]) {\n imax = max(imax, i);\n jmax = max(jmax, j);\n }\n\n for (int di = 0; di + imax < N; di++) {\n for (int dj = 0; dj + jmax < N; dj++) {\n Placement p;\n p.mask.reset();\n for (auto [i, j] : shapes[m]) {\n int id = id_of(di + i, dj + j);\n p.cells.push_back(id);\n p.mask.set(id);\n }\n placements[m].push_back(p);\n }\n }\n }\n}\n\nvoid initial_queries() {\n // Whole grid: almost free and gives total amount.\n vector all;\n for (int id = 0; id < C; id++) all.push_back(id);\n do_divination(all);\n\n // Rows.\n for (int i = 0; i < N; i++) {\n vector cells;\n for (int j = 0; j < N; j++) cells.push_back(id_of(i, j));\n do_divination(cells);\n }\n\n // Columns.\n for (int j = 0; j < N; j++) {\n vector cells;\n for (int i = 0; i < N; i++) cells.push_back(id_of(i, j));\n do_divination(cells);\n }\n\n // Coarse blocks.\n int B = 4;\n for (int si = 0; si < N; si += B) {\n for (int sj = 0; sj < N; sj += B) {\n vector cells;\n for (int i = si; i < min(N, si + B); i++) {\n for (int j = sj; j < min(N, sj + B); j++) {\n cells.push_back(id_of(i, j));\n }\n }\n if ((int)cells.size() >= 2) do_divination(cells);\n }\n }\n\n // Random half-grid masks. Cheap global linear measurements.\n int R = (N <= 10 ? 18 : 30);\n vector ids(C);\n iota(ids.begin(), ids.end(), 0);\n for (int r = 0; r < R; r++) {\n shuffle(ids.begin(), ids.end(), rng);\n vector cells;\n int sz = max(2, C / 2);\n for (int t = 0; t < sz; t++) cells.push_back(ids[t]);\n do_divination(cells);\n }\n}\n\nbitset union_of_state(const vector& pos) {\n bitset res;\n res.reset();\n for (int m = 0; m < M; m++) {\n res |= placements[m][pos[m]].mask;\n }\n return res;\n}\n\nbool union_consistent_with_drills(const bitset& mask) {\n for (int id = 0; id < C; id++) {\n if (drilled[id] == -1) continue;\n if (drilled[id] == 0 && mask.test(id)) return false;\n if (drilled[id] > 0 && !mask.test(id)) return false;\n }\n return true;\n}\n\nstring mask_key(const bitset& mask) {\n string s;\n s.reserve(C);\n for (int id = 0; id < C; id++) s.push_back(mask.test(id) ? '1' : '0');\n return s;\n}\n\nvector find_candidates(int want, int time_ms) {\n int O = observations.size();\n\n vector>> contrib(M);\n for (int m = 0; m < M; m++) {\n int P = placements[m].size();\n contrib[m].assign(P, vector(O, 0));\n for (int p = 0; p < P; p++) {\n for (int o = 0; o < O; o++) {\n bitset b = placements[m][p].mask & observations[o].mask;\n contrib[m][p][o] = (unsigned char)b.count();\n }\n }\n }\n\n auto score_of_sums = [&](const vector& sums) {\n double sc = 0.0;\n for (int o = 0; o < O; o++) {\n double e = sums[o] - observations[o].target;\n sc += observations[o].weight * e * e;\n }\n return sc;\n };\n\n vector result;\n auto deadline = chrono::steady_clock::now() + chrono::milliseconds(max(5, time_ms));\n\n int restarts = 0;\n while (restarts < 3 || chrono::steady_clock::now() < deadline) {\n restarts++;\n\n vector pos(M);\n for (int m = 0; m < M; m++) {\n uniform_int_distribution dist(0, (int)placements[m].size() - 1);\n pos[m] = dist(rng);\n }\n\n vector sums(O, 0);\n for (int m = 0; m < M; m++) {\n for (int o = 0; o < O; o++) {\n sums[o] += contrib[m][pos[m]][o];\n }\n }\n\n vector order(M);\n iota(order.begin(), order.end(), 0);\n\n for (int sweep = 0; sweep < 7; sweep++) {\n shuffle(order.begin(), order.end(), rng);\n bool changed = false;\n\n for (int mm = 0; mm < M; mm++) {\n int m = order[mm];\n int oldp = pos[m];\n\n for (int o = 0; o < O; o++) {\n sums[o] -= contrib[m][oldp][o];\n }\n\n int bestp = oldp;\n double bestsc = numeric_limits::infinity();\n\n int P = placements[m].size();\n for (int p = 0; p < P; p++) {\n double sc = 0.0;\n for (int o = 0; o < O; o++) {\n double v = sums[o] + contrib[m][p][o];\n double e = v - observations[o].target;\n sc += observations[o].weight * e * e;\n if (sc >= bestsc) break;\n }\n if (sc < bestsc) {\n bestsc = sc;\n bestp = p;\n }\n }\n\n pos[m] = bestp;\n for (int o = 0; o < O; o++) {\n sums[o] += contrib[m][bestp][o];\n }\n\n if (bestp != oldp) changed = true;\n }\n\n if (!changed) break;\n }\n\n State st;\n st.pos = pos;\n st.score = score_of_sums(sums);\n st.uni = union_of_state(pos);\n result.push_back(st);\n\n if (elapsed_ms() > 2700.0) break;\n }\n\n sort(result.begin(), result.end(), [](const State& a, const State& b) {\n return a.score < b.score;\n });\n\n vector uniq;\n unordered_set seen;\n for (auto &st : result) {\n string key = mask_key(st.uni);\n if (seen.insert(key).second) {\n uniq.push_back(st);\n if ((int)uniq.size() >= want) break;\n }\n }\n\n return uniq;\n}\n\nint choose_drill_cell(const vector& cand, int wrong_same_count) {\n int K = cand.size();\n vector freq(C, 0);\n\n for (auto &st : cand) {\n for (int id = 0; id < C; id++) {\n if (st.uni.test(id)) freq[id]++;\n }\n }\n\n int best = -1;\n int bestScore = -1;\n\n // Prefer uncertain cells among candidate unions.\n for (int id = 0; id < C; id++) {\n if (drilled[id] != -1) continue;\n int f = freq[id];\n if (f == 0 || f == K) continue;\n int score = min(f, K - f);\n if (score > bestScore) {\n bestScore = score;\n best = id;\n }\n }\n\n if (best != -1) return best;\n\n // If all candidates agree, verify predicted positives and nearby negatives.\n if (!cand.empty()) {\n const bitset& mask = cand[0].uni;\n\n if (wrong_same_count % 2 == 0) {\n for (int id = 0; id < C; id++) {\n if (drilled[id] == -1 && mask.test(id)) return id;\n }\n }\n\n // Boundary negatives.\n for (int id = 0; id < C; id++) {\n if (drilled[id] != -1 || mask.test(id)) continue;\n int i = id / N, j = id % N;\n bool near = false;\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d], nj = j + dj[d];\n if (0 <= ni && ni < N && 0 <= nj && nj < N) {\n if (mask.test(id_of(ni, nj))) near = true;\n }\n }\n if (near) return id;\n }\n\n for (int id = 0; id < C; id++) {\n if (drilled[id] == -1 && !mask.test(id)) return id;\n }\n }\n\n for (int id = 0; id < C; id++) {\n if (drilled[id] == -1) return id;\n }\n\n return -1;\n}\n\nvoid fallback_drill_all_and_answer() {\n for (int id = 0; id < C; id++) {\n if (drilled[id] == -1) {\n do_drill(id);\n }\n }\n\n bitset ans;\n ans.reset();\n for (int id = 0; id < C; id++) {\n if (drilled[id] > 0) ans.set(id);\n }\n\n ask_answer(ans);\n exit(0);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> M >> EPSV;\n C = N * N;\n MAX_OPS = 2 * C;\n\n shapes.resize(M);\n for (int m = 0; m < M; m++) {\n int d;\n cin >> d;\n shapes[m].resize(d);\n for (int k = 0; k < d; k++) {\n cin >> shapes[m][k].first >> shapes[m][k].second;\n }\n }\n\n drilled.assign(C, -1);\n build_placements();\n\n initial_queries();\n\n unordered_set guessed;\n int heuristic_drills = 0;\n int guesses = 0;\n int wrong_same_count = 0;\n\n while (true) {\n int unknown = 0;\n for (int id = 0; id < C; id++) if (drilled[id] == -1) unknown++;\n\n // Keep enough operations to drill everything and submit.\n if (op_cnt + unknown + 1 >= MAX_OPS) {\n fallback_drill_all_and_answer();\n }\n\n if (elapsed_ms() > 2700.0 || heuristic_drills >= 55) {\n fallback_drill_all_and_answer();\n }\n\n int tlim = 90;\n if (heuristic_drills == 0) tlim = 350;\n if (elapsed_ms() > 2200.0) tlim = 20;\n\n vector cand = find_candidates(10, tlim);\n if (cand.empty()) {\n fallback_drill_all_and_answer();\n }\n\n bitset bestMask = cand[0].uni;\n string key = mask_key(bestMask);\n\n bool can_try_answer =\n guesses < 25 &&\n op_cnt + unknown + 2 <= MAX_OPS &&\n guessed.find(key) == guessed.end() &&\n union_consistent_with_drills(bestMask);\n\n if (can_try_answer) {\n guessed.insert(key);\n guesses++;\n bool ok = ask_answer(bestMask);\n if (ok) return 0;\n wrong_same_count++;\n }\n\n unknown = 0;\n for (int id = 0; id < C; id++) if (drilled[id] == -1) unknown++;\n if (op_cnt + unknown + 1 >= MAX_OPS) {\n fallback_drill_all_and_answer();\n }\n\n int cell = choose_drill_cell(cand, wrong_same_count);\n if (cell == -1) {\n fallback_drill_all_and_answer();\n }\n\n do_drill(cell);\n heuristic_drills++;\n }\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nstatic const int W = 1000;\nusing ll = long long;\nusing ull = unsigned long long;\n\nstruct Rect {\n int i0, j0, i1, j1;\n};\n\nstruct Option {\n int l, r; // inclusive\n int h;\n ll cost;\n bool stat;\n};\n\nint D, N;\nvector> A;\nvector maxA;\n\ninline int ceil_div(int x, int y) {\n return (x + y - 1) / y;\n}\n\nstruct Scorer {\n int HN = 999 * 1000;\n int VN = 1000 * 999;\n int HW, VW;\n\n Scorer() {\n HW = (HN + 63) >> 6;\n VW = (VN + 63) >> 6;\n }\n\n inline void setbit(vector& b, int idx) const {\n b[idx >> 6] |= 1ULL << (idx & 63);\n }\n\n ll score(const vector>& sol) const {\n vector prevH(HW, 0), prevV(VW, 0), curH(HW), curV(VW);\n ll total = 0;\n\n for (int d = 0; d < D; d++) {\n fill(curH.begin(), curH.end(), 0);\n fill(curV.begin(), curV.end(), 0);\n\n for (int k = 0; k < N; k++) {\n const Rect& r = sol[d][k];\n\n ll area = 1LL * (r.i1 - r.i0) * (r.j1 - r.j0);\n if (area < A[d][k]) total += 100LL * (A[d][k] - area);\n\n if (r.i0 > 0) {\n int row = r.i0 - 1;\n for (int x = r.j0; x < r.j1; x++) {\n setbit(curH, row * 1000 + x);\n }\n }\n if (r.i1 < W) {\n int row = r.i1 - 1;\n for (int x = r.j0; x < r.j1; x++) {\n setbit(curH, row * 1000 + x);\n }\n }\n if (r.j0 > 0) {\n int col = r.j0 - 1;\n for (int y = r.i0; y < r.i1; y++) {\n setbit(curV, y * 999 + col);\n }\n }\n if (r.j1 < W) {\n int col = r.j1 - 1;\n for (int y = r.i0; y < r.i1; y++) {\n setbit(curV, y * 999 + col);\n }\n }\n }\n\n if (d > 0) {\n for (int i = 0; i < HW; i++) total += __builtin_popcountll(prevH[i] ^ curH[i]);\n for (int i = 0; i < VW; i++) total += __builtin_popcountll(prevV[i] ^ curV[i]);\n }\n\n prevH.swap(curH);\n prevV.swap(curV);\n }\n\n return total;\n }\n};\n\nvector> make_empty_solution() {\n return vector>(D, vector(N));\n}\n\nvector> stable_shelf_dp() {\n int K = N + 1;\n int HD = 1001;\n\n vector pref(HD * D * K, 0);\n auto P = [&](int h, int d, int k) -> int& {\n return pref[(h * D + d) * K + k];\n };\n\n for (int h = 1; h <= 1000; h++) {\n for (int d = 0; d < D; d++) {\n P(h, d, 0) = 0;\n for (int k = 0; k < N; k++) {\n P(h, d, k + 1) = P(h, d, k) + ceil_div(A[d][k], h);\n }\n }\n }\n\n vector prefMax(HD * K, 0);\n auto PM = [&](int h, int k) -> int& {\n return prefMax[h * K + k];\n };\n\n for (int h = 1; h <= 1000; h++) {\n PM(h, 0) = 0;\n for (int k = 0; k < N; k++) {\n PM(h, k + 1) = PM(h, k) + ceil_div(maxA[k], h);\n }\n }\n\n auto dyn_feasible = [&](int l, int r, int h) {\n for (int d = 0; d < D; d++) {\n int s = P(h, d, r + 1) - P(h, d, l);\n if (s > W) return false;\n }\n return true;\n };\n\n auto stat_feasible = [&](int l, int r, int h) {\n int s = PM(h, r + 1) - PM(h, l);\n return s <= W;\n };\n\n auto dyn_cost = [&](int l, int r, int h) -> ll {\n int m = r - l + 1;\n if (m <= 1) return 0;\n\n ll res = 0;\n vector a, b;\n a.reserve(m - 1);\n b.reserve(m - 1);\n\n for (int d = 1; d < D; d++) {\n a.clear();\n b.clear();\n\n for (int t = l; t < r; t++) {\n a.push_back(P(h, d - 1, t + 1) - P(h, d - 1, l));\n b.push_back(P(h, d, t + 1) - P(h, d, l));\n }\n\n int i = 0, j = 0, common = 0;\n while (i < (int)a.size() && j < (int)b.size()) {\n if (a[i] == b[j]) {\n common++;\n i++;\n j++;\n } else if (a[i] < b[j]) {\n i++;\n } else {\n j++;\n }\n }\n\n int sym = 2 * (m - 1) - 2 * common;\n res += 1LL * sym * h;\n }\n\n return res;\n };\n\n vector