{"model_name":"gpt-5.2-medium","codes":{"1":{"ahc001":"#include \nusing namespace std;\n\nstatic constexpr int W = 10000;\nstatic constexpr int H = 10000;\n\nstruct Rect {\n int lx, ly, rx, ry; // [lx,rx) x [ly,ry)\n};\n\nstatic inline long long areaLL(const Rect& r) {\n return 1LL * (r.rx - r.lx) * (r.ry - r.ly);\n}\n\nstatic inline bool overlapPosArea(const Rect& a, const Rect& b) {\n int x0 = max(a.lx, b.lx);\n int x1 = min(a.rx, b.rx);\n if (x0 >= x1) return false;\n int y0 = max(a.ly, b.ly);\n int y1 = min(a.ry, b.ry);\n return (y0 < y1);\n}\n\n// splitmix64 RNG\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t nextU64() {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n }\n uint32_t nextU32() { return (uint32_t)nextU64(); }\n int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline double sat(long long r, long long s) {\n long long mn = min(r, s);\n long long mx = max(r, s);\n double a = (double)mn / (double)mx;\n double t = 1.0 - a;\n return 1.0 - t * t;\n}\n\nstruct Solver {\n int n;\n vector x, y;\n vector r;\n vector rects;\n vector p;\n RNG rng;\n\n Solver(): rng(123456789) {}\n\n bool containsPoint(int i, const Rect& rc) const {\n // must contain (x[i]+0.5, y[i]+0.5) <=> cell [x,x+1) x [y,y+1) included\n return (rc.lx <= x[i] && rc.rx >= x[i] + 1 && rc.ly <= y[i] && rc.ry >= y[i] + 1);\n }\n\n bool inBounds(const Rect& rc) const {\n return (0 <= rc.lx && rc.lx < rc.rx && rc.rx <= W &&\n 0 <= rc.ly && rc.ly < rc.ry && rc.ry <= H);\n }\n\n bool validNoOverlap(int i, const Rect& rc) const {\n if (!inBounds(rc)) return false;\n if (!containsPoint(i, rc)) return false;\n for (int j = 0; j < n; j++) if (j != i) {\n if (overlapPosArea(rc, rects[j])) return false;\n }\n return true;\n }\n\n // Directional expansion limits (given current rects, no overlap assumed).\n // Return coordinate limit (exclusive side position) you can expand to without overlap.\n int limitRight(int i) const {\n const Rect& a = rects[i];\n int lim = W;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n // y-overlap?\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.lx >= a.rx) lim = min(lim, b.lx);\n }\n }\n return lim;\n }\n int limitLeft(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.rx <= a.lx) lim = max(lim, b.rx);\n }\n }\n return lim;\n }\n int limitUp(int i) const {\n const Rect& a = rects[i];\n int lim = H;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ly >= a.ry) lim = min(lim, b.ly);\n }\n }\n return lim;\n }\n int limitDown(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ry <= a.ly) lim = max(lim, b.ry);\n }\n }\n return lim;\n }\n\n void init() {\n rects.resize(n);\n p.assign(n, 0.0);\n for (int i = 0; i < n; i++) {\n rects[i] = Rect{x[i], y[i], x[i] + 1, y[i] + 1};\n p[i] = sat(r[i], 1);\n }\n }\n\n void greedyExpand(int rounds = 6) {\n vector ord(n);\n iota(ord.begin(), ord.end(), 0);\n\n for (int rep = 0; rep < rounds; rep++) {\n shuffle(ord.begin(), ord.end(), std::mt19937((unsigned)rng.nextU32()));\n for (int idx = 0; idx < n; idx++) {\n int i = ord[idx];\n for (;;) {\n long long s0 = areaLL(rects[i]);\n if (s0 >= r[i]) break;\n\n double bestGain = 1e-18;\n Rect bestR = rects[i];\n\n Rect cur = rects[i];\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n\n // try each direction: compute max limit; choose coordinate that targets area close to r\n // Right\n {\n int lim = limitRight(i);\n if (lim > cur.rx) {\n long long needW = (r[i] + h - 1) / h;\n int idealRx = cur.lx + (int)needW;\n int newRx = max(cur.rx, idealRx);\n newRx = min(newRx, lim);\n if (newRx != cur.rx) {\n Rect cand = cur;\n cand.rx = newRx;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain && validNoOverlap(i, cand)) {\n bestGain = g;\n bestR = cand;\n }\n }\n }\n }\n // Left\n {\n int lim = limitLeft(i);\n if (lim < cur.lx) {\n long long needW = (r[i] + h - 1) / h;\n int idealLx = cur.rx - (int)needW;\n int newLx = min(cur.lx, idealLx);\n newLx = max(newLx, lim);\n // must still contain point\n newLx = min(newLx, x[i]);\n if (newLx != cur.lx) {\n Rect cand = cur;\n cand.lx = newLx;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain && validNoOverlap(i, cand)) {\n bestGain = g;\n bestR = cand;\n }\n }\n }\n }\n // Up\n {\n int lim = limitUp(i);\n if (lim > cur.ry) {\n long long needH = (r[i] + w - 1) / w;\n int idealRy = cur.ly + (int)needH;\n int newRy = max(cur.ry, idealRy);\n newRy = min(newRy, lim);\n if (newRy != cur.ry) {\n Rect cand = cur;\n cand.ry = newRy;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain && validNoOverlap(i, cand)) {\n bestGain = g;\n bestR = cand;\n }\n }\n }\n }\n // Down\n {\n int lim = limitDown(i);\n if (lim < cur.ly) {\n long long needH = (r[i] + w - 1) / w;\n int idealLy = cur.ry - (int)needH;\n int newLy = min(cur.ly, idealLy);\n newLy = max(newLy, lim);\n newLy = min(newLy, y[i]);\n if (newLy != cur.ly) {\n Rect cand = cur;\n cand.ly = newLy;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain && validNoOverlap(i, cand)) {\n bestGain = g;\n bestR = cand;\n }\n }\n }\n }\n\n if (bestGain <= 1e-18) break;\n rects[i] = bestR;\n p[i] = sat(r[i], areaLL(rects[i]));\n }\n }\n }\n }\n\n // choose width closest to r/h (or height closest to r/w)\n int bestWidthForTarget(long long targetR, int h) const {\n double ideal = (double)targetR / (double)h;\n int w1 = max(1, (int)floor(ideal));\n int w2 = max(1, (int)ceil(ideal));\n long long a1 = 1LL * w1 * h;\n long long a2 = 1LL * w2 * h;\n if (llabs(a1 - targetR) <= llabs(a2 - targetR)) return w1;\n return w2;\n }\n int bestHeightForTarget(long long targetR, int w) const {\n double ideal = (double)targetR / (double)w;\n int h1 = max(1, (int)floor(ideal));\n int h2 = max(1, (int)ceil(ideal));\n long long a1 = 1LL * w * h1;\n long long a2 = 1LL * w * h2;\n if (llabs(a1 - targetR) <= llabs(a2 - targetR)) return h1;\n return h2;\n }\n\n void anneal(double timeLimitSec = 4.85) {\n using clk = std::chrono::high_resolution_clock;\n auto t0 = clk::now();\n\n const double T0 = 0.06;\n const double T1 = 0.0015;\n\n auto nowSec = [&]() -> double {\n return std::chrono::duration(clk::now() - t0).count();\n };\n\n int it = 0;\n while (true) {\n double t = nowSec();\n if (t >= timeLimitSec) break;\n double prog = t / timeLimitSec;\n double temp = T0 * pow(T1 / T0, prog);\n\n int i = (int)(rng.nextU32() % (uint32_t)n);\n Rect cur = rects[i];\n long long s0 = areaLL(cur);\n double p0 = p[i];\n\n double op = rng.nextDouble();\n Rect cand = cur;\n\n if (op < 0.72) {\n // Resize one side\n int side = (int)(rng.nextU32() % 4); // 0:L 1:R 2:D 3:U\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n bool wantExpand = (s0 < r[i]) ? (rng.nextDouble() < 0.85) : (rng.nextDouble() < 0.25);\n\n if (wantExpand) {\n // expanding only (shrinking never helps when below target)\n if (side == 0) { // left\n int lim = limitLeft(i);\n if (lim < cur.lx) {\n long long needW = (r[i] + h - 1) / h;\n int idealLx = cur.rx - (int)needW;\n int minLx = lim;\n int maxLx = cur.lx - 1;\n int newLx;\n if (rng.nextDouble() < 0.55) newLx = max(minLx, min(maxLx, idealLx));\n else newLx = rng.nextInt(minLx, maxLx);\n newLx = min(newLx, x[i]);\n cand.lx = newLx;\n } else continue;\n } else if (side == 1) { // right\n int lim = limitRight(i);\n if (lim > cur.rx) {\n long long needW = (r[i] + h - 1) / h;\n int idealRx = cur.lx + (int)needW;\n int minRx = cur.rx + 1;\n int maxRx = lim;\n int newRx;\n if (rng.nextDouble() < 0.55) newRx = max(minRx, min(maxRx, idealRx));\n else newRx = rng.nextInt(minRx, maxRx);\n cand.rx = newRx;\n } else continue;\n } else if (side == 2) { // down\n int lim = limitDown(i);\n if (lim < cur.ly) {\n long long needH = (r[i] + w - 1) / w;\n int idealLy = cur.ry - (int)needH;\n int minLy = lim;\n int maxLy = cur.ly - 1;\n int newLy;\n if (rng.nextDouble() < 0.55) newLy = max(minLy, min(maxLy, idealLy));\n else newLy = rng.nextInt(minLy, maxLy);\n newLy = min(newLy, y[i]);\n cand.ly = newLy;\n } else continue;\n } else { // up\n int lim = limitUp(i);\n if (lim > cur.ry) {\n long long needH = (r[i] + w - 1) / w;\n int idealRy = cur.ly + (int)needH;\n int minRy = cur.ry + 1;\n int maxRy = lim;\n int newRy;\n if (rng.nextDouble() < 0.55) newRy = max(minRy, min(maxRy, idealRy));\n else newRy = rng.nextInt(minRy, maxRy);\n cand.ry = newRy;\n } else continue;\n }\n } else {\n // Shrink towards target (or random shrink). Shrinking is always overlap-safe.\n if (side == 0) { // move left border right\n int minLx = cur.lx;\n int maxLx = x[i]; // must keep lx<=x\n if (maxLx <= minLx) continue;\n int desiredW = bestWidthForTarget(r[i], h);\n int idealLx = cur.rx - desiredW;\n idealLx = min(idealLx, x[i]);\n idealLx = max(idealLx, cur.lx);\n int newLx;\n if (rng.nextDouble() < 0.65) newLx = idealLx;\n else newLx = rng.nextInt(minLx, maxLx);\n cand.lx = newLx;\n } else if (side == 1) { // move right border left\n int minRx = x[i] + 1;\n int maxRx = cur.rx;\n if (maxRx <= minRx) continue;\n int desiredW = bestWidthForTarget(r[i], h);\n int idealRx = cur.lx + desiredW;\n idealRx = max(idealRx, x[i] + 1);\n idealRx = min(idealRx, cur.rx);\n int newRx;\n if (rng.nextDouble() < 0.65) newRx = idealRx;\n else newRx = rng.nextInt(minRx, maxRx);\n cand.rx = newRx;\n } else if (side == 2) { // move bottom border up\n int minLy = cur.ly;\n int maxLy = y[i];\n if (maxLy <= minLy) continue;\n int desiredH = bestHeightForTarget(r[i], w);\n int idealLy = cur.ry - desiredH;\n idealLy = min(idealLy, y[i]);\n idealLy = max(idealLy, cur.ly);\n int newLy;\n if (rng.nextDouble() < 0.65) newLy = idealLy;\n else newLy = rng.nextInt(minLy, maxLy);\n cand.ly = newLy;\n } else { // move top border down\n int minRy = y[i] + 1;\n int maxRy = cur.ry;\n if (maxRy <= minRy) continue;\n int desiredH = bestHeightForTarget(r[i], w);\n int idealRy = cur.ly + desiredH;\n idealRy = max(idealRy, y[i] + 1);\n idealRy = min(idealRy, cur.ry);\n int newRy;\n if (rng.nextDouble() < 0.65) newRy = idealRy;\n else newRy = rng.nextInt(minRy, maxRy);\n cand.ry = newRy;\n }\n }\n } else {\n // Shift operation (keeps size)\n bool horizontal = (rng.nextDouble() < 0.5);\n if (horizontal) {\n int kmin = max(-cur.lx, (x[i] + 1) - cur.rx);\n int kmax = min(W - cur.rx, x[i] - cur.lx);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int k;\n if (kmin == kmax) {\n if (kmin == 0) continue;\n k = kmin;\n } else {\n // limit huge jumps a bit, but still allow\n int lim = 400;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n }\n cand.lx += k; cand.rx += k;\n } else {\n int kmin = max(-cur.ly, (y[i] + 1) - cur.ry);\n int kmax = min(H - cur.ry, y[i] - cur.ly);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int k;\n if (kmin == kmax) {\n if (kmin == 0) continue;\n k = kmin;\n } else {\n int lim = 400;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n }\n cand.ly += k; cand.ry += k;\n }\n }\n\n if (!validNoOverlap(i, cand)) continue;\n\n long long s1 = areaLL(cand);\n double p1 = sat(r[i], s1);\n double delta = p1 - p0;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp(delta / temp);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (accept) {\n rects[i] = cand;\n p[i] = p1;\n }\n\n ++it;\n }\n }\n\n void solve() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> n;\n x.resize(n); y.resize(n); r.resize(n);\n for (int i = 0; i < n; i++) {\n cin >> x[i] >> y[i] >> r[i];\n }\n\n init();\n greedyExpand(6);\n anneal(4.85);\n\n for (int i = 0; i < n; i++) {\n const Rect& rc = rects[i];\n cout << rc.lx << ' ' << rc.ly << ' ' << rc.rx << ' ' << rc.ry << \"\\n\";\n }\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nstatic const int N = 50;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n explicit XorShift(uint64_t seed = 0) { x ^= seed + 0x9e3779b97f4a7c15ULL; }\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline uint32_t nextU32() { return (uint32_t)nextU64(); }\n inline double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Path {\n vector moves;\n long long score = 0;\n};\n\nint si, sj;\nint tgrid[N][N];\nint pgrid[N][N];\nint Mtiles = 0;\n\nstatic const int di[4] = {-1, 1, 0, 0};\nstatic const int dj[4] = {0, 0, -1, 1};\nstatic const char dc[4] = {'U','D','L','R'};\n\ninline bool inside(int i, int j) { return (unsigned)i < N && (unsigned)j < N; }\n\nstruct Builder {\n vector usedTile;\n int ci, cj;\n long long curScore;\n\n Builder() = default;\n explicit Builder(int M): usedTile(M, 0), ci(0), cj(0), curScore(0) {}\n\n inline void initAtStart() {\n fill(usedTile.begin(), usedTile.end(), 0);\n ci = si; cj = sj;\n curScore = pgrid[ci][cj];\n usedTile[tgrid[ci][cj]] = 1;\n }\n\n inline bool canMoveDir(int d) const {\n int ni = ci + di[d], nj = cj + dj[d];\n if (!inside(ni,nj)) return false;\n int ct = tgrid[ci][cj];\n int nt = tgrid[ni][nj];\n if (nt == ct) return false;\n if (usedTile[nt]) return false;\n return true;\n }\n\n inline int mobilityFrom(int ni, int nj) const {\n int nt = tgrid[ni][nj];\n int cnt = 0;\n for (int d=0; d<4; d++) {\n int xi = ni + di[d], xj = nj + dj[d];\n if (!inside(xi,xj)) continue;\n int xt = tgrid[xi][xj];\n if (xt == nt) continue;\n if (usedTile[xt]) continue;\n cnt++;\n }\n return cnt;\n }\n\n inline int bestNextValueFrom(int ni, int nj) const {\n int nt = tgrid[ni][nj];\n int best = 0;\n for (int d=0; d<4; d++) {\n int xi = ni + di[d], xj = nj + dj[d];\n if (!inside(xi,xj)) continue;\n int xt = tgrid[xi][xj];\n if (xt == nt) continue;\n if (usedTile[xt]) continue;\n best = max(best, pgrid[xi][xj]);\n }\n return best;\n }\n\n inline void applyMoveDir(int d) {\n int ni = ci + di[d], nj = cj + dj[d];\n int nt = tgrid[ni][nj];\n usedTile[nt] = 1;\n ci = ni; cj = nj;\n curScore += pgrid[ci][cj];\n }\n};\n\nPath buildPathFromPrefix(const vector& prefix, int cutLen, XorShift &rng, double temp) {\n Builder b(Mtiles);\n b.initAtStart();\n\n Path res;\n res.moves.reserve(2600);\n\n // Replay prefix[0..cutLen)\n for (int k = 0; k < cutLen; k++) {\n char c = prefix[k];\n int d = 0;\n if (c=='U') d=0; else if (c=='D') d=1; else if (c=='L') d=2; else d=3;\n if (!b.canMoveDir(d)) break; // safety (shouldn't happen for best prefix)\n b.applyMoveDir(d);\n res.moves.push_back(c);\n }\n\n // Grow tail with stochastic greedy\n while (true) {\n int candDirs[4];\n double hval[4];\n int csz = 0;\n\n for (int d=0; d<4; d++) {\n if (!b.canMoveDir(d)) continue;\n int ni = b.ci + di[d], nj = b.cj + dj[d];\n int immediate = pgrid[ni][nj];\n int mob = b.mobilityFrom(ni, nj);\n int bestNext = b.bestNextValueFrom(ni, nj);\n\n double H = (double)immediate + 10.0 * (double)mob + 0.5 * (double)bestNext;\n candDirs[csz] = d;\n hval[csz] = H;\n csz++;\n }\n if (csz == 0) break;\n\n // softmax sampling\n double mx = hval[0];\n for (int i=1;i= 2600) break; // just a safe cap\n }\n\n res.score = b.curScore;\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> si >> sj;\n int mxT = 0;\n for (int i=0;i> tgrid[i][j];\n mxT = max(mxT, tgrid[i][j]);\n }\n for (int i=0;i> pgrid[i][j];\n\n Mtiles = mxT + 1;\n\n XorShift rng(1234567);\n\n auto start = chrono::high_resolution_clock::now();\n auto timeLimit = 1.95; // seconds\n\n Path best;\n best.score = -1;\n\n // Initial multi-start\n for (int it=0; it<200; it++) {\n double temp = 60.0 - 40.0 * (it / 200.0); // 60 -> 20\n auto cand = buildPathFromPrefix({}, 0, rng, temp);\n if (cand.score > best.score) best = std::move(cand);\n }\n\n // Cut & regrow local search until time is up\n long long iter = 0;\n while (true) {\n iter++;\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > timeLimit) break;\n\n int L = (int)best.moves.size();\n int cutLen = (L == 0) ? 0 : rng.nextInt(0, L);\n\n // temperature decreases over time (more greedy later)\n double progress = min(1.0, elapsed / timeLimit);\n double temp = 50.0 * (1.0 - progress) + 10.0; // 60 -> 10\n\n auto cand = buildPathFromPrefix(best.moves, cutLen, rng, temp);\n if (cand.score > best.score) best = std::move(cand);\n }\n\n // Output moves as a single string\n string out;\n out.reserve(best.moves.size());\n for (char c: best.moves) out.push_back(c);\n cout << out << \"\\n\";\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nstatic constexpr int N = 30;\nstatic constexpr int V = N * N;\n\nstruct EdgeRef {\n bool horiz; // true: h[i][j] between (i,j)-(i,j+1), false: v[i][j] between (i,j)-(i+1,j)\n int i, j;\n};\n\nstatic inline int vid(int i, int j) { return i * N + j; }\nstatic inline pair vpos(int id){ return {id / N, id % N}; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Estimated weights\n static double h[N][N-1];\n static double v[N-1][N];\n static int hc[N][N-1];\n static int vc[N-1][N];\n\n for(int i=0;i unif01(0.0, 1.0);\n\n auto clamp_w = [](double x)->double{\n if (x < 100.0) return 100.0;\n if (x > 10000.0) return 10000.0;\n return x;\n };\n\n auto get_base_w = [&](int i1,int j1,int i2,int j2)->double{\n if (i1 == i2) {\n int i = i1;\n int j = min(j1, j2);\n return h[i][j];\n } else {\n int i = min(i1, i2);\n int j = j1;\n return v[i][j];\n }\n };\n\n auto add_smoothing = [&](double beta){\n // Horizontal smoothing per row\n for(int i=0;i> si >> sj >> ti >> tj)) return 0;\n int s = vid(si, sj), t = vid(ti, tj);\n\n // Exploration schedule (early queries explore more)\n // eps: max relative perturbation amplitude\n double eps = 0.0;\n if (k < 250) {\n double x = 1.0 - (double)k / 250.0; // from 1 -> 0\n eps = 0.30 * x; // up to 30% perturbation early\n }\n\n // Dijkstra\n static double dist[V];\n static int prevv[V];\n static char prevMove[V];\n\n const double INF = 1e100;\n for(int i=0;i;\n priority_queue, greater

> pq;\n dist[s] = 0;\n pq.push({0.0, s});\n\n auto relax = [&](int from, int to, char mv, double w){\n double nd = dist[from] + w;\n if (nd < dist[to]) {\n dist[to] = nd;\n prevv[to] = from;\n prevMove[to] = mv;\n pq.push({nd, to});\n }\n };\n\n while(!pq.empty()){\n auto [d,u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n if (u == t) break;\n auto [i,j] = vpos(u);\n\n // neighbor cost = base_w * (1 + noise) for exploration\n auto perturbed = [&](double base)->double{\n if (eps <= 0.0) return base;\n double r = (unif01(rng) * 2.0 - 1.0) * eps; // [-eps, eps]\n double w = base * (1.0 + r);\n if (w < 1.0) w = 1.0;\n return w;\n };\n\n if (i > 0) {\n double base = v[i-1][j];\n relax(u, vid(i-1,j), 'U', perturbed(base));\n }\n if (i+1 < N) {\n double base = v[i][j];\n relax(u, vid(i+1,j), 'D', perturbed(base));\n }\n if (j > 0) {\n double base = h[i][j-1];\n relax(u, vid(i,j-1), 'L', perturbed(base));\n }\n if (j+1 < N) {\n double base = h[i][j];\n relax(u, vid(i,j+1), 'R', perturbed(base));\n }\n }\n\n // Reconstruct path (also collect edges)\n string path;\n vector used_edges;\n if (prevv[t] == -1 && s != t) {\n // Should never happen on a connected grid; fallback to Manhattan.\n int ci=si, cj=sj;\n while (ci < ti) { path.push_back('D'); ci++; }\n while (ci > ti) { path.push_back('U'); ci--; }\n while (cj < tj) { path.push_back('R'); cj++; }\n while (cj > tj) { path.push_back('L'); cj--; }\n // Build used_edges from this path\n ci=si; cj=sj;\n for(char c: path){\n int ni=ci, nj=cj;\n if (c=='U') ni--;\n if (c=='D') ni++;\n if (c=='L') nj--;\n if (c=='R') nj++;\n if (ci == ni) {\n used_edges.push_back({true, ci, min(cj,nj)});\n } else {\n used_edges.push_back({false, min(ci,ni), cj});\n }\n ci=ni; cj=nj;\n }\n } else {\n // Walk back from t to s\n int cur = t;\n vector rev;\n vector> nodes_rev;\n nodes_rev.push_back(vpos(cur));\n while(cur != s){\n char mv = prevMove[cur];\n rev.push_back(mv);\n cur = prevv[cur];\n nodes_rev.push_back(vpos(cur));\n }\n reverse(rev.begin(), rev.end());\n path.assign(rev.begin(), rev.end());\n\n // nodes_rev is reversed along backtracking; rebuild forward nodes to extract edges\n // nodes_rev currently: [t, ..., s]; reverse:\n reverse(nodes_rev.begin(), nodes_rev.end()); // [s, ..., t]\n for (int idx = 0; idx+1 < (int)nodes_rev.size(); idx++){\n auto [i1,j1] = nodes_rev[idx];\n auto [i2,j2] = nodes_rev[idx+1];\n if (i1 == i2) used_edges.push_back({true, i1, min(j1,j2)});\n else used_edges.push_back({false, min(i1,i2), j1});\n }\n }\n\n cout << path << \"\\n\" << flush;\n\n long long obs;\n cin >> obs;\n\n // Update model\n double pred = 0.0;\n for (auto &e: used_edges){\n pred += e.horiz ? h[e.i][e.j] : v[e.i][e.j];\n }\n if (pred < 1.0) pred = 1.0;\n\n double r = (double)obs / pred;\n // cap extreme ratios (stability)\n r = max(0.2, min(5.0, r));\n double logr = log(r);\n\n // Multiplicative per-edge update with decaying learning rate\n const double base_lr = 0.45; // overall aggressiveness\n for (auto &e: used_edges){\n int cnt;\n double *wptr;\n if (e.horiz) { cnt = ++hc[e.i][e.j]; wptr = &h[e.i][e.j]; }\n else { cnt = ++vc[e.i][e.j]; wptr = &v[e.i][e.j]; }\n\n double lr = base_lr / sqrt((double)cnt + 2.0); // decays\n // w *= exp(lr * log(r))\n double nw = (*wptr) * exp(lr * logr);\n *wptr = clamp_w(nw);\n }\n\n // Periodic smoothing to exploit row/column base structure\n if ((k+1) % 25 == 0) {\n double beta = 0.10;\n if (k >= 300) beta = 0.06;\n if (k >= 700) beta = 0.04;\n add_smoothing(beta);\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20;\nstatic const int LMIN = 2;\nstatic const int LMAX = 12;\nstatic const int ALPHA = 9; // A-H + '.'\n\nstruct XorShift64 {\n uint64_t x;\n explicit XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n inline uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n inline double next_double() {\n // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline uint8_t ch2code(char ch) {\n if (ch == '.') return 8;\n return (uint8_t)(ch - 'A'); // A..H -> 0..7\n}\nstatic inline char code2ch(uint8_t c) {\n if (c == 8) return '.';\n return (char)('A' + c);\n}\n\nstruct LineHash {\n // cyclic line length N, but keep expanded 2N for wrap\n array dig{};\n array pref{}; // base-9\n const array* pow9;\n\n void rebuild_pref() {\n pref[0] = 0;\n for (int i = 0; i < 2*N; i++) {\n pref[i+1] = pref[i] * ALPHA + (uint64_t)dig[i];\n }\n }\n\n inline uint64_t substr_val(int start, int len) const {\n // start in [0,N-1], len in [2,12], start+len <= N-1+12 <= 31 < 40 OK\n uint64_t a = pref[start + len];\n uint64_t b = pref[start] * (*pow9)[len];\n return a - b;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, M;\n cin >> Nin >> M;\n // N is fixed to 20\n vector s(M);\n for (int i = 0; i < M; i++) cin >> s[i];\n\n // Precompute powers of 9\n array pow9{};\n pow9[0] = 1;\n for (int i = 1; i <= LMAX; i++) pow9[i] = pow9[i-1] * (uint64_t)ALPHA;\n\n // Encode a string (A..H only) to key = val*16 + len\n auto encode_string_key = [&](const string& t) -> uint64_t {\n uint64_t v = 0;\n for (char ch : t) v = v * ALPHA + (uint64_t)ch2code(ch);\n return v * 16ull + (uint64_t)t.size();\n };\n\n // Compress unique strings; duplicates share satisfaction\n unordered_map key2id;\n key2id.reserve((size_t)M * 2);\n vector weight; // multiplicity per unique string\n vector keys; // id -> key\n for (int i = 0; i < M; i++) {\n uint64_t k = encode_string_key(s[i]);\n auto it = key2id.find(k);\n if (it == key2id.end()) {\n int id = (int)weight.size();\n key2id.emplace(k, id);\n weight.push_back(1);\n keys.push_back(k);\n } else {\n weight[it->second]++;\n }\n }\n int U = (int)weight.size();\n\n // Precompute affected (start,len) list for each position 0..N-1\n vector>> affected(N);\n for (int pos = 0; pos < N; pos++) {\n vector> v;\n v.reserve(77);\n for (int len = LMIN; len <= LMAX; len++) {\n for (int t = 0; t < len; t++) {\n int start = pos - t;\n start %= N;\n if (start < 0) start += N;\n v.emplace_back(start, len);\n }\n }\n affected[pos] = move(v);\n }\n\n XorShift64 rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n // Grid and line hashes\n array, N> grid{};\n array rows, cols;\n for (int i = 0; i < N; i++) {\n rows[i].pow9 = &pow9;\n cols[i].pow9 = &pow9;\n }\n\n auto rebuild_all_lines_from_grid = [&]() {\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n rows[r].dig[c] = grid[r][c];\n rows[r].dig[c+N] = grid[r][c];\n }\n rows[r].rebuild_pref();\n }\n for (int c = 0; c < N; c++) {\n for (int r = 0; r < N; r++) {\n cols[c].dig[r] = grid[r][c];\n cols[c].dig[r+N] = grid[r][c];\n }\n cols[c].rebuild_pref();\n }\n };\n\n vector occ(U, 0);\n long long satWeight = 0;\n\n auto clear_and_recount_occ = [&]() {\n fill(occ.begin(), occ.end(), 0);\n satWeight = 0;\n\n auto add_key = [&](uint64_t key) {\n auto it = key2id.find(key);\n if (it == key2id.end()) return;\n int id = it->second;\n if (occ[id]++ == 0) satWeight += weight[id];\n };\n\n for (int r = 0; r < N; r++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = rows[r].substr_val(start, len);\n uint64_t key = v * 16ull + (uint64_t)len;\n add_key(key);\n }\n }\n }\n for (int c = 0; c < N; c++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = cols[c].substr_val(start, len);\n uint64_t key = v * 16ull + (uint64_t)len;\n add_key(key);\n }\n }\n }\n };\n\n auto update_occ_by_key_change = [&](uint64_t oldKey, uint64_t newKey, long long &delta) {\n if (oldKey == newKey) return;\n auto itOld = key2id.find(oldKey);\n if (itOld != key2id.end()) {\n int id = itOld->second;\n int before = occ[id];\n occ[id]--;\n if (before > 0 && occ[id] == 0) delta -= weight[id];\n }\n auto itNew = key2id.find(newKey);\n if (itNew != key2id.end()) {\n int id = itNew->second;\n int before = occ[id];\n occ[id]++;\n if (before == 0) delta += weight[id];\n }\n };\n\n // Do change cell (r,c) to newv, updating row/col hashes and occ/satWeight, return delta\n auto doChange = [&](int r, int c, uint8_t newv) -> long long {\n uint8_t oldv = grid[r][c];\n if (oldv == newv) return 0;\n\n long long delta = 0;\n\n // --- Row r affected at position c ---\n const auto &affRow = affected[c];\n array oldKeysRow;\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first;\n int len = affRow[i].second;\n uint64_t v = rows[r].substr_val(start, len);\n oldKeysRow[i] = v * 16ull + (uint64_t)len;\n }\n // apply change to row hash\n rows[r].dig[c] = newv;\n rows[r].dig[c+N] = newv;\n rows[r].rebuild_pref();\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first;\n int len = affRow[i].second;\n uint64_t v = rows[r].substr_val(start, len);\n uint64_t newKey = v * 16ull + (uint64_t)len;\n update_occ_by_key_change(oldKeysRow[i], newKey, delta);\n }\n\n // --- Col c affected at position r ---\n const auto &affCol = affected[r];\n array oldKeysCol;\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first;\n int len = affCol[i].second;\n uint64_t v = cols[c].substr_val(start, len);\n oldKeysCol[i] = v * 16ull + (uint64_t)len;\n }\n // apply change to col hash\n cols[c].dig[r] = newv;\n cols[c].dig[r+N] = newv;\n cols[c].rebuild_pref();\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first;\n int len = affCol[i].second;\n uint64_t v = cols[c].substr_val(start, len);\n uint64_t newKey = v * 16ull + (uint64_t)len;\n update_occ_by_key_change(oldKeysCol[i], newKey, delta);\n }\n\n // finalize grid\n grid[r][c] = newv;\n satWeight += delta;\n return delta;\n };\n\n // Initialize grid randomly with A-H (no dots for SA start)\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) grid[r][c] = (uint8_t)rng.next_int(8);\n rebuild_all_lines_from_grid();\n clear_and_recount_occ();\n\n array, N> bestGrid = grid;\n long long bestSat = satWeight;\n\n // Simulated Annealing\n auto t0 = chrono::high_resolution_clock::now();\n const double TL_SA = 2.75; // seconds for SA\n const double Tstart = 5.0;\n const double Tend = 0.10;\n\n long long totalWeight = M;\n\n auto elapsed_sec = [&]() -> double {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - t0).count();\n };\n\n while (true) {\n double e = elapsed_sec();\n if (e >= TL_SA) break;\n double progress = e / TL_SA;\n double T = Tstart * pow(Tend / Tstart, progress);\n\n int r = rng.next_int(N);\n int c = rng.next_int(N);\n uint8_t oldv = grid[r][c];\n uint8_t newv = (uint8_t)rng.next_int(8);\n if (newv == oldv) continue;\n\n long long delta = doChange(r, c, newv);\n\n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / T);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (!accept) {\n doChange(r, c, oldv); // revert\n } else {\n if (satWeight > bestSat) {\n bestSat = satWeight;\n bestGrid = grid;\n if (bestSat == totalWeight) {\n // found full satisfaction; still keep SA running a bit is okay,\n // but we can stop early to save time for dot phase.\n // break;\n }\n }\n }\n }\n\n // Restore best\n grid = bestGrid;\n rebuild_all_lines_from_grid();\n clear_and_recount_occ();\n\n // Dot-removal bonus phase if all satisfied\n const double TL_TOTAL = 2.95;\n if (satWeight == totalWeight) {\n vector cells(N*N);\n iota(cells.begin(), cells.end(), 0);\n\n int rounds = 8;\n for (int rd = 0; rd < rounds; rd++) {\n // stop if close to time limit\n if (elapsed_sec() >= TL_TOTAL) break;\n // shuffle\n for (int i = (int)cells.size() - 1; i > 0; i--) {\n int j = rng.next_int(i + 1);\n swap(cells[i], cells[j]);\n }\n for (int idx : cells) {\n if (elapsed_sec() >= TL_TOTAL) break;\n int r = idx / N, c = idx % N;\n uint8_t oldv = grid[r][c];\n if (oldv == 8) continue;\n doChange(r, c, 8); // try dot\n if (satWeight != totalWeight) {\n doChange(r, c, oldv); // rollback\n }\n }\n }\n }\n\n // Output\n for (int r = 0; r < N; r++) {\n string line;\n line.reserve(N);\n for (int c = 0; c < N; c++) line.push_back(code2ch(grid[r][c]));\n cout << line << \"\\n\";\n }\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct HopcroftKarp {\n int nL, nR;\n vector> adj;\n vector dist;\n vector pairU, pairV;\n\n HopcroftKarp(int nL=0, int nR=0) { init(nL, nR); }\n\n void init(int _nL, int _nR) {\n nL = _nL; nR = _nR;\n adj.assign(nL, {});\n dist.assign(nL, 0);\n pairU.assign(nL, -1);\n pairV.assign(nR, -1);\n }\n void add_edge(int u, int v) { adj[u].push_back(v); }\n\n bool bfs() {\n queue q;\n for (int u = 0; u < nL; u++) {\n if (pairU[u] == -1) {\n dist[u] = 0;\n q.push(u);\n } else dist[u] = -1;\n }\n bool foundFree = false;\n while (!q.empty()) {\n int u = q.front(); q.pop();\n for (int v : adj[u]) {\n int u2 = pairV[v];\n if (u2 != -1 && dist[u2] == -1) {\n dist[u2] = dist[u] + 1;\n q.push(u2);\n }\n if (u2 == -1) foundFree = true;\n }\n }\n return foundFree;\n }\n\n bool dfs(int u) {\n for (int v : adj[u]) {\n int u2 = pairV[v];\n if (u2 == -1 || (dist[u2] == dist[u] + 1 && dfs(u2))) {\n pairU[u] = v;\n pairV[v] = u;\n return true;\n }\n }\n dist[u] = -1;\n return false;\n }\n\n int max_matching() {\n int matching = 0;\n while (bfs()) {\n for (int u = 0; u < nL; u++) {\n if (pairU[u] == -1) {\n if (dfs(u)) matching++;\n }\n }\n }\n return matching;\n }\n\n // Konig: min vertex cover from max matching.\n // Returns (coverLeft, coverRight)\n pair, vector> min_vertex_cover() {\n // BFS from unmatched left along alternating paths:\n vector visL(nL, 0), visR(nR, 0);\n queue q;\n for (int u = 0; u < nL; u++) {\n if (pairU[u] == -1) {\n visL[u] = 1;\n q.push(u);\n }\n }\n while (!q.empty()) {\n int u = q.front(); q.pop();\n for (int v : adj[u]) {\n // traverse only non-matching edges L->R\n if (pairU[u] == v) continue;\n if (!visR[v]) {\n visR[v] = 1;\n int u2 = pairV[v];\n if (u2 != -1 && !visL[u2]) {\n visL[u2] = 1;\n q.push(u2);\n }\n }\n }\n }\n // min vertex cover = (Left not visited) union (Right visited)\n vector coverL(nL, 0), coverR(nR, 0);\n for (int u = 0; u < nL; u++) if (!visL[u]) coverL[u] = 1;\n for (int v = 0; v < nR; v++) if (visR[v]) coverR[v] = 1;\n return {coverL, coverR};\n }\n};\n\nstatic const long long INFLL = (1LL<<60);\n\nstruct Solver {\n int N, si, sj;\n vector g;\n\n int startId;\n vector cellCost; // N*N, cost to enter cell (0 for obstacles unused)\n\n vector rowSeg, colSeg; // N*N -> seg id, or -1\n int R = 0, C = 0;\n vector> rowCells, colCells; // seg -> list of cell ids\n\n // row adjacency to column segments, and cell id of intersection\n vector> adjV;\n vector> adjCell;\n\n inline int id(int i, int j) const { return i*N + j; }\n inline int ri(int id) const { return id / N; }\n inline int rj(int id) const { return id % N; }\n inline bool isRoad(int id) const { return g[ri(id)][rj(id)] != '#'; }\n\n vector dijkstra_dist(int src) {\n int V = N*N;\n vector dist(V, INFLL);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n while (!pq.empty()) {\n auto [d,u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n int ui = ri(u), uj = rj(u);\n static const int di[4] = {-1,1,0,0};\n static const int dj[4] = {0,0,-1,1};\n for (int k=0;k<4;k++){\n int vi = ui + di[k], vj = uj + dj[k];\n if (vi<0||vi>=N||vj<0||vj>=N) continue;\n int v = id(vi,vj);\n if (!isRoad(v)) continue;\n long long nd = d + cellCost[v];\n if (nd < dist[v]) {\n dist[v] = nd;\n pq.push({nd, v});\n }\n }\n }\n return dist;\n }\n\n string dijkstra_path(int src, int dst) {\n if (src == dst) return \"\";\n int V = N*N;\n vector dist(V, INFLL);\n vector prev(V, -1);\n vector prevDir(V, 0);\n\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n\n while (!pq.empty()) {\n auto [d,u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n if (u == dst) break;\n int ui = ri(u), uj = rj(u);\n // order doesn't matter\n // U,D,L,R moves from u to v\n static const int di[4] = {-1,1,0,0};\n static const int dj[4] = {0,0,-1,1};\n static const char mv[4] = {'U','D','L','R'};\n for (int k=0;k<4;k++){\n int vi = ui + di[k], vj = uj + dj[k];\n if (vi<0||vi>=N||vj<0||vj>=N) continue;\n int v = id(vi,vj);\n if (!isRoad(v)) continue;\n long long nd = d + cellCost[v];\n if (nd < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n prevDir[v] = mv[k];\n pq.push({nd, v});\n }\n }\n }\n\n // backtrack\n string rev;\n int cur = dst;\n while (cur != src) {\n int p = prev[cur];\n if (p == -1) {\n // should not happen (roads are connected), fallback empty\n return \"\";\n }\n rev.push_back(prevDir[cur]);\n cur = p;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n }\n\n void build_segments() {\n int V = N*N;\n rowSeg.assign(V, -1);\n colSeg.assign(V, -1);\n\n // row segments\n R = 0;\n for (int i=0;i choose_targets_via_vertex_cover() {\n HopcroftKarp hk(R, C);\n hk.adj = adjV;\n hk.pairU.assign(R, -1);\n hk.pairV.assign(C, -1);\n hk.dist.assign(R, 0);\n hk.max_matching();\n auto [coverL0, coverR0] = hk.min_vertex_cover();\n\n // start already visits its row/col segments\n int sRow = rowSeg[startId];\n int sCol = colSeg[startId];\n if (sRow >= 0) coverL0[sRow] = 0;\n if (sCol >= 0) coverR0[sCol] = 0;\n\n vector leftList, rightList;\n leftList.reserve(R);\n rightList.reserve(C);\n vector lMap(R, -1), rMap(C, -1);\n for (int u=0;u> edgeCell2(nL);\n for (int i=0;i> alignedCell(nL);\n for (int i=0;i needL(R, 0), needR(C, 0);\n for (int u=0;u doneL(R, 0), doneR(C, 0);\n vector selectedCell(N*N, 0);\n vector targets;\n\n // select matched edges first (cover 2 vertices)\n for (int i=0;ij)\n int cell = -1;\n for (int t=0;t<(int)hk2.adj[i].size();t++){\n if (hk2.adj[i][t] == j) { cell = alignedCell[i][t]; break; }\n }\n if (cell == -1) continue;\n int u = leftList[i];\n int v = rightList[j];\n doneL[u] = 1;\n doneR[v] = 1;\n if (!selectedCell[cell]) {\n selectedCell[cell] = 1;\n targets.push_back(cell);\n }\n }\n\n auto heuristic = [&](int cell)->int {\n int i = ri(cell), j = rj(cell);\n return abs(i - si) + abs(j - sj) + cellCost[cell]; // small is better\n };\n\n // cover remaining left vertices\n for (int u=0;u> compute_dist_matrix(const vector& nodes) {\n int M = (int)nodes.size();\n vector> distM(M, vector(M, INT_MAX/4));\n for (int a=0;a= INFLL/2) ? (INT_MAX/4) : (int)dist[nodes[b]];\n }\n }\n return distM;\n }\n\n vector build_tour_order(const vector>& d, int M, double timeLimitSec=1.3) {\n // nodes: 0 is start, 1..M-1 are targets. Need tour [0 ... 0].\n vector unvis;\n for (int i=1;i tour;\n tour.reserve(M+1);\n tour.push_back(0);\n int cur = 0;\n while (!unvis.empty()) {\n int bestIdx = -1;\n int bestCost = INT_MAX;\n for (int k=0;k<(int)unvis.size();k++){\n int nx = unvis[k];\n int c = d[cur][nx];\n if (c < bestCost) { bestCost = c; bestIdx = k; }\n }\n int nx = unvis[bestIdx];\n tour.push_back(nx);\n cur = nx;\n unvis.erase(unvis.begin() + bestIdx);\n }\n tour.push_back(0); // close\n\n // local search: relocation with simulated annealing-lite\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n auto now = chrono::high_resolution_clock::now;\n auto t0 = now();\n auto elapsed = [&](){\n return chrono::duration(now()-t0).count();\n };\n\n auto tourCost = [&](){\n long long s=0;\n for (int i=0;i+1<(int)tour.size();i++) s += d[tour[i]][tour[i+1]];\n return s;\n };\n\n long long bestC = tourCost();\n vector bestTour = tour;\n\n int m = (int)tour.size(); // = M+1\n uniform_int_distribution posDist(1, m-2);\n\n double T0 = 3000.0, T1 = 50.0;\n\n while (elapsed() < timeLimitSec) {\n int i = posDist(rng);\n int j = posDist(rng);\n if (i == j) continue;\n\n // move node at position i to after position j\n int x = tour[i];\n int a = tour[i-1], b = tour[i+1];\n\n // remove contribution\n long long delta = 0;\n delta += d[a][b] - d[a][x] - d[x][b];\n\n // build indices after removal\n if (j > i) j--; // after erasing i, j shifts left\n // insert after j -> between c and d2\n int c = tour[j];\n int d2 = tour[j+1];\n delta += d[c][x] + d[x][d2] - d[c][d2];\n\n if (delta >= 0) {\n double e = elapsed() / timeLimitSec;\n double T = T0 * (1.0 - e) + T1 * e;\n double prob = exp(- (double)delta / T);\n uniform_real_distribution ur(0.0, 1.0);\n if (ur(rng) > prob) continue;\n }\n\n // apply move\n int node = tour[i];\n tour.erase(tour.begin() + i);\n tour.insert(tour.begin() + (j+1), node);\n\n long long cst = 0;\n for (int k=0;k+1<(int)tour.size();k++) cst += d[tour[k]][tour[k+1]];\n if (cst < bestC) {\n bestC = cst;\n bestTour = tour;\n }\n }\n return bestTour;\n }\n\n void solve() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> si >> sj;\n g.resize(N);\n for (int i=0;i> g[i];\n\n startId = id(si,sj);\n\n cellCost.assign(N*N, 0);\n for (int i=0;i targets = choose_targets_via_vertex_cover();\n\n // build node list for TSP-like ordering: node[0]=start, then targets\n vector nodes;\n nodes.reserve(1 + targets.size());\n nodes.push_back(startId);\n // remove duplicates and also remove start if accidentally present\n {\n vector used(N*N, 0);\n used[startId] = 1;\n for (int c : targets) {\n if (!used[c]) {\n used[c] = 1;\n nodes.push_back(c);\n }\n }\n }\n\n int M = (int)nodes.size();\n // distance matrix\n auto distM = compute_dist_matrix(nodes);\n\n // decide visiting order (closed tour in node indices)\n auto tourIdx = build_tour_order(distM, M, 1.35);\n\n // reconstruct full move string by shortest paths between consecutive nodes\n string ans;\n ans.reserve(200000);\n\n for (int t=0;t+1<(int)tourIdx.size();t++){\n int uIdx = tourIdx[t];\n int vIdx = tourIdx[t+1];\n int u = nodes[uIdx];\n int v = nodes[vIdx];\n string path = dijkstra_path(u, v);\n ans += path;\n }\n\n cout << ans << \"\\n\";\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nstruct FastRand {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int mod) { return (int)(next_u64() % (uint64_t)mod); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector> d(N, vector(K));\n vector sumD(N, 0);\n for (int i = 0; i < N; i++) {\n long long s = 0;\n for (int k = 0; k < K; k++) {\n cin >> d[i][k];\n s += d[i][k];\n }\n sumD[i] = (int)s;\n }\n\n vector> out(N);\n vector indeg0(N, 0);\n for (int e = 0; e < R; e++) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg0[v]++;\n }\n\n // critical path length (longest path to end in #tasks)\n vector crit(N, 1);\n for (int i = N - 1; i >= 0; i--) {\n int best = 1;\n for (int v : out[i]) best = max(best, 1 + crit[v]);\n crit[i] = best;\n }\n\n // average difficulty (for exploration target)\n double avgD = 0.0;\n for (int i = 0; i < N; i++) avgD += sumD[i];\n avgD /= max(1, N);\n\n vector indeg = indeg0;\n vector task_state(N, 0); // 0:not started, 1:running, 2:done\n\n vector member_task(M, -1);\n vector start_day(M, -1);\n\n // member scalar-skill bounds & estimate\n const double SK_MIN = 0.0, SK_MAX = 2000.0;\n vector lb(M, SK_MIN), ub(M, SK_MAX), est(M, 60.0);\n vector done_cnt(M, 0);\n\n FastRand rng;\n\n auto predict_time = [&](int i, int j) -> double {\n double w = (double)sumD[i] - est[j];\n if (w <= 0.0) return 1.0;\n return max(1.0, w);\n };\n\n auto update_member = [&](int j, int i, int t_obs) {\n double p = (double)sumD[i];\n if (t_obs <= 1) {\n // If t==1, w may be 0 or up to 4 (with r=-3 and max(1, w+r))\n lb[j] = max(lb[j], p - 4.0);\n } else {\n // t ~= w + r, r in [-3,3]\n // => w in [t-3, t+3]\n // => s = p - w in [p-(t+3), p-(t-3)]\n lb[j] = max(lb[j], p - (double)(t_obs + 3));\n ub[j] = min(ub[j], p - (double)(t_obs - 3));\n }\n if (ub[j] < lb[j]) ub[j] = lb[j];\n\n double mid = 0.5 * (lb[j] + ub[j]);\n mid = min(SK_MAX, max(SK_MIN, mid));\n\n // smooth to reduce noise impact\n est[j] = 0.6 * est[j] + 0.4 * mid;\n est[j] = min(SK_MAX, max(SK_MIN, est[j]));\n done_cnt[j]++;\n };\n\n int day = 0;\n while (true) {\n day++;\n\n // list free members\n vector free_members;\n free_members.reserve(M);\n for (int j = 0; j < M; j++) if (member_task[j] == -1) free_members.push_back(j);\n\n // list available tasks\n vector avail;\n avail.reserve(N);\n for (int i = 0; i < N; i++) {\n if (task_state[i] == 0 && indeg[i] == 0) avail.push_back(i);\n }\n\n // sort by (critical desc, difficulty desc, index asc)\n sort(avail.begin(), avail.end(), [&](int a, int b) {\n if (crit[a] != crit[b]) return crit[a] > crit[b];\n if (sumD[a] != sumD[b]) return sumD[a] > sumD[b];\n return a < b;\n });\n\n // assign greedily\n vector> assigns; // (member, task), 0-based\n assigns.reserve(free_members.size());\n vector used(N, 0);\n\n const int SCAN = 200; // scan top candidates\n for (int j : free_members) {\n if (avail.empty()) break;\n\n int best_i = -1;\n double best_score = -1e100;\n\n int lim = min((int)avail.size(), SCAN);\n\n // Exploration for first few tasks of each member:\n // choose closer-to-average difficulty among high-priority tasks\n bool explore = (done_cnt[j] < 3);\n\n // small random epsilon exploration too\n if (rng.next_double() < 0.03 && !avail.empty()) {\n // pick random among top lim\n int pick = avail[rng.next_int(lim)];\n if (!used[pick]) {\n best_i = pick;\n }\n }\n\n if (best_i == -1) {\n for (int idx = 0; idx < lim; idx++) {\n int i = avail[idx];\n if (used[i]) continue;\n\n double tp = predict_time(i, j);\n double sc;\n if (explore) {\n // prioritize critical tasks but keep time moderate by targeting avg difficulty\n sc = 5.0 * (double)crit[i]\n - 0.15 * tp\n - 0.02 * fabs((double)sumD[i] - avgD);\n } else {\n sc = 5.0 * (double)crit[i] - tp + 0.01 * (double)sumD[i];\n }\n\n if (sc > best_score) {\n best_score = sc;\n best_i = i;\n }\n }\n }\n\n if (best_i == -1) continue;\n\n used[best_i] = 1;\n task_state[best_i] = 1;\n member_task[j] = best_i;\n start_day[j] = day;\n assigns.push_back({j, best_i});\n }\n\n // output\n cout << assigns.size();\n for (auto [j, i] : assigns) {\n cout << ' ' << (j + 1) << ' ' << (i + 1);\n }\n cout << \"\\n\" << flush;\n\n // input results\n string line;\n if (!std::getline(cin, line)) return 0;\n if (line.size() == 0) { // sometimes after >> there is a leftover newline; read again\n if (!std::getline(cin, line)) return 0;\n }\n if (line == \"-1\") return 0;\n\n stringstream ss(line);\n int nfin;\n ss >> nfin;\n for (int z = 0; z < nfin; z++) {\n int a;\n ss >> a;\n int j = a - 1;\n int i = member_task[j];\n if (i < 0) continue; // safety\n\n int t_obs = day - start_day[j] + 1;\n\n // finish\n member_task[j] = -1;\n start_day[j] = -1;\n task_state[i] = 2;\n\n // update indegrees\n for (int v : out[i]) indeg[v]--;\n\n // update estimate\n update_member(j, i, t_obs);\n }\n\n // (optional) visualization prediction output as comments (ignored by judge)\n // You can uncomment if you want in local runs:\n /*\n for (int j = 0; j < M; j++) {\n cout << \"#s \" << (j+1);\n // no per-dim estimation here; just dump scalar replicated (for visualization only)\n for (int k = 0; k < K; k++) cout << ' ' << (int)round(est[j] / K);\n cout << \"\\n\";\n }\n cout << flush;\n */\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n};\nstatic inline int manhattan(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\n\nstruct Order {\n int id; // 1..1000\n Point P, D;\n int intra; // dist(P,D)\n int proxy; // dist(O,P)+intra+dist(D,O)\n};\n\nstruct XorShift64 {\n uint64_t x = 88172645463325252ull;\n explicit XorShift64(uint64_t seed = 0) { if (seed) x = seed; }\n uint64_t next() {\n uint64_t y = x;\n y ^= y << 7;\n y ^= y >> 9;\n return x = y;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next() % (uint64_t)(hi - lo + 1));\n }\n double next_double() {\n // [0,1)\n return (next() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic const Point OFFICE{400, 400};\n\nstruct Solver {\n vector orders; // size 1000, index 0..999\n vector pool; // candidate order indices (0..999)\n vector used; // used[idx] in current solution\n\n XorShift64 rng;\n\n Solver() : used(1000, 0), rng(1234567) {}\n\n int cost_sequence(const vector& seq) const {\n // seq contains order indices in [0..999], size m=50\n int m = (int)seq.size();\n int T = 0;\n if (m == 0) return 0;\n // office -> first pickup\n T += manhattan(OFFICE, orders[seq[0]].P);\n // internal + transitions\n for (int i = 0; i < m; i++) {\n const Order& oi = orders[seq[i]];\n T += oi.intra;\n if (i + 1 < m) {\n const Order& oj = orders[seq[i + 1]];\n T += manhattan(oi.D, oj.P);\n } else {\n T += manhattan(oi.D, OFFICE);\n }\n }\n return T;\n }\n\n // delta if we insert order idx into seq at position pos (0..m)\n int insertion_delta(const vector& seq, int idx, int pos) const {\n int m = (int)seq.size();\n const Order& o = orders[idx];\n\n Point prev = (pos == 0) ? OFFICE : orders[seq[pos - 1]].D;\n Point next = (pos == m) ? OFFICE : orders[seq[pos]].P;\n\n int before = manhattan(prev, next);\n int after = manhattan(prev, o.P) + o.intra + manhattan(o.D, next);\n return after - before;\n }\n\n // delta if we remove seq[pos] from seq (seq size m>=1)\n int removal_delta(const vector& seq, int pos) const {\n int m = (int)seq.size();\n int idx = seq[pos];\n const Order& o = orders[idx];\n\n Point prev = (pos == 0) ? OFFICE : orders[seq[pos - 1]].D;\n Point next = (pos == m - 1) ? OFFICE : orders[seq[pos + 1]].P;\n\n int before = manhattan(prev, o.P) + o.intra + manhattan(o.D, next);\n int after = manhattan(prev, next);\n return after - before; // typically negative improvement\n }\n\n pair best_insertion_pos(const vector& seq, int idx) const {\n // returns (bestPos, bestDelta)\n int m = (int)seq.size();\n int bestPos = 0;\n int bestDelta = INT_MAX;\n for (int pos = 0; pos <= m; pos++) {\n int d = insertion_delta(seq, idx, pos);\n if (d < bestDelta) {\n bestDelta = d;\n bestPos = pos;\n }\n }\n return {bestPos, bestDelta};\n }\n\n void do_relocate_improve(vector& seq) const {\n // first-improvement relocate\n int m = (int)seq.size();\n int curCost = cost_sequence(seq);\n for (int i = 0; i < m; i++) {\n int idx = seq[i];\n vector tmp;\n tmp.reserve(m-1);\n for (int k = 0; k < m; k++) if (k != i) tmp.push_back(seq[k]);\n\n int deltaRemove = removal_delta(seq, i);\n // Now insert idx into tmp best position\n auto [posIns, deltaIns] = best_insertion_pos(tmp, idx);\n int newCost = curCost + deltaRemove + deltaIns;\n\n if (newCost < curCost) {\n tmp.insert(tmp.begin() + posIns, idx);\n seq.swap(tmp);\n return;\n }\n }\n }\n\n void do_2opt_improve(vector& seq) const {\n // first-improvement 2-opt using full recomputation of affected segment cost (small n=50)\n int m = (int)seq.size();\n int cur = cost_sequence(seq);\n\n for (int l = 0; l < m - 1; l++) {\n for (int r = l + 1; r < m; r++) {\n vector tmp = seq;\n reverse(tmp.begin() + l, tmp.begin() + r + 1);\n int nc = cost_sequence(tmp);\n if (nc < cur) {\n seq.swap(tmp);\n return;\n }\n }\n }\n }\n\n void local_optimize(vector& seq, int passes = 8) const {\n for (int p = 0; p < passes; p++) {\n int before = cost_sequence(seq);\n do_2opt_improve(seq);\n do_relocate_improve(seq);\n int after = cost_sequence(seq);\n if (after >= before) break;\n }\n }\n\n vector greedy_init(int m = 50) {\n vector seq;\n seq.reserve(m);\n fill(used.begin(), used.end(), 0);\n\n Point cur = OFFICE;\n const double alpha = 0.25; // bias toward ending closer to office\n\n for (int t = 0; t < m; t++) {\n int best = -1;\n double bestScore = 1e100;\n for (int idx : pool) if (!used[idx]) {\n const Order& o = orders[idx];\n double s = manhattan(cur, o.P) + o.intra + alpha * manhattan(o.D, OFFICE);\n if (s < bestScore) {\n bestScore = s;\n best = idx;\n }\n }\n if (best == -1) break;\n used[best] = 1;\n seq.push_back(best);\n cur = orders[best].D;\n }\n // If pool too small, fill from all (shouldn't happen if pool>=m)\n for (int i = 0; (int)seq.size() < m; i++) if (!used[i]) {\n used[i] = 1;\n seq.push_back(i);\n }\n return seq;\n }\n\n void solve() {\n // Build pool: best K by proxy\n vector idxs(1000);\n iota(idxs.begin(), idxs.end(), 0);\n sort(idxs.begin(), idxs.end(), [&](int i, int j){\n return orders[i].proxy < orders[j].proxy;\n });\n int K = 420;\n pool.assign(idxs.begin(), idxs.begin() + K);\n\n // Initial solution\n vector seq = greedy_init(50);\n local_optimize(seq, 10);\n\n // Rebuild used from seq (since local optimize doesn't change membership)\n fill(used.begin(), used.end(), 0);\n for (int x : seq) used[x] = 1;\n\n int bestCost = cost_sequence(seq);\n vector bestSeq = seq;\n\n // SA loop: remove one + insert one\n auto start = chrono::steady_clock::now();\n const double TL = 1.90; // seconds\n int iter = 0;\n\n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed >= TL) break;\n double frac = elapsed / TL;\n\n // temperature schedule\n double T0 = 1200.0, T1 = 20.0;\n double temp = T0 * pow(T1 / T0, frac);\n\n // pick a random remove position\n int m = (int)seq.size();\n int remPos = rng.next_int(0, m - 1);\n int remIdx = seq[remPos];\n\n // pick a random candidate to insert (prefer pool)\n int insIdx = -1;\n for (int tries = 0; tries < 20; tries++) {\n int cand = pool[rng.next_int(0, (int)pool.size() - 1)];\n if (!used[cand]) { insIdx = cand; break; }\n }\n if (insIdx == -1) {\n // fallback search\n int cand = rng.next_int(0, 999);\n if (!used[cand]) insIdx = cand;\n }\n if (insIdx == -1) continue;\n\n int curCost = cost_sequence(seq);\n\n // create seq2 without remPos\n vector seq2;\n seq2.reserve(m - 1);\n for (int i = 0; i < m; i++) if (i != remPos) seq2.push_back(seq[i]);\n\n int deltaRemove = removal_delta(seq, remPos);\n auto [posIns, deltaIns] = best_insertion_pos(seq2, insIdx);\n int newCost = curCost + deltaRemove + deltaIns;\n int delta = newCost - curCost;\n\n bool accept = false;\n if (delta <= 0) accept = true;\n else {\n double prob = exp(-delta / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n // apply\n used[remIdx] = 0;\n used[insIdx] = 1;\n seq2.insert(seq2.begin() + posIns, insIdx);\n seq.swap(seq2);\n\n // occasional local optimization\n if ((iter % 60) == 0) local_optimize(seq, 3);\n\n int c = cost_sequence(seq);\n if (c < bestCost) {\n bestCost = c;\n bestSeq = seq;\n }\n }\n\n iter++;\n }\n\n // finalize with best found + stronger local opt\n seq = bestSeq;\n local_optimize(seq, 20);\n\n // Output\n // m and list of chosen order IDs (1..1000)\n int m = 50;\n cout << m;\n for (int idx : seq) cout << ' ' << orders[idx].id;\n cout << \"\\n\";\n\n // Route: office, then for each order pickup->delivery, then office\n vector route;\n route.reserve(2*m + 2);\n route.push_back(OFFICE);\n for (int idx : seq) {\n route.push_back(orders[idx].P);\n route.push_back(orders[idx].D);\n }\n route.push_back(OFFICE);\n\n cout << (int)route.size();\n for (auto &p : route) cout << ' ' << p.x << ' ' << p.y;\n cout << \"\\n\";\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Solver solver;\n solver.orders.resize(1000);\n for (int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n solver.orders[i].id = i + 1;\n solver.orders[i].P = Point{a,b};\n solver.orders[i].D = Point{c,d};\n solver.orders[i].intra = manhattan(solver.orders[i].P, solver.orders[i].D);\n solver.orders[i].proxy = manhattan(OFFICE, solver.orders[i].P)\n + solver.orders[i].intra\n + manhattan(solver.orders[i].D, OFFICE);\n }\n\n solver.solve();\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct DSU {\n int n;\n int comps;\n vector p, sz;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n comps = n;\n p.resize(n);\n sz.assign(n, 1);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){\n while(p[a]!=a){\n p[a] = p[p[a]];\n a = p[a];\n }\n return a;\n }\n bool same(int a,int b){ return find(a)==find(b); }\n bool merge(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 comps--;\n return true;\n }\n};\n\nstatic constexpr int N = 400;\nstatic constexpr int M = 1995;\nstatic constexpr int INF = 1e9;\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> x[i] >> y[i];\n }\n vector u(M), v(M);\n for(int i=0;i> u[i] >> v[i];\n }\n\n // Precompute d_i\n vector d(M);\n for(int i=0;i ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a, int b){\n if(d[a] != d[b]) return d[a] < d[b];\n return a < b;\n });\n vector inGuide(M, 0);\n {\n DSU tmp(N);\n int cnt = 0;\n for(int id: ord){\n if(tmp.merge(u[id], v[id])){\n inGuide[id] = 1;\n if(++cnt == N-1) break;\n }\n }\n }\n\n DSU chosen(N);\n\n auto feasible_if_reject = [&](int i, int &minOutA, int &minOutB, int &kComps)->bool{\n // Contract current chosen-DSU components.\n vector root(N);\n for(int vv=0; vv comp_id(N, -1);\n int k = 0;\n for(int vv=0; vv minout(k, INF);\n\n for(int j=i+1; j> li;\n\n int ans = 0;\n if(chosen.same(u[i], v[i])){\n ans = 0;\n } else {\n int minOutA, minOutB, kComps;\n bool ok = feasible_if_reject(i, minOutA, minOutB, kComps);\n if(!ok){\n // Must take to keep possibility of final connectivity\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n // Heuristic acceptance\n long double rem = (long double)(M - i);\n long double urgency = (kComps <= 1 ? 0.0L : (long double)(kComps - 1) / rem);\n\n long double alpha = inGuide[i] ? 1.90L : 1.45L;\n alpha += 2.20L * urgency;\n\n // If this edge's d is close to the best remaining outgoing from either endpoint component,\n // make it a bit more attractive.\n if(minOutA < INF && (long double)d[i] <= 1.15L * (long double)minOutA) alpha += 0.20L;\n if(minOutB < INF && (long double)d[i] <= 1.15L * (long double)minOutB) alpha += 0.20L;\n\n if(alpha > 3.0L) alpha = 3.0L;\n\n if(li <= (int)llround(1.05L * (long double)d[i])) {\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else if((long double)li <= alpha * (long double)d[i]) {\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n ans = 0;\n }\n }\n }\n\n cout << ans << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nstatic const int H = 30, W = 30;\nstatic const int TURNS = 300;\n\nstruct Pet {\n int x, y, t;\n};\nstruct Human {\n int x, y;\n};\n\nstruct BFSResult {\n int dist[H+1][W+1];\n char firstDir[H+1][W+1]; // 'U','D','L','R' first move from start\n};\n\nstatic inline bool in_grid(int x, int y) {\n return 1 <= x && x <= H && 1 <= y && y <= W;\n}\n\nint dx4[4] = {-1, +1, 0, 0};\nint dy4[4] = {0, 0, -1, +1};\nchar dirU[4] = {'U','D','L','R'};\nchar dirL[4] = {'u','d','l','r'};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N; cin >> N;\n vector pets(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].x >> pets[i].y >> pets[i].t;\n }\n int M; cin >> M;\n vector humans(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].x >> humans[i].y;\n }\n\n // Wall grid: impassable if true\n static bool wall[H+1][W+1];\n for (int x = 1; x <= H; x++) for (int y = 1; y <= W; y++) wall[x][y] = false;\n\n // ---- Choose sanctuary rectangle ----\n // Interior: [x1..x2], [y1..y2]\n int best_x1=6, best_y1=6, bestS=20;\n long long bestScore = LLONG_MIN;\n\n auto countPetsInside = [&](int x1,int y1,int S)->int{\n int x2 = x1 + S - 1;\n int y2 = y1 + S - 1;\n int c = 0;\n for (auto &p: pets) {\n if (x1 <= p.x && p.x <= x2 && y1 <= p.y && p.y <= y2) c++;\n }\n return c;\n };\n\n auto humanTravelCost = [&](int x1,int y1,int S)->long long{\n int x2 = x1 + S - 1;\n int y2 = y1 + S - 1;\n long long sum = 0;\n for (auto &h: humans) {\n int tx = min(max(h.x, x1), x2);\n int ty = min(max(h.y, y1), y2);\n sum += llabs(h.x - tx) + llabs(h.y - ty);\n }\n return sum;\n };\n\n // Ensure we have a 1-cell perimeter inside grid:\n // x1>=2,y1>=2, x2<=29,y2<=29 so that x1-1..x2+1 inside [1..30]\n for (int S = 26; S >= 16; S--) {\n for (int x1 = 2; x1 + S - 1 <= 29; x1++) {\n for (int y1 = 2; y1 + S - 1 <= 29; y1++) {\n int petsIn = countPetsInside(x1,y1,S);\n if (petsIn > 2) continue;\n long long cost = humanTravelCost(x1,y1,S);\n long long area = 1LL*S*S;\n // Heuristic evaluation\n long long score = area*1000LL - petsIn*250000LL - cost*20LL;\n if (score > bestScore) {\n bestScore = score;\n best_x1=x1; best_y1=y1; bestS=S;\n }\n }\n }\n }\n\n int x1 = best_x1, y1 = best_y1;\n int x2 = x1 + bestS - 1;\n int y2 = y1 + bestS - 1;\n\n // Gate on bottom perimeter at mid y (within [y1..y2])\n int gate_x = x2 + 1;\n int gate_y = (y1 + y2) / 2;\n\n auto inInterior = [&](int x,int y)->bool{\n return x1 <= x && x <= x2 && y1 <= y && y <= y2;\n };\n\n // Build perimeter cell list (unique)\n vector> perimeter;\n {\n set> s;\n // top row x1-1, y in [y1-1..y2+1]\n for (int y = y1-1; y <= y2+1; y++) s.insert({x1-1, y});\n // bottom row x2+1\n for (int y = y1-1; y <= y2+1; y++) s.insert({x2+1, y});\n // left col y1-1, x in [x1..x2]\n for (int x = x1; x <= x2; x++) s.insert({x, y1-1});\n // right col y2+1\n for (int x = x1; x <= x2; x++) s.insert({x, y2+1});\n\n for (auto &e: s) perimeter.push_back(e);\n }\n\n auto isPerimeterCell = [&](int x,int y)->bool{\n // membership test (small; use formula instead)\n bool onTop = (x == x1-1 && (y1-1) <= y && y <= (y2+1));\n bool onBot = (x == x2+1 && (y1-1) <= y && y <= (y2+1));\n bool onLeft = (y == y1-1 && x1 <= x && x <= x2);\n bool onRight = (y == y2+1 && x1 <= x && x <= x2);\n return onTop || onBot || onLeft || onRight;\n };\n\n auto bfsFrom = [&](int sx,int sy)->BFSResult{\n BFSResult res;\n const int INF = 1e9;\n for (int x=1;x<=H;x++) for (int y=1;y<=W;y++){\n res.dist[x][y]=INF;\n res.firstDir[x][y]='?';\n }\n deque> q;\n res.dist[sx][sy]=0;\n res.firstDir[sx][sy]='.';\n q.push_back({sx,sy});\n\n while(!q.empty()){\n auto [x,y]=q.front(); q.pop_front();\n for(int k=0;k<4;k++){\n int nx=x+dx4[k], ny=y+dy4[k];\n if(!in_grid(nx,ny)) continue;\n if(wall[nx][ny]) continue;\n if(res.dist[nx][ny] != INF) continue;\n res.dist[nx][ny] = res.dist[x][y]+1;\n if(x==sx && y==sy) res.firstDir[nx][ny] = dirU[k];\n else res.firstDir[nx][ny] = res.firstDir[x][y];\n q.push_back({nx,ny});\n }\n }\n return res;\n };\n\n auto placeableWallCell = [&](int tx,int ty,\n const vector> &petCnt,\n const vector> &humanCnt)->bool{\n if(!in_grid(tx,ty)) return false;\n if(humanCnt[tx][ty] > 0) return false;\n if(petCnt[tx][ty] > 0) return false;\n // adjacent pet forbidden\n for(int k=0;k<4;k++){\n int ax=tx+dx4[k], ay=ty+dy4[k];\n if(in_grid(ax,ay) && petCnt[ax][ay] > 0) return false;\n }\n return true;\n };\n\n enum Phase { BUILD=0, CLOSE=1, DONE=2 };\n Phase phase = BUILD;\n\n for (int turn = 0; turn < TURNS; turn++) {\n // Occupancy at start of turn\n vector> petCnt(H+1, vector(W+1, 0));\n vector> humanCnt(H+1, vector(W+1, 0));\n for (auto &p: pets) petCnt[p.x][p.y]++;\n for (auto &h: humans) humanCnt[h.x][h.y]++;\n\n int petsInside = 0;\n for (auto &p: pets) if (inInterior(p.x,p.y)) petsInside++;\n\n bool allHumansInside = true;\n for (auto &h: humans) if (!inInterior(h.x,h.y)) { allHumansInside=false; break; }\n\n bool perimeterComplete = true;\n for (auto &cell: perimeter) {\n int px=cell.first, py=cell.second;\n if (px==gate_x && py==gate_y) continue; // gate allowed open\n if (!wall[px][py]) { perimeterComplete=false; break; }\n }\n\n if (phase == BUILD) {\n if (perimeterComplete && allHumansInside && petsInside==0) phase = CLOSE;\n } else if (phase == CLOSE) {\n // if already closed by some chance\n if (wall[gate_x][gate_y]) phase = DONE;\n }\n\n vector action(M, '.');\n set> plannedWalls;\n set> plannedMoveDest;\n\n // Precompute BFS for each human (small grid)\n vector bfsRes(M);\n for (int i=0;ibool{\n if(!in_grid(tx,ty)) return false;\n if(wall[tx][ty]) return false;\n if(plannedWalls.count({tx,ty})) return false;\n plannedMoveDest.insert({tx,ty});\n // Determine direction from current to (tx,ty)\n int x=humans[i].x, y=humans[i].y;\n for(int k=0;k<4;k++){\n if(x+dx4[k]==tx && y+dy4[k]==ty){\n action[i] = dirU[k];\n return true;\n }\n }\n return false;\n };\n\n auto planMoveToward = [&](int i, int tx, int ty)->void{\n auto &b = bfsRes[i];\n if(!in_grid(tx,ty)) return;\n if(b.dist[tx][ty] >= (int)1e9) return;\n char fd = b.firstDir[tx][ty];\n if(fd=='.' || fd=='?') return;\n int x=humans[i].x, y=humans[i].y;\n int k=-1;\n for(int kk=0;kk<4;kk++) if(dirU[kk]==fd) { k=kk; break; }\n if(k==-1) return;\n int nx=x+dx4[k], ny=y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) return;\n if(plannedWalls.count({nx,ny})) return;\n plannedMoveDest.insert({nx,ny});\n action[i]=fd;\n };\n\n auto planWallAt = [&](int i, int wx, int wy)->bool{\n // must be adjacent\n int x=humans[i].x, y=humans[i].y;\n int k=-1;\n for(int kk=0;kk<4;kk++){\n if(x+dx4[kk]==wx && y+dy4[kk]==wy){ k=kk; break; }\n }\n if(k==-1) return false;\n\n if(plannedMoveDest.count({wx,wy})) return false;\n if(!placeableWallCell(wx,wy, petCnt, humanCnt)) return false;\n\n // Ok plan\n plannedWalls.insert({wx,wy});\n action[i]=dirL[k];\n return true;\n };\n\n auto chooseInteriorTarget = [&](const Human &h)->pair{\n int tx = min(max(h.x, x1), x2);\n int ty = min(max(h.y, y1), y2);\n // bias toward gate-adjacent interior cell to simplify ingress\n // interior cell just above the bottom gate:\n int gx_in = x2;\n int gy_in = gate_y;\n // If reachable, prefer it\n // (No BFS here; selection only. Movement uses BFS)\n return {gx_in, gy_in};\n };\n\n auto findBuildTask = [&](int i, bool allowGate)->tuple{\n // returns (bestDist, workX,workY, wallX,wallY), bestDist=INF if none\n const int INF = 1e9;\n int bestD=INF, bestWX=-1,bestWY=-1, bestWallX=-1,bestWallY=-1;\n auto &b = bfsRes[i];\n\n for (auto &cell: perimeter) {\n int wx=cell.first, wy=cell.second;\n if (!allowGate && wx==gate_x && wy==gate_y) continue;\n if (wall[wx][wy]) continue;\n\n // Choose adjacent work position p\n for(int k=0;k<4;k++){\n int px=wx+dx4[k], py=wy+dy4[k];\n if(!in_grid(px,py)) continue;\n if(wall[px][py]) continue;\n int d = b.dist[px][py];\n if(d >= INF) continue;\n // Prefer building from inside\n int penalty = inInterior(px,py) ? 0 : 3;\n int val = d + penalty;\n if(val < bestD){\n bestD=val;\n bestWX=px; bestWY=py;\n bestWallX=wx; bestWallY=wy;\n }\n }\n }\n return {bestD,bestWX,bestWY,bestWallX,bestWallY};\n };\n\n // ---- Plan actions ----\n for (int i=0;i= (int)1e9) { action[i]='.'; continue; }\n\n if (humans[i].x == workX && humans[i].y == workY) {\n // Try to place that wall; if impossible now, try any adjacent required wall\n if (planWallAt(i, wallX, wallY)) continue;\n\n bool done = false;\n for(int k=0;k<4;k++){\n int wx=humans[i].x+dx4[k], wy=humans[i].y+dy4[k];\n if(!in_grid(wx,wy)) continue;\n if(!isPerimeterCell(wx,wy)) continue;\n if(wx==gate_x && wy==gate_y) continue;\n if(wall[wx][wy]) continue;\n if(planWallAt(i, wx, wy)) { done=true; break; }\n }\n if(!done) action[i]='.';\n } else {\n planMoveToward(i, workX, workY);\n }\n continue;\n }\n\n // Perimeter complete but not closing yet: wait (pets may still be inside / humans not all inside)\n action[i]='.';\n }\n\n // Output actions\n string out;\n out.reserve(M);\n for (int i=0;i mv(N);\n for (int i=0;i> mv[i])) return 0;\n }\n // Update pet positions according to given move strings\n for (int i=0;i\nusing namespace std;\n\nstatic constexpr int H = 20;\nstatic constexpr int W = 20;\nstatic constexpr int N = H * W;\nstatic constexpr int LMAX = 200;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n\n vector h(H), v(H - 1);\n for (int i = 0; i < H; i++) cin >> h[i]; // length 19\n for (int i = 0; i < H - 1; i++) cin >> v[i]; // length 20\n\n auto id = [&](int i, int j) { return i * W + j; };\n int s = id(si, sj);\n int t = id(ti, tj);\n\n // Precompute deterministic move results for each cell and action.\n // dir: 0=U,1=D,2=L,3=R\n int mv[N][4];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) {\n int cur = id(i, j);\n // U\n if (i == 0 || v[i - 1][j] == '1') mv[cur][0] = cur;\n else mv[cur][0] = id(i - 1, j);\n // D\n if (i == H - 1 || v[i][j] == '1') mv[cur][1] = cur;\n else mv[cur][1] = id(i + 1, j);\n // L\n if (j == 0 || h[i][j - 1] == '1') mv[cur][2] = cur;\n else mv[cur][2] = id(i, j - 1);\n // R\n if (j == W - 1 || h[i][j] == '1') mv[cur][3] = cur;\n else mv[cur][3] = id(i, j + 1);\n }\n\n // BFS distances to target (ignoring forgetting).\n const int INF = 1e9;\n vector dist(N, INF);\n deque dq;\n dist[t] = 0;\n dq.push_back(t);\n while (!dq.empty()) {\n int x = dq.front(); dq.pop_front();\n int d = dist[x];\n // neighbors: those that can move into x\n // easiest: just traverse undirected edges by checking mv both ways\n // but N is small, do direct adjacency by coordinates:\n int i = x / W, j = x % W;\n // from (i-1,j) via D\n if (i > 0) {\n int y = id(i - 1, j);\n if (mv[y][1] == x && dist[y] == INF) { dist[y] = d + 1; dq.push_back(y); }\n }\n // from (i+1,j) via U\n if (i + 1 < H) {\n int y = id(i + 1, j);\n if (mv[y][0] == x && dist[y] == INF) { dist[y] = d + 1; dq.push_back(y); }\n }\n // from (i,j-1) via R\n if (j > 0) {\n int y = id(i, j - 1);\n if (mv[y][3] == x && dist[y] == INF) { dist[y] = d + 1; dq.push_back(y); }\n }\n // from (i,j+1) via L\n if (j + 1 < W) {\n int y = id(i, j + 1);\n if (mv[y][2] == x && dist[y] == INF) { dist[y] = d + 1; dq.push_back(y); }\n }\n }\n\n // Precompute (1-p)^d\n vector pow1p(401, 0.0);\n pow1p[0] = 1.0;\n double q = 1.0 - p;\n for (int d = 1; d <= 400; d++) pow1p[d] = pow1p[d - 1] * q;\n\n // Heuristic table F[len][d]\n // Approximate additional expected score from a cell at distance d when current length is len.\n static double F[LMAX + 1][401];\n for (int len = 0; len <= LMAX; len++) {\n for (int d = 0; d <= 400; d++) {\n if (d == INF) { F[len][d] = 0.0; continue; }\n if (len + d > LMAX) F[len][d] = 0.0;\n else {\n int arrive_t = len + d;\n // true score if arrive at turn arrive_t (1-indexed).\n // Here arrive_t is length after d more actions, so it's that turn count.\n double reward = 401.0 - arrive_t;\n // rough success probability scale\n F[len][d] = reward * pow1p[d];\n }\n }\n }\n\n struct Node {\n int len = 0;\n double score = 0.0; // exact expected score accumulated so far\n double key = 0.0; // for beam ranking\n array path{};\n array prob{}; // distribution over non-absorbed states; prob[t] is kept 0\n };\n\n auto compute_key = [&](const Node& nd) -> double {\n double k = nd.score;\n int len = nd.len;\n // Add heuristic from remaining mass.\n for (int s0 = 0; s0 < N; s0++) {\n float ps = nd.prob[s0];\n if (ps <= 0.0f) continue;\n int d = dist[s0];\n if (d > 400) continue;\n k += (double)ps * F[len][d];\n }\n return k;\n };\n\n auto extend = [&](const Node& cur, int a) -> Node {\n Node nxt;\n nxt.len = cur.len + 1;\n nxt.score = cur.score;\n nxt.path = cur.path;\n static const char dc[4] = {'U','D','L','R'};\n nxt.path[cur.len] = dc[a];\n nxt.prob.fill(0.0f);\n\n double reach = 0.0;\n // Update distribution\n for (int x = 0; x < N; x++) {\n float px = cur.prob[x];\n if (px <= 0.0f) continue;\n\n // forget -> stay\n nxt.prob[x] += px * (float)p;\n\n // remember -> attempt move\n int y = mv[x][a];\n double mvprob = (double)px * (1.0 - p);\n if (y == t) reach += mvprob;\n else nxt.prob[y] += (float)mvprob;\n }\n\n // Contribution of reaching at this turn\n int turn = nxt.len; // 1-indexed effectively\n nxt.score += reach * (401.0 - turn);\n\n // Keep target prob at 0 (absorbed handled via score only)\n nxt.prob[t] = 0.0f;\n\n nxt.key = compute_key(nxt);\n return nxt;\n };\n\n // Beam search\n int BEAM_WIDTH = 150;\n\n Node init;\n init.len = 0;\n init.score = 0.0;\n init.prob.fill(0.0f);\n init.prob[s] = 1.0f;\n init.prob[t] = 0.0f;\n init.key = compute_key(init);\n\n vector beam;\n beam.reserve(BEAM_WIDTH);\n beam.push_back(init);\n\n // best exact stopping-at-len solution\n Node best = init;\n best.key = best.score; // not used\n\n for (int step = 0; step < LMAX; step++) {\n vector cand;\n cand.reserve(beam.size() * 4);\n\n for (const auto& nd : beam) {\n for (int a = 0; a < 4; a++) {\n Node child = extend(nd, a);\n // track best exact (if we stop here)\n if (child.score > best.score) best = child;\n cand.push_back(std::move(child));\n }\n }\n\n nth_element(cand.begin(),\n cand.begin() + min((int)cand.size(), BEAM_WIDTH),\n cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n\n int take = min((int)cand.size(), BEAM_WIDTH);\n cand.resize(take);\n sort(cand.begin(), cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n\n beam.swap(cand);\n }\n\n // Output best path\n string out;\n out.reserve(best.len);\n for (int i = 0; i < best.len; i++) out.push_back(best.path[i]);\n cout << out << \"\\n\";\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nstatic const int N = 30;\nstatic const int CELLS = N * N;\nstatic const int PORTS = CELLS * 4;\n\n// Directions: 0:left, 1:up, 2:right, 3:down\nstatic const int dj[4] = {-1, 0, 1, 0};\nstatic const int di[4] = {0, -1, 0, 1};\n\n// Given in the statement\nstatic const int to_table[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\n// rotate CCW by 90 degrees mapping (from statement figure)\nstatic const int rot1[8] = {\n 1, 2, 3, 0, // 0->1->2->3->0\n 5, 4, // 4<->5\n 7, 6 // 6<->7\n};\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n explicit XorShift(uint64_t seed) : x(seed) {}\n inline uint32_t nextU32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU32() % (uint32_t)(hi - lo + 1));\n }\n inline double nextDouble() { // [0,1)\n return (nextU32() + 0.5) / 4294967296.0;\n }\n};\n\nstruct Timer {\n chrono::high_resolution_clock::time_point st;\n Timer() : st(chrono::high_resolution_clock::now()) {}\n double elapsedSec() const {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nstruct EvalResult {\n int L1 = 0, L2 = 0;\n int score = 0;\n int auxValue = 0; // used for SA acceptance\n};\n\nint rotState(int t, int r) {\n while (r--) t = rot1[t];\n return t;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n vector init(CELLS);\n for (int i = 0; i < N; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < N; j++) {\n init[i * N + j] = s[j] - '0';\n }\n }\n\n // Precompute \"has port\" and internal partner for each tile state\n bool hasPort[8][4];\n int partner[8][4];\n for (int t = 0; t < 8; t++) {\n for (int d = 0; d < 4; d++) {\n int d2 = to_table[t][d];\n hasPort[t][d] = (d2 != -1);\n partner[t][d] = d2; // valid iff hasPort is true\n }\n }\n\n // Current solution\n vector rot(CELLS, 0);\n vector state(CELLS);\n for (int p = 0; p < CELLS; p++) state[p] = (uint8_t)rotState(init[p], rot[p]);\n\n // Evaluation function (rebuild port graph; extract cycle components)\n vector ext(PORTS); // external neighbor port id or -1\n vector exist(PORTS); // 1 if port exists\n vector vis(PORTS); // visited for component traversal\n\n auto evaluate = [&]() -> EvalResult {\n // Build exist[]\n for (int cell = 0; cell < CELLS; cell++) {\n int t = state[cell];\n int base = cell * 4;\n for (int s = 0; s < 4; s++) {\n exist[base + s] = hasPort[t][s] ? 1 : 0;\n }\n }\n // Build ext[] by checking right and down borders\n std::fill(ext.begin(), ext.end(), -1);\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int cell = i * N + j;\n int base = cell * 4;\n\n // right neighbor\n if (j + 1 < N) {\n int cellR = i * N + (j + 1);\n int baseR = cellR * 4;\n int a = base + 2; // this right\n int b = baseR + 0; // neighbor left\n if (exist[a] && exist[b]) {\n ext[a] = b;\n ext[b] = a;\n }\n }\n // down neighbor\n if (i + 1 < N) {\n int cellD = (i + 1) * N + j;\n int baseD = cellD * 4;\n int a = base + 3; // this down\n int b = baseD + 1; // neighbor up\n if (exist[a] && exist[b]) {\n ext[a] = b;\n ext[b] = a;\n }\n }\n }\n }\n\n // Traverse components\n std::fill(vis.begin(), vis.end(), 0);\n int best1 = 0, best2 = 0;\n int sumLoops = 0;\n int loopsCnt = 0;\n\n vector st;\n st.reserve(256);\n\n for (int p = 0; p < PORTS; p++) {\n if (!exist[p] || vis[p]) continue;\n\n bool isCycle = true;\n int compSize = 0;\n\n st.clear();\n st.push_back(p);\n vis[p] = 1;\n\n while (!st.empty()) {\n int v = st.back();\n st.pop_back();\n compSize++;\n\n // if any port misses external match => open => not a cycle\n if (ext[v] == -1) isCycle = false;\n\n int cell = v / 4;\n int side = v % 4;\n\n // internal neighbor\n int t = state[cell];\n int ip = partner[t][side];\n int u_int = cell * 4 + ip;\n\n if (exist[u_int] && !vis[u_int]) {\n vis[u_int] = 1;\n st.push_back(u_int);\n }\n // external neighbor (if exists)\n int u_ext = ext[v];\n if (u_ext != -1 && !vis[u_ext]) {\n vis[u_ext] = 1;\n st.push_back(u_ext);\n }\n }\n\n if (isCycle) {\n int len = compSize / 2;\n loopsCnt++;\n sumLoops += len;\n if (len > best1) {\n best2 = best1;\n best1 = len;\n } else if (len > best2) {\n best2 = len;\n }\n }\n }\n\n EvalResult res;\n res.L1 = best1;\n res.L2 = best2;\n res.score = (loopsCnt >= 2 ? best1 * best2 : 0);\n\n // Auxiliary objective for SA (helps create >=2 loops)\n // Weighting is heuristic; final best is tracked by true score.\n res.auxValue = res.score + 10000 * res.L2 + 10 * sumLoops;\n return res;\n };\n\n // SA parameters\n Timer timer;\n double timeLimit = 1.90; // seconds (safe margin under 2.0)\n\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n EvalResult cur = evaluate();\n int bestScore = cur.score;\n vector bestRot = rot;\n\n // Temperature schedule tuned to value magnitude\n const double T0 = 200000.0;\n const double T1 = 10.0;\n\n while (timer.elapsedSec() < timeLimit) {\n double t = timer.elapsedSec() / timeLimit;\n double Temp = T0 * (1.0 - t) + T1 * t;\n\n int cell = rng.nextInt(0, CELLS - 1);\n\n uint8_t oldr = rot[cell];\n uint8_t olds = state[cell];\n\n // Move: mostly \u00b11 rotation, sometimes random\n uint8_t newr;\n if (rng.nextU32() % 16 == 0) {\n newr = (uint8_t)rng.nextInt(0, 3);\n } else {\n // +1 or -1 (mod 4)\n newr = (uint8_t)((oldr + ((rng.nextU32() & 1) ? 1 : 3)) & 3);\n }\n if (newr == oldr) continue;\n\n rot[cell] = newr;\n state[cell] = (uint8_t)rotState(init[cell], rot[cell]);\n\n EvalResult nxt = evaluate();\n int delta = nxt.auxValue - cur.auxValue;\n\n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / Temp);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (accept) {\n cur = nxt;\n if (cur.score > bestScore) {\n bestScore = cur.score;\n bestRot = rot;\n }\n } else {\n // rollback\n rot[cell] = oldr;\n state[cell] = olds;\n }\n }\n\n // Output best found rotations as 900 chars\n string out;\n out.resize(CELLS);\n for (int p = 0; p < CELLS; p++) out[p] = char('0' + bestRot[p]);\n cout << out << \"\\n\";\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n uint32_t next_u32() { return (uint32_t)next_u64(); }\n int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline int hexval(char c) {\n if ('0' <= c && c <= '9') return c - '0';\n return 10 + (c - 'a');\n}\n\n// Evaluation:\n// - bestTree: max size among components that are trees (edges = vertices-1)\n// - matchEdges: total number of matched edges\n// - cycleExcess: sum over components of max(0, edges-(vertices-1))\n// scalar used for SA acceptance (allows occasional decreases in bestTree early).\nstruct Eval {\n int bestTree = 0;\n int matchEdges = 0;\n int cycleExcess = 0;\n int scalar = 0;\n};\n\nstruct DSU {\n int n;\n vector p, r;\n DSU(int n=0): n(n), p(n), r(n,0) { iota(p.begin(), p.end(), 0); }\n int find(int a){ while(p[a]!=a){ p[a]=p[p[a]]; a=p[a]; } return a; }\n void unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return;\n if(r[a]& a, int N) {\n int NN = N*N;\n DSU dsu(NN);\n\n vector> edges;\n edges.reserve(2*NN);\n\n auto id = [N](int r,int c){ return r*N+c; };\n\n int matchEdges = 0;\n for(int r=0;r vcnt(NN,0), ecnt(NN,0);\n for(int i=0;i v-1) cycleExcess += (e - (v-1));\n }\n\n // SA scalar (tuned so bestTree dominates but can decrease early)\n // - bestTree step: 1000\n // - matching edges help: +10 each\n // - cycles penalized: -40 each\n int scalar = bestTree * 1000 + matchEdges * 10 - cycleExcess * 40;\n\n return Eval{bestTree, matchEdges, cycleExcess, scalar};\n}\n\n// Moves: U,D,L,R meaning the tile above/below/left/right slides into empty.\n// Equivalent: empty moves U/D/L/R.\nstatic const char DIRCH[4] = {'U','D','L','R'};\nstatic const int dr[4] = {-1, +1, 0, 0};\nstatic const int dc[4] = {0, 0, -1, +1};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T;\n cin >> N >> T;\n vector init(N*N);\n int er=-1, ec=-1;\n for(int i=0;i> s;\n for(int j=0;j(now-start).count();\n };\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n seed ^= (uint64_t)(N*10007 + T*1000003);\n XorShift64 rng(seed);\n\n // Best overall answer found\n string bestAns;\n Eval bestEval;\n bestEval.bestTree = -1;\n int bestK = INT_MAX; // for full solutions\n\n // time limit margin\n const double TIME_LIMIT_MS = 2850.0;\n\n int runCount = 0;\n\n while(elapsed_ms() < TIME_LIMIT_MS) {\n runCount++;\n\n vector a = init;\n int cur_er = er, cur_ec = ec;\n Eval curE = evaluate_board(a, N);\n\n string moves;\n moves.reserve(T);\n\n // Best prefix in this run\n int runBestIdx = 0;\n Eval runBestEval = curE;\n\n // If already full, answer is empty\n if(curE.bestTree == targetFull) {\n bestAns = \"\";\n break;\n }\n\n // SA parameters\n const double temp0 = 800.0;\n const double temp1 = 5.0;\n\n int lastDir = -1;\n\n // Build up to T accepted moves (rejections don't consume move budget)\n int accepted = 0;\n int trialsSinceAccept = 0;\n\n while(accepted < T && elapsed_ms() < TIME_LIMIT_MS) {\n trialsSinceAccept++;\n if(trialsSinceAccept > 20000) break; // safety\n\n double prog = (double)accepted / max(1, T);\n double temp = temp0 * pow(temp1 / temp0, prog);\n\n // pick a random legal dir, with mild anti-backtrack preference\n int cand[4], ccnt=0;\n for(int d=0; d<4; d++){\n int nr = cur_er + dr[d], nc = cur_ec + dc[d];\n if(nr<0||nr>=N||nc<0||nc>=N) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n\n int d;\n if(lastDir != -1 && ccnt >= 2) {\n // avoid immediate reverse with high probability\n int rev = (lastDir==0?1:lastDir==1?0:lastDir==2?3:2);\n if(rng.next_double() < 0.80) {\n // choose among dirs excluding rev if possible\n int tmp[4], tcnt=0;\n for(int k=0;k0) d = tmp[rng.next_int(tcnt)];\n else d = cand[rng.next_int(ccnt)];\n } else {\n d = cand[rng.next_int(ccnt)];\n }\n } else {\n d = cand[rng.next_int(ccnt)];\n }\n\n int nr = cur_er + dr[d], nc = cur_ec + dc[d];\n int u = cur_er*N + cur_ec;\n int v = nr*N + nc;\n\n // apply swap (accept candidate move)\n swap(a[u], a[v]);\n cur_er = nr; cur_ec = nc;\n\n Eval newE = evaluate_board(a, N);\n int delta = newE.scalar - curE.scalar;\n\n bool accept = false;\n if(delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if(rng.next_double() < prob) accept = true;\n }\n\n if(accept) {\n // keep\n curE = newE;\n moves.push_back(DIRCH[d]);\n accepted++;\n trialsSinceAccept = 0;\n lastDir = d;\n\n // update best prefix in this run:\n // primary: bestTree, then matchEdges, then smaller cycleExcess\n bool betterRun =\n (curE.bestTree > runBestEval.bestTree) ||\n (curE.bestTree == runBestEval.bestTree && curE.matchEdges > runBestEval.matchEdges) ||\n (curE.bestTree == runBestEval.bestTree && curE.matchEdges == runBestEval.matchEdges && curE.cycleExcess < runBestEval.cycleExcess);\n\n if(betterRun) {\n runBestEval = curE;\n runBestIdx = accepted;\n }\n\n // full tree: best is shortest K\n if(curE.bestTree == targetFull) {\n // record best full prefix in this run (earliest full is current accepted)\n runBestEval = curE;\n runBestIdx = accepted;\n break;\n }\n } else {\n // revert\n swap(a[u], a[v]);\n cur_er -= dr[d];\n cur_ec -= dc[d];\n }\n }\n\n // consider run best prefix as candidate answer\n string candAns = moves.substr(0, runBestIdx);\n Eval candEval = runBestEval;\n int candK = (int)candAns.size();\n\n bool betterOverall = false;\n if(bestEval.bestTree < 0) betterOverall = true;\n else if(candEval.bestTree == targetFull && bestEval.bestTree != targetFull) betterOverall = true;\n else if(candEval.bestTree == targetFull && bestEval.bestTree == targetFull) {\n if(candK < bestK) betterOverall = true;\n } else if(candEval.bestTree != targetFull && bestEval.bestTree != targetFull) {\n if(candEval.bestTree > bestEval.bestTree) betterOverall = true;\n else if(candEval.bestTree == bestEval.bestTree) {\n if(candEval.matchEdges > bestEval.matchEdges) betterOverall = true;\n else if(candEval.matchEdges == bestEval.matchEdges && candEval.cycleExcess < bestEval.cycleExcess) betterOverall = true;\n }\n }\n\n if(betterOverall) {\n bestAns = candAns;\n bestEval = candEval;\n bestK = candK;\n // If we found a full solution with very small K, we can stop early.\n if(bestEval.bestTree == targetFull && bestK <= N*N) break;\n }\n }\n\n // Ensure within T\n if((int)bestAns.size() > T) bestAns.resize(T);\n\n cout << bestAns << \"\\n\";\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\nusing i128 = __int128_t;\n\nstatic inline uint64_t splitmix64(uint64_t x) {\n x += 0x9e3779b97f4a7c15ULL;\n x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;\n x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;\n return x ^ (x >> 31);\n}\n\nstruct RNG {\n uint64_t state;\n explicit RNG(uint64_t seed=1) : state(seed) {}\n uint64_t next_u64() { return state = splitmix64(state); }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n double next_double(double l, double r) {\n return l + (r - l) * next_double();\n }\n};\n\nstruct Point {\n int x, y;\n};\n\nstruct Line {\n int64 px, py, qx, qy;\n};\n\nstatic inline int sgn_i128(i128 v) {\n if (v > 0) return 1;\n if (v < 0) return -1;\n return 0;\n}\n\n// orientation of (P->Q) x (P->X)\nstatic inline int side_of(const Line& ln, int x, int y) {\n i128 dx = (i128)ln.qx - (i128)ln.px;\n i128 dy = (i128)ln.qy - (i128)ln.py;\n i128 ax = (i128)x - (i128)ln.px;\n i128 ay = (i128)y - (i128)ln.py;\n i128 cross = dx * ay - dy * ax;\n return sgn_i128(cross);\n}\n\nstatic inline uint64_t hash_line(const Line& ln) {\n uint64_t h = 0;\n auto mix = [&](int64 v) {\n h ^= splitmix64((uint64_t)v + 0x9e3779b97f4a7c15ULL + (h<<6) + (h>>2));\n };\n mix(ln.px); mix(ln.py); mix(ln.qx); mix(ln.qy);\n return h;\n}\n\n// Generate a line by angle+offset, then round endpoints to integers.\nstatic Line make_line_from_angle_offset(long double theta, long double offset) {\n // normal n=(cos, sin), direction d=(-sin, cos)\n long double nx = cos(theta), ny = sin(theta);\n long double dx = -sin(theta), dy = cos(theta);\n\n // point on line p0 = n * offset\n long double x0 = nx * offset;\n long double y0 = ny * offset;\n\n // far endpoints along direction\n long double L = 20000.0L;\n long double x1 = x0 + dx * L;\n long double y1 = y0 + dy * L;\n long double x2 = x0 - dx * L;\n long double y2 = y0 - dy * L;\n\n Line ln;\n ln.px = llround(x1);\n ln.py = llround(y1);\n ln.qx = llround(x2);\n ln.qy = llround(y2);\n\n // ensure distinct\n if (ln.px == ln.qx && ln.py == ln.qy) {\n ln.qx += 1;\n }\n return ln;\n}\n\n// Distance from origin to line (for quick rejection) using long double.\nstatic long double dist_origin_to_line_ld(const Line& ln) {\n long double x1 = (long double)ln.px, y1 = (long double)ln.py;\n long double x2 = (long double)ln.qx, y2 = (long double)ln.qy;\n long double A = y2 - y1;\n long double B = x1 - x2;\n long double C = -(A * x1 + B * y1);\n long double denom = sqrt(A*A + B*B);\n if (denom == 0) return 1e100L;\n return fabsl(C) / denom;\n}\n\nstruct Evaluator {\n const vector& pts;\n array a; // 1..10\n int totalA;\n\n Evaluator(const vector& pts_, const array& a_) : pts(pts_), a(a_) {\n totalA = 0;\n for (int d=1; d<=10; d++) totalA += a[d];\n }\n\n // returns distributable pieces count = sum min(a_d, b_d)\n int eval(const vector& lines) const {\n int L = (int)lines.size();\n vector posMask(L), negMask(L);\n for (int i=0;i cnt;\n cnt.reserve(pts.size() * 2);\n\n for (const auto& p : pts) {\n uint64_t key = 0;\n bool cut = false;\n for (int i=0;i 0 ? posMask[i] : negMask[i]);\n }\n if (cut) continue;\n cnt[key]++;\n }\n\n int b[11] = {};\n for (auto &kv : cnt) {\n int sz = kv.second;\n if (1 <= sz && sz <= 10) b[sz]++;\n }\n\n int distributed = 0;\n for (int d=1; d<=10; d++) distributed += min(a[d], b[d]);\n return distributed;\n }\n};\n\nstatic bool line_hits_any_strawberry_center(const Line& ln, const vector& pts) {\n for (auto &p: pts) {\n if (side_of(ln, p.x, p.y) == 0) return true;\n }\n return false;\n}\n\nstatic bool is_valid_line(const Line& ln) {\n auto inRange = [&](int64 v){ return -1000000000LL <= v && v <= 1000000000LL; };\n if (!inRange(ln.px) || !inRange(ln.py) || !inRange(ln.qx) || !inRange(ln.qy)) return false;\n if (ln.px == ln.qx && ln.py == ln.qy) return false;\n return true;\n}\n\n// random line that intersects the disk and (optionally) avoids passing through strawberries.\nstatic bool gen_candidate_line(Line &out, RNG &rng, const vector& pts) {\n const long double R = 10000.0L;\n for (int it=0; it<200; it++) {\n long double theta = rng.next_double(0.0, acosl(-1.0L)); // [0, pi)\n long double offset = rng.next_double(-0.98*R, 0.98*R);\n\n Line ln = make_line_from_angle_offset(theta, offset);\n if (!is_valid_line(ln)) continue;\n\n // must intersect disk\n if (dist_origin_to_line_ld(ln) >= R) continue;\n\n // avoid cutting strawberries exactly\n if (line_hits_any_strawberry_center(ln, pts)) continue;\n\n out = ln;\n return true;\n }\n return false;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n cin >> N >> K;\n array a{};\n for (int d=1; d<=10; d++) cin >> a[d];\n\n vector pts(N);\n for (int i=0;i> pts[i].x >> pts[i].y;\n\n // seed based on input\n uint64_t seed = 123456789ULL;\n seed ^= splitmix64((uint64_t)N * 1009 + (uint64_t)K);\n for (int d=1; d<=10; d++) seed ^= splitmix64((uint64_t)a[d] * (d*10007ULL));\n for (int i=0;i bestLines;\n int bestVal = -1;\n\n // restarts\n int RESTARTS = 6;\n int CANDS_PER_STEP = 25;\n\n for (int r=0; r cur;\n int curVal = evaluator.eval(cur);\n int equalSteps = 0;\n\n for (int step=0; step tmp = cur;\n tmp.push_back(ln);\n int v = evaluator.eval(tmp);\n if (v > bestHereVal) {\n bestHereVal = v;\n bestLn = ln;\n foundAny = true;\n }\n }\n\n if (!foundAny) break;\n if (bestHereVal < curVal) break; // do not decrease\n\n cur.push_back(bestLn);\n if (bestHereVal == curVal) {\n equalSteps++;\n // if we keep not improving, stop early\n if (equalSteps >= 12) break;\n } else {\n equalSteps = 0;\n }\n curVal = bestHereVal;\n\n // early perfect\n if (curVal == totalA) break;\n }\n\n if (curVal > bestVal) {\n bestVal = curVal;\n bestLines = cur;\n }\n if (bestVal == totalA) break;\n }\n\n // output\n cout << bestLines.size() << \"\\n\";\n for (auto &ln : bestLines) {\n cout << ln.px << \" \" << ln.py << \" \" << ln.qx << \" \" << ln.qy << \"\\n\";\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Pt {\n int x, y;\n};\n\nstatic inline int sgn(int a){ return (a>0) - (a<0); }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n vector> dot(N, vector(N, 0));\n for(int i=0;i>x>>y;\n dot[x][y]=1;\n }\n\n auto inside = [&](int x,int y)->bool{\n return 0<=x && x> h(N, vector(N-1, 0));\n vector> v(N-1, vector(N, 0));\n vector> d1(N-1, vector(N-1, 0));\n vector> d2(N-1, vector(N-1, 0));\n\n auto usedSeg = [&](Pt a, Pt b)->unsigned char&{\n int dx = b.x - a.x, dy = b.y - a.y;\n if (abs(dx)+abs(dy)==1) {\n if (dy==0) {\n int y = a.y;\n int x = min(a.x, b.x);\n return h[y][x];\n } else {\n int x = a.x;\n int y = min(a.y, b.y);\n return v[y][x];\n }\n } else {\n // diagonal unit\n int x = min(a.x, b.x);\n int y = min(a.y, b.y);\n if (dx==dy) return d1[y][x];\n else return d2[y][x]; // dx==-dy\n }\n };\n\n auto edgeLen = [&](Pt a, Pt b)->int{\n return max(abs(a.x-b.x), abs(a.y-b.y));\n };\n\n // Check an edge (a->b) satisfies:\n // - it's horizontal/vertical/diagonal (\u00b11 slope),\n // - no intermediate points have dots (condition 2),\n // - no unit segments were previously used (condition 3).\n auto checkEdge = [&](Pt a, Pt b)->bool{\n int dx = b.x - a.x, dy = b.y - a.y;\n int adx = abs(dx), ady = abs(dy);\n if (!((dx==0 && dy!=0) || (dy==0 && dx!=0) || (adx==ady && adx!=0))) return false;\n int sx = sgn(dx), sy = sgn(dy);\n int len = max(adx, ady);\n\n // intermediate dots\n for(int i=1;ibool{\n if (!inside(p1.x,p1.y) || !inside(p2.x,p2.y) || !inside(p3.x,p3.y) || !inside(p4.x,p4.y)) return false;\n if (dot[p1.x][p1.y]) return false;\n if (!dot[p2.x][p2.y] || !dot[p3.x][p3.y] || !dot[p4.x][p4.y]) return false;\n\n // edges must be valid (condition 2 & 3)\n if (!checkEdge(p1,p2)) return false;\n if (!checkEdge(p2,p3)) return false;\n if (!checkEdge(p3,p4)) return false;\n if (!checkEdge(p4,p1)) return false;\n\n return true;\n };\n\n auto applyRect = [&](Pt p1, Pt p2, Pt p3, Pt p4){\n dot[p1.x][p1.y] = 1;\n applyEdge(p1,p2);\n applyEdge(p2,p3);\n applyEdge(p3,p4);\n applyEdge(p4,p1);\n };\n\n // Precompute points sorted by descending weight (farther from center first).\n int c = (N-1)/2;\n vector order;\n order.reserve(N*N);\n for(int x=0;xint{\n int dx = p.x - c;\n int dy = p.y - c;\n return dx*dx + dy*dy + 1;\n };\n sort(order.begin(), order.end(), [&](const Pt& a, const Pt& b){\n int wa = weight(a), wb = weight(b);\n if (wa != wb) return wa > wb;\n if (a.x != b.x) return a.x < b.x;\n return a.y < b.y;\n });\n\n // Collect up to LIM nearest dots along a direction (dx,dy) from p (excluding p).\n auto collectDir = [&](Pt p, int dx, int dy, int LIM)->vector{\n vector res;\n for(int step=1;;step++){\n int nx = p.x + dx*step;\n int ny = p.y + dy*step;\n if (!inside(nx,ny)) break;\n if (dot[nx][ny]) {\n res.push_back({nx,ny});\n if ((int)res.size() >= LIM) break;\n }\n }\n return res;\n };\n\n vector> ops;\n\n auto start = chrono::steady_clock::now();\n const double TL = 4.85; // stop earlier than 5.0s\n\n int LIM = 4; // nearest dots per direction (tunable)\n for(int pass=0; pass<50; pass++){\n bool progressed = false;\n\n for(const auto &p1 : order){\n // time check\n auto now = chrono::steady_clock::now();\n double t = chrono::duration(now - start).count();\n if (t > TL) break;\n\n if (dot[p1.x][p1.y]) continue;\n\n // Gather nearby existing dots\n vector horiz, vert, diagPlus, diagMinus;\n {\n auto L = collectDir(p1, -1, 0, LIM);\n auto R = collectDir(p1, 1, 0, LIM);\n horiz.reserve(L.size()+R.size());\n horiz.insert(horiz.end(), L.begin(), L.end());\n horiz.insert(horiz.end(), R.begin(), R.end());\n }\n {\n auto D = collectDir(p1, 0, -1, LIM);\n auto U = collectDir(p1, 0, 1, LIM);\n vert.reserve(D.size()+U.size());\n vert.insert(vert.end(), D.begin(), D.end());\n vert.insert(vert.end(), U.begin(), U.end());\n }\n {\n auto NE = collectDir(p1, 1, 1, LIM);\n auto SW = collectDir(p1, -1, -1, LIM);\n diagPlus.reserve(NE.size()+SW.size());\n diagPlus.insert(diagPlus.end(), NE.begin(), NE.end());\n diagPlus.insert(diagPlus.end(), SW.begin(), SW.end());\n }\n {\n auto SE = collectDir(p1, 1, -1, LIM);\n auto NW = collectDir(p1, -1, 1, LIM);\n diagMinus.reserve(SE.size()+NW.size());\n diagMinus.insert(diagMinus.end(), SE.begin(), SE.end());\n diagMinus.insert(diagMinus.end(), NW.begin(), NW.end());\n }\n\n bool found = false;\n Pt bestP2{}, bestP3{}, bestP4{};\n int bestPerim = INT_MAX;\n\n // Axis-aligned rectangles: p2 on row, p4 on col, p3 at (p2.x, p4.y).\n for(const auto &p2 : horiz){\n for(const auto &p4 : vert){\n if (p2.x == p1.x || p4.y == p1.y) continue;\n Pt p3{p2.x, p4.y};\n if (!inside(p3.x,p3.y)) continue;\n if (!dot[p3.x][p3.y]) continue;\n\n if (!validRect(p1, p2, p3, p4)) continue;\n int perim = edgeLen(p1,p2) + edgeLen(p2,p3) + edgeLen(p3,p4) + edgeLen(p4,p1);\n if (perim < bestPerim) {\n bestPerim = perim;\n bestP2 = p2; bestP3 = p3; bestP4 = p4;\n found = true;\n }\n }\n }\n\n // 45-degree rectangles: p2 on diagPlus (x-y const), p4 on diagMinus (x+y const)\n for(const auto &p2 : diagPlus){\n for(const auto &p4 : diagMinus){\n if (p2.x==p1.x && p2.y==p1.y) continue;\n if (p4.x==p1.x && p4.y==p1.y) continue;\n Pt p3{p2.x + p4.x - p1.x, p2.y + p4.y - p1.y};\n if (!inside(p3.x,p3.y)) continue;\n if (!dot[p3.x][p3.y]) continue;\n\n if (!validRect(p1, p2, p3, p4)) continue;\n int perim = edgeLen(p1,p2) + edgeLen(p2,p3) + edgeLen(p3,p4) + edgeLen(p4,p1);\n if (perim < bestPerim) {\n bestPerim = perim;\n bestP2 = p2; bestP3 = p3; bestP4 = p4;\n found = true;\n }\n }\n }\n\n if (found) {\n applyRect(p1, bestP2, bestP3, bestP4);\n ops.push_back({p1.x,p1.y, bestP2.x,bestP2.y, bestP3.x,bestP3.y, bestP4.x,bestP4.y});\n progressed = true;\n }\n }\n\n auto now = chrono::steady_clock::now();\n double t = chrono::duration(now - start).count();\n if (t > TL) break;\n\n if (!progressed) break;\n }\n\n cout << ops.size() << \"\\n\";\n for(auto &a: ops){\n for(int i=0;i<8;i++){\n if (i) cout << ' ';\n cout << a[i];\n }\n cout << \"\\n\";\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstatic constexpr int N = 10;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct State {\n array, N> g{}; // 0 empty, 1..3 flavor\n\n void clear() {\n for (int y = 0; y < N; y++) for (int x = 0; x < N; x++) g[y][x] = 0;\n }\n\n // Place candy of flavor f at the p-th empty cell in scan order (y asc, x asc).\n void placeByP(int p, uint8_t f) {\n int cnt = 0;\n for (int y = 0; y < N; y++) {\n for (int x = 0; x < N; x++) {\n if (g[y][x] == 0) {\n cnt++;\n if (cnt == p) {\n g[y][x] = f;\n return;\n }\n }\n }\n }\n // Should never happen for valid inputs.\n }\n\n static void tiltInPlace(array, N>& a, char dir) {\n if (dir == 'L') {\n for (int y = 0; y < N; y++) {\n uint8_t tmp[N]; int k = 0;\n for (int x = 0; x < N; x++) if (a[y][x]) tmp[k++] = a[y][x];\n for (int x = 0; x < N; x++) a[y][x] = 0;\n for (int x = 0; x < k; x++) a[y][x] = tmp[x];\n }\n } else if (dir == 'R') {\n for (int y = 0; y < N; y++) {\n uint8_t tmp[N]; int k = 0;\n for (int x = 0; x < N; x++) if (a[y][x]) tmp[k++] = a[y][x];\n for (int x = 0; x < N; x++) a[y][x] = 0;\n for (int i = 0; i < k; i++) a[y][N - k + i] = tmp[i];\n }\n } else if (dir == 'F') { // toward smaller y\n for (int x = 0; x < N; x++) {\n uint8_t tmp[N]; int k = 0;\n for (int y = 0; y < N; y++) if (a[y][x]) tmp[k++] = a[y][x];\n for (int y = 0; y < N; y++) a[y][x] = 0;\n for (int y = 0; y < k; y++) a[y][x] = tmp[y];\n }\n } else { // 'B' toward larger y\n for (int x = 0; x < N; x++) {\n uint8_t tmp[N]; int k = 0;\n for (int y = 0; y < N; y++) if (a[y][x]) tmp[k++] = a[y][x];\n for (int y = 0; y < N; y++) a[y][x] = 0;\n for (int i = 0; i < k; i++) a[N - k + i][x] = tmp[i];\n }\n }\n }\n\n State afterTilt(char dir) const {\n State s = *this;\n tiltInPlace(s.g, dir);\n return s;\n }\n\n vector> empties() const {\n vector> res;\n res.reserve(100);\n for (int y = 0; y < N; y++) for (int x = 0; x < N; x++)\n if (g[y][x] == 0) res.emplace_back(y, x);\n return res;\n }\n};\n\nstruct Evaluator {\n // Weights tuned lightly for stability; feel free to tune further.\n double wCC = 8.0;\n double wAdj = 1.5;\n double wVar = 0.03;\n double wOrd = 6.0;\n double wSep = 0.4;\n\n double eval(const State& s) const {\n // CC: sum of component sizes squared (same-flavor 4-neighbor)\n bool vis[N][N];\n for (int y = 0; y < N; y++) for (int x = 0; x < N; x++) vis[y][x] = false;\n\n int ccSumSq = 0;\n int qy[100], qx[100];\n\n for (int sy = 0; sy < N; sy++) for (int sx = 0; sx < N; sx++) {\n uint8_t f = s.g[sy][sx];\n if (!f || vis[sy][sx]) continue;\n int head = 0, tail = 0;\n vis[sy][sx] = true;\n qy[tail] = sy; qx[tail] = sx; tail++;\n int cnt = 0;\n while (head < tail) {\n int y = qy[head], x = qx[head]; head++;\n cnt++;\n const int dy[4] = {-1, 1, 0, 0};\n const int dx[4] = {0, 0, -1, 1};\n for (int d = 0; d < 4; d++) {\n int ny = y + dy[d], nx = x + dx[d];\n if (0 <= ny && ny < N && 0 <= nx && nx < N && !vis[ny][nx] && s.g[ny][nx] == f) {\n vis[ny][nx] = true;\n qy[tail] = ny; qx[tail] = nx; tail++;\n }\n }\n }\n ccSumSq += cnt * cnt;\n }\n\n // Adj: number of same-flavor adjacent pairs (count each edge once)\n int adjSame = 0;\n for (int y = 0; y < N; y++) for (int x = 0; x < N; x++) {\n uint8_t f = s.g[y][x];\n if (!f) continue;\n if (x + 1 < N && s.g[y][x + 1] == f) adjSame++;\n if (y + 1 < N && s.g[y + 1][x] == f) adjSame++;\n }\n\n // Centroids and variance per flavor\n double cnt[4] = {0,0,0,0};\n double sx[4] = {0,0,0,0}, sy[4] = {0,0,0,0};\n double sx2[4] = {0,0,0,0}, sy2[4] = {0,0,0,0};\n\n for (int y = 0; y < N; y++) for (int x = 0; x < N; x++) {\n uint8_t f = s.g[y][x];\n if (!f) continue;\n cnt[f] += 1.0;\n sx[f] += x; sy[f] += y;\n sx2[f] += x * 1.0 * x;\n sy2[f] += y * 1.0 * y;\n }\n\n double ax[4] = {0,0,0,0}, ay[4] = {0,0,0,0};\n for (int f = 1; f <= 3; f++) {\n if (cnt[f] > 0) {\n ax[f] = sx[f] / cnt[f];\n ay[f] = sy[f] / cnt[f];\n }\n }\n\n double varSum = 0.0;\n for (int f = 1; f <= 3; f++) if (cnt[f] > 0) {\n // var(x) = E[x^2] - E[x]^2, multiplied by cnt to be sum of squared deviations\n double ex = sx[f] / cnt[f];\n double ey = sy[f] / cnt[f];\n double sumSqDevX = sx2[f] - cnt[f] * ex * ex;\n double sumSqDevY = sy2[f] - cnt[f] * ey * ey;\n varSum += (sumSqDevX + sumSqDevY);\n }\n\n // Order penalty: encourage ax[1] <= ax[2] <= ax[3] when both exist\n auto ordPenaltyPair = [&](int a, int b) -> double {\n if (cnt[a] == 0 || cnt[b] == 0) return 0.0;\n return max(0.0, ax[a] - ax[b]);\n };\n double ordPenalty = ordPenaltyPair(1,2) + ordPenaltyPair(2,3);\n\n // Separation: sum of squared distances between centroids\n double sep = 0.0;\n for (int i = 1; i <= 3; i++) for (int j = i+1; j <= 3; j++) {\n if (cnt[i] == 0 || cnt[j] == 0) continue;\n double dx = ax[i] - ax[j];\n double dy = ay[i] - ay[j];\n sep += dx*dx + dy*dy;\n }\n\n return wCC * ccSumSq + wAdj * adjSame - wVar * varSum - wOrd * ordPenalty + wSep * sep;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n array f{};\n for (int t = 1; t <= 100; t++) {\n if (!(cin >> f[t])) return 0;\n }\n\n State cur;\n cur.clear();\n\n Evaluator ev;\n XorShift rng; // deterministic\n\n const array DIRS = {'F','B','L','R'};\n\n for (int t = 1; t <= 100; t++) {\n int p;\n cin >> p;\n\n // Environment places candy first\n cur.placeByP(p, (uint8_t)f[t]);\n\n // Choose tilt\n char bestDir = 'L';\n double bestVal = -1e100;\n\n for (char a : DIRS) {\n State s1 = cur.afterTilt(a);\n double base = ev.eval(s1);\n\n double val = base;\n\n // 1-step stochastic lookahead (expectation over next random placement)\n if (t < 100) {\n auto emps = s1.empties();\n int m = (int)emps.size();\n int S = min(16, m);\n // sample without replacement (partial shuffle)\n for (int i = 0; i < S; i++) {\n int j = rng.nextInt(i, m - 1);\n swap(emps[i], emps[j]);\n }\n\n double sumBest = 0.0;\n for (int i = 0; i < S; i++) {\n State s2 = s1;\n auto [y, x] = emps[i];\n s2.g[y][x] = (uint8_t)f[t + 1];\n\n double bestNext = -1e100;\n for (char b : DIRS) {\n State s3 = s2.afterTilt(b);\n bestNext = max(bestNext, ev.eval(s3));\n }\n sumBest += bestNext;\n }\n double expectedNext = (S > 0) ? (sumBest / S) : base;\n\n // Blend immediate quality and expected next-turn quality\n val = 0.70 * base + 0.30 * expectedNext;\n }\n\n if (val > bestVal + 1e-9) {\n bestVal = val;\n bestDir = a;\n } else if (abs(val - bestVal) <= 1e-9) {\n // tie-break deterministically but slightly varied\n if ((rng.nextU64() & 1ULL) == 0) bestDir = a;\n }\n }\n\n // Apply chosen tilt to real state\n State::tiltInPlace(cur.g, bestDir);\n\n // Output and flush (required)\n cout << bestDir << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nstruct Adj100 {\n // Enough for N<=100 => 2*64 bits\n array w{};\n};\n\nstatic inline void set_edge(vector& adj, int u, int v) {\n adj[u].w[v >> 6] |= 1ULL << (v & 63);\n adj[v].w[u >> 6] |= 1ULL << (u & 63);\n}\nstatic inline bool has_edge(const vector& adj, int u, int v) {\n return (adj[u].w[v >> 6] >> (v & 63)) & 1ULL;\n}\nstatic inline int popcnt2(const array& a) {\n return __builtin_popcountll(a[0]) + __builtin_popcountll(a[1]);\n}\nstatic inline int popcnt_and2(const array& a, const array& b) {\n return __builtin_popcountll(a[0] & b[0]) + __builtin_popcountll(a[1] & b[1]);\n}\n\nstruct Proto {\n vector mu_sorted_deg; // size N\n double Em = 0.0; // expected noisy edge count\n double Etri = 0.0; // expected noisy triangle count\n double VarTri = 1.0; // rough variance for normalization\n};\n\nstruct AnalyzedCounts {\n long long m = 0;\n long long tri = 0;\n vector deg;\n};\n\n// Compute degrees, edge count, triangle count from adjacency (undirected, simple)\nstatic AnalyzedCounts analyze_observed(const vector& adj, int N) {\n AnalyzedCounts res;\n res.deg.assign(N, 0);\n\n long long sum_deg = 0;\n for (int i = 0; i < N; i++) {\n int d = popcnt2(adj[i].w);\n res.deg[i] = d;\n sum_deg += d;\n }\n res.m = sum_deg / 2;\n\n long long sumCommon = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (has_edge(adj, i, j)) {\n sumCommon += popcnt_and2(adj[i].w, adj[j].w);\n }\n }\n }\n res.tri = sumCommon / 3;\n return res;\n}\n\n// Precompute c0..c3 for triples by number of original edges, then expected triangles after noise.\nstatic void compute_triple_edge_histogram(\n const vector& adj, int N,\n long long &c0, long long &c1, long long &c2, long long &c3\n) {\n vector deg(N);\n for (int i = 0; i < N; i++) deg[i] = popcnt2(adj[i].w);\n\n vector triEdgeSum(N, 0);\n long long sumCommon = 0;\n\n // For each edge (u,v): common neighbors count\n // sumCommon = 3*c3, and triEdgeSum[x] helps for c2.\n for (int u = 0; u < N; u++) {\n for (int v = u + 1; v < N; v++) {\n if (!has_edge(adj, u, v)) continue;\n int common = popcnt_and2(adj[u].w, adj[v].w);\n sumCommon += common;\n triEdgeSum[u] += common;\n triEdgeSum[v] += common;\n }\n }\n c3 = sumCommon / 3;\n\n // triInc[v] = number of triangles incident to v\n vector triInc(N, 0);\n for (int v = 0; v < N; v++) triInc[v] = triEdgeSum[v] / 2;\n\n // c2: triples with exactly 2 edges (a wedge)\n c2 = 0;\n for (int v = 0; v < N; v++) {\n long long wedges = 1LL * deg[v] * (deg[v] - 1) / 2;\n c2 += (wedges - triInc[v]);\n }\n\n // c1: triples with exactly 1 edge\n // For each original edge (u,v), count w adjacent to neither u nor v:\n // count = (N-2) - |N(u)\\{v} \u222a N(v)\\{u}| = N - deg[u] - deg[v] + common_uv\n c1 = 0;\n for (int u = 0; u < N; u++) {\n for (int v = u + 1; v < N; v++) {\n if (!has_edge(adj, u, v)) continue;\n int common = popcnt_and2(adj[u].w, adj[v].w);\n c1 += (long long)N - deg[u] - deg[v] + common;\n }\n }\n\n long long totalTriples = 1LL * N * (N - 1) * (N - 2) / 6;\n c0 = totalTriples - c1 - c2 - c3;\n if (c0 < 0) c0 = 0; // guard for any accidental rounding issues\n}\n\nstatic vector build_graph(int N, int hubSize, const vector& smallSizes, int kMask) {\n vector adj(N);\n\n // group ranges\n int B = (int)smallSizes.size();\n vector start(B+1, 0);\n start[0] = hubSize;\n for (int i = 0; i < B; i++) start[i+1] = start[i] + smallSizes[i];\n // hub: [0, hubSize)\n // group i: [start[i], start[i+1])\n\n auto add_clique = [&](int L, int R) {\n for (int i = L; i < R; i++) {\n for (int j = i + 1; j < R; j++) set_edge(adj, i, j);\n }\n };\n\n // hub clique\n add_clique(0, hubSize);\n // small cliques\n for (int i = 0; i < B; i++) add_clique(start[i], start[i+1]);\n\n // connect hub <-> group i iff bit i is 1\n for (int i = 0; i < B; i++) {\n if (((kMask >> i) & 1) == 0) continue;\n for (int u = 0; u < hubSize; u++) {\n for (int v = start[i]; v < start[i+1]; v++) set_edge(adj, u, v);\n }\n }\n return adj;\n}\n\nstatic string adj_to_string(const vector& adj, int N) {\n string s;\n s.reserve((size_t)N * (N - 1) / 2);\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n s.push_back(has_edge(adj, i, j) ? '1' : '0');\n }\n }\n return s;\n}\n\nstatic vector string_to_adj(const string& s, int N) {\n vector adj(N);\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (s[idx++] == '1') set_edge(adj, i, j);\n }\n }\n return adj;\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 // Choose N by epsilon (tradeoff robustness vs 1/N)\n int N;\n if (eps <= 0.15) N = 60;\n else if (eps <= 0.25) N = 80;\n else N = 100;\n\n // Fixed 7 small groups; hub gets the remaining vertices.\n vector smallSizes = {3,4,5,6,7,8,9}; // sum=42\n int sumSmall = accumulate(smallSizes.begin(), smallSizes.end(), 0);\n int hubSize = N - sumSmall;\n if (hubSize < 4) {\n // Safety fallback (shouldn't happen with our N choices)\n N = 100;\n hubSize = N - sumSmall;\n }\n\n const int B = (int)smallSizes.size();\n // We use kMask = k (0..M-1). Since M<=100 and 2^7=128, it's enough.\n // If M was larger, we would need more bits/groups.\n\n // Precompute prototypes\n vector prot(M);\n\n // Common constants for scoring\n const double p1 = 1.0 - eps;\n const double p0 = eps;\n const double scale = 1.0 - 2.0 * eps; // difference between \"edge was 1\" and \"edge was 0\" expectations\n const double degOffset = eps * (N - 1);\n const double sigma2_deg = (N - 1) * eps * (1.0 - eps) + 1e-9;\n const double Tedges = 1.0 * N * (N - 1) / 2.0;\n const double var_m = Tedges * eps * (1.0 - eps) + 1e-9;\n\n // Output graphs\n cout << N << \"\\n\";\n for (int k = 0; k < M; k++) {\n auto G = build_graph(N, hubSize, smallSizes, k);\n\n // Build output string\n string out = adj_to_string(G, N);\n cout << out << \"\\n\";\n\n // Analyze prototype for decoding\n // Original degrees\n vector deg0(N, 0);\n for (int v = 0; v < N; v++) deg0[v] = popcnt2(G[v].w);\n\n // Expected noisy degrees then sorted\n vector mu(N);\n for (int v = 0; v < N; v++) mu[v] = degOffset + scale * deg0[v];\n sort(mu.begin(), mu.end());\n prot[k].mu_sorted_deg = move(mu);\n\n // Expected noisy edge count\n long long m0 = 0;\n for (int v = 0; v < N; v++) m0 += deg0[v];\n m0 /= 2;\n prot[k].Em = m0 * p1 + (Tedges - m0) * p0;\n\n // Expected noisy triangle count (via c0..c3)\n long long c0, c1, c2, c3;\n compute_triple_edge_histogram(G, N, c0, c1, c2, c3);\n const double eTri =\n c3 * (p1*p1*p1) +\n c2 * (p1*p1*p0) +\n c1 * (p1*p0*p0) +\n c0 * (p0*p0*p0);\n prot[k].Etri = eTri;\n\n // Rough variance for normalization\n double totalTriples = 1.0 * N * (N - 1) * (N - 2) / 6.0;\n double pbar = (totalTriples > 0 ? eTri / totalTriples : 0.0);\n pbar = min(1.0, max(0.0, pbar));\n prot[k].VarTri = totalTriples * pbar * (1.0 - pbar) + 1.0; // +1 to avoid div0\n }\n cout.flush();\n\n // Answer queries\n for (int q = 0; q < 100; q++) {\n string hs;\n cin >> hs;\n if (!cin) break;\n\n auto H = string_to_adj(hs, N);\n auto obs = analyze_observed(H, N);\n\n vector degSorted = obs.deg;\n sort(degSorted.begin(), degSorted.end());\n\n int best = 0;\n double bestScore = 1e300;\n\n for (int k = 0; k < M; k++) {\n // Degree SSE vs expected sorted degrees\n const auto &mu = prot[k].mu_sorted_deg;\n double sse = 0.0;\n for (int i = 0; i < N; i++) {\n double diff = (double)degSorted[i] - mu[i];\n sse += diff * diff;\n }\n double z_deg = sse / (sigma2_deg * N);\n\n // Edge count term\n double dm = (double)obs.m - prot[k].Em;\n double z_m = (dm * dm) / var_m;\n\n // Triangle count term\n double dt = (double)obs.tri - prot[k].Etri;\n double z_t = (dt * dt) / prot[k].VarTri;\n\n // Weights (tuned mildly; degrees dominate, triangles assist)\n double score = z_deg + 0.30 * z_m + 0.10 * z_t;\n\n if (score < bestScore) {\n bestScore = score;\n best = k;\n }\n }\n\n cout << best << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n int w;\n};\n\nstatic inline long long sqll(long long x) { return x * x; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n\n vector edges(M);\n vector>> g(N); // (to, edgeId)\n vector> gw(N); // parallel weights (to keep fast)\n g.assign(N, {});\n gw.assign(N, {});\n\n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n edges[i] = {u, v, w};\n g[u].push_back({v, i});\n gw[u].push_back(w);\n g[v].push_back({u, i});\n gw[v].push_back(w);\n }\n // coordinates: not used, but must be consumed\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n\n // RNG\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937_64 rng(seed);\n\n // --- 1) Importance estimation by sampled Dijkstra + SPT subtree contributions ---\n int S = min(40, N);\n vector sources(N);\n iota(sources.begin(), sources.end(), 0);\n shuffle(sources.begin(), sources.end(), rng);\n sources.resize(S);\n\n const long long INF = (1LL<<62);\n vector importance(M, 0);\n\n vector dist(N);\n vector parentV(N), parentE(N);\n vector order(N);\n vector subtree(N);\n\n // Dijkstra with parent tracking for an SPT\n for (int si = 0; si < S; si++) {\n int s = sources[si];\n fill(dist.begin(), dist.end(), INF);\n fill(parentV.begin(), parentV.end(), -1);\n fill(parentE.begin(), parentE.end(), -1);\n\n using P = pair;\n priority_queue, greater

> pq;\n dist[s] = 0;\n pq.push({0, s});\n\n while (!pq.empty()) {\n auto [dcur, v] = pq.top();\n pq.pop();\n if (dcur != dist[v]) continue;\n // relax\n for (int idx = 0; idx < (int)g[v].size(); idx++) {\n auto [to, eid] = g[v][idx];\n long long w = gw[v][idx];\n long long nd = dcur + w;\n if (nd < dist[to]) {\n dist[to] = nd;\n parentV[to] = v;\n parentE[to] = eid;\n pq.push({nd, to});\n }\n }\n }\n\n // sort vertices by distance descending to accumulate subtree sizes bottom-up\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int a, int b){\n return dist[a] > dist[b];\n });\n\n fill(subtree.begin(), subtree.end(), 1);\n for (int v : order) {\n int p = parentV[v];\n if (p != -1) subtree[p] += subtree[v];\n }\n\n // edge contribution from the chosen SPT\n for (int v = 0; v < N; v++) {\n if (v == s) continue;\n int eid = parentE[v];\n if (eid < 0) continue; // should not happen in connected graph\n long long sz = subtree[v];\n importance[eid] += sz * (long long)(N - sz);\n }\n }\n\n long long totalImp = 0;\n for (auto x : importance) totalImp += x;\n long double impScale = (M > 0 ? (long double)totalImp / (long double)M : 1.0L);\n if (impScale < 1.0L) impScale = 1.0L;\n\n // --- 2) Initial construction: balanced target counts per day ---\n vector target(D, M / D);\n for (int d = 0; d < (M % D); d++) target[d]++;\n\n // Edge order by importance (descending), tie by weight (descending)\n vector eorder(M);\n iota(eorder.begin(), eorder.end(), 0);\n sort(eorder.begin(), eorder.end(), [&](int a, int b){\n if (importance[a] != importance[b]) return importance[a] > importance[b];\n return edges[a].w > edges[b].w;\n });\n\n vector dayOfEdge(M, -1);\n vector> edgesInDay(D);\n for (int d = 0; d < D; d++) edgesInDay[d].reserve(target[d]);\n\n vector cnt(D, 0);\n vector daySumImp(D, 0);\n\n // incident counts per (day, vertex) and squared-sum penalty per day\n vector> inc(D, vector(N, 0));\n vector dayVertexPenalty(D, 0); // sum_v inc^2\n\n auto deltaAddEdgeVP = [&](int d, int u, int v) -> long long {\n long long delta = 0;\n {\n long long a = inc[d][u];\n long long b = a + 1;\n delta += b*b - a*a;\n }\n {\n long long a = inc[d][v];\n long long b = a + 1;\n delta += b*b - a*a;\n }\n // if u==v (no), but keep safe\n if (u == v) delta -= 1; // correct double count if ever happens\n return delta;\n };\n\n auto applyAddEdge = [&](int d, int eid) {\n int u = edges[eid].u, v = edges[eid].v;\n // update dayVertexPenalty\n long long dvp = 0;\n {\n long long a = inc[d][u];\n long long b = a + 1;\n dvp += b*b - a*a;\n inc[d][u] = (uint16_t)b;\n }\n {\n long long a = inc[d][v];\n long long b = a + 1;\n dvp += b*b - a*a;\n inc[d][v] = (uint16_t)b;\n }\n if (u == v) dvp -= 1;\n dayVertexPenalty[d] += dvp;\n\n daySumImp[d] += importance[eid];\n dayOfEdge[eid] = d;\n edgesInDay[d].push_back(eid);\n cnt[d]++;\n };\n\n // Greedy assignment\n const long double alphaVP = 0.7L * impScale; // vertex concentration penalty weight\n const long double betaCnt = 0.02L * impScale; // slight bias for lower count early\n\n for (int eid : eorder) {\n int u = edges[eid].u, v = edges[eid].v;\n int bestD = -1;\n long double bestCost = numeric_limits::infinity();\n\n for (int d = 0; d < D; d++) {\n if (cnt[d] >= target[d]) continue;\n long long dvp = deltaAddEdgeVP(d, u, v);\n long double cost = (long double)daySumImp[d]\n + alphaVP * (long double)dvp\n + betaCnt * (long double)cnt[d];\n if (cost < bestCost) {\n bestCost = cost;\n bestD = d;\n }\n }\n // should always find since sum target == M\n if (bestD < 0) bestD = 0;\n applyAddEdge(bestD, eid);\n }\n\n // prepare posInDay for O(1) swap updates\n vector posInDay(M, -1);\n for (int d = 0; d < D; d++) {\n for (int i = 0; i < (int)edgesInDay[d].size(); i++) {\n posInDay[edgesInDay[d][i]] = i;\n }\n }\n\n // --- 3) Simulated annealing with swaps (keeps day sizes exact) ---\n auto makeChanges = [&](int eidRemove, int eidAdd) {\n // returns vector of (vertex, deltaInc) with merged duplicates\n array vs = {edges[eidRemove].u, edges[eidRemove].v, edges[eidAdd].u, edges[eidAdd].v};\n array ds = {-1, -1, +1, +1};\n // merge duplicates in small array\n vector> tmp;\n tmp.reserve(4);\n for (int i = 0; i < 4; i++) {\n int v = vs[i], del = ds[i];\n bool found = false;\n for (auto &p : tmp) if (p.first == v) { p.second += del; found = true; break; }\n if (!found) tmp.push_back({v, del});\n }\n // remove zeros\n vector> ch;\n ch.reserve(tmp.size());\n for (auto &p : tmp) if (p.second != 0) ch.push_back(p);\n return ch;\n };\n\n auto deltaVPForDay = [&](int d, const vector>& changes) -> long long {\n long long delta = 0;\n for (auto [v, del] : changes) {\n long long a = inc[d][v];\n long long b = a + del;\n delta += b*b - a*a;\n }\n return delta;\n };\n\n auto applyVPChanges = [&](int d, const vector>& changes) {\n long long delta = 0;\n for (auto [v, del] : changes) {\n long long a = inc[d][v];\n long long b = a + del;\n delta += b*b - a*a;\n inc[d][v] = (uint16_t)b;\n }\n dayVertexPenalty[d] += delta;\n };\n\n long long sumSqImp = 0;\n long long totalVP = 0;\n for (int d = 0; d < D; d++) {\n sumSqImp += sqll(daySumImp[d]);\n totalVP += dayVertexPenalty[d];\n }\n\n long double coeffVP = (long double)(impScale * impScale * 0.5L);\n auto objective = [&]() -> long double {\n return (long double)sumSqImp + coeffVP * (long double)totalVP;\n };\n\n long double curObj = objective();\n\n auto startTime = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 5.85; // keep margin under 6 sec\n uniform_real_distribution uni01(0.0, 1.0);\n\n // temperature schedule based on current obj magnitude\n long double T0 = max((long double)1.0, curObj * 1e-4L);\n long double T1 = max((long double)1e-3, curObj * 1e-7L);\n\n // pre-build list of days for random pick\n vector dayIdx(D);\n iota(dayIdx.begin(), dayIdx.end(), 0);\n\n long long iters = 0;\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - startTime).count();\n if (elapsed > TIME_LIMIT) break;\n double t = elapsed / TIME_LIMIT;\n long double T = T0 * pow((double)(T1 / T0), t);\n\n // pick two distinct days and one random edge from each\n int a = (int)(rng() % D);\n int b = (int)(rng() % (D - 1));\n if (b >= a) b++;\n if (edgesInDay[a].empty() || edgesInDay[b].empty()) continue;\n\n int ia = (int)(rng() % edgesInDay[a].size());\n int ib = (int)(rng() % edgesInDay[b].size());\n int e1 = edgesInDay[a][ia];\n int e2 = edgesInDay[b][ib];\n if (e1 == e2) continue;\n\n long long p1 = importance[e1], p2 = importance[e2];\n long long A = daySumImp[a], B = daySumImp[b];\n\n long long A2 = A - p1 + p2;\n long long B2 = B - p2 + p1;\n\n long long deltaSumSq = sqll(A2) + sqll(B2) - sqll(A) - sqll(B);\n\n auto chA = makeChanges(e1, e2); // in day a: remove e1, add e2\n auto chB = makeChanges(e2, e1); // in day b: remove e2, add e1\n\n long long deltaVPa = deltaVPForDay(a, chA);\n long long deltaVPb = deltaVPForDay(b, chB);\n long long deltaVP = deltaVPa + deltaVPb;\n\n long double deltaObj = (long double)deltaSumSq + coeffVP * (long double)deltaVP;\n\n bool accept = false;\n if (deltaObj <= 0) accept = true;\n else {\n long double prob = expl(-(double)(deltaObj / T));\n if (uni01(rng) < (double)prob) accept = true;\n }\n\n if (accept) {\n // apply sums\n sumSqImp += deltaSumSq;\n daySumImp[a] = A2;\n daySumImp[b] = B2;\n\n // apply VP changes\n totalVP += deltaVP;\n applyVPChanges(a, chA);\n applyVPChanges(b, chB);\n\n // swap in vectors\n // update positions\n int posa = posInDay[e1];\n int posb = posInDay[e2];\n // use known indices ia/ib but pos arrays are safer\n posa = ia;\n posb = ib;\n\n edgesInDay[a][posa] = e2;\n edgesInDay[b][posb] = e1;\n posInDay[e2] = posa;\n posInDay[e1] = posb;\n\n dayOfEdge[e1] = b;\n dayOfEdge[e2] = a;\n\n curObj += deltaObj;\n }\n\n iters++;\n }\n\n // Output days as 1..D\n for (int i = 0; i < M; i++) {\n int d = dayOfEdge[i] + 1;\n if (i) cout << ' ';\n cout << d;\n }\n cout << '\\n';\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstruct Stick {\n int axis; // 0=x,1=y,2=z\n int x, y, z; // start coordinate (minimum along axis)\n int cur; // consumed length from the start\n int rem; // remaining length\n};\n\nstruct Candidate {\n long double obj = (1e100L);\n int n = 0;\n vector b1, b2;\n};\n\nstatic inline int idx3(int D, int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\nvector build_occ_full(int D, const vector& f, const vector& r) {\n vector occ(D*D*D, 0);\n for (int z=0; z build_occ_min(int D, const vector& f, const vector& r) {\n vector occ(D*D*D, 0);\n for (int z=0; z X, Y;\n for (int x=0; x= cy) {\n for (int t=0; t build_occ_star(int D, const vector& f, const vector& r) {\n // pick global hubs that appear in many z-rows\n int bestX = 0, bestY = 0;\n int bestXcnt = -1, bestYcnt = -1;\n for (int x=0; x bestXcnt) bestXcnt = c, bestX = x;\n }\n for (int y=0; y bestYcnt) bestYcnt = c, bestY = y;\n }\n\n vector occ(D*D*D, 0);\n for (int z=0; z X, Y;\n for (int x=0; x build_occ(int D, int strategy, const vector& f, const vector& r) {\n // 0:FULL, 1:MIN, 2:STAR\n if (strategy == 0) return build_occ_full(D,f,r);\n if (strategy == 1) return build_occ_min(D,f,r);\n return build_occ_star(D,f,r);\n}\n\nvector build_sticks(int D, const vector& occ, int axis) {\n vector sticks;\n if (axis == 0) { // x\n for (int y=0; y& sticks, int L) {\n int bestDiv = -1, best = -1;\n int bestDivLen = -1, bestLen = -1;\n for (int i=0;i<(int)sticks.size();i++) {\n const auto &s = sticks[i];\n if (s.rem < L) continue;\n if (s.rem % L == 0) {\n if (s.rem > bestDivLen) bestDivLen = s.rem, bestDiv = i;\n } else {\n if (s.rem > bestLen) bestLen = s.rem, best = i;\n }\n }\n if (bestDiv != -1) return bestDiv;\n return best;\n}\n\nvoid cut_piece(int D, Stick& s, int L, vector& b, int blockId) {\n // assign L cells from the front\n for (int t=0; t& sticks) {\n long long v=0;\n for (auto &s: sticks) v += s.rem;\n return v;\n}\n\nCandidate simulate_candidate(int D,\n const vector& occ1, const vector& occ2,\n int axis1, int axis2) {\n Candidate cand;\n cand.b1.assign(D*D*D, 0);\n cand.b2.assign(D*D*D, 0);\n\n vector s1 = build_sticks(D, occ1, axis1);\n vector s2 = build_sticks(D, occ2, axis2);\n\n int blockId = 0;\n long double sharedPenalty = 0.0L;\n\n for (int L=D; L>=1; L--) {\n while (true) {\n int i1 = find_best_stick(s1, L);\n int i2 = find_best_stick(s2, L);\n if (i1 < 0 || i2 < 0) break;\n // cut shared piece\n blockId++;\n cut_piece(D, s1[i1], L, cand.b1, blockId);\n cut_piece(D, s2[i2], L, cand.b2, blockId);\n sharedPenalty += 1.0L / (long double)L;\n }\n }\n\n // leftover exclusive sticks\n for (auto &s: s1) {\n if (s.rem <= 0) continue;\n blockId++;\n cut_piece(D, s, s.rem, cand.b1, blockId);\n }\n for (auto &s: s2) {\n if (s.rem <= 0) continue;\n blockId++;\n cut_piece(D, s, s.rem, cand.b2, blockId);\n }\n\n // objective = (r1+r2) + sum_{shared} 1/v\n // r1+r2 = volume of blocks used only in one object = total leftover volume after sharing\n // After our process, shared cuts consume equal volume from both; leftovers are exclusive.\n // We can compute exclusives as number of cells with id==0 (but we filled sticks only).\n // Easier: exclusive volume = |vol(occ1)-vol(occ2)| if everything in smaller got shared.\n // Our algorithm shares all possible including L=1, so yes.\n long long V1=0, V2=0;\n for (char c: occ1) V1 += c;\n for (char c: occ2) V2 += c;\n long double exclusive = (long double) llabs(V1 - V2);\n\n cand.n = blockId;\n cand.obj = exclusive + sharedPenalty;\n return cand;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D;\n cin >> D;\n vector f(2*D), r(2*D);\n vector> F(2, vector(D)), R(2, vector(D));\n for (int i=0;i<2;i++) {\n for (int z=0; z> F[i][z];\n for (int z=0; z> R[i][z];\n }\n\n vector strategies = {0,1,2}; // FULL, MIN, STAR\n vector axes = {0,1,2}; // x,y,z\n\n Candidate best;\n\n // Prebuild occ for each strategy and object\n vector>> occs(2, vector>(3));\n for (int i=0;i<2;i++) {\n for (int s: strategies) {\n occs[i][s] = build_occ(D, s, F[i], R[i]);\n }\n }\n\n for (int s1: strategies) for (int s2: strategies) {\n const auto &occ1 = occs[0][s1];\n const auto &occ2 = occs[1][s2];\n for (int a1: axes) for (int a2: axes) {\n Candidate cand = simulate_candidate(D, occ1, occ2, a1, a2);\n if (cand.obj + 1e-18L < best.obj) {\n best = std::move(cand);\n }\n }\n }\n\n cout << best.n << \"\\n\";\n // output b1, b2 in order (x*D^2 + y*D + z)\n for (int i=0; i\nusing namespace std;\n\nstatic const long long INFLL = (1LL<<60);\n\nstruct Edge {\n int u, v;\n long long w;\n};\n\nstruct EvalResult {\n bool valid = false;\n long long S = INFLL;\n vector P; // size N\n vector B; // size M (0/1)\n vector assign; // size K, assigned station (0-based)\n};\n\nstatic inline int ceil_sqrt_ll(long long x) {\n if (x <= 0) return 0;\n long long r = (long long)floor(sqrt((long double)x));\n while (r*r < x) ++r;\n while (r>0 && (r-1)*(r-1) >= x) --r;\n if (r > 5000) return 5001;\n return (int)r;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K;\n cin >> N >> M >> K;\n vector x(N), y(N);\n for (int i = 0; i < N; i++) cin >> x[i] >> y[i];\n\n vector edges(M);\n // For Floyd init: keep minimum edge between two vertices if any (graph is simple, but be safe)\n vector> dist(N, vector(N, INFLL));\n vector> nxt(N, vector(N, -1));\n vector> edgeId(N, vector(N, -1));\n\n for (int i = 0; i < N; i++) {\n dist[i][i] = 0;\n nxt[i][i] = i;\n }\n\n for (int j = 0; j < M; j++) {\n int u, v;\n long long w;\n cin >> u >> v >> w;\n --u; --v;\n edges[j] = {u, v, w};\n if (w < dist[u][v]) {\n dist[u][v] = dist[v][u] = w;\n nxt[u][v] = v;\n nxt[v][u] = u;\n edgeId[u][v] = edgeId[v][u] = j;\n }\n }\n\n vector a(K), b(K);\n for (int k = 0; k < K; k++) cin >> a[k] >> b[k];\n\n // Precompute resident->station distances (ceil Euclid), store as uint16_t (<=5001)\n vector> d; // N is fixed 100 per statement, but keep dynamic-safe\n d.resize(K);\n for (int k = 0; k < K; k++) {\n for (int i = 0; i < N; i++) {\n long long dx = (long long)a[k] - x[i];\n long long dy = (long long)b[k] - y[i];\n long long dsq = dx*dx + dy*dy;\n int cd = ceil_sqrt_ll(dsq);\n if (cd > 5000) cd = 5001;\n d[k][i] = (uint16_t)cd;\n }\n }\n\n // Floyd-Warshall with path reconstruction via nxt\n for (int k = 0; k < N; k++) {\n for (int i = 0; i < N; i++) if (dist[i][k] < INFLL) {\n for (int j = 0; j < N; j++) if (dist[k][j] < INFLL) {\n long long nd = dist[i][k] + dist[k][j];\n if (nd < dist[i][j]) {\n dist[i][j] = nd;\n nxt[i][j] = nxt[i][k];\n }\n }\n }\n }\n\n auto reconstruct_path_edges = [&](int s, int t, vector& Bmark) -> void {\n int cur = s;\n while (cur != t) {\n int nx = nxt[cur][t];\n if (nx < 0) return; // disconnected (should not happen)\n int eid = edgeId[cur][nx];\n if (eid >= 0) Bmark[eid] = 1;\n cur = nx;\n }\n };\n\n auto evaluate = [&](const vector& U) -> EvalResult {\n EvalResult res;\n res.P.assign(N, 0);\n res.B.assign(M, 0);\n res.assign.assign(K, -1);\n\n // Assign each resident to nearest allowed station\n vector cnt(N, 0);\n for (int k = 0; k < K; k++) {\n int besti = -1;\n int bestd = 5002;\n // scan all stations (N=100)\n for (int i = 0; i < N; i++) if (U[i]) {\n int di = (int)d[k][i];\n if (di < bestd) { bestd = di; besti = i; }\n }\n if (besti < 0 || bestd > 5000) {\n res.valid = false;\n return res;\n }\n res.assign[k] = besti;\n cnt[besti]++;\n if (bestd > res.P[besti]) res.P[besti] = bestd;\n }\n\n // Active stations A: those with P>0 plus root(0)\n vector active;\n active.reserve(N);\n vector isActive(N, 0);\n isActive[0] = 1;\n active.push_back(0);\n for (int i = 1; i < N; i++) {\n if (res.P[i] > 0) {\n isActive[i] = 1;\n active.push_back(i);\n }\n }\n\n // If only root active, still valid (but then residents couldn't be assigned elsewhere => impossible unless all within P1)\n // But our assignment would have set P1 accordingly.\n\n // Metric MST (Prim) over active nodes with weights dist[u][v]\n int A = (int)active.size();\n vector best(A, INFLL);\n vector parent(A, -1);\n vector used(A, 0);\n best[0] = 0;\n for (int it = 0; it < A; it++) {\n int v = -1;\n for (int i = 0; i < A; i++) if (!used[i]) {\n if (v < 0 || best[i] < best[v]) v = i;\n }\n if (v < 0 || best[v] >= INFLL/2) {\n res.valid = false;\n return res; // should not happen in connected graph\n }\n used[v] = 1;\n int vv = active[v];\n for (int i = 0; i < A; i++) if (!used[i]) {\n int uu = active[i];\n long long w = dist[vv][uu];\n if (w < best[i]) {\n best[i] = w;\n parent[i] = v;\n }\n }\n }\n\n // Reconstruct union of shortest paths for MST edges\n vector Bmark(M, 0);\n for (int i = 1; i < A; i++) {\n int u = active[i];\n int p = active[parent[i]];\n reconstruct_path_edges(u, p, Bmark);\n }\n\n long long edgeCost = 0;\n for (int j = 0; j < M; j++) if (Bmark[j]) edgeCost += edges[j].w;\n\n long long radCost = 0;\n for (int i = 0; i < N; i++) {\n long long pi = res.P[i];\n radCost += pi * pi;\n }\n\n res.valid = true;\n res.S = radCost + edgeCost;\n res.B = std::move(Bmark);\n return res;\n };\n\n // Time management\n auto t_start = chrono::steady_clock::now();\n auto elapsed_ms = [&]() -> long long {\n auto t_now = chrono::steady_clock::now();\n return chrono::duration_cast(t_now - t_start).count();\n };\n\n // Random engine\n std::mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n EvalResult bestGlobal;\n bestGlobal.S = INFLL;\n\n int restarts = 3; // keep small for safety\n for (int rep = 0; rep < restarts; rep++) {\n if (elapsed_ms() > 1850) break;\n\n vector U(N, 1);\n U[0] = 1;\n\n EvalResult cur = evaluate(U);\n if (!cur.valid) {\n // fallback: should never happen since U=all stations\n continue;\n }\n\n // Removal order: far from root first, with some randomization\n vector order;\n order.reserve(N-1);\n for (int i = 1; i < N; i++) order.push_back(i);\n sort(order.begin(), order.end(), [&](int a, int b){\n return dist[0][a] > dist[0][b];\n });\n // slight shuffle in chunks to diversify\n for (int i = 0; i < (int)order.size(); i += 10) {\n int r = min((int)order.size(), i + 10);\n shuffle(order.begin() + i, order.begin() + r, rng);\n }\n\n bool improved = true;\n while (improved && elapsed_ms() <= 1900) {\n improved = false;\n for (int idx = 0; idx < (int)order.size(); idx++) {\n if (elapsed_ms() > 1900) break;\n int v = order[idx];\n if (!U[v]) continue;\n U[v] = 0;\n EvalResult nxtRes = evaluate(U);\n if (nxtRes.valid && nxtRes.S < cur.S) {\n cur = std::move(nxtRes);\n improved = true;\n } else {\n U[v] = 1;\n }\n }\n }\n\n if (cur.valid && cur.S < bestGlobal.S) bestGlobal = std::move(cur);\n }\n\n // Output best found\n if (!bestGlobal.valid) {\n // absolute fallback: all edges OFF, all radii 0 (will score poorly but valid output format)\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << 0;\n }\n cout << \"\\n\";\n for (int j = 0; j < M; j++) {\n if (j) cout << ' ';\n cout << 0;\n }\n cout << \"\\n\";\n return 0;\n }\n\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << bestGlobal.P[i];\n }\n cout << \"\\n\";\n for (int j = 0; j < M; j++) {\n if (j) cout << ' ';\n cout << bestGlobal.B[j];\n }\n cout << \"\\n\";\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nstruct Op {\n int x1, y1, x2, y2;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n static constexpr int N = 30;\n vector> b(N, vector(N, -1));\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) cin >> b[x][y];\n }\n\n vector ops;\n ops.reserve(10000);\n\n auto do_swap = [&](int x1, int y1, int x2, int y2) {\n swap(b[x1][y1], b[x2][y2]);\n ops.push_back({x1, y1, x2, y2});\n };\n\n auto siftDown = [&](int sx, int sy) {\n int x = sx, y = sy;\n while (x < N - 1) {\n int lx = x + 1, ly = y;\n int rx = x + 1, ry = y + 1;\n\n int bestx = x, besty = y;\n if (b[lx][ly] < b[bestx][besty]) { bestx = lx; besty = ly; }\n if (b[rx][ry] < b[bestx][besty]) { bestx = rx; besty = ry; }\n\n if (bestx == x && besty == y) break; // heap property satisfied here\n\n if ((int)ops.size() >= 10000) return; // safety (shouldn't happen)\n do_swap(x, y, bestx, besty);\n x = bestx; y = besty;\n }\n };\n\n // Floyd heapify: bottom-up\n for (int x = N - 2; x >= 0; x--) {\n for (int y = 0; y <= x; y++) {\n siftDown(x, y);\n if ((int)ops.size() >= 10000) break;\n }\n if ((int)ops.size() >= 10000) break;\n }\n\n cout << ops.size() << \"\\n\";\n for (auto &op : ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nstatic constexpr int D = 9;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n uint32_t next_u32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n int next_int(int n) { return (int)(next_u32() % (uint32_t)n); }\n};\n\nstruct Cell { int r, c; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Din, N;\n cin >> Din >> N;\n // D is fixed to 9 in all testcases.\n int ent_r = 0, ent_c = (D - 1) / 2;\n\n bool obstacle[D][D]{};\n for (int k = 0; k < N; k++) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n }\n\n // Count containers\n int M = D * D - 1 - N; // number of containers (labels 0..M-1)\n\n // Precompute static BFS distances from entrance on obstacle grid.\n const int INF = 1e9;\n int dist0[D][D];\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) dist0[i][j] = INF;\n\n queue q;\n dist0[ent_r][ent_c] = 0;\n q.push({ent_r, ent_c});\n int dr[4] = {1,-1,0,0};\n int dc[4] = {0,0,1,-1};\n while (!q.empty()) {\n auto [r,c] = q.front(); q.pop();\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (dist0[nr][nc] != INF) continue;\n dist0[nr][nc] = dist0[r][c] + 1;\n q.push({nr,nc});\n }\n }\n\n // Build rank map: sort usable cells (excluding entrance, excluding obstacles) by (dist, r, c).\n vector usable;\n usable.reserve(M);\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (obstacle[i][j]) continue;\n if (i == ent_r && j == ent_c) continue;\n usable.push_back({i,j});\n }\n sort(usable.begin(), usable.end(), [&](const Cell& a, const Cell& b){\n int da = dist0[a.r][a.c];\n int db = dist0[b.r][b.c];\n if (da != db) return da < db;\n if (a.r != b.r) return a.r < b.r;\n return a.c < b.c;\n });\n int rankCell[D][D];\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) rankCell[i][j] = -1;\n for (int i = 0; i < (int)usable.size(); i++) {\n rankCell[usable[i].r][usable[i].c] = i; // 0..M-1\n }\n\n // Current state during placement:\n // empty[r][c] = true means currently empty and traversable (for placement reachability graph).\n bool emptyCell[D][D]{};\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (obstacle[i][j]) emptyCell[i][j] = false;\n else emptyCell[i][j] = true;\n }\n // label stored for containers (valid once placed)\n int labelAt[D][D];\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) labelAt[i][j] = -1;\n\n XorShift rng;\n\n auto compute_articulation = [&]() {\n // Build id mapping for empty cells (including entrance), obstacles excluded.\n int id[D][D];\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) id[i][j] = -1;\n vector nodes;\n nodes.reserve(D*D);\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (obstacle[i][j]) continue;\n if (!emptyCell[i][j]) continue;\n id[i][j] = (int)nodes.size();\n nodes.push_back({i,j});\n }\n int V = (int)nodes.size();\n vector disc(V, 0), low(V, 0), parent(V, -1);\n vector isArt(V, 0);\n int timer = 0;\n\n int root = id[ent_r][ent_c];\n // Should always exist\n if (root < 0) {\n // degenerate, but shouldn't happen\n vector> art(D, vector(D, 0));\n return art;\n }\n\n function dfs = [&](int u) {\n disc[u] = low[u] = ++timer;\n int children = 0;\n auto [r,c] = nodes[u];\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n int v = id[nr][nc];\n if (v < 0) continue;\n if (!disc[v]) {\n parent[v] = u;\n children++;\n dfs(v);\n low[u] = min(low[u], low[v]);\n if (parent[u] == -1) {\n if (children > 1) isArt[u] = 1;\n } else {\n if (low[v] >= disc[u]) isArt[u] = 1;\n }\n } else if (v != parent[u]) {\n low[u] = min(low[u], disc[v]);\n }\n }\n };\n\n dfs(root);\n\n vector> art(D, vector(D, 0));\n for (int u = 0; u < V; u++) {\n auto [r,c] = nodes[u];\n art[r][c] = isArt[u];\n }\n return art;\n };\n\n auto deg_empty = [&](int r, int c) {\n int d = 0;\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (emptyCell[nr][nc]) d++;\n }\n return d;\n };\n\n // Placement phase\n for (int step = 0; step < M; step++) {\n int t;\n cin >> t;\n\n auto art = compute_articulation();\n\n vector cand;\n cand.reserve(D*D);\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (obstacle[i][j]) continue;\n if (!emptyCell[i][j]) continue;\n if (i == ent_r && j == ent_c) continue;\n if (art[i][j]) continue; // avoid cut vertices\n cand.push_back({i,j});\n }\n if (cand.empty()) {\n // Fallback (should rarely happen): allow any empty non-entrance\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (obstacle[i][j]) continue;\n if (!emptyCell[i][j]) continue;\n if (i == ent_r && j == ent_c) continue;\n cand.push_back({i,j});\n }\n }\n\n // Choose best candidate by rank matching.\n // score = 100*|rank - t| + 3*deg + small random\n long long bestScore = (1LL<<60);\n vector bests;\n for (auto &c : cand) {\n int r = c.r, cc = c.c;\n int rk = rankCell[r][cc];\n if (rk < 0) continue;\n long long s = llabs(rk - t) * 100LL + deg_empty(r, cc) * 3LL + (rng.next_u32() % 3u);\n if (s < bestScore) {\n bestScore = s;\n bests.clear();\n bests.push_back(c);\n } else if (s == bestScore) {\n bests.push_back(c);\n }\n }\n if (bests.empty()) {\n // should not happen, but just in case\n bests = cand;\n }\n Cell chosen = bests[rng.next_int((int)bests.size())];\n\n cout << chosen.r << \" \" << chosen.c << endl; // endl flushes\n // place container\n emptyCell[chosen.r][chosen.c] = false;\n labelAt[chosen.r][chosen.c] = t;\n }\n\n // Retrieval phase: greedy smallest reachable container.\n bool removed[D][D]{};\n bool reachable[D][D]{};\n bool inPQ[D][D]{};\n\n auto is_empty_now = [&](int r, int c)->bool{\n if (obstacle[r][c]) return false;\n if (r == ent_r && c == ent_c) return true;\n return removed[r][c];\n };\n auto has_container = [&](int r, int c)->bool{\n if (obstacle[r][c]) return false;\n if (r == ent_r && c == ent_c) return false;\n return !removed[r][c];\n };\n\n struct Item {\n int t, r, c;\n bool operator>(const Item& other) const { return t > other.t; }\n };\n priority_queue, greater> pq;\n\n queue bfs;\n reachable[ent_r][ent_c] = true;\n bfs.push({ent_r, ent_c});\n\n auto expand = [&]() {\n while (!bfs.empty()) {\n auto [r,c] = bfs.front(); bfs.pop();\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (is_empty_now(nr,nc)) {\n if (!reachable[nr][nc]) {\n reachable[nr][nc] = true;\n bfs.push({nr,nc});\n }\n } else if (has_container(nr,nc)) {\n if (!inPQ[nr][nc]) {\n inPQ[nr][nc] = true;\n pq.push({labelAt[nr][nc], nr, nc});\n }\n }\n }\n }\n };\n\n expand();\n\n for (int k = 0; k < M; k++) {\n while (!pq.empty()) {\n auto it = pq.top(); pq.pop();\n int r = it.r, c = it.c;\n if (removed[r][c]) continue; // stale\n // remove it\n cout << r << \" \" << c << endl;\n removed[r][c] = true;\n // Now it's an empty cell and must be reachable (it was adjacent to reachable empty).\n if (!reachable[r][c]) {\n reachable[r][c] = true;\n bfs.push({r,c});\n }\n expand();\n break;\n }\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nstatic const int NMAX = 50;\nstatic const int CMAX = 100;\n\nstruct Pos { int r, c; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m; // n=50, m=100\n vector> g(n, vector(n));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) cin >> g[i][j];\n }\n\n const int V = m + 1; // colors 0..m\n\n auto inside = [&](int r, int c) { return 0 <= r && r < n && 0 <= c && c < n; };\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n\n // orig adjacency (boolean)\n vector> orig(V, vector(V, 0));\n auto add_orig_edge = [&](int a, int b) {\n if (a == b) return;\n if (a > b) swap(a, b);\n orig[a][b] = 1;\n };\n\n // Build original adjacency among 1..m\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j + 1 < n) add_orig_edge(g[i][j], g[i][j+1]);\n if (i + 1 < n) add_orig_edge(g[i][j], g[i+1][j]);\n }\n }\n // Original adjacency with outside(0) from boundary\n for (int i = 0; i < n; i++) {\n add_orig_edge(0, g[i][0]);\n add_orig_edge(0, g[i][n-1]);\n }\n for (int j = 0; j < n; j++) {\n add_orig_edge(0, g[0][j]);\n add_orig_edge(0, g[n-1][j]);\n }\n\n vector inB(V, 0);\n for (int c = 1; c <= m; c++) {\n int a = 0, b = c;\n if (a > b) swap(a, b);\n if (orig[a][b]) inB[c] = 1;\n }\n\n // Current adjacency counts among non-zero colors (and between non-zero colors).\n // cnt[a][b] for a> cnt(V, vector(V, 0));\n auto add_cnt_edge = [&](int a, int b, int delta) {\n if (a == b) return;\n if (a > b) swap(a, b);\n cnt[a][b] += delta;\n };\n\n // cur0[c] = number of adjacency edges between color c and 0 (outside boundary edges + internal 0 edges)\n vector cur0(V, 0);\n\n // Initialize adjacency counts from current grid (initially equals original grid, no internal 0).\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j + 1 < n) {\n int a = g[i][j], b = g[i][j+1];\n if (a != b && a != 0 && b != 0) add_cnt_edge(a, b, +1);\n }\n if (i + 1 < n) {\n int a = g[i][j], b = g[i+1][j];\n if (a != b && a != 0 && b != 0) add_cnt_edge(a, b, +1);\n }\n }\n }\n // boundary outside adjacency counts (0 with boundary cell colors)\n for (int i = 0; i < n; i++) {\n cur0[g[i][0]]++;\n cur0[g[i][n-1]]++;\n }\n for (int j = 0; j < n; j++) {\n cur0[g[0][j]]++;\n cur0[g[n-1][j]]++;\n }\n\n // sizes and representatives for colors 1..m\n vector sz(V, 0);\n vector rep(V, Pos{-1,-1});\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n int c = g[i][j];\n if (c != 0) {\n sz[c]++;\n rep[c] = Pos{i,j};\n }\n }\n\n // BFS visited stamp for connectivity checks\n static int vis[NMAX][NMAX];\n int stamp = 1;\n\n auto find_rep_scan = [&](int col) -> Pos {\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n if (g[i][j] == col) return Pos{i,j};\n }\n return Pos{-1,-1};\n };\n\n auto connected_after_removal = [&](int col, int rr, int cc) -> bool {\n // col != 0, and we assume sz[col] >= 2 before removal.\n Pos st = rep[col];\n if (!(st.r >= 0 && g[st.r][st.c] == col) || (st.r == rr && st.c == cc)) {\n // try neighbor first\n bool found = false;\n for (int k = 0; k < 4 && !found; k++) {\n int nr = rr + dr[k], nc = cc + dc[k];\n if (inside(nr,nc) && g[nr][nc] == col) {\n st = Pos{nr,nc};\n found = true;\n }\n }\n if (!found) st = find_rep_scan(col);\n if (st.r < 0) return false; // shouldn't happen because sz[col]>=2\n }\n\n stamp++;\n deque q;\n vis[st.r][st.c] = stamp;\n q.push_back(st);\n int reached = 0;\n\n while (!q.empty()) {\n Pos p = q.front(); q.pop_front();\n reached++;\n for (int k = 0; k < 4; k++) {\n int nr = p.r + dr[k], nc = p.c + dc[k];\n if (!inside(nr,nc)) continue;\n if (nr == rr && nc == cc) continue; // removed cell\n if (g[nr][nc] != col) continue;\n if (vis[nr][nc] == stamp) continue;\n vis[nr][nc] = stamp;\n q.push_back(Pos{nr,nc});\n }\n }\n return reached == sz[col] - 1;\n };\n\n auto boundary_edges = [&](int r, int c) -> int {\n int b = 0;\n if (r == 0) b++;\n if (r == n-1) b++;\n if (c == 0) b++;\n if (c == n-1) b++;\n return b;\n };\n\n // Frontier: boundary cells + cells adjacent to existing 0.\n vector frontier;\n frontier.reserve(n*n*4);\n for (int i = 0; i < n; i++) {\n frontier.push_back(Pos{i,0});\n frontier.push_back(Pos{i,n-1});\n }\n for (int j = 0; j < n; j++) {\n frontier.push_back(Pos{0,j});\n frontier.push_back(Pos{n-1,j});\n }\n\n auto zero_count = [&]() -> int {\n int z = 0;\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) if (g[i][j] == 0) z++;\n return z;\n };\n\n vector> best = g;\n int bestZ = zero_count();\n\n // RNG\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n std::mt19937_64 rng(seed);\n\n auto try_remove = [&](int r, int c) -> bool {\n int col = g[r][c];\n if (col == 0) return false;\n if (sz[col] <= 1) return false;\n\n int bnd = boundary_edges(r, c);\n\n int same = 0;\n int neigh0 = 0;\n static int diffCnt[CMAX+1+1];\n static int touched[CMAX+1+1];\n int touchedN = 0;\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 d = g[nr][nc];\n if (d == col) same++;\n else if (d == 0) neigh0++;\n else {\n if (diffCnt[d] == 0) touched[touchedN++] = d;\n diffCnt[d]++;\n }\n }\n\n // Ensure new 0 cell is connected to outside-connected 0 component:\n // boundary cell is connected (touch outside), or adjacent to existing 0.\n if (bnd == 0 && neigh0 == 0) {\n for (int i = 0; i < touchedN; i++) diffCnt[touched[i]] = 0;\n return false;\n }\n\n // We will create 0 adjacency to every neighboring nonzero color (including col via same neighbors).\n // So all neighboring different colors must be in B.\n for (int i = 0; i < touchedN; i++) {\n int d = touched[i];\n if (!inB[d]) {\n for (int j = 0; j < touchedN; j++) diffCnt[touched[j]] = 0;\n return false;\n }\n }\n\n // Update of cur0[col]\n int new_cur0_col = cur0[col] + same - neigh0 - bnd;\n if (!inB[col]) {\n // must stay exactly 0\n if (new_cur0_col != 0) {\n for (int j = 0; j < touchedN; j++) diffCnt[touched[j]] = 0;\n return false;\n }\n } else {\n // must remain adjacent to 0\n if (new_cur0_col <= 0) {\n for (int j = 0; j < touchedN; j++) diffCnt[touched[j]] = 0;\n return false;\n }\n }\n\n // Check we don't delete the last adjacency for any required edge (col,d)\n for (int i = 0; i < touchedN; i++) {\n int d = touched[i];\n int k = diffCnt[d];\n int a = min(col, d), b = max(col, d);\n if (orig[a][b]) { // required\n if (cnt[a][b] - k <= 0) {\n for (int j = 0; j < touchedN; j++) diffCnt[touched[j]] = 0;\n return false;\n }\n }\n }\n\n // Connectivity check for col after removing (r,c)\n if (!connected_after_removal(col, r, c)) {\n for (int j = 0; j < touchedN; j++) diffCnt[touched[j]] = 0;\n return false;\n }\n\n // Apply updates:\n // For each neighbor different color d:\n // - remove col-d adjacency edges (cnt--)\n // - add 0-d adjacency edges (cur0[d]++)\n for (int i = 0; i < touchedN; i++) {\n int d = touched[i];\n int k = diffCnt[d];\n int a = min(col, d), b = max(col, d);\n cnt[a][b] -= k;\n cur0[d] += k;\n }\n // Update cur0[col]\n cur0[col] = new_cur0_col;\n\n // Remove cell\n g[r][c] = 0;\n sz[col]--;\n if (rep[col].r == r && rep[col].c == c) {\n rep[col] = find_rep_scan(col);\n }\n\n // Add neighbors as new frontier (adjacent to new 0 cell)\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 if (g[nr][nc] != 0) frontier.push_back(Pos{nr,nc});\n }\n\n // clear diffCnt entries\n for (int j = 0; j < touchedN; j++) diffCnt[touched[j]] = 0;\n\n return true;\n };\n\n auto startTime = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 1.90; // seconds, keep margin\n\n // Main loop: randomized carving\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double t = chrono::duration(now - startTime).count();\n if (t > TIME_LIMIT) break;\n\n if (frontier.empty()) break;\n int idx = (int)(rng() % frontier.size());\n Pos p = frontier[idx];\n frontier[idx] = frontier.back();\n frontier.pop_back();\n\n if (try_remove(p.r, p.c)) {\n int z = zero_count();\n if (z > bestZ) {\n bestZ = z;\n best = g;\n }\n }\n }\n\n // Output best found\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 return 0;\n}","ahc025":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Solver {\n int N, D, Q;\n int used = 0;\n\n XorShift rng;\n\n // Estimated rank-based \"weights\"\n vector west;\n vector order; // ascending by estimated weight (light -> heavy)\n\n // Final bins\n vector> bins;\n vector binSumEst;\n\n Solver() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cin >> N >> D >> Q;\n west.assign(N, 1.0);\n }\n\n char query_sets(const vector& L, const vector& R) {\n // Must be non-empty and disjoint.\n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << \"\\n\" << flush;\n\n string s;\n cin >> s;\n used++;\n return s[0];\n }\n\n char cmp_item(int a, int b) {\n // Compare {a} vs {b}\n vector L = {a}, R = {b};\n return query_sets(L, R);\n }\n\n // Insert item x into current \"order\" (ascending light->heavy),\n // using up to k comparisons (k can be small).\n void insert_with_budget(int x, int k) {\n int m = (int)order.size();\n if (m == 0) { order.push_back(x); return; }\n if (k <= 0) { order.push_back(x); return; }\n\n // If we have enough, do normal binary-search insertion by comparisons.\n int need = 0;\n while ((1 << need) < (m + 1)) need++;\n if (k >= need) {\n int lo = 0, hi = m;\n while (lo < hi && k > 0) {\n int mid = (lo + hi) >> 1;\n char res = cmp_item(x, order[mid]);\n k--;\n // res == '<' means x lighter than order[mid] => go left\n if (res == '<') hi = mid;\n else lo = mid + 1;\n }\n order.insert(order.begin() + lo, x);\n return;\n }\n\n // Coarse insertion: compare against a few evenly spaced pivots.\n int lowBound = 0, highBound = m;\n for (int t = 1; t <= k; t++) {\n int pos = (int)((long long)t * m / (k + 1));\n pos = max(0, min(m - 1, pos));\n char res = cmp_item(x, order[pos]);\n // If x < pivot, it must be before pos\n if (res == '<') highBound = min(highBound, pos);\n // If x > pivot, it must be after pos\n else if (res == '>') lowBound = max(lowBound, pos + 1);\n else {\n // Equal: insert around pos\n lowBound = max(lowBound, pos);\n highBound = min(highBound, pos + 1);\n }\n }\n\n int ins = lowBound;\n if (lowBound > highBound) ins = (lowBound + highBound) / 2;\n ins = max(0, min(m, ins));\n order.insert(order.begin() + ins, x);\n }\n\n void build_order() {\n vector items(N);\n iota(items.begin(), items.end(), 0);\n // Randomize insertion order to reduce bias under small Q\n for (int i = N - 1; i > 0; i--) swap(items[i], items[rng.next_int(0, i)]);\n\n order.clear();\n order.reserve(N);\n\n // Allocate ~70% queries to sorting/order learning\n int sortBudget = (int)llround(Q * 0.70);\n sortBudget = max(0, min(Q, sortBudget));\n\n int idx = 0;\n if (idx < N) {\n order.push_back(items[idx++]);\n }\n while (idx < N) {\n int remItems = N - idx;\n int remQ = sortBudget - used;\n if (remQ <= 0) break;\n\n // comparisons per insertion (adaptive)\n int k = max(1, remQ / remItems);\n k = min(k, 8); // keep it small; coarse is fine\n insert_with_budget(items[idx], k);\n idx++;\n if (used >= sortBudget) break;\n }\n\n // If we didn't insert all items in order-building, append remaining unsorted.\n while (idx < N) {\n order.push_back(items[idx++]);\n }\n\n // Now order is \"approx ascending\" by weight.\n // Assign rank-based pseudo-weights (exponential mapping).\n // base tuned mildly by D (more bins -> prefer a bit steeper).\n double base = 1.09 + 0.02 * min(1.0, (double)D / 20.0);\n vector pos(N);\n for (int i = 0; i < N; i++) pos[order[i]] = i;\n\n for (int i = 0; i < N; i++) {\n west[i] = pow(base, pos[i]);\n }\n }\n\n void initial_partition() {\n bins.assign(D, {});\n binSumEst.assign(D, 0.0);\n\n // Use heaviest-first (reverse of ascending order)\n vector heavy(order.rbegin(), order.rend());\n\n // Seed: ensure each bin non-empty with first D heaviest\n int ptr = 0;\n for (int b = 0; b < D; b++) {\n int it = heavy[ptr++];\n bins[b].push_back(it);\n binSumEst[b] += west[it];\n }\n\n // Then LPT\n for (; ptr < (int)heavy.size(); ptr++) {\n int it = heavy[ptr];\n int best = 0;\n for (int b = 1; b < D; b++) {\n if (binSumEst[b] < binSumEst[best]) best = b;\n }\n bins[best].push_back(it);\n binSumEst[best] += west[it];\n }\n }\n\n vector bin_items_sorted_by_est_asc(int b) {\n auto v = bins[b];\n sort(v.begin(), v.end(), [&](int i, int j){\n return west[i] < west[j];\n });\n return v;\n }\n\n // Try to move one item from heavy->light using a few queries.\n // Returns true if moved.\n bool balance_once(int bHeavy, int bLight) {\n if (bHeavy == bLight) return false;\n if ((int)bins[bHeavy].size() <= 1) return false; // don't empty the bin\n if ((int)bins[bLight].size() <= 0) return false; // should not happen\n\n // Candidates in heavy bin sorted by estimated weight ascending (light -> heavy)\n vector cand = bin_items_sorted_by_est_asc(bHeavy);\n // Exclude the only item? already ensured size>=2 so ok.\n\n auto test_move_pred = [&](int x)->char {\n // Compare (heavy without x) vs (light with x)\n vector L, R;\n L.reserve(bins[bHeavy].size() - 1);\n R.reserve(bins[bLight].size() + 1);\n for (int it : bins[bHeavy]) if (it != x) L.push_back(it);\n for (int it : bins[bLight]) R.push_back(it);\n R.push_back(x);\n\n // L and R must be non-empty. L non-empty because heavy size>=2.\n return query_sets(L, R);\n };\n\n // Binary search smallest item (by est) such that after moving it,\n // heavy_without_x <= light_plus_x, i.e. response is '<' or '=' (not '>').\n int lo = 0, hi = (int)cand.size() - 1;\n int ans = -1;\n\n // Limit steps based on remaining queries\n int remQ = Q - used;\n int maxSteps = min(7, remQ); // <= 7 predicate queries\n for (int step = 0; step < maxSteps && lo <= hi; step++) {\n int mid = (lo + hi) >> 1;\n int x = cand[mid];\n char res = test_move_pred(x);\n // res == '>' means (heavy\\{x}) still heavier => x too light => need heavier => go right\n if (res == '>') {\n lo = mid + 1;\n } else {\n ans = mid;\n hi = mid - 1;\n }\n if (used >= Q) break;\n }\n\n if (ans == -1) ans = (int)cand.size() - 1; // even heaviest doesn't flip, move heaviest\n\n int x = cand[ans];\n\n // Perform the move\n {\n auto &A = bins[bHeavy];\n auto it = find(A.begin(), A.end(), x);\n if (it == A.end()) return false;\n A.erase(it);\n }\n bins[bLight].push_back(x);\n\n binSumEst[bHeavy] -= west[x];\n binSumEst[bLight] += west[x];\n return true;\n }\n\n void balancing_phase() {\n while (used < Q) {\n // Pick bins with max/min estimated sums\n int bMax = 0, bMin = 0;\n for (int b = 1; b < D; b++) {\n if (binSumEst[b] > binSumEst[bMax]) bMax = b;\n if (binSumEst[b] < binSumEst[bMin]) bMin = b;\n }\n if (bMax == bMin) break;\n\n // Need at least 1 query to compare full bins.\n if (used >= Q) break;\n\n // Compare full bins to know true heavier side.\n char res = query_sets(bins[bMax], bins[bMin]);\n if (used >= Q) break;\n\n int heavy = -1, light = -1;\n if (res == '>') { heavy = bMax; light = bMin; }\n else if (res == '<') { heavy = bMin; light = bMax; }\n else {\n // equal, great; do nothing\n continue;\n }\n\n // Try a guided move with remaining queries.\n if (used >= Q) break;\n bool moved = balance_once(heavy, light);\n if (!moved) {\n // If can't move, just continue; might be stuck due to bin sizes.\n continue;\n }\n }\n }\n\n void consume_remaining_queries_dummy() {\n // Must do exactly Q queries. If any remain, do harmless fixed queries.\n while (used < Q) {\n int a = 0, b = 1;\n if (N >= 2) {\n vector L = {a}, R = {b};\n query_sets(L, R);\n } else {\n // Should never happen (N>=30)\n vector L = {0}, R = {0};\n query_sets(L, R);\n }\n }\n }\n\n void output_answer() {\n vector ans(N, 0);\n for (int b = 0; b < D; b++) {\n for (int it : bins[b]) ans[it] = b;\n }\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << ans[i];\n }\n cout << \"\\n\" << flush;\n }\n\n void solve() {\n build_order();\n initial_partition();\n balancing_phase();\n consume_remaining_queries_dummy();\n output_answer();\n }\n};\n\nint main() {\n Solver solver;\n solver.solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x;\n XorShift() {\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n x = seed ? seed : 88172645463325252ULL;\n }\n uint32_t next_u32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)(x & 0xffffffffu);\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u32() % (uint32_t)(r - l + 1));\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m; // here always n=200, m=10\n vector> st(m);\n for (int i = 0; i < m; i++) {\n st[i].resize(n / m);\n for (int j = 0; j < n / m; j++) cin >> st[i][j]; // bottom -> top\n }\n\n vector> ops;\n ops.reserve(5000);\n\n auto find_box = [&](int v) -> pair {\n // returns (stack index, position index from bottom), or (-1,-1)\n for (int i = 0; i < m; i++) {\n for (int j = 0; j < (int)st[i].size(); j++) {\n if (st[i][j] == v) return {i, j};\n }\n }\n return {-1, -1};\n };\n\n auto stack_min = [&](int i) -> int {\n if (st[i].empty()) return INT_MAX;\n return *min_element(st[i].begin(), st[i].end());\n };\n\n XorShift rng;\n\n int cur = 1;\n while (cur <= n) {\n auto [s, pos] = find_box(cur);\n if (s < 0) {\n // Should never happen.\n break;\n }\n\n // If cur already on top -> remove it.\n if (!st[s].empty() && st[s].back() == cur) {\n ops.emplace_back(cur, 0);\n st[s].pop_back();\n cur++;\n continue;\n }\n\n // Otherwise move all boxes above cur as one block.\n int h = (int)st[s].size();\n int start = pos + 1; // first box above cur\n int bottomMoved = st[s][start]; // \"v\" in operation1\n vector block(st[s].begin() + start, st[s].end());\n st[s].erase(st[s].begin() + start, st[s].end());\n\n // Choose destination stack d != s by heuristic:\n // - avoid covering stacks that contain small (soon) numbers\n // - prefer large min and large top\n // - keep heights small\n const int SOON_W = 25; // \"soon\" window\n long long bestEval = (1LL<<62);\n vector candidates;\n\n for (int d = 0; d < m; d++) if (d != s) {\n int hd = (int)st[d].size();\n int mind = stack_min(d);\n int topd = st[d].empty() ? INT_MAX : st[d].back();\n\n long long eval = 0;\n\n // Main: keep height moderate\n eval += 120LL * hd;\n\n // Prefer dumping onto stacks that are \"far in the future\"\n // (large minimum value means no small values are buried).\n if (mind != INT_MAX) eval -= 3LL * mind;\n\n // Prefer large top (burying large accessible value is less harmful).\n if (topd != INT_MAX) eval -= 1LL * topd;\n\n // Prefer using an empty stack a bit (acts as buffer / doesn't bury anything).\n if (st[d].empty()) eval -= 500;\n\n // Strongly avoid stacks whose minimum is needed soon (burying them is bad).\n if (mind != INT_MAX && mind <= cur + SOON_W) eval += 20000;\n\n // Mildly discourage placing block bottom onto a smaller top (breaks \"decreasing\" feel).\n if (!st[d].empty() && topd <= bottomMoved) eval += 2000;\n\n if (eval < bestEval) {\n bestEval = eval;\n candidates.clear();\n candidates.push_back(d);\n } else if (eval == bestEval) {\n candidates.push_back(d);\n }\n }\n\n int d = candidates[rng.next_int(0, (int)candidates.size() - 1)];\n\n // Apply move (operation1)\n ops.emplace_back(bottomMoved, d + 1);\n st[d].insert(st[d].end(), block.begin(), block.end());\n\n // Now cur must be on top of stack s.\n // Immediately carry it out (operation2).\n if (st[s].empty() || st[s].back() != cur) {\n // Fallback safety: if something unexpected, search again (shouldn't happen).\n auto [ss, pp] = find_box(cur);\n s = ss;\n }\n ops.emplace_back(cur, 0);\n st[s].pop_back();\n cur++;\n\n // Hard safety (not expected to trigger with this approach).\n if ((int)ops.size() > 5000) break;\n }\n\n // Output operations (K lines, no need to print K).\n for (auto [v, i] : ops) {\n cout << v << \" \" << i << \"\\n\";\n }\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstatic inline char opp(char c) {\n if (c=='U') return 'D';\n if (c=='D') return 'U';\n if (c=='L') return 'R';\n return 'L';\n}\n\nstruct BFSResult {\n vector prev;\n vector pmove; // move taken from prev -> node\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> 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 vector> d(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> d[i][j];\n\n int V = N*N;\n auto id = [&](int i, int j){ return i*N + j; };\n auto rc = [&](int idx){ return pair(idx/N, idx%N); };\n\n // Build adjacency: (to, moveChar)\n vector>> g(V);\n auto add_edge = [&](int a, int b, char c){\n g[a].push_back({b,c});\n };\n for(int i=0;i parentMove(V, 0);\n vector parent(V, -1);\n vector order(V, -1), itidx(V, 0);\n vector st;\n vector route_base;\n vector enteredMove; enteredMove.reserve(V);\n\n // sort adjacency per node by d of destination descending (static)\n for (int u=0; u d[bi][bj];\n });\n }\n\n vector visited(V, 0);\n st.push_back(0);\n enteredMove.push_back(0);\n visited[0]=1;\n\n while(!st.empty()){\n int u = st.back();\n int &it = itidx[u];\n if (it == (int)g[u].size()) {\n // backtrack\n st.pop_back();\n char mv = enteredMove.back();\n enteredMove.pop_back();\n if (!st.empty()) {\n // we returned from child to parent, append opposite move\n route_base.push_back(opp(mv));\n }\n continue;\n }\n auto [to, mv] = g[u][it++];\n if (visited[to]) continue;\n visited[to]=1;\n parent[to]=u;\n parentMove[to]=mv;\n\n // move to child\n route_base.push_back(mv);\n st.push_back(to);\n enteredMove.push_back(mv);\n }\n\n string base;\n base.reserve(route_base.size());\n for(char c: route_base) base.push_back(c);\n\n // BFS from a source, store parents to reconstruct shortest path.\n auto bfs_from = [&](int s)->BFSResult{\n BFSResult res;\n res.prev.assign(V, -1);\n res.pmove.assign(V, 0);\n deque q;\n q.push_back(s);\n res.prev[s] = s;\n while(!q.empty()){\n int u=q.front(); q.pop_front();\n for(auto [to,mv]: g[u]){\n if(res.prev[to]!=-1) continue;\n res.prev[to]=u;\n res.pmove[to]=mv;\n q.push_back(to);\n }\n }\n return res;\n };\n\n // reconstruct path s->t using BFSResult from s\n auto path_from_bfs = [&](int s, int t, const BFSResult& br)->string{\n if (s==t) return \"\";\n if (br.prev[t]==-1) return \"\"; // unreachable (shouldn't happen)\n string rev;\n int cur=t;\n while(cur!=s){\n char mv = br.pmove[cur];\n rev.push_back(mv);\n cur = br.prev[cur];\n }\n reverse(rev.begin(), rev.end());\n return rev;\n };\n\n auto reverse_opp = [&](const string& p)->string{\n string r;\n r.reserve(p.size());\n for(int i=(int)p.size()-1;i>=0;i--) r.push_back(opp(p[i]));\n return r;\n };\n\n // Evaluate average dirtiness exactly from visit gaps in O(L).\n auto eval_route = [&](const string& route)->long double{\n int L = (int)route.size();\n vector first(V, -1), last(V, -1);\n vector sumG(V, 0);\n\n int ci=0,cj=0;\n for(int t=1;t<=L;t++){\n char c = route[t-1];\n if(c=='U') ci--;\n else if(c=='D') ci++;\n else if(c=='L') cj--;\n else cj++;\n\n int u = id(ci,cj);\n if(first[u]==-1) first[u]=t;\n if(last[u]!=-1){\n long long gap = t - last[u];\n sumG[u] += gap*(gap-1)/2;\n }\n last[u]=t;\n }\n // wrap gaps\n for(int u=0;u dist0(V, -1);\n {\n deque q;\n q.push_back(0);\n dist0[0]=0;\n while(!q.empty()){\n int u=q.front(); q.pop_front();\n for(auto [to,mv]: g[u]){\n if(dist0[to]!=-1) continue;\n dist0[to]=dist0[u]+1;\n q.push_back(to);\n }\n }\n }\n\n // Candidate important cells: by d/(dist+1)\n vector cells(V);\n iota(cells.begin(), cells.end(), 0);\n sort(cells.begin(), cells.end(), [&](int a, int b){\n auto [ai,aj]=rc(a);\n auto [bi,bj]=rc(b);\n long double sa = (long double)d[ai][aj] / (long double)(dist0[a]+1);\n long double sb = (long double)d[bi][bj] / (long double)(dist0[b]+1);\n if (sa != sb) return sa > sb;\n return d[ai][aj] > d[bi][bj];\n });\n\n int M = min(15, V);\n vector top;\n for(int k=0;k bfsTop;\n bfsTop.reserve(top.size());\n for(int u: top) bfsTop.push_back(bfs_from(u));\n\n // Build candidate loops (all start/end at 0)\n vector loops;\n\n // Very short loops: go to neighbor and back\n for(auto [to,mv]: g[0]){\n string lp;\n lp.push_back(mv);\n lp.push_back(opp(mv));\n loops.push_back(lp);\n }\n\n // Single-target out-and-back shortest loop\n for(int idx=0; idx<(int)top.size(); idx++){\n int p = top[idx];\n string sp = path_from_bfs(0, p, bfs0);\n if(sp.empty()) continue;\n string lp = sp + reverse_opp(sp);\n if ((int)lp.size() <= 600) loops.push_back(lp);\n }\n\n // Pair loops: 0->p->q->0\n int K = min(8, (int)top.size());\n for(int i=0;i q using bfs from p\n string p_q = path_from_bfs(p, q, bfsTop[i]); // bfsTop[i] corresponds to top[i] == p\n if(p_q.empty()) continue;\n string q_s = reverse_opp(s_q);\n string lp = s_p + p_q + q_s;\n if ((int)lp.size() <= 800) loops.push_back(lp);\n }\n }\n\n // Deduplicate loops (optional)\n sort(loops.begin(), loops.end());\n loops.erase(unique(loops.begin(), loops.end()), loops.end());\n\n // Candidate repetition counts (Fibonacci-like)\n auto build_r_list = [&](int maxR){\n vector rlist;\n rlist.push_back(0);\n int a=1,b=2;\n while(a<=maxR){\n rlist.push_back(a);\n int c=a+b;\n a=b; b=c;\n }\n rlist.push_back(maxR);\n sort(rlist.begin(), rlist.end());\n rlist.erase(unique(rlist.begin(), rlist.end()), rlist.end());\n return rlist;\n };\n\n string bestRoute = base;\n long double bestScore = eval_route(bestRoute);\n\n int baseLen = (int)base.size();\n\n for(const string& loop : loops){\n int c = (int)loop.size();\n if(c==0) continue;\n if(baseLen + c > 100000) continue;\n\n int maxR = (100000 - baseLen) / c;\n if(maxR < 0) continue;\n auto rlist = build_r_list(maxR);\n\n int bestR = 0;\n for(int r : rlist){\n int L = baseLen + r*c;\n if(L<=0 || L>100000) continue;\n int r1 = r/2;\n int r2 = r - r1;\n string route;\n route.reserve(L);\n for(int k=0;k maxR) continue;\n int L = baseLen + (int)r*c;\n if(L<=0 || L>100000) continue;\n int r1 = (int)r/2;\n int r2 = (int)r - r1;\n string route;\n route.reserve(L);\n for(int k=0;k\nusing namespace std;\n\nstatic const long long INF = (1LL<<60);\n\nstruct Timer {\n chrono::steady_clock::time_point st;\n Timer() : st(chrono::steady_clock::now()) {}\n double elapsed_sec() const {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n vector t(M);\n for (int i = 0; i < M; i++) cin >> t[i];\n\n const int V = N * N;\n vector x(V), y(V);\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int id = i * N + j;\n x[id] = i; y[id] = j;\n }\n auto manhattan = [&](int a, int b) -> int {\n return abs(x[a] - x[b]) + abs(y[a] - y[b]);\n };\n\n // positions[c] = list of cell ids having letter c\n array, 26> positions;\n for (int i = 0; i < 26; i++) positions[i].clear();\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n positions[A[i][j] - 'A'].push_back(i * N + j);\n }\n\n // idxInLetter[c][cellId] = index in positions[c], else -1\n array, 26> idxInLetter;\n for (int c = 0; c < 26; c++) {\n idxInLetter[c].fill(-1);\n for (int k = 0; k < (int)positions[c].size(); k++) {\n idxInLetter[c][positions[c][k]] = k;\n }\n }\n\n int startCell = si * N + sj;\n\n // Overlap between current string S and next pattern p (length 5), max 4\n auto overlap_suffix_prefix = [&](const string &S, const string &p) -> int {\n int maxL = min(4, (int)S.size());\n for (int l = maxL; l >= 0; l--) {\n bool ok = true;\n for (int i = 0; i < l; i++) {\n if (S[(int)S.size() - l + i] != p[i]) { ok = false; break; }\n }\n if (ok) return l;\n }\n return 0;\n };\n\n // Exact minimal typing cost for given S (no reconstruction)\n auto typing_cost = [&](const string &S) -> long long {\n vector prevIds(1, startCell);\n vector prevCost(1, 0);\n\n for (char ch : S) {\n int c = ch - 'A';\n const auto &curIds = positions[c];\n vector curCost(curIds.size(), INF);\n\n for (int i = 0; i < (int)curIds.size(); i++) {\n int v = curIds[i];\n long long best = INF;\n for (int j = 0; j < (int)prevIds.size(); j++) {\n long long cand = prevCost[j] + manhattan(prevIds[j], v);\n if (cand < best) best = cand;\n }\n curCost[i] = best + 1; // press cost\n }\n prevIds = curIds;\n prevCost.swap(curCost);\n }\n\n long long ans = INF;\n for (auto v : prevCost) ans = min(ans, v);\n return ans;\n };\n\n // Build candidate S by greedy extension with randomness\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto build_candidate = [&]() -> string {\n vector used(M, 0);\n int start = uniform_int_distribution(0, M - 1)(rng);\n used[start] = 1;\n int usedCnt = 1;\n\n string S = t[start];\n\n while (usedCnt < M) {\n int bestOv = -1;\n vector cand;\n cand.reserve(M);\n\n // Find best overlap\n for (int k = 0; k < M; k++) if (!used[k]) {\n int ov = overlap_suffix_prefix(S, t[k]);\n if (ov > bestOv) {\n bestOv = ov;\n cand.clear();\n cand.push_back(k);\n } else if (ov == bestOv) {\n cand.push_back(k);\n }\n }\n\n // random tie-break\n int pick = cand[uniform_int_distribution(0, (int)cand.size() - 1)(rng)];\n used[pick] = 1;\n usedCnt++;\n\n int ov = overlap_suffix_prefix(S, t[pick]);\n S += t[pick].substr(ov);\n }\n\n return S;\n };\n\n Timer timer;\n double TIME_LIMIT = 1.85; // seconds, leave margin\n\n string bestS;\n long long bestT = INF;\n\n // A few deterministic tries first: start from each of some indices\n // (still using the random builder is fine; it is fast)\n int iters = 0;\n while (timer.elapsed_sec() < TIME_LIMIT) {\n string S = build_candidate();\n if ((int)S.size() > 5000) continue; // should never happen here\n\n long long T = typing_cost(S);\n if (T < bestT) {\n bestT = T;\n bestS = std::move(S);\n }\n iters++;\n }\n\n if (bestS.empty()) {\n // Fallback: just concatenate\n bestS = t[0];\n for (int i = 1; i < M; i++) bestS += t[i];\n }\n\n // DP with parent reconstruction for bestS\n int L = (int)bestS.size();\n vector letters(L);\n for (int i = 0; i < L; i++) letters[i] = bestS[i] - 'A';\n\n vector> parent(L); // parent[p][k] = previous cellId (0..224)\n vector prevIds(1, startCell);\n vector prevCost(1, 0);\n\n // We'll also keep the last layer's ids/cost to choose end.\n vector lastIds;\n vector lastCost;\n\n for (int p = 0; p < L; p++) {\n int c = letters[p];\n const auto &curIds = positions[c];\n vector curCost(curIds.size(), INF);\n parent[p].assign(curIds.size(), (int16_t)-1);\n\n for (int i = 0; i < (int)curIds.size(); i++) {\n int v = curIds[i];\n long long best = INF;\n int bestPrevCell = -1;\n for (int j = 0; j < (int)prevIds.size(); j++) {\n long long cand = prevCost[j] + manhattan(prevIds[j], v);\n if (cand < best) {\n best = cand;\n bestPrevCell = prevIds[j];\n }\n }\n curCost[i] = best + 1;\n parent[p][i] = (int16_t)bestPrevCell;\n }\n\n prevIds = curIds;\n prevCost.swap(curCost);\n lastIds = prevIds;\n lastCost = prevCost;\n }\n\n // Choose best ending cell\n int bestK = 0;\n for (int i = 1; i < (int)lastCost.size(); i++) {\n if (lastCost[i] < lastCost[bestK]) bestK = i;\n }\n\n // Backtrack\n vector answerCells(L);\n int curCell = lastIds[bestK];\n\n for (int p = L - 1; p >= 0; p--) {\n answerCells[p] = curCell;\n int c = letters[p];\n int k = idxInLetter[c][curCell];\n // k should be valid\n int prevCell = (int)parent[p][k];\n curCell = prevCell;\n }\n\n // Output coordinates for each operation\n for (int p = 0; p < L; p++) {\n int id = answerCells[p];\n cout << (id / N) << ' ' << (id % N) << '\\n';\n }\n\n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n explicit XorShift(uint64_t seed = 0) {\n if (seed) x ^= seed;\n for (int i = 0; i < 10; i++) next_u64();\n }\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n uint32_t next_u32() { return (uint32_t)next_u64(); }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Placement {\n vector cells; // indices in [0, N*N)\n vector contrib; // per mask t: sum of m_t over cells\n};\n\nstatic inline void flush_out() {\n cout << flush;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector>> shapes(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n shapes[k].resize(d);\n for (int i = 0; i < d; i++) {\n int r, c;\n cin >> r >> c;\n shapes[k][i] = {r, c};\n }\n }\n\n const int V = N * N;\n\n // Parameters (tuned for robustness within op-limit)\n int T = max(40, min(80, V / 5)); // number of random masks\n int R = 2; // repetitions per mask (average noise down)\n // Total divination ops = 2 * T * R\n // Worst-case fallback drills = N^2\n // Total ops <= 2TR + N^2 + answers <= 800 always for N<=20.\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n // Build random balanced sign masks m[t][idx] in {-1,+1}\n vector> sign(T, vector(V, -1));\n vector> Aset(T), Bset(T);\n vector perm(V);\n\n for (int t = 0; t < T; t++) {\n iota(perm.begin(), perm.end(), 0);\n // shuffle\n for (int i = V - 1; i >= 1; i--) {\n int j = (int)(rng.next_u64() % (uint64_t)(i + 1));\n swap(perm[i], perm[j]);\n }\n int half = V / 2;\n Aset[t].clear();\n Bset[t].clear();\n for (int i = 0; i < V; i++) {\n int idx = perm[i];\n if (i < half) {\n sign[t][idx] = +1;\n Aset[t].push_back(idx);\n } else {\n sign[t][idx] = -1;\n Bset[t].push_back(idx);\n }\n }\n // if V is odd, sets sizes differ by 1, still ok (both >=2 for N>=10)\n }\n\n auto inv_est = [&](long long y, int k) -> double {\n // E[y] = k*eps + (1-2eps) * v(S)\n // vhat = (y - k*eps) / (1-2eps)\n double denom = (1.0 - 2.0 * eps);\n double vhat = ( (double)y - (double)k * eps ) / denom;\n // v(S) can be up to k*M due to overlaps\n double lo = 0.0;\n double hi = (double)k * (double)M;\n if (vhat < lo) vhat = lo;\n if (vhat > hi) vhat = hi;\n return vhat;\n };\n\n auto query_set = [&](const vector& idxs) -> long long {\n int d = (int)idxs.size();\n // d must be >=2 for divination\n cout << \"q \" << d;\n for (int idx : idxs) {\n int i = idx / N, j = idx % N;\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n flush_out();\n long long resp;\n cin >> resp;\n return resp;\n };\n\n // Collect observations obs[t] ~ sum_idx sign[t][idx] * v(idx)\n vector obs(T, 0.0);\n for (int t = 0; t < T; t++) {\n double acc = 0.0;\n for (int rep = 0; rep < R; rep++) {\n long long yA = query_set(Aset[t]);\n long long yB = query_set(Bset[t]);\n double vA = inv_est(yA, (int)Aset[t].size());\n double vB = inv_est(yB, (int)Bset[t].size());\n acc += (vA - vB);\n }\n obs[t] = acc / (double)R;\n }\n\n // Enumerate placements for each field, precompute contrib vectors\n vector> placements(M);\n placements.reserve(M);\n\n for (int k = 0; k < M; k++) {\n int maxr = 0, maxc = 0;\n for (auto [r, c] : shapes[k]) {\n maxr = max(maxr, r);\n maxc = max(maxc, c);\n }\n int H = maxr + 1;\n int W = maxc + 1;\n int diMax = N - H;\n int djMax = N - W;\n\n vector ps;\n ps.reserve((diMax + 1) * (djMax + 1));\n\n for (int di = 0; di <= diMax; di++) {\n for (int dj = 0; dj <= djMax; dj++) {\n Placement p;\n p.cells.reserve(shapes[k].size());\n for (auto [r, c] : shapes[k]) {\n int ii = di + r;\n int jj = dj + c;\n p.cells.push_back(ii * N + jj);\n }\n p.contrib.assign(T, 0);\n // contrib[t] = sum_{cell in p} sign[t][cell]\n for (int idx : p.cells) {\n for (int t = 0; t < T; t++) {\n p.contrib[t] += (int16_t)sign[t][idx];\n }\n }\n ps.push_back(std::move(p));\n }\n }\n placements[k] = std::move(ps);\n }\n\n // Simulated annealing to fit obs\n vector choice(M, 0);\n for (int k = 0; k < M; k++) {\n choice[k] = rng.next_int(0, (int)placements[k].size() - 1);\n }\n\n vector pred(T, 0);\n for (int t = 0; t < T; t++) {\n int s = 0;\n for (int k = 0; k < M; k++) s += placements[k][choice[k]].contrib[t];\n pred[t] = s;\n }\n\n auto calc_obj = [&]() -> double {\n double o = 0.0;\n for (int t = 0; t < T; t++) {\n double d = (double)pred[t] - obs[t];\n o += d * d;\n }\n return o;\n };\n\n double obj = calc_obj();\n\n int iters = 250000; // should fit in time; small problem\n double startTemp = 30.0;\n double endTemp = 0.5;\n\n for (int it = 0; it < iters; it++) {\n int k = rng.next_int(0, M - 1);\n int curP = choice[k];\n int Pk = (int)placements[k].size();\n int nxtP = rng.next_int(0, Pk - 1);\n if (nxtP == curP) continue;\n\n // temperature schedule\n double frac = (double)it / (double)iters;\n double temp = startTemp * pow(endTemp / startTemp, frac);\n\n double delta = 0.0;\n // compute delta objective by updating pred with diff\n for (int t = 0; t < T; t++) {\n int diff = (int)placements[k][nxtP].contrib[t] - (int)placements[k][curP].contrib[t];\n double before = (double)pred[t] - obs[t];\n double after = (double)(pred[t] + diff) - obs[t];\n delta += (after * after) - (before * before);\n }\n\n bool accept = false;\n if (delta <= 0) {\n accept = true;\n } else {\n double prob = exp(-delta / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n for (int t = 0; t < T; t++) {\n pred[t] += (int)placements[k][nxtP].contrib[t] - (int)placements[k][curP].contrib[t];\n }\n choice[k] = nxtP;\n obj += delta;\n }\n }\n\n // Build estimated union set from chosen placements\n vector oil(V, 0);\n for (int k = 0; k < M; k++) {\n const auto &p = placements[k][choice[k]];\n for (int idx : p.cells) oil[idx] = 1;\n }\n vector> ansCells;\n ansCells.reserve(V);\n for (int idx = 0; idx < V; idx++) {\n if (oil[idx]) ansCells.push_back({idx / N, idx % N});\n }\n\n auto output_answer = [&](const vector>& cells) -> int {\n cout << \"a \" << (int)cells.size();\n for (auto [i, j] : cells) cout << \" \" << i << \" \" << j;\n cout << \"\\n\";\n flush_out();\n int ok;\n cin >> ok;\n return ok;\n };\n\n // First attempt (cheap)\n {\n int ok = output_answer(ansCells);\n if (ok == 1) return 0;\n }\n\n // Fallback: drill everything (guaranteed correctness)\n vector> finalCells;\n finalCells.reserve(V);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n flush_out();\n long long v;\n cin >> v;\n if (v > 0) finalCells.push_back({i, j});\n }\n }\n // Final guaranteed answer\n (void)output_answer(finalCells);\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nusing ll = long long;\nstatic const ll INF = (1LL<<62);\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int W, D, N;\n cin >> W >> D >> N;\n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) cin >> a[d][k];\n }\n\n // Precompute penalty f[k][w] = total shortage penalty over all days\n // if rank k gets a strip of width w (area = W*w).\n // w ranges 1..W\n vector> f(N, vector(W + 1, 0));\n for (int k = 0; k < N; k++) {\n for (int w = 1; w <= W; w++) {\n ll cap = 1LL * W * w;\n ll shortage_sum = 0;\n for (int d = 0; d < D; d++) {\n if ((ll)a[d][k] > cap) shortage_sum += (ll)a[d][k] - cap;\n }\n f[k][w] = 100LL * shortage_sum;\n }\n }\n\n // DP: dp[i][s] = min penalty using first i strips with total width s\n vector> dp(N + 1, vector(W + 1, INF));\n vector> prevW(N + 1, vector(W + 1, -1)); // chosen width at step i\n dp[0][0] = 0;\n\n for (int i = 0; i < N; i++) {\n for (int s = 0; s <= W; s++) {\n if (dp[i][s] >= INF) continue;\n int rem = W - s;\n int need = (N - 1 - i); // remaining strips after this one, each needs at least 1\n int maxw = rem - need;\n if (maxw < 1) continue;\n for (int w = 1; w <= maxw; w++) {\n int s2 = s + w;\n ll nd = dp[i][s] + f[i][w];\n if (nd < dp[i + 1][s2]) {\n dp[i + 1][s2] = nd;\n prevW[i + 1][s2] = (short)w;\n }\n }\n }\n }\n\n // Reconstruct widths\n vector widths(N, 1);\n int s = W;\n for (int i = N; i >= 1; i--) {\n int w = prevW[i][s];\n if (w < 0) {\n // Fallback (shouldn't happen): simple equal split\n widths.assign(N, W / N);\n for (int i2 = 0; i2 < W % N; i2++) widths[N - 1 - i2]++;\n break;\n }\n widths[i - 1] = w;\n s -= w;\n }\n\n // Sort widths so smaller ranks get smaller strips (never worse due to monotonic demands)\n sort(widths.begin(), widths.end());\n\n // Build strip x-coordinates\n vector x(N + 1, 0);\n for (int k = 0; k < N; k++) x[k + 1] = x[k] + widths[k];\n // Ensure x[N] == W\n if (x[N] != W) {\n // Adjust last strip to fix rounding/reconstruction errors (shouldn't happen)\n x[N] = W;\n }\n\n // Output same rectangles for all days:\n // Rectangle k: top-left (0, x[k]) bottom-right (W, x[k+1])\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n int i0 = 0;\n int j0 = x[k];\n int i1 = W;\n int j1 = x[k + 1];\n // Validity: j0 < j1 guaranteed because widths>=1\n cout << i0 << ' ' << j0 << ' ' << i1 << ' ' << j1 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nstatic constexpr int N = 9;\nstatic constexpr int M = 20;\nstatic constexpr int POS = 7; // 0..6\nstatic constexpr int A = M * POS * POS; // 980\nstatic constexpr int MOD = 998244353;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline uint32_t nextU32() { return (uint32_t)nextU64(); }\n inline int nextInt(int n) { return (int)(nextU64() % (uint64_t)n); }\n inline double nextDouble01() { // [0,1)\n // 53-bit precision\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct CellDelta {\n uint8_t x, y; // 0..8\n int v; // 0..MOD-1\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, Kin;\n cin >> Nin >> Min >> Kin; // should be 9,20,81\n vector> a(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> a[i][j];\n\n // Read stamps\n int s[M][3][3];\n for (int m = 0; m < M; m++) {\n for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) cin >> s[m][i][j];\n }\n\n // Precompute action -> list of 9 affected cells and add-values\n vector> act(A);\n for (int m = 0; m < M; m++) {\n for (int p = 0; p < POS; p++) {\n for (int q = 0; q < POS; q++) {\n int id = m * 49 + p * 7 + q;\n int k = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n act[id][k++] = CellDelta{(uint8_t)(p + di), (uint8_t)(q + dj), s[m][di][dj]};\n }\n }\n }\n }\n\n auto decode = [&](int id) {\n int m = id / 49;\n int r = id % 49;\n int p = r / 7;\n int q = r % 7;\n return array{m,p,q};\n };\n\n // Current board residues and score\n int board[N][N];\n long long score = 0;\n auto resetBoard = [&]() {\n score = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n board[i][j] = a[i][j];\n score += board[i][j];\n }\n };\n\n // delta if we apply (sign=+1) or remove (sign=-1) an action, and actually apply it\n auto applyAction = [&](int id, int sign) -> long long {\n if (id < 0) return 0;\n long long dsum = 0;\n const auto &lst = act[id];\n if (sign == +1) {\n for (const auto &cd : lst) {\n int &r = board[cd.x][cd.y];\n int old = r;\n int nw = old + cd.v;\n if (nw >= MOD) nw -= MOD;\n r = nw;\n dsum += (long long)(nw - old);\n }\n } else { // -1\n for (const auto &cd : lst) {\n int &r = board[cd.x][cd.y];\n int old = r;\n int nw = old - cd.v;\n if (nw < 0) nw += MOD;\n r = nw;\n dsum += (long long)(nw - old);\n }\n }\n score += dsum;\n return dsum;\n };\n\n // compute delta if apply id, without changing board\n auto evalDeltaAdd = [&](int id) -> long long {\n long long dsum = 0;\n const auto &lst = act[id];\n for (const auto &cd : lst) {\n int old = board[cd.x][cd.y];\n int nw = old + cd.v;\n if (nw >= MOD) nw -= MOD;\n dsum += (long long)(nw - old);\n }\n return dsum;\n };\n\n // --- Greedy initialization ---\n resetBoard();\n vector ops(Kin, -1);\n\n for (int t = 0; t < Kin; t++) {\n long long bestD = 0;\n int bestId = -1;\n for (int id = 0; id < A; id++) {\n long long d = evalDeltaAdd(id);\n if (d > bestD) {\n bestD = d;\n bestId = id;\n }\n }\n if (bestId < 0 || bestD <= 0) break;\n ops[t] = bestId;\n applyAction(bestId, +1);\n }\n\n // --- Simulated annealing on K slots (null allowed) ---\n XorShift64 rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n const double TIME_LIMIT = 1.95;\n auto t0 = chrono::steady_clock::now();\n\n auto elapsedSec = [&]() -> double {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - t0).count();\n };\n\n // Temperature schedule tuned to score scale (~1e9 per cell effect)\n const double T0 = 5e8;\n const double T1 = 1e5;\n\n while (true) {\n double et = elapsedSec();\n if (et >= TIME_LIMIT) break;\n double prog = et / TIME_LIMIT;\n double T = T0 * pow(T1 / T0, prog);\n\n int idx = rng.nextInt(Kin);\n int oldId = ops[idx];\n\n int newId;\n // 15% set to null, else random action\n if (rng.nextInt(100) < 15) newId = -1;\n else newId = rng.nextInt(A);\n\n if (newId == oldId) continue;\n\n long long before = score;\n // apply change\n applyAction(oldId, -1);\n applyAction(newId, +1);\n long long after = score;\n long long delta = after - before;\n\n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / T);\n if (rng.nextDouble01() < prob) accept = true;\n }\n\n if (accept) {\n ops[idx] = newId;\n } else {\n // revert\n applyAction(newId, -1);\n applyAction(oldId, +1);\n }\n }\n\n // Output: compress non-null operations (any order is fine)\n vector> out;\n out.reserve(Kin);\n for (int i = 0; i < Kin; i++) {\n if (ops[i] < 0) continue;\n out.push_back(decode(ops[i]));\n }\n\n cout << out.size() << \"\\n\";\n for (auto &x : out) {\n cout << x[0] << \" \" << x[1] << \" \" << x[2] << \"\\n\";\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstatic constexpr int N = 5;\nstatic constexpr int MAXT = 10000;\n\nstruct Pos { int x, y; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin;\n cin >> Nin;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> A[i][j];\n\n // For each container id, where/when it will arrive (receiving row, index).\n vector recv_row(N*N, -1), recv_idx(N*N, -1);\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int id = A[i][j];\n recv_row[id] = i;\n recv_idx[id] = j;\n }\n\n // Grid: -1 empty, otherwise container id.\n int grid[N][N];\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) grid[i][j] = -1;\n\n // Container positions:\n // (-2,-2) unspawned, (-1,-1) dispatched, otherwise location on grid.\n vector cont_pos(N*N, Pos{-2,-2});\n\n // Receiving pointer per row: next container index to spawn from that receiving gate.\n int next_in[N] = {0,0,0,0,0};\n\n // Large crane state (only crane 0 is used after bombing others)\n Pos crane{0,0};\n int holding = -1; // container id, -1 if none\n\n // Output action strings\n vector out(N);\n deque plan; // planned actions for large crane\n\n auto in_bounds = [&](int x, int y)->bool{\n return 0 <= x && x < N && 0 <= y && y < N;\n };\n\n auto manhattan_plan = [&](Pos from, Pos to) {\n // Simple Manhattan route: vertical then horizontal.\n while (from.x < to.x) { plan.push_back('D'); from.x++; }\n while (from.x > to.x) { plan.push_back('U'); from.x--; }\n while (from.y < to.y) { plan.push_back('R'); from.y++; }\n while (from.y > to.y) { plan.push_back('L'); from.y--; }\n };\n\n auto is_empty = [&](int x, int y)->bool{\n return grid[x][y] == -1;\n };\n\n auto find_storage = [&]()->Pos{\n // Prefer interior columns 1..3 (never dispatch column 4).\n for (int y = 1; y <= 3; y++) {\n for (int x = 0; x < N; x++) {\n if (grid[x][y] == -1) return Pos{x,y};\n }\n }\n // Next, allow left edge rows already fully spawned.\n for (int x = 0; x < N; x++) {\n if (next_in[x] >= N && grid[x][0] == -1) return Pos{x,0};\n }\n // Finally, any empty non-dispatch cell.\n for (int x = 0; x < N; x++) for (int y = 0; y < N; y++) {\n if (y == N-1) continue;\n if (grid[x][y] == -1) return Pos{x,y};\n }\n // Should never happen; at least current cell is empty after a pick, but return it.\n return crane;\n };\n\n auto next_target = [&]()->int{\n for (int t = 0; t < N*N; t++) {\n if (!(cont_pos[t].x == -1 && cont_pos[t].y == -1)) {\n // not dispatched\n // But if unspawned (-2,-2) it's still not dispatched, keep as target.\n return t;\n }\n }\n return -1;\n };\n\n auto dispatched_count = [&]()->int{\n int c = 0;\n for (int t = 0; t < N*N; t++) if (cont_pos[t].x == -1) c++;\n return c;\n };\n\n // Simulation loop\n for (int turn = 0; turn < MAXT; turn++) {\n // Step 1: receiving\n for (int i = 0; i < N; i++) {\n if (next_in[i] >= N) continue;\n // Condition: no container at (i,0) and no crane holding a container at (i,0).\n // We have only large crane. It can stand there empty-handed without blocking.\n bool crane_holding_here = (holding != -1 && crane.x == i && crane.y == 0);\n if (grid[i][0] == -1 && !crane_holding_here) {\n int id = A[i][next_in[i]];\n next_in[i]++;\n grid[i][0] = id;\n cont_pos[id] = Pos{i,0};\n }\n }\n\n // Ensure output strings have current turn slot.\n for (int i = 0; i < N; i++) out[i].push_back('.');\n\n // Small cranes: bomb at turn 0, then do nothing\n if (turn == 0) {\n for (int i = 1; i < N; i++) out[i][turn] = 'B';\n }\n\n // Large crane action planning\n int tgt = next_target();\n if (tgt == -1) {\n // all dispatched, we can stop early (but need at least 1 length; already have).\n // Trim trailing '.' is allowed but not necessary.\n break;\n }\n\n if (plan.empty()) {\n int target = tgt;\n\n // If holding something, decide where to put it.\n if (holding != -1) {\n int want = target;\n int dr = holding / N;\n // If holding is exactly the next target, go dispatch it.\n if (holding == want) {\n Pos gate{dr, N-1};\n if (!(crane.x == gate.x && crane.y == gate.y)) {\n manhattan_plan(crane, gate);\n }\n plan.push_back('Q');\n } else {\n // Drop to storage\n Pos st = find_storage();\n if (!(crane.x == st.x && crane.y == st.y)) {\n manhattan_plan(crane, st);\n }\n plan.push_back('Q');\n }\n } else {\n // Not holding: if target is on grid, pick and dispatch.\n if (cont_pos[target].x >= 0) {\n Pos p = cont_pos[target];\n if (!(crane.x == p.x && crane.y == p.y)) {\n manhattan_plan(crane, p);\n }\n plan.push_back('P');\n Pos gate{target / N, N-1};\n // after pick, crane remains on p; route from p to gate\n manhattan_plan(p, gate);\n plan.push_back('Q');\n } else {\n // Target not spawned yet: go to its receiving gate and clear until it appears.\n int rr = recv_row[target];\n Pos g{rr, 0};\n if (!(crane.x == g.x && crane.y == g.y)) {\n manhattan_plan(crane, g);\n } else {\n // We're on the gate. After receiving step, there should be a container unless exhausted.\n if (grid[rr][0] != -1) {\n int c = grid[rr][0];\n if (c == target) {\n plan.push_back('P');\n Pos gate{target / N, N-1};\n manhattan_plan(g, gate);\n plan.push_back('Q');\n } else {\n // Pick and store it away.\n plan.push_back('P');\n // after pick, need a place to drop\n Pos st = find_storage();\n manhattan_plan(g, st);\n plan.push_back('Q');\n }\n } else {\n // Shouldn't happen unless the row is exhausted; just wait.\n plan.push_back('.');\n }\n }\n }\n }\n }\n\n // Execute one action for the large crane this turn\n char act0 = plan.empty() ? '.' : plan.front();\n if (!plan.empty()) plan.pop_front();\n out[0][turn] = act0;\n\n // Step 2: apply large crane action\n auto do_move = [&](int dx, int dy) {\n int nx = crane.x + dx, ny = crane.y + dy;\n if (!in_bounds(nx, ny)) return false;\n crane = Pos{nx, ny};\n return true;\n };\n\n bool ok = true;\n if (act0 == '.') {\n // nothing\n } else if (act0 == 'U') ok = do_move(-1, 0);\n else if (act0 == 'D') ok = do_move(1, 0);\n else if (act0 == 'L') ok = do_move(0, -1);\n else if (act0 == 'R') ok = do_move(0, 1);\n else if (act0 == 'P') {\n if (holding != -1) ok = false;\n else {\n int &cell = grid[crane.x][crane.y];\n if (cell == -1) ok = false;\n else {\n holding = cell;\n cont_pos[holding] = Pos{-3,-3}; // held\n cell = -1;\n }\n }\n } else if (act0 == 'Q') {\n if (holding == -1) ok = false;\n else {\n int &cell = grid[crane.x][crane.y];\n if (cell != -1) ok = false;\n else {\n cell = holding;\n cont_pos[holding] = crane;\n holding = -1;\n }\n }\n } else {\n // 'B' not used for large\n ok = false;\n }\n\n // If something went wrong, fall back to safe no-op from now (avoid UB),\n // but in normal operation this should never trigger.\n if (!ok) {\n // Output a minimal valid solution instead of crashing:\n // just stop planning further.\n // (In contest you'd rather assert(false), but keep it safe.)\n plan.clear();\n }\n\n // Step 3: dispatch\n for (int i = 0; i < N; i++) {\n int &cell = grid[i][N-1];\n if (cell != -1) {\n int id = cell;\n cell = -1;\n cont_pos[id] = Pos{-1,-1}; // dispatched\n\n // We don't strictly need to verify correctness, but you can sanity-check:\n // if (id/5 != i) { /* wrong gate */ }\n }\n }\n\n // If all dispatched, we can stop early (keeping current length is fine).\n if (dispatched_count() == N*N) break;\n }\n\n // Remove trailing '.' uniformly? Not required. Just output as-is.\n // Ensure at least length 1 (guaranteed by loop or by turn==0 push).\n for (int i = 0; i < N; i++) {\n if (out[i].empty()) out[i] = \".\";\n cout << out[i] << \"\\n\";\n }\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Pos {\n int r, c;\n};\nstatic inline int manhattan(const Pos& a, const Pos& b) {\n return abs(a.r - b.r) + abs(a.c - b.c);\n}\n\nstatic inline string step_dir(const Pos& a, const Pos& b) {\n if (b.r == a.r - 1 && b.c == a.c) return \"U\";\n if (b.r == a.r + 1 && b.c == a.c) return \"D\";\n if (b.r == a.r && b.c == a.c - 1) return \"L\";\n if (b.r == a.r && b.c == a.c + 1) return \"R\";\n return \"\"; // should not happen for adjacent steps\n}\n\n// Apply transpose mapping (r,c)->(c,r)\nstatic inline Pos transposed(Pos p) { return Pos{p.c, p.r}; }\n\n// Candidate path generator base patterns.\n// Each returns an order of positions to be processed (all cells except (0,0)),\n// and ensures the walk from start through that order is adjacent step-by-step.\nvector gen_col0_then_rowserp(int N) {\n // Start at (0,0), go down column 0 (process (1,0)..(N-1,0)),\n // then process remaining columns 1..N-1 row-by-row from bottom to top, serpentine.\n vector seq;\n for (int r = 1; r < N; r++) seq.push_back({r, 0}); // down col0\n\n for (int r = N - 1; r >= 0; r--) {\n int t = (N - 1 - r); // 0,1,2...\n if (t % 2 == 0) { // left->right for cols 1..N-1\n for (int c = 1; c < N; c++) seq.push_back({r, c});\n } else { // right->left\n for (int c = N - 1; c >= 1; c--) seq.push_back({r, c});\n }\n }\n // seq has size N*N - 1\n return seq;\n}\n\nvector gen_col0_then_colserp(int N) {\n // Start at (0,0), go down column 0 (process (1,0)..(N-1,0)),\n // then process columns 1..N-1, each full column top-bottom alternating direction,\n // starting from bottom row to keep adjacency from (N-1,0)->(N-1,1).\n vector seq;\n for (int r = 1; r < N; r++) seq.push_back({r, 0}); // down col0\n\n for (int c = 1; c < N; c++) {\n int t = c - 1;\n if (t % 2 == 0) {\n // go up from bottom to top\n for (int r = N - 1; r >= 0; r--) seq.push_back({r, c});\n } else {\n // go down from top to bottom\n for (int r = 0; r < N; r++) seq.push_back({r, c});\n }\n }\n return seq;\n}\n\nvector gen_row0_then_colserp(int N) {\n // Start at (0,0), go right on row 0 (process (0,1)..(0,N-1)),\n // then for columns from right to left, process rows 1..N-1 serpentine\n // to maintain adjacency from (0,N-1)->(1,N-1).\n vector seq;\n for (int c = 1; c < N; c++) seq.push_back({0, c}); // right along row0\n\n for (int c = N - 1; c >= 0; c--) {\n int t = (N - 1 - c);\n if (t % 2 == 0) {\n // go down rows 1..N-1\n for (int r = 1; r < N; r++) seq.push_back({r, c});\n } else {\n // go up rows N-1..1\n for (int r = N - 1; r >= 1; r--) seq.push_back({r, c});\n }\n }\n return seq;\n}\n\nvector gen_row0_then_rowserp(int N) {\n // Start at (0,0), go right on row 0 (process (0,1)..(0,N-1)),\n // then process remaining rows 1..N-1 as a snake starting from column N-1\n // to maintain adjacency from (0,N-1)->(1,N-1).\n vector seq;\n for (int c = 1; c < N; c++) seq.push_back({0, c}); // row0\n\n for (int r = 1; r < N; r++) {\n int t = r - 1;\n if (t % 2 == 0) {\n // go left from N-1 to 0\n for (int c = N - 1; c >= 0; c--) seq.push_back({r, c});\n } else {\n // go right 0 to N-1\n for (int c = 0; c < N; c++) seq.push_back({r, c});\n }\n }\n return seq;\n}\n\nstruct Plan {\n long long cost = (1LL<<62);\n long long B = 0;\n vector order; // cells to process (exclude start)\n bool transposed = false;\n};\n\nPlan evaluate_plan(int N, const vector>& h0, const vector& order) {\n const int h00 = h0[0][0];\n\n // Compute min prefix sum of heights in order\n long long pref = 0, minPref = 0;\n for (auto p : order) {\n pref += h0[p.r][p.c];\n minPref = min(minPref, pref);\n }\n long long B = max({0LL, -minPref, (long long)h00});\n\n // Simulate exact cost (including movement with current load, load/unload costs)\n long long cost = 0;\n long long load = 0;\n\n // initial load at start\n if (B > 0) { cost += B; load += B; }\n\n Pos cur{0,0};\n // walk through order\n for (auto nxt : order) {\n // move (must be adjacent)\n int dist = manhattan(cur, nxt);\n if (dist != 1) {\n // invalid (shouldn't happen for our generators)\n return Plan{(1LL<<62), B, order, false};\n }\n cost += 100 + load;\n cur = nxt;\n\n int hh = h0[cur.r][cur.c];\n cost += llabs((long long)hh);\n load += hh;\n if (load < 0) {\n // Should not happen if B computed correctly, but guard.\n return Plan{(1LL<<62), B, order, false};\n }\n }\n\n // return to start via a fixed shortest path (up then left)\n while (cur.r > 0) {\n cost += 100 + load;\n cur.r--;\n }\n while (cur.c > 0) {\n cost += 100 + load;\n cur.c--;\n }\n\n // final unload all load onto start\n if (load > 0) cost += load, load = 0;\n\n // Done.\n Plan res;\n res.cost = cost;\n res.B = B;\n res.order = order;\n return res;\n}\n\nvector build_output(int N, const vector>& h0, const Plan& best) {\n vector ops;\n long long load = 0;\n\n auto emit_load = [&](long long d) {\n if (d <= 0) return;\n ops.push_back(\"+\" + to_string(d));\n load += d;\n };\n auto emit_unload = [&](long long d) {\n if (d <= 0) return;\n ops.push_back(\"-\" + to_string(d));\n load -= d;\n };\n auto emit_move = [&](const string& s) { ops.push_back(s); };\n\n // initial +B at (0,0)\n if (best.B > 0) emit_load(best.B);\n\n Pos cur{0,0};\n // process each cell in order\n for (auto nxt : best.order) {\n // move adjacent\n string dir = step_dir(cur, nxt);\n if (dir.empty()) {\n // should not happen\n // fallback: move by Manhattan (shouldn't be needed)\n while (cur.r < nxt.r) { emit_move(\"D\"); cur.r++; }\n while (cur.r > nxt.r) { emit_move(\"U\"); cur.r--; }\n while (cur.c < nxt.c) { emit_move(\"R\"); cur.c++; }\n while (cur.c > nxt.c) { emit_move(\"L\"); cur.c--; }\n } else {\n emit_move(dir);\n cur = nxt;\n }\n\n int hh = h0[cur.r][cur.c];\n if (hh > 0) emit_load(hh);\n else if (hh < 0) emit_unload(- (long long)hh);\n }\n\n // return to (0,0): up then left\n while (cur.r > 0) { emit_move(\"U\"); cur.r--; }\n while (cur.c > 0) { emit_move(\"L\"); cur.c--; }\n\n // unload remaining onto start\n if (load > 0) emit_unload(load);\n\n // ops size is far below 100000\n return ops;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> h[i][j];\n\n vector> candidates;\n\n // Base 4 patterns\n candidates.push_back(gen_col0_then_rowserp(N));\n candidates.push_back(gen_col0_then_colserp(N));\n candidates.push_back(gen_row0_then_colserp(N));\n candidates.push_back(gen_row0_then_rowserp(N));\n\n // Their transposes (often different)\n for (int k = 0; k < 4; k++) {\n vector t;\n t.reserve(candidates[k].size());\n for (auto p : candidates[k]) t.push_back(transposed(p));\n candidates.push_back(std::move(t));\n }\n\n Plan best;\n for (auto &ord : candidates) {\n // sanity: must have N*N-1 cells and exclude (0,0)\n if ((int)ord.size() != N*N - 1) continue;\n bool ok = true;\n for (auto p : ord) if (p.r == 0 && p.c == 0) ok = false;\n if (!ok) continue;\n\n auto plan = evaluate_plan(N, h, ord);\n if (plan.cost < best.cost) best = std::move(plan);\n }\n\n auto ops = build_output(N, h, best);\n for (auto &s : ops) cout << s << \"\\n\";\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nstatic constexpr int N = 6;\nstatic constexpr int M = 15;\n\nstruct XorShift64 {\n uint64_t x = 88172645463325252ull;\n explicit XorShift64(uint64_t seed = 0) {\n if (seed) x ^= seed + 0x9e3779b97f4a7c15ULL;\n }\n uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int lo, int hi) { // [lo, hi)\n return lo + (int)(nextU64() % (uint64_t)(hi - lo));\n }\n double nextDouble() { // [0,1)\n // 53-bit mantissa\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Seed {\n array x{};\n int v = 0;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, T;\n cin >> Nin >> Min >> T;\n const int S = 2 * Nin * (Nin - 1); // 60\n\n vector seeds(S);\n\n auto readSeeds = [&]() {\n for (int i = 0; i < S; i++) {\n int sum = 0;\n for (int l = 0; l < M; l++) {\n int a; cin >> a;\n seeds[i].x[l] = a;\n sum += a;\n }\n seeds[i].v = sum;\n }\n };\n\n readSeeds();\n\n // Precompute grid edges (positions 0..35).\n vector> edges;\n edges.reserve(60);\n auto id = [&](int r, int c){ return r * N + c; };\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N - 1; c++) edges.push_back({id(r,c), id(r,c+1)});\n }\n for (int r = 0; r < N - 1; r++) {\n for (int c = 0; c < N; c++) edges.push_back({id(r,c), id(r+1,c)});\n }\n\n // Parameters\n const double alpha = 1.20; // weight of std\n const double tau = 100.0; // exp scaling\n\n XorShift64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto selectCandidates = [&]() -> vector {\n vector ids(S);\n iota(ids.begin(), ids.end(), 0);\n sort(ids.begin(), ids.end(), [&](int a, int b){\n return seeds[a].v > seeds[b].v;\n });\n\n vector picked;\n picked.reserve(36);\n vector used(S, 0);\n\n auto add = [&](int s){\n if (!used[s]) {\n used[s] = 1;\n picked.push_back(s);\n }\n };\n\n // Top by total value\n for (int i = 0; i < min(S, 18); i++) add(ids[i]);\n\n // Specialists by each coordinate\n for (int l = 0; l < M; l++) {\n vector byCoord = ids;\n sort(byCoord.begin(), byCoord.end(), [&](int a, int b){\n return seeds[a].x[l] > seeds[b].x[l];\n });\n for (int k = 0; k < 2; k++) add(byCoord[k]);\n }\n\n // Fill up by value\n for (int i = 0; (int)picked.size() < 36 && i < S; i++) add(ids[i]);\n\n // If still short (shouldn't happen), fill arbitrary\n for (int i = 0; (int)picked.size() < 36 && i < S; i++) add(i);\n\n // If too many, keep best by value\n if ((int)picked.size() > 36) {\n sort(picked.begin(), picked.end(), [&](int a, int b){\n return seeds[a].v > seeds[b].v;\n });\n picked.resize(36);\n }\n return picked;\n };\n\n // Precompute pair utility w[i][j] for current 60 seeds\n vector> w(S, vector(S, 0.0));\n auto buildPairUtility = [&]() {\n for (int i = 0; i < S; i++) {\n w[i][i] = exp((seeds[i].v) / tau); // not really used\n }\n for (int i = 0; i < S; i++) for (int j = i + 1; j < S; j++) {\n double mean = 0.5 * (seeds[i].v + seeds[j].v);\n double diff2 = 0.0;\n for (int l = 0; l < M; l++) {\n double d = double(seeds[i].x[l] - seeds[j].x[l]);\n diff2 += d * d;\n }\n double st = 0.5 * sqrt(diff2);\n double edgeScore = mean + alpha * st;\n double val = exp(edgeScore / tau);\n w[i][j] = w[j][i] = val;\n }\n };\n\n auto objective = [&](const vector& grid) -> double {\n double obj = 0.0;\n for (auto [a, b] : edges) obj += w[grid[a]][grid[b]];\n return obj;\n };\n\n auto solveLayoutSA = [&](const vector& cand, double timeLimitSec) -> vector {\n // multi-start\n int starts = 2;\n vector bestGrid(36);\n double bestObj = -1e100;\n\n auto startTime = chrono::steady_clock::now();\n auto deadline = startTime + chrono::duration(timeLimitSec);\n\n for (int st = 0; st < starts; st++) {\n vector grid(36);\n // init: shuffle candidates\n vector perm = cand;\n for (int i = 35; i >= 1; i--) {\n int j = rng.nextInt(0, i + 1);\n swap(perm[i], perm[j]);\n }\n for (int p = 0; p < 36; p++) grid[p] = perm[p];\n\n double curObj = objective(grid);\n vector curGrid = grid;\n\n vector localBestGrid = curGrid;\n double localBestObj = curObj;\n\n // SA parameters tuned for this objective scale.\n const double T0 = 5000.0;\n const double T1 = 10.0;\n\n int it = 0;\n while (chrono::steady_clock::now() < deadline) {\n it++;\n double prog = (double)it / 200000.0;\n if (prog > 1.0) prog = 1.0;\n double temp = T0 * pow(T1 / T0, prog);\n\n int a = rng.nextInt(0, 36);\n int b = rng.nextInt(0, 36);\n if (a == b) continue;\n\n swap(curGrid[a], curGrid[b]);\n double nxtObj = objective(curGrid);\n double delta = nxtObj - curObj;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double p = exp(delta / temp);\n accept = (rng.nextDouble() < p);\n }\n\n if (accept) {\n curObj = nxtObj;\n if (curObj > localBestObj) {\n localBestObj = curObj;\n localBestGrid = curGrid;\n }\n } else {\n swap(curGrid[a], curGrid[b]);\n }\n }\n\n if (localBestObj > bestObj) {\n bestObj = localBestObj;\n bestGrid = localBestGrid;\n }\n }\n return bestGrid;\n };\n\n auto allStart = chrono::steady_clock::now();\n auto allDeadline = allStart + chrono::milliseconds(1900);\n\n for (int t = 0; t < T; t++) {\n buildPairUtility();\n vector cand = selectCandidates();\n\n // Allocate remaining time evenly.\n auto now = chrono::steady_clock::now();\n double remain = chrono::duration(allDeadline - now).count();\n if (remain < 0.02) remain = 0.02;\n double perTurn = remain / (T - t);\n\n // Solve layout\n vector grid = solveLayoutSA(cand, perTurn * 0.92);\n\n // Output as 6 lines\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n if (c) cout << ' ';\n cout << grid[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n\n // Read next generation\n readSeeds();\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Pos {\n int x, y;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n\n // Current board state\n vector> cur(N, vector(N, 0));\n vector> surplus(N, vector(N, 0)); // cur=1, t=0\n vector> deficit(N, vector(N, 0)); // cur=0, t=1\n\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur[i][j] = (s[i][j] == '1');\n\n int surplusCnt = 0, deficitCnt = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int T = (t[i][j] == '1');\n if (cur[i][j] == 1 && T == 0) surplus[i][j] = 1, surplusCnt++;\n if (cur[i][j] == 0 && T == 1) deficit[i][j] = 1, deficitCnt++;\n }\n\n // --- Arm design: root(0) + 4 children(1..4), each length 1 ---\n // V' = 5 regardless of given V (must be <= V, and constraints give V>=5).\n const int Vp = 5;\n cout << Vp << \"\\n\";\n for (int u = 1; u < Vp; u++) {\n cout << 0 << \" \" << 1 << \"\\n\";\n }\n // Initial root position\n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n\n // Directions: 0=Up,1=Right,2=Down,3=Left\n int dx4[4] = {-1, 0, 1, 0};\n int dy4[4] = {0, 1, 0, -1};\n\n // After initialization, fingertips are fixed:\n // vertex 1: Up, 2: Right, 3: Down, 4: Left\n int fingerDir[5] = {-1, 0, 1, 2, 3}; // index by vertex id\n\n // Fingertip holding state (only 1..4 used)\n array hold{};\n hold.fill(0);\n\n auto inside = [&](int x, int y) {\n return (0 <= x && x < N && 0 <= y && y < N);\n };\n\n // Build periodic route: snake forward then backward (excluding duplicate endpoints),\n // ending back at (0,0). Consecutive positions are adjacent or equal.\n vector forward;\n forward.reserve(N * N);\n for (int i = 0; i < N; i++) {\n if (i % 2 == 0) {\n for (int j = 0; j < N; j++) forward.push_back({i, j});\n } else {\n for (int j = N - 1; j >= 0; j--) forward.push_back({i, j});\n }\n }\n vector route = forward;\n for (int k = (int)forward.size() - 2; k >= 0; k--) route.push_back(forward[k]);\n // route[0] == route.back() == (0,0)\n\n auto moveChar = [&](Pos a, Pos b) -> char {\n int dx = b.x - a.x;\n int dy = b.y - a.y;\n if (dx == -1 && dy == 0) return 'U';\n if (dx == 1 && dy == 0) return 'D';\n if (dx == 0 && dy == -1) return 'L';\n if (dx == 0 && dy == 1) return 'R';\n return '.';\n };\n\n int turns = 0;\n const int MAXT = 100000;\n\n auto doActions = [&](string &cmd) {\n // actions are at indices [Vp .. 2*Vp-1] => [5..9]\n // cmd[5] is root action (always '.')\n int base = Vp;\n cmd[base + 0] = '.';\n\n for (int u = 1; u <= 4; u++) {\n int d = fingerDir[u];\n int x = rx + dx4[d];\n int y = ry + dy4[d];\n cmd[base + u] = '.';\n if (!inside(x, y)) continue;\n\n if (hold[u]) {\n // Place if this cell is a deficit (cur=0,t=1)\n if (deficit[x][y]) {\n // place\n cmd[base + u] = 'P';\n hold[u] = 0;\n cur[x][y] = 1;\n deficit[x][y] = 0;\n deficitCnt--;\n }\n } else {\n // Pick if this cell is a surplus (cur=1,t=0)\n if (surplus[x][y]) {\n cmd[base + u] = 'P';\n hold[u] = 1;\n cur[x][y] = 0;\n surplus[x][y] = 0;\n surplusCnt--;\n }\n }\n }\n };\n\n auto emit = [&](const string &cmd) {\n cout << cmd << \"\\n\";\n turns++;\n };\n\n // --- Initialization: rotate fingers to form a cross ---\n // Initial all edges extend to the right. We want:\n // v1: Up (L once), v2: Right (none), v3: Down (R once), v4: Left (R twice).\n // Turn 0: v1=L, v3=R, v4=R. Turn 1: v4=R.\n {\n string cmd(2 * Vp, '.');\n cmd[0] = '.'; // no move\n cmd[1] = 'L'; // v1\n cmd[2] = '.'; // v2\n cmd[3] = 'R'; // v3\n cmd[4] = 'R'; // v4 (Right->Down)\n // no actions in init turns (keep simple)\n emit(cmd);\n }\n if (turns < MAXT) {\n string cmd(2 * Vp, '.');\n cmd[0] = '.';\n cmd[4] = 'R'; // v4 (Down->Left)\n emit(cmd);\n }\n\n // Now we assume the fixed directions are established. (We never rotate again.)\n\n auto done = [&]() {\n if (surplusCnt != 0 || deficitCnt != 0) return false;\n for (int u = 1; u <= 4; u++) if (hold[u]) return false;\n return true;\n };\n\n // Optional: one action turn at the start\n if (turns < MAXT && !done()) {\n string cmd(2 * Vp, '.');\n cmd[0] = '.';\n // no rotations\n doActions(cmd);\n emit(cmd);\n }\n\n // Main loop: follow the periodic snake route and act after each move.\n // We track the current index on the route by the actual position.\n int idx = 0;\n rx = route[0].x;\n ry = route[0].y;\n\n while (turns < MAXT && !done()) {\n int nextIdx;\n if (idx + 1 < (int)route.size()) nextIdx = idx + 1;\n else nextIdx = 1; // if at the last (which equals start), continue to route[1]\n\n Pos a = route[idx];\n Pos b = route[nextIdx];\n\n // Move root according to route\n char mv = moveChar(a, b);\n rx = b.x;\n ry = b.y;\n idx = nextIdx;\n\n string cmd(2 * Vp, '.');\n cmd[0] = mv;\n // rotations are all '.'\n doActions(cmd);\n emit(cmd);\n }\n\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n uint32_t next_u32() { return (uint32_t)(next_u64() & 0xffffffffu); }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n double next_double() {\n // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline double now_sec() {\n using namespace std::chrono;\n return duration_cast>(steady_clock::now().time_since_epoch()).count();\n}\n\nstruct Point {\n int x, y;\n int w; // +1 mackerel, -1 sardine\n};\n\nstruct Rect {\n int xl, xr, yb, yt; // inclusive\n};\n\nstatic inline bool rect_ok(const Rect& r) {\n if (!(0 <= r.xl && r.xl <= 100000)) return false;\n if (!(0 <= r.xr && r.xr <= 100000)) return false;\n if (!(0 <= r.yb && r.yb <= 100000)) return false;\n if (!(0 <= r.yt && r.yt <= 100000)) return false;\n if (r.xl >= r.xr) return false;\n if (r.yb >= r.yt) return false;\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n if (w + h > 200000) return false; // perimeter <= 4e5\n return true;\n}\n\nstatic inline int eval_rect(const Rect& r, const vector& pts) {\n int s = 0;\n for (const auto& p : pts) {\n if (r.xl <= p.x && p.x <= r.xr && r.yb <= p.y && p.y <= r.yt) s += p.w;\n }\n return s;\n}\n\nstatic inline Rect clamp_make(int xl, int xr, int yb, int yt) {\n Rect r{xl, xr, yb, yt};\n r.xl = max(0, min(100000, r.xl));\n r.xr = max(0, min(100000, r.xr));\n r.yb = max(0, min(100000, r.yb));\n r.yt = max(0, min(100000, r.yt));\n // ensure strict\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n // shrink if perimeter too big\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n long long sum = w + h;\n if (sum > 200000) {\n // reduce both directions proportionally, keeping center roughly\n int cx = (r.xl + r.xr) / 2;\n int cy = (r.yb + r.yt) / 2;\n long long over = sum - 200000;\n // reduce width by rw and height by rh\n long long rw = min(over, w - 1);\n long long rh = min(over - rw, h - 1);\n // if still over, trim more (shouldn't happen much)\n while (rw + rh < over) {\n if (w - rw > h - rh && w - rw > 1) rw++;\n else if (h - rh > 1) rh++;\n else break;\n }\n long long neww = max(1LL, w - rw);\n long long newh = max(1LL, h - rh);\n int halfw = (int)(neww / 2);\n int halfh = (int)(newh / 2);\n r.xl = cx - halfw;\n r.xr = r.xl + (int)neww;\n r.yb = cy - halfh;\n r.yt = r.yb + (int)newh;\n // clamp again\n if (r.xl < 0) { r.xr -= r.xl; r.xl = 0; }\n if (r.yb < 0) { r.yt -= r.yb; r.yb = 0; }\n if (r.xr > 100000) { int d = r.xr - 100000; r.xl -= d; r.xr = 100000; if (r.xl < 0) r.xl = 0; }\n if (r.yt > 100000) { int d = r.yt - 100000; r.yb -= d; r.yt = 100000; if (r.yb < 0) r.yb = 0; }\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n }\n return r;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N; // fixed 5000\n vector pts;\n pts.reserve(2 * N);\n vector macks;\n macks.reserve(N);\n\n for (int i = 0; i < 2 * N; i++) {\n int x, y;\n cin >> x >> y;\n int w = (i < N) ? +1 : -1;\n pts.push_back({x, y, w});\n if (i < N) macks.push_back({x, y, +1});\n }\n\n double t0 = now_sec();\n const double TL = 1.95; // keep some margin\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n seed ^= (uint64_t)(pts[0].x * 1000003u + pts[0].y);\n XorShift64 rng(seed);\n\n // Baseline best: tiny rectangle around a random mackerel (guarantee >=1 mackerel, maybe sardines too)\n auto make_around = [&](const Point& c, int w, int h) -> Rect {\n int xl = c.x - w / 2;\n int xr = c.x + w / 2;\n int yb = c.y - h / 2;\n int yt = c.y + h / 2;\n Rect r = clamp_make(xl, xr, yb, yt);\n // ensure center is inside (inclusive)\n if (!(r.xl <= c.x && c.x <= r.xr && r.yb <= c.y && c.y <= r.yt)) {\n r = clamp_make(c.x, c.x + 1, c.y, c.y + 1);\n }\n return r;\n };\n\n Rect best = clamp_make(0, 1, 0, 1);\n int bestDiff = -1e9;\n\n // Initial random sampling around mackerel points\n {\n int trials = 2500;\n for (int it = 0; it < trials; it++) {\n const auto& c = macks[rng.next_int(0, (int)macks.size() - 1)];\n // sizes: mixture of small and medium\n int w, h;\n if (rng.next_double() < 0.65) {\n w = rng.next_int(200, 12000);\n h = rng.next_int(200, 12000);\n } else {\n w = rng.next_int(4000, 60000);\n h = rng.next_int(4000, 60000);\n }\n // enforce perimeter constraint: w+h <= 200000 always true here, but keep safe\n if (w + h > 200000) {\n int over = w + h - 200000;\n w = max(1, w - over / 2);\n h = max(1, h - (over - over / 2));\n }\n Rect r = make_around(c, w, h);\n if (!rect_ok(r)) continue;\n int diff = eval_rect(r, pts);\n if (diff > bestDiff) {\n bestDiff = diff;\n best = r;\n }\n }\n }\n\n // Simulated annealing from the best found\n Rect cur = best;\n int curDiff = bestDiff;\n\n const double SA_T0 = 80.0;\n const double SA_T1 = 1.0;\n\n int iter = 0;\n while (true) {\n double t = now_sec() - t0;\n if (t > TL) break;\n double progress = t / TL;\n double temp = SA_T0 * pow(SA_T1 / SA_T0, progress);\n\n Rect nxt = cur;\n\n // occasional restart around a random mackerel\n if ((iter % 200 == 0) && rng.next_double() < 0.15) {\n const auto& c = macks[rng.next_int(0, (int)macks.size() - 1)];\n int w = rng.next_int(500, 50000);\n int h = rng.next_int(500, 50000);\n nxt = make_around(c, w, h);\n } else {\n // mutate one side\n int which = rng.next_int(0, 3);\n int maxDelta = (int)round(20000 * (1.0 - progress) + 200); // cool down\n int delta = rng.next_int(-maxDelta, maxDelta);\n\n if (which == 0) nxt.xl += delta;\n if (which == 1) nxt.xr += delta;\n if (which == 2) nxt.yb += delta;\n if (which == 3) nxt.yt += delta;\n\n // small probability: expand/shrink both x sides or y sides\n if (rng.next_double() < 0.10) {\n int d2 = rng.next_int(-maxDelta / 3, maxDelta / 3);\n if (rng.next_double() < 0.5) { nxt.xl -= d2; nxt.xr += d2; }\n else { nxt.yb -= d2; nxt.yt += d2; }\n }\n\n nxt = clamp_make(nxt.xl, nxt.xr, nxt.yb, nxt.yt);\n }\n\n if (!rect_ok(nxt)) { iter++; continue; }\n\n int nxtDiff = eval_rect(nxt, pts);\n int delta = nxtDiff - curDiff;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n cur = nxt;\n curDiff = nxtDiff;\n if (curDiff > bestDiff) {\n bestDiff = curDiff;\n best = cur;\n }\n }\n iter++;\n }\n\n // Fallback: if somehow invalid, output minimal rectangle.\n if (!rect_ok(best)) best = clamp_make(0, 1, 0, 1);\n\n // Output as 4-vertex rectangle polygon (counterclockwise)\n cout << 4 << \"\\n\";\n cout << best.xl << \" \" << best.yb << \"\\n\";\n cout << best.xr << \" \" << best.yb << \"\\n\";\n cout << best.xr << \" \" << best.yt << \"\\n\";\n cout << best.xl << \" \" << best.yt << \"\\n\";\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct Op {\n int p; // rectangle index\n int r; // 0/1 rotation\n char d; // 'U' or 'L'\n int b; // reference rectangle index or -1\n};\n\nstruct Candidate {\n vector ops; // size N, ops[i].p == i\n ll estW = (1LL<<62);\n ll estH = (1LL<<62);\n ll estObj = (1LL<<62); // estW + estH\n string tag;\n};\n\nstruct Placed {\n ll x=0, y=0, w=0, h=0;\n};\n\nstatic inline bool overlapPosLen(ll a1, ll a2, ll b1, ll b2) {\n // intervals [a1,a2), [b1,b2) overlap with positive length?\n return max(a1, b1) < min(a2, b2);\n}\n\npair simulate_estimate(const vector& ops, const vector& W, const vector& H) {\n int N = (int)ops.size();\n vector placed(N);\n\n ll maxX = 0, maxY = 0;\n\n for (int i = 0; i < N; i++) {\n const auto &op = ops[i];\n int idx = op.p;\n ll w = W[idx], h = H[idx];\n if (op.r) swap(w, h);\n\n ll x = 0, y = 0;\n if (op.d == 'U') {\n x = 0;\n if (op.b != -1) {\n const auto &pb = placed[op.b];\n x = pb.x + pb.w;\n }\n // y = max bottom among rectangles overlapping in x\n y = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(x, x + w, pj.x, pj.x + pj.w)) {\n y = max(y, pj.y + pj.h);\n }\n }\n } else { // 'L'\n y = 0;\n if (op.b != -1) {\n const auto &pb = placed[op.b];\n y = pb.y + pb.h;\n }\n // x = max right among rectangles overlapping in y\n x = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(y, y + h, pj.y, pj.y + pj.h)) {\n x = max(x, pj.x + pj.w);\n }\n }\n }\n\n placed[i] = Placed{x, y, w, h};\n maxX = max(maxX, x + w);\n maxY = max(maxY, y + h);\n }\n return {maxX, maxY};\n}\n\nstruct RNG {\n uint64_t x;\n explicit RNG(uint64_t seed=88172645463325252ULL) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nCandidate make_row_shelf(\n const vector& w, const vector& h,\n ll Wlim,\n uint64_t seed,\n double epsRotate = 0.08,\n double epsBadChoice = 0.03,\n string tag = \"row\"\n) {\n int N = (int)w.size();\n RNG rng(seed);\n\n Candidate cand;\n cand.ops.resize(N);\n\n int prevRowAnchor = -1; // tallest in previous row\n ll rowW = 0;\n ll rowH = 0;\n int rowTallestIdx = -1;\n ll rowTallestH = -1;\n\n auto choose_rotation = [&](ll rowW, ll rowH, ll Wlim, ll w0, ll h0, ll w1, ll h1) -> int {\n bool fit0 = (rowW + w0 <= Wlim);\n bool fit1 = (rowW + w1 <= Wlim);\n\n int best = 0;\n if (fit0 && fit1) {\n // prefer smaller resulting row height, tie by smaller width\n ll rh0 = max(rowH, h0);\n ll rh1 = max(rowH, h1);\n if (rh1 < rh0 || (rh1 == rh0 && w1 < w0)) best = 1;\n } else if (!fit0 && fit1) best = 1;\n else if (fit0 && !fit1) best = 0;\n else {\n // both don't fit => prefer smaller width\n if (w1 < w0 || (w1 == w0 && h1 < h0)) best = 1;\n }\n\n // small randomness for diversity\n if (rng.next_double() < epsRotate) best ^= 1;\n return best;\n };\n\n auto start_new_row = [&]() {\n // finalize current row\n prevRowAnchor = rowTallestIdx;\n rowW = 0;\n rowH = 0;\n rowTallestIdx = -1;\n rowTallestH = -1;\n };\n\n for (int i = 0; i < N; i++) {\n // decide whether to break row before placing i:\n // evaluate both rotations' widths; if neither can fit (unless row empty), we break.\n ll w0 = w[i], h0 = h[i];\n ll w1 = h[i], h1 = w[i];\n\n if (rowW > 0) {\n bool anyFit = (rowW + w0 <= Wlim) || (rowW + w1 <= Wlim);\n // also sometimes break near limit or when this rect is very tall (heuristic)\n bool nearFull = (rowW >= (ll)floor((long double)Wlim * 0.92L));\n bool veryTall = (rowH > 0 && max(h0, h1) > (ll)floor((long double)rowH * 1.35L));\n if (!anyFit || (nearFull && rng.next_double() < 0.30) || (veryTall && rng.next_double() < epsBadChoice)) {\n start_new_row();\n }\n }\n\n int r = choose_rotation(rowW, rowH, Wlim, w0, h0, w1, h1);\n ll ww = (r == 0 ? w0 : w1);\n ll hh = (r == 0 ? h0 : h1);\n\n // place in current row using 'L' with b = prevRowAnchor (or -1 for first row)\n cand.ops[i] = Op{i, r, 'L', prevRowAnchor};\n\n rowW += ww;\n rowH = max(rowH, hh);\n if (hh > rowTallestH) {\n rowTallestH = hh;\n rowTallestIdx = i;\n }\n }\n\n auto [West, Hest] = simulate_estimate(cand.ops, w, h);\n cand.estW = West;\n cand.estH = Hest;\n cand.estObj = West + Hest;\n cand.tag = tag + \"(Wlim=\" + to_string(Wlim) + \",seed=\" + to_string(seed) + \")\";\n return cand;\n}\n\nCandidate make_col_shelf(\n const vector& w, const vector& h,\n ll Hlim,\n uint64_t seed,\n double epsRotate = 0.08,\n double epsBadChoice = 0.03,\n string tag = \"col\"\n) {\n int N = (int)w.size();\n RNG rng(seed);\n\n Candidate cand;\n cand.ops.resize(N);\n\n int prevColAnchor = -1; // widest in previous column\n ll colH = 0;\n ll colW = 0;\n int colWidestIdx = -1;\n ll colWidestW = -1;\n\n auto choose_rotation = [&](ll colH, ll colW, ll Hlim, ll w0, ll h0, ll w1, ll h1) -> int {\n bool fit0 = (colH + h0 <= Hlim);\n bool fit1 = (colH + h1 <= Hlim);\n\n int best = 0;\n if (fit0 && fit1) {\n // prefer smaller resulting column width, tie by smaller height\n ll cw0 = max(colW, w0);\n ll cw1 = max(colW, w1);\n if (cw1 < cw0 || (cw1 == cw0 && h1 < h0)) best = 1;\n } else if (!fit0 && fit1) best = 1;\n else if (fit0 && !fit1) best = 0;\n else {\n // both don't fit => prefer smaller height\n if (h1 < h0 || (h1 == h0 && w1 < w0)) best = 1;\n }\n\n if (rng.next_double() < epsRotate) best ^= 1;\n return best;\n };\n\n auto start_new_col = [&]() {\n prevColAnchor = colWidestIdx;\n colH = 0;\n colW = 0;\n colWidestIdx = -1;\n colWidestW = -1;\n };\n\n for (int i = 0; i < N; i++) {\n ll w0 = w[i], h0 = h[i];\n ll w1 = h[i], h1 = w[i];\n\n if (colH > 0) {\n bool anyFit = (colH + h0 <= Hlim) || (colH + h1 <= Hlim);\n bool nearFull = (colH >= (ll)floor((long double)Hlim * 0.92L));\n bool veryWide = (colW > 0 && max(w0, w1) > (ll)floor((long double)colW * 1.35L));\n if (!anyFit || (nearFull && rng.next_double() < 0.30) || (veryWide && rng.next_double() < epsBadChoice)) {\n start_new_col();\n }\n }\n\n int r = choose_rotation(colH, colW, Hlim, w0, h0, w1, h1);\n ll ww = (r == 0 ? w0 : w1);\n ll hh = (r == 0 ? h0 : h1);\n\n // place in current column using 'U' with b = prevColAnchor (or -1 for first column)\n cand.ops[i] = Op{i, r, 'U', prevColAnchor};\n\n colH += hh;\n colW = max(colW, ww);\n if (ww > colWidestW) {\n colWidestW = ww;\n colWidestIdx = i;\n }\n }\n\n auto [West, Hest] = simulate_estimate(cand.ops, w, h);\n cand.estW = West;\n cand.estH = Hest;\n cand.estObj = West + Hest;\n cand.tag = tag + \"(Hlim=\" + to_string(Hlim) + \",seed=\" + to_string(seed) + \")\";\n return cand;\n}\n\nCandidate make_all_one_row(const vector& w, const vector& h, uint64_t seed, string tag=\"oneRow\") {\n int N = (int)w.size();\n RNG rng(seed);\n Candidate cand;\n cand.ops.resize(N);\n // All in y=0 row: use 'L' b=-1 always. Rotation: prefer smaller height.\n for (int i = 0; i < N; i++) {\n ll w0 = w[i], h0 = h[i];\n ll w1 = h[i], h1 = w[i];\n int r = 0;\n if (h1 < h0 || (h1 == h0 && w1 < w0)) r = 1;\n if (rng.next_double() < 0.05) r ^= 1;\n cand.ops[i] = Op{i, r, 'L', -1};\n }\n auto [West, Hest] = simulate_estimate(cand.ops, w, h);\n cand.estW = West; cand.estH = Hest; cand.estObj = West + Hest;\n cand.tag = tag;\n return cand;\n}\n\nCandidate make_all_one_col(const vector& w, const vector& h, uint64_t seed, string tag=\"oneCol\") {\n int N = (int)w.size();\n RNG rng(seed);\n Candidate cand;\n cand.ops.resize(N);\n // All in x=0 column: use 'U' b=-1 always. Rotation: prefer smaller width.\n for (int i = 0; i < N; i++) {\n ll w0 = w[i], h0 = h[i];\n ll w1 = h[i], h1 = w[i];\n int r = 0;\n if (w1 < w0 || (w1 == w0 && h1 < h0)) r = 1;\n if (rng.next_double() < 0.05) r ^= 1;\n cand.ops[i] = Op{i, r, 'U', -1};\n }\n auto [West, Hest] = simulate_estimate(cand.ops, w, h);\n cand.estW = West; cand.estH = Hest; cand.estObj = West + Hest;\n cand.tag = tag;\n return cand;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T;\n int sigma;\n cin >> N >> T >> sigma;\n\n vector wp(N), hp(N);\n for (int i = 0; i < N; i++) cin >> wp[i] >> hp[i];\n\n // Compute rough scale\n long double areaSum = 0;\n ll sumW = 0, sumH = 0;\n for (int i = 0; i < N; i++) {\n areaSum += (long double)wp[i] * (long double)hp[i];\n sumW += wp[i];\n sumH += hp[i];\n }\n ll sq = max(1, (ll)floor(sqrt((long double)areaSum)));\n\n vector pool;\n // Extremes\n pool.push_back(make_all_one_row(wp, hp, 1, \"oneRow\"));\n pool.push_back(make_all_one_col(wp, hp, 2, \"oneCol\"));\n\n // Row-shelf candidates with various target widths\n vector factorsW = {0.60L, 0.75L, 0.90L, 1.00L, 1.10L, 1.25L, 1.45L};\n uint64_t seedBase = 1234567;\n\n for (int fi = 0; fi < (int)factorsW.size(); fi++) {\n ll Wlim = max(1, (ll)llround((long double)sq * factorsW[fi]));\n // keep within reasonable range: cannot exceed sumW anyway\n Wlim = min(Wlim, sumW);\n for (int k = 0; k < 7; k++) {\n uint64_t sd = seedBase + 1000ULL * fi + k;\n pool.push_back(make_row_shelf(wp, hp, Wlim, sd, 0.10, 0.05, \"row\"));\n }\n }\n\n // Col-shelf candidates with various target heights\n vector factorsH = {0.60L, 0.75L, 0.90L, 1.00L, 1.10L, 1.25L, 1.45L};\n for (int fi = 0; fi < (int)factorsH.size(); fi++) {\n ll Hlim = max(1, (ll)llround((long double)sq * factorsH[fi]));\n Hlim = min(Hlim, sumH);\n for (int k = 0; k < 7; k++) {\n uint64_t sd = seedBase + 20000ULL + 1000ULL * fi + k;\n pool.push_back(make_col_shelf(wp, hp, Hlim, sd, 0.10, 0.05, \"col\"));\n }\n }\n\n // Sort by estimated objective (W+H) and keep top few\n sort(pool.begin(), pool.end(), [](const Candidate& a, const Candidate& b) {\n if (a.estObj != b.estObj) return a.estObj < b.estObj;\n if (a.estW != b.estW) return a.estW < b.estW;\n return a.estH < b.estH;\n });\n\n int KEEP = min((int)pool.size(), 60);\n pool.resize(KEEP);\n\n // Interactive loop: output candidates in this order, then repeat the best observed (by W'+H').\n ll bestMeasured = (1LL<<62);\n int bestIdx = 0;\n\n for (int t = 0; t < T; t++) {\n int useIdx = t < (int)pool.size() ? t : bestIdx;\n const auto &cand = pool[useIdx];\n\n cout << N << \"\\n\";\n for (int i = 0; i < N; i++) {\n const auto &op = cand.ops[i];\n cout << op.p << \" \" << op.r << \" \" << op.d << \" \" << op.b << \"\\n\";\n }\n cout << flush;\n\n ll Wm, Hm;\n if (!(cin >> Wm >> Hm)) return 0;\n\n ll measured = Wm + Hm;\n if (measured < bestMeasured) {\n bestMeasured = measured;\n bestIdx = useIdx;\n }\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nstatic inline uint32_t xorshift32(uint32_t &x) {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n}\n\nstruct BFSResult {\n vector dist;\n vector prev;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n\n vector> edges(M);\n vector> g(N);\n g.assign(N, {});\n edges.reserve(M);\n\n // For safety validation at end\n unordered_set edgeSet;\n edgeSet.reserve(M * 2);\n\n auto keyEdge = [&](int u, int v)->long long{\n if (u > v) swap(u, v);\n return (long long)u * N + v;\n };\n\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n edges[i] = {u, v};\n g[u].push_back(v);\n g[v].push_back(u);\n edgeSet.insert(keyEdge(u, v));\n }\n // coordinates not used in this heuristic\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n\n auto multiSourceBFS = [&](const vector& roots)->BFSResult{\n const int INF = 1e9;\n BFSResult res;\n res.dist.assign(N, INF);\n res.prev.assign(N, -1);\n deque q;\n for (int r : roots) {\n res.dist[r] = 0;\n res.prev[r] = -1;\n q.push_back(r);\n }\n while (!q.empty()) {\n int v = q.front(); q.pop_front();\n int nd = res.dist[v] + 1;\n for (int to : g[v]) {\n if (res.dist[to] > nd) {\n res.dist[to] = nd;\n res.prev[to] = v;\n q.push_back(to);\n }\n }\n }\n return res;\n };\n\n // 1) Root selection (cover all within H, prefer small A)\n int minA = INT_MAX, root0 = 0;\n for (int i = 0; i < N; i++) if (A[i] < minA) { minA = A[i]; root0 = i; }\n\n vector roots;\n roots.push_back(root0);\n\n while (true) {\n auto bfs = multiSourceBFS(roots);\n int far = -1, farD = -1;\n for (int i = 0; i < N; i++) {\n if (bfs.dist[i] > farD) { farD = bfs.dist[i]; far = i; }\n }\n if (farD <= H) break;\n\n // climb from far towards nearest root by (farD - H) steps\n int cur = far;\n int steps = farD - H;\n\n // keep last few nodes on this climb to pick a low-A root candidate\n // path: far -> ... -> (candidate) -> ... -> root\n int child1 = -1, child2 = -1; // nodes closer to far\n for (int s = 0; s < steps; s++) {\n child2 = child1;\n child1 = cur;\n cur = bfs.prev[cur];\n if (cur == -1) break;\n }\n if (cur == -1) {\n // should not happen in connected graph, but be safe\n roots.push_back(far);\n continue;\n }\n\n // candidates: cur (dist H from far), child1 (H-1), child2 (H-2)\n int best = cur;\n auto consider = [&](int v){\n if (v == -1) return;\n if (A[v] < A[best]) best = v;\n };\n consider(child1);\n consider(child2);\n\n roots.push_back(best);\n }\n\n // Try removing redundant roots (keep coverage <=H)\n {\n uint32_t rng = 123456789u;\n vector order = roots;\n for (int i = (int)order.size() - 1; i > 0; i--) {\n int j = (int)(xorshift32(rng) % (i + 1));\n swap(order[i], order[j]);\n }\n vector alive(N, 0);\n for (int r : roots) alive[r] = 1;\n\n for (int r : order) {\n if (!alive[r]) continue;\n vector tmp;\n tmp.reserve(roots.size());\n for (int rr : roots) if (alive[rr] && rr != r) tmp.push_back(rr);\n if (tmp.empty()) continue;\n\n auto bfs = multiSourceBFS(tmp);\n int farD = 0;\n for (int i = 0; i < N; i++) farD = max(farD, bfs.dist[i]);\n if (farD <= H) {\n alive[r] = 0;\n }\n }\n vector newRoots;\n for (int r : roots) if (alive[r]) newRoots.push_back(r);\n roots.swap(newRoots);\n }\n\n // 2) Initial forest by BFS from roots\n auto bfs = multiSourceBFS(roots);\n vector parent(N, -1), depth(N, 0);\n\n // If some vertex still >H (shouldn't), make it a root.\n for (int i = 0; i < N; i++) {\n if (bfs.dist[i] > H) {\n parent[i] = -1;\n depth[i] = 0;\n }\n }\n // For covered vertices, parent is prev, depth is dist\n for (int i = 0; i < N; i++) {\n if (bfs.dist[i] <= H) {\n parent[i] = bfs.prev[i];\n depth[i] = bfs.dist[i];\n }\n }\n\n // 3) Prepare children lists with O(1) removal\n vector> children(N);\n vector idxInChild(N, -1);\n children.assign(N, {});\n for (int v = 0; v < N; v++) {\n if (parent[v] != -1) {\n int p = parent[v];\n idxInChild[v] = (int)children[p].size();\n children[p].push_back(v);\n }\n }\n\n auto removeChild = [&](int p, int v) {\n int idx = idxInChild[v];\n if (idx < 0) return;\n int last = children[p].back();\n children[p][idx] = last;\n idxInChild[last] = idx;\n children[p].pop_back();\n idxInChild[v] = -1;\n };\n auto addChild = [&](int p, int v) {\n idxInChild[v] = (int)children[p].size();\n children[p].push_back(v);\n };\n\n // current score (attractiveness sum)\n long long score = 0;\n for (int v = 0; v < N; v++) score += 1LL * (depth[v] + 1) * A[v];\n\n auto isAncestor = [&](int anc, int v)->bool{\n // check if anc is on parent chain of v\n // depth <= H so this is cheap\n while (v != -1) {\n if (v == anc) return true;\n v = parent[v];\n }\n return false;\n };\n\n // 4) Hill-climb: reparent subtree deeper using random edges\n uint32_t rng = 987654321u;\n auto start = chrono::steady_clock::now();\n const double TL = 1.90; // seconds, leave a little margin\n\n int iter = 0;\n while (true) {\n iter++;\n if ((iter & 1023) == 0) {\n auto now = chrono::steady_clock::now();\n double t = chrono::duration(now - start).count();\n if (t > TL) break;\n }\n\n auto [a, b] = edges[xorshift32(rng) % M];\n int u, v;\n if (xorshift32(rng) & 1) { u = a; v = b; }\n else { u = b; v = a; }\n\n // try make u parent of v\n if (u == v) continue;\n if (parent[v] == u) continue;\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n\n int delta = newDepthV - depth[v];\n if (delta <= 0) continue; // only improving by pushing deeper\n\n // cycle check: u must not be in subtree(v)\n // equivalent: v is not an ancestor of u\n if (isAncestor(v, u)) continue;\n\n // collect subtree of v, check depth feasibility, compute sumA\n long long sumA = 0;\n vector sub;\n sub.reserve(64);\n vector st;\n st.push_back(v);\n bool ok = true;\n while (!st.empty()) {\n int x = st.back(); st.pop_back();\n sub.push_back(x);\n sumA += A[x];\n if (depth[x] + delta > H) { ok = false; break; }\n for (int ch : children[x]) st.push_back(ch);\n }\n if (!ok) continue;\n\n // accept\n long long gain = 1LL * delta * sumA;\n if (gain <= 0) continue;\n\n int oldp = parent[v];\n if (oldp != -1) removeChild(oldp, v);\n parent[v] = u;\n addChild(u, v);\n\n for (int x : sub) depth[x] += delta;\n score += gain;\n }\n\n // 5) Final safety pass: validate parent edges and depths; fix if needed\n // recompute depths by BFS/DFS from roots of the forest, detect cycles/unreachable\n vector indeg(N, 0);\n for (int v = 0; v < N; v++) if (parent[v] != -1) indeg[v]++;\n\n // ensure parent edges exist; otherwise cut\n for (int v = 0; v < N; v++) {\n if (parent[v] != -1) {\n if (!edgeSet.count(keyEdge(v, parent[v]))) {\n int p = parent[v];\n removeChild(p, v);\n parent[v] = -1;\n }\n }\n }\n\n // recompute depth from roots\n vector dep2(N, -1);\n deque q;\n for (int v = 0; v < N; v++) {\n if (parent[v] == -1) {\n dep2[v] = 0;\n q.push_back(v);\n }\n }\n while (!q.empty()) {\n int x = q.front(); q.pop_front();\n for (int ch : children[x]) {\n if (dep2[ch] != -1) continue; // should not happen\n dep2[ch] = dep2[x] + 1;\n q.push_back(ch);\n }\n }\n // if something went wrong (cycle), cut those vertices to roots\n for (int v = 0; v < N; v++) {\n if (dep2[v] == -1) {\n // break cycle by making it root\n int p = parent[v];\n if (p != -1) removeChild(p, v);\n parent[v] = -1;\n dep2[v] = 0;\n }\n }\n // enforce height <= H by cutting overly deep vertices (rare)\n // do one pass: if dep2[v] > H, cut it\n for (int v = 0; v < N; v++) {\n if (dep2[v] > H) {\n int p = parent[v];\n if (p != -1) removeChild(p, v);\n parent[v] = -1;\n dep2[v] = 0;\n }\n }\n\n // Output\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << \"\\n\";\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstatic inline int pc64(uint64_t x){ return __builtin_popcountll(x); }\n\nstruct Action {\n char dir; // L,R,U,D (forward)\n int p; // row or column index\n int k; // number of shifts forward (and backward)\n uint64_t mask; // which oni indices are removed by this action\n int cost; // 2*k\n};\n\nstatic inline char opposite_dir(char d){\n if(d=='L') return 'R';\n if(d=='R') return 'L';\n if(d=='U') return 'D';\n return 'U';\n}\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N; // fixed 20 in this contest\n vector C(N);\n for(int i=0;i> C[i];\n\n // Index Oni positions (max 40)\n vector> oniPos;\n vector> oniId(N, vector(N, -1));\n for(int i=0;i>> rowOnis(N), colOnis(N); // (pos, id)\n for(int id=0; id rowFirstFuku(N, N), rowLastFuku(N, -1);\n vector colFirstFuku(N, N), colLastFuku(N, -1);\n for(int i=0;i acts;\n acts.reserve(8000);\n\n auto add_action = [&](char dir, int p, int k, uint64_t mask){\n if(k<=0) return;\n if(mask==0) return;\n Action a{dir, p, k, mask, 2*k};\n acts.push_back(a);\n };\n\n // Generate row actions\n for(int i=0;i=0; t--){\n int col = rowOnis[i][t].first;\n int id = rowOnis[i][t].second;\n if(col > lastF){\n sufMask |= (1ULL<=0; t--){\n int row = colOnis[j][t].first;\n int id = colOnis[j][t].second;\n if(row > lastF){\n sufMask |= (1ULL< sol; sol.reserve(64);\n\n while(uncovered){\n int bestIdx = -1;\n int bestGain = 0;\n int bestCost = 1;\n\n for(int idx=0; idx<(int)acts.size(); idx++){\n uint64_t gmask = acts[idx].mask & uncovered;\n int gain = pc64(gmask);\n if(gain==0) continue;\n int cost = acts[idx].cost;\n\n // maximize gain/cost, then gain, then lower cost\n // compare gain1/cost1 vs gain2/cost2 => gain1*cost2 ? gain2*cost1\n if(bestIdx==-1 ||\n 1LL*gain*bestCost > 1LL*bestGain*cost ||\n (1LL*gain*bestCost == 1LL*bestGain*cost && (gain > bestGain ||\n (gain==bestGain && cost < bestCost)))){\n bestIdx = idx;\n bestGain = gain;\n bestCost = cost;\n }\n }\n\n if(bestIdx==-1){\n // Shouldn't happen, but fallback: remove remaining oni one by one using guaranteed safe direction.\n break;\n }\n sol.push_back(bestIdx);\n uncovered &= ~acts[bestIdx].mask;\n }\n\n // If fallback needed (rare), add singleton removals.\n if(uncovered){\n for(int id=0; id>id)&1ULL)==0) continue;\n auto [i,j] = oniPos[id];\n\n // find a safe direction per problem guarantee\n // Left: no fuku in row i, cols [0..j-1]\n bool ok = false;\n // left\n if(rowFirstFuku[i] >= j){\n // action L with k=j+1, removes all oni in prefix, but at least this one\n // build mask of oni in row with col <= j\n uint64_t msk = 0;\n for(auto [col, oid] : rowOnis[i]) if(col<=j) msk |= (1ULL<=j) msk |= (1ULL<= i){\n uint64_t msk = 0;\n for(auto [row, oid] : colOnis[j]) if(row<=i) msk |= (1ULL<=i) msk |= (1ULL<& s){\n vector cnt(M,0);\n for(int idx: s){\n uint64_t m = acts[idx].mask;\n while(m){\n int b = __builtin_ctzll(m);\n cnt[b]++;\n m &= (m-1);\n }\n }\n return cnt;\n };\n\n // Prune & replace passes\n for(int iter=0; iter<20; iter++){\n bool changed = false;\n vector cnt = build_counts(sol);\n\n // prune\n for(int si=0; si<(int)sol.size(); ){\n int aidx = sol[si];\n uint64_t m = acts[aidx].mask;\n bool hasUnique = false;\n uint64_t tmp = m;\n while(tmp){\n int b = __builtin_ctzll(tmp);\n if(cnt[b]==1){ hasUnique=true; break; }\n tmp &= (tmp-1);\n }\n if(!hasUnique){\n // remove\n sol.erase(sol.begin()+si);\n changed = true;\n cnt = build_counts(sol);\n }else{\n si++;\n }\n }\n\n // replacement\n cnt = build_counts(sol);\n for(int si=0; si<(int)sol.size(); si++){\n int oldIdx = sol[si];\n uint64_t oldMask = acts[oldIdx].mask;\n int oldCost = acts[oldIdx].cost;\n\n // needed = bits uniquely covered by this action\n uint64_t needed = 0;\n uint64_t tmp = oldMask;\n while(tmp){\n int b = __builtin_ctzll(tmp);\n if(cnt[b]==1) needed |= (1ULL<= bestCost) continue;\n if((needed & ~acts[cand].mask) != 0) continue; // doesn't cover needed\n bestIdx = cand;\n bestCost = acts[cand].cost;\n }\n\n if(bestIdx != oldIdx){\n sol[si] = bestIdx;\n changed = true;\n cnt = build_counts(sol);\n }\n }\n\n if(!changed) break;\n }\n\n // Emit operations\n vector> ops;\n ops.reserve(2000);\n for(int idx: sol){\n const auto &a = acts[idx];\n for(int t=0;t 4*N*N){\n // Fallback: very safe per-oni method (guaranteed within 1600).\n ops.clear();\n // Recompute fuku boundaries (still same), and remove each oni individually with a safe direction\n for(int id=0; id= j){\n int k = j+1;\n for(int t=0;t= i){\n int k = i+1;\n for(int t=0;t 4*N*N){\n // As a last resort, output nothing (will score poorly but avoid WA due to too many lines).\n // However, problem guarantee + this method should prevent reaching here.\n return 0;\n }\n }\n\n for(auto [d,p]: ops){\n cout << d << \" \" << p << \"\\n\";\n }\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x = 88172645463325252ull;\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n uint32_t next_u32() { return (uint32_t)next_u64(); }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic constexpr int NMAX = 100;\n\nstatic inline long long simulate_plan(int N, int L,\n const int a[NMAX], const int b[NMAX],\n const int T[NMAX],\n int outCnt[NMAX]) {\n // counts\n for (int i = 0; i < N; i++) outCnt[i] = 0;\n\n int x = 0;\n outCnt[x] = 1;\n\n for (int step = 1; step < L; step++) {\n // t = outCnt[x] is the number of times x was assigned by end of last week\n int nx = (outCnt[x] & 1) ? a[x] : b[x];\n x = nx;\n outCnt[x]++;\n }\n\n long long err = 0;\n for (int i = 0; i < N; i++) err += llabs((long long)outCnt[i] - (long long)T[i]);\n return err;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, L;\n cin >> N >> L;\n static int T[NMAX];\n for (int i = 0; i < N; i++) cin >> T[i];\n\n XorShift64 rng;\n\n // ---- Build a_i as a single Hamiltonian cycle over employees ----\n vector order(N);\n iota(order.begin(), order.end(), 0);\n stable_sort(order.begin(), order.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] < T[j];\n return i < j;\n });\n\n static int a[NMAX], b_cur[NMAX], b_best[NMAX];\n static int predOf[NMAX];\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n a[u] = v;\n }\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n predOf[v] = u;\n }\n\n // ---- Greedy assignment of b_i to match remaining incoming capacity ----\n // cap[j] = 2*T[j] - T[pred(j)] (already gets T[pred(j)] from a_pred(j))\n static long long cap[NMAX];\n for (int j = 0; j < N; j++) cap[j] = 2LL * T[j] - (long long)T[predOf[j]];\n\n // Process sources in descending T to place big weights first\n vector srcs(N);\n iota(srcs.begin(), srcs.end(), 0);\n stable_sort(srcs.begin(), srcs.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] > T[j];\n return i < j;\n });\n\n for (int idx = 0; idx < N; idx++) {\n int i = srcs[idx];\n long long w = T[i];\n\n int bestJ = 0;\n long long bestCap = LLONG_MIN;\n\n // Prefer bins with cap >= w; among them choose the largest cap.\n // If none, choose the bin with the largest cap anyway.\n bool foundFit = false;\n for (int j = 0; j < N; j++) {\n if (cap[j] >= w) {\n if (!foundFit || cap[j] > bestCap) {\n foundFit = true;\n bestCap = cap[j];\n bestJ = j;\n }\n }\n }\n if (!foundFit) {\n bestCap = cap[0];\n bestJ = 0;\n for (int j = 1; j < N; j++) {\n if (cap[j] > bestCap) {\n bestCap = cap[j];\n bestJ = j;\n }\n }\n }\n\n b_cur[i] = bestJ;\n cap[bestJ] -= w;\n }\n\n // ---- Evaluate initial ----\n static int cnt_cur[NMAX], cnt_tmp[NMAX];\n long long err_cur = simulate_plan(N, L, a, b_cur, T, cnt_cur);\n\n for (int i = 0; i < N; i++) b_best[i] = b_cur[i];\n long long err_best = err_cur;\n\n // ---- Local search over b only ----\n auto start = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 1.90; // seconds (leave margin)\n\n // helper to build candidate lists based on current counts\n auto build_deficit_list = [&](const int cnt[NMAX]) {\n vector> v; // (deficit, idx)\n v.reserve(N);\n for (int j = 0; j < N; j++) {\n int d = T[j] - cnt[j];\n v.emplace_back(d, j);\n }\n sort(v.begin(), v.end(), [&](auto &p, auto &q){\n if (p.first != q.first) return p.first > q.first;\n return p.second < q.second;\n });\n vector res;\n for (auto &p : v) res.push_back(p.second);\n return res;\n };\n\n auto build_src_list = [&](const int cnt[NMAX]) {\n vector> v; // (visits, idx)\n v.reserve(N);\n for (int i = 0; i < N; i++) v.emplace_back(cnt[i], i);\n sort(v.begin(), v.end(), [&](auto &p, auto &q){\n if (p.first != q.first) return p.first > q.first;\n return p.second < q.second;\n });\n vector res;\n for (auto &p : v) res.push_back(p.second);\n return res;\n };\n\n int iter = 0;\n while (true) {\n iter++;\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > TIME_LIMIT) break;\n\n double progress = elapsed / TIME_LIMIT;\n double temp0 = 2000.0, temp1 = 20.0;\n double temp = temp0 * pow(temp1 / temp0, progress);\n\n // Build bias lists\n vector deficit = build_deficit_list(cnt_cur); // biggest deficit first\n vector srcBias = build_src_list(cnt_cur); // most visited first\n\n // Propose a move\n int i = srcBias[min((int)srcBias.size()-1, rng.next_int(0, 29))];\n\n bool doSwap = (rng.next_double() < 0.35);\n int old_bi = b_cur[i];\n\n int j = -1;\n int i2 = -1;\n int old_bi2 = -1;\n\n if (!doSwap) {\n // Change one b_i toward a deficit node with high probability\n bool useDef = (rng.next_double() < 0.85);\n if (useDef) {\n int k = rng.next_int(0, 29);\n k = min(k, (int)deficit.size() - 1);\n j = deficit[k];\n } else {\n j = rng.next_int(0, N - 1);\n }\n if (j == old_bi) continue;\n b_cur[i] = j;\n } else {\n // Swap two b's (keeps multiset of destinations)\n i2 = srcBias[min((int)srcBias.size()-1, rng.next_int(0, 29))];\n if (i2 == i) i2 = rng.next_int(0, N - 1);\n if (i2 == i) continue;\n old_bi2 = b_cur[i2];\n if (old_bi2 == old_bi) continue;\n swap(b_cur[i], b_cur[i2]);\n }\n\n long long err_new = simulate_plan(N, L, a, b_cur, T, cnt_tmp);\n\n bool accept = false;\n if (err_new <= err_cur) {\n accept = true;\n } else {\n double prob = exp((double)(err_cur - err_new) / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n err_cur = err_new;\n for (int k = 0; k < N; k++) cnt_cur[k] = cnt_tmp[k];\n\n if (err_cur < err_best) {\n err_best = err_cur;\n for (int k = 0; k < N; k++) b_best[k] = b_cur[k];\n }\n } else {\n // revert\n if (!doSwap) {\n b_cur[i] = old_bi;\n } else {\n // swap back\n swap(b_cur[i], b_cur[i2]);\n }\n }\n }\n\n // Output: fixed a, best b found\n for (int i = 0; i < N; i++) {\n cout << a[i] << ' ' << b_best[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nstruct DSU {\n int n;\n vector p, r;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n p.resize(n);\n r.assign(n,0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){ return p[a]==a?a:p[a]=find(p[a]);}\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a] 0; s /= 2) {\n int rx = (x & s) ? 1 : 0;\n int ry = (y & s) ? 1 : 0;\n d += (uint32_t)s * (uint32_t)s * (uint32_t)((3 * rx) ^ ry);\n rot(s, x, y, rx, ry);\n }\n return d;\n}\n\nstruct EdgeCand {\n int u, v;\n long long d2;\n bool fromQuery;\n};\n\nstatic inline long long sqrll(long long a){ return a*a; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L;\n int W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for(int i=0;i> G[i];\n\n vector lx(N), rx(N), ly(N), ry(N);\n for(int i=0;i> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n // Estimated coordinates: rectangle center (integer)\n vector ex(N), ey(N);\n for(int i=0;iint{\n // v in [0,10000], map to [0,65535]\n return (int)llround((long double)v * 65535.0L / 10000.0L);\n };\n\n vector hkey(N);\n for(int i=0;i cities(N);\n iota(cities.begin(), cities.end(), 0);\n sort(cities.begin(), cities.end(), [&](int a, int b){\n if(hkey[a] != hkey[b]) return hkey[a] < hkey[b];\n if(ex[a] != ex[b]) return ex[a] < ex[b];\n return ey[a] < ey[b];\n });\n\n // Assign contiguous segments, but choose which group gets which segment by sorting groups by size\n vector gidx(M);\n iota(gidx.begin(), gidx.end(), 0);\n sort(gidx.begin(), gidx.end(), [&](int a, int b){\n if(G[a] != G[b]) return G[a] > G[b];\n return a < b;\n });\n\n vector> groups(M);\n int ptr = 0;\n for(int t=0;t dist2(N*N);\n for(int i=0;i>> queryEdges(M);\n int usedQ = 0;\n\n auto do_query = [&](const vector& subset) -> vector> {\n int l = (int)subset.size();\n cout << \"? \" << l;\n for(int v: subset) cout << \" \" << v;\n cout << \"\\n\" << flush;\n\n vector> ret;\n ret.reserve(l-1);\n for(int i=0;i> a >> b;\n if(a>b) swap(a,b);\n ret.push_back({a,b});\n }\n return ret;\n };\n\n // Query each group by overlapping blocks of size up to L, overlap 1 vertex.\n // Order queries by larger groups first (already by gidx).\n for(int t=0;t subset(vec.begin()+pos, vec.begin()+pos+l);\n auto ret = do_query(subset);\n queryEdges[k].insert(queryEdges[k].end(), ret.begin(), ret.end());\n usedQ++;\n pos += (l - 1); // overlap by 1\n }\n }\n\n // Final answer\n cout << \"!\\n\" << flush;\n\n for(int k=0;k bestFromQuery; // key -> fromQuery\n bestFromQuery.reserve((size_t)g * 16);\n\n auto add_edge = [&](int u, int v, bool fromQuery){\n if(u==v) return;\n if(u>v) swap(u,v);\n long long key = (long long)u * 1000LL + v; // N<=800\n auto it = bestFromQuery.find(key);\n if(it == bestFromQuery.end()) bestFromQuery.emplace(key, fromQuery);\n else it->second = it->second || fromQuery;\n };\n\n for(auto &e: queryEdges[k]) add_edge(e.first, e.second, true);\n\n // Chain edges to guarantee connectivity even if queries are missing\n for(int i=0;i cands;\n cands.reserve(bestFromQuery.size());\n for(auto &kv: bestFromQuery){\n long long key = kv.first;\n int u = (int)(key / 1000LL);\n int v = (int)(key % 1000LL);\n EdgeCand ec;\n ec.u = u; ec.v = v;\n ec.d2 = dist2[u*N + v];\n ec.fromQuery = kv.second;\n cands.push_back(ec);\n }\n\n // Map city id to local index for DSU\n unordered_map lid;\n lid.reserve((size_t)g*2);\n for(int i=0;i b.fromQuery;\n if(a.u != b.u) return a.u < b.u;\n return a.v < b.v;\n });\n\n DSU dsu(g);\n vector> chosen;\n chosen.reserve(g-1);\n\n for(auto &e: cands){\n int a = lid[e.u];\n int b = lid[e.v];\n if(dsu.unite(a,b)){\n chosen.push_back({e.u, e.v});\n if((int)chosen.size() == g-1) break;\n }\n }\n\n // If still not connected (should be rare), connect components using best estimated edges\n while((int)chosen.size() < g-1){\n // Find best pair across different components\n int bestU=-1, bestV=-1;\n long long bestD2 = (1LL<<62);\n\n // compress component ids\n for(int i=0;i bestV) swap(bestU, bestV);\n chosen.push_back({bestU, bestV});\n }\n }\n\n // Output exactly g-1 edges\n // (Assume we achieved it; but keep safe fallback)\n if((int)chosen.size() != g-1){\n // Ultimate fallback: star to vec[0]\n chosen.clear();\n for(int i=1;iv) swap(u,v);\n chosen.push_back({u,v});\n }\n }\n\n for(auto &e: chosen){\n cout << e.first << \" \" << e.second << \"\\n\";\n }\n }\n\n cout << flush;\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nstatic constexpr int N = 20;\n\nstruct Pos {\n int r, c;\n};\nstatic inline int pid(int r, int c) { return r * N + c; }\nstatic inline bool inside(int r, int c) { return 0 <= r && r < N && 0 <= c && c < N; }\n\nstruct Prev {\n int pstate = -1;\n char act = '?';\n char dir = '?';\n};\n\nstatic const int dr[4] = {-1, 1, 0, 0};\nstatic const int dc[4] = {0, 0, -1, 1};\nstatic const char dch[4] = {'U', 'D', 'L', 'R'};\n\nstruct Planner {\n // candidate cells (<=8)\n vector cand;\n array cand_id; // -1 if not candidate, else index\n int C = 0;\n\n Planner() {\n cand_id.fill(-1);\n }\n\n void build_candidates(const Pos& start, const Pos& target) {\n cand.clear();\n cand_id.fill(-1);\n\n auto add = [&](int r, int c) {\n if (!inside(r,c)) return;\n int id = pid(r,c);\n if (cand_id[id] != -1) return;\n cand_id[id] = (int)cand.size();\n cand.push_back({r,c});\n };\n\n // neighbors of start\n for (int k = 0; k < 4; k++) add(start.r + dr[k], start.c + dc[k]);\n // neighbors of target\n for (int k = 0; k < 4; k++) add(target.r + dr[k], target.c + dc[k]);\n\n C = (int)cand.size();\n }\n\n inline bool is_blocked_cell(int r, int c, int mask) const {\n int idx = cand_id[pid(r,c)];\n if (idx == -1) return false; // board is otherwise empty\n return (mask >> idx) & 1;\n }\n\n int slide_endpoint(int r, int c, int dir, int mask) const {\n // Find nearest candidate-block in that ray; otherwise boundary.\n int bestDist = INT_MAX;\n\n // scan candidate blocks only (C <= 8)\n for (int i = 0; i < C; i++) if ((mask >> i) & 1) {\n int br = cand[i].r, bc = cand[i].c;\n if (dir == 0) { // U\n if (bc == c && br < r) bestDist = min(bestDist, r - br);\n } else if (dir == 1) { // D\n if (bc == c && br > r) bestDist = min(bestDist, br - r);\n } else if (dir == 2) { // L\n if (br == r && bc < c) bestDist = min(bestDist, c - bc);\n } else { // R\n if (br == r && bc > c) bestDist = min(bestDist, bc - c);\n }\n }\n\n if (bestDist != INT_MAX) {\n // stop right before the block\n int nr = r + dr[dir] * (bestDist - 1);\n int nc = c + dc[dir] * (bestDist - 1);\n return pid(nr, nc);\n } else {\n // stop at boundary edge cell\n if (dir == 0) return pid(0, c);\n if (dir == 1) return pid(N - 1, c);\n if (dir == 2) return pid(r, 0);\n return pid(r, N - 1);\n }\n }\n\n // BFS shortest path from start to target, with mask starting at 0 and ending at 0\n vector> plan(const Pos& start, const Pos& target) {\n build_candidates(start, target);\n const int MASKS = 1 << C;\n const int STATES = (N*N) * MASKS;\n\n vector dist(STATES, -1);\n vector prv(STATES);\n\n auto sid = [&](int pos, int mask) {\n return pos * MASKS + mask;\n };\n\n int sPos = pid(start.r, start.c);\n int tPos = pid(target.r, target.c);\n int sState = sid(sPos, 0);\n int gState = sid(tPos, 0);\n\n deque q;\n dist[sState] = 0;\n q.push_back(sState);\n\n while (!q.empty()) {\n int cur = q.front(); q.pop_front();\n if (cur == gState) break;\n\n int pos = cur / MASKS;\n int mask = cur % MASKS;\n int r = pos / N;\n int c = pos % N;\n\n for (int d = 0; d < 4; d++) {\n // Move\n {\n int nr = r + dr[d], nc = c + dc[d];\n if (inside(nr,nc) && !is_blocked_cell(nr,nc,mask)) {\n int np = pid(nr,nc);\n int ns = sid(np, mask);\n if (dist[ns] == -1) {\n dist[ns] = dist[cur] + 1;\n prv[ns] = {cur, 'M', dch[d]};\n q.push_back(ns);\n }\n }\n }\n // Slide\n {\n int np = slide_endpoint(r,c,d,mask);\n int ns = sid(np, mask);\n if (dist[ns] == -1) {\n dist[ns] = dist[cur] + 1;\n prv[ns] = {cur, 'S', dch[d]};\n q.push_back(ns);\n }\n }\n // Alter (only if adjacent cell is in candidate set)\n {\n int ar = r + dr[d], ac = c + dc[d];\n if (inside(ar,ac)) {\n int idx = cand_id[pid(ar,ac)];\n if (idx != -1) {\n int nmask = mask ^ (1 << idx);\n int ns = sid(pos, nmask);\n if (dist[ns] == -1) {\n dist[ns] = dist[cur] + 1;\n prv[ns] = {cur, 'A', dch[d]};\n q.push_back(ns);\n }\n }\n }\n }\n }\n }\n\n if (dist[gState] == -1) {\n // Should not happen, but fallback: Manhattan moves (board is empty).\n vector> res;\n int r = start.r, c = start.c;\n while (r < target.r) { res.push_back({'M','D'}); r++; }\n while (r > target.r) { res.push_back({'M','U'}); r--; }\n while (c < target.c) { res.push_back({'M','R'}); c++; }\n while (c > target.c) { res.push_back({'M','L'}); c--; }\n return res;\n }\n\n // Reconstruct\n vector> rev;\n int cur = gState;\n while (cur != sState) {\n Prev p = prv[cur];\n rev.push_back({p.act, p.dir});\n cur = p.pstate;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n }\n\n // For debug/safety: simulate within the same per-leg candidate/mask model\n void simulate_leg(Pos &cur, const Pos& target, const vector>& acts) {\n // candidates already built by plan() before calling this, but to be safe rebuild:\n build_candidates(cur, target);\n int mask = 0;\n\n auto dirIndex = [&](char d)->int{\n if (d=='U') return 0;\n if (d=='D') return 1;\n if (d=='L') return 2;\n return 3;\n };\n\n for (auto [a,d] : acts) {\n int di = dirIndex(d);\n if (a=='M') {\n int nr = cur.r + dr[di], nc = cur.c + dc[di];\n if (!inside(nr,nc) || is_blocked_cell(nr,nc,mask)) {\n // illegal; ignore in release builds\n // but we keep it strict:\n cerr << \"Illegal move\\n\";\n exit(0);\n }\n cur = {nr,nc};\n } else if (a=='S') {\n int np = slide_endpoint(cur.r, cur.c, di, mask);\n cur = {np / N, np % N};\n } else if (a=='A') {\n int ar = cur.r + dr[di], ac = cur.c + dc[di];\n if (!inside(ar,ac)) { cerr << \"Illegal alter\\n\"; exit(0); }\n int idx = cand_id[pid(ar,ac)];\n if (idx == -1) { cerr << \"Alter outside candidates (shouldn't happen)\\n\"; exit(0); }\n mask ^= (1<> n >> M;\n vector pts(M);\n for (int i = 0; i < M; i++) cin >> pts[i].r >> pts[i].c;\n\n Pos cur = pts[0];\n vector> answer;\n answer.reserve(1600);\n\n Planner planner;\n\n for (int k = 1; k < M; k++) {\n Pos tgt = pts[k];\n auto acts = planner.plan(cur, tgt);\n\n // Safety simulate (cheap) and advance cur\n planner.simulate_leg(cur, tgt, acts);\n\n for (auto &p : acts) answer.push_back(p);\n }\n\n // Output\n for (auto [a,d] : answer) {\n cout << a << ' ' << d << \"\\n\";\n }\n return 0;\n}"},"2":{"ahc001":"#include \nusing namespace std;\n\nstatic constexpr int W = 10000;\nstatic constexpr int H = 10000;\n\nstruct Rect {\n int lx, ly, rx, ry; // [lx,rx) x [ly,ry)\n};\n\nstatic inline long long areaLL(const Rect& r) {\n return 1LL * (r.rx - r.lx) * (r.ry - r.ly);\n}\n\nstatic inline bool overlapPosArea(const Rect& a, const Rect& b) {\n int x0 = max(a.lx, b.lx);\n int x1 = min(a.rx, b.rx);\n if (x0 >= x1) return false;\n int y0 = max(a.ly, b.ly);\n int y1 = min(a.ry, b.ry);\n return (y0 < y1);\n}\n\n// splitmix64 RNG\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t nextU64() {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n }\n uint32_t nextU32() { return (uint32_t)nextU64(); }\n int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline double sat(long long r, long long s) {\n long long mn = min(r, s);\n long long mx = max(r, s);\n double a = (double)mn / (double)mx;\n double t = 1.0 - a;\n return 1.0 - t * t;\n}\n\nstruct Solver {\n int n;\n vector x, y;\n vector r;\n vector rects;\n vector p;\n RNG rng;\n\n Solver(): rng(123456789) {}\n\n bool containsPoint(int i, const Rect& rc) const {\n // must contain (x[i]+0.5, y[i]+0.5) <=> cell [x,x+1) x [y,y+1) included\n return (rc.lx <= x[i] && rc.rx >= x[i] + 1 && rc.ly <= y[i] && rc.ry >= y[i] + 1);\n }\n\n bool inBounds(const Rect& rc) const {\n return (0 <= rc.lx && rc.lx < rc.rx && rc.rx <= W &&\n 0 <= rc.ly && rc.ly < rc.ry && rc.ry <= H);\n }\n\n bool validNoOverlap(int i, const Rect& rc) const {\n if (!inBounds(rc)) return false;\n if (!containsPoint(i, rc)) return false;\n for (int j = 0; j < n; j++) if (j != i) {\n if (overlapPosArea(rc, rects[j])) return false;\n }\n return true;\n }\n\n // Directional expansion limits (given current rects, no overlap assumed).\n // Return coordinate limit (exclusive side position) you can expand to without overlap.\n int limitRight(int i) const {\n const Rect& a = rects[i];\n int lim = W;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n // y-overlap?\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.lx >= a.rx) lim = min(lim, b.lx);\n }\n }\n return lim;\n }\n int limitLeft(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.rx <= a.lx) lim = max(lim, b.rx);\n }\n }\n return lim;\n }\n int limitUp(int i) const {\n const Rect& a = rects[i];\n int lim = H;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ly >= a.ry) lim = min(lim, b.ly);\n }\n }\n return lim;\n }\n int limitDown(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ry <= a.ly) lim = max(lim, b.ry);\n }\n }\n return lim;\n }\n\n void init() {\n rects.resize(n);\n p.assign(n, 0.0);\n for (int i = 0; i < n; i++) {\n rects[i] = Rect{x[i], y[i], x[i] + 1, y[i] + 1};\n p[i] = sat(r[i], 1);\n }\n }\n\n void greedyExpand(int rounds = 6) {\n vector ord(n);\n iota(ord.begin(), ord.end(), 0);\n\n for (int rep = 0; rep < rounds; rep++) {\n shuffle(ord.begin(), ord.end(), std::mt19937((unsigned)rng.nextU32()));\n for (int idx = 0; idx < n; idx++) {\n int i = ord[idx];\n for (;;) {\n long long s0 = areaLL(rects[i]);\n if (s0 >= r[i]) break;\n\n double bestGain = 1e-18;\n Rect bestR = rects[i];\n\n Rect cur = rects[i];\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n\n // try each direction: compute max limit; choose coordinate that targets area close to r\n // Right\n {\n int lim = limitRight(i);\n if (lim > cur.rx) {\n long long needW = (r[i] + h - 1) / h;\n int idealRx = cur.lx + (int)needW;\n int newRx = max(cur.rx, idealRx);\n newRx = min(newRx, lim);\n if (newRx != cur.rx) {\n Rect cand = cur;\n cand.rx = newRx;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain && validNoOverlap(i, cand)) {\n bestGain = g;\n bestR = cand;\n }\n }\n }\n }\n // Left\n {\n int lim = limitLeft(i);\n if (lim < cur.lx) {\n long long needW = (r[i] + h - 1) / h;\n int idealLx = cur.rx - (int)needW;\n int newLx = min(cur.lx, idealLx);\n newLx = max(newLx, lim);\n // must still contain point\n newLx = min(newLx, x[i]);\n if (newLx != cur.lx) {\n Rect cand = cur;\n cand.lx = newLx;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain && validNoOverlap(i, cand)) {\n bestGain = g;\n bestR = cand;\n }\n }\n }\n }\n // Up\n {\n int lim = limitUp(i);\n if (lim > cur.ry) {\n long long needH = (r[i] + w - 1) / w;\n int idealRy = cur.ly + (int)needH;\n int newRy = max(cur.ry, idealRy);\n newRy = min(newRy, lim);\n if (newRy != cur.ry) {\n Rect cand = cur;\n cand.ry = newRy;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain && validNoOverlap(i, cand)) {\n bestGain = g;\n bestR = cand;\n }\n }\n }\n }\n // Down\n {\n int lim = limitDown(i);\n if (lim < cur.ly) {\n long long needH = (r[i] + w - 1) / w;\n int idealLy = cur.ry - (int)needH;\n int newLy = min(cur.ly, idealLy);\n newLy = max(newLy, lim);\n newLy = min(newLy, y[i]);\n if (newLy != cur.ly) {\n Rect cand = cur;\n cand.ly = newLy;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain && validNoOverlap(i, cand)) {\n bestGain = g;\n bestR = cand;\n }\n }\n }\n }\n\n if (bestGain <= 1e-18) break;\n rects[i] = bestR;\n p[i] = sat(r[i], areaLL(rects[i]));\n }\n }\n }\n }\n\n // choose width closest to r/h (or height closest to r/w)\n int bestWidthForTarget(long long targetR, int h) const {\n double ideal = (double)targetR / (double)h;\n int w1 = max(1, (int)floor(ideal));\n int w2 = max(1, (int)ceil(ideal));\n long long a1 = 1LL * w1 * h;\n long long a2 = 1LL * w2 * h;\n if (llabs(a1 - targetR) <= llabs(a2 - targetR)) return w1;\n return w2;\n }\n int bestHeightForTarget(long long targetR, int w) const {\n double ideal = (double)targetR / (double)w;\n int h1 = max(1, (int)floor(ideal));\n int h2 = max(1, (int)ceil(ideal));\n long long a1 = 1LL * w * h1;\n long long a2 = 1LL * w * h2;\n if (llabs(a1 - targetR) <= llabs(a2 - targetR)) return h1;\n return h2;\n }\n\n void anneal(double timeLimitSec = 4.85) {\n using clk = std::chrono::high_resolution_clock;\n auto t0 = clk::now();\n\n const double T0 = 0.06;\n const double T1 = 0.0015;\n\n auto nowSec = [&]() -> double {\n return std::chrono::duration(clk::now() - t0).count();\n };\n\n int it = 0;\n while (true) {\n double t = nowSec();\n if (t >= timeLimitSec) break;\n double prog = t / timeLimitSec;\n double temp = T0 * pow(T1 / T0, prog);\n\n int i = (int)(rng.nextU32() % (uint32_t)n);\n Rect cur = rects[i];\n long long s0 = areaLL(cur);\n double p0 = p[i];\n\n double op = rng.nextDouble();\n Rect cand = cur;\n\n if (op < 0.72) {\n // Resize one side\n int side = (int)(rng.nextU32() % 4); // 0:L 1:R 2:D 3:U\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n bool wantExpand = (s0 < r[i]) ? (rng.nextDouble() < 0.85) : (rng.nextDouble() < 0.25);\n\n if (wantExpand) {\n // expanding only (shrinking never helps when below target)\n if (side == 0) { // left\n int lim = limitLeft(i);\n if (lim < cur.lx) {\n long long needW = (r[i] + h - 1) / h;\n int idealLx = cur.rx - (int)needW;\n int minLx = lim;\n int maxLx = cur.lx - 1;\n int newLx;\n if (rng.nextDouble() < 0.55) newLx = max(minLx, min(maxLx, idealLx));\n else newLx = rng.nextInt(minLx, maxLx);\n newLx = min(newLx, x[i]);\n cand.lx = newLx;\n } else continue;\n } else if (side == 1) { // right\n int lim = limitRight(i);\n if (lim > cur.rx) {\n long long needW = (r[i] + h - 1) / h;\n int idealRx = cur.lx + (int)needW;\n int minRx = cur.rx + 1;\n int maxRx = lim;\n int newRx;\n if (rng.nextDouble() < 0.55) newRx = max(minRx, min(maxRx, idealRx));\n else newRx = rng.nextInt(minRx, maxRx);\n cand.rx = newRx;\n } else continue;\n } else if (side == 2) { // down\n int lim = limitDown(i);\n if (lim < cur.ly) {\n long long needH = (r[i] + w - 1) / w;\n int idealLy = cur.ry - (int)needH;\n int minLy = lim;\n int maxLy = cur.ly - 1;\n int newLy;\n if (rng.nextDouble() < 0.55) newLy = max(minLy, min(maxLy, idealLy));\n else newLy = rng.nextInt(minLy, maxLy);\n newLy = min(newLy, y[i]);\n cand.ly = newLy;\n } else continue;\n } else { // up\n int lim = limitUp(i);\n if (lim > cur.ry) {\n long long needH = (r[i] + w - 1) / w;\n int idealRy = cur.ly + (int)needH;\n int minRy = cur.ry + 1;\n int maxRy = lim;\n int newRy;\n if (rng.nextDouble() < 0.55) newRy = max(minRy, min(maxRy, idealRy));\n else newRy = rng.nextInt(minRy, maxRy);\n cand.ry = newRy;\n } else continue;\n }\n } else {\n // Shrink towards target (or random shrink). Shrinking is always overlap-safe.\n if (side == 0) { // move left border right\n int minLx = cur.lx;\n int maxLx = x[i]; // must keep lx<=x\n if (maxLx <= minLx) continue;\n int desiredW = bestWidthForTarget(r[i], h);\n int idealLx = cur.rx - desiredW;\n idealLx = min(idealLx, x[i]);\n idealLx = max(idealLx, cur.lx);\n int newLx;\n if (rng.nextDouble() < 0.65) newLx = idealLx;\n else newLx = rng.nextInt(minLx, maxLx);\n cand.lx = newLx;\n } else if (side == 1) { // move right border left\n int minRx = x[i] + 1;\n int maxRx = cur.rx;\n if (maxRx <= minRx) continue;\n int desiredW = bestWidthForTarget(r[i], h);\n int idealRx = cur.lx + desiredW;\n idealRx = max(idealRx, x[i] + 1);\n idealRx = min(idealRx, cur.rx);\n int newRx;\n if (rng.nextDouble() < 0.65) newRx = idealRx;\n else newRx = rng.nextInt(minRx, maxRx);\n cand.rx = newRx;\n } else if (side == 2) { // move bottom border up\n int minLy = cur.ly;\n int maxLy = y[i];\n if (maxLy <= minLy) continue;\n int desiredH = bestHeightForTarget(r[i], w);\n int idealLy = cur.ry - desiredH;\n idealLy = min(idealLy, y[i]);\n idealLy = max(idealLy, cur.ly);\n int newLy;\n if (rng.nextDouble() < 0.65) newLy = idealLy;\n else newLy = rng.nextInt(minLy, maxLy);\n cand.ly = newLy;\n } else { // move top border down\n int minRy = y[i] + 1;\n int maxRy = cur.ry;\n if (maxRy <= minRy) continue;\n int desiredH = bestHeightForTarget(r[i], w);\n int idealRy = cur.ly + desiredH;\n idealRy = max(idealRy, y[i] + 1);\n idealRy = min(idealRy, cur.ry);\n int newRy;\n if (rng.nextDouble() < 0.65) newRy = idealRy;\n else newRy = rng.nextInt(minRy, maxRy);\n cand.ry = newRy;\n }\n }\n } else {\n // Shift operation (keeps size)\n bool horizontal = (rng.nextDouble() < 0.5);\n if (horizontal) {\n int kmin = max(-cur.lx, (x[i] + 1) - cur.rx);\n int kmax = min(W - cur.rx, x[i] - cur.lx);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int k;\n if (kmin == kmax) {\n if (kmin == 0) continue;\n k = kmin;\n } else {\n // limit huge jumps a bit, but still allow\n int lim = 400;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n }\n cand.lx += k; cand.rx += k;\n } else {\n int kmin = max(-cur.ly, (y[i] + 1) - cur.ry);\n int kmax = min(H - cur.ry, y[i] - cur.ly);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int k;\n if (kmin == kmax) {\n if (kmin == 0) continue;\n k = kmin;\n } else {\n int lim = 400;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n }\n cand.ly += k; cand.ry += k;\n }\n }\n\n if (!validNoOverlap(i, cand)) continue;\n\n long long s1 = areaLL(cand);\n double p1 = sat(r[i], s1);\n double delta = p1 - p0;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp(delta / temp);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (accept) {\n rects[i] = cand;\n p[i] = p1;\n }\n\n ++it;\n }\n }\n\n void solve() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> n;\n x.resize(n); y.resize(n); r.resize(n);\n for (int i = 0; i < n; i++) {\n cin >> x[i] >> y[i] >> r[i];\n }\n\n init();\n greedyExpand(6);\n anneal(4.85);\n\n for (int i = 0; i < n; i++) {\n const Rect& rc = rects[i];\n cout << rc.lx << ' ' << rc.ly << ' ' << rc.rx << ' ' << rc.ry << \"\\n\";\n }\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nstatic const int N = 50;\nstatic const int V = N * N;\n\nstatic const int di[4] = {-1, 1, 0, 0};\nstatic const int dj[4] = {0, 0, -1, 1};\nstatic const char dc[4] = {'U','D','L','R'};\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n explicit XorShift(uint64_t seed = 0) { x ^= seed + 0x9e3779b97f4a7c15ULL; }\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Path {\n vector moves;\n long long score = 0;\n};\n\nint si, sj;\nint tgrid[N][N];\nint pgrid[N][N];\n\nint Mtiles = 0;\nint tileOf[V];\nint valOf[V];\n\nstruct Neis {\n int to[4];\n int deg = 0;\n};\nNeis nei[V];\n\ninline bool inside(int i, int j) { return (unsigned)i < N && (unsigned)j < N; }\ninline int id(int i, int j) { return i * N + j; }\n\n// Global used-tile stamping (fast reset without fill)\nvector usedStamp;\nint curStamp = 1;\n\ninline bool isUsedTile(int tile) {\n return usedStamp[tile] == curStamp;\n}\ninline void markTile(int tile) {\n usedStamp[tile] = curStamp;\n}\n\n// mobility after arriving at vertex v, with some extra tiles considered \"already used\"\ninline int mobility1(int v, int extra1 = -1) {\n int tv = tileOf[v];\n int cnt = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue; // cannot move within same tile\n if (tu == extra1) continue;\n if (isUsedTile(tu)) continue;\n cnt++;\n }\n return cnt;\n}\n\ninline int mobility2(int v, int extra1, int extra2) {\n int tv = tileOf[v];\n int cnt = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1 || tu == extra2) continue;\n if (isUsedTile(tu)) continue;\n cnt++;\n }\n return cnt;\n}\n\ninline int bestNextValue(int v, int extra1 = -1) {\n int tv = tileOf[v];\n int best = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1) continue;\n if (isUsedTile(tu)) continue;\n best = max(best, valOf[u]);\n }\n return best;\n}\n\n// Two-step lookahead: best (value2 + mob2 bonus) among second moves.\ninline int bestSecondStep(int v, int extraFirstTile) {\n int tv = tileOf[v];\n int best = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extraFirstTile) continue;\n if (isUsedTile(tu)) continue;\n\n // After taking u as second step, both extraFirstTile and tu are unavailable.\n int mob = mobility2(u, extraFirstTile, tu);\n int v2 = valOf[u] + 15 * mob;\n best = max(best, v2);\n }\n return best;\n}\n\ninline int dirFromTo(int a, int b) {\n int ai = a / N, aj = a % N;\n int bi = b / N, bj = b % N;\n if (bi == ai - 1 && bj == aj) return 0;\n if (bi == ai + 1 && bj == aj) return 1;\n if (bi == ai && bj == aj - 1) return 2;\n return 3;\n}\n\nPath buildFromPrefix(const vector& prefix, int cutLen, XorShift &rng, double eps) {\n // reset stamp\n curStamp++;\n if (curStamp == INT_MAX) { // extremely unlikely, but be safe\n fill(usedStamp.begin(), usedStamp.end(), 0);\n curStamp = 1;\n }\n\n int cur = id(si, sj);\n long long score = valOf[cur];\n markTile(tileOf[cur]);\n\n Path res;\n res.moves.reserve(2600);\n\n // replay prefix\n for (int k = 0; k < cutLen; k++) {\n char c = prefix[k];\n int d = (c=='U'?0:(c=='D'?1:(c=='L'?2:3)));\n int ni = (cur / N) + di[d];\n int nj = (cur % N) + dj[d];\n if (!inside(ni,nj)) break;\n int nxt = id(ni,nj);\n int ct = tileOf[cur], nt = tileOf[nxt];\n if (nt == ct) break;\n if (isUsedTile(nt)) break;\n markTile(nt);\n cur = nxt;\n score += valOf[cur];\n res.moves.push_back(c);\n }\n\n // weights (tuned for robustness)\n const int Wmob = 25;\n const double Wbest1 = 0.5;\n const double Wbest2 = 0.7;\n const int deadPenalty = 120;\n\n while (true) {\n // enumerate legal moves\n int cand[4];\n double H[4];\n int csz = 0;\n\n int ct = tileOf[cur];\n const auto &ng = nei[cur];\n for (int k = 0; k < ng.deg; k++) {\n int nxt = ng.to[k];\n int nt = tileOf[nxt];\n if (nt == ct) continue;\n if (isUsedTile(nt)) continue;\n\n // After moving to nxt, tile nt becomes used.\n int mob1 = mobility1(nxt, nt);\n int b1 = bestNextValue(nxt, nt);\n int b2 = bestSecondStep(nxt, nt);\n\n double h = (double)valOf[nxt]\n + (double)Wmob * (double)mob1\n + Wbest1 * (double)b1\n + Wbest2 * (double)b2;\n\n if (mob1 == 0) h -= deadPenalty;\n\n cand[csz] = nxt;\n H[csz] = h;\n csz++;\n }\n\n if (csz == 0) break;\n\n int pick = 0;\n if (rng.nextDouble() < eps) {\n pick = rng.nextInt(0, csz - 1);\n } else {\n for (int i = 1; i < csz; i++) if (H[i] > H[pick]) pick = i;\n }\n\n int nxt = cand[pick];\n int d = dirFromTo(cur, nxt);\n\n markTile(tileOf[nxt]);\n cur = nxt;\n score += valOf[cur];\n res.moves.push_back(dc[d]);\n\n if ((int)res.moves.size() >= 2600) break;\n }\n\n res.score = score;\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> si >> sj;\n int mxT = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n cin >> tgrid[i][j];\n mxT = max(mxT, tgrid[i][j]);\n }\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n cin >> pgrid[i][j];\n }\n Mtiles = mxT + 1;\n\n // Flatten & build adjacency\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v = id(i,j);\n tileOf[v] = tgrid[i][j];\n valOf[v] = pgrid[i][j];\n }\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v = id(i,j);\n nei[v].deg = 0;\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d], nj = j + dj[d];\n if (!inside(ni,nj)) continue;\n nei[v].to[nei[v].deg++] = id(ni,nj);\n }\n }\n\n usedStamp.assign(Mtiles, 0);\n\n XorShift rng(1234567);\n\n auto start = chrono::high_resolution_clock::now();\n const double TL = 1.95;\n\n Path best;\n best.score = -1;\n\n // Multi-start: more greedy than before, but still exploring\n for (int it = 0; it < 300; it++) {\n double eps = 0.25; // explore a bit\n auto cand = buildFromPrefix({}, 0, rng, eps);\n if (cand.score > best.score) best = std::move(cand);\n\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > TL * 0.35) break; // don't overdo initial phase\n }\n\n // Local search: cut & regrow (biased to tail) + multiple trials per cut\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > TL) break;\n double progress = min(1.0, elapsed / TL);\n\n int L = (int)best.moves.size();\n int cutLen = 0;\n if (L > 0) {\n if (rng.nextDouble() < 0.7) {\n int lo = max(0, L - 200);\n cutLen = rng.nextInt(lo, L);\n } else {\n cutLen = rng.nextInt(0, L);\n }\n }\n\n // exploration decreases over time\n double eps = 0.22 * (1.0 - progress) + 0.03; // ~0.25 -> 0.03\n\n // try several regrowths from same cut, keep best\n Path bestCand;\n bestCand.score = -1;\n const int TRIES = 4;\n for (int k = 0; k < TRIES; k++) {\n auto cand = buildFromPrefix(best.moves, cutLen, rng, eps);\n if (cand.score > bestCand.score) bestCand = std::move(cand);\n }\n if (bestCand.score > best.score) best = std::move(bestCand);\n }\n\n string out;\n out.reserve(best.moves.size());\n for (char c : best.moves) out.push_back(c);\n cout << out << \"\\n\";\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nstatic constexpr int N = 30;\nstatic constexpr int V = N * N;\n\nstruct EdgeRef {\n bool horiz; // true: h[i][j] between (i,j)-(i,j+1), false: v[i][j] between (i,j)-(i+1,j)\n int i, j;\n};\n\nstatic inline int vid(int i, int j) { return i * N + j; }\nstatic inline pair vpos(int id){ return {id / N, id % N}; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Estimated weights\n static double h[N][N-1];\n static double v[N-1][N];\n static int hc[N][N-1];\n static int vc[N-1][N];\n\n for(int i=0;i unif01(0.0, 1.0);\n\n auto clamp_w = [](double x)->double{\n if (x < 100.0) return 100.0;\n if (x > 10000.0) return 10000.0;\n return x;\n };\n\n auto get_base_w = [&](int i1,int j1,int i2,int j2)->double{\n if (i1 == i2) {\n int i = i1;\n int j = min(j1, j2);\n return h[i][j];\n } else {\n int i = min(i1, i2);\n int j = j1;\n return v[i][j];\n }\n };\n\n auto add_smoothing = [&](double beta){\n // Horizontal smoothing per row\n for(int i=0;i> si >> sj >> ti >> tj)) return 0;\n int s = vid(si, sj), t = vid(ti, tj);\n\n // Exploration schedule (early queries explore more)\n // eps: max relative perturbation amplitude\n double eps = 0.0;\n if (k < 250) {\n double x = 1.0 - (double)k / 250.0; // from 1 -> 0\n eps = 0.30 * x; // up to 30% perturbation early\n }\n\n // Dijkstra\n static double dist[V];\n static int prevv[V];\n static char prevMove[V];\n\n const double INF = 1e100;\n for(int i=0;i;\n priority_queue, greater

> pq;\n dist[s] = 0;\n pq.push({0.0, s});\n\n auto relax = [&](int from, int to, char mv, double w){\n double nd = dist[from] + w;\n if (nd < dist[to]) {\n dist[to] = nd;\n prevv[to] = from;\n prevMove[to] = mv;\n pq.push({nd, to});\n }\n };\n\n while(!pq.empty()){\n auto [d,u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n if (u == t) break;\n auto [i,j] = vpos(u);\n\n // neighbor cost = base_w * (1 + noise) for exploration\n auto perturbed = [&](double base)->double{\n if (eps <= 0.0) return base;\n double r = (unif01(rng) * 2.0 - 1.0) * eps; // [-eps, eps]\n double w = base * (1.0 + r);\n if (w < 1.0) w = 1.0;\n return w;\n };\n\n if (i > 0) {\n double base = v[i-1][j];\n relax(u, vid(i-1,j), 'U', perturbed(base));\n }\n if (i+1 < N) {\n double base = v[i][j];\n relax(u, vid(i+1,j), 'D', perturbed(base));\n }\n if (j > 0) {\n double base = h[i][j-1];\n relax(u, vid(i,j-1), 'L', perturbed(base));\n }\n if (j+1 < N) {\n double base = h[i][j];\n relax(u, vid(i,j+1), 'R', perturbed(base));\n }\n }\n\n // Reconstruct path (also collect edges)\n string path;\n vector used_edges;\n if (prevv[t] == -1 && s != t) {\n // Should never happen on a connected grid; fallback to Manhattan.\n int ci=si, cj=sj;\n while (ci < ti) { path.push_back('D'); ci++; }\n while (ci > ti) { path.push_back('U'); ci--; }\n while (cj < tj) { path.push_back('R'); cj++; }\n while (cj > tj) { path.push_back('L'); cj--; }\n // Build used_edges from this path\n ci=si; cj=sj;\n for(char c: path){\n int ni=ci, nj=cj;\n if (c=='U') ni--;\n if (c=='D') ni++;\n if (c=='L') nj--;\n if (c=='R') nj++;\n if (ci == ni) {\n used_edges.push_back({true, ci, min(cj,nj)});\n } else {\n used_edges.push_back({false, min(ci,ni), cj});\n }\n ci=ni; cj=nj;\n }\n } else {\n // Walk back from t to s\n int cur = t;\n vector rev;\n vector> nodes_rev;\n nodes_rev.push_back(vpos(cur));\n while(cur != s){\n char mv = prevMove[cur];\n rev.push_back(mv);\n cur = prevv[cur];\n nodes_rev.push_back(vpos(cur));\n }\n reverse(rev.begin(), rev.end());\n path.assign(rev.begin(), rev.end());\n\n // nodes_rev is reversed along backtracking; rebuild forward nodes to extract edges\n // nodes_rev currently: [t, ..., s]; reverse:\n reverse(nodes_rev.begin(), nodes_rev.end()); // [s, ..., t]\n for (int idx = 0; idx+1 < (int)nodes_rev.size(); idx++){\n auto [i1,j1] = nodes_rev[idx];\n auto [i2,j2] = nodes_rev[idx+1];\n if (i1 == i2) used_edges.push_back({true, i1, min(j1,j2)});\n else used_edges.push_back({false, min(i1,i2), j1});\n }\n }\n\n cout << path << \"\\n\" << flush;\n\n long long obs;\n cin >> obs;\n\n // Update model\n double pred = 0.0;\n for (auto &e: used_edges){\n pred += e.horiz ? h[e.i][e.j] : v[e.i][e.j];\n }\n if (pred < 1.0) pred = 1.0;\n\n double r = (double)obs / pred;\n // cap extreme ratios (stability)\n r = max(0.2, min(5.0, r));\n double logr = log(r);\n\n // Multiplicative per-edge update with decaying learning rate\n const double base_lr = 0.45; // overall aggressiveness\n for (auto &e: used_edges){\n int cnt;\n double *wptr;\n if (e.horiz) { cnt = ++hc[e.i][e.j]; wptr = &h[e.i][e.j]; }\n else { cnt = ++vc[e.i][e.j]; wptr = &v[e.i][e.j]; }\n\n double lr = base_lr / sqrt((double)cnt + 2.0); // decays\n // w *= exp(lr * log(r))\n double nw = (*wptr) * exp(lr * logr);\n *wptr = clamp_w(nw);\n }\n\n // Periodic smoothing to exploit row/column base structure\n if ((k+1) % 25 == 0) {\n double beta = 0.10;\n if (k >= 300) beta = 0.06;\n if (k >= 700) beta = 0.04;\n add_smoothing(beta);\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20;\nstatic const int LMIN = 2;\nstatic const int LMAX = 12;\nstatic const int ALPHA = 9; // A-H + '.'\n\nstruct XorShift64 {\n uint64_t x;\n explicit XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n inline uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n inline double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline uint8_t ch2code(char ch) {\n if (ch == '.') return 8;\n return (uint8_t)(ch - 'A');\n}\nstatic inline char code2ch(uint8_t c) {\n if (c == 8) return '.';\n return (char)('A' + c);\n}\n\nstruct LineHash {\n array dig{};\n array pref{};\n const array* pow9 = nullptr;\n\n void rebuild_pref() {\n pref[0] = 0;\n for (int i = 0; i < 2*N; i++) {\n pref[i+1] = pref[i] * (uint64_t)ALPHA + (uint64_t)dig[i];\n }\n }\n inline uint64_t substr_val(int start, int len) const {\n // modulo 2^64 arithmetic; for len<=12 values are <2^64 so they match exact encoding\n uint64_t a = pref[start + len];\n uint64_t b = pref[start] * (*pow9)[len];\n return a - b;\n }\n};\n\nstruct Delta {\n int dBase = 0;\n int dLen = 0;\n int dBonus = 0;\n};\n\nstruct Solver {\n int M;\n vector inputS;\n\n // unique strings\n int U;\n vector weight; // multiplicity in input\n vector slen; // length\n vector> sdig; // digits A..H\n unordered_map key2id;\n\n // pow9\n array pow9{};\n\n // grid and hashes\n array, N> grid{};\n array rows, cols;\n\n // affected list per position\n vector>> affected;\n\n // occ & scores\n vector occ;\n long long baseSat = 0; // sum weight*(occ>0) (==M when all satisfied)\n long long lenSat = 0; // sum len*(occ>0)\n long long occBonus = 0; // sum min(occ,2)\n\n XorShift64 rng;\n\n Solver(int M_, vector s_)\n : M(M_), inputS(std::move(s_)),\n rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count())\n {\n // pow9\n pow9[0] = 1;\n for (int i = 1; i <= LMAX; i++) pow9[i] = pow9[i-1] * (uint64_t)ALPHA;\n\n // compress unique strings\n auto encode_key_exact = [&](const string& t) -> uint64_t {\n uint64_t v = 0;\n for (char ch : t) v = v * (uint64_t)ALPHA + (uint64_t)ch2code(ch); // A..H only\n return v * 16ull + (uint64_t)t.size();\n };\n\n key2id.reserve((size_t)M * 2);\n for (auto &lh : rows) lh.pow9 = &pow9;\n for (auto &lh : cols) lh.pow9 = &pow9;\n\n weight.clear(); slen.clear(); sdig.clear();\n\n for (int i = 0; i < M; i++) {\n uint64_t key = encode_key_exact(inputS[i]);\n auto it = key2id.find(key);\n if (it == key2id.end()) {\n int id = (int)weight.size();\n key2id.emplace(key, id);\n weight.push_back(1);\n slen.push_back((int)inputS[i].size());\n vector d;\n d.reserve(inputS[i].size());\n for (char ch : inputS[i]) d.push_back(ch2code(ch));\n sdig.push_back(std::move(d));\n } else {\n weight[it->second]++;\n }\n }\n U = (int)weight.size();\n\n occ.assign(U, 0);\n\n // affected starts for each position in a cyclic line\n affected.assign(N, {});\n for (int pos = 0; pos < N; pos++) {\n vector> v;\n v.reserve(77);\n for (int len = LMIN; len <= LMAX; len++) {\n for (int t = 0; t < len; t++) {\n int start = pos - t;\n start %= N;\n if (start < 0) start += N;\n v.emplace_back(start, len);\n }\n }\n affected[pos] = move(v);\n }\n }\n\n inline void rebuild_all_lines_from_grid() {\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n rows[r].dig[c] = grid[r][c];\n rows[r].dig[c+N] = grid[r][c];\n }\n rows[r].rebuild_pref();\n }\n for (int c = 0; c < N; c++) {\n for (int r = 0; r < N; r++) {\n cols[c].dig[r] = grid[r][c];\n cols[c].dig[r+N] = grid[r][c];\n }\n cols[c].rebuild_pref();\n }\n }\n\n inline uint64_t make_key(uint64_t v, int len) const {\n return v * 16ull + (uint64_t)len;\n }\n\n inline int bonus_of(int x) const { return x >= 2 ? 2 : x; }\n\n inline void adjust_occ(int id, int delta, Delta &D) {\n int before = occ[id];\n int after = before + delta;\n occ[id] = after;\n\n // baseSat and lenSat depend on (occ>0)\n if (before == 0 && after > 0) {\n baseSat += weight[id];\n lenSat += slen[id];\n D.dBase += weight[id];\n D.dLen += slen[id];\n } else if (before > 0 && after == 0) {\n baseSat -= weight[id];\n lenSat -= slen[id];\n D.dBase -= weight[id];\n D.dLen -= slen[id];\n }\n\n // occBonus uses min(occ,2)\n int b0 = bonus_of(before);\n int b1 = bonus_of(after);\n occBonus += (b1 - b0);\n D.dBonus += (b1 - b0);\n }\n\n inline void update_key_change(uint64_t oldKey, uint64_t newKey, Delta &D) {\n if (oldKey == newKey) return;\n auto itOld = key2id.find(oldKey);\n if (itOld != key2id.end()) adjust_occ(itOld->second, -1, D);\n auto itNew = key2id.find(newKey);\n if (itNew != key2id.end()) adjust_occ(itNew->second, +1, D);\n }\n\n void recount_occ_slow() {\n fill(occ.begin(), occ.end(), 0);\n baseSat = lenSat = occBonus = 0;\n\n auto add_key = [&](uint64_t key) {\n auto it = key2id.find(key);\n if (it == key2id.end()) return;\n int id = it->second;\n if (occ[id] == 0) {\n baseSat += weight[id];\n lenSat += slen[id];\n }\n occ[id]++;\n };\n\n for (int r = 0; r < N; r++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = rows[r].substr_val(start, len);\n add_key(make_key(v, len));\n }\n }\n }\n for (int c = 0; c < N; c++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = cols[c].substr_val(start, len);\n add_key(make_key(v, len));\n }\n }\n }\n for (int id = 0; id < U; id++) occBonus += bonus_of(occ[id]);\n }\n\n // apply single cell change, returns delta components (already applied)\n Delta doChange(int r, int c, uint8_t newv) {\n uint8_t oldv = grid[r][c];\n if (oldv == newv) return {};\n\n Delta D;\n\n // row r affected at position c\n const auto &affRow = affected[c];\n array oldKeysRow;\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first;\n int len = affRow[i].second;\n oldKeysRow[i] = make_key(rows[r].substr_val(start, len), len);\n }\n\n rows[r].dig[c] = newv;\n rows[r].dig[c+N] = newv;\n rows[r].rebuild_pref();\n\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first;\n int len = affRow[i].second;\n uint64_t newKey = make_key(rows[r].substr_val(start, len), len);\n update_key_change(oldKeysRow[i], newKey, D);\n }\n\n // col c affected at position r\n const auto &affCol = affected[r];\n array oldKeysCol;\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first;\n int len = affCol[i].second;\n oldKeysCol[i] = make_key(cols[c].substr_val(start, len), len);\n }\n\n cols[c].dig[r] = newv;\n cols[c].dig[r+N] = newv;\n cols[c].rebuild_pref();\n\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first;\n int len = affCol[i].second;\n uint64_t newKey = make_key(cols[c].substr_val(start, len), len);\n update_key_change(oldKeysCol[i], newKey, D);\n }\n\n grid[r][c] = newv;\n return D;\n }\n\n inline double evalDeltaF(const Delta &D, double lambda, double beta) const {\n return (double)D.dBase + lambda * (double)D.dLen + beta * (double)D.dBonus;\n }\n\n // pick a likely unsatisfied id by random probing\n int pick_unsatisfied_id() {\n for (int t = 0; t < 40; t++) {\n int id = rng.next_int(U);\n if (occ[id] == 0) return id;\n }\n // fallback: linear scan (rare)\n for (int id = 0; id < U; id++) if (occ[id] == 0) return id;\n return -1;\n }\n\n // compound move helpers\n struct ChangeRec { int r, c; uint8_t oldv; };\n\n // embed a string along a row or col at random start; returns accumulated Delta and records old values for revert\n pair> apply_embed_move(int id, int orient, int idx, int start) {\n // orient 0: row idx, columns advance\n // orient 1: col idx, rows advance\n Delta total;\n vector rec;\n rec.reserve(slen[id]);\n\n for (int t = 0; t < slen[id]; t++) {\n int r = (orient == 0) ? idx : (start + t) % N;\n int c = (orient == 0) ? (start + t) % N : idx;\n uint8_t nv = sdig[id][t];\n uint8_t ov = grid[r][c];\n if (ov == nv) continue;\n rec.push_back({r, c, ov});\n Delta d = doChange(r, c, nv);\n total.dBase += d.dBase;\n total.dLen += d.dLen;\n total.dBonus+= d.dBonus;\n }\n return {total, rec};\n }\n\n void revert_changes(const vector &rec) {\n for (int i = (int)rec.size() - 1; i >= 0; i--) {\n doChange(rec[i].r, rec[i].c, rec[i].oldv);\n }\n }\n\n // cyclic shift a full row/col; returns accumulated Delta and records old values for revert\n pair> apply_shift_move(int orient, int idx, int k) {\n // orient 0: row, 1: col\n array newvals;\n if (orient == 0) {\n for (int c = 0; c < N; c++) newvals[(c + k) % N] = grid[idx][c];\n } else {\n for (int r = 0; r < N; r++) newvals[(r + k) % N] = grid[r][idx];\n }\n\n Delta total;\n vector rec;\n rec.reserve(N);\n\n for (int t = 0; t < N; t++) {\n int r = (orient == 0) ? idx : t;\n int c = (orient == 0) ? t : idx;\n uint8_t nv = newvals[t];\n uint8_t ov = grid[r][c];\n if (ov == nv) continue;\n rec.push_back({r, c, ov});\n Delta d = doChange(r, c, nv);\n total.dBase += d.dBase;\n total.dLen += d.dLen;\n total.dBonus+= d.dBonus;\n }\n return {total, rec};\n }\n\n array, N> run_sa(double duration_sec, long long &outBestBase) {\n // random init (A-H)\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) grid[r][c] = (uint8_t)rng.next_int(8);\n\n rebuild_all_lines_from_grid();\n recount_occ_slow();\n\n auto bestGrid = grid;\n long long bestBase = baseSat;\n long long bestLen = lenSat;\n long long bestBonus= occBonus;\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n };\n\n const double Tstart = 6.0;\n const double Tend = 0.15;\n const double lambda0 = 0.25; // early emphasis on longer strings\n const double beta = 0.02; // tiny smoothing\n\n while (true) {\n double e = elapsed();\n if (e >= duration_sec) break;\n double p = e / duration_sec;\n\n double T = Tstart * pow(Tend / Tstart, p);\n double lambda = lambda0 * (1.0 - p);\n\n double rmove = rng.next_double();\n\n // 1) row/col shift move (rare but powerful)\n if (rmove < 0.03) {\n int orient = rng.next_int(2);\n int idx = rng.next_int(N);\n int k = 1 + rng.next_int(N - 1);\n\n auto [D, rec] = apply_shift_move(orient, idx, k);\n double dF = evalDeltaF(D, lambda, beta);\n\n bool accept = false;\n if (dF >= 0) accept = true;\n else if (rng.next_double() < exp(dF / T)) accept = true;\n\n if (!accept) revert_changes(rec);\n }\n // 2) embed unsatisfied string move\n else if (rmove < 0.18) {\n int id = pick_unsatisfied_id();\n if (id == -1) continue; // all satisfied\n int orient = rng.next_int(2);\n int idx = rng.next_int(N);\n int start = rng.next_int(N);\n\n auto [D, rec] = apply_embed_move(id, orient, idx, start);\n double dF = evalDeltaF(D, lambda, beta);\n\n bool accept = false;\n if (dF >= 0) accept = true;\n else if (rng.next_double() < exp(dF / T)) accept = true;\n\n if (!accept) revert_changes(rec);\n }\n // 3) single-cell move\n else {\n int r = rng.next_int(N);\n int c = rng.next_int(N);\n uint8_t oldv = grid[r][c];\n uint8_t newv = (uint8_t)rng.next_int(8);\n if (newv == oldv) continue;\n\n Delta D = doChange(r, c, newv);\n double dF = evalDeltaF(D, lambda, beta);\n\n bool accept = false;\n if (dF >= 0) accept = true;\n else if (rng.next_double() < exp(dF / T)) accept = true;\n\n if (!accept) {\n doChange(r, c, oldv);\n }\n }\n\n // update best (primary: baseSat, secondary: lenSat+occBonus)\n if (baseSat > bestBase ||\n (baseSat == bestBase && (lenSat > bestLen ||\n (lenSat == bestLen && occBonus > bestBonus)))) {\n bestBase = baseSat;\n bestLen = lenSat;\n bestBonus = occBonus;\n bestGrid = grid;\n }\n }\n\n outBestBase = bestBase;\n return bestGrid;\n }\n\n void dot_removal(double time_limit_sec, chrono::high_resolution_clock::time_point globalStart) {\n auto elapsed_global = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - globalStart).count();\n };\n\n if (baseSat != M) return;\n\n vector cells(N*N);\n iota(cells.begin(), cells.end(), 0);\n int rounds = 10;\n\n for (int rd = 0; rd < rounds; rd++) {\n if (elapsed_global() >= time_limit_sec) break;\n for (int i = (int)cells.size() - 1; i > 0; i--) {\n int j = rng.next_int(i + 1);\n swap(cells[i], cells[j]);\n }\n for (int idx : cells) {\n if (elapsed_global() >= time_limit_sec) break;\n int r = idx / N, c = idx % N;\n uint8_t oldv = grid[r][c];\n if (oldv == 8) continue;\n doChange(r, c, 8);\n if (baseSat != M) doChange(r, c, oldv);\n }\n }\n }\n\n array, N> solve() {\n auto globalStart = chrono::high_resolution_clock::now();\n const double TL = 2.95;\n\n // SA time budget and restarts\n const double SA_TIME = 2.55;\n const int RESTARTS = 3;\n const double per = SA_TIME / RESTARTS;\n\n array, N> bestGrid{};\n long long bestBase = -1;\n\n for (int t = 0; t < RESTARTS; t++) {\n long long localBestBase = 0;\n auto g = run_sa(per, localBestBase);\n if (localBestBase > bestBase) {\n bestBase = localBestBase;\n bestGrid = g;\n if (bestBase == M) break;\n }\n // small time check\n double eg = chrono::duration(chrono::high_resolution_clock::now() - globalStart).count();\n if (eg >= TL - 0.25) break;\n }\n\n // restore best\n grid = bestGrid;\n rebuild_all_lines_from_grid();\n recount_occ_slow();\n\n // dot removal if fully satisfied\n dot_removal(TL, globalStart);\n\n return grid;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, M;\n cin >> Nin >> M;\n vector s(M);\n for (int i = 0; i < M; i++) cin >> s[i];\n\n Solver solver(M, s);\n auto ans = solver.solve();\n\n for (int r = 0; r < N; r++) {\n string line;\n line.reserve(N);\n for (int c = 0; c < N; c++) line.push_back(code2ch(ans[r][c]));\n cout << line << \"\\n\";\n }\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstatic const long long INFLL = (1LL<<60);\n\nstruct HopcroftKarp {\n int nL, nR;\n vector> adj;\n vector dist;\n vector pairU, pairV;\n\n HopcroftKarp(int nL=0, int nR=0) { init(nL, nR); }\n void init(int _nL, int _nR) {\n nL=_nL; nR=_nR;\n adj.assign(nL, {});\n dist.assign(nL, 0);\n pairU.assign(nL, -1);\n pairV.assign(nR, -1);\n }\n void add_edge(int u, int v){ adj[u].push_back(v); }\n\n bool bfs() {\n queue q;\n for(int u=0; u, vector> min_vertex_cover() {\n // BFS from unmatched left along alternating paths:\n vector visL(nL,0), visR(nR,0);\n queue q;\n for(int u=0; uR\n if(pairU[u]==v) continue;\n if(!visR[v]){\n visR[v]=1;\n int u2=pairV[v];\n if(u2!=-1 && !visL[u2]){\n visL[u2]=1;\n q.push(u2);\n }\n }\n }\n }\n // min vertex cover = (Left not visited) union (Right visited)\n vector coverL(nL,0), coverR(nR,0);\n for(int u=0; u dist;\n vector prev;\n vector prevDir; // move from prev -> current\n};\n\nstruct Solver {\n int N, si, sj;\n vector g;\n int startId;\n vector cellCost; // cost to enter cell\n\n // segment ids per cell\n vector rowSeg, colSeg;\n int R=0, C=0;\n vector> rowCells, colCells;\n\n vector> adjV; // rowSeg -> list of colSeg\n vector> adjCell; // rowSeg -> corresponding cell id\n\n inline int id(int i,int j) const { return i*N+j; }\n inline int ri(int v) const { return v/N; }\n inline int rj(int v) const { return v%N; }\n inline bool isRoad(int v) const { return g[ri(v)][rj(v)]!='#'; }\n\n DijkstraResult dijkstra_full(int src) const {\n int V=N*N;\n DijkstraResult res;\n res.dist.assign(V, INFLL);\n res.prev.assign(V, -1);\n res.prevDir.assign(V, 0);\n\n priority_queue, vector>, greater>> pq;\n res.dist[src]=0;\n pq.push({0,src});\n\n static const int di[4] = {-1,1,0,0};\n static const int dj[4] = {0,0,-1,1};\n static const char mv[4] = {'U','D','L','R'};\n\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=res.dist[u]) continue;\n int ui=ri(u), uj=rj(u);\n for(int k=0;k<4;k++){\n int vi=ui+di[k], vj=uj+dj[k];\n if(vi<0||vi>=N||vj<0||vj>=N) continue;\n int v=id(vi,vj);\n if(!isRoad(v)) continue;\n long long nd=d + cellCost[v];\n if(nd < res.dist[v]){\n res.dist[v]=nd;\n res.prev[v]=u;\n res.prevDir[v]=mv[k];\n pq.push({nd,v});\n }\n }\n }\n return res;\n }\n\n string reconstruct_path_cells(int src, int dst, const vector& prev, const vector& prevDir) const {\n if(src==dst) return \"\";\n string rev;\n int cur=dst;\n while(cur!=src){\n int p=prev[cur];\n if(p==-1) return \"\"; // should not happen\n rev.push_back(prevDir[cur]);\n cur=p;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n }\n\n void build_segments() {\n int V=N*N;\n rowSeg.assign(V, -1);\n colSeg.assign(V, -1);\n\n R=0;\n for(int i=0;i choose_targets(const vector& distStart) {\n HopcroftKarp hk(R, C);\n hk.adj = adjV;\n hk.pairU.assign(R, -1);\n hk.pairV.assign(C, -1);\n hk.dist.assign(R, 0);\n hk.max_matching();\n auto [coverL, coverR] = hk.min_vertex_cover();\n\n // start already activates its row/col segment\n int sRow=rowSeg[startId], sCol=colSeg[startId];\n if(sRow>=0) coverL[sRow]=0;\n if(sCol>=0) coverR[sCol]=0;\n\n vector reqL, reqR;\n vector mapL(R, -1), mapR(C, -1);\n for(int u=0; u> edgeCell(nL); // aligned with hk2.adj[i]\n for(int i=0;i needL(R,0), needR(C,0);\n for(int u=0;u doneL(R,0), doneR(C,0);\n vector picked(N*N,0);\n vector targets;\n\n auto pick_cell = [&](int cell){\n if(cell<0) return;\n if(!picked[cell]){\n picked[cell]=1;\n targets.push_back(cell);\n }\n };\n\n // pick matched edges first (covers 2 required vertices)\n for(int i=0;iint{\n int best=-1;\n long long bestKey=INFLL;\n for(int cell: rowCells[u]){\n int v=colSeg[cell];\n long long key = distStart[cell] + cellCost[cell];\n if(needR[v] && !doneR[v]) key -= 1000000; // huge bonus if covers still-needed R\n if(key < bestKey){ bestKey=key; best=cell; }\n }\n return best;\n };\n auto best_cell_for_col = [&](int v)->int{\n int best=-1;\n long long bestKey=INFLL;\n for(int cell: colCells[v]){\n int u=rowSeg[cell];\n long long key = distStart[cell] + cellCost[cell];\n if(needL[u] && !doneL[u]) key -= 1000000; // huge bonus if covers still-needed L\n if(key < bestKey){ bestKey=key; best=cell; }\n }\n return best;\n };\n\n for(int u=0;u cntL(R,0), cntR(C,0);\n for(int cell: targets){\n int u=rowSeg[cell], v=colSeg[cell];\n if(needL[u]) cntL[u]++;\n if(needR[v]) cntR[v]++;\n }\n\n vector order=targets;\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n shuffle(order.begin(), order.end(), rng);\n\n vector removed(N*N,0);\n for(int cell: order){\n int u=rowSeg[cell], v=colSeg[cell];\n bool okU = (!needL[u]) || (cntL[u] >= 2);\n bool okV = (!needR[v]) || (cntR[v] >= 2);\n if(okU && okV){\n removed[cell]=1;\n if(needL[u]) cntL[u]--;\n if(needR[v]) cntR[v]--;\n }\n }\n vector pruned;\n pruned.reserve(targets.size());\n for(int cell: targets) if(!removed[cell]) pruned.push_back(cell);\n return pruned;\n }\n\n // Build distance matrix and also store prev pointers for each source node (cell id).\n void compute_dist_prev_for_nodes(const vector& nodes,\n vector>& distM,\n vector>& prevM,\n vector>& prevDirM) const {\n int M=(int)nodes.size();\n int V=N*N;\n distM.assign(M, vector(M, INT_MAX/4));\n prevM.assign(M, vector(V, -1));\n prevDirM.assign(M, vector(V, 0));\n\n for(int s=0;s=INFLL/2) ? (INT_MAX/4) : (int)d;\n }\n }\n }\n\n long long tour_cost(const vector& tour, const vector>& d) const {\n long long s=0;\n for(int i=0;i+1<(int)tour.size();i++) s += d[tour[i]][tour[i+1]];\n return s;\n }\n\n vector build_tour_cheapest_insertion(const vector>& d, int M, mt19937& rng) const {\n // tour is in node indices, must start/end at 0.\n // start with [0,0], insert nodes 1..M-1 at best position.\n vector tour = {0,0};\n vector nodes;\n nodes.reserve(M-1);\n for(int i=1;i improve_tour_local_search(vector tour, const vector>& d,\n double timeLimitSec) const {\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n auto t0=chrono::high_resolution_clock::now();\n auto elapsed=[&](){\n return chrono::duration(chrono::high_resolution_clock::now()-t0).count();\n };\n\n long long bestC = tour_cost(tour, d);\n vector bestTour = tour;\n\n int m=(int)tour.size(); // M+1\n uniform_int_distribution posDist(1, m-2);\n uniform_real_distribution ur(0.0, 1.0);\n\n // SA-like acceptance for uphill moves\n double T0=2500.0, T1=20.0;\n\n auto accept = [&](long long delta)->bool{\n if(delta <= 0) return true;\n double e = min(1.0, elapsed()/timeLimitSec);\n double T = T0*(1.0-e) + T1*e;\n double p = exp(-(double)delta / T);\n return ur(rng) < p;\n };\n\n auto apply_relocate = [&](int i, int j){ // move node at i to after j\n int x=tour[i];\n tour.erase(tour.begin()+i);\n if(j > i) j--;\n tour.insert(tour.begin()+j+1, x);\n };\n\n while(elapsed() < timeLimitSec){\n double e = elapsed()/timeLimitSec;\n int mode;\n // mix of operations\n if(e < 0.6) mode = (ur(rng) < 0.6 ? 0 : 1); // relocation / swap\n else mode = (ur(rng) < 0.45 ? 0 : (ur(rng) < 0.8 ? 1 : 2)); // add 2-opt sometimes\n\n if(mode==0){\n // relocation\n int i=posDist(rng), j=posDist(rng);\n if(i==j) continue;\n int x=tour[i];\n int a=tour[i-1], b=tour[i+1];\n\n long long delta=0;\n delta += (long long)d[a][b] - d[a][x] - d[x][b];\n\n if(j > i) j--;\n int c=tour[j], d2=tour[j+1];\n delta += (long long)d[c][x] + d[x][d2] - d[c][d2];\n\n if(!accept(delta)) continue;\n apply_relocate(i, j);\n } else if(mode==1){\n // swap two positions (not endpoints)\n int i=posDist(rng), j=posDist(rng);\n if(i==j) continue;\n if(i>j) swap(i,j);\n\n int xi=tour[i], xj=tour[j];\n int a=tour[i-1], bi=tour[i+1];\n int c=tour[j-1], dj=tour[j+1];\n\n long long before=0, after=0;\n\n if(i+1==j){\n // adjacent\n before = (long long)d[a][xi] + d[xi][xj] + d[xj][dj];\n after = (long long)d[a][xj] + d[xj][xi] + d[xi][dj];\n } else {\n before = (long long)d[a][xi] + d[xi][bi] + d[c][xj] + d[xj][dj];\n after = (long long)d[a][xj] + d[xj][bi] + d[c][xi] + d[xi][dj];\n }\n long long delta = after - before;\n if(!accept(delta)) continue;\n swap(tour[i], tour[j]);\n } else {\n // 2-opt reversal (works for ATSP as a valid move, but delta needs segment scan)\n int i=posDist(rng), j=posDist(rng);\n if(i==j) continue;\n if(i>j) swap(i,j);\n if(j-i < 2) continue;\n\n // compute delta by scanning internal edges\n long long oldSum=0, newSum=0;\n // edges entering/exiting the segment\n int a=tour[i-1], x=tour[i];\n int y=tour[j], b=tour[j+1];\n oldSum += (long long)d[a][x] + d[y][b];\n newSum += (long long)d[a][y] + d[x][b];\n\n // internal edges forward vs reversed\n for(int k=i; k> N >> si >> sj;\n g.resize(N);\n for(int i=0;i> g[i];\n\n startId=id(si,sj);\n cellCost.assign(N*N, 0);\n for(int i=0;i(chrono::high_resolution_clock::now()-globalStart).count();\n };\n\n // Dijkstra from start for better target selection\n auto startRes = dijkstra_full(startId);\n vector distStart = startRes.dist;\n\n // Choose and prune targets\n vector targets = choose_targets(distStart);\n\n // Build node list: start + unique targets (excluding start)\n vector nodes;\n nodes.reserve(1 + targets.size());\n nodes.push_back(startId);\n {\n vector used(N*N, 0);\n used[startId]=1;\n for(int c: targets){\n if(!used[c]){\n used[c]=1;\n nodes.push_back(c);\n }\n }\n }\n int M=(int)nodes.size();\n\n // Compute distance matrix + prev pointers (for later path reconstruction)\n vector> distM;\n vector> prevM;\n vector> prevDirM;\n compute_dist_prev_for_nodes(nodes, distM, prevM, prevDirM);\n\n // Multi-start: build a few insertion tours and take the best as starting point\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n vector bestTour;\n long long bestC = INFLL;\n int trials = (M <= 80 ? 6 : (M <= 140 ? 4 : 3));\n for(int t=0;t\nusing namespace std;\n\nstruct FastRand {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int mod) { return (int)(next_u64() % (uint64_t)mod); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n // Box-Muller for standard normal\n double next_normal() {\n double u1 = max(1e-12, next_double());\n double u2 = next_double();\n return sqrt(-2.0 * log(u1)) * cos(2.0 * M_PI * u2);\n }\n};\n\n// Hungarian algorithm for rectangular min-cost assignment with m>=n.\n// cost is n x m.\nstatic vector hungarian_min_cost(const vector>& cost) {\n int n = (int)cost.size();\n int m = (int)cost[0].size();\n const long long INF = (1LL<<62);\n\n vector u(n+1, 0), v(m+1, 0);\n vector p(m+1, 0), way(m+1, 0);\n\n for (int i = 1; i <= n; i++) {\n p[0] = i;\n int j0 = 0;\n vector minv(m+1, INF);\n vector used(m+1, false);\n do {\n used[j0] = true;\n int i0 = p[j0];\n long long delta = INF;\n int j1 = 0;\n for (int j = 1; j <= m; j++) if (!used[j]) {\n long long cur = cost[i0-1][j-1] - u[i0] - v[j];\n if (cur < minv[j]) minv[j] = cur, way[j] = j0;\n if (minv[j] < delta) delta = minv[j], j1 = j;\n }\n for (int j = 0; j <= m; j++) {\n if (used[j]) u[p[j]] += delta, v[j] -= delta;\n else minv[j] -= delta;\n }\n j0 = j1;\n } while (p[j0] != 0);\n\n // augmenting\n do {\n int j1 = way[j0];\n p[j0] = p[j1];\n j0 = j1;\n } while (j0);\n }\n\n // assignment: for each row i, find column j with p[j]=i\n vector ans(n, -1);\n for (int j = 1; j <= m; j++) {\n if (p[j] >= 1 && p[j] <= n) ans[p[j]-1] = j-1;\n }\n return ans;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector> d(N, vector(K));\n vector sumD(N, 0);\n vector meanD(K, 0.0);\n\n for (int i = 0; i < N; i++) {\n long long s = 0;\n for (int k = 0; k < K; k++) {\n cin >> d[i][k];\n s += d[i][k];\n meanD[k] += d[i][k];\n }\n sumD[i] = (int)s;\n }\n for (int k = 0; k < K; k++) meanD[k] /= max(1, N);\n\n vector> out(N);\n vector indeg0(N, 0);\n for (int e = 0; e < R; e++) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg0[v]++;\n }\n\n // critical path length (in tasks)\n vector crit(N, 1);\n for (int i = N - 1; i >= 0; i--) {\n int best = 1;\n for (int v : out[i]) best = max(best, 1 + crit[v]);\n crit[i] = best;\n }\n\n vector outdeg(N);\n for (int i = 0; i < N; i++) outdeg[i] = (int)out[i].size();\n\n double avgSumD = 0.0;\n for (int i = 0; i < N; i++) avgSumD += sumD[i];\n avgSumD /= max(1, N);\n\n vector indeg = indeg0;\n vector task_state(N, 0); // 0:not started, 1:running, 2:done\n\n vector member_task(M, -1);\n vector start_day(M, -1);\n vector done_cnt(M, 0);\n\n FastRand rng;\n\n // K-dim skill estimate\n vector> s_est(M, vector(K, 0.0));\n for (int j = 0; j < M; j++) {\n // Random direction ~ |N(0,1)|, magnitude ~ 40 (mid of 20..60)\n vector v(K);\n double norm2 = 0.0;\n for (int k = 0; k < K; k++) {\n double x = fabs(rng.next_normal());\n v[k] = x;\n norm2 += x * x;\n }\n double mag = 40.0;\n double scale = (norm2 > 0) ? (mag / sqrt(norm2)) : 0.0;\n for (int k = 0; k < K; k++) {\n // small prior blend toward meanD to avoid pathological starts\n double initv = v[k] * scale;\n s_est[j][k] = 0.7 * initv + 0.3 * (meanD[k] * 2.0);\n if (s_est[j][k] < 0) s_est[j][k] = 0;\n }\n }\n\n auto w_pred = [&](int i, int j) -> double {\n double w = 0.0;\n const auto& sj = s_est[j];\n for (int k = 0; k < K; k++) {\n double diff = (double)d[i][k] - sj[k];\n if (diff > 0) w += diff;\n }\n return w;\n };\n\n auto t_pred = [&](int i, int j) -> double {\n double w = w_pred(i, j);\n if (w <= 0.0) return 1.0;\n // small bias improves robustness against r in [-3,3]\n return max(1.0, w + 0.5);\n };\n\n auto update_member = [&](int j, int i, int t_obs) {\n // target w roughly equals observed days for t>1, else 0\n double target_w = (t_obs <= 1) ? 0.0 : (double)t_obs;\n\n double w = w_pred(i, j);\n double err = w - target_w; // want err -> 0\n\n // Learning rate decays with number of observations\n double lr = 0.12 / sqrt(1.0 + done_cnt[j]); // tuned small & stable\n\n // Gradient: f(s)=sum max(0, d-s), df/ds_k = -1 if active else 0\n // Loss = (f-target)^2 => grad = 2*(f-target)*df/ds\n // Update s_k -= lr * grad => s_k += 2*lr*err for active dims.\n double delta = 2.0 * lr * err;\n\n // cap to avoid huge jumps on noisy tasks\n delta = max(-8.0, min(8.0, delta));\n\n auto &sj = s_est[j];\n for (int k = 0; k < K; k++) {\n if ((double)d[i][k] > sj[k]) {\n sj[k] += delta;\n if (sj[k] < 0) sj[k] = 0;\n }\n }\n\n // mild regularization toward a prior to prevent collapse\n for (int k = 0; k < K; k++) {\n double prior = meanD[k] * 2.0;\n sj[k] = 0.995 * sj[k] + 0.005 * prior;\n if (sj[k] < 0) sj[k] = 0;\n }\n\n done_cnt[j]++;\n };\n\n int day = 0;\n while (true) {\n day++;\n\n vector free_members;\n free_members.reserve(M);\n for (int j = 0; j < M; j++) if (member_task[j] == -1) free_members.push_back(j);\n\n vector avail;\n avail.reserve(N);\n for (int i = 0; i < N; i++) if (task_state[i] == 0 && indeg[i] == 0) avail.push_back(i);\n\n // Prepare candidate tasks:\n // (1) top by criticality\n sort(avail.begin(), avail.end(), [&](int a, int b) {\n if (crit[a] != crit[b]) return crit[a] > crit[b];\n if (outdeg[a] != outdeg[b]) return outdeg[a] > outdeg[b];\n if (sumD[a] != sumD[b]) return sumD[a] > sumD[b];\n return a < b;\n });\n\n unordered_set candset;\n candset.reserve(800);\n int TOP = min(160, (int)avail.size());\n for (int idx = 0; idx < TOP; idx++) candset.insert(avail[idx]);\n\n // (2) for each free member, add tasks predicted fast (and somewhat critical)\n int PER = 24;\n for (int j : free_members) {\n vector> best;\n best.reserve(avail.size());\n for (int i : avail) {\n double tp = t_pred(i, j);\n // smaller is better; incorporate criticality as a tie-breaker\n double key = tp - 0.15 * (double)crit[i] - 0.01 * (double)outdeg[i];\n best.push_back({key, i});\n }\n if ((int)best.size() > PER) {\n nth_element(best.begin(), best.begin() + PER, best.end());\n best.resize(PER);\n }\n for (auto &p : best) candset.insert(p.second);\n }\n\n vector cands;\n cands.reserve(candset.size());\n for (int i : candset) cands.push_back(i);\n\n // stable order for columns\n sort(cands.begin(), cands.end(), [&](int a, int b) {\n if (crit[a] != crit[b]) return crit[a] > crit[b];\n if (outdeg[a] != outdeg[b]) return outdeg[a] > outdeg[b];\n if (sumD[a] != sumD[b]) return sumD[a] > sumD[b];\n return a < b;\n });\n\n vector> assigns; // (member, task) 0-based\n assigns.reserve(free_members.size());\n\n if (!free_members.empty() && !cands.empty()) {\n int F = (int)free_members.size();\n int C = (int)cands.size();\n int W = max(F, C); // columns after padding\n const long long BIG = (long long)4e12;\n\n vector> cost(F, vector(W, BIG));\n\n // Build costs: minimize -score\n // score = A*crit + B*outdeg - D*t_pred + small difficulty term\n for (int r = 0; r < F; r++) {\n int j = free_members[r];\n bool explore = (done_cnt[j] < 4);\n for (int c = 0; c < C; c++) {\n int i = cands[c];\n double tp = t_pred(i, j);\n\n double sc = 120.0 * (double)crit[i]\n + 6.0 * (double)outdeg[i]\n - 1.0 * tp\n + 0.002 * (double)sumD[i];\n\n if (explore) {\n // Early stage: prefer moderate tasks to learn faster and avoid huge stalls\n sc -= 0.03 * fabs((double)sumD[i] - avgSumD);\n }\n\n long long ssc = (long long)llround(sc * 1000.0);\n cost[r][c] = -ssc;\n }\n }\n\n // If C < F, remaining columns are dummy with BIG cost (forces assignment only if no tasks)\n // If C > F, extra columns exist but that's fine.\n\n vector assign_col = hungarian_min_cost(cost);\n\n vector used_task(N, 0);\n for (int r = 0; r < F; r++) {\n int c = assign_col[r];\n if (c < 0 || c >= C) continue;\n int i = cands[c];\n if (task_state[i] != 0) continue;\n if (used_task[i]) continue; // safety\n int j = free_members[r];\n\n used_task[i] = 1;\n task_state[i] = 1;\n member_task[j] = i;\n start_day[j] = day;\n assigns.push_back({j, i});\n }\n }\n\n // Output assignments for today\n cout << assigns.size();\n for (auto [j, i] : assigns) cout << ' ' << (j + 1) << ' ' << (i + 1);\n cout << \"\\n\" << flush;\n\n // Read completion info\n int nfin;\n if (!(cin >> nfin)) return 0;\n if (nfin == -1) return 0;\n\n for (int z = 0; z < nfin; z++) {\n int a; cin >> a;\n int j = a - 1;\n int i = member_task[j];\n if (i < 0) continue; // safety\n\n int t_obs = day - start_day[j] + 1;\n\n // finish task\n member_task[j] = -1;\n start_day[j] = -1;\n task_state[i] = 2;\n\n // unlock successors\n for (int v : out[i]) indeg[v]--;\n\n // update skill estimate\n update_member(j, i, t_obs);\n }\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point { int x, y; };\nstatic inline int manhattan(const Point& a, const Point& b){\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\nstatic const Point OFFICE{400, 400};\n\nstruct Order {\n int id; // 1..1000\n Point P, D;\n int intra;\n int proxy;\n};\n\nstruct XorShift64 {\n uint64_t x;\n explicit XorShift64(uint64_t seed=88172645463325252ull) : x(seed) {}\n uint64_t next() {\n uint64_t y = x;\n y ^= y << 7;\n y ^= y >> 9;\n return x = y;\n }\n int next_int(int lo, int hi){ // inclusive\n return lo + (int)(next() % (uint64_t)(hi - lo + 1));\n }\n double next_double() { // [0,1)\n return (next() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Solver {\n vector orders; // 1000\n vector pool; // candidate global indices\n vector usedGlobal; // size 1000\n XorShift64 rng;\n\n Solver(): usedGlobal(1000, 0) {\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n rng = XorShift64(seed);\n }\n\n // node id: 2*k = pickup of chosen[k], 2*k+1 = delivery\n inline Point node_point(int node, const vector& chosen) const {\n int k = node >> 1;\n bool isDel = node & 1;\n int g = chosen[k];\n return isDel ? orders[g].D : orders[g].P;\n }\n\n int route_cost(const vector& ev, const vector& chosen) const {\n int cost = 0;\n Point cur = OFFICE;\n for (int node : ev) {\n Point nxt = node_point(node, chosen);\n cost += manhattan(cur, nxt);\n cur = nxt;\n }\n cost += manhattan(cur, OFFICE);\n return cost;\n }\n\n void build_pos(const vector& ev, vector& pos) const {\n int L = (int)ev.size();\n pos.assign(L, -1); // will resize later by caller; not used\n }\n\n bool valid_precedence(const vector& ev, int m) const {\n // m orders => nodes 0..2m-1\n vector pos(2*m, -1);\n for (int i = 0; i < (int)ev.size(); i++) pos[ev[i]] = i;\n for (int k = 0; k < m; k++) {\n if (pos[2*k] < 0 || pos[2*k+1] < 0) return false;\n if (!(pos[2*k] < pos[2*k+1])) return false;\n }\n return true;\n }\n\n vector greedy_init_chosen(int m=50) {\n // Similar to previous greedy on consecutive model, just for initial selection.\n vector chosen;\n chosen.reserve(m);\n fill(usedGlobal.begin(), usedGlobal.end(), 0);\n\n Point cur = OFFICE;\n const double alpha = 0.25;\n\n for (int t = 0; t < m; t++) {\n int best = -1;\n double bestScore = 1e100;\n for (int idx : pool) if (!usedGlobal[idx]) {\n const auto& o = orders[idx];\n double s = manhattan(cur, o.P) + o.intra + alpha * manhattan(o.D, OFFICE);\n if (s < bestScore) { bestScore = s; best = idx; }\n }\n if (best == -1) break;\n usedGlobal[best] = 1;\n chosen.push_back(best);\n cur = orders[best].D;\n }\n for (int i = 0; (int)chosen.size() < m; i++) if (!usedGlobal[i]) {\n usedGlobal[i] = 1;\n chosen.push_back(i);\n }\n return chosen;\n }\n\n vector init_events_consecutive(int m=50) const {\n vector ev;\n ev.reserve(2*m);\n for (int k = 0; k < m; k++) {\n ev.push_back(2*k);\n ev.push_back(2*k+1);\n }\n return ev;\n }\n\n // --- neighborhood moves on event list ---\n bool move_pair(vector& out, const vector& ev, int m, int k, int p2, int q2) const {\n int nodeP = 2*k, nodeD = 2*k+1;\n int L = (int)ev.size();\n int posP=-1, posD=-1;\n for (int i=0;iposD) return false;\n\n out = ev;\n int i = min(posP,posD), j = max(posP,posD);\n out.erase(out.begin()+j);\n out.erase(out.begin()+i); // now length L-2\n int L2 = L-2;\n if (!(0 <= p2 && p2 <= L2)) return false;\n out.insert(out.begin()+p2, nodeP); // length L2+1\n if (!(p2+1 <= q2 && q2 <= L2+1)) return false;\n out.insert(out.begin()+q2, nodeD);\n return valid_precedence(out, m);\n }\n\n bool move_single(vector& out, const vector& ev, int m, int node, int newPos) const {\n int L = (int)ev.size();\n int oldPos = -1;\n for (int i=0;i& out, const vector& ev, int m, int l, int r) const {\n if (l>=r) return false;\n out = ev;\n reverse(out.begin()+l, out.begin()+r+1);\n return valid_precedence(out, m);\n }\n\n int pick_unused_from_pool() {\n for (int t=0;t<30;t++){\n int g = pool[rng.next_int(0, (int)pool.size()-1)];\n if (!usedGlobal[g]) return g;\n }\n for (int t=0;t<200;t++){\n int g = rng.next_int(0,999);\n if (!usedGlobal[g]) return g;\n }\n return -1;\n }\n\n void solve() {\n // candidate pool\n vector idxs(1000);\n iota(idxs.begin(), idxs.end(), 0);\n sort(idxs.begin(), idxs.end(), [&](int i, int j){\n return orders[i].proxy < orders[j].proxy;\n });\n int K = 650; // slightly larger than before to allow better replacements\n pool.assign(idxs.begin(), idxs.begin() + K);\n\n const int m = 50;\n vector chosen = greedy_init_chosen(m);\n vector ev = init_events_consecutive(m);\n\n // Make sure usedGlobal matches chosen (greedy already did, but keep consistent)\n fill(usedGlobal.begin(), usedGlobal.end(), 0);\n for (int g : chosen) usedGlobal[g] = 1;\n\n int curCost = route_cost(ev, chosen);\n int bestCost = curCost;\n vector bestChosen = chosen;\n vector bestEv = ev;\n\n auto start = chrono::steady_clock::now();\n const double TL = 1.95;\n\n int iter = 0;\n while (true) {\n double elapsed = chrono::duration(chrono::steady_clock::now() - start).count();\n if (elapsed >= TL) break;\n double frac = elapsed / TL;\n\n // SA temperature\n double T0 = 3000.0, T1 = 40.0;\n double temp = T0 * pow(T1 / T0, frac);\n\n double r = rng.next_double();\n bool isSwapMove = (r < 0.22); // subset replacement sometimes\n bool accepted = false;\n\n if (isSwapMove) {\n int k = rng.next_int(0, m-1);\n int oldG = chosen[k];\n int newG = pick_unused_from_pool();\n if (newG == -1) { iter++; continue; }\n\n chosen[k] = newG;\n int newCost = route_cost(ev, chosen);\n int delta = newCost - curCost;\n\n if (delta <= 0) accepted = true;\n else {\n double prob = exp(-delta / temp);\n if (rng.next_double() < prob) accepted = true;\n }\n\n if (accepted) {\n usedGlobal[oldG] = 0;\n usedGlobal[newG] = 1;\n curCost = newCost;\n } else {\n chosen[k] = oldG;\n }\n } else {\n vector ev2;\n double t = rng.next_double();\n\n if (t < 0.60) {\n // move pair (pickup+delivery of same order)\n int k = rng.next_int(0, m-1);\n int L = (int)ev.size();\n int L2 = L-2;\n\n // find current positions\n int nodeP = 2*k, nodeD = 2*k+1;\n int posP=-1,posD=-1;\n for (int i=0;i=0 && posD>=0 && posP route;\n route.reserve(2*m + 2);\n route.push_back(OFFICE);\n for (int node : bestEv) {\n int k = node >> 1;\n bool isDel = node & 1;\n int g = bestChosen[k];\n route.push_back(isDel ? orders[g].D : orders[g].P);\n }\n route.push_back(OFFICE);\n\n cout << (int)route.size();\n for (auto &p : route) cout << ' ' << p.x << ' ' << p.y;\n cout << \"\\n\";\n }\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Solver solver;\n solver.orders.resize(1000);\n for (int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n solver.orders[i].id = i + 1;\n solver.orders[i].P = {a,b};\n solver.orders[i].D = {c,d};\n solver.orders[i].intra = manhattan(solver.orders[i].P, solver.orders[i].D);\n solver.orders[i].proxy = manhattan(OFFICE, solver.orders[i].P)\n + solver.orders[i].intra\n + manhattan(solver.orders[i].D, OFFICE);\n }\n solver.solve();\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct DSU {\n int n;\n int comps;\n vector p, sz;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n comps = n;\n p.resize(n);\n sz.assign(n, 1);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){\n while(p[a]!=a){\n p[a] = p[p[a]];\n a = p[a];\n }\n return a;\n }\n bool same(int a,int b){ return find(a)==find(b); }\n bool merge(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 comps--;\n return true;\n }\n};\n\nstatic constexpr int N = 400;\nstatic constexpr int M = 1995;\nstatic constexpr int INF = 1e9;\n\nstruct StepContext {\n vector root; // root[v] in chosen DSU\n vector comp_id; // comp_id[root] -> 0..k-1, -1 for non-root indices\n int k; // #components\n};\n\n// Build contraction mapping for current chosen forest\nstatic StepContext build_context(DSU &chosen) {\n StepContext ctx;\n ctx.root.resize(N);\n for(int i=0;i &u, const vector &v)\n{\n if(ctx.k <= 1) return true;\n DSU dsu2(ctx.k);\n\n for(int j=i+1;j &u, const vector &v, const vector &d)\n{\n if(ctx.k <= 1) return false;\n\n int cu = ctx.comp_id[ ctx.root[u[i]] ];\n int cv = ctx.comp_id[ ctx.root[v[i]] ];\n if(cu == cv) return false;\n\n struct E {\n int a,b;\n int w;\n bool is_cur;\n };\n vector edges;\n edges.reserve(M - i);\n\n for(int j=i;j (int)e2.is_cur;\n });\n\n DSU mst(ctx.k);\n bool taken_cur = false;\n for(auto &e: edges){\n if(mst.merge(e.a, e.b)){\n if(e.is_cur) taken_cur = true;\n if(mst.comps == 1) break;\n }\n }\n // If MST couldn't be completed (shouldn't happen if feasible from i, but can if edges list empty), return false.\n return taken_cur;\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> x[i] >> y[i];\n\n vector u(M), v(M);\n for(int i=0;i> u[i] >> v[i];\n\n vector d(M);\n for(int i=0;i> li;\n\n int ans = 0;\n if(chosen.same(u[i], v[i])){\n ans = 0;\n } else {\n StepContext ctx = build_context(chosen);\n\n // Hard safety: if rejecting breaks future-connectivity feasibility, must take.\n bool ok_reject = feasible_if_reject(i, ctx, u, v);\n if(!ok_reject){\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n // Structure-aware: check membership in expected MST.\n bool in_mst = current_edge_in_expected_mst(i, li, ctx, u, v, d);\n\n // Urgency: if we are running out of edges relative to remaining merges.\n // remaining merges = (k-1)\n long double rem_edges = (long double)(M - i);\n long double urgency = (ctx.k <= 1 ? 0.0L : (long double)(ctx.k - 1) / rem_edges);\n\n long double ratio = (long double)li / (long double)d[i];\n\n // Decision policy:\n // 1) take if expected-MST wants it\n // 2) otherwise take only if it's a strong bargain, or we are late (urgent) and it's not too bad\n if(in_mst){\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else if(ratio <= 1.18L) { // very good deal\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n // Near the end we may need to accept some not-great edges; allow moderate acceptance.\n // (kept conservative to not worsen average)\n long double allow = 1.45L + 1.50L * urgency; // typically around 1.45 early\n if(allow > 2.20L) allow = 2.20L;\n if(ratio <= allow){\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n ans = 0;\n }\n }\n }\n }\n\n cout << ans << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nstatic const int H = 30, W = 30;\nstatic const int TURNS = 300;\n\nstruct Pet { int x, y, t; };\nstruct Human { int x, y; };\n\nstatic inline bool in_grid(int x, int y){ return 1<=x && x<=H && 1<=y && y<=W; }\n\nint dx4[4] = {-1, +1, 0, 0};\nint dy4[4] = {0, 0, -1, +1};\nchar dirMove[4] = {'U','D','L','R'};\nchar dirWall[4] = {'u','d','l','r'};\n\nstruct BFSResult {\n int dist[H+1][W+1];\n char first[H+1][W+1];\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N; cin >> N;\n vector pets(N);\n for(int i=0;i> pets[i].x >> pets[i].y >> pets[i].t;\n int M; cin >> M;\n vector humans(M);\n for(int i=0;i> humans[i].x >> humans[i].y;\n\n static bool wall[H+1][W+1];\n for(int x=1;x<=H;x++) for(int y=1;y<=W;y++) wall[x][y]=false;\n\n // ----- rectangle selection -----\n auto petsInside = [&](int x1,int y1,int S)->int{\n int x2=x1+S-1, y2=y1+S-1;\n int c=0;\n for(auto &p: pets) if(x1<=p.x && p.x<=x2 && y1<=p.y && p.y<=y2) c++;\n return c;\n };\n auto humanTravelCost = [&](int x1,int y1,int S)->long long{\n int x2=x1+S-1, y2=y1+S-1;\n long long sum=0;\n for(auto &h: humans){\n int tx=min(max(h.x,x1),x2);\n int ty=min(max(h.y,y1),y2);\n sum += llabs(h.x-tx)+llabs(h.y-ty);\n }\n return sum;\n };\n auto distPetToRect = [&](const Pet& p, int x1,int y1,int S)->int{\n int x2=x1+S-1, y2=y1+S-1;\n int dx=0, dy=0;\n if(p.x < x1) dx = x1 - p.x;\n else if(p.x > x2) dx = p.x - x2;\n if(p.y < y1) dy = y1 - p.y;\n else if(p.y > y2) dy = p.y - y2;\n return dx + dy;\n };\n auto nearPetsCount = [&](int x1,int y1,int S, int th)->int{\n int c=0;\n for(auto &p: pets){\n int d = distPetToRect(p,x1,y1,S);\n if(d<=th) c++;\n }\n return c;\n };\n\n int best_x1=2, best_y1=2, bestS=16;\n long long bestScore = LLONG_MIN;\n\n // Require perimeter to be within grid: x1>=2,y1>=2,x2<=29,y2<=29\n // Strongly prefer 0 pets inside.\n for(int pass=0; pass<2; pass++){\n // pass=0: only 0 pets inside, pass=1: allow up to 1\n int allowInside = (pass==0 ? 0 : 1);\n for(int S=26; S>=14; S--){\n for(int x1=2; x1+S-1<=29; x1++){\n for(int y1=2; y1+S-1<=29; y1++){\n int pin = petsInside(x1,y1,S);\n if(pin>allowInside) continue;\n\n long long area = 1LL*S*S;\n long long hcost = humanTravelCost(x1,y1,S);\n int near2 = nearPetsCount(x1,y1,S,2); // pets close => block perimeter placement\n int near1 = nearPetsCount(x1,y1,S,1);\n\n long long score = area*1000LL\n - (long long)pin*2000000000LL\n - (long long)near1*300000LL\n - (long long)near2*120000LL\n - hcost*25LL;\n\n if(score > bestScore){\n bestScore=score;\n best_x1=x1; best_y1=y1; bestS=S;\n }\n }\n }\n }\n if(bestScore!=LLONG_MIN && petsInside(best_x1,best_y1,bestS)<=allowInside) {\n if(pass==0 && petsInside(best_x1,best_y1,bestS)==0) break;\n }\n }\n\n int x1=best_x1, y1=best_y1;\n int x2=x1+bestS-1, y2=y1+bestS-1;\n\n auto inInterior = [&](int x,int y)->bool{ return x1<=x && x<=x2 && y1<=y && y<=y2; };\n\n // perimeter cells (one step outside rectangle)\n vector> perimeter;\n {\n set> s;\n for(int y=y1-1;y<=y2+1;y++) s.insert({x1-1,y});\n for(int y=y1-1;y<=y2+1;y++) s.insert({x2+1,y});\n for(int x=x1;x<=x2;x++) s.insert({x,y1-1});\n for(int x=x1;x<=x2;x++) s.insert({x,y2+1});\n perimeter.assign(s.begin(), s.end());\n }\n auto isPerimeterCell = [&](int x,int y)->bool{\n bool onTop = (x==x1-1 && (y1-1)<=y && y<=(y2+1));\n bool onBot = (x==x2+1 && (y1-1)<=y && y<=(y2+1));\n bool onL = (y==y1-1 && x1<=x && x<=x2);\n bool onR = (y==y2+1 && x1<=x && x<=x2);\n return onTop||onBot||onL||onR;\n };\n\n auto bfsFrom = [&](int sx,int sy)->BFSResult{\n BFSResult res;\n const int INF = 1e9;\n for(int x=1;x<=H;x++) for(int y=1;y<=W;y++){\n res.dist[x][y]=INF;\n res.first[x][y]='?';\n }\n deque> q;\n res.dist[sx][sy]=0;\n res.first[sx][sy]='.';\n q.push_back({sx,sy});\n while(!q.empty()){\n auto [x,y]=q.front(); q.pop_front();\n for(int k=0;k<4;k++){\n int nx=x+dx4[k], ny=y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) continue;\n if(res.dist[nx][ny]!=INF) continue;\n res.dist[nx][ny]=res.dist[x][y]+1;\n res.first[nx][ny] = (x==sx && y==sy) ? dirMove[k] : res.first[x][y];\n q.push_back({nx,ny});\n }\n }\n return res;\n };\n\n auto placeableWall = [&](int tx,int ty,\n const vector>& petCnt,\n const vector>& humanCnt)->bool{\n if(!in_grid(tx,ty)) return false;\n if(humanCnt[tx][ty]>0) return false;\n if(petCnt[tx][ty]>0) return false;\n for(int k=0;k<4;k++){\n int ax=tx+dx4[k], ay=ty+dy4[k];\n if(in_grid(ax,ay) && petCnt[ax][ay]>0) return false;\n }\n return true;\n };\n\n // Internal cut planning\n enum Phase { BUILD_PERIM=0, CUT=1, DONE=2 };\n Phase phase = BUILD_PERIM;\n\n // Cut representation\n bool cutVertical=false;\n int cutPos=-1; // y for vertical, x for horizontal\n bool keepRightOrDown=true; // if vertical: keep right side; if horizontal: keep down side\n vector> cutCells; // all cells of cut wall\n\n auto cutComplete = [&]()->bool{\n for(auto &c: cutCells) if(!wall[c.first][c.second]) return false;\n return true;\n };\n\n auto allHumansInSafeSide = [&]()->bool{\n if(phase!=CUT) return true;\n for(auto &h: humans){\n if(!inInterior(h.x,h.y)) return false; // should be enclosed by then\n if(cutVertical){\n if(keepRightOrDown){\n if(h.y <= cutPos) return false; // cut wall at cutPos is blocked; safe side y>=cutPos+1\n }else{\n if(h.y >= cutPos) return false; // safe side y<=cutPos-1\n }\n }else{\n if(keepRightOrDown){\n if(h.x <= cutPos) return false; // safe side x>=cutPos+1\n }else{\n if(h.x >= cutPos) return false; // safe side x<=cutPos-1\n }\n }\n }\n return true;\n };\n\n auto safeTargetCell = [&]()->pair{\n if(phase!=CUT){\n // center of rectangle\n return {(x1+x2)/2, (y1+y2)/2};\n }\n int tx, ty;\n if(cutVertical){\n if(keepRightOrDown){\n tx=(x1+x2)/2;\n ty=(cutPos+1 + y2)/2;\n }else{\n tx=(x1+x2)/2;\n ty=(y1 + cutPos-1)/2;\n }\n }else{\n if(keepRightOrDown){\n tx=(cutPos+1 + x2)/2;\n ty=(y1+y2)/2;\n }else{\n tx=(x1 + cutPos-1)/2;\n ty=(y1+y2)/2;\n }\n }\n tx = min(max(tx,1),30);\n ty = min(max(ty,1),30);\n return {tx,ty};\n };\n\n // Attempt to find a buffered cut separating all current inside pets to one side.\n // We require buffer >= BUF so that while building the cut, pets are unlikely to reach adjacency.\n auto tryPlanCut = [&](const vector& petsNow)->bool{\n vector insidePets;\n insidePets.reserve(N);\n for(auto &p: petsNow) if(inInterior(p.x,p.y)) insidePets.push_back(p);\n if(insidePets.empty()) return false;\n\n int minPX=31,maxPX=0,minPY=31,maxPY=0;\n for(auto &p: insidePets){\n minPX=min(minPX,p.x); maxPX=max(maxPX,p.x);\n minPY=min(minPY,p.y); maxPY=max(maxPY,p.y);\n }\n\n // Buffer. Rabbits move 3, dogs/cats can also move 2; pick 4 for safety.\n const int BUF = 4;\n\n long long bestArea=-1;\n bool bestVert=false;\n int bestPos=-1;\n bool bestKeep=true;\n\n // vertical cuts: wall at y=pos, pos in (y1..y2) excluding border so both sides have space\n for(int pos=y1+1; pos<=y2-1; pos++){\n // keep right side (pets on left with buffer): maxPY <= pos-BUF\n if(maxPY <= pos - BUF){\n long long area = 1LL*(x2-x1+1) * (y2-(pos+1)+1);\n if(area > bestArea){\n bestArea=area; bestVert=true; bestPos=pos; bestKeep=true;\n }\n }\n // keep left side (pets on right with buffer): minPY >= pos+BUF\n if(minPY >= pos + BUF){\n long long area = 1LL*(x2-x1+1) * ((pos-1)-y1+1);\n if(area > bestArea){\n bestArea=area; bestVert=true; bestPos=pos; bestKeep=false;\n }\n }\n }\n // horizontal cuts: wall at x=pos\n for(int pos=x1+1; pos<=x2-1; pos++){\n // keep down side (pets up with buffer): maxPX <= pos-BUF\n if(maxPX <= pos - BUF){\n long long area = 1LL*(y2-y1+1) * (x2-(pos+1)+1);\n if(area > bestArea){\n bestArea=area; bestVert=false; bestPos=pos; bestKeep=true;\n }\n }\n // keep up side (pets down with buffer): minPX >= pos+BUF\n if(minPX >= pos + BUF){\n long long area = 1LL*(y2-y1+1) * ((pos-1)-x1+1);\n if(area > bestArea){\n bestArea=area; bestVert=false; bestPos=pos; bestKeep=false;\n }\n }\n }\n\n if(bestArea < 0) return false;\n\n cutVertical = bestVert;\n cutPos = bestPos;\n keepRightOrDown = bestKeep;\n cutCells.clear();\n if(cutVertical){\n for(int x=x1; x<=x2; x++) cutCells.push_back({x, cutPos});\n }else{\n for(int y=y1; y<=y2; y++) cutCells.push_back({cutPos, y});\n }\n return true;\n };\n\n for(int turn=0; turn> petCnt(H+1, vector(W+1,0));\n vector> humanCnt(H+1, vector(W+1,0));\n for(auto &p: pets) petCnt[p.x][p.y]++;\n for(auto &h: humans) humanCnt[h.x][h.y]++;\n\n bool perimComplete=true;\n for(auto &c: perimeter){\n if(!wall[c.first][c.second]) { perimComplete=false; break; }\n }\n\n int trappedPets=0;\n for(auto &p: pets) if(inInterior(p.x,p.y)) trappedPets++;\n\n // Phase transitions\n if(phase==BUILD_PERIM){\n if(perimComplete){\n if(trappedPets==0) phase=DONE;\n else{\n // attempt immediate cut planning; otherwise remain BUILD_PERIM but do nothing special\n if(tryPlanCut(pets)) phase=CUT;\n else {\n // Still better to be sealed than catastrophic; remain sealed and try cut later.\n phase=CUT; // enter CUT mode but may have no cut yet -> we'll replan\n cutCells.clear();\n cutPos=-1;\n }\n }\n }\n } else if(phase==CUT){\n if(perimComplete && trappedPets==0) phase=DONE;\n else{\n // if no active cut, retry planning when possible\n if(cutPos==-1 || cutCells.empty()){\n tryPlanCut(pets);\n } else {\n if(cutComplete() && allHumansInSafeSide()) phase=DONE;\n }\n }\n }\n\n // BFS per human\n vector bfsRes(M);\n for(int i=0;i act(M, '.');\n set> plannedWalls;\n set> plannedMoveDest;\n\n auto planWallAt = [&](int i, int wx, int wy)->bool{\n int x=humans[i].x, y=humans[i].y;\n int k=-1;\n for(int kk=0;kk<4;kk++) if(x+dx4[kk]==wx && y+dy4[kk]==wy){ k=kk; break; }\n if(k==-1) return false;\n if(plannedMoveDest.count({wx,wy})) return false;\n if(!placeableWall(wx,wy,petCnt,humanCnt)) return false;\n plannedWalls.insert({wx,wy});\n act[i]=dirWall[k];\n return true;\n };\n\n auto planMoveToward = [&](int i, int tx, int ty)->void{\n auto &b=bfsRes[i];\n if(!in_grid(tx,ty)) return;\n if(b.dist[tx][ty]>= (int)1e9) return;\n char fd=b.first[tx][ty];\n if(fd=='.' || fd=='?') return;\n int k=-1;\n for(int kk=0;kk<4;kk++) if(dirMove[kk]==fd){ k=kk; break; }\n if(k==-1) return;\n int nx=humans[i].x+dx4[k], ny=humans[i].y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) return;\n if(plannedWalls.count({nx,ny})) return;\n plannedMoveDest.insert({nx,ny});\n act[i]=fd;\n };\n\n // Find nearest build task among a set of target wall cells\n auto findBuildTask = [&](int i, const vector>& targets)->tuple{\n const int INF=1e9;\n int best=INF;\n int bestWorkX=-1,bestWorkY=-1,bestWallX=-1,bestWallY=-1;\n auto &b=bfsRes[i];\n for(auto &cell: targets){\n int wx=cell.first, wy=cell.second;\n if(wall[wx][wy]) continue;\n // need adjacent work cell\n for(int k=0;k<4;k++){\n int px=wx+dx4[k], py=wy+dy4[k];\n if(!in_grid(px,py) || wall[px][py]) continue;\n int d=b.dist[px][py];\n if(d>=INF) continue;\n // Prefer building from interior when perimeter building\n int penalty=0;\n if(isPerimeterCell(wx,wy)){\n // work cell inside rectangle is preferred\n penalty = inInterior(px,py) ? 0 : 3;\n }\n int val=d+penalty;\n if(val= (int)1e9){ act[i]='.'; continue; }\n if(humans[i].x==workX && humans[i].y==workY){\n if(!planWallAt(i, wallX, wallY)){\n // fallback: try any adjacent missing perimeter cell\n bool done=false;\n for(int k=0;k<4;k++){\n int wx=humans[i].x+dx4[k], wy=humans[i].y+dy4[k];\n if(!in_grid(wx,wy)) continue;\n if(!isPerimeterCell(wx,wy)) continue;\n if(wall[wx][wy]) continue;\n if(planWallAt(i, wx, wy)){ done=true; break; }\n }\n if(!done) act[i]='.';\n }\n } else {\n planMoveToward(i, workX, workY);\n }\n }\n } else if(phase==CUT){\n // If cut not decided, just stand (perimeter already should be complete soon; no catastrophic gate anymore).\n // If cut decided, move humans to safe side, then build cut quickly.\n if(cutPos==-1 || cutCells.empty()){\n for(int i=0;i= cutPos+1);\n else onSafe = (humans[i].y <= cutPos-1);\n }else{\n if(keepRightOrDown) onSafe = (humans[i].x >= cutPos+1);\n else onSafe = (humans[i].x <= cutPos-1);\n }\n if(!onSafe){\n planMoveToward(i, tx, ty);\n continue;\n }\n // Build cut\n auto [best, workX, workY, wallX, wallY] = findBuildTask(i, cutCells);\n if(best >= (int)1e9){ act[i]='.'; continue; }\n if(humans[i].x==workX && humans[i].y==workY){\n if(!planWallAt(i, wallX, wallY)) act[i]='.';\n }else{\n planMoveToward(i, workX, workY);\n }\n }\n }\n }\n\n // Output\n string out; out.reserve(M);\n for(int i=0;i mv(N);\n for(int i=0;i> mv[i])) return 0;\n }\n for(int i=0;i\nusing namespace std;\n\nstatic constexpr int H = 20;\nstatic constexpr int W = 20;\nstatic constexpr int N = H * W;\nstatic constexpr int LMAX = 200;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n\n vector h(H), v(H - 1);\n for (int i = 0; i < H; i++) cin >> h[i]; // length 19\n for (int i = 0; i < H - 1; i++) cin >> v[i]; // length 20\n\n auto id = [&](int i, int j) { return i * W + j; };\n int s = id(si, sj);\n int t = id(ti, tj);\n\n // mv[state][dir], dir: 0=U,1=D,2=L,3=R\n int mv[N][4];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) {\n int cur = id(i, j);\n // U\n if (i == 0 || v[i - 1][j] == '1') mv[cur][0] = cur;\n else mv[cur][0] = id(i - 1, j);\n // D\n if (i == H - 1 || v[i][j] == '1') mv[cur][1] = cur;\n else mv[cur][1] = id(i + 1, j);\n // L\n if (j == 0 || h[i][j - 1] == '1') mv[cur][2] = cur;\n else mv[cur][2] = id(i, j - 1);\n // R\n if (j == W - 1 || h[i][j] == '1') mv[cur][3] = cur;\n else mv[cur][3] = id(i, j + 1);\n }\n\n const double q = 1.0 - p;\n\n // Strong heuristic: optimistic best (state-dependent) policy value.\n // G[turn][x] = max expected additional score from x starting at absolute turn=turn\n // turn in [1..LMAX+1], with G[LMAX+1]=0\n static double G[LMAX + 2][N];\n for (int x = 0; x < N; x++) G[LMAX + 1][x] = 0.0;\n\n for (int turn = LMAX; turn >= 1; --turn) {\n double reward = 401.0 - turn;\n for (int x = 0; x < N; x++) {\n if (x == t) { G[turn][x] = 0.0; continue; }\n double best = 0.0;\n double stay_part = p * G[turn + 1][x];\n for (int a = 0; a < 4; a++) {\n int y = mv[x][a];\n double val = stay_part;\n if (y == t) val += q * reward;\n else val += q * G[turn + 1][y];\n if (val > best) best = val;\n }\n G[turn][x] = best;\n }\n G[turn][t] = 0.0;\n }\n\n struct Node {\n int len = 0;\n double score = 0.0; // exact expected score accumulated so far\n double key = 0.0; // score + heuristic\n array path{};\n array prob{}; // distribution over \"not yet reached\"\n };\n\n auto compute_key = [&](const Node& nd) -> double {\n // heuristic starts at next absolute turn = len+1\n int turn = nd.len + 1;\n if (turn > LMAX) return nd.score;\n double k = nd.score;\n const double *g = G[turn];\n for (int x = 0; x < N; x++) {\n float px = nd.prob[x];\n if (px != 0.0f) k += (double)px * g[x];\n }\n return k;\n };\n\n auto extend = [&](const Node& cur, int a) -> Node {\n static const char dc[4] = {'U','D','L','R'};\n Node nxt;\n nxt.len = cur.len + 1;\n nxt.score = cur.score;\n nxt.path = cur.path;\n nxt.path[cur.len] = dc[a];\n nxt.prob.fill(0.0f);\n\n double reach = 0.0;\n // Transition distribution\n for (int x = 0; x < N; x++) {\n float px = cur.prob[x];\n if (px == 0.0f) continue;\n\n // forget -> stay\n nxt.prob[x] += px * (float)p;\n\n // remember -> move attempt\n int y = mv[x][a];\n double mvprob = (double)px * q;\n if (y == t) reach += mvprob;\n else nxt.prob[y] += (float)mvprob;\n }\n nxt.prob[t] = 0.0f;\n\n int turn = nxt.len;\n nxt.score += reach * (401.0 - turn);\n nxt.key = compute_key(nxt);\n return nxt;\n };\n\n // Beam search\n // Wider beam improves worst-case instances; still fast enough.\n const int BEAM_WIDTH = 450;\n\n Node init;\n init.len = 0;\n init.score = 0.0;\n init.prob.fill(0.0f);\n init.prob[s] = 1.0f;\n init.prob[t] = 0.0f;\n init.key = compute_key(init);\n\n vector beam;\n beam.reserve(BEAM_WIDTH);\n beam.push_back(init);\n\n Node best = init;\n\n for (int step = 0; step < LMAX; step++) {\n vector cand;\n cand.reserve(beam.size() * 4);\n\n for (const auto& nd : beam) {\n for (int a = 0; a < 4; a++) {\n Node child = extend(nd, a);\n if (child.score > best.score) best = child;\n cand.push_back(std::move(child));\n }\n }\n\n int take = min((int)cand.size(), BEAM_WIDTH);\n nth_element(cand.begin(), cand.begin() + take, cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n cand.resize(take);\n sort(cand.begin(), cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n\n beam.swap(cand);\n }\n\n string out;\n out.reserve(best.len);\n for (int i = 0; i < best.len; i++) out.push_back(best.path[i]);\n cout << out << \"\\n\";\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nstatic const int N = 30;\nstatic const int CELLS = N * N;\nstatic const int PORTS = CELLS * 4;\n\n// Directions: 0:left, 1:up, 2:right, 3:down\nstatic const int dj[4] = {-1, 0, 1, 0};\nstatic const int di[4] = {0, -1, 0, 1};\n\nstatic const int to_table[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\n// rotate CCW by 90 degrees mapping\nstatic const int rot1[8] = {1,2,3,0, 5,4, 7,6};\n\nstruct XorShift {\n uint64_t x;\n explicit XorShift(uint64_t seed=88172645463325252ull) : x(seed) {}\n inline uint32_t nextU32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU32() % (uint32_t)(hi - lo + 1));\n }\n inline double nextDouble() { // [0,1)\n return (nextU32() + 0.5) / 4294967296.0;\n }\n};\n\nstruct Timer {\n chrono::high_resolution_clock::time_point st;\n Timer() : st(chrono::high_resolution_clock::now()) {}\n double elapsedSec() const {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nstruct EvalResult {\n int L1=0, L2=0;\n int loopsCnt=0;\n int score=0; // true score = L1*L2 or 0\n int matchedBorders=0; // count of adjacent borders with rails on both sides\n int boundaryPorts=0; // number of rail-ports on the outer boundary (always bad)\n int sumLen=0; // sum of cycle lengths\n int sumLen2=0; // sum of squares of cycle lengths (encourages long cycles)\n int aux=0; // SA objective\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector init(CELLS);\n for (int i = 0; i < N; i++) {\n string s; cin >> s;\n for (int j = 0; j < N; j++) init[i*N + j] = s[j] - '0';\n }\n\n // Precompute state after r rotations\n uint8_t stateAfterRot[8][4];\n for (int t = 0; t < 8; t++) {\n int cur = t;\n for (int r = 0; r < 4; r++) {\n stateAfterRot[t][r] = (uint8_t)cur;\n cur = rot1[cur];\n }\n }\n\n bool hasPort[8][4];\n int partner[8][4];\n for (int t = 0; t < 8; t++) {\n for (int d = 0; d < 4; d++) {\n int d2 = to_table[t][d];\n hasPort[t][d] = (d2 != -1);\n partner[t][d] = d2; // valid iff hasPort\n }\n }\n\n // Buffers for evaluation\n static uint8_t existPort[PORTS];\n static int16_t ext[PORTS];\n static uint16_t visStamp[PORTS];\n uint16_t curStamp = 1;\n static int stk[PORTS];\n\n auto evaluate = [&](const vector& state) -> EvalResult {\n EvalResult res;\n\n // existPort and boundaryPorts\n res.boundaryPorts = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int cell = i*N + j;\n int t = state[cell];\n int base = cell*4;\n for (int s = 0; s < 4; s++) existPort[base+s] = hasPort[t][s] ? 1 : 0;\n\n if (j == 0 && hasPort[t][0]) res.boundaryPorts++;\n if (i == 0 && hasPort[t][1]) res.boundaryPorts++;\n if (j == N-1 && hasPort[t][2]) res.boundaryPorts++;\n if (i == N-1 && hasPort[t][3]) res.boundaryPorts++;\n }\n }\n\n // build ext (only where both sides exist)\n for (int p = 0; p < PORTS; p++) ext[p] = -1;\n res.matchedBorders = 0;\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int cell = i*N + j;\n int base = cell*4;\n // right\n if (j+1 < N) {\n int cellR = i*N + (j+1);\n int baseR = cellR*4;\n int a = base + 2;\n int b = baseR + 0;\n if (existPort[a] && existPort[b]) {\n ext[a] = (int16_t)b;\n ext[b] = (int16_t)a;\n res.matchedBorders++;\n }\n }\n // down\n if (i+1 < N) {\n int cellD = (i+1)*N + j;\n int baseD = cellD*4;\n int a = base + 3;\n int b = baseD + 1;\n if (existPort[a] && existPort[b]) {\n ext[a] = (int16_t)b;\n ext[b] = (int16_t)a;\n res.matchedBorders++;\n }\n }\n }\n }\n\n // traverse connected components of ports\n if (++curStamp == 0) { // extremely unlikely; reset stamps\n memset(visStamp, 0, sizeof(visStamp));\n curStamp = 1;\n }\n\n int best1 = 0, best2 = 0;\n\n for (int p = 0; p < PORTS; p++) {\n if (!existPort[p] || visStamp[p] == curStamp) continue;\n\n bool isCycle = true;\n int compSize = 0;\n\n int sp = 0;\n stk[sp++] = p;\n visStamp[p] = curStamp;\n\n while (sp) {\n int v = stk[--sp];\n compSize++;\n\n if (ext[v] == -1) isCycle = false;\n\n int cell = v / 4;\n int side = v % 4;\n int t = state[cell];\n\n // internal neighbor\n int u_int = cell*4 + partner[t][side];\n if (existPort[u_int] && visStamp[u_int] != curStamp) {\n visStamp[u_int] = curStamp;\n stk[sp++] = u_int;\n }\n\n // external neighbor\n int u_ext = ext[v];\n if (u_ext != -1 && visStamp[u_ext] != curStamp) {\n visStamp[u_ext] = curStamp;\n stk[sp++] = u_ext;\n }\n }\n\n if (isCycle) {\n int len = compSize / 2;\n res.loopsCnt++;\n res.sumLen += len;\n res.sumLen2 += len * len;\n\n if (len > best1) { best2 = best1; best1 = len; }\n else if (len > best2) { best2 = len; }\n }\n }\n\n res.L1 = best1;\n res.L2 = best2;\n res.score = (res.loopsCnt >= 2 ? best1 * best2 : 0);\n\n // Auxiliary objective (dense gradients)\n // - big reward for having >=2 loops\n // - strong reward for long cycles (sumLen2)\n // - reward matched borders (helps close paths into cycles)\n // - penalize boundary ports\n long long aux = 0;\n aux += 500000LL * min(res.loopsCnt, 2); // push to create 2 loops\n aux += 200LL * res.sumLen2; // merge into long cycles\n aux += 30LL * res.matchedBorders; // close connections\n aux -= 80LL * res.boundaryPorts; // avoid leaks to outside\n // once we have a real score, prioritize it heavily\n aux += 20000LL * res.score;\n // also prefer improving the second loop\n aux += 2000LL * res.L2;\n\n if (aux > INT_MAX) aux = INT_MAX;\n res.aux = (int)aux;\n return res;\n };\n\n Timer timer;\n double TL = 1.90;\n\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n vector globalBestRot(CELLS, 0);\n int globalBestScore = 0;\n\n // Multi-start SA\n int restarts = 0;\n while (timer.elapsedSec() < TL) {\n restarts++;\n\n // random init\n vector rot(CELLS);\n vector state(CELLS);\n for (int c = 0; c < CELLS; c++) {\n rot[c] = (uint8_t)rng.nextInt(0, 3);\n state[c] = stateAfterRot[init[c]][rot[c]];\n }\n\n EvalResult cur = evaluate(state);\n int bestScoreRun = cur.score;\n vector bestRotRun = rot;\n\n double startT = timer.elapsedSec();\n // allocate time per restart adaptively (more restarts early, longer if time remains)\n double remaining = TL - startT;\n double slice = min(0.30, remaining); // ~6 restarts typical\n\n // SA temperature schedule\n const double T0 = 300000.0;\n const double T1 = 50.0;\n\n int noImprove = 0;\n\n while (timer.elapsedSec() - startT < slice) {\n double t = (timer.elapsedSec() - startT) / slice;\n double Temp = T0 * (1.0 - t) + T1 * t;\n\n int cell = rng.nextInt(0, CELLS - 1);\n\n uint8_t oldr = rot[cell];\n uint8_t olds = state[cell];\n\n // choose a different rotation (more global than \u00b11)\n uint8_t newr = oldr;\n uint32_t r = rng.nextU32();\n if ((r & 31) == 0) {\n newr = (uint8_t)rng.nextInt(0, 3);\n } else {\n // pick among the other 3 uniformly\n int add = (int)(r % 3) + 1;\n newr = (uint8_t)((oldr + add) & 3);\n }\n if (newr == oldr) continue;\n\n rot[cell] = newr;\n state[cell] = stateAfterRot[init[cell]][newr];\n\n EvalResult nxt = evaluate(state);\n int delta = nxt.aux - cur.aux;\n\n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / Temp);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (accept) {\n cur = nxt;\n noImprove++;\n\n if (cur.score > bestScoreRun) {\n bestScoreRun = cur.score;\n bestRotRun = rot;\n noImprove = 0;\n }\n\n if (cur.score > globalBestScore) {\n globalBestScore = cur.score;\n globalBestRot = rot;\n }\n\n // occasional kick if stagnating\n if (noImprove > 2000 && (rng.nextU32() & 255) == 0) {\n for (int k = 0; k < 30; k++) {\n int c2 = rng.nextInt(0, CELLS - 1);\n rot[c2] = (uint8_t)rng.nextInt(0, 3);\n state[c2] = stateAfterRot[init[c2]][rot[c2]];\n }\n cur = evaluate(state);\n noImprove = 0;\n }\n } else {\n rot[cell] = oldr;\n state[cell] = olds;\n }\n }\n }\n\n // Output best found\n string out(CELLS, '0');\n for (int c = 0; c < CELLS; c++) out[c] = char('0' + globalBestRot[c]);\n cout << out << \"\\n\";\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n uint32_t next_u32() { return (uint32_t)next_u64(); }\n int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline int hexval(char c) {\n if ('0' <= c && c <= '9') return c - '0';\n return 10 + (c - 'a');\n}\n\n// Evaluation:\n// - bestTree: max size among components that are trees (edges = vertices-1)\n// - matchEdges: total number of matched edges\n// - cycleExcess: sum over components of max(0, edges-(vertices-1))\n// scalar used for SA acceptance (allows occasional decreases in bestTree early).\nstruct Eval {\n int bestTree = 0;\n int matchEdges = 0;\n int cycleExcess = 0;\n int scalar = 0;\n};\n\nstruct DSU {\n int n;\n vector p, r;\n DSU(int n=0): n(n), p(n), r(n,0) { iota(p.begin(), p.end(), 0); }\n int find(int a){ while(p[a]!=a){ p[a]=p[p[a]]; a=p[a]; } return a; }\n void unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return;\n if(r[a]& a, int N) {\n int NN = N*N;\n DSU dsu(NN);\n\n vector> edges;\n edges.reserve(2*NN);\n\n auto id = [N](int r,int c){ return r*N+c; };\n\n int matchEdges = 0;\n for(int r=0;r vcnt(NN,0), ecnt(NN,0);\n for(int i=0;i v-1) cycleExcess += (e - (v-1));\n }\n\n // SA scalar (tuned so bestTree dominates but can decrease early)\n // - bestTree step: 1000\n // - matching edges help: +10 each\n // - cycles penalized: -40 each\n int scalar = bestTree * 1000 + matchEdges * 10 - cycleExcess * 40;\n\n return Eval{bestTree, matchEdges, cycleExcess, scalar};\n}\n\n// Moves: U,D,L,R meaning the tile above/below/left/right slides into empty.\n// Equivalent: empty moves U/D/L/R.\nstatic const char DIRCH[4] = {'U','D','L','R'};\nstatic const int dr[4] = {-1, +1, 0, 0};\nstatic const int dc[4] = {0, 0, -1, +1};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T;\n cin >> N >> T;\n vector init(N*N);\n int er=-1, ec=-1;\n for(int i=0;i> s;\n for(int j=0;j(now-start).count();\n };\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n seed ^= (uint64_t)(N*10007 + T*1000003);\n XorShift64 rng(seed);\n\n // Best overall answer found\n string bestAns;\n Eval bestEval;\n bestEval.bestTree = -1;\n int bestK = INT_MAX; // for full solutions\n\n // time limit margin\n const double TIME_LIMIT_MS = 2850.0;\n\n int runCount = 0;\n\n while(elapsed_ms() < TIME_LIMIT_MS) {\n runCount++;\n\n vector a = init;\n int cur_er = er, cur_ec = ec;\n Eval curE = evaluate_board(a, N);\n\n string moves;\n moves.reserve(T);\n\n // Best prefix in this run\n int runBestIdx = 0;\n Eval runBestEval = curE;\n\n // If already full, answer is empty\n if(curE.bestTree == targetFull) {\n bestAns = \"\";\n break;\n }\n\n // SA parameters\n const double temp0 = 800.0;\n const double temp1 = 5.0;\n\n int lastDir = -1;\n\n // Build up to T accepted moves (rejections don't consume move budget)\n int accepted = 0;\n int trialsSinceAccept = 0;\n\n while(accepted < T && elapsed_ms() < TIME_LIMIT_MS) {\n trialsSinceAccept++;\n if(trialsSinceAccept > 20000) break; // safety\n\n double prog = (double)accepted / max(1, T);\n double temp = temp0 * pow(temp1 / temp0, prog);\n\n // pick a random legal dir, with mild anti-backtrack preference\n int cand[4], ccnt=0;\n for(int d=0; d<4; d++){\n int nr = cur_er + dr[d], nc = cur_ec + dc[d];\n if(nr<0||nr>=N||nc<0||nc>=N) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n\n int d;\n if(lastDir != -1 && ccnt >= 2) {\n // avoid immediate reverse with high probability\n int rev = (lastDir==0?1:lastDir==1?0:lastDir==2?3:2);\n if(rng.next_double() < 0.80) {\n // choose among dirs excluding rev if possible\n int tmp[4], tcnt=0;\n for(int k=0;k0) d = tmp[rng.next_int(tcnt)];\n else d = cand[rng.next_int(ccnt)];\n } else {\n d = cand[rng.next_int(ccnt)];\n }\n } else {\n d = cand[rng.next_int(ccnt)];\n }\n\n int nr = cur_er + dr[d], nc = cur_ec + dc[d];\n int u = cur_er*N + cur_ec;\n int v = nr*N + nc;\n\n // apply swap (accept candidate move)\n swap(a[u], a[v]);\n cur_er = nr; cur_ec = nc;\n\n Eval newE = evaluate_board(a, N);\n int delta = newE.scalar - curE.scalar;\n\n bool accept = false;\n if(delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if(rng.next_double() < prob) accept = true;\n }\n\n if(accept) {\n // keep\n curE = newE;\n moves.push_back(DIRCH[d]);\n accepted++;\n trialsSinceAccept = 0;\n lastDir = d;\n\n // update best prefix in this run:\n // primary: bestTree, then matchEdges, then smaller cycleExcess\n bool betterRun =\n (curE.bestTree > runBestEval.bestTree) ||\n (curE.bestTree == runBestEval.bestTree && curE.matchEdges > runBestEval.matchEdges) ||\n (curE.bestTree == runBestEval.bestTree && curE.matchEdges == runBestEval.matchEdges && curE.cycleExcess < runBestEval.cycleExcess);\n\n if(betterRun) {\n runBestEval = curE;\n runBestIdx = accepted;\n }\n\n // full tree: best is shortest K\n if(curE.bestTree == targetFull) {\n // record best full prefix in this run (earliest full is current accepted)\n runBestEval = curE;\n runBestIdx = accepted;\n break;\n }\n } else {\n // revert\n swap(a[u], a[v]);\n cur_er -= dr[d];\n cur_ec -= dc[d];\n }\n }\n\n // consider run best prefix as candidate answer\n string candAns = moves.substr(0, runBestIdx);\n Eval candEval = runBestEval;\n int candK = (int)candAns.size();\n\n bool betterOverall = false;\n if(bestEval.bestTree < 0) betterOverall = true;\n else if(candEval.bestTree == targetFull && bestEval.bestTree != targetFull) betterOverall = true;\n else if(candEval.bestTree == targetFull && bestEval.bestTree == targetFull) {\n if(candK < bestK) betterOverall = true;\n } else if(candEval.bestTree != targetFull && bestEval.bestTree != targetFull) {\n if(candEval.bestTree > bestEval.bestTree) betterOverall = true;\n else if(candEval.bestTree == bestEval.bestTree) {\n if(candEval.matchEdges > bestEval.matchEdges) betterOverall = true;\n else if(candEval.matchEdges == bestEval.matchEdges && candEval.cycleExcess < bestEval.cycleExcess) betterOverall = true;\n }\n }\n\n if(betterOverall) {\n bestAns = candAns;\n bestEval = candEval;\n bestK = candK;\n // If we found a full solution with very small K, we can stop early.\n if(bestEval.bestTree == targetFull && bestK <= N*N) break;\n }\n }\n\n // Ensure within T\n if((int)bestAns.size() > T) bestAns.resize(T);\n\n cout << bestAns << \"\\n\";\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\nusing i128 = __int128_t;\n\nstatic inline uint64_t splitmix64(uint64_t x) {\n x += 0x9e3779b97f4a7c15ULL;\n x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;\n x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;\n return x ^ (x >> 31);\n}\n\nstruct RNG {\n uint64_t state;\n explicit RNG(uint64_t seed=1) : state(seed) {}\n uint64_t next_u64() { return state = splitmix64(state); }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n double next_double(double l, double r) {\n return l + (r - l) * next_double();\n }\n};\n\nstruct Point {\n int x, y;\n};\n\nstruct Line {\n int64 px, py, qx, qy;\n};\n\nstatic inline int sgn_i128(i128 v) {\n if (v > 0) return 1;\n if (v < 0) return -1;\n return 0;\n}\n\n// orientation of (P->Q) x (P->X)\nstatic inline int side_of(const Line& ln, int x, int y) {\n i128 dx = (i128)ln.qx - (i128)ln.px;\n i128 dy = (i128)ln.qy - (i128)ln.py;\n i128 ax = (i128)x - (i128)ln.px;\n i128 ay = (i128)y - (i128)ln.py;\n i128 cross = dx * ay - dy * ax;\n return sgn_i128(cross);\n}\n\nstatic inline uint64_t hash_line(const Line& ln) {\n uint64_t h = 0;\n auto mix = [&](int64 v) {\n h ^= splitmix64((uint64_t)v + 0x9e3779b97f4a7c15ULL + (h<<6) + (h>>2));\n };\n mix(ln.px); mix(ln.py); mix(ln.qx); mix(ln.qy);\n return h;\n}\n\n// Generate a line by angle+offset, then round endpoints to integers.\nstatic Line make_line_from_angle_offset(long double theta, long double offset) {\n // normal n=(cos, sin), direction d=(-sin, cos)\n long double nx = cos(theta), ny = sin(theta);\n long double dx = -sin(theta), dy = cos(theta);\n\n // point on line p0 = n * offset\n long double x0 = nx * offset;\n long double y0 = ny * offset;\n\n // far endpoints along direction\n long double L = 20000.0L;\n long double x1 = x0 + dx * L;\n long double y1 = y0 + dy * L;\n long double x2 = x0 - dx * L;\n long double y2 = y0 - dy * L;\n\n Line ln;\n ln.px = llround(x1);\n ln.py = llround(y1);\n ln.qx = llround(x2);\n ln.qy = llround(y2);\n\n // ensure distinct\n if (ln.px == ln.qx && ln.py == ln.qy) {\n ln.qx += 1;\n }\n return ln;\n}\n\n// Distance from origin to line (for quick rejection) using long double.\nstatic long double dist_origin_to_line_ld(const Line& ln) {\n long double x1 = (long double)ln.px, y1 = (long double)ln.py;\n long double x2 = (long double)ln.qx, y2 = (long double)ln.qy;\n long double A = y2 - y1;\n long double B = x1 - x2;\n long double C = -(A * x1 + B * y1);\n long double denom = sqrt(A*A + B*B);\n if (denom == 0) return 1e100L;\n return fabsl(C) / denom;\n}\n\nstruct Evaluator {\n const vector& pts;\n array a; // 1..10\n int totalA;\n\n Evaluator(const vector& pts_, const array& a_) : pts(pts_), a(a_) {\n totalA = 0;\n for (int d=1; d<=10; d++) totalA += a[d];\n }\n\n // returns distributable pieces count = sum min(a_d, b_d)\n int eval(const vector& lines) const {\n int L = (int)lines.size();\n vector posMask(L), negMask(L);\n for (int i=0;i cnt;\n cnt.reserve(pts.size() * 2);\n\n for (const auto& p : pts) {\n uint64_t key = 0;\n bool cut = false;\n for (int i=0;i 0 ? posMask[i] : negMask[i]);\n }\n if (cut) continue;\n cnt[key]++;\n }\n\n int b[11] = {};\n for (auto &kv : cnt) {\n int sz = kv.second;\n if (1 <= sz && sz <= 10) b[sz]++;\n }\n\n int distributed = 0;\n for (int d=1; d<=10; d++) distributed += min(a[d], b[d]);\n return distributed;\n }\n};\n\nstatic bool line_hits_any_strawberry_center(const Line& ln, const vector& pts) {\n for (auto &p: pts) {\n if (side_of(ln, p.x, p.y) == 0) return true;\n }\n return false;\n}\n\nstatic bool is_valid_line(const Line& ln) {\n auto inRange = [&](int64 v){ return -1000000000LL <= v && v <= 1000000000LL; };\n if (!inRange(ln.px) || !inRange(ln.py) || !inRange(ln.qx) || !inRange(ln.qy)) return false;\n if (ln.px == ln.qx && ln.py == ln.qy) return false;\n return true;\n}\n\n// random line that intersects the disk and (optionally) avoids passing through strawberries.\nstatic bool gen_candidate_line(Line &out, RNG &rng, const vector& pts) {\n const long double R = 10000.0L;\n for (int it=0; it<200; it++) {\n long double theta = rng.next_double(0.0, acosl(-1.0L)); // [0, pi)\n long double offset = rng.next_double(-0.98*R, 0.98*R);\n\n Line ln = make_line_from_angle_offset(theta, offset);\n if (!is_valid_line(ln)) continue;\n\n // must intersect disk\n if (dist_origin_to_line_ld(ln) >= R) continue;\n\n // avoid cutting strawberries exactly\n if (line_hits_any_strawberry_center(ln, pts)) continue;\n\n out = ln;\n return true;\n }\n return false;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n cin >> N >> K;\n array a{};\n for (int d=1; d<=10; d++) cin >> a[d];\n\n vector pts(N);\n for (int i=0;i> pts[i].x >> pts[i].y;\n\n // seed based on input\n uint64_t seed = 123456789ULL;\n seed ^= splitmix64((uint64_t)N * 1009 + (uint64_t)K);\n for (int d=1; d<=10; d++) seed ^= splitmix64((uint64_t)a[d] * (d*10007ULL));\n for (int i=0;i bestLines;\n int bestVal = -1;\n\n // restarts\n int RESTARTS = 6;\n int CANDS_PER_STEP = 25;\n\n for (int r=0; r cur;\n int curVal = evaluator.eval(cur);\n int equalSteps = 0;\n\n for (int step=0; step tmp = cur;\n tmp.push_back(ln);\n int v = evaluator.eval(tmp);\n if (v > bestHereVal) {\n bestHereVal = v;\n bestLn = ln;\n foundAny = true;\n }\n }\n\n if (!foundAny) break;\n if (bestHereVal < curVal) break; // do not decrease\n\n cur.push_back(bestLn);\n if (bestHereVal == curVal) {\n equalSteps++;\n // if we keep not improving, stop early\n if (equalSteps >= 12) break;\n } else {\n equalSteps = 0;\n }\n curVal = bestHereVal;\n\n // early perfect\n if (curVal == totalA) break;\n }\n\n if (curVal > bestVal) {\n bestVal = curVal;\n bestLines = cur;\n }\n if (bestVal == totalA) break;\n }\n\n // output\n cout << bestLines.size() << \"\\n\";\n for (auto &ln : bestLines) {\n cout << ln.px << \" \" << ln.py << \" \" << ln.qx << \" \" << ln.qy << \"\\n\";\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Pt {\n int x, y;\n};\n\nstatic inline int sgn(int a){ return (a>0) - (a<0); }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n vector> dot(N, vector(N, 0));\n for(int i=0;i>x>>y;\n dot[x][y]=1;\n }\n\n auto inside = [&](int x,int y)->bool{\n return 0<=x && x> h(N, vector(N-1, 0));\n vector> v(N-1, vector(N, 0));\n vector> d1(N-1, vector(N-1, 0));\n vector> d2(N-1, vector(N-1, 0));\n\n auto usedSeg = [&](Pt a, Pt b)->unsigned char&{\n int dx = b.x - a.x, dy = b.y - a.y;\n if (abs(dx)+abs(dy)==1) {\n if (dy==0) {\n int y = a.y;\n int x = min(a.x, b.x);\n return h[y][x];\n } else {\n int x = a.x;\n int y = min(a.y, b.y);\n return v[y][x];\n }\n } else {\n // diagonal unit\n int x = min(a.x, b.x);\n int y = min(a.y, b.y);\n if (dx==dy) return d1[y][x];\n else return d2[y][x]; // dx==-dy\n }\n };\n\n auto edgeLen = [&](Pt a, Pt b)->int{\n return max(abs(a.x-b.x), abs(a.y-b.y));\n };\n\n // Check an edge (a->b) satisfies:\n // - it's horizontal/vertical/diagonal (\u00b11 slope),\n // - no intermediate points have dots (condition 2),\n // - no unit segments were previously used (condition 3).\n auto checkEdge = [&](Pt a, Pt b)->bool{\n int dx = b.x - a.x, dy = b.y - a.y;\n int adx = abs(dx), ady = abs(dy);\n if (!((dx==0 && dy!=0) || (dy==0 && dx!=0) || (adx==ady && adx!=0))) return false;\n int sx = sgn(dx), sy = sgn(dy);\n int len = max(adx, ady);\n\n // intermediate dots\n for(int i=1;ibool{\n if (!inside(p1.x,p1.y) || !inside(p2.x,p2.y) || !inside(p3.x,p3.y) || !inside(p4.x,p4.y)) return false;\n if (dot[p1.x][p1.y]) return false;\n if (!dot[p2.x][p2.y] || !dot[p3.x][p3.y] || !dot[p4.x][p4.y]) return false;\n\n // edges must be valid (condition 2 & 3)\n if (!checkEdge(p1,p2)) return false;\n if (!checkEdge(p2,p3)) return false;\n if (!checkEdge(p3,p4)) return false;\n if (!checkEdge(p4,p1)) return false;\n\n return true;\n };\n\n auto applyRect = [&](Pt p1, Pt p2, Pt p3, Pt p4){\n dot[p1.x][p1.y] = 1;\n applyEdge(p1,p2);\n applyEdge(p2,p3);\n applyEdge(p3,p4);\n applyEdge(p4,p1);\n };\n\n // Precompute points sorted by descending weight (farther from center first).\n int c = (N-1)/2;\n vector order;\n order.reserve(N*N);\n for(int x=0;xint{\n int dx = p.x - c;\n int dy = p.y - c;\n return dx*dx + dy*dy + 1;\n };\n sort(order.begin(), order.end(), [&](const Pt& a, const Pt& b){\n int wa = weight(a), wb = weight(b);\n if (wa != wb) return wa > wb;\n if (a.x != b.x) return a.x < b.x;\n return a.y < b.y;\n });\n\n // Collect up to LIM nearest dots along a direction (dx,dy) from p (excluding p).\n auto collectDir = [&](Pt p, int dx, int dy, int LIM)->vector{\n vector res;\n for(int step=1;;step++){\n int nx = p.x + dx*step;\n int ny = p.y + dy*step;\n if (!inside(nx,ny)) break;\n if (dot[nx][ny]) {\n res.push_back({nx,ny});\n if ((int)res.size() >= LIM) break;\n }\n }\n return res;\n };\n\n vector> ops;\n\n auto start = chrono::steady_clock::now();\n const double TL = 4.85; // stop earlier than 5.0s\n\n int LIM = 4; // nearest dots per direction (tunable)\n for(int pass=0; pass<50; pass++){\n bool progressed = false;\n\n for(const auto &p1 : order){\n // time check\n auto now = chrono::steady_clock::now();\n double t = chrono::duration(now - start).count();\n if (t > TL) break;\n\n if (dot[p1.x][p1.y]) continue;\n\n // Gather nearby existing dots\n vector horiz, vert, diagPlus, diagMinus;\n {\n auto L = collectDir(p1, -1, 0, LIM);\n auto R = collectDir(p1, 1, 0, LIM);\n horiz.reserve(L.size()+R.size());\n horiz.insert(horiz.end(), L.begin(), L.end());\n horiz.insert(horiz.end(), R.begin(), R.end());\n }\n {\n auto D = collectDir(p1, 0, -1, LIM);\n auto U = collectDir(p1, 0, 1, LIM);\n vert.reserve(D.size()+U.size());\n vert.insert(vert.end(), D.begin(), D.end());\n vert.insert(vert.end(), U.begin(), U.end());\n }\n {\n auto NE = collectDir(p1, 1, 1, LIM);\n auto SW = collectDir(p1, -1, -1, LIM);\n diagPlus.reserve(NE.size()+SW.size());\n diagPlus.insert(diagPlus.end(), NE.begin(), NE.end());\n diagPlus.insert(diagPlus.end(), SW.begin(), SW.end());\n }\n {\n auto SE = collectDir(p1, 1, -1, LIM);\n auto NW = collectDir(p1, -1, 1, LIM);\n diagMinus.reserve(SE.size()+NW.size());\n diagMinus.insert(diagMinus.end(), SE.begin(), SE.end());\n diagMinus.insert(diagMinus.end(), NW.begin(), NW.end());\n }\n\n bool found = false;\n Pt bestP2{}, bestP3{}, bestP4{};\n int bestPerim = INT_MAX;\n\n // Axis-aligned rectangles: p2 on row, p4 on col, p3 at (p2.x, p4.y).\n for(const auto &p2 : horiz){\n for(const auto &p4 : vert){\n if (p2.x == p1.x || p4.y == p1.y) continue;\n Pt p3{p2.x, p4.y};\n if (!inside(p3.x,p3.y)) continue;\n if (!dot[p3.x][p3.y]) continue;\n\n if (!validRect(p1, p2, p3, p4)) continue;\n int perim = edgeLen(p1,p2) + edgeLen(p2,p3) + edgeLen(p3,p4) + edgeLen(p4,p1);\n if (perim < bestPerim) {\n bestPerim = perim;\n bestP2 = p2; bestP3 = p3; bestP4 = p4;\n found = true;\n }\n }\n }\n\n // 45-degree rectangles: p2 on diagPlus (x-y const), p4 on diagMinus (x+y const)\n for(const auto &p2 : diagPlus){\n for(const auto &p4 : diagMinus){\n if (p2.x==p1.x && p2.y==p1.y) continue;\n if (p4.x==p1.x && p4.y==p1.y) continue;\n Pt p3{p2.x + p4.x - p1.x, p2.y + p4.y - p1.y};\n if (!inside(p3.x,p3.y)) continue;\n if (!dot[p3.x][p3.y]) continue;\n\n if (!validRect(p1, p2, p3, p4)) continue;\n int perim = edgeLen(p1,p2) + edgeLen(p2,p3) + edgeLen(p3,p4) + edgeLen(p4,p1);\n if (perim < bestPerim) {\n bestPerim = perim;\n bestP2 = p2; bestP3 = p3; bestP4 = p4;\n found = true;\n }\n }\n }\n\n if (found) {\n applyRect(p1, bestP2, bestP3, bestP4);\n ops.push_back({p1.x,p1.y, bestP2.x,bestP2.y, bestP3.x,bestP3.y, bestP4.x,bestP4.y});\n progressed = true;\n }\n }\n\n auto now = chrono::steady_clock::now();\n double t = chrono::duration(now - start).count();\n if (t > TL) break;\n\n if (!progressed) break;\n }\n\n cout << ops.size() << \"\\n\";\n for(auto &a: ops){\n for(int i=0;i<8;i++){\n if (i) cout << ' ';\n cout << a[i];\n }\n cout << \"\\n\";\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstatic constexpr int H = 10, W = 10, C = 100;\n\nstruct XorShift {\n uint64_t x;\n explicit XorShift(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n inline double nextDouble() {\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct State {\n // row-major: idx = y*10+x. 0 empty, 1..3 flavors\n array a{};\n\n inline uint8_t& at(int y, int x) { return a[y * W + x]; }\n inline uint8_t at(int y, int x) const { return a[y * W + x]; }\n\n void clear() { a.fill(0); }\n\n // Place candy of flavor f at p-th empty cell in scan order (y asc, x asc)\n void placeByP(int p, uint8_t f) {\n int cnt = 0;\n for (int i = 0; i < C; i++) {\n if (a[i] == 0) {\n cnt++;\n if (cnt == p) {\n a[i] = f;\n return;\n }\n }\n }\n }\n\n inline void tiltInPlace(char dir) {\n if (dir == 'L') {\n for (int y = 0; y < H; y++) {\n uint8_t tmp[W]; int k = 0;\n int base = y * W;\n for (int x = 0; x < W; x++) if (a[base + x]) tmp[k++] = a[base + x];\n for (int x = 0; x < W; x++) a[base + x] = 0;\n for (int x = 0; x < k; x++) a[base + x] = tmp[x];\n }\n } else if (dir == 'R') {\n for (int y = 0; y < H; y++) {\n uint8_t tmp[W]; int k = 0;\n int base = y * W;\n for (int x = 0; x < W; x++) if (a[base + x]) tmp[k++] = a[base + x];\n for (int x = 0; x < W; x++) a[base + x] = 0;\n for (int i = 0; i < k; i++) a[base + (W - k + i)] = tmp[i];\n }\n } else if (dir == 'F') { // to smaller y\n for (int x = 0; x < W; x++) {\n uint8_t tmp[H]; int k = 0;\n for (int y = 0; y < H; y++) {\n uint8_t v = a[y * W + x];\n if (v) tmp[k++] = v;\n }\n for (int y = 0; y < H; y++) a[y * W + x] = 0;\n for (int y = 0; y < k; y++) a[y * W + x] = tmp[y];\n }\n } else { // 'B' to larger y\n for (int x = 0; x < W; x++) {\n uint8_t tmp[H]; int k = 0;\n for (int y = 0; y < H; y++) {\n uint8_t v = a[y * W + x];\n if (v) tmp[k++] = v;\n }\n for (int y = 0; y < H; y++) a[y * W + x] = 0;\n for (int i = 0; i < k; i++) a[(H - k + i) * W + x] = tmp[i];\n }\n }\n }\n\n inline State afterTilt(char dir) const {\n State s = *this;\n s.tiltInPlace(dir);\n return s;\n }\n\n inline vector empties() const {\n vector e;\n e.reserve(C);\n for (int i = 0; i < C; i++) if (a[i] == 0) e.push_back(i);\n return e;\n }\n};\n\n// Cheap heuristic (no BFS components) for fast greedy decisions in rollouts\nstruct CheapEval {\n // weights tuned mildly; Monte Carlo is main driver now\n double wAdj = 2.0;\n double wVar = 0.05;\n double wOrd = 8.0;\n double wSep = 0.4;\n\n double operator()(const State& s) const {\n int adjSame = 0;\n for (int y = 0; y < H; y++) for (int x = 0; x < W; x++) {\n uint8_t f = s.at(y,x);\n if (!f) continue;\n if (x+1 < W && s.at(y,x+1) == f) adjSame++;\n if (y+1 < H && s.at(y+1,x) == f) adjSame++;\n }\n\n double cnt[4] = {0,0,0,0};\n double sx[4] = {0,0,0,0}, sy[4] = {0,0,0,0};\n double sx2[4] = {0,0,0,0}, sy2[4] = {0,0,0,0};\n\n for (int y = 0; y < H; y++) for (int x = 0; x < W; x++) {\n uint8_t f = s.at(y,x);\n if (!f) continue;\n cnt[f] += 1.0;\n sx[f] += x; sy[f] += y;\n sx2[f] += 1.0 * x * x;\n sy2[f] += 1.0 * y * y;\n }\n\n double ax[4] = {0,0,0,0}, ay[4] = {0,0,0,0};\n for (int f = 1; f <= 3; f++) if (cnt[f] > 0) {\n ax[f] = sx[f] / cnt[f];\n ay[f] = sy[f] / cnt[f];\n }\n\n double varSum = 0.0;\n for (int f = 1; f <= 3; f++) if (cnt[f] > 0) {\n double ex = ax[f], ey = ay[f];\n varSum += (sx2[f] - cnt[f]*ex*ex) + (sy2[f] - cnt[f]*ey*ey);\n }\n\n auto ordPenaltyPair = [&](int a, int b) -> double {\n if (cnt[a] == 0 || cnt[b] == 0) return 0.0;\n return max(0.0, ax[a] - ax[b]); // want ax[a] <= ax[b]\n };\n double ordPenalty = ordPenaltyPair(1,2) + ordPenaltyPair(2,3);\n\n double sep = 0.0;\n for (int i = 1; i <= 3; i++) for (int j = i+1; j <= 3; j++) {\n if (cnt[i] == 0 || cnt[j] == 0) continue;\n double dx = ax[i] - ax[j];\n double dy = ay[i] - ay[j];\n sep += dx*dx + dy*dy;\n }\n\n return wAdj * adjSame - wVar * varSum - wOrd * ordPenalty + wSep * sep;\n }\n};\n\nstatic inline int finalComponentSumSq(const State& s) {\n bool vis[C];\n memset(vis, 0, sizeof(vis));\n int sumsq = 0;\n\n int q[C];\n for (int i = 0; i < C; i++) {\n if (s.a[i] == 0 || vis[i]) continue;\n uint8_t f = s.a[i];\n int head = 0, tail = 0;\n vis[i] = true;\n q[tail++] = i;\n int cnt = 0;\n while (head < tail) {\n int v = q[head++];\n cnt++;\n int y = v / W, x = v % W;\n // 4-neighbors\n if (y > 0) {\n int u = v - W;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (y+1 < H) {\n int u = v + W;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (x > 0) {\n int u = v - 1;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (x+1 < W) {\n int u = v + 1;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n }\n sumsq += cnt * cnt;\n }\n return sumsq;\n}\n\n// One rollout from state \"s\" starting at step (tNext) where next candy is f[tNext].\n// Random placements; tilt choices via greedy cheap evaluation.\nstatic int rollout(State s, int tNext, const array& f, XorShift& rng, const CheapEval& cev) {\n static constexpr array DIRS = {'F','B','L','R'};\n\n for (int t = tNext; t <= 100; t++) {\n // random empty cell\n vector e;\n e.reserve(C);\n for (int i = 0; i < C; i++) if (s.a[i] == 0) e.push_back(i);\n if (e.empty()) break;\n int idx = rng.nextInt(0, (int)e.size() - 1);\n s.a[e[idx]] = (uint8_t)f[t];\n\n // choose tilt by greedy cheap eval\n char bestDir = 'L';\n double bestV = -1e100;\n for (char d : DIRS) {\n State ns = s.afterTilt(d);\n double v = cev(ns);\n if (v > bestV) bestV = v, bestDir = d;\n }\n s.tiltInPlace(bestDir);\n }\n return finalComponentSumSq(s);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n array f{};\n for (int t = 1; t <= 100; t++) {\n if (!(cin >> f[t])) return 0;\n }\n\n // Seed RNG from flavor sequence (deterministic, but instance-dependent)\n uint64_t seed = 1469598103934665603ULL;\n for (int t = 1; t <= 100; t++) seed = (seed ^ (uint64_t)f[t]) * 1099511628211ULL;\n XorShift rng(seed);\n\n State cur;\n cur.clear();\n\n CheapEval cev;\n static constexpr array DIRS = {'F','B','L','R'};\n\n auto timeStart = chrono::high_resolution_clock::now();\n const double TL = 1.95; // seconds, safety under 2.0\n\n for (int t = 1; t <= 100; t++) {\n int p;\n cin >> p;\n\n // place current candy\n cur.placeByP(p, (uint8_t)f[t]);\n\n // AtCoder note: \"nothing happens at 100th tilt\" but outputting is safe.\n // We still decide something (cheap).\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - timeStart).count();\n double remaining = max(0.0, TL - elapsed);\n int stepsLeft = max(1, 101 - t);\n\n // allocate time for this move\n double alloc = remaining * 0.90 / stepsLeft;\n // clamp: avoid too tiny / too huge allocations\n alloc = min(alloc, 0.060);\n alloc = max(alloc, 0.001);\n\n auto deadline = now + chrono::duration(alloc);\n\n // precompute candidate next states\n array cand;\n array baseH{};\n for (int i = 0; i < 4; i++) {\n cand[i] = cur.afterTilt(DIRS[i]);\n baseH[i] = cev(cand[i]);\n }\n\n // If last move, no future, just maximize immediate cheap heuristic + final CC (same)\n if (t == 100) {\n int bestI = 0;\n double bestScore = -1e100;\n for (int i = 0; i < 4; i++) {\n // final CC exact (cheap enough once)\n int cc = finalComponentSumSq(cand[i]);\n double score = cc * 1.0 + 0.2 * baseH[i];\n if (score > bestScore) bestScore = score, bestI = i;\n }\n char out = DIRS[bestI];\n cout << out << \"\\n\" << flush;\n cur = cand[bestI];\n continue;\n }\n\n // Monte Carlo evaluation\n array sum{};\n array cnt{};\n\n // Always do at least 1 rollout per action (if we have time)\n int roundRobin = 0;\n while (chrono::high_resolution_clock::now() < deadline) {\n int i = roundRobin & 3;\n roundRobin++;\n\n // rollout from cand[i], next step is t+1\n int res = rollout(cand[i], t + 1, f, rng, cev);\n sum[i] += res;\n cnt[i] += 1;\n }\n\n // select best action by mean rollout + small immediate heuristic bias\n int bestI = 0;\n double bestScore = -1e100;\n for (int i = 0; i < 4; i++) {\n double mean = (cnt[i] ? (double)sum[i] / cnt[i] : -1e100);\n // immediate bias helps when rollouts are few\n double score = mean + 1.5 * baseH[i];\n if (score > bestScore) bestScore = score, bestI = i;\n }\n\n char out = DIRS[bestI];\n cout << out << \"\\n\" << flush;\n\n // apply chosen tilt to the real current state\n cur = cand[bestI];\n }\n\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nstruct Adj100 {\n // Enough for N<=100 => 2*64 bits\n array w{};\n};\n\nstatic inline void set_edge(vector& adj, int u, int v) {\n adj[u].w[v >> 6] |= 1ULL << (v & 63);\n adj[v].w[u >> 6] |= 1ULL << (u & 63);\n}\nstatic inline bool has_edge(const vector& adj, int u, int v) {\n return (adj[u].w[v >> 6] >> (v & 63)) & 1ULL;\n}\nstatic inline int popcnt2(const array& a) {\n return __builtin_popcountll(a[0]) + __builtin_popcountll(a[1]);\n}\nstatic inline int popcnt_and2(const array& a, const array& b) {\n return __builtin_popcountll(a[0] & b[0]) + __builtin_popcountll(a[1] & b[1]);\n}\n\nstruct Proto {\n vector mu_sorted_deg; // size N\n double Em = 0.0; // expected noisy edge count\n double Etri = 0.0; // expected noisy triangle count\n double VarTri = 1.0; // rough variance for normalization\n};\n\nstruct AnalyzedCounts {\n long long m = 0;\n long long tri = 0;\n vector deg;\n};\n\n// Compute degrees, edge count, triangle count from adjacency (undirected, simple)\nstatic AnalyzedCounts analyze_observed(const vector& adj, int N) {\n AnalyzedCounts res;\n res.deg.assign(N, 0);\n\n long long sum_deg = 0;\n for (int i = 0; i < N; i++) {\n int d = popcnt2(adj[i].w);\n res.deg[i] = d;\n sum_deg += d;\n }\n res.m = sum_deg / 2;\n\n long long sumCommon = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (has_edge(adj, i, j)) {\n sumCommon += popcnt_and2(adj[i].w, adj[j].w);\n }\n }\n }\n res.tri = sumCommon / 3;\n return res;\n}\n\n// Precompute c0..c3 for triples by number of original edges, then expected triangles after noise.\nstatic void compute_triple_edge_histogram(\n const vector& adj, int N,\n long long &c0, long long &c1, long long &c2, long long &c3\n) {\n vector deg(N);\n for (int i = 0; i < N; i++) deg[i] = popcnt2(adj[i].w);\n\n vector triEdgeSum(N, 0);\n long long sumCommon = 0;\n\n // For each edge (u,v): common neighbors count\n // sumCommon = 3*c3, and triEdgeSum[x] helps for c2.\n for (int u = 0; u < N; u++) {\n for (int v = u + 1; v < N; v++) {\n if (!has_edge(adj, u, v)) continue;\n int common = popcnt_and2(adj[u].w, adj[v].w);\n sumCommon += common;\n triEdgeSum[u] += common;\n triEdgeSum[v] += common;\n }\n }\n c3 = sumCommon / 3;\n\n // triInc[v] = number of triangles incident to v\n vector triInc(N, 0);\n for (int v = 0; v < N; v++) triInc[v] = triEdgeSum[v] / 2;\n\n // c2: triples with exactly 2 edges (a wedge)\n c2 = 0;\n for (int v = 0; v < N; v++) {\n long long wedges = 1LL * deg[v] * (deg[v] - 1) / 2;\n c2 += (wedges - triInc[v]);\n }\n\n // c1: triples with exactly 1 edge\n // For each original edge (u,v), count w adjacent to neither u nor v:\n // count = (N-2) - |N(u)\\{v} \u222a N(v)\\{u}| = N - deg[u] - deg[v] + common_uv\n c1 = 0;\n for (int u = 0; u < N; u++) {\n for (int v = u + 1; v < N; v++) {\n if (!has_edge(adj, u, v)) continue;\n int common = popcnt_and2(adj[u].w, adj[v].w);\n c1 += (long long)N - deg[u] - deg[v] + common;\n }\n }\n\n long long totalTriples = 1LL * N * (N - 1) * (N - 2) / 6;\n c0 = totalTriples - c1 - c2 - c3;\n if (c0 < 0) c0 = 0; // guard for any accidental rounding issues\n}\n\nstatic vector build_graph(int N, int hubSize, const vector& smallSizes, int kMask) {\n vector adj(N);\n\n // group ranges\n int B = (int)smallSizes.size();\n vector start(B+1, 0);\n start[0] = hubSize;\n for (int i = 0; i < B; i++) start[i+1] = start[i] + smallSizes[i];\n // hub: [0, hubSize)\n // group i: [start[i], start[i+1])\n\n auto add_clique = [&](int L, int R) {\n for (int i = L; i < R; i++) {\n for (int j = i + 1; j < R; j++) set_edge(adj, i, j);\n }\n };\n\n // hub clique\n add_clique(0, hubSize);\n // small cliques\n for (int i = 0; i < B; i++) add_clique(start[i], start[i+1]);\n\n // connect hub <-> group i iff bit i is 1\n for (int i = 0; i < B; i++) {\n if (((kMask >> i) & 1) == 0) continue;\n for (int u = 0; u < hubSize; u++) {\n for (int v = start[i]; v < start[i+1]; v++) set_edge(adj, u, v);\n }\n }\n return adj;\n}\n\nstatic string adj_to_string(const vector& adj, int N) {\n string s;\n s.reserve((size_t)N * (N - 1) / 2);\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n s.push_back(has_edge(adj, i, j) ? '1' : '0');\n }\n }\n return s;\n}\n\nstatic vector string_to_adj(const string& s, int N) {\n vector adj(N);\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (s[idx++] == '1') set_edge(adj, i, j);\n }\n }\n return adj;\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 // Choose N by epsilon (tradeoff robustness vs 1/N)\n int N;\n if (eps <= 0.15) N = 60;\n else if (eps <= 0.25) N = 80;\n else N = 100;\n\n // Fixed 7 small groups; hub gets the remaining vertices.\n vector smallSizes = {3,4,5,6,7,8,9}; // sum=42\n int sumSmall = accumulate(smallSizes.begin(), smallSizes.end(), 0);\n int hubSize = N - sumSmall;\n if (hubSize < 4) {\n // Safety fallback (shouldn't happen with our N choices)\n N = 100;\n hubSize = N - sumSmall;\n }\n\n const int B = (int)smallSizes.size();\n // We use kMask = k (0..M-1). Since M<=100 and 2^7=128, it's enough.\n // If M was larger, we would need more bits/groups.\n\n // Precompute prototypes\n vector prot(M);\n\n // Common constants for scoring\n const double p1 = 1.0 - eps;\n const double p0 = eps;\n const double scale = 1.0 - 2.0 * eps; // difference between \"edge was 1\" and \"edge was 0\" expectations\n const double degOffset = eps * (N - 1);\n const double sigma2_deg = (N - 1) * eps * (1.0 - eps) + 1e-9;\n const double Tedges = 1.0 * N * (N - 1) / 2.0;\n const double var_m = Tedges * eps * (1.0 - eps) + 1e-9;\n\n // Output graphs\n cout << N << \"\\n\";\n for (int k = 0; k < M; k++) {\n auto G = build_graph(N, hubSize, smallSizes, k);\n\n // Build output string\n string out = adj_to_string(G, N);\n cout << out << \"\\n\";\n\n // Analyze prototype for decoding\n // Original degrees\n vector deg0(N, 0);\n for (int v = 0; v < N; v++) deg0[v] = popcnt2(G[v].w);\n\n // Expected noisy degrees then sorted\n vector mu(N);\n for (int v = 0; v < N; v++) mu[v] = degOffset + scale * deg0[v];\n sort(mu.begin(), mu.end());\n prot[k].mu_sorted_deg = move(mu);\n\n // Expected noisy edge count\n long long m0 = 0;\n for (int v = 0; v < N; v++) m0 += deg0[v];\n m0 /= 2;\n prot[k].Em = m0 * p1 + (Tedges - m0) * p0;\n\n // Expected noisy triangle count (via c0..c3)\n long long c0, c1, c2, c3;\n compute_triple_edge_histogram(G, N, c0, c1, c2, c3);\n const double eTri =\n c3 * (p1*p1*p1) +\n c2 * (p1*p1*p0) +\n c1 * (p1*p0*p0) +\n c0 * (p0*p0*p0);\n prot[k].Etri = eTri;\n\n // Rough variance for normalization\n double totalTriples = 1.0 * N * (N - 1) * (N - 2) / 6.0;\n double pbar = (totalTriples > 0 ? eTri / totalTriples : 0.0);\n pbar = min(1.0, max(0.0, pbar));\n prot[k].VarTri = totalTriples * pbar * (1.0 - pbar) + 1.0; // +1 to avoid div0\n }\n cout.flush();\n\n // Answer queries\n for (int q = 0; q < 100; q++) {\n string hs;\n cin >> hs;\n if (!cin) break;\n\n auto H = string_to_adj(hs, N);\n auto obs = analyze_observed(H, N);\n\n vector degSorted = obs.deg;\n sort(degSorted.begin(), degSorted.end());\n\n int best = 0;\n double bestScore = 1e300;\n\n for (int k = 0; k < M; k++) {\n // Degree SSE vs expected sorted degrees\n const auto &mu = prot[k].mu_sorted_deg;\n double sse = 0.0;\n for (int i = 0; i < N; i++) {\n double diff = (double)degSorted[i] - mu[i];\n sse += diff * diff;\n }\n double z_deg = sse / (sigma2_deg * N);\n\n // Edge count term\n double dm = (double)obs.m - prot[k].Em;\n double z_m = (dm * dm) / var_m;\n\n // Triangle count term\n double dt = (double)obs.tri - prot[k].Etri;\n double z_t = (dt * dt) / prot[k].VarTri;\n\n // Weights (tuned mildly; degrees dominate, triangles assist)\n double score = z_deg + 0.30 * z_m + 0.10 * z_t;\n\n if (score < bestScore) {\n bestScore = score;\n best = k;\n }\n }\n\n cout << best << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n int w;\n};\n\nstatic inline long long sqll(long long x) { return x * x; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n\n vector edges(M);\n vector>> g(N); // (to, edgeId)\n vector> gw(N); // parallel weights\n g.assign(N, {});\n gw.assign(N, {});\n\n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n edges[i] = {u, v, w};\n g[u].push_back({v, i});\n gw[u].push_back(w);\n g[v].push_back({u, i});\n gw[v].push_back(w);\n }\n // consume coordinates\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937_64 rng(seed);\n\n const long long INF = (1LL<<62);\n\n // --- 1) Edge importance estimation by sampled Dijkstra + SPT subtree contributions ---\n int S = min(36, N); // a bit smaller to leave time for replacement-path Dijkstra\n vector sources(N);\n iota(sources.begin(), sources.end(), 0);\n shuffle(sources.begin(), sources.end(), rng);\n sources.resize(S);\n\n vector importance(M, 0);\n vector dist(N);\n vector parentV(N), parentE(N);\n vector order(N);\n vector subtree(N);\n\n for (int si = 0; si < S; si++) {\n int s = sources[si];\n fill(dist.begin(), dist.end(), INF);\n fill(parentV.begin(), parentV.end(), -1);\n fill(parentE.begin(), parentE.end(), -1);\n\n using P = pair;\n priority_queue, greater

> pq;\n dist[s] = 0;\n pq.push({0, s});\n\n while (!pq.empty()) {\n auto [dcur, v] = pq.top();\n pq.pop();\n if (dcur != dist[v]) continue;\n for (int idx = 0; idx < (int)g[v].size(); idx++) {\n auto [to, eid] = g[v][idx];\n long long w = gw[v][idx];\n long long nd = dcur + w;\n if (nd < dist[to]) {\n dist[to] = nd;\n parentV[to] = v;\n parentE[to] = eid;\n pq.push({nd, to});\n }\n }\n }\n\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int a, int b){\n return dist[a] > dist[b];\n });\n\n fill(subtree.begin(), subtree.end(), 1);\n for (int v : order) {\n int p = parentV[v];\n if (p != -1) subtree[p] += subtree[v];\n }\n\n for (int v = 0; v < N; v++) {\n if (v == s) continue;\n int eid = parentE[v];\n if (eid < 0) continue;\n long long sz = subtree[v];\n importance[eid] += sz * (long long)(N - sz);\n }\n }\n\n long long totalImp = 0;\n for (auto x : importance) totalImp += x;\n long double impScale = (M > 0 ? (long double)totalImp / (long double)M : 1.0L);\n if (impScale < 1.0L) impScale = 1.0L;\n\n // --- 2) Build \"conflict edges\" using replacement paths for important edges ---\n // conf[e] : list of (otherEdge, weight)\n vector>> conf(M);\n\n auto add_conf = [&](int a, int b, int w){\n if (a == b) return;\n // avoid duplicates by linear scan (lists are kept small)\n for (auto &p : conf[a]) if (p.first == b) { p.second = max(p.second, w); return; }\n conf[a].push_back({b, w});\n };\n\n // order edges by importance\n vector eorder(M);\n iota(eorder.begin(), eorder.end(), 0);\n sort(eorder.begin(), eorder.end(), [&](int a, int b){\n if (importance[a] != importance[b]) return importance[a] > importance[b];\n return edges[a].w > edges[b].w;\n });\n\n int T = min(M, 650); // number of edges to analyze for replacement paths\n int L = 8; // how many \"strong\" edges on the replacement path to conflict with\n\n // Dijkstra that forbids exactly one edge; early exit when reaching target.\n vector dist2(N);\n vector parV2(N), parE2(N);\n\n auto replacement_path_edges = [&](int s, int t, int bannedEid) -> pair> {\n fill(dist2.begin(), dist2.end(), INF);\n fill(parV2.begin(), parV2.end(), -1);\n fill(parE2.begin(), parE2.end(), -1);\n\n using P = pair;\n priority_queue, greater

> pq;\n dist2[s] = 0;\n pq.push({0, s});\n while (!pq.empty()) {\n auto [dcur, v] = pq.top();\n pq.pop();\n if (dcur != dist2[v]) continue;\n if (v == t) break;\n for (int idx = 0; idx < (int)g[v].size(); idx++) {\n auto [to, eid] = g[v][idx];\n if (eid == bannedEid) continue;\n long long w = gw[v][idx];\n long long nd = dcur + w;\n if (nd < dist2[to]) {\n dist2[to] = nd;\n parV2[to] = v;\n parE2[to] = eid;\n pq.push({nd, to});\n }\n }\n }\n if (dist2[t] >= INF/4) return {INF, {}};\n\n vector pathE;\n int cur = t;\n while (cur != s) {\n int pe = parE2[cur];\n if (pe < 0) break; // safety\n pathE.push_back(pe);\n cur = parV2[cur];\n }\n // pathE is edges from t->s (reverse order), but order doesn't matter here\n return {dist2[t], pathE};\n };\n\n for (int idx = 0; idx < T; idx++) {\n int e = eorder[idx];\n int u = edges[e].u, v = edges[e].v;\n\n auto [repDist, pathE] = replacement_path_edges(u, v, e);\n if (pathE.empty() || repDist >= INF/4) continue;\n\n // pick top-L edges on the replacement path by importance\n sort(pathE.begin(), pathE.end());\n pathE.erase(unique(pathE.begin(), pathE.end()), pathE.end());\n pathE.erase(remove(pathE.begin(), pathE.end(), e), pathE.end());\n if (pathE.empty()) continue;\n\n sort(pathE.begin(), pathE.end(), [&](int a, int b){\n return importance[a] > importance[b];\n });\n if ((int)pathE.size() > L) pathE.resize(L);\n\n // conflict weight: stronger for more important edges and larger replacement stretch\n long double stretch = (long double)repDist / (long double)max(1, edges[e].w);\n if (stretch > 10.0L) stretch = 10.0L;\n\n int base = (int)llround(50.0L * (long double)importance[e] / impScale); // around 0..100+\n base = max(5, min(base, 400));\n int wconf = (int)llround((long double)base * stretch);\n wconf = max(5, min(wconf, 1500));\n\n for (int f : pathE) {\n add_conf(e, f, wconf);\n add_conf(f, e, wconf);\n }\n }\n\n // --- 3) Balanced targets per day ---\n vector target(D, M / D);\n for (int d = 0; d < (M % D); d++) target[d]++;\n\n // --- 4) Greedy initial assignment with conflict-aware cost ---\n vector dayOfEdge(M, -1);\n vector> edgesInDay(D);\n for (int d = 0; d < D; d++) edgesInDay[d].reserve(target[d]);\n\n vector cnt(D, 0);\n vector daySumImp(D, 0);\n\n // incident counts per (day, vertex), and squared-sum penalty per day\n vector> inc(D, vector(N, 0));\n vector dayVertexPenalty(D, 0); // sum_v inc^2\n\n auto deltaAddEdgeVP = [&](int d, int u, int v) -> long long {\n long long delta = 0;\n long long a = inc[d][u], b = a + 1;\n delta += b*b - a*a;\n a = inc[d][v], b = a + 1;\n delta += b*b - a*a;\n if (u == v) delta -= 1;\n return delta;\n };\n\n auto applyAddEdge = [&](int d, int eid) {\n int u = edges[eid].u, v = edges[eid].v;\n {\n long long a = inc[d][u];\n long long b = a + 1;\n dayVertexPenalty[d] += b*b - a*a;\n inc[d][u] = (int16_t)b;\n }\n {\n long long a = inc[d][v];\n long long b = a + 1;\n dayVertexPenalty[d] += b*b - a*a;\n inc[d][v] = (int16_t)b;\n }\n if (u == v) dayVertexPenalty[d] -= 1;\n daySumImp[d] += importance[eid];\n dayOfEdge[eid] = d;\n edgesInDay[d].push_back(eid);\n cnt[d]++;\n };\n\n auto conflictCostIfPut = [&](int eid, int d) -> long long {\n long long s = 0;\n for (auto [f, w] : conf[eid]) {\n int df = dayOfEdge[f];\n if (df == d) s += w;\n }\n return s;\n };\n\n const long double alphaVP = 0.7L * impScale;\n const long double betaCnt = 0.02L * impScale;\n // during greedy, conflict should matter but not dominate\n const long double alphaConfGreedy = (long double)(impScale * 0.05L);\n\n for (int eid : eorder) {\n int u = edges[eid].u, v = edges[eid].v;\n int bestD = -1;\n long double bestCost = numeric_limits::infinity();\n\n for (int d = 0; d < D; d++) {\n if (cnt[d] >= target[d]) continue;\n long long dvp = deltaAddEdgeVP(d, u, v);\n long long cconf = conflictCostIfPut(eid, d);\n long double cost = (long double)daySumImp[d]\n + alphaVP * (long double)dvp\n + betaCnt * (long double)cnt[d]\n + alphaConfGreedy * (long double)cconf;\n if (cost < bestCost) {\n bestCost = cost;\n bestD = d;\n }\n }\n if (bestD < 0) bestD = 0;\n applyAddEdge(bestD, eid);\n }\n\n // positions for O(1) swap updates\n vector posInDay(M, -1);\n for (int d = 0; d < D; d++) {\n for (int i = 0; i < (int)edgesInDay[d].size(); i++) posInDay[edgesInDay[d][i]] = i;\n }\n\n // --- 5) SA with swaps, objective includes conflict penalty ---\n auto makeChanges = [&](int eidRemove, int eidAdd) {\n array vs = {edges[eidRemove].u, edges[eidRemove].v, edges[eidAdd].u, edges[eidAdd].v};\n array ds = {-1, -1, +1, +1};\n vector> tmp;\n tmp.reserve(4);\n for (int i = 0; i < 4; i++) {\n int v = vs[i], del = ds[i];\n bool found = false;\n for (auto &p : tmp) if (p.first == v) { p.second += del; found = true; break; }\n if (!found) tmp.push_back({v, del});\n }\n vector> ch;\n ch.reserve(tmp.size());\n for (auto &p : tmp) if (p.second != 0) ch.push_back(p);\n return ch;\n };\n\n auto deltaVPForDay = [&](int d, const vector>& changes) -> long long {\n long long delta = 0;\n for (auto [v, del] : changes) {\n long long a = inc[d][v];\n long long b = a + del;\n delta += b*b - a*a;\n }\n return delta;\n };\n\n auto applyVPChanges = [&](int d, const vector>& changes) {\n long long delta = 0;\n for (auto [v, del] : changes) {\n long long a = inc[d][v];\n long long b = a + del;\n delta += b*b - a*a;\n inc[d][v] = (int16_t)b;\n }\n dayVertexPenalty[d] += delta;\n };\n\n // total conflict cost = sum over undirected pairs (count once)\n // We'll maintain it, and compute delta for swaps carefully to avoid double counting for (e1,e2).\n long long totalConf = 0;\n // initialize by summing only (eid < f) from eid's list to count each pair once\n for (int e = 0; e < M; e++) {\n int de = dayOfEdge[e];\n for (auto [f, w] : conf[e]) {\n if (e < f && dayOfEdge[f] == de) totalConf += w;\n }\n }\n\n long long sumSqImp = 0;\n long long totalVP = 0;\n for (int d = 0; d < D; d++) {\n sumSqImp += sqll(daySumImp[d]);\n totalVP += dayVertexPenalty[d];\n }\n\n long double coeffVP = (long double)(impScale * impScale * 0.5L);\n long double coeffConf = (long double)(impScale * impScale * 0.02L);\n\n auto objective = [&]() -> long double {\n return (long double)sumSqImp + coeffVP * (long double)totalVP + coeffConf * (long double)totalConf;\n };\n\n auto deltaConfEdgeMove = [&](int e, int oldDay, int newDay, int ignoreNeighbor) -> long long {\n long long delta = 0;\n for (auto [f, w] : conf[e]) {\n if (f == ignoreNeighbor) continue;\n int df = dayOfEdge[f];\n // count pair once: (min, max)\n if (e < f) {\n bool oldSame = (df == oldDay);\n bool newSame = (df == newDay);\n delta += (long long)w * ((long long)newSame - (long long)oldSame);\n } else {\n // pair is counted when f < e, so handle it here too:\n // We can still update totalConf correctly by checking the same condition but using \"pair counted at min id\",\n // meaning this pair contributes regardless of which endpoint changed.\n bool oldSame = (df == oldDay);\n bool newSame = (df == newDay);\n delta += (long long)w * ((long long)newSame - (long long)oldSame);\n }\n }\n // IMPORTANT: the above would double-count pairs because conf is symmetric and we are not restricting to min(e,f).\n // Fix: only update pairs where e is the smaller id (so each pair updated from the smaller endpoint only),\n // BUT then we'd need access when e is larger. Instead, we do symmetric update but only for edges that move.\n // For correctness, we must ensure each affected pair is updated exactly once.\n // We handle this by restricting to e < f here, and also scanning the other endpoint's list when it moves.\n // Therefore, implement with e < f restriction.\n return 0;\n };\n\n // Correct delta computation: update pairs from the smaller endpoint only.\n auto deltaConfMoveSmallerOnly = [&](int e, int oldDay, int newDay, int ignoreNeighbor) -> long long {\n long long delta = 0;\n for (auto [f, w] : conf[e]) {\n if (f == ignoreNeighbor) continue;\n if (e < f) {\n int df = dayOfEdge[f];\n bool oldSame = (df == oldDay);\n bool newSame = (df == newDay);\n delta += (long long)w * ((long long)newSame - (long long)oldSame);\n }\n }\n return delta;\n };\n // For pairs where e is larger, the smaller endpoint is f, so that pair will be updated when f moves (if it moves).\n // In a swap move, both endpoints move, so all affected pairs are covered by scanning both moved edges\n // (excluding the pair (e1,e2) which we handle separately once).\n\n auto pairWeight = [&](int a, int b) -> int {\n // find weight in conf[a] (small)\n for (auto [f, w] : conf[a]) if (f == b) return w;\n return 0;\n };\n\n long double curObj = objective();\n\n auto startTime = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 5.85;\n uniform_real_distribution uni01(0.0, 1.0);\n\n long double T0 = max((long double)1.0, curObj * 1e-4L);\n long double T1 = max((long double)1e-3, curObj * 1e-7L);\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - startTime).count();\n if (elapsed > TIME_LIMIT) break;\n double tt = elapsed / TIME_LIMIT;\n long double T = T0 * pow((double)(T1 / T0), tt);\n\n int a = (int)(rng() % D);\n int b = (int)(rng() % (D - 1));\n if (b >= a) b++;\n if (edgesInDay[a].empty() || edgesInDay[b].empty()) continue;\n\n int ia = (int)(rng() % edgesInDay[a].size());\n int ib = (int)(rng() % edgesInDay[b].size());\n int e1 = edgesInDay[a][ia];\n int e2 = edgesInDay[b][ib];\n if (e1 == e2) continue;\n\n long long p1 = importance[e1], p2 = importance[e2];\n long long A = daySumImp[a], B = daySumImp[b];\n\n long long A2 = A - p1 + p2;\n long long B2 = B - p2 + p1;\n long long deltaSumSq = sqll(A2) + sqll(B2) - sqll(A) - sqll(B);\n\n auto chA = makeChanges(e1, e2); // day a: remove e1 add e2\n auto chB = makeChanges(e2, e1); // day b: remove e2 add e1\n long long deltaVP = deltaVPForDay(a, chA) + deltaVPForDay(b, chB);\n\n // conflict delta: update affected pairs from the smaller endpoint only\n // We must compute delta using the pre-move dayOfEdge.\n long long deltaConf = 0;\n\n // handle pairs involving e1 (as smaller endpoint)\n deltaConf += deltaConfMoveSmallerOnly(e1, a, b, e2);\n // handle pairs involving e2 (as smaller endpoint)\n deltaConf += deltaConfMoveSmallerOnly(e2, b, a, e1);\n\n // handle the pair (e1,e2) exactly once, from smaller endpoint\n int lo = min(e1, e2), hi = max(e1, e2);\n int w12 = pairWeight(lo, hi);\n if (w12 > 0) {\n bool oldSame = (dayOfEdge[lo] == dayOfEdge[hi]); // currently false (different days)\n // after swap, they also remain in different days, so same=false still.\n // However, if a==b (not), so no change.\n // Thus delta is 0 always. Keep logic for safety if extended moves are added.\n bool newSame = false;\n deltaConf += (long long)w12 * ((long long)newSame - (long long)oldSame);\n }\n\n long double deltaObj = (long double)deltaSumSq\n + coeffVP * (long double)deltaVP\n + coeffConf * (long double)deltaConf;\n\n bool accept = false;\n if (deltaObj <= 0) accept = true;\n else {\n long double prob = expl(-(double)(deltaObj / T));\n if (uni01(rng) < (double)prob) accept = true;\n }\n\n if (accept) {\n sumSqImp += deltaSumSq;\n daySumImp[a] = A2;\n daySumImp[b] = B2;\n\n totalVP += deltaVP;\n applyVPChanges(a, chA);\n applyVPChanges(b, chB);\n\n totalConf += deltaConf;\n\n // swap in vectors\n edgesInDay[a][ia] = e2;\n edgesInDay[b][ib] = e1;\n posInDay[e2] = ia;\n posInDay[e1] = ib;\n\n dayOfEdge[e1] = b;\n dayOfEdge[e2] = a;\n\n curObj += deltaObj;\n }\n }\n\n // output 1..D\n for (int i = 0; i < M; i++) {\n if (i) cout << ' ';\n cout << (dayOfEdge[i] + 1);\n }\n cout << '\\n';\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstruct Stick {\n int axis; // 0=x,1=y,2=z\n int x, y, z; // start coordinate (minimum along axis)\n int cur; // consumed length from the start\n int rem; // remaining length\n};\n\nstruct Candidate {\n long double obj = (1e100L);\n int n = 0;\n vector b1, b2;\n};\n\nstatic inline int idx3(int D, int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\nvector build_occ_full(int D, const vector& f, const vector& r) {\n vector occ(D*D*D, 0);\n for (int z=0; z build_occ_min(int D, const vector& f, const vector& r) {\n vector occ(D*D*D, 0);\n for (int z=0; z X, Y;\n for (int x=0; x= cy) {\n for (int t=0; t build_occ_star(int D, const vector& f, const vector& r) {\n // pick global hubs that appear in many z-rows\n int bestX = 0, bestY = 0;\n int bestXcnt = -1, bestYcnt = -1;\n for (int x=0; x bestXcnt) bestXcnt = c, bestX = x;\n }\n for (int y=0; y bestYcnt) bestYcnt = c, bestY = y;\n }\n\n vector occ(D*D*D, 0);\n for (int z=0; z X, Y;\n for (int x=0; x build_occ(int D, int strategy, const vector& f, const vector& r) {\n // 0:FULL, 1:MIN, 2:STAR\n if (strategy == 0) return build_occ_full(D,f,r);\n if (strategy == 1) return build_occ_min(D,f,r);\n return build_occ_star(D,f,r);\n}\n\nvector build_sticks(int D, const vector& occ, int axis) {\n vector sticks;\n if (axis == 0) { // x\n for (int y=0; y& sticks, int L) {\n int bestDiv = -1, best = -1;\n int bestDivLen = -1, bestLen = -1;\n for (int i=0;i<(int)sticks.size();i++) {\n const auto &s = sticks[i];\n if (s.rem < L) continue;\n if (s.rem % L == 0) {\n if (s.rem > bestDivLen) bestDivLen = s.rem, bestDiv = i;\n } else {\n if (s.rem > bestLen) bestLen = s.rem, best = i;\n }\n }\n if (bestDiv != -1) return bestDiv;\n return best;\n}\n\nvoid cut_piece(int D, Stick& s, int L, vector& b, int blockId) {\n // assign L cells from the front\n for (int t=0; t& sticks) {\n long long v=0;\n for (auto &s: sticks) v += s.rem;\n return v;\n}\n\nCandidate simulate_candidate(int D,\n const vector& occ1, const vector& occ2,\n int axis1, int axis2) {\n Candidate cand;\n cand.b1.assign(D*D*D, 0);\n cand.b2.assign(D*D*D, 0);\n\n vector s1 = build_sticks(D, occ1, axis1);\n vector s2 = build_sticks(D, occ2, axis2);\n\n int blockId = 0;\n long double sharedPenalty = 0.0L;\n\n for (int L=D; L>=1; L--) {\n while (true) {\n int i1 = find_best_stick(s1, L);\n int i2 = find_best_stick(s2, L);\n if (i1 < 0 || i2 < 0) break;\n // cut shared piece\n blockId++;\n cut_piece(D, s1[i1], L, cand.b1, blockId);\n cut_piece(D, s2[i2], L, cand.b2, blockId);\n sharedPenalty += 1.0L / (long double)L;\n }\n }\n\n // leftover exclusive sticks\n for (auto &s: s1) {\n if (s.rem <= 0) continue;\n blockId++;\n cut_piece(D, s, s.rem, cand.b1, blockId);\n }\n for (auto &s: s2) {\n if (s.rem <= 0) continue;\n blockId++;\n cut_piece(D, s, s.rem, cand.b2, blockId);\n }\n\n // objective = (r1+r2) + sum_{shared} 1/v\n // r1+r2 = volume of blocks used only in one object = total leftover volume after sharing\n // After our process, shared cuts consume equal volume from both; leftovers are exclusive.\n // We can compute exclusives as number of cells with id==0 (but we filled sticks only).\n // Easier: exclusive volume = |vol(occ1)-vol(occ2)| if everything in smaller got shared.\n // Our algorithm shares all possible including L=1, so yes.\n long long V1=0, V2=0;\n for (char c: occ1) V1 += c;\n for (char c: occ2) V2 += c;\n long double exclusive = (long double) llabs(V1 - V2);\n\n cand.n = blockId;\n cand.obj = exclusive + sharedPenalty;\n return cand;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D;\n cin >> D;\n vector f(2*D), r(2*D);\n vector> F(2, vector(D)), R(2, vector(D));\n for (int i=0;i<2;i++) {\n for (int z=0; z> F[i][z];\n for (int z=0; z> R[i][z];\n }\n\n vector strategies = {0,1,2}; // FULL, MIN, STAR\n vector axes = {0,1,2}; // x,y,z\n\n Candidate best;\n\n // Prebuild occ for each strategy and object\n vector>> occs(2, vector>(3));\n for (int i=0;i<2;i++) {\n for (int s: strategies) {\n occs[i][s] = build_occ(D, s, F[i], R[i]);\n }\n }\n\n for (int s1: strategies) for (int s2: strategies) {\n const auto &occ1 = occs[0][s1];\n const auto &occ2 = occs[1][s2];\n for (int a1: axes) for (int a2: axes) {\n Candidate cand = simulate_candidate(D, occ1, occ2, a1, a2);\n if (cand.obj + 1e-18L < best.obj) {\n best = std::move(cand);\n }\n }\n }\n\n cout << best.n << \"\\n\";\n // output b1, b2 in order (x*D^2 + y*D + z)\n for (int i=0; i\nusing namespace std;\n\nstatic const long long INFLL = (1LL << 60);\n\nstruct Edge {\n int u, v;\n long long w;\n};\n\nstruct DSU {\n int n;\n vector p, r;\n DSU(int n=0): n(n), p(n,-1), r(n,0) {\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){ return p[a]==a? a : p[a]=find(p[a]); }\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a]0 && (r-1)*(r-1) >= x) --r;\n if (r > 5000) return 5001;\n return (int)r;\n}\n\nstruct EvalResult {\n bool valid = false;\n long long S = INFLL;\n vector P; // N\n vector B; // M\n vector cnt; // N, #assigned residents (useful for pruning order)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K;\n cin >> N >> M >> K;\n\n vector x(N), y(N);\n for (int i = 0; i < N; i++) cin >> x[i] >> y[i];\n\n vector edges(M);\n vector> dist(N, vector(N, INFLL));\n vector> nxt(N, vector(N, -1));\n vector> edgeId(N, vector(N, -1));\n\n for (int i = 0; i < N; i++) {\n dist[i][i] = 0;\n nxt[i][i] = i;\n }\n\n for (int j = 0; j < M; j++) {\n int u, v;\n long long w;\n cin >> u >> v >> w;\n --u; --v;\n edges[j] = {u, v, w};\n if (w < dist[u][v]) {\n dist[u][v] = dist[v][u] = w;\n nxt[u][v] = v;\n nxt[v][u] = u;\n edgeId[u][v] = edgeId[v][u] = j;\n }\n }\n\n vector a(K), b(K);\n for (int k = 0; k < K; k++) cin >> a[k] >> b[k];\n\n // resident -> station distance (ceil euclid), clipped to 5001\n vector> d(K);\n for (int k = 0; k < K; k++) {\n for (int i = 0; i < N; i++) {\n long long dx = (long long)a[k] - x[i];\n long long dy = (long long)b[k] - y[i];\n long long dsq = dx*dx + dy*dy;\n int cd = ceil_sqrt_ll(dsq);\n if (cd > 5000) cd = 5001;\n d[k][i] = (uint16_t)cd;\n }\n }\n\n // Floyd-Warshall + next matrix\n for (int k = 0; k < N; k++) {\n for (int i = 0; i < N; i++) if (dist[i][k] < INFLL) {\n for (int j = 0; j < N; j++) if (dist[k][j] < INFLL) {\n long long nd = dist[i][k] + dist[k][j];\n if (nd < dist[i][j]) {\n dist[i][j] = nd;\n nxt[i][j] = nxt[i][k];\n }\n }\n }\n }\n vector distRoot(N);\n for (int i = 0; i < N; i++) distRoot[i] = dist[0][i];\n\n auto reconstruct_path_edges = [&](int s, int t, vector& mark) {\n int cur = s;\n while (cur != t) {\n int nx = nxt[cur][t];\n if (nx < 0) return;\n int eid = edgeId[cur][nx];\n if (eid >= 0) mark[eid] = 1;\n cur = nx;\n }\n };\n\n // Build cable set from terminal stations and radii, with cycle removal + leaf pruning.\n auto build_cables = [&](const vector& P) -> pair, long long> {\n vector terminal(N, 0);\n terminal[0] = 1;\n vector terms;\n terms.reserve(N);\n terms.push_back(0);\n for (int i = 1; i < N; i++) {\n if (P[i] > 0) {\n terminal[i] = 1;\n terms.push_back(i);\n }\n }\n\n // Prim on metric closure of terminals\n int T = (int)terms.size();\n vector best(T, INFLL);\n vector parent(T, -1);\n vector used(T, 0);\n best[0] = 0;\n\n for (int it = 0; it < T; it++) {\n int v = -1;\n for (int i = 0; i < T; i++) if (!used[i]) {\n if (v < 0 || best[i] < best[v]) v = i;\n }\n if (v < 0 || best[v] >= INFLL/2) {\n // disconnected (shouldn't happen)\n return {vector(M, 0), INFLL};\n }\n used[v] = 1;\n int vv = terms[v];\n for (int i = 0; i < T; i++) if (!used[i]) {\n int uu = terms[i];\n long long w = dist[vv][uu];\n if (w < best[i]) {\n best[i] = w;\n parent[i] = v;\n }\n }\n }\n\n // Union of shortest paths\n vector unionMark(M, 0);\n for (int i = 1; i < T; i++) {\n int u = terms[i];\n int p = terms[parent[i]];\n reconstruct_path_edges(u, p, unionMark);\n }\n\n // Cycle removal: Kruskal on union edges (minimum forest for each component)\n vector unionEdges;\n unionEdges.reserve(M);\n for (int j = 0; j < M; j++) if (unionMark[j]) unionEdges.push_back(j);\n sort(unionEdges.begin(), unionEdges.end(), [&](int a, int b){\n return edges[a].w < edges[b].w;\n });\n\n DSU dsu(N);\n vector alive(M, 0);\n for (int id : unionEdges) {\n if (dsu.unite(edges[id].u, edges[id].v)) alive[id] = 1;\n }\n\n // Build adjacency for pruning\n vector>> g(N);\n vector deg(N, 0);\n for (int id = 0; id < M; id++) if (alive[id]) {\n int u = edges[id].u, v = edges[id].v;\n g[u].push_back({v, id});\n g[v].push_back({u, id});\n deg[u]++; deg[v]++;\n }\n\n // Prune non-terminal leaves (on the forest)\n deque q;\n vector inq(N, 0);\n for (int i = 0; i < N; i++) {\n if (!terminal[i] && deg[i] <= 1) { q.push_back(i); inq[i] = 1; }\n }\n\n auto remove_edge = [&](int v, int to, int eid) {\n if (!alive[eid]) return;\n alive[eid] = 0;\n deg[v]--;\n deg[to]--;\n if (!terminal[to] && deg[to] <= 1 && !inq[to]) { q.push_back(to); inq[to] = 1; }\n };\n\n while (!q.empty()) {\n int v = q.front(); q.pop_front();\n if (terminal[v]) continue;\n if (deg[v] != 1) continue;\n // find the only alive incident edge\n for (auto [to, eid] : g[v]) {\n if (alive[eid]) {\n remove_edge(v, to, eid);\n break;\n }\n }\n }\n\n // Keep only root component (just in case)\n vector vis(N, 0);\n deque bfs;\n vis[0] = 1;\n bfs.push_back(0);\n while (!bfs.empty()) {\n int v = bfs.front(); bfs.pop_front();\n for (auto [to, eid] : g[v]) {\n if (!alive[eid]) continue;\n if (!vis[to]) { vis[to] = 1; bfs.push_back(to); }\n }\n }\n for (int id = 0; id < M; id++) if (alive[id]) {\n if (!vis[edges[id].u] || !vis[edges[id].v]) alive[id] = 0;\n }\n\n long long edgeCost = 0;\n vector B(M, 0);\n for (int id = 0; id < M; id++) if (alive[id]) {\n B[id] = 1;\n edgeCost += edges[id].w;\n }\n return {B, edgeCost};\n };\n\n // Evaluate with greedy marginal assignment; take best among a few trials (different resident orders)\n auto evaluate = [&](const vector& U, int trials, std::mt19937& rng, bool shuffleOrders) -> EvalResult {\n EvalResult bestRes;\n bestRes.valid = false;\n bestRes.S = INFLL;\n\n vector order(K);\n iota(order.begin(), order.end(), 0);\n\n // Bias: avoid opening far stations (units are comparable: w up to ~5e7, P^2 up to 2.5e7)\n const double openGamma = 0.30;\n\n for (int t = 0; t < trials; t++) {\n if (t > 0 || shuffleOrders) {\n shuffle(order.begin(), order.end(), rng);\n }\n\n vector P(N, 0), cnt(N, 0);\n\n bool ok = true;\n for (int idx = 0; idx < K; idx++) {\n int k = order[idx];\n long long bestDelta = INFLL;\n int besti = -1;\n int bestNewP = 0;\n\n for (int i = 0; i < N; i++) if (U[i]) {\n int di = (int)d[k][i];\n if (di > 5000) continue;\n\n int pi = P[i];\n int newp = (pi >= di) ? pi : di;\n long long delta = 1LL*newp*newp - 1LL*pi*pi;\n\n // penalty if this assignment \"opens\" a new station (i!=0)\n if (i != 0 && pi == 0 && cnt[i] == 0) {\n delta += (long long) llround(openGamma * (long double)distRoot[i]);\n }\n\n if (delta < bestDelta ||\n (delta == bestDelta && newp < bestNewP) ||\n (delta == bestDelta && newp == bestNewP && di < (int)d[k][besti])) {\n bestDelta = delta;\n besti = i;\n bestNewP = newp;\n }\n }\n\n if (besti < 0) { ok = false; break; }\n P[besti] = bestNewP;\n cnt[besti]++;\n }\n if (!ok) continue;\n\n long long radCost = 0;\n for (int i = 0; i < N; i++) radCost += 1LL*P[i]*P[i];\n\n auto [B, edgeCost] = build_cables(P);\n if (edgeCost >= INFLL/2) continue;\n\n long long S = radCost + edgeCost;\n if (S < bestRes.S) {\n bestRes.valid = true;\n bestRes.S = S;\n bestRes.P = std::move(P);\n bestRes.B = std::move(B);\n bestRes.cnt = std::move(cnt);\n }\n }\n return bestRes;\n };\n\n auto t_start = chrono::steady_clock::now();\n auto elapsed_ms = [&]() -> long long {\n auto t_now = chrono::steady_clock::now();\n return chrono::duration_cast(t_now - t_start).count();\n };\n\n std::mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n EvalResult bestGlobal;\n bestGlobal.valid = false;\n bestGlobal.S = INFLL;\n\n int restarts = 2;\n for (int rep = 0; rep < restarts; rep++) {\n if (elapsed_ms() > 1850) break;\n\n vector U(N, 1);\n U[0] = 1;\n\n EvalResult cur = evaluate(U, /*trials=*/2, rng, /*shuffleOrders=*/false);\n if (!cur.valid) continue;\n\n // Light simulated annealing toggling stations\n // (mostly tries removals, sometimes adds back)\n const int SA_IT = 120;\n double T0 = 5e7, T1 = 1e6;\n for (int it = 0; it < SA_IT && elapsed_ms() < 1750; it++) {\n double tt = (double)it / max(1, SA_IT-1);\n double T = T0 * (1.0 - tt) + T1 * tt;\n\n int v = uniform_int_distribution(1, N-1)(rng);\n U[v] ^= 1;\n\n EvalResult nxt = evaluate(U, /*trials=*/1, rng, /*shuffleOrders=*/true);\n if (!nxt.valid) {\n U[v] ^= 1;\n continue;\n }\n\n long long diff = nxt.S - cur.S;\n bool accept = false;\n if (diff <= 0) accept = true;\n else {\n double prob = exp(-(double)diff / T);\n double r = uniform_real_distribution(0.0, 1.0)(rng);\n accept = (r < prob);\n }\n\n if (accept) cur = std::move(nxt);\n else U[v] ^= 1;\n }\n\n // Greedy improvement: repeatedly try removing low-usage stations\n bool improved = true;\n while (improved && elapsed_ms() < 1900) {\n improved = false;\n\n // Re-evaluate with slightly more trials for stability of cnt/P\n cur = evaluate(U, /*trials=*/2, rng, /*shuffleOrders=*/false);\n if (!cur.valid) break;\n\n vector cand;\n cand.reserve(N-1);\n for (int i = 1; i < N; i++) if (U[i]) cand.push_back(i);\n\n sort(cand.begin(), cand.end(), [&](int a, int b){\n // remove \"less useful\" first: small assigned count, small radius, far from root\n if (cur.cnt[a] != cur.cnt[b]) return cur.cnt[a] < cur.cnt[b];\n if (cur.P[a] != cur.P[b]) return cur.P[a] < cur.P[b];\n return distRoot[a] > distRoot[b];\n });\n\n for (int v : cand) {\n if (elapsed_ms() > 1900) break;\n U[v] = 0;\n EvalResult nxt = evaluate(U, /*trials=*/1, rng, /*shuffleOrders=*/true);\n if (nxt.valid && nxt.S < cur.S) {\n cur = std::move(nxt);\n improved = true;\n break; // first improvement, then recompute ordering\n } else {\n U[v] = 1;\n }\n }\n }\n\n if (cur.valid && cur.S < bestGlobal.S) bestGlobal = std::move(cur);\n }\n\n if (!bestGlobal.valid) {\n // Fallback: valid format\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << 0;\n }\n cout << \"\\n\";\n for (int j = 0; j < M; j++) {\n if (j) cout << ' ';\n cout << 0;\n }\n cout << \"\\n\";\n return 0;\n }\n\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << bestGlobal.P[i];\n }\n cout << \"\\n\";\n for (int j = 0; j < M; j++) {\n if (j) cout << ' ';\n cout << bestGlobal.B[j];\n }\n cout << \"\\n\";\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nstruct Op { int x1,y1,x2,y2; };\n\nstatic constexpr int N = 30;\nstatic constexpr int M = N*(N+1)/2;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector> b(N, vector(N, -1));\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) cin >> b[x][y];\n }\n\n // position of each value\n vector> pos(M);\n for (int x = 0; x < N; x++) for (int y = 0; y <= x; y++) pos[b[x][y]] = {x,y};\n\n vector ops;\n ops.reserve(10000);\n\n auto do_swap = [&](int x1,int y1,int x2,int y2){\n int v1 = b[x1][y1], v2 = b[x2][y2];\n swap(b[x1][y1], b[x2][y2]);\n pos[v1] = {x2,y2};\n pos[v2] = {x1,y1};\n ops.push_back({x1,y1,x2,y2});\n };\n\n auto can_swap_more = [&](){ return (int)ops.size() < 10000; };\n\n // Phase 1: bubble up smallest values (targeted sift-up)\n // Tune L: too large may add swaps; too small gives little benefit.\n const int L = 90;\n\n for (int v = 0; v < L && can_swap_more(); v++) {\n while (can_swap_more()) {\n auto [x,y] = pos[v];\n if (x == 0) break;\n\n // parents: (x-1,y-1) and (x-1,y)\n bool hasL = (y-1 >= 0);\n bool hasR = (y <= x-1);\n\n int bestPx=-1, bestPy=-1;\n int cur = b[x][y];\n\n auto consider_parent = [&](int px,int py){\n if (b[px][py] > cur) {\n if (bestPx == -1 || b[px][py] > b[bestPx][bestPy]) {\n bestPx = px; bestPy = py;\n }\n }\n };\n\n if (hasL) consider_parent(x-1, y-1);\n if (hasR) consider_parent(x-1, y);\n\n if (bestPx == -1) break; // already <= both parents\n do_swap(x,y,bestPx,bestPy);\n }\n }\n\n // Phase 2: standard Floyd heapify (bottom-up sift-down), guarantees E=0\n auto siftDown = [&](int sx, int sy){\n int x = sx, y = sy;\n while (can_swap_more() && x < N-1) {\n int lx = x+1, ly = y;\n int rx = x+1, ry = y+1;\n\n int bestx = x, besty = y;\n if (b[lx][ly] < b[bestx][besty]) { bestx = lx; besty = ly; }\n if (b[rx][ry] < b[bestx][besty]) { bestx = rx; besty = ry; }\n\n if (bestx == x && besty == y) break;\n do_swap(x,y,bestx,besty);\n x = bestx; y = besty;\n }\n };\n\n for (int x = N-2; x >= 0 && can_swap_more(); x--) {\n for (int y = 0; y <= x && can_swap_more(); y++) {\n siftDown(x,y);\n }\n }\n\n cout << ops.size() << \"\\n\";\n for (auto &op: ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nstatic constexpr int D = 9;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n uint32_t next_u32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n int next_int(int n) { return (int)(next_u32() % (uint32_t)n); }\n};\n\nstruct Cell { int r, c; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Din, N;\n cin >> Din >> N;\n int ent_r = 0, ent_c = (D - 1) / 2;\n\n bool obstacle[D][D]{};\n for (int k = 0; k < N; k++) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n }\n\n int M = D * D - 1 - N; // number of containers (labels 0..M-1)\n\n int dr[4] = {1,-1,0,0};\n int dc[4] = {0,0,1,-1};\n\n // Static BFS distance from entrance on obstacle grid.\n const int INF = 1e9;\n int dist0[D][D];\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) dist0[i][j] = INF;\n queue q;\n dist0[ent_r][ent_c] = 0;\n q.push({ent_r, ent_c});\n while (!q.empty()) {\n auto [r,c] = q.front(); q.pop();\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (dist0[nr][nc] != INF) continue;\n dist0[nr][nc] = dist0[r][c] + 1;\n q.push({nr,nc});\n }\n }\n\n // ========= Helper: articulation points on current empty graph =========\n auto compute_articulation = [&](const bool emptyCell[D][D]) {\n int id[D][D];\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) id[i][j] = -1;\n vector nodes;\n nodes.reserve(D*D);\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (obstacle[i][j]) continue;\n if (!emptyCell[i][j]) continue;\n id[i][j] = (int)nodes.size();\n nodes.push_back({i,j});\n }\n int V = (int)nodes.size();\n vector disc(V, 0), low(V, 0), parent(V, -1);\n vector isArt(V, 0);\n int timer = 0;\n\n int root = id[ent_r][ent_c];\n // If entrance isn't empty, something is inconsistent; return no-art to avoid crash.\n vector> art(D, vector(D, 0));\n if (root < 0) return art;\n\n function dfs = [&](int u) {\n disc[u] = low[u] = ++timer;\n int children = 0;\n auto [r,c] = nodes[u];\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n int v = id[nr][nc];\n if (v < 0) continue;\n if (!disc[v]) {\n parent[v] = u;\n children++;\n dfs(v);\n low[u] = min(low[u], low[v]);\n if (parent[u] == -1) {\n if (children > 1) isArt[u] = 1;\n } else {\n if (low[v] >= disc[u]) isArt[u] = 1;\n }\n } else if (v != parent[u]) {\n low[u] = min(low[u], disc[v]);\n }\n }\n };\n\n dfs(root);\n for (int u = 0; u < V; u++) {\n auto [r,c] = nodes[u];\n art[r][c] = isArt[u];\n }\n return art;\n };\n\n auto deg_empty = [&](const bool emptyCell[D][D], int r, int c) {\n int d = 0;\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (emptyCell[nr][nc]) d++;\n }\n return d;\n };\n\n // ========= Precompute peelIndex (topology-aware priority) =========\n // peelIndex = step at which the cell is removed in a \"safe fill\" simulation.\n int peelIndex[D][D];\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) peelIndex[i][j] = -1;\n\n {\n bool simEmpty[D][D];\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n simEmpty[i][j] = (!obstacle[i][j]);\n }\n // Entrance stays empty throughout simulation (we never \"remove\" it).\n int step = 0;\n while (step < M) {\n auto art = compute_articulation(simEmpty);\n\n Cell best{-1,-1};\n // Choose a removable non-articulation cell, prefer far and leaf-ish.\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (!simEmpty[i][j]) continue;\n if (obstacle[i][j]) continue;\n if (i == ent_r && j == ent_c) continue;\n if (art[i][j]) continue;\n\n if (best.r == -1) best = {i,j};\n else {\n int d1 = dist0[i][j], d2 = dist0[best.r][best.c];\n int g1 = deg_empty(simEmpty, i, j), g2 = deg_empty(simEmpty, best.r, best.c);\n // farthest first, then smaller degree first, then lex.\n if (d1 != d2) {\n if (d1 > d2) best = {i,j};\n } else if (g1 != g2) {\n if (g1 < g2) best = {i,j};\n } else {\n if (i < best.r || (i == best.r && j < best.c)) best = {i,j};\n }\n }\n }\n\n if (best.r == -1) {\n // Fallback: should be very rare. Remove any non-entrance empty.\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (!simEmpty[i][j]) continue;\n if (obstacle[i][j]) continue;\n if (i == ent_r && j == ent_c) continue;\n best = {i,j};\n break;\n }\n }\n\n peelIndex[best.r][best.c] = step;\n simEmpty[best.r][best.c] = false;\n step++;\n }\n }\n\n // ========= Online placement state =========\n bool emptyCell[D][D]; // true = empty/traversable\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) emptyCell[i][j] = (!obstacle[i][j]);\n\n int labelAt[D][D];\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) labelAt[i][j] = -1;\n\n XorShift rng;\n\n // ========= Placement phase =========\n for (int step = 0; step < M; step++) {\n int t;\n cin >> t;\n\n auto art = compute_articulation(emptyCell);\n\n // desired peel index: small label should be in the \"core\" (large peelIndex),\n // so desired = M-1-t.\n int desired = (M - 1 - t);\n\n Cell chosen{-1,-1};\n long long bestScore = (1LL<<60);\n\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (obstacle[i][j]) continue;\n if (!emptyCell[i][j]) continue;\n if (i == ent_r && j == ent_c) continue;\n if (art[i][j]) continue;\n\n int pi = peelIndex[i][j];\n if (pi < 0) continue;\n\n // Main term: match topology-aware peel index.\n // Secondary: keep flexibility (prefer smaller degree to fill leaves earlier).\n long long score = 100LL * llabs(pi - desired)\n + 5LL * deg_empty(emptyCell, i, j)\n + 1LL * dist0[i][j]; // mild tie-break\n\n // deterministic tie-break (but add tiny noise to diversify a bit)\n score = score * 4 + (rng.next_u32() & 3u);\n\n if (score < bestScore) {\n bestScore = score;\n chosen = {i,j};\n }\n }\n\n if (chosen.r == -1) {\n // Fallback: allow any empty non-entrance (still should be reachable in valid instances).\n for (int i = 0; i < D; i++) for (int j = 0; j < D; j++) {\n if (obstacle[i][j]) continue;\n if (!emptyCell[i][j]) continue;\n if (i == ent_r && j == ent_c) continue;\n chosen = {i,j};\n break;\n }\n }\n\n cout << chosen.r << \" \" << chosen.c << endl; // endl flushes\n\n emptyCell[chosen.r][chosen.c] = false;\n labelAt[chosen.r][chosen.c] = t;\n }\n\n // ========= Retrieval phase (greedy min label among reachable) =========\n bool removed[D][D]{};\n bool reachable[D][D]{};\n bool inPQ[D][D]{};\n\n auto is_empty_now = [&](int r, int c)->bool{\n if (obstacle[r][c]) return false;\n if (r == ent_r && c == ent_c) return true;\n return removed[r][c];\n };\n auto has_container = [&](int r, int c)->bool{\n if (obstacle[r][c]) return false;\n if (r == ent_r && c == ent_c) return false;\n return !removed[r][c];\n };\n\n struct Item {\n int t, r, c;\n bool operator>(const Item& other) const {\n if (t != other.t) return t > other.t;\n if (r != other.r) return r > other.r;\n return c > other.c;\n }\n };\n priority_queue, greater> pq;\n\n queue bfs;\n reachable[ent_r][ent_c] = true;\n bfs.push({ent_r, ent_c});\n\n auto expand = [&]() {\n while (!bfs.empty()) {\n auto [r,c] = bfs.front(); bfs.pop();\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (is_empty_now(nr,nc)) {\n if (!reachable[nr][nc]) {\n reachable[nr][nc] = true;\n bfs.push({nr,nc});\n }\n } else if (has_container(nr,nc)) {\n if (!inPQ[nr][nc]) {\n inPQ[nr][nc] = true;\n pq.push({labelAt[nr][nc], nr, nc});\n }\n }\n }\n }\n };\n\n expand();\n\n for (int k = 0; k < M; k++) {\n while (!pq.empty()) {\n auto it = pq.top(); pq.pop();\n int r = it.r, c = it.c;\n if (removed[r][c]) continue; // stale\n cout << r << \" \" << c << endl;\n removed[r][c] = true;\n if (!reachable[r][c]) {\n reachable[r][c] = true;\n bfs.push({r,c});\n }\n expand();\n break;\n }\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nstatic const int N = 50;\nstatic const int M = 100;\n\nstruct Pos { int r, c; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m; // fixed n=50, m=100\n vector> g(n, vector(n));\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) cin >> g[i][j];\n\n const int V = m + 1; // colors 0..m\n auto inside = [&](int r, int c){ return 0 <= r && r < n && 0 <= c && c < n; };\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n\n // origAdj[a][b] = whether adjacency must exist (undirected)\n vector> origAdj(V, vector(V, 0));\n auto setOrigAdj = [&](int a, int b){\n if (a == b) return;\n origAdj[a][b] = origAdj[b][a] = 1;\n };\n\n // Build original adjacency from internal edges\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n if (i + 1 < n) setOrigAdj(g[i][j], g[i+1][j]);\n if (j + 1 < n) setOrigAdj(g[i][j], g[i][j+1]);\n }\n // Adjacency to outside (0) via boundary\n for (int i = 0; i < n; i++) {\n setOrigAdj(0, g[i][0]);\n setOrigAdj(0, g[i][n-1]);\n }\n for (int j = 0; j < n; j++) {\n setOrigAdj(0, g[0][j]);\n setOrigAdj(0, g[n-1][j]);\n }\n\n // inB[c] <=> originally adjacent to 0\n vector inB(V, 0);\n for (int c = 1; c <= m; c++) inB[c] = origAdj[0][c];\n\n // edgeCnt[a][b] for a> edgeCnt(V, vector(V, 0));\n auto addEdgeCnt = [&](int a, int b, int delta){\n if (a == b) return;\n if (a > b) swap(a, b);\n edgeCnt[a][b] += delta;\n };\n auto getEdgeCnt = [&](int a, int b)->int{\n if (a == b) return 0;\n if (a > b) swap(a, b);\n return edgeCnt[a][b];\n };\n\n // Initialize edgeCnt from current grid (initially original, no internal 0)\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n if (i + 1 < n) {\n int a = g[i][j], b = g[i+1][j];\n if (a != b) addEdgeCnt(a, b, +1);\n }\n if (j + 1 < n) {\n int a = g[i][j], b = g[i][j+1];\n if (a != b) addEdgeCnt(a, b, +1);\n }\n }\n // Boundary-outside edges\n for (int i = 0; i < n; i++) {\n addEdgeCnt(0, g[i][0], +1);\n addEdgeCnt(0, g[i][n-1], +1);\n }\n for (int j = 0; j < n; j++) {\n addEdgeCnt(0, g[0][j], +1);\n addEdgeCnt(0, g[n-1][j], +1);\n }\n\n // size and representative for each color 1..m\n vector sz(V, 0);\n vector rep(V, Pos{-1, -1});\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n int c = g[i][j];\n if (c != 0) {\n sz[c]++;\n rep[c] = Pos{i, j};\n }\n }\n\n // BFS visited stamp (for connectivity checks)\n static int vis[N][N];\n int stamp = 1;\n\n auto find_rep_scan = [&](int col)->Pos{\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++)\n if (g[i][j] == col) return Pos{i, j};\n return Pos{-1, -1};\n };\n\n auto count_same_neighbors = [&](int r, int c, int col)->int{\n int cnt = 0;\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 if (g[nr][nc] == col) cnt++;\n }\n return cnt;\n };\n\n // Check connectivity of `col` after removing cell (r,c) from that color (cell will become something else).\n auto connected_after_removal = [&](int col, int r, int c)->bool{\n // leaf shortcut: if removed cell has <=1 same-color neighbor, it cannot disconnect the remainder.\n if (sz[col] <= 2) return true;\n if (count_same_neighbors(r, c, col) <= 1) return true;\n\n Pos st = rep[col];\n if (!(st.r >= 0 && g[st.r][st.c] == col) || (st.r == r && st.c == c)) {\n bool found = false;\n for (int k = 0; k < 4 && !found; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr,nc) && g[nr][nc] == col) {\n st = Pos{nr,nc};\n found = true;\n }\n }\n if (!found) st = find_rep_scan(col);\n if (st.r < 0) return false;\n }\n\n stamp++;\n deque q;\n vis[st.r][st.c] = stamp;\n q.push_back(st);\n int reached = 0;\n\n while (!q.empty()) {\n auto p = q.front(); q.pop_front();\n reached++;\n for (int k = 0; k < 4; k++) {\n int nr = p.r + dr[k], nc = p.c + dc[k];\n if (!inside(nr,nc)) continue;\n if (nr == r && nc == c) continue;\n if (g[nr][nc] != col) continue;\n if (vis[nr][nc] == stamp) continue;\n vis[nr][nc] = stamp;\n q.push_back(Pos{nr,nc});\n }\n }\n return reached == sz[col] - 1;\n };\n\n auto boundary_sides = [&](int r, int c)->int{\n int b = 0;\n if (r == 0) b++;\n if (r == n-1) b++;\n if (c == 0) b++;\n if (c == n-1) b++;\n return b;\n };\n\n // Frontier cells to try deletions more often (boundary + neighbors of existing 0)\n vector frontier;\n frontier.reserve(n*n*4);\n for (int i = 0; i < n; i++) {\n frontier.push_back(Pos{i, 0});\n frontier.push_back(Pos{i, n-1});\n }\n for (int j = 0; j < n; j++) {\n frontier.push_back(Pos{0, j});\n frontier.push_back(Pos{n-1, j});\n }\n\n // RNG + time\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937_64 rng(seed);\n auto startTime = chrono::high_resolution_clock::now();\n const double TL = 1.95;\n\n auto time_ok = [&](){\n double t = chrono::duration(chrono::high_resolution_clock::now() - startTime).count();\n return t < TL;\n };\n\n auto is_neighbor0 = [&](int r, int c)->bool{\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 if (g[nr][nc] == 0) return true;\n }\n return false;\n };\n\n // Try painting cell (r,c) to newCol (0..m), oldCol != 0.\n auto try_paint = [&](int r, int c, int newCol)->bool{\n int oldCol = g[r][c];\n if (oldCol == 0) return false;\n if (oldCol == newCol) return false;\n\n // oldCol must remain non-empty\n if (sz[oldCol] <= 1) return false;\n\n // Collect neighbor colors with multiplicity, including virtual outside(0) for each boundary side.\n vector neigh;\n neigh.reserve(8);\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr,nc)) neigh.push_back(g[nr][nc]);\n }\n int bnd = boundary_sides(r, c);\n for (int t = 0; t < bnd; t++) neigh.push_back(0);\n\n // Constraints for newCol == 0: must not create isolated 0 component.\n if (newCol == 0) {\n if (bnd == 0 && !is_neighbor0(r, c)) return false;\n // Also, 0 must not become adjacent to colors not adjacent-to-0 in original.\n // (i.e., origAdj[0][x] must hold for any neighbor x != 0)\n for (int x : neigh) {\n if (x != 0 && !origAdj[0][x]) return false;\n }\n } else {\n // Adding cell to newCol must keep newCol connected => need adjacent existing newCol cell.\n bool adjNew = false;\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 if (g[nr][nc] == newCol) { adjNew = true; break; }\n }\n if (!adjNew) return false;\n }\n\n // Compute affected pair deltas (small list of at most ~16 entries)\n struct Delta { int a,b, d; };\n array ds;\n int dsz = 0;\n auto add_delta = [&](int a, int b, int dd){\n if (a == b || dd == 0) return;\n if (a > b) swap(a, b);\n for (int i = 0; i < dsz; i++) {\n if (ds[i].a == a && ds[i].b == b) { ds[i].d += dd; return; }\n }\n ds[dsz++] = Delta{a,b,dd};\n };\n\n // Local edge updates: for each neighbor x,\n // oldCol-x edge is removed if oldCol!=x, newCol-x edge is added if newCol!=x.\n // Also forbid creating any adjacency not in original.\n for (int x : neigh) {\n if (oldCol != x) add_delta(oldCol, x, -1);\n if (newCol != x) {\n // If this introduces an edge between newCol and x, it must be allowed in original.\n if (!origAdj[newCol][x]) return false;\n add_delta(newCol, x, +1);\n }\n }\n\n // Connectivity check of oldCol after removing this cell\n if (!connected_after_removal(oldCol, r, c)) return false;\n\n // Check adjacency constraints for affected pairs\n for (int i = 0; i < dsz; i++) {\n int a = ds[i].a, b = ds[i].b, dd = ds[i].d;\n int cur = edgeCnt[a][b];\n int nxt = cur + dd;\n if (nxt < 0) return false;\n if (origAdj[a][b]) {\n if (nxt == 0) return false; // required adjacency must remain\n } else {\n if (nxt != 0) return false; // forbidden adjacency must not appear\n }\n }\n\n // Additionally ensure (0,color) pairs touched still satisfy required/non-required:\n // Already covered by above checks because any created 0-x edge requires origAdj[0][x].\n // But we also might remove 0-x edges. The rule says if origAdj[0][x]==1, must stay >0.\n // Also covered in pair checks.\n\n // Accept move: apply deltas\n for (int i = 0; i < dsz; i++) {\n edgeCnt[ds[i].a][ds[i].b] += ds[i].d;\n }\n\n // Apply recolor\n g[r][c] = newCol;\n sz[oldCol]--;\n if (newCol != 0) {\n sz[newCol]++;\n rep[newCol] = Pos{r,c}; // safe to update to something valid\n }\n if (rep[oldCol].r == r && rep[oldCol].c == c) {\n // try to pick a neighbor, else scan\n Pos cand{-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] == oldCol) { cand = Pos{nr,nc}; break; }\n }\n if (cand.r < 0) cand = find_rep_scan(oldCol);\n rep[oldCol] = cand;\n }\n\n // If we created a 0 cell, its neighbors become good deletion candidates (frontier)\n if (newCol == 0) {\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 if (g[nr][nc] != 0) frontier.push_back(Pos{nr,nc});\n }\n }\n return true;\n };\n\n // Heuristic: do not increase \"internal area\" (colors not originally adjacent to 0).\n auto internal_flag = [&](int col)->int{\n if (col == 0) return 0;\n return inB[col] ? 0 : 1;\n };\n\n // Main loop: mix deletions and recolors\n while (time_ok()) {\n // Choose a cell. Prefer frontier for deletion attempts.\n int r, c;\n bool pickFront = (!frontier.empty() && (rng() % 100) < 70);\n if (pickFront) {\n int idx = (int)(rng() % frontier.size());\n r = frontier[idx].r;\n c = frontier[idx].c;\n frontier[idx] = frontier.back();\n frontier.pop_back();\n } else {\n r = (int)(rng() % n);\n c = (int)(rng() % n);\n }\n if (g[r][c] == 0) continue;\n\n // Try deletion to 0 with decent probability; otherwise try recolor to neighbor color.\n bool tryZero = ((rng() % 100) < 55);\n if (tryZero) {\n (void)try_paint(r, c, 0);\n continue;\n }\n\n // Propose recolor to a neighboring non-zero color\n int oldCol = g[r][c];\n array cand;\n int ksz = 0;\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 x = g[nr][nc];\n if (x == 0 || x == oldCol) continue;\n cand[ksz++] = x;\n }\n if (ksz == 0) continue;\n int newCol = cand[(int)(rng() % ksz)];\n\n // Acceptance rule: never increase internal area; neutral moves accepted with small probability.\n int deltaInternal = internal_flag(newCol) - internal_flag(oldCol);\n if (deltaInternal > 0) continue; // forbid making internal mass larger\n if (deltaInternal == 0) {\n // neutral moves: accept rarely, just to rearrange / escape minor dead-ends\n if ((rng() % 100) >= 7) continue;\n }\n (void)try_paint(r, c, newCol);\n }\n\n // Output final grid\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j) cout << ' ';\n cout << g[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Solver {\n int N, D, Q;\n int used = 0;\n\n XorShift rng;\n\n // Estimated rank-based \"weights\"\n vector west;\n vector order; // ascending by estimated weight (light -> heavy)\n\n // Final bins\n vector> bins;\n vector binSumEst;\n\n Solver() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cin >> N >> D >> Q;\n west.assign(N, 1.0);\n }\n\n char query_sets(const vector& L, const vector& R) {\n // Must be non-empty and disjoint.\n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << \"\\n\" << flush;\n\n string s;\n cin >> s;\n used++;\n return s[0];\n }\n\n char cmp_item(int a, int b) {\n // Compare {a} vs {b}\n vector L = {a}, R = {b};\n return query_sets(L, R);\n }\n\n // Insert item x into current \"order\" (ascending light->heavy),\n // using up to k comparisons (k can be small).\n void insert_with_budget(int x, int k) {\n int m = (int)order.size();\n if (m == 0) { order.push_back(x); return; }\n if (k <= 0) { order.push_back(x); return; }\n\n // If we have enough, do normal binary-search insertion by comparisons.\n int need = 0;\n while ((1 << need) < (m + 1)) need++;\n if (k >= need) {\n int lo = 0, hi = m;\n while (lo < hi && k > 0) {\n int mid = (lo + hi) >> 1;\n char res = cmp_item(x, order[mid]);\n k--;\n // res == '<' means x lighter than order[mid] => go left\n if (res == '<') hi = mid;\n else lo = mid + 1;\n }\n order.insert(order.begin() + lo, x);\n return;\n }\n\n // Coarse insertion: compare against a few evenly spaced pivots.\n int lowBound = 0, highBound = m;\n for (int t = 1; t <= k; t++) {\n int pos = (int)((long long)t * m / (k + 1));\n pos = max(0, min(m - 1, pos));\n char res = cmp_item(x, order[pos]);\n // If x < pivot, it must be before pos\n if (res == '<') highBound = min(highBound, pos);\n // If x > pivot, it must be after pos\n else if (res == '>') lowBound = max(lowBound, pos + 1);\n else {\n // Equal: insert around pos\n lowBound = max(lowBound, pos);\n highBound = min(highBound, pos + 1);\n }\n }\n\n int ins = lowBound;\n if (lowBound > highBound) ins = (lowBound + highBound) / 2;\n ins = max(0, min(m, ins));\n order.insert(order.begin() + ins, x);\n }\n\n void build_order() {\n vector items(N);\n iota(items.begin(), items.end(), 0);\n // Randomize insertion order to reduce bias under small Q\n for (int i = N - 1; i > 0; i--) swap(items[i], items[rng.next_int(0, i)]);\n\n order.clear();\n order.reserve(N);\n\n // Allocate ~70% queries to sorting/order learning\n int sortBudget = (int)llround(Q * 0.70);\n sortBudget = max(0, min(Q, sortBudget));\n\n int idx = 0;\n if (idx < N) {\n order.push_back(items[idx++]);\n }\n while (idx < N) {\n int remItems = N - idx;\n int remQ = sortBudget - used;\n if (remQ <= 0) break;\n\n // comparisons per insertion (adaptive)\n int k = max(1, remQ / remItems);\n k = min(k, 8); // keep it small; coarse is fine\n insert_with_budget(items[idx], k);\n idx++;\n if (used >= sortBudget) break;\n }\n\n // If we didn't insert all items in order-building, append remaining unsorted.\n while (idx < N) {\n order.push_back(items[idx++]);\n }\n\n // Now order is \"approx ascending\" by weight.\n // Assign rank-based pseudo-weights (exponential mapping).\n // base tuned mildly by D (more bins -> prefer a bit steeper).\n double base = 1.09 + 0.02 * min(1.0, (double)D / 20.0);\n vector pos(N);\n for (int i = 0; i < N; i++) pos[order[i]] = i;\n\n for (int i = 0; i < N; i++) {\n west[i] = pow(base, pos[i]);\n }\n }\n\n void initial_partition() {\n bins.assign(D, {});\n binSumEst.assign(D, 0.0);\n\n // Use heaviest-first (reverse of ascending order)\n vector heavy(order.rbegin(), order.rend());\n\n // Seed: ensure each bin non-empty with first D heaviest\n int ptr = 0;\n for (int b = 0; b < D; b++) {\n int it = heavy[ptr++];\n bins[b].push_back(it);\n binSumEst[b] += west[it];\n }\n\n // Then LPT\n for (; ptr < (int)heavy.size(); ptr++) {\n int it = heavy[ptr];\n int best = 0;\n for (int b = 1; b < D; b++) {\n if (binSumEst[b] < binSumEst[best]) best = b;\n }\n bins[best].push_back(it);\n binSumEst[best] += west[it];\n }\n }\n\n vector bin_items_sorted_by_est_asc(int b) {\n auto v = bins[b];\n sort(v.begin(), v.end(), [&](int i, int j){\n return west[i] < west[j];\n });\n return v;\n }\n\n // Try to move one item from heavy->light using a few queries.\n // Returns true if moved.\n bool balance_once(int bHeavy, int bLight) {\n if (bHeavy == bLight) return false;\n if ((int)bins[bHeavy].size() <= 1) return false; // don't empty the bin\n if ((int)bins[bLight].size() <= 0) return false; // should not happen\n\n // Candidates in heavy bin sorted by estimated weight ascending (light -> heavy)\n vector cand = bin_items_sorted_by_est_asc(bHeavy);\n // Exclude the only item? already ensured size>=2 so ok.\n\n auto test_move_pred = [&](int x)->char {\n // Compare (heavy without x) vs (light with x)\n vector L, R;\n L.reserve(bins[bHeavy].size() - 1);\n R.reserve(bins[bLight].size() + 1);\n for (int it : bins[bHeavy]) if (it != x) L.push_back(it);\n for (int it : bins[bLight]) R.push_back(it);\n R.push_back(x);\n\n // L and R must be non-empty. L non-empty because heavy size>=2.\n return query_sets(L, R);\n };\n\n // Binary search smallest item (by est) such that after moving it,\n // heavy_without_x <= light_plus_x, i.e. response is '<' or '=' (not '>').\n int lo = 0, hi = (int)cand.size() - 1;\n int ans = -1;\n\n // Limit steps based on remaining queries\n int remQ = Q - used;\n int maxSteps = min(7, remQ); // <= 7 predicate queries\n for (int step = 0; step < maxSteps && lo <= hi; step++) {\n int mid = (lo + hi) >> 1;\n int x = cand[mid];\n char res = test_move_pred(x);\n // res == '>' means (heavy\\{x}) still heavier => x too light => need heavier => go right\n if (res == '>') {\n lo = mid + 1;\n } else {\n ans = mid;\n hi = mid - 1;\n }\n if (used >= Q) break;\n }\n\n if (ans == -1) ans = (int)cand.size() - 1; // even heaviest doesn't flip, move heaviest\n\n int x = cand[ans];\n\n // Perform the move\n {\n auto &A = bins[bHeavy];\n auto it = find(A.begin(), A.end(), x);\n if (it == A.end()) return false;\n A.erase(it);\n }\n bins[bLight].push_back(x);\n\n binSumEst[bHeavy] -= west[x];\n binSumEst[bLight] += west[x];\n return true;\n }\n\n void balancing_phase() {\n while (used < Q) {\n // Pick bins with max/min estimated sums\n int bMax = 0, bMin = 0;\n for (int b = 1; b < D; b++) {\n if (binSumEst[b] > binSumEst[bMax]) bMax = b;\n if (binSumEst[b] < binSumEst[bMin]) bMin = b;\n }\n if (bMax == bMin) break;\n\n // Need at least 1 query to compare full bins.\n if (used >= Q) break;\n\n // Compare full bins to know true heavier side.\n char res = query_sets(bins[bMax], bins[bMin]);\n if (used >= Q) break;\n\n int heavy = -1, light = -1;\n if (res == '>') { heavy = bMax; light = bMin; }\n else if (res == '<') { heavy = bMin; light = bMax; }\n else {\n // equal, great; do nothing\n continue;\n }\n\n // Try a guided move with remaining queries.\n if (used >= Q) break;\n bool moved = balance_once(heavy, light);\n if (!moved) {\n // If can't move, just continue; might be stuck due to bin sizes.\n continue;\n }\n }\n }\n\n void consume_remaining_queries_dummy() {\n // Must do exactly Q queries. If any remain, do harmless fixed queries.\n while (used < Q) {\n int a = 0, b = 1;\n if (N >= 2) {\n vector L = {a}, R = {b};\n query_sets(L, R);\n } else {\n // Should never happen (N>=30)\n vector L = {0}, R = {0};\n query_sets(L, R);\n }\n }\n }\n\n void output_answer() {\n vector ans(N, 0);\n for (int b = 0; b < D; b++) {\n for (int it : bins[b]) ans[it] = b;\n }\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << ans[i];\n }\n cout << \"\\n\" << flush;\n }\n\n void solve() {\n build_order();\n initial_partition();\n balancing_phase();\n consume_remaining_queries_dummy();\n output_answer();\n }\n};\n\nint main() {\n Solver solver;\n solver.solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstatic constexpr int N = 200;\nstatic constexpr int M = 10;\n\nstruct State {\n vector> st; // bottom -> top\n int cur; // next box to remove\n};\n\nstatic inline pair find_box(const vector>& st, int v) {\n for (int i = 0; i < (int)st.size(); i++) {\n for (int j = 0; j < (int)st[i].size(); j++) if (st[i][j] == v) return {i, j};\n }\n return {-1, -1};\n}\n\nstatic inline int stack_min(const vector& s) {\n if (s.empty()) return INT_MAX;\n return *min_element(s.begin(), s.end());\n}\n\nstatic inline int count_leq(const vector& s, int x) {\n int c = 0;\n for (int v : s) c += (v <= x);\n return c;\n}\n\n// Greedy destination evaluation: lower is better.\nstatic inline long long eval_dest(const vector>& st, int cur, int src, int dst,\n int blockSize, int bottomMoved) {\n const auto& d = st[dst];\n int hd = (int)d.size();\n int mind = stack_min(d);\n int topd = d.empty() ? INT_MAX : d.back();\n\n // Windows of \"soon to be needed\".\n int W1 = 30;\n int W2 = 10;\n int soon = count_leq(d, cur + W1);\n int vsoon = count_leq(d, cur + W2);\n\n long long e = 0;\n\n // Main term: burying soon-needed boxes costs roughly blockSize per such box later.\n e += 120LL * blockSize * soon;\n e += 240LL * blockSize * vsoon;\n\n // Prefer using empty stack as a buffer.\n if (d.empty()) e -= 20000;\n\n // Keep heights under control.\n e += 80LL * hd;\n\n // Prefer stacks whose minimum is large (contains no small boxes).\n if (mind != INT_MAX) e -= 8LL * mind;\n\n // Prefer large top (heuristic).\n if (topd != INT_MAX) e -= 2LL * topd;\n\n // Mild penalty if destination top is \"smaller\" than the moved block bottom.\n // (Often leads to mixed small-on-large structure.)\n if (!d.empty() && topd <= bottomMoved) e += 3000;\n\n // Hard avoid stacks that already have very small minimum.\n if (mind != INT_MAX && mind <= cur + 10) e += 50000;\n\n (void)src; // currently unused, kept for clarity/extension\n return e;\n}\n\n// Apply: move block starting at position `start` (0-index, from bottom) from src to dst.\nstatic inline void apply_move(vector>& st, int src, int start, int dst) {\n vector block(st[src].begin() + start, st[src].end());\n st[src].erase(st[src].begin() + start, st[src].end());\n st[dst].insert(st[dst].end(), block.begin(), block.end());\n}\n\n// Simulate a few future removals with greedy destination choice.\n// Returns estimated additional energy.\nstatic long long rollout_energy(State s, int steps) {\n long long energy = 0;\n for (int t = 0; t < steps && s.cur <= N; t++) {\n auto [si, pos] = find_box(s.st, s.cur);\n if (si < 0) break;\n\n // If already on top: remove for free.\n if (!s.st[si].empty() && s.st[si].back() == s.cur) {\n s.st[si].pop_back();\n s.cur++;\n continue;\n }\n\n // Move all above cur as one block.\n int h = (int)s.st[si].size();\n int start = pos + 1; // first above cur\n int blockSize = h - start;\n int bottomMoved = s.st[si][start];\n\n // Choose destination greedily.\n long long best = (1LL<<62);\n int bestd = -1;\n for (int d = 0; d < M; d++) if (d != si) {\n long long e = eval_dest(s.st, s.cur, si, d, blockSize, bottomMoved);\n if (e < best) { best = e; bestd = d; }\n }\n\n apply_move(s.st, si, start, bestd);\n energy += (long long)blockSize + 1; // cost of this move\n\n // Now cur must be on top of si, remove.\n if (!s.st[si].empty() && s.st[si].back() == s.cur) {\n s.st[si].pop_back();\n s.cur++;\n } else {\n // Safety (shouldn't happen)\n auto [s2, p2] = find_box(s.st, s.cur);\n if (s2 >= 0 && !s.st[s2].empty() && s.st[s2].back() == s.cur) {\n s.st[s2].pop_back();\n s.cur++;\n } else {\n break;\n }\n }\n }\n return energy;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m; // always 200,10\n vector> st(m);\n for (int i = 0; i < m; i++) {\n st[i].resize(n / m);\n for (int j = 0; j < n / m; j++) cin >> st[i][j];\n }\n\n vector> ops;\n ops.reserve(5000);\n\n int cur = 1;\n\n while (cur <= n) {\n auto [s, pos] = find_box(st, cur);\n if (s < 0) break; // should not happen\n\n if (!st[s].empty() && st[s].back() == cur) {\n ops.emplace_back(cur, 0);\n st[s].pop_back();\n cur++;\n continue;\n }\n\n int h = (int)st[s].size();\n int start = pos + 1;\n int blockSize = h - start;\n int bottomMoved = st[s][start];\n\n // Choose destination by: immediate eval + rollout.\n // Note: immediate move energy (blockSize+1) is same for all dst, so we compare only future.\n int ROLLOUT_STEPS = 14;\n\n long long bestScore = (1LL<<62);\n int bestDst = -1;\n\n for (int d = 0; d < m; d++) if (d != s) {\n long long immediate = eval_dest(st, cur, s, d, blockSize, bottomMoved);\n\n State tmp{st, cur};\n\n // Apply this candidate move and pop cur (since we will do it immediately in real run).\n apply_move(tmp.st, s, start, d);\n // pay energy of move in rollout score as well? it's constant across d, so optional.\n // But for stability when comparing different blockSize scenarios in nested rollouts, include it.\n long long future = 0;\n future += (long long)blockSize + 1;\n\n // Pop cur\n if (!tmp.st[s].empty() && tmp.st[s].back() == cur) {\n tmp.st[s].pop_back();\n tmp.cur++;\n } else {\n // safety\n auto [s2, p2] = find_box(tmp.st, cur);\n if (s2 >= 0 && !tmp.st[s2].empty() && tmp.st[s2].back() == cur) {\n tmp.st[s2].pop_back();\n tmp.cur++;\n }\n }\n\n future += rollout_energy(tmp, ROLLOUT_STEPS);\n\n // Combine. Rollout dominates; immediate guides tie-break / noise.\n long long total = future * 100000LL + immediate;\n\n if (total < bestScore) {\n bestScore = total;\n bestDst = d;\n }\n }\n\n // Execute chosen move.\n // Must physically construct moved block for operation output correctness.\n vector block(st[s].begin() + start, st[s].end());\n st[s].erase(st[s].begin() + start, st[s].end());\n st[bestDst].insert(st[bestDst].end(), block.begin(), block.end());\n\n ops.emplace_back(bottomMoved, bestDst + 1);\n\n // Now remove cur\n ops.emplace_back(cur, 0);\n // cur should be on top of s\n if (!st[s].empty() && st[s].back() == cur) st[s].pop_back();\n else {\n // safety fallback\n auto [s2, p2] = find_box(st, cur);\n if (s2 >= 0 && !st[s2].empty() && st[s2].back() == cur) st[s2].pop_back();\n }\n cur++;\n\n if ((int)ops.size() > 5000) break; // not expected\n }\n\n for (auto [v, i] : ops) {\n cout << v << \" \" << i << \"\\n\";\n }\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstatic inline char opp(char c){\n if(c=='U') return 'D';\n if(c=='D') return 'U';\n if(c=='L') return 'R';\n return 'L';\n}\n\nstruct BFSResult {\n vector prev;\n vector pmove; // move taken from prev -> node\n vector dist;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector h(N-1), v(N);\n for(int i=0;i> h[i];\n for(int i=0;i> v[i];\n vector> d(N, vector(N));\n for(int i=0;i> d[i][j];\n\n int V = N*N;\n auto id = [&](int i,int j){ return i*N+j; };\n auto rc = [&](int x){ return pair(x/N, x%N); };\n\n // adjacency: (to, move)\n vector>> g(V);\n auto add_edge=[&](int a,int b,char c){\n g[a].push_back({b,c});\n };\n for(int i=0;iBFSResult{\n BFSResult br;\n br.prev.assign(V, -1);\n br.pmove.assign(V, 0);\n br.dist.assign(V, -1);\n deque q;\n q.push_back(s);\n br.prev[s]=s;\n br.dist[s]=0;\n while(!q.empty()){\n int u=q.front(); q.pop_front();\n for(auto [to,mv]: g[u]){\n if(br.prev[to]!=-1) continue;\n br.prev[to]=u;\n br.pmove[to]=mv;\n br.dist[to]=br.dist[u]+1;\n q.push_back(to);\n }\n }\n return br;\n };\n\n auto path_using_bfs = [&](int s,int t,const BFSResult& br)->string{\n if(s==t) return \"\";\n if(br.prev[t]==-1) return \"\"; // unreachable shouldn't happen\n string rev;\n int cur=t;\n while(cur!=s){\n rev.push_back(br.pmove[cur]);\n cur=br.prev[cur];\n }\n reverse(rev.begin(), rev.end());\n return rev;\n };\n\n auto reverse_opp = [&](const string& p)->string{\n string r;\n r.reserve(p.size());\n for(int i=(int)p.size()-1;i>=0;i--) r.push_back(opp(p[i]));\n return r;\n };\n\n // Exact evaluation of average dirtiness from visit gaps.\n auto eval_route = [&](const string& route)->long double{\n int L=(int)route.size();\n vector first(V,-1), last(V,-1);\n vector sumG(V,0);\n\n int ci=0,cj=0;\n for(int t=1;t<=L;t++){\n char c=route[t-1];\n if(c=='U') ci--;\n else if(c=='D') ci++;\n else if(c=='L') cj--;\n else cj++;\n if(ci<0||ci>=N||cj<0||cj>=N) return (long double)1e30;\n int u=id(ci,cj);\n if(first[u]==-1) first[u]=t;\n if(last[u]!=-1){\n long long gap=t-last[u];\n sumG[u]+=gap*(gap-1)/2;\n }\n last[u]=t;\n }\n // must end at (0,0)\n if(ci!=0||cj!=0) return (long double)1e30;\n\n for(int u=0;u vis(V,0);\n int cur=0;\n vis[0]=1;\n int unvisited = V-1;\n\n string mainRoute;\n mainRoute.reserve(100000);\n\n auto apply_move = [&](char mv, int &pos){\n auto [i,j]=rc(pos);\n int ni=i, nj=j;\n if(mv=='U') ni--;\n else if(mv=='D') ni++;\n else if(mv=='L') nj--;\n else nj++;\n pos = id(ni,nj);\n };\n\n while(unvisited>0){\n BFSResult br = bfs_from(cur);\n\n int bestDist = INT_MAX;\n // first find nearest distance to any unvisited\n for(int u=0;u=0){\n bestDist = min(bestDist, br.dist[u]);\n }\n }\n if(bestDist==INT_MAX) break; // shouldn't happen\n\n // among nodes within bestDist+2, choose highest d (bias toward important but not too far)\n int chosen=-1;\n int chosenD=-1;\n int limit = bestDist + 2;\n for(int u=0;u limit) continue;\n auto [i,j]=rc(u);\n int du=d[i][j];\n if(du>chosenD){\n chosenD=du;\n chosen=u;\n }\n }\n if(chosen==-1){\n // fallback: nearest\n for(int u=0;u 100000-5000) break; // safety margin\n }\n\n // Return to 0\n {\n BFSResult br = bfs_from(cur);\n string back = path_using_bfs(cur, 0, br);\n for(char mv: back){\n mainRoute.push_back(mv);\n apply_move(mv, cur);\n if(!vis[cur]){\n vis[cur]=1;\n unvisited--;\n }\n }\n }\n\n // If somehow some cells remain unvisited (very unlikely), do a fallback coverage using DFS Euler from 0\n // (guarantees legality).\n if(unvisited>0 || cur!=0){\n // Build DFS Euler as fallback\n vector visited2(V,0);\n vector itidx(V,0);\n vector st;\n vector entered;\n string base;\n base.reserve(2*V+10);\n\n // neighbor order: higher d first\n vector>> g2 = g;\n for(int u=0;u d[bi][bj];\n });\n }\n\n st.push_back(0);\n entered.push_back(0);\n visited2[0]=1;\n while(!st.empty()){\n int u=st.back();\n int &it = itidx[u];\n if(it==(int)g2[u].size()){\n st.pop_back();\n char mv = entered.back();\n entered.pop_back();\n if(!st.empty()) base.push_back(opp(mv));\n continue;\n }\n auto [to,mv]=g2[u][it++];\n if(visited2[to]) continue;\n visited2[to]=1;\n base.push_back(mv);\n st.push_back(to);\n entered.push_back(mv);\n }\n mainRoute = base;\n }\n\n // Ensure mainRoute ends at 0 (it should)\n // ---------- Generate loop candidates ----------\n BFSResult bfs0 = bfs_from(0);\n vector dist0 = bfs0.dist;\n\n vector cells(V);\n iota(cells.begin(), cells.end(), 0);\n sort(cells.begin(), cells.end(), [&](int a,int b){\n auto [ai,aj]=rc(a);\n auto [bi,bj]=rc(b);\n long double sa = (long double)d[ai][aj] / (long double)(dist0[a]+1);\n long double sb = (long double)d[bi][bj] / (long double)(dist0[b]+1);\n if(sa!=sb) return sa>sb;\n return d[ai][aj] > d[bi][bj];\n });\n\n vector top;\n int M = min(25, V);\n for(int k=0;k loops;\n loops.reserve(300);\n\n // tiny 2-step loops\n for(auto [to,mv]: g[0]){\n string lp;\n lp.push_back(mv);\n lp.push_back(opp(mv));\n loops.push_back(lp);\n }\n\n // single target loops 0->p->0\n for(int p: top){\n string sp = path_using_bfs(0,p,bfs0);\n if(sp.empty()) continue;\n string lp = sp + reverse_opp(sp);\n if((int)lp.size()<=1200) loops.push_back(lp);\n }\n\n // pair loops 0->p->q->0\n int K = min(12, (int)top.size());\n vector bfsTop;\n bfsTop.reserve(K);\n for(int i=0;i centers)->string{\n // build 0 -> centers... -> 0 using shortest paths (BFS per segment)\n string cyc;\n int cur=0;\n for(int c: centers){\n BFSResult br = bfs_from(cur);\n string seg = path_using_bfs(cur, c, br);\n if(seg.empty() && cur!=c) return \"\";\n cyc += seg;\n cur = c;\n }\n BFSResult br = bfs_from(cur);\n string back = path_using_bfs(cur, 0, br);\n if(back.empty() && cur!=0) return \"\";\n cyc += back;\n return cyc;\n };\n\n for(int m=3;m<=6;m++){\n if((int)top.size() centers(top.begin(), top.begin()+m);\n\n // deterministic greedy order: nearest-neighbor from 0 by dist0\n {\n vector ord = centers;\n sort(ord.begin(), ord.end(), [&](int a,int b){ return dist0[a] < dist0[b]; });\n string cyc = build_cycle(ord);\n if(!cyc.empty() && (int)cyc.size()<=2500) loops.push_back(cyc);\n }\n // randomized shuffles\n for(int t=0;t<10;t++){\n auto ord = centers;\n shuffle(ord.begin(), ord.end(), rng);\n string cyc = build_cycle(ord);\n if(!cyc.empty() && (int)cyc.size()<=2500) loops.push_back(cyc);\n }\n }\n\n sort(loops.begin(), loops.end());\n loops.erase(unique(loops.begin(), loops.end()), loops.end());\n\n auto build_r_list = [&](int maxR){\n vector rlist;\n rlist.push_back(0);\n int a=1,b=2;\n while(a<=maxR){\n rlist.push_back(a);\n int c=a+b;\n a=b; b=c;\n }\n rlist.push_back(maxR);\n sort(rlist.begin(), rlist.end());\n rlist.erase(unique(rlist.begin(), rlist.end()), rlist.end());\n return rlist;\n };\n\n // ---------- Choose best combination ----------\n string bestRoute = mainRoute;\n long double bestScore = eval_route(bestRoute);\n\n int mainLen = (int)mainRoute.size();\n for(const string& loop: loops){\n int c = (int)loop.size();\n if(c==0) continue;\n if(mainLen + c > 100000) continue;\n\n int maxR = (100000 - mainLen) / c;\n auto rlist = build_r_list(maxR);\n\n int bestR = 0;\n for(int r: rlist){\n int L = mainLen + r*c;\n if(L<=0 || L>100000) continue;\n int r1 = r/2, r2 = r-r1;\n string route;\n route.reserve(L);\n for(int k=0;kmaxR) continue;\n int L = mainLen + (int)r*c;\n if(L<=0 || L>100000) continue;\n int r1 = (int)r/2, r2 = (int)r - r1;\n string route;\n route.reserve(L);\n for(int k=0;k\nusing namespace std;\n\nstatic const long long INF = (1LL<<60);\n\nstruct Timer {\n chrono::steady_clock::time_point st;\n Timer() : st(chrono::steady_clock::now()) {}\n double elapsed_sec() const {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n vector t(M);\n for (int i = 0; i < M; i++) cin >> t[i];\n\n const int V = N * N;\n vector x(V), y(V);\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int id = i * N + j;\n x[id] = i; y[id] = j;\n }\n auto manhattan = [&](int a, int b) -> int {\n return abs(x[a] - x[b]) + abs(y[a] - y[b]);\n };\n\n // positions[c] = list of cell ids having letter c\n array, 26> positions;\n for (int i = 0; i < 26; i++) positions[i].clear();\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n positions[A[i][j] - 'A'].push_back(i * N + j);\n }\n\n // idxInLetter[c][cellId] = index in positions[c], else -1\n array, 26> idxInLetter;\n for (int c = 0; c < 26; c++) {\n idxInLetter[c].fill(-1);\n for (int k = 0; k < (int)positions[c].size(); k++) {\n idxInLetter[c][positions[c][k]] = k;\n }\n }\n\n int startCell = si * N + sj;\n\n // Overlap between current string S and next pattern p (length 5), max 4\n auto overlap_suffix_prefix = [&](const string &S, const string &p) -> int {\n int maxL = min(4, (int)S.size());\n for (int l = maxL; l >= 0; l--) {\n bool ok = true;\n for (int i = 0; i < l; i++) {\n if (S[(int)S.size() - l + i] != p[i]) { ok = false; break; }\n }\n if (ok) return l;\n }\n return 0;\n };\n\n // Exact minimal typing cost for given S (no reconstruction)\n auto typing_cost = [&](const string &S) -> long long {\n vector prevIds(1, startCell);\n vector prevCost(1, 0);\n\n for (char ch : S) {\n int c = ch - 'A';\n const auto &curIds = positions[c];\n vector curCost(curIds.size(), INF);\n\n for (int i = 0; i < (int)curIds.size(); i++) {\n int v = curIds[i];\n long long best = INF;\n for (int j = 0; j < (int)prevIds.size(); j++) {\n long long cand = prevCost[j] + manhattan(prevIds[j], v);\n if (cand < best) best = cand;\n }\n curCost[i] = best + 1; // press cost\n }\n prevIds = curIds;\n prevCost.swap(curCost);\n }\n\n long long ans = INF;\n for (auto v : prevCost) ans = min(ans, v);\n return ans;\n };\n\n // Build candidate S by greedy extension with randomness\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto build_candidate = [&]() -> string {\n vector used(M, 0);\n int start = uniform_int_distribution(0, M - 1)(rng);\n used[start] = 1;\n int usedCnt = 1;\n\n string S = t[start];\n\n while (usedCnt < M) {\n int bestOv = -1;\n vector cand;\n cand.reserve(M);\n\n // Find best overlap\n for (int k = 0; k < M; k++) if (!used[k]) {\n int ov = overlap_suffix_prefix(S, t[k]);\n if (ov > bestOv) {\n bestOv = ov;\n cand.clear();\n cand.push_back(k);\n } else if (ov == bestOv) {\n cand.push_back(k);\n }\n }\n\n // random tie-break\n int pick = cand[uniform_int_distribution(0, (int)cand.size() - 1)(rng)];\n used[pick] = 1;\n usedCnt++;\n\n int ov = overlap_suffix_prefix(S, t[pick]);\n S += t[pick].substr(ov);\n }\n\n return S;\n };\n\n Timer timer;\n double TIME_LIMIT = 1.85; // seconds, leave margin\n\n string bestS;\n long long bestT = INF;\n\n // A few deterministic tries first: start from each of some indices\n // (still using the random builder is fine; it is fast)\n int iters = 0;\n while (timer.elapsed_sec() < TIME_LIMIT) {\n string S = build_candidate();\n if ((int)S.size() > 5000) continue; // should never happen here\n\n long long T = typing_cost(S);\n if (T < bestT) {\n bestT = T;\n bestS = std::move(S);\n }\n iters++;\n }\n\n if (bestS.empty()) {\n // Fallback: just concatenate\n bestS = t[0];\n for (int i = 1; i < M; i++) bestS += t[i];\n }\n\n // DP with parent reconstruction for bestS\n int L = (int)bestS.size();\n vector letters(L);\n for (int i = 0; i < L; i++) letters[i] = bestS[i] - 'A';\n\n vector> parent(L); // parent[p][k] = previous cellId (0..224)\n vector prevIds(1, startCell);\n vector prevCost(1, 0);\n\n // We'll also keep the last layer's ids/cost to choose end.\n vector lastIds;\n vector lastCost;\n\n for (int p = 0; p < L; p++) {\n int c = letters[p];\n const auto &curIds = positions[c];\n vector curCost(curIds.size(), INF);\n parent[p].assign(curIds.size(), (int16_t)-1);\n\n for (int i = 0; i < (int)curIds.size(); i++) {\n int v = curIds[i];\n long long best = INF;\n int bestPrevCell = -1;\n for (int j = 0; j < (int)prevIds.size(); j++) {\n long long cand = prevCost[j] + manhattan(prevIds[j], v);\n if (cand < best) {\n best = cand;\n bestPrevCell = prevIds[j];\n }\n }\n curCost[i] = best + 1;\n parent[p][i] = (int16_t)bestPrevCell;\n }\n\n prevIds = curIds;\n prevCost.swap(curCost);\n lastIds = prevIds;\n lastCost = prevCost;\n }\n\n // Choose best ending cell\n int bestK = 0;\n for (int i = 1; i < (int)lastCost.size(); i++) {\n if (lastCost[i] < lastCost[bestK]) bestK = i;\n }\n\n // Backtrack\n vector answerCells(L);\n int curCell = lastIds[bestK];\n\n for (int p = L - 1; p >= 0; p--) {\n answerCells[p] = curCell;\n int c = letters[p];\n int k = idxInLetter[c][curCell];\n // k should be valid\n int prevCell = (int)parent[p][k];\n curCell = prevCell;\n }\n\n // Output coordinates for each operation\n for (int p = 0; p < L; p++) {\n int id = answerCells[p];\n cout << (id / N) << ' ' << (id % N) << '\\n';\n }\n\n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n explicit XorShift(uint64_t seed = 0) {\n if (seed) x ^= seed;\n for (int i = 0; i < 10; i++) next_u64();\n }\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Placement {\n vector cells; // indices in [0, N*N)\n vector contrib; // per mask: sum of signs on those cells\n};\n\nstatic inline void flush_out() { cout << flush; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed_ms = [&]() -> double {\n auto t1 = chrono::high_resolution_clock::now();\n return chrono::duration(t1 - t0).count();\n };\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector>> shapes(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n shapes[k].resize(d);\n for (int i = 0; i < d; i++) {\n int r, c;\n cin >> r >> c;\n shapes[k][i] = {r, c};\n }\n }\n\n const int V = N * N;\n\n // Choose number of random masks (T). Keep it moderate for speed.\n // With N<=20, V<=400. T=50~60 is usually enough for a decent fit.\n int T = 50;\n if (V <= 144) T = 45;\n if (V >= 361) T = 55;\n // One repetition per mask pair\n int R = 1;\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n // Random balanced masks: sign[t][idx] in {-1,+1}\n vector> sign(T, vector(V, -1));\n vector> Aset(T), Bset(T);\n vector perm(V);\n\n for (int t = 0; t < T; t++) {\n iota(perm.begin(), perm.end(), 0);\n for (int i = V - 1; i >= 1; i--) {\n int j = (int)(rng.next_u64() % (uint64_t)(i + 1));\n swap(perm[i], perm[j]);\n }\n int half = V / 2;\n Aset[t].clear(); Bset[t].clear();\n Aset[t].reserve(half + 1);\n Bset[t].reserve(V - half + 1);\n for (int i = 0; i < V; i++) {\n int idx = perm[i];\n if (i < half) { sign[t][idx] = +1; Aset[t].push_back(idx); }\n else { sign[t][idx] = -1; Bset[t].push_back(idx); }\n }\n }\n\n auto inv_est = [&](long long y, int k) -> float {\n // E[y] = k*eps + (1-2eps)*v(S)\n double denom = (1.0 - 2.0 * eps);\n double vhat = ((double)y - (double)k * eps) / denom;\n if (vhat < 0.0) vhat = 0.0;\n double hi = (double)k * (double)M;\n if (vhat > hi) vhat = hi;\n return (float)vhat;\n };\n\n auto query_set = [&](const vector& idxs) -> long long {\n int d = (int)idxs.size();\n cout << \"q \" << d;\n for (int idx : idxs) {\n int i = idx / N, j = idx % N;\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n flush_out();\n long long resp;\n cin >> resp;\n return resp;\n };\n\n // Observe random projections: obs[t] ~ sum sign[t][idx] * v(idx)\n vector obs(T, 0.0f);\n for (int t = 0; t < T; t++) {\n float acc = 0.0f;\n for (int rep = 0; rep < R; rep++) {\n long long yA = query_set(Aset[t]);\n long long yB = query_set(Bset[t]);\n float vA = inv_est(yA, (int)Aset[t].size());\n float vB = inv_est(yB, (int)Bset[t].size());\n acc += (vA - vB);\n }\n obs[t] = acc / (float)R;\n }\n\n // Enumerate placements + contrib precompute\n vector> placements(M);\n for (int k = 0; k < M; k++) {\n int maxr = 0, maxc = 0;\n for (auto [r, c] : shapes[k]) {\n maxr = max(maxr, r);\n maxc = max(maxc, c);\n }\n int H = maxr + 1, W = maxc + 1;\n int diMax = N - H, djMax = N - W;\n\n vector ps;\n ps.reserve((diMax + 1) * (djMax + 1));\n\n for (int di = 0; di <= diMax; di++) {\n for (int dj = 0; dj <= djMax; dj++) {\n Placement p;\n p.cells.reserve(shapes[k].size());\n for (auto [r, c] : shapes[k]) {\n int ii = di + r, jj = dj + c;\n p.cells.push_back(ii * N + jj);\n }\n p.contrib.assign(T, 0);\n\n // Cache-friendly: for each t, sum signs over cells\n for (int t = 0; t < T; t++) {\n int s = 0;\n const auto &st = sign[t];\n for (int idx : p.cells) s += (int)st[idx];\n p.contrib[t] = (int16_t)s;\n }\n\n ps.push_back(std::move(p));\n }\n }\n placements[k] = std::move(ps);\n }\n\n // Coordinate descent optimization over placements\n vector choice(M, 0);\n for (int k = 0; k < M; k++) {\n choice[k] = rng.next_int(0, (int)placements[k].size() - 1);\n }\n\n vector pred(T, 0);\n for (int t = 0; t < T; t++) {\n int s = 0;\n for (int k = 0; k < M; k++) s += (int)placements[k][choice[k]].contrib[t];\n pred[t] = s;\n }\n\n // A few sweeps; stop if time is close.\n // This is extremely fast compared to SA.\n int maxSweeps = 60;\n for (int sweep = 0; sweep < maxSweeps; sweep++) {\n if (elapsed_ms() > 2100.0) break; // time guard (leave room for fallback I/O)\n\n bool changed = false;\n for (int k = 0; k < M; k++) {\n const int curP = choice[k];\n\n // base_pred = pred - contrib(curP)\n // objective for placement p:\n // sum_t (base_pred[t] + contrib[p][t] - obs[t])^2\n vector base_res(T);\n for (int t = 0; t < T; t++) {\n int base_pred_t = pred[t] - (int)placements[k][curP].contrib[t];\n base_res[t] = (float)base_pred_t - obs[t];\n }\n\n int bestP = curP;\n double bestObj = 1e100;\n\n const auto &pk = placements[k];\n for (int p = 0; p < (int)pk.size(); p++) {\n double o = 0.0;\n const auto &con = pk[p].contrib;\n for (int t = 0; t < T; t++) {\n float r = base_res[t] + (float)con[t];\n o += (double)r * (double)r;\n }\n if (o < bestObj) {\n bestObj = o;\n bestP = p;\n }\n }\n\n if (bestP != curP) {\n // apply update to pred\n for (int t = 0; t < T; t++) {\n pred[t] += (int)placements[k][bestP].contrib[t] - (int)placements[k][curP].contrib[t];\n }\n choice[k] = bestP;\n changed = true;\n }\n }\n if (!changed) break;\n }\n\n // Build union cells from inferred placements\n vector oil(V, 0);\n for (int k = 0; k < M; k++) {\n for (int idx : placements[k][choice[k]].cells) oil[idx] = 1;\n }\n vector> ansCells;\n ansCells.reserve(V);\n for (int idx = 0; idx < V; idx++) if (oil[idx]) ansCells.push_back({idx / N, idx % N});\n\n auto output_answer = [&](const vector>& cells) -> int {\n cout << \"a \" << (int)cells.size();\n for (auto [i, j] : cells) cout << \" \" << i << \" \" << j;\n cout << \"\\n\";\n flush_out();\n int ok;\n cin >> ok;\n return ok;\n };\n\n // First attempt\n {\n int ok = output_answer(ansCells);\n if (ok == 1) return 0;\n }\n\n // Fallback: drill everything (guaranteed)\n vector> finalCells;\n finalCells.reserve(V);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n flush_out();\n long long v;\n cin >> v;\n if (v > 0) finalCells.push_back({i, j});\n }\n }\n (void)output_answer(finalCells);\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nusing ll = long long;\nstatic const ll INF = (1LL<<62);\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int W, D, N;\n cin >> W >> D >> N;\n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) cin >> a[d][k];\n }\n\n // Precompute penalty f[k][w] = total shortage penalty over all days\n // if rank k gets a strip of width w (area = W*w).\n // w ranges 1..W\n vector> f(N, vector(W + 1, 0));\n for (int k = 0; k < N; k++) {\n for (int w = 1; w <= W; w++) {\n ll cap = 1LL * W * w;\n ll shortage_sum = 0;\n for (int d = 0; d < D; d++) {\n if ((ll)a[d][k] > cap) shortage_sum += (ll)a[d][k] - cap;\n }\n f[k][w] = 100LL * shortage_sum;\n }\n }\n\n // DP: dp[i][s] = min penalty using first i strips with total width s\n vector> dp(N + 1, vector(W + 1, INF));\n vector> prevW(N + 1, vector(W + 1, -1)); // chosen width at step i\n dp[0][0] = 0;\n\n for (int i = 0; i < N; i++) {\n for (int s = 0; s <= W; s++) {\n if (dp[i][s] >= INF) continue;\n int rem = W - s;\n int need = (N - 1 - i); // remaining strips after this one, each needs at least 1\n int maxw = rem - need;\n if (maxw < 1) continue;\n for (int w = 1; w <= maxw; w++) {\n int s2 = s + w;\n ll nd = dp[i][s] + f[i][w];\n if (nd < dp[i + 1][s2]) {\n dp[i + 1][s2] = nd;\n prevW[i + 1][s2] = (short)w;\n }\n }\n }\n }\n\n // Reconstruct widths\n vector widths(N, 1);\n int s = W;\n for (int i = N; i >= 1; i--) {\n int w = prevW[i][s];\n if (w < 0) {\n // Fallback (shouldn't happen): simple equal split\n widths.assign(N, W / N);\n for (int i2 = 0; i2 < W % N; i2++) widths[N - 1 - i2]++;\n break;\n }\n widths[i - 1] = w;\n s -= w;\n }\n\n // Sort widths so smaller ranks get smaller strips (never worse due to monotonic demands)\n sort(widths.begin(), widths.end());\n\n // Build strip x-coordinates\n vector x(N + 1, 0);\n for (int k = 0; k < N; k++) x[k + 1] = x[k] + widths[k];\n // Ensure x[N] == W\n if (x[N] != W) {\n // Adjust last strip to fix rounding/reconstruction errors (shouldn't happen)\n x[N] = W;\n }\n\n // Output same rectangles for all days:\n // Rectangle k: top-left (0, x[k]) bottom-right (W, x[k+1])\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n int i0 = 0;\n int j0 = x[k];\n int i1 = W;\n int j1 = x[k + 1];\n // Validity: j0 < j1 guaranteed because widths>=1\n cout << i0 << ' ' << j0 << ' ' << i1 << ' ' << j1 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nstatic constexpr int N = 9;\nstatic constexpr int M = 20;\nstatic constexpr int POS = 7; // stamp top-left positions 0..6\nstatic constexpr int A = M * POS * POS; // 980 actions\nstatic constexpr int MOD = 998244353;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline int nextInt(int n) { return (int)(nextU64() % (uint64_t)n); }\n inline double nextDouble01() {\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct CellDelta {\n uint8_t x, y; // 0..8\n int v; // 0..MOD-1\n};\n\nstruct State {\n array,N> board{};\n long long score = 0;\n vector ops; // size K, each in [-1, A-1]\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, K;\n cin >> Nin >> Min >> K;\n\n array,N> a{};\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> a[i][j];\n\n int s[M][3][3];\n for (int m = 0; m < M; m++)\n for (int i = 0; i < 3; i++)\n for (int j = 0; j < 3; j++)\n cin >> s[m][i][j];\n\n // Precompute each action's affected 9 cells.\n vector> act(A);\n for (int m = 0; m < M; m++) {\n for (int p = 0; p < POS; p++) {\n for (int q = 0; q < POS; q++) {\n int id = m * 49 + p * 7 + q;\n int k = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n act[id][k++] = CellDelta{(uint8_t)(p + di), (uint8_t)(q + dj), s[m][di][dj]};\n }\n }\n }\n }\n\n auto decode = [&](int id) {\n int m = id / 49;\n int r = id % 49;\n int p = r / 7;\n int q = r % 7;\n return array{m,p,q};\n };\n\n auto initStateFromA = [&]() -> State {\n State st;\n st.ops.assign(K, -1);\n st.score = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n st.board[i][j] = a[i][j];\n st.score += st.board[i][j];\n }\n return st;\n };\n\n auto applyAction = [&](State &st, int id, int sign) -> long long {\n if (id < 0) return 0;\n long long dsum = 0;\n const auto &lst = act[id];\n if (sign == +1) {\n for (const auto &cd : lst) {\n int &r = st.board[cd.x][cd.y];\n int old = r;\n int nw = old + cd.v;\n if (nw >= MOD) nw -= MOD;\n r = nw;\n dsum += (long long)(nw - old);\n }\n } else {\n for (const auto &cd : lst) {\n int &r = st.board[cd.x][cd.y];\n int old = r;\n int nw = old - cd.v;\n if (nw < 0) nw += MOD;\n r = nw;\n dsum += (long long)(nw - old);\n }\n }\n st.score += dsum;\n return dsum;\n };\n\n auto evalDeltaAdd = [&](const State &st, int id) -> long long {\n long long dsum = 0;\n const auto &lst = act[id];\n for (const auto &cd : lst) {\n int old = st.board[cd.x][cd.y];\n int nw = old + cd.v;\n if (nw >= MOD) nw -= MOD;\n dsum += (long long)(nw - old);\n }\n return dsum;\n };\n\n // One coordinate descent pass: for each slot, remove old and reinsert best action (or null).\n auto coordinateDescentPass = [&](State &st, XorShift64 &rng) -> bool {\n vector order(K);\n iota(order.begin(), order.end(), 0);\n // shuffle for better behavior\n for (int i = K - 1; i > 0; i--) swap(order[i], order[rng.nextInt(i + 1)]);\n\n bool changed = false;\n for (int idx : order) {\n int oldId = st.ops[idx];\n if (oldId >= 0) applyAction(st, oldId, -1);\n\n long long bestD = 0;\n int bestId = -1; // null\n for (int id = 0; id < A; id++) {\n long long d = evalDeltaAdd(st, id);\n if (d > bestD) {\n bestD = d;\n bestId = id;\n }\n }\n\n st.ops[idx] = bestId;\n if (bestId >= 0) applyAction(st, bestId, +1);\n if (bestId != oldId) changed = true;\n }\n return changed;\n };\n\n // Greedy builder with randomness among top-T actions each step.\n auto randomizedGreedy = [&](XorShift64 &rng, int TOPT) -> State {\n State st = initStateFromA();\n int used = 0;\n for (int t = 0; t < K; t++) {\n // keep top candidates in small vector\n array, 32> top; // TOPT <= 20-ish\n int sz = 0;\n\n for (int id = 0; id < A; id++) {\n long long d = evalDeltaAdd(st, id);\n if (d <= 0) continue;\n if (sz < TOPT) {\n top[sz++] = {d, id};\n if (sz == TOPT) {\n // make it a min-heap by d\n make_heap(top.begin(), top.begin()+sz, greater<>());\n }\n } else {\n // heap top is smallest\n if (d > top[0].first) {\n pop_heap(top.begin(), top.begin()+sz, greater<>());\n top[sz-1] = {d, id};\n push_heap(top.begin(), top.begin()+sz, greater<>());\n }\n }\n }\n\n if (sz == 0) break;\n\n // Convert heap to list\n vector> cand(top.begin(), top.begin()+sz);\n // Weighted random by delta (clipped)\n long double sum = 0;\n for (auto &p : cand) sum += (long double)p.first;\n long double r = rng.nextDouble01() * (double)sum;\n int pick = cand.back().second;\n for (auto &p : cand) {\n r -= (long double)p.first;\n if (r <= 0) { pick = p.second; break; }\n }\n\n st.ops[t] = pick;\n applyAction(st, pick, +1);\n used++;\n }\n // remaining are -1 already\n return st;\n };\n\n XorShift64 rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n const double TIME_LIMIT = 1.95;\n auto t0 = chrono::steady_clock::now();\n auto elapsedSec = [&]() -> double {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - t0).count();\n };\n\n // Multi-start: a few different greedy initializations, then local optimize.\n State best;\n best.score = LLONG_MIN;\n {\n int starts = 3;\n for (int stid = 0; stid < starts; stid++) {\n State st = randomizedGreedy(rng, 10);\n // push to local optimum quickly\n for (int it = 0; it < 4; it++) {\n if (!coordinateDescentPass(st, rng)) break;\n }\n if (st.score > best.score) best = st;\n }\n }\n\n State cur = best;\n\n // ILS + SA acceptance between local optima\n const double T0 = 2.0e9;\n const double T1 = 5.0e4;\n\n while (true) {\n double et = elapsedSec();\n if (et >= TIME_LIMIT) break;\n double prog = et / TIME_LIMIT;\n double T = T0 * pow(T1 / T0, prog);\n\n State trial = cur;\n\n // small perturbation: random replacements\n int R = 6;\n for (int r = 0; r < R; r++) {\n int idx = rng.nextInt(K);\n int oldId = trial.ops[idx];\n\n int newId;\n if (rng.nextInt(100) < 20) newId = -1;\n else newId = rng.nextInt(A);\n if (newId == oldId) continue;\n\n applyAction(trial, oldId, -1);\n applyAction(trial, newId, +1);\n trial.ops[idx] = newId;\n }\n\n // settle to a local optimum (1-2 passes are enough given small size)\n coordinateDescentPass(trial, rng);\n if (rng.nextInt(100) < 40) coordinateDescentPass(trial, rng);\n\n long long delta = trial.score - cur.score;\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / T);\n if (rng.nextDouble01() < prob) accept = true;\n }\n if (accept) cur = std::move(trial);\n\n if (cur.score > best.score) best = cur;\n }\n\n // Output (compress non-null)\n vector> out;\n out.reserve(K);\n for (int i = 0; i < K; i++) {\n if (best.ops[i] < 0) continue;\n out.push_back(decode(best.ops[i]));\n }\n\n cout << out.size() << \"\\n\";\n for (auto &x : out) {\n cout << x[0] << \" \" << x[1] << \" \" << x[2] << \"\\n\";\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstatic constexpr int N = 5;\nstatic constexpr int MAXT = 10000;\n\nstruct Pos { int x, y; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin;\n cin >> Nin;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> A[i][j];\n\n // For each container id, where/when it will arrive (receiving row, index).\n vector recv_row(N*N, -1), recv_idx(N*N, -1);\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int id = A[i][j];\n recv_row[id] = i;\n recv_idx[id] = j;\n }\n\n // Grid: -1 empty, otherwise container id.\n int grid[N][N];\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) grid[i][j] = -1;\n\n // Container positions:\n // (-2,-2) unspawned, (-1,-1) dispatched, otherwise location on grid.\n vector cont_pos(N*N, Pos{-2,-2});\n\n // Receiving pointer per row: next container index to spawn from that receiving gate.\n int next_in[N] = {0,0,0,0,0};\n\n // Large crane state (only crane 0 is used after bombing others)\n Pos crane{0,0};\n int holding = -1; // container id, -1 if none\n\n // Output action strings\n vector out(N);\n deque plan; // planned actions for large crane\n\n auto in_bounds = [&](int x, int y)->bool{\n return 0 <= x && x < N && 0 <= y && y < N;\n };\n\n auto manhattan_plan = [&](Pos from, Pos to) {\n // Simple Manhattan route: vertical then horizontal.\n while (from.x < to.x) { plan.push_back('D'); from.x++; }\n while (from.x > to.x) { plan.push_back('U'); from.x--; }\n while (from.y < to.y) { plan.push_back('R'); from.y++; }\n while (from.y > to.y) { plan.push_back('L'); from.y--; }\n };\n\n auto is_empty = [&](int x, int y)->bool{\n return grid[x][y] == -1;\n };\n\n auto find_storage = [&]()->Pos{\n // Prefer interior columns 1..3 (never dispatch column 4).\n for (int y = 1; y <= 3; y++) {\n for (int x = 0; x < N; x++) {\n if (grid[x][y] == -1) return Pos{x,y};\n }\n }\n // Next, allow left edge rows already fully spawned.\n for (int x = 0; x < N; x++) {\n if (next_in[x] >= N && grid[x][0] == -1) return Pos{x,0};\n }\n // Finally, any empty non-dispatch cell.\n for (int x = 0; x < N; x++) for (int y = 0; y < N; y++) {\n if (y == N-1) continue;\n if (grid[x][y] == -1) return Pos{x,y};\n }\n // Should never happen; at least current cell is empty after a pick, but return it.\n return crane;\n };\n\n auto next_target = [&]()->int{\n for (int t = 0; t < N*N; t++) {\n if (!(cont_pos[t].x == -1 && cont_pos[t].y == -1)) {\n // not dispatched\n // But if unspawned (-2,-2) it's still not dispatched, keep as target.\n return t;\n }\n }\n return -1;\n };\n\n auto dispatched_count = [&]()->int{\n int c = 0;\n for (int t = 0; t < N*N; t++) if (cont_pos[t].x == -1) c++;\n return c;\n };\n\n // Simulation loop\n for (int turn = 0; turn < MAXT; turn++) {\n // Step 1: receiving\n for (int i = 0; i < N; i++) {\n if (next_in[i] >= N) continue;\n // Condition: no container at (i,0) and no crane holding a container at (i,0).\n // We have only large crane. It can stand there empty-handed without blocking.\n bool crane_holding_here = (holding != -1 && crane.x == i && crane.y == 0);\n if (grid[i][0] == -1 && !crane_holding_here) {\n int id = A[i][next_in[i]];\n next_in[i]++;\n grid[i][0] = id;\n cont_pos[id] = Pos{i,0};\n }\n }\n\n // Ensure output strings have current turn slot.\n for (int i = 0; i < N; i++) out[i].push_back('.');\n\n // Small cranes: bomb at turn 0, then do nothing\n if (turn == 0) {\n for (int i = 1; i < N; i++) out[i][turn] = 'B';\n }\n\n // Large crane action planning\n int tgt = next_target();\n if (tgt == -1) {\n // all dispatched, we can stop early (but need at least 1 length; already have).\n // Trim trailing '.' is allowed but not necessary.\n break;\n }\n\n if (plan.empty()) {\n int target = tgt;\n\n // If holding something, decide where to put it.\n if (holding != -1) {\n int want = target;\n int dr = holding / N;\n // If holding is exactly the next target, go dispatch it.\n if (holding == want) {\n Pos gate{dr, N-1};\n if (!(crane.x == gate.x && crane.y == gate.y)) {\n manhattan_plan(crane, gate);\n }\n plan.push_back('Q');\n } else {\n // Drop to storage\n Pos st = find_storage();\n if (!(crane.x == st.x && crane.y == st.y)) {\n manhattan_plan(crane, st);\n }\n plan.push_back('Q');\n }\n } else {\n // Not holding: if target is on grid, pick and dispatch.\n if (cont_pos[target].x >= 0) {\n Pos p = cont_pos[target];\n if (!(crane.x == p.x && crane.y == p.y)) {\n manhattan_plan(crane, p);\n }\n plan.push_back('P');\n Pos gate{target / N, N-1};\n // after pick, crane remains on p; route from p to gate\n manhattan_plan(p, gate);\n plan.push_back('Q');\n } else {\n // Target not spawned yet: go to its receiving gate and clear until it appears.\n int rr = recv_row[target];\n Pos g{rr, 0};\n if (!(crane.x == g.x && crane.y == g.y)) {\n manhattan_plan(crane, g);\n } else {\n // We're on the gate. After receiving step, there should be a container unless exhausted.\n if (grid[rr][0] != -1) {\n int c = grid[rr][0];\n if (c == target) {\n plan.push_back('P');\n Pos gate{target / N, N-1};\n manhattan_plan(g, gate);\n plan.push_back('Q');\n } else {\n // Pick and store it away.\n plan.push_back('P');\n // after pick, need a place to drop\n Pos st = find_storage();\n manhattan_plan(g, st);\n plan.push_back('Q');\n }\n } else {\n // Shouldn't happen unless the row is exhausted; just wait.\n plan.push_back('.');\n }\n }\n }\n }\n }\n\n // Execute one action for the large crane this turn\n char act0 = plan.empty() ? '.' : plan.front();\n if (!plan.empty()) plan.pop_front();\n out[0][turn] = act0;\n\n // Step 2: apply large crane action\n auto do_move = [&](int dx, int dy) {\n int nx = crane.x + dx, ny = crane.y + dy;\n if (!in_bounds(nx, ny)) return false;\n crane = Pos{nx, ny};\n return true;\n };\n\n bool ok = true;\n if (act0 == '.') {\n // nothing\n } else if (act0 == 'U') ok = do_move(-1, 0);\n else if (act0 == 'D') ok = do_move(1, 0);\n else if (act0 == 'L') ok = do_move(0, -1);\n else if (act0 == 'R') ok = do_move(0, 1);\n else if (act0 == 'P') {\n if (holding != -1) ok = false;\n else {\n int &cell = grid[crane.x][crane.y];\n if (cell == -1) ok = false;\n else {\n holding = cell;\n cont_pos[holding] = Pos{-3,-3}; // held\n cell = -1;\n }\n }\n } else if (act0 == 'Q') {\n if (holding == -1) ok = false;\n else {\n int &cell = grid[crane.x][crane.y];\n if (cell != -1) ok = false;\n else {\n cell = holding;\n cont_pos[holding] = crane;\n holding = -1;\n }\n }\n } else {\n // 'B' not used for large\n ok = false;\n }\n\n // If something went wrong, fall back to safe no-op from now (avoid UB),\n // but in normal operation this should never trigger.\n if (!ok) {\n // Output a minimal valid solution instead of crashing:\n // just stop planning further.\n // (In contest you'd rather assert(false), but keep it safe.)\n plan.clear();\n }\n\n // Step 3: dispatch\n for (int i = 0; i < N; i++) {\n int &cell = grid[i][N-1];\n if (cell != -1) {\n int id = cell;\n cell = -1;\n cont_pos[id] = Pos{-1,-1}; // dispatched\n\n // We don't strictly need to verify correctness, but you can sanity-check:\n // if (id/5 != i) { /* wrong gate */ }\n }\n }\n\n // If all dispatched, we can stop early (keeping current length is fine).\n if (dispatched_count() == N*N) break;\n }\n\n // Remove trailing '.' uniformly? Not required. Just output as-is.\n // Ensure at least length 1 (guaranteed by loop or by turn==0 push).\n for (int i = 0; i < N; i++) {\n if (out[i].empty()) out[i] = \".\";\n cout << out[i] << \"\\n\";\n }\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Pos {\n int r, c;\n};\nstatic inline int manhattan(const Pos& a, const Pos& b) {\n return abs(a.r - b.r) + abs(a.c - b.c);\n}\n\nstatic inline string step_dir(const Pos& a, const Pos& b) {\n if (b.r == a.r - 1 && b.c == a.c) return \"U\";\n if (b.r == a.r + 1 && b.c == a.c) return \"D\";\n if (b.r == a.r && b.c == a.c - 1) return \"L\";\n if (b.r == a.r && b.c == a.c + 1) return \"R\";\n return \"\"; // should not happen for adjacent steps\n}\n\n// Apply transpose mapping (r,c)->(c,r)\nstatic inline Pos transposed(Pos p) { return Pos{p.c, p.r}; }\n\n// Candidate path generator base patterns.\n// Each returns an order of positions to be processed (all cells except (0,0)),\n// and ensures the walk from start through that order is adjacent step-by-step.\nvector gen_col0_then_rowserp(int N) {\n // Start at (0,0), go down column 0 (process (1,0)..(N-1,0)),\n // then process remaining columns 1..N-1 row-by-row from bottom to top, serpentine.\n vector seq;\n for (int r = 1; r < N; r++) seq.push_back({r, 0}); // down col0\n\n for (int r = N - 1; r >= 0; r--) {\n int t = (N - 1 - r); // 0,1,2...\n if (t % 2 == 0) { // left->right for cols 1..N-1\n for (int c = 1; c < N; c++) seq.push_back({r, c});\n } else { // right->left\n for (int c = N - 1; c >= 1; c--) seq.push_back({r, c});\n }\n }\n // seq has size N*N - 1\n return seq;\n}\n\nvector gen_col0_then_colserp(int N) {\n // Start at (0,0), go down column 0 (process (1,0)..(N-1,0)),\n // then process columns 1..N-1, each full column top-bottom alternating direction,\n // starting from bottom row to keep adjacency from (N-1,0)->(N-1,1).\n vector seq;\n for (int r = 1; r < N; r++) seq.push_back({r, 0}); // down col0\n\n for (int c = 1; c < N; c++) {\n int t = c - 1;\n if (t % 2 == 0) {\n // go up from bottom to top\n for (int r = N - 1; r >= 0; r--) seq.push_back({r, c});\n } else {\n // go down from top to bottom\n for (int r = 0; r < N; r++) seq.push_back({r, c});\n }\n }\n return seq;\n}\n\nvector gen_row0_then_colserp(int N) {\n // Start at (0,0), go right on row 0 (process (0,1)..(0,N-1)),\n // then for columns from right to left, process rows 1..N-1 serpentine\n // to maintain adjacency from (0,N-1)->(1,N-1).\n vector seq;\n for (int c = 1; c < N; c++) seq.push_back({0, c}); // right along row0\n\n for (int c = N - 1; c >= 0; c--) {\n int t = (N - 1 - c);\n if (t % 2 == 0) {\n // go down rows 1..N-1\n for (int r = 1; r < N; r++) seq.push_back({r, c});\n } else {\n // go up rows N-1..1\n for (int r = N - 1; r >= 1; r--) seq.push_back({r, c});\n }\n }\n return seq;\n}\n\nvector gen_row0_then_rowserp(int N) {\n // Start at (0,0), go right on row 0 (process (0,1)..(0,N-1)),\n // then process remaining rows 1..N-1 as a snake starting from column N-1\n // to maintain adjacency from (0,N-1)->(1,N-1).\n vector seq;\n for (int c = 1; c < N; c++) seq.push_back({0, c}); // row0\n\n for (int r = 1; r < N; r++) {\n int t = r - 1;\n if (t % 2 == 0) {\n // go left from N-1 to 0\n for (int c = N - 1; c >= 0; c--) seq.push_back({r, c});\n } else {\n // go right 0 to N-1\n for (int c = 0; c < N; c++) seq.push_back({r, c});\n }\n }\n return seq;\n}\n\nstruct Plan {\n long long cost = (1LL<<62);\n long long B = 0;\n vector order; // cells to process (exclude start)\n bool transposed = false;\n};\n\nPlan evaluate_plan(int N, const vector>& h0, const vector& order) {\n const int h00 = h0[0][0];\n\n // Compute min prefix sum of heights in order\n long long pref = 0, minPref = 0;\n for (auto p : order) {\n pref += h0[p.r][p.c];\n minPref = min(minPref, pref);\n }\n long long B = max({0LL, -minPref, (long long)h00});\n\n // Simulate exact cost (including movement with current load, load/unload costs)\n long long cost = 0;\n long long load = 0;\n\n // initial load at start\n if (B > 0) { cost += B; load += B; }\n\n Pos cur{0,0};\n // walk through order\n for (auto nxt : order) {\n // move (must be adjacent)\n int dist = manhattan(cur, nxt);\n if (dist != 1) {\n // invalid (shouldn't happen for our generators)\n return Plan{(1LL<<62), B, order, false};\n }\n cost += 100 + load;\n cur = nxt;\n\n int hh = h0[cur.r][cur.c];\n cost += llabs((long long)hh);\n load += hh;\n if (load < 0) {\n // Should not happen if B computed correctly, but guard.\n return Plan{(1LL<<62), B, order, false};\n }\n }\n\n // return to start via a fixed shortest path (up then left)\n while (cur.r > 0) {\n cost += 100 + load;\n cur.r--;\n }\n while (cur.c > 0) {\n cost += 100 + load;\n cur.c--;\n }\n\n // final unload all load onto start\n if (load > 0) cost += load, load = 0;\n\n // Done.\n Plan res;\n res.cost = cost;\n res.B = B;\n res.order = order;\n return res;\n}\n\nvector build_output(int N, const vector>& h0, const Plan& best) {\n vector ops;\n long long load = 0;\n\n auto emit_load = [&](long long d) {\n if (d <= 0) return;\n ops.push_back(\"+\" + to_string(d));\n load += d;\n };\n auto emit_unload = [&](long long d) {\n if (d <= 0) return;\n ops.push_back(\"-\" + to_string(d));\n load -= d;\n };\n auto emit_move = [&](const string& s) { ops.push_back(s); };\n\n // initial +B at (0,0)\n if (best.B > 0) emit_load(best.B);\n\n Pos cur{0,0};\n // process each cell in order\n for (auto nxt : best.order) {\n // move adjacent\n string dir = step_dir(cur, nxt);\n if (dir.empty()) {\n // should not happen\n // fallback: move by Manhattan (shouldn't be needed)\n while (cur.r < nxt.r) { emit_move(\"D\"); cur.r++; }\n while (cur.r > nxt.r) { emit_move(\"U\"); cur.r--; }\n while (cur.c < nxt.c) { emit_move(\"R\"); cur.c++; }\n while (cur.c > nxt.c) { emit_move(\"L\"); cur.c--; }\n } else {\n emit_move(dir);\n cur = nxt;\n }\n\n int hh = h0[cur.r][cur.c];\n if (hh > 0) emit_load(hh);\n else if (hh < 0) emit_unload(- (long long)hh);\n }\n\n // return to (0,0): up then left\n while (cur.r > 0) { emit_move(\"U\"); cur.r--; }\n while (cur.c > 0) { emit_move(\"L\"); cur.c--; }\n\n // unload remaining onto start\n if (load > 0) emit_unload(load);\n\n // ops size is far below 100000\n return ops;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> h[i][j];\n\n vector> candidates;\n\n // Base 4 patterns\n candidates.push_back(gen_col0_then_rowserp(N));\n candidates.push_back(gen_col0_then_colserp(N));\n candidates.push_back(gen_row0_then_colserp(N));\n candidates.push_back(gen_row0_then_rowserp(N));\n\n // Their transposes (often different)\n for (int k = 0; k < 4; k++) {\n vector t;\n t.reserve(candidates[k].size());\n for (auto p : candidates[k]) t.push_back(transposed(p));\n candidates.push_back(std::move(t));\n }\n\n Plan best;\n for (auto &ord : candidates) {\n // sanity: must have N*N-1 cells and exclude (0,0)\n if ((int)ord.size() != N*N - 1) continue;\n bool ok = true;\n for (auto p : ord) if (p.r == 0 && p.c == 0) ok = false;\n if (!ok) continue;\n\n auto plan = evaluate_plan(N, h, ord);\n if (plan.cost < best.cost) best = std::move(plan);\n }\n\n auto ops = build_output(N, h, best);\n for (auto &s : ops) cout << s << \"\\n\";\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nstatic constexpr int N = 6;\nstatic constexpr int M = 15;\n\nstruct XorShift64 {\n uint64_t x = 88172645463325252ull;\n explicit XorShift64(uint64_t seed = 0) {\n if (seed) x ^= seed + 0x9e3779b97f4a7c15ULL;\n }\n uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int lo, int hi) { // [lo, hi)\n return lo + (int)(nextU64() % (uint64_t)(hi - lo));\n }\n double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Seed {\n array x{};\n int v = 0;\n int mx = 0;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, T;\n cin >> Nin >> Min >> T;\n const int S = 2 * Nin * (Nin - 1); // 60\n vector seeds(S);\n\n auto readSeeds = [&]() {\n for (int i = 0; i < S; i++) {\n int sum = 0, mx = 0;\n for (int l = 0; l < M; l++) {\n int a; cin >> a;\n seeds[i].x[l] = a;\n sum += a;\n mx = max(mx, a);\n }\n seeds[i].v = sum;\n seeds[i].mx = mx;\n }\n };\n readSeeds();\n\n auto pid = [&](int r, int c){ return r * N + c; };\n\n // List of edges (unordered pairs of positions 0..35)\n vector> edges;\n edges.reserve(60);\n for (int r = 0; r < N; r++) for (int c = 0; c < N - 1; c++)\n edges.push_back({pid(r,c), pid(r,c+1)});\n for (int r = 0; r < N - 1; r++) for (int c = 0; c < N; c++)\n edges.push_back({pid(r,c), pid(r+1,c)});\n\n // Neighbor list per position for O(deg) swap delta\n array, 36> nbr;\n for (auto [a,b] : edges) {\n nbr[a].push_back(b);\n nbr[b].push_back(a);\n }\n\n XorShift64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());\n\n // Parameters (tuned to emphasize tail)\n const double zTail = 2.8; // ~sqrt(2 log 60)\n const double tau = 75.0; // exp scaling; smaller => more \"max-like\"\n\n vector> w(S, vector(S, 0.0));\n\n auto buildPairUtility = [&]() {\n for (int i = 0; i < S; i++) {\n for (int j = i + 1; j < S; j++) {\n double mean = 0.5 * (seeds[i].v + seeds[j].v);\n\n double diff2 = 0.0;\n int best = 0;\n for (int l = 0; l < M; l++) {\n int a = seeds[i].x[l], b = seeds[j].x[l];\n double d = double(a - b);\n diff2 += d * d;\n best += max(a, b);\n }\n double st = 0.5 * sqrt(diff2);\n double pot = min(best, mean + zTail * st); // tail-ish but bounded\n double val = exp(pot / tau);\n w[i][j] = w[j][i] = val;\n }\n w[i][i] = exp(seeds[i].v / tau);\n }\n };\n\n auto selectCandidates = [&]() -> vector {\n vector ids(S);\n iota(ids.begin(), ids.end(), 0);\n\n // Sort by total value\n vector byV = ids;\n sort(byV.begin(), byV.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n\n // Sort by max component (keeps \"spiky\" specialists)\n vector byMx = ids;\n sort(byMx.begin(), byMx.end(), [&](int a, int b){\n if (seeds[a].mx != seeds[b].mx) return seeds[a].mx > seeds[b].mx;\n return seeds[a].v > seeds[b].v;\n });\n\n vector picked;\n picked.reserve(36);\n vector used(S, 0);\n\n auto add = [&](int s){\n if (!used[s]) {\n used[s] = 1;\n picked.push_back(s);\n }\n };\n\n // More weight on high-sum seeds than before\n for (int i = 0; i < min(S, 22); i++) add(byV[i]);\n\n // Per-criterion top1 to keep extrema across dimensions\n for (int l = 0; l < M; l++) {\n int bestId = 0;\n for (int i = 1; i < S; i++) {\n if (seeds[i].x[l] > seeds[bestId].x[l]) bestId = i;\n }\n add(bestId);\n }\n\n // Add some spiky seeds\n for (int i = 0; i < min(S, 10); i++) add(byMx[i]);\n\n // Fill up by value\n for (int i = 0; (int)picked.size() < 36 && i < S; i++) add(byV[i]);\n\n if ((int)picked.size() > 36) {\n // keep best by value as tiebreak\n sort(picked.begin(), picked.end(), [&](int a, int b){\n if (seeds[a].v != seeds[b].v) return seeds[a].v > seeds[b].v;\n return seeds[a].mx > seeds[b].mx;\n });\n picked.resize(36);\n }\n return picked;\n };\n\n auto calcObjective = [&](const vector& grid) -> double {\n double obj = 0.0;\n for (auto [a,b] : edges) obj += w[grid[a]][grid[b]];\n return obj;\n };\n\n auto swapDelta = [&](const vector& grid, int p, int q) -> double {\n int A = grid[p], B = grid[q];\n double delta = 0.0;\n\n // Edges incident to p\n for (int n : nbr[p]) {\n if (n == q) continue; // edge (p,q) unchanged because w is symmetric\n int C = grid[n];\n delta += w[B][C] - w[A][C];\n }\n // Edges incident to q\n for (int n : nbr[q]) {\n if (n == p) continue;\n int C = grid[n];\n delta += w[A][C] - w[B][C];\n }\n return delta;\n };\n\n auto solveLayoutSA = [&](const vector& cand, double timeLimitSec) -> vector {\n auto start = chrono::steady_clock::now();\n auto deadline = start + chrono::duration(timeLimitSec);\n\n vector bestGrid(36);\n double bestObj = -1e100;\n\n int starts = 3;\n for (int st = 0; st < starts; st++) {\n // Initial layout: alternate between top/high and random for diversity\n vector perm = cand;\n if (st == 0) {\n // descending by v\n sort(perm.begin(), perm.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n } else {\n for (int i = 35; i >= 1; i--) {\n int j = rng.nextInt(0, i + 1);\n swap(perm[i], perm[j]);\n }\n }\n\n vector curGrid(36);\n for (int i = 0; i < 36; i++) curGrid[i] = perm[i];\n\n double curObj = calcObjective(curGrid);\n vector localBestGrid = curGrid;\n double localBestObj = curObj;\n\n // SA schedule\n const double T0 = 3000.0;\n const double T1 = 5.0;\n\n long long it = 0;\n while (chrono::steady_clock::now() < deadline) {\n it++;\n // time-based cooling\n double tprog = chrono::duration(chrono::steady_clock::now() - start).count() / timeLimitSec;\n if (tprog > 1.0) tprog = 1.0;\n double temp = T0 * pow(T1 / T0, tprog);\n\n int p = rng.nextInt(0, 36);\n int q = rng.nextInt(0, 36);\n if (p == q) continue;\n\n double delta = swapDelta(curGrid, p, q);\n if (delta >= 0.0 || rng.nextDouble() < exp(delta / temp)) {\n swap(curGrid[p], curGrid[q]);\n curObj += delta;\n if (curObj > localBestObj) {\n localBestObj = curObj;\n localBestGrid = curGrid;\n }\n }\n }\n\n if (localBestObj > bestObj) {\n bestObj = localBestObj;\n bestGrid = localBestGrid;\n }\n }\n\n return bestGrid;\n };\n\n auto allStart = chrono::steady_clock::now();\n auto allDeadline = allStart + chrono::milliseconds(1900);\n\n for (int t = 0; t < T; t++) {\n buildPairUtility();\n vector cand = selectCandidates();\n\n auto now = chrono::steady_clock::now();\n double remain = chrono::duration(allDeadline - now).count();\n if (remain < 0.02) remain = 0.02;\n double perTurn = remain / (T - t);\n\n vector grid = solveLayoutSA(cand, perTurn * 0.95);\n\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n if (c) cout << ' ';\n cout << grid[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n\n readSeeds();\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Pos { int x, y; };\n\nstatic inline int mod4(int x){ x%=4; if(x<0) x+=4; return x; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n\n // Board state tracking for monotone progress\n vector> surplus(N, vector(N, 0)); // cur=1, target=0\n vector> deficit(N, vector(N, 0)); // cur=0, target=1\n vector> cur(N, vector(N, 0));\n\n int surplusCnt = 0, deficitCnt = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n cur[i][j] = (s[i][j] == '1');\n int T = (t[i][j] == '1');\n if (cur[i][j] == 1 && T == 0) surplus[i][j] = 1, surplusCnt++;\n if (cur[i][j] == 0 && T == 1) deficit[i][j] = 1, deficitCnt++;\n }\n\n auto inside = [&](int x, int y)->bool {\n return 0 <= x && x < N && 0 <= y && y < N;\n };\n\n // Arm design: root(0) + 4 children (1..4), length 1\n const int Vp = 5;\n cout << Vp << \"\\n\";\n for (int u = 1; u < Vp; u++) cout << 0 << \" \" << 1 << \"\\n\";\n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n\n // Directions: 0=Up,1=Right,2=Down,3=Left\n int dx4[4] = {-1, 0, 1, 0};\n int dy4[4] = {0, 1, 0, -1};\n\n // Each leaf has its own current direction. Initially all edges extend to the right.\n array dir;\n dir.fill(1); // Right\n array hold{};\n hold.fill(0);\n\n auto done = [&]() {\n if (surplusCnt != 0 || deficitCnt != 0) return false;\n for (int u = 1; u <= 4; u++) if (hold[u]) return false;\n return true;\n };\n\n // Build periodic snake route (forward and backward)\n vector forward;\n forward.reserve(N * N);\n for (int i = 0; i < N; i++) {\n if (i % 2 == 0) for (int j = 0; j < N; j++) forward.push_back({i, j});\n else for (int j = N - 1; j >= 0; j--) forward.push_back({i, j});\n }\n vector route = forward;\n for (int k = (int)forward.size() - 2; k >= 0; k--) route.push_back(forward[k]);\n // route[0]==route.back()==(0,0)\n\n auto moveChar = [&](Pos a, Pos b)->char {\n int dx = b.x - a.x, dy = b.y - a.y;\n if (dx == -1 && dy == 0) return 'U';\n if (dx == 1 && dy == 0) return 'D';\n if (dx == 0 && dy == -1) return 'L';\n if (dx == 0 && dy == 1) return 'R';\n return '.';\n };\n\n auto rotCharToReach = [&](int from, int to)->char {\n if (from == to) return '.';\n if (mod4(from + 1) == to) return 'R';\n if (mod4(from + 3) == to) return 'L';\n // can't in one step\n return '?';\n };\n\n auto minRotDist = [&](int from, int to)->int {\n int cw = mod4(to - from);\n int ccw = mod4(from - to);\n return min(cw, ccw); // 0,1,2\n };\n\n // Plan immediate (<=1 rotation) placements then picks for a fixed root position.\n struct Plan {\n array rot; // for vertices 1..4\n array actP; // 'P' or '.'\n int places = 0;\n int picks = 0;\n };\n\n auto planImmediateAt = [&](int px, int py)->Plan {\n Plan best;\n best.rot.fill('.');\n best.actP.fill('.');\n best.places = -1;\n best.picks = -1;\n\n // availability by direction at this position\n array isDef{}, isSur{};\n for (int d = 0; d < 4; d++) {\n int nx = px + dx4[d], ny = py + dy4[d];\n if (!inside(nx, ny)) { isDef[d] = 0; isSur[d] = 0; continue; }\n isDef[d] = deficit[nx][ny];\n isSur[d] = surplus[nx][ny];\n }\n\n // brute force search over assignments for placements then picks\n // Because size is tiny, do DFS.\n array rotTmp; rotTmp.fill('.');\n array actTmp; actTmp.fill('.');\n array usedDir{}; usedDir.fill(0);\n\n int bestPlace = -1;\n int bestPlaceRotCost = 1e9;\n array rotAfterPlace;\n array actAfterPlace;\n array usedAfterPlace;\n\n function dfsPlace = [&](int u, int placeCnt, int rotCost) {\n if (u == 5) {\n if (placeCnt > bestPlace || (placeCnt == bestPlace && rotCost < bestPlaceRotCost)) {\n bestPlace = placeCnt;\n bestPlaceRotCost = rotCost;\n rotAfterPlace = rotTmp;\n actAfterPlace = actTmp;\n usedAfterPlace = usedDir;\n }\n return;\n }\n if (u == 0) { dfsPlace(u+1, placeCnt, rotCost); return; }\n if (u >= 1 && u <= 4) {\n if (!hold[u]) {\n // leave for pick stage\n dfsPlace(u+1, placeCnt, rotCost);\n return;\n }\n // Option: do nothing\n dfsPlace(u+1, placeCnt, rotCost);\n\n // Try placing to any deficit dir reachable in <=1 step and not used\n for (int d = 0; d < 4; d++) if (isDef[d] && !usedDir[d]) {\n int dist = minRotDist(dir[u], d);\n if (dist > 1) continue;\n char rc = rotCharToReach(dir[u], d);\n if (rc == '?') continue;\n\n // apply\n char prevRot = rotTmp[u];\n char prevAct = actTmp[u];\n usedDir[d] = 1;\n rotTmp[u] = rc;\n actTmp[u] = 'P';\n dfsPlace(u+1, placeCnt + 1, rotCost + (rc != '.'));\n // revert\n rotTmp[u] = prevRot;\n actTmp[u] = prevAct;\n usedDir[d] = 0;\n }\n }\n };\n\n dfsPlace(1, 0, 0);\n\n // Now with fixed best placement decisions, decide picks on remaining dirs.\n // Start state\n rotTmp = rotAfterPlace;\n actTmp = actAfterPlace;\n usedDir = usedAfterPlace;\n\n int bestPick = -1;\n int bestPickRotCost = 1e9;\n array rotFinal;\n array actFinal;\n\n function dfsPick = [&](int u, int pickCnt, int rotCost) {\n if (u == 5) {\n if (pickCnt > bestPick || (pickCnt == bestPick && rotCost < bestPickRotCost)) {\n bestPick = pickCnt;\n bestPickRotCost = rotCost;\n rotFinal = rotTmp;\n actFinal = actTmp;\n }\n return;\n }\n if (u < 1 || u > 4) { dfsPick(u+1, pickCnt, rotCost); return; }\n\n if (hold[u]) {\n // already holding; leave as is (maybe it placed this turn; but action 'P' already set)\n dfsPick(u+1, pickCnt, rotCost);\n return;\n }\n\n // Option: do nothing\n dfsPick(u+1, pickCnt, rotCost);\n\n // Try picking from any surplus dir reachable in <=1 step and not used\n for (int d = 0; d < 4; d++) if (isSur[d] && !usedDir[d]) {\n int dist = minRotDist(dir[u], d);\n if (dist > 1) continue;\n char rc = rotCharToReach(dir[u], d);\n if (rc == '?') continue;\n\n char prevRot = rotTmp[u];\n char prevAct = actTmp[u];\n usedDir[d] = 1;\n rotTmp[u] = rc;\n actTmp[u] = 'P';\n dfsPick(u+1, pickCnt + 1, rotCost + (rc != '.'));\n rotTmp[u] = prevRot;\n actTmp[u] = prevAct;\n usedDir[d] = 0;\n }\n };\n\n dfsPick(1, 0, 0);\n\n Plan out;\n out.rot = rotFinal;\n out.actP = actFinal;\n out.places = bestPlace;\n out.picks = bestPick;\n if (out.places < 0) { // fallback safety\n out.rot.fill('.');\n out.actP.fill('.');\n out.places = 0;\n out.picks = 0;\n }\n return out;\n };\n\n // If we can't place immediately but we are adjacent to some deficit and have a holding leaf\n // that needs 180-degree rotation, do a \"prep\" (stay and rotate one step).\n auto planPrep180At = [&](int px, int py)->optional> {\n // returns (leaf u, rotation char) or nullopt\n // Find any adjacent deficit dir d and holding leaf u with minDist==2.\n int bestU = -1;\n char bestRot = '.';\n for (int d = 0; d < 4; d++) {\n int nx = px + dx4[d], ny = py + dy4[d];\n if (!inside(nx, ny)) continue;\n if (!deficit[nx][ny]) continue;\n\n for (int u = 1; u <= 4; u++) if (hold[u]) {\n if (minRotDist(dir[u], d) == 2) {\n // rotate one step toward d (either L or R reduces dist from 2 to 1)\n // Choose deterministic: prefer 'R'.\n int cw = mod4(d - dir[u]);\n // cw is 2 here, either L or R works; pick 'R' by default.\n char rc = 'R';\n bestU = u;\n bestRot = rc;\n return make_pair(bestU, bestRot);\n }\n }\n }\n return nullopt;\n };\n\n auto applyTurn = [&](char mv, const array& rotCmd, const array& actCmd) {\n // Move\n if (mv == 'U') rx--;\n else if (mv == 'D') rx++;\n else if (mv == 'L') ry--;\n else if (mv == 'R') ry++;\n // Rotations (for leaves 1..4)\n for (int u = 1; u <= 4; u++) {\n if (rotCmd[u] == 'L') dir[u] = mod4(dir[u] + 3);\n else if (rotCmd[u] == 'R') dir[u] = mod4(dir[u] + 1);\n }\n // Actions processed in increasing vertex order. Root(0) does nothing.\n for (int u = 1; u <= 4; u++) {\n if (actCmd[u] != 'P') continue;\n int d = dir[u];\n int x = rx + dx4[d], y = ry + dy4[d];\n if (!inside(x, y)) continue;\n\n if (hold[u]) {\n // place only if deficit\n if (deficit[x][y]) {\n hold[u] = 0;\n cur[x][y] = 1;\n deficit[x][y] = 0;\n deficitCnt--;\n }\n } else {\n // pick only if surplus\n if (surplus[x][y]) {\n hold[u] = 1;\n cur[x][y] = 0;\n surplus[x][y] = 0;\n surplusCnt--;\n }\n }\n }\n };\n\n int idx = 0;\n const int MAXT = 100000;\n int turns = 0;\n\n while (turns < MAXT && !done()) {\n // Try to place/pick by staying first (good for 2-step 180 placement).\n Plan stayPlan = planImmediateAt(rx, ry);\n bool didStay = false;\n\n array rotCmd; rotCmd.fill('.');\n array actCmd; actCmd.fill('.');\n char mv = '.';\n\n if (stayPlan.places > 0) {\n // do stay\n mv = '.';\n rotCmd = stayPlan.rot;\n actCmd = stayPlan.actP;\n didStay = true;\n } else {\n // If can't place immediately, try 180-degree prep if adjacent deficit exists\n auto prep = planPrep180At(rx, ry);\n if (prep.has_value()) {\n mv = '.';\n rotCmd.fill('.');\n actCmd.fill('.');\n rotCmd[prep->first] = prep->second;\n didStay = true;\n }\n }\n\n if (!didStay) {\n // Move along route\n int nextIdx = (idx + 1 < (int)route.size() ? idx + 1 : 1);\n Pos a = route[idx], b = route[nextIdx];\n mv = moveChar(a, b);\n // simulate move position for planning\n int nRx = rx, nRy = ry;\n if (mv == 'U') nRx--;\n else if (mv == 'D') nRx++;\n else if (mv == 'L') nRy--;\n else if (mv == 'R') nRy++;\n\n Plan movePlan = planImmediateAt(nRx, nRy);\n rotCmd = movePlan.rot;\n actCmd = movePlan.actP;\n\n idx = nextIdx;\n }\n\n // Build and output command string\n string cmd(2 * Vp, '.');\n cmd[0] = mv;\n for (int u = 1; u <= 4; u++) cmd[u] = rotCmd[u];\n cmd[Vp + 0] = '.';\n for (int u = 1; u <= 4; u++) cmd[Vp + u] = actCmd[u];\n\n cout << cmd << \"\\n\";\n turns++;\n\n // Apply to our internal simulation\n applyTurn(mv, rotCmd, actCmd);\n }\n\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int l, int r) { return l + (int)(next_u64() % (uint64_t)(r - l + 1)); } // inclusive\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n};\n\nstatic inline double now_sec() {\n using namespace std::chrono;\n return duration_cast>(steady_clock::now().time_since_epoch()).count();\n}\n\nstruct Point {\n int x, y;\n int w; // +1 for mackerel, -1 for sardine\n};\n\nstruct Rect { // inclusive bounds\n int xl, xr, yb, yt;\n};\n\nstatic inline bool rect_ok(const Rect& r) {\n if (!(0 <= r.xl && r.xl <= 100000)) return false;\n if (!(0 <= r.xr && r.xr <= 100000)) return false;\n if (!(0 <= r.yb && r.yb <= 100000)) return false;\n if (!(0 <= r.yt && r.yt <= 100000)) return false;\n if (r.xl >= r.xr) return false;\n if (r.yb >= r.yt) return false;\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n return (w + h <= 200000); // perimeter <= 4e5\n}\n\nstatic inline Rect clamp_make(int xl, int xr, int yb, int yt) {\n Rect r{xl, xr, yb, yt};\n r.xl = max(0, min(100000, r.xl));\n r.xr = max(0, min(100000, r.xr));\n r.yb = max(0, min(100000, r.yb));\n r.yt = max(0, min(100000, r.yt));\n\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n long long sum = w + h;\n if (sum > 200000) {\n int cx = (r.xl + r.xr) / 2;\n int cy = (r.yb + r.yt) / 2;\n long long over = sum - 200000;\n\n long long rw = min(over, w - 1);\n long long rh = min(over - rw, h - 1);\n while (rw + rh < over) {\n if ((w - rw) > (h - rh) && (w - rw) > 1) rw++;\n else if ((h - rh) > 1) rh++;\n else break;\n }\n\n long long neww = max(1LL, w - rw);\n long long newh = max(1LL, h - rh);\n\n int halfw = (int)(neww / 2);\n int halfh = (int)(newh / 2);\n\n r.xl = cx - halfw;\n r.xr = r.xl + (int)neww;\n r.yb = cy - halfh;\n r.yt = r.yb + (int)newh;\n\n if (r.xl < 0) { r.xr -= r.xl; r.xl = 0; }\n if (r.yb < 0) { r.yt -= r.yb; r.yb = 0; }\n if (r.xr > 100000) { int d = r.xr - 100000; r.xl -= d; r.xr = 100000; if (r.xl < 0) r.xl = 0; }\n if (r.yt > 100000) { int d = r.yt - 100000; r.yb -= d; r.yt = 100000; if (r.yb < 0) r.yb = 0; }\n\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n }\n return r;\n}\n\n// Static 2D BIT (Fenwick over x), each node stores sorted unique y and prefix sums of weights.\n// Supports prefix query: sum of weights for points with x <= X and y <= Y.\nstruct BIT2DStatic {\n struct Node {\n vector ys;\n vector pref; // pref[i] = sum for ys[0..i]\n vector> tmp; // (y,w) before build\n };\n\n int M; // number of unique x\n vector xs; // sorted unique x\n vector bit; // 1..M\n\n BIT2DStatic() : M(0) {}\n\n void build(const vector& pts) {\n xs.clear();\n xs.reserve(pts.size());\n for (auto &p: pts) xs.push_back(p.x);\n sort(xs.begin(), xs.end());\n xs.erase(unique(xs.begin(), xs.end()), xs.end());\n M = (int)xs.size();\n bit.assign(M + 1, Node());\n\n // collect\n for (auto &p: pts) {\n int xi = (int)(lower_bound(xs.begin(), xs.end(), p.x) - xs.begin()) + 1;\n for (int j = xi; j <= M; j += j & -j) {\n bit[j].tmp.push_back({p.y, p.w});\n }\n }\n\n // build each node: sort by y, compress same y, build prefix\n for (int j = 1; j <= M; j++) {\n auto &t = bit[j].tmp;\n sort(t.begin(), t.end());\n vector ys;\n vector sums;\n ys.reserve(t.size());\n sums.reserve(t.size());\n for (int k = 0; k < (int)t.size(); ) {\n int y = t[k].first;\n int s = 0;\n while (k < (int)t.size() && t[k].first == y) {\n s += t[k].second;\n k++;\n }\n ys.push_back(y);\n sums.push_back(s);\n }\n bit[j].ys = move(ys);\n bit[j].pref.resize(sums.size());\n int run = 0;\n for (int i = 0; i < (int)sums.size(); i++) {\n run += sums[i];\n bit[j].pref[i] = run;\n }\n bit[j].tmp.clear();\n bit[j].tmp.shrink_to_fit();\n }\n }\n\n inline int node_query(const Node& nd, int yBound) const {\n // sum for y <= yBound\n const auto& ys = nd.ys;\n if (ys.empty()) return 0;\n int pos = (int)(upper_bound(ys.begin(), ys.end(), yBound) - ys.begin());\n if (pos <= 0) return 0;\n return nd.pref[pos - 1];\n }\n\n inline int prefix_query(int xBound, int yBound) const {\n // x <= xBound and y <= yBound\n if (xBound < 0 || yBound < 0) return 0;\n int xi = (int)(upper_bound(xs.begin(), xs.end(), xBound) - xs.begin()); // 0..M\n int res = 0;\n for (int j = xi; j > 0; j -= j & -j) {\n res += node_query(bit[j], yBound);\n }\n return res;\n }\n\n inline int rect_sum_inclusive(const Rect& r) const {\n // inclusive: [xl..xr] x [yb..yt]\n int A = prefix_query(r.xr, r.yt);\n int B = prefix_query(r.xl - 1, r.yt);\n int C = prefix_query(r.xr, r.yb - 1);\n int D = prefix_query(r.xl - 1, r.yb - 1);\n return A - B - C + D;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N; // fixed 5000\n vector pts;\n pts.reserve(2 * N);\n vector macks;\n macks.reserve(N);\n\n for (int i = 0; i < 2 * N; i++) {\n int x, y;\n cin >> x >> y;\n int w = (i < N) ? +1 : -1;\n pts.push_back({x, y, w});\n if (i < N) macks.push_back({x, y, +1});\n }\n\n BIT2DStatic bit2d;\n bit2d.build(pts);\n\n double t0 = now_sec();\n const double TL = 1.95;\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n seed ^= (uint64_t)(pts[0].x * 1000003u + pts[0].y * 9176u + 12345u);\n XorShift64 rng(seed);\n\n auto eval_rect = [&](const Rect& r) -> int {\n return bit2d.rect_sum_inclusive(r);\n };\n\n auto make_around = [&](const Point& c, int w, int h) -> Rect {\n int xl = c.x - w / 2;\n int xr = c.x + w / 2;\n int yb = c.y - h / 2;\n int yt = c.y + h / 2;\n Rect r = clamp_make(xl, xr, yb, yt);\n if (!(r.xl <= c.x && c.x <= r.xr && r.yb <= c.y && c.y <= r.yt)) {\n r = clamp_make(c.x, c.x + 1, c.y, c.y + 1);\n }\n return r;\n };\n\n Rect best = clamp_make(0, 1, 0, 1);\n int bestDiff = -1e9;\n\n // Stronger random sampling (cheap now)\n {\n int trials = 40000;\n for (int it = 0; it < trials; it++) {\n const auto& c = macks[rng.next_int(0, (int)macks.size() - 1)];\n\n // mix of small/medium/large\n int w, h;\n double r = rng.next_double();\n if (r < 0.60) { w = rng.next_int(150, 9000); h = rng.next_int(150, 9000); }\n else if (r < 0.90) { w = rng.next_int(2000, 40000); h = rng.next_int(2000, 40000); }\n else { w = rng.next_int(15000, 90000); h = rng.next_int(15000, 90000); }\n\n if (w + h > 200000) {\n int over = w + h - 200000;\n w = max(1, w - over / 2);\n h = max(1, h - (over - over / 2));\n }\n Rect rr = make_around(c, w, h);\n if (!rect_ok(rr)) continue;\n\n int diff = eval_rect(rr);\n if (diff > bestDiff) {\n bestDiff = diff;\n best = rr;\n }\n }\n }\n\n // Simulated annealing with more iterations + snap moves\n Rect cur = best;\n int curDiff = bestDiff;\n\n const double SA_T0 = 120.0;\n const double SA_T1 = 0.8;\n\n int iter = 0;\n while (true) {\n double t = now_sec() - t0;\n if (t > TL) break;\n double progress = t / TL;\n double temp = SA_T0 * pow(SA_T1 / SA_T0, progress);\n\n Rect nxt = cur;\n\n double dice = rng.next_double();\n\n if (dice < 0.05) {\n // restart around a random mackerel\n const auto& c = macks[rng.next_int(0, (int)macks.size() - 1)];\n int w = rng.next_int(300, 80000);\n int h = rng.next_int(300, 80000);\n nxt = make_around(c, w, h);\n } else if (dice < 0.35) {\n // snap one side near a random point coordinate (include/exclude boundary control)\n const auto& p = pts[rng.next_int(0, (int)pts.size() - 1)];\n int which = rng.next_int(0, 3);\n int off = rng.next_int(-300, 300);\n if (which == 0) nxt.xl = p.x + off;\n if (which == 1) nxt.xr = p.x + off;\n if (which == 2) nxt.yb = p.y + off;\n if (which == 3) nxt.yt = p.y + off;\n nxt = clamp_make(nxt.xl, nxt.xr, nxt.yb, nxt.yt);\n } else {\n // local perturbation\n int which = rng.next_int(0, 3);\n int maxDelta = (int)round(25000 * (1.0 - progress) + 120); // cool down\n int delta = rng.next_int(-maxDelta, maxDelta);\n\n if (which == 0) nxt.xl += delta;\n if (which == 1) nxt.xr += delta;\n if (which == 2) nxt.yb += delta;\n if (which == 3) nxt.yt += delta;\n\n // symmetric expand/shrink\n if (rng.next_double() < 0.15) {\n int d2 = rng.next_int(-maxDelta / 4, maxDelta / 4);\n if (rng.next_double() < 0.5) { nxt.xl -= d2; nxt.xr += d2; }\n else { nxt.yb -= d2; nxt.yt += d2; }\n }\n\n nxt = clamp_make(nxt.xl, nxt.xr, nxt.yb, nxt.yt);\n }\n\n if (!rect_ok(nxt)) { iter++; continue; }\n\n int nxtDiff = eval_rect(nxt);\n int delta = nxtDiff - curDiff;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n cur = nxt;\n curDiff = nxtDiff;\n if (curDiff > bestDiff) {\n bestDiff = curDiff;\n best = cur;\n }\n }\n\n iter++;\n }\n\n if (!rect_ok(best)) best = clamp_make(0, 1, 0, 1);\n\n // Output rectangle (CCW). 4 vertices, all distinct due to strict width/height.\n cout << 4 << \"\\n\";\n cout << best.xl << \" \" << best.yb << \"\\n\";\n cout << best.xr << \" \" << best.yb << \"\\n\";\n cout << best.xr << \" \" << best.yt << \"\\n\";\n cout << best.xl << \" \" << best.yt << \"\\n\";\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct Op {\n int p;\n int r;\n char d; // 'L' or 'U'\n int b; // -1 or previous index\n};\n\nstruct Placed {\n ll x=0, y=0, w=0, h=0;\n};\n\nstatic inline bool overlapPosLen(ll a1, ll a2, ll b1, ll b2) {\n return max(a1, b1) < min(a2, b2);\n}\n\nstruct RNG {\n uint64_t x;\n explicit RNG(uint64_t seed=88172645463325252ULL) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\npair place_one(\n const vector& placed, int i,\n ll w, ll h, char d, int b\n) {\n ll x=0, y=0;\n if (d == 'U') {\n x = 0;\n if (b != -1) x = placed[b].x + placed[b].w;\n y = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(x, x+w, pj.x, pj.x+pj.w)) {\n y = max(y, pj.y + pj.h);\n }\n }\n } else { // 'L'\n y = 0;\n if (b != -1) y = placed[b].y + placed[b].h;\n x = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(y, y+h, pj.y, pj.y+pj.h)) {\n x = max(x, pj.x + pj.w);\n }\n }\n }\n return {x,y};\n}\n\npair simulate_ops(const vector& ops, const vector& W, const vector& H) {\n int N = (int)ops.size();\n vector placed(N);\n ll maxX=0, maxY=0;\n\n for (int i = 0; i < N; i++) {\n const auto& op = ops[i];\n int idx = op.p;\n ll w = W[idx], h = H[idx];\n if (op.r) swap(w,h);\n\n auto [x,y] = place_one(placed, i, w, h, op.d, op.b);\n placed[i] = Placed{x,y,w,h};\n maxX = max(maxX, x+w);\n maxY = max(maxY, y+h);\n }\n return {maxX, maxY};\n}\n\nstruct Candidate {\n vector ops;\n ll estW = (1LL<<62), estH = (1LL<<62), estObj = (1LL<<62);\n string tag;\n};\n\nCandidate make_all_one_row(const vector& w, const vector& h, uint64_t seed, string tag=\"oneRow\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n for (int i=0;i& w, const vector& h, uint64_t seed, string tag=\"oneCol\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n for (int i=0;i& w, const vector& h, ll Wlim, uint64_t seed, string tag=\"rowShelf\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n int prevAnchor=-1;\n ll rowW=0, rowH=0;\n int rowTall=-1; ll rowTallH=-1;\n\n auto finish_row = [&](){\n prevAnchor = rowTall;\n rowW=0; rowH=0;\n rowTall=-1; rowTallH=-1;\n };\n\n for(int i=0;i0){\n bool fit0 = (rowW+w0<=Wlim);\n bool fit1 = (rowW+w1<=Wlim);\n if(!fit0 && !fit1) finish_row();\n else if(rowW > (ll)llround((long double)Wlim*0.94L) && rng.next_double()<0.25) finish_row();\n }\n\n // choose rotation by row height then fit\n int r=0;\n bool fit0 = (rowW+w0<=Wlim);\n bool fit1 = (rowW+w1<=Wlim);\n if(fit0 && fit1){\n ll rh0=max(rowH,h0), rh1=max(rowH,h1);\n if(rh1rowTallH){ rowTallH=hh; rowTall=i; }\n }\n\n auto [W,H] = simulate_ops(c.ops,w,h);\n c.estW=W; c.estH=H; c.estObj=W+H;\n c.tag = tag + \"(Wlim=\" + to_string(Wlim) + \")\";\n return c;\n}\n\nCandidate make_col_shelf(const vector& w, const vector& h, ll Hlim, uint64_t seed, string tag=\"colShelf\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n int prevAnchor=-1;\n ll colH=0, colW=0;\n int colWide=-1; ll colWideW=-1;\n\n auto finish_col = [&](){\n prevAnchor = colWide;\n colH=0; colW=0;\n colWide=-1; colWideW=-1;\n };\n\n for(int i=0;i0){\n bool fit0 = (colH+h0<=Hlim);\n bool fit1 = (colH+h1<=Hlim);\n if(!fit0 && !fit1) finish_col();\n else if(colH > (ll)llround((long double)Hlim*0.94L) && rng.next_double()<0.25) finish_col();\n }\n\n int r=0;\n bool fit0 = (colH+h0<=Hlim);\n bool fit1 = (colH+h1<=Hlim);\n if(fit0 && fit1){\n ll cw0=max(colW,w0), cw1=max(colW,w1);\n if(cw1colWideW){ colWideW=ww; colWide=i; }\n }\n\n auto [W,H] = simulate_ops(c.ops,w,h);\n c.estW=W; c.estH=H; c.estObj=W+H;\n c.tag = tag + \"(Hlim=\" + to_string(Hlim) + \")\";\n return c;\n}\n\n// Greedy mosaic: each step tries (r,d,b) from small candidate sets and chooses best.\nCandidate make_greedy_mosaic(\n const vector& w, const vector& h,\n uint64_t seed,\n double aspectPenalty, // weight for |W-H|\n double areaPenalty, // small weight for W*H\n double pPreferL, // bias for L vs U\n int Kanchor, // top-K anchors for each direction\n string tag=\"mosaic\"\n) {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n vector placed(N);\n ll curW=0, curH=0;\n\n auto get_topK_indices = [&](int i, bool byBottom, int K)->vector{\n vector idx(i);\n iota(idx.begin(), idx.end(), 0);\n auto key = [&](int j)->ll{\n const auto& pj = placed[j];\n return byBottom ? (pj.y+pj.h) : (pj.x+pj.w);\n };\n sort(idx.begin(), idx.end(), [&](int a,int b){\n return key(a) > key(b);\n });\n if ((int)idx.size() > K) idx.resize(K);\n return idx;\n };\n\n for(int i=0;i BL = {-1}, BU = {-1};\n if(i>0){\n auto topBottom = get_topK_indices(i, true, Kanchor);\n auto topRight = get_topK_indices(i, false, Kanchor);\n BL.insert(BL.end(), topBottom.begin(), topBottom.end());\n BU.insert(BU.end(), topRight.begin(), topRight.end());\n\n // add a few random anchors for diversity\n for(int t=0;t<3;t++){\n BL.push_back(rng.next_int(0,i-1));\n BU.push_back(rng.next_int(0,i-1));\n }\n // ensure i-1 is included\n BL.push_back(i-1);\n BU.push_back(i-1);\n }\n\n // dedup\n auto dedup = [&](vector& v){\n sort(v.begin(), v.end());\n v.erase(unique(v.begin(), v.end()), v.end());\n };\n dedup(BL); dedup(BU);\n\n // Try options\n double bestScore = 1e100;\n Op bestOp{i,0,'L',-1};\n ll bestNX=0, bestNY=0, bestNW=0, bestNH=0;\n\n auto eval = [&](ll nW, ll nH)->double{\n long double Wd=nW, Hd=nH;\n long double score = Wd + Hd;\n score += (long double)aspectPenalty * fabsl(Wd - Hd);\n score += (long double)areaPenalty * (Wd * Hd) / 1e6L; // scale down\n return (double)score;\n };\n\n auto consider = [&](int r, char d, int b){\n ll ww = (r? w1:w0);\n ll hh = (r? h1:h0);\n\n auto [x,y] = place_one(placed, i, ww, hh, d, b);\n ll nW = max(curW, x+ww);\n ll nH = max(curH, y+hh);\n\n double sc = eval(nW,nH);\n\n // mild bias to prefer L or U (to create varied candidates)\n if (d=='L') sc *= (1.0 - 0.02*(pPreferL-0.5));\n else sc *= (1.0 + 0.02*(pPreferL-0.5));\n\n // small randomness to escape ties\n sc *= (1.0 + 0.0005 * (rng.next_double() - 0.5));\n\n if (sc < bestScore) {\n bestScore=sc;\n bestOp = Op{i,r,d,b};\n bestNX=x; bestNY=y; bestNW=ww; bestNH=hh;\n }\n };\n\n // Direction set with bias\n bool tryLFirst = (rng.next_double() < pPreferL);\n for(int rr=0; rr<2; rr++){\n // sometimes only try the \"natural\" rotation first\n // but still consider both in most cases\n int r = rr;\n if (rng.next_double() < 0.08) r ^= 1;\n\n if (tryLFirst) {\n for (int b : BL) consider(r,'L',b);\n for (int b : BU) consider(r,'U',b);\n } else {\n for (int b : BU) consider(r,'U',b);\n for (int b : BL) consider(r,'L',b);\n }\n }\n\n // Commit\n c.ops[i]=bestOp;\n placed[i]=Placed{bestNX,bestNY,bestNW,bestNH};\n curW = max(curW, bestNX+bestNW);\n curH = max(curH, bestNY+bestNH);\n }\n\n c.estW=curW; c.estH=curH; c.estObj=curW+curH;\n c.tag = tag + \"(asp=\" + to_string(aspectPenalty) + \",area=\" + to_string(areaPenalty) + \")\";\n return c;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T, sigma;\n cin >> N >> T >> sigma;\n vector wp(N), hp(N);\n for(int i=0;i> wp[i] >> hp[i];\n\n long double areaSum=0;\n ll sumW=0, sumH=0;\n for(int i=0;i(1, (ll)floor(sqrt(areaSum)));\n\n vector pool;\n pool.push_back(make_all_one_row(wp,hp,1,\"oneRow\"));\n pool.push_back(make_all_one_col(wp,hp,2,\"oneCol\"));\n\n // Shelves\n vector factors = {0.55L,0.70L,0.85L,1.00L,1.15L,1.35L,1.60L};\n uint64_t seedBase = 1234567;\n\n for(int fi=0; fi<(int)factors.size(); fi++){\n ll Wlim = (ll)llround((long double)sq * factors[fi]);\n Wlim = max(1, min(Wlim, sumW));\n for(int k=0;k<5;k++){\n pool.push_back(make_row_shelf(wp,hp,Wlim,seedBase + 1000ULL*fi + k, \"rowShelf\"));\n }\n }\n for(int fi=0; fi<(int)factors.size(); fi++){\n ll Hlim = (ll)llround((long double)sq * factors[fi]);\n Hlim = max(1, min(Hlim, sumH));\n for(int k=0;k<5;k++){\n pool.push_back(make_col_shelf(wp,hp,Hlim,seedBase + 20000ULL + 1000ULL*fi + k, \"colShelf\"));\n }\n }\n\n // Greedy mosaic variants (main improvement)\n vector asp = {0.00, 0.03, 0.06, 0.10};\n vector areaPen = {0.0, 0.0008, 0.0016};\n vector biasL = {0.30, 0.50, 0.70}; // prefer U, balanced, prefer L\n\n uint64_t s2 = 7777777;\n for (double a : asp) for (double ap : areaPen) for (double bl : biasL) {\n for(int rep=0; rep<5; rep++){\n pool.push_back(make_greedy_mosaic(wp,hp, s2++, a, ap, bl, 12, \"mosaic\"));\n }\n }\n\n // Evaluate precisely (still using wp/hp) and keep best K\n for (auto &c : pool) {\n auto [W,H] = simulate_ops(c.ops, wp, hp);\n c.estW=W; c.estH=H; c.estObj=W+H;\n }\n sort(pool.begin(), pool.end(), [](const Candidate& a, const Candidate& b){\n if (a.estObj != b.estObj) return a.estObj < b.estObj;\n if (a.estW != b.estW) return a.estW < b.estW;\n return a.estH < b.estH;\n });\n\n int KEEP = min((int)pool.size(), 80);\n pool.resize(KEEP);\n\n ll bestMeasured = (1LL<<62);\n int bestIdx = 0;\n\n for(int t=0;t> Wm >> Hm)) return 0;\n ll measured = Wm + Hm;\n if(measured < bestMeasured){\n bestMeasured = measured;\n bestIdx = useIdx;\n }\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nstatic inline uint32_t xorshift32(uint32_t &x) {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n}\nstatic inline double rand01(uint32_t &x) {\n return (double)xorshift32(x) / 4294967296.0; // [0,1)\n}\n\nstruct BFSResult {\n vector dist;\n vector prev;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n\n vector> edges(M);\n vector> g(N);\n g.assign(N, {});\n\n unordered_set edgeSet;\n edgeSet.reserve(M * 2);\n\n auto keyEdge = [&](int u, int v)->long long{\n if (u > v) swap(u, v);\n return (long long)u * N + v;\n };\n\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n edges[i] = {u, v};\n g[u].push_back(v);\n g[v].push_back(u);\n edgeSet.insert(keyEdge(u, v));\n }\n\n // coordinates unused\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n\n auto multiSourceBFS = [&](const vector& roots)->BFSResult{\n const int INF = 1e9;\n BFSResult res;\n res.dist.assign(N, INF);\n res.prev.assign(N, -1);\n deque q;\n for (int r : roots) {\n res.dist[r] = 0;\n res.prev[r] = -1;\n q.push_back(r);\n }\n while (!q.empty()) {\n int v = q.front(); q.pop_front();\n int nd = res.dist[v] + 1;\n for (int to : g[v]) {\n if (res.dist[to] > nd) {\n res.dist[to] = nd;\n res.prev[to] = v;\n q.push_back(to);\n }\n }\n }\n return res;\n };\n\n // -----------------------\n // 1) Choose roots to cover all vertices within distance <= H (prefer low A)\n // -----------------------\n int root0 = min_element(A.begin(), A.end()) - A.begin();\n vector roots = {root0};\n\n while (true) {\n auto bfs = multiSourceBFS(roots);\n int far = -1, farD = -1;\n for (int i = 0; i < N; i++) {\n if (bfs.dist[i] > farD) { farD = bfs.dist[i]; far = i; }\n }\n if (farD <= H) break;\n\n int cur = far;\n int steps = farD - H;\n\n int child1 = -1, child2 = -1;\n for (int s = 0; s < steps; s++) {\n child2 = child1;\n child1 = cur;\n cur = bfs.prev[cur];\n if (cur == -1) break;\n }\n if (cur == -1) {\n roots.push_back(far);\n continue;\n }\n\n int best = cur;\n auto consider = [&](int v){\n if (v == -1) return;\n if (A[v] < A[best]) best = v;\n };\n consider(child1);\n consider(child2);\n\n roots.push_back(best);\n }\n\n // Greedy root removal\n {\n uint32_t rng = 123456789u;\n vector order = roots;\n for (int i = (int)order.size() - 1; i > 0; i--) {\n int j = (int)(xorshift32(rng) % (i + 1));\n swap(order[i], order[j]);\n }\n vector alive(N, 0);\n for (int r : roots) alive[r] = 1;\n\n for (int r : order) {\n if (!alive[r]) continue;\n vector tmp;\n tmp.reserve(roots.size());\n for (int rr : roots) if (alive[rr] && rr != r) tmp.push_back(rr);\n if (tmp.empty()) continue;\n\n auto bfs = multiSourceBFS(tmp);\n int mx = 0;\n for (int i = 0; i < N; i++) mx = max(mx, bfs.dist[i]);\n if (mx <= H) alive[r] = 0;\n }\n vector newRoots;\n for (int r : roots) if (alive[r]) newRoots.push_back(r);\n roots.swap(newRoots);\n }\n\n // -----------------------\n // 2) Initial forest by BFS\n // -----------------------\n auto bfs = multiSourceBFS(roots);\n vector parent(N, -1), depth(N, 0);\n\n for (int v = 0; v < N; v++) {\n if (bfs.dist[v] <= H) {\n parent[v] = bfs.prev[v];\n depth[v] = bfs.dist[v];\n } else {\n parent[v] = -1;\n depth[v] = 0;\n }\n }\n\n // -----------------------\n // 3) Children adjacency for subtree enumeration\n // -----------------------\n vector> children(N);\n vector idxInChild(N, -1);\n children.assign(N, {});\n\n auto addChild = [&](int p, int v){\n idxInChild[v] = (int)children[p].size();\n children[p].push_back(v);\n };\n auto removeChild = [&](int p, int v){\n int idx = idxInChild[v];\n if (idx < 0) return;\n int last = children[p].back();\n children[p][idx] = last;\n idxInChild[last] = idx;\n children[p].pop_back();\n idxInChild[v] = -1;\n };\n\n for (int v = 0; v < N; v++) {\n if (parent[v] != -1) addChild(parent[v], v);\n }\n\n long long score = 0;\n for (int v = 0; v < N; v++) score += 1LL * (depth[v] + 1) * A[v];\n\n auto isAncestor = [&](int anc, int v)->bool{\n // depth always <= H (10), so this is O(H)\n while (v != -1) {\n if (v == anc) return true;\n v = parent[v];\n }\n return false;\n };\n\n // -----------------------\n // 4) Simulated annealing with subtree depth-shift move + cut-to-root move\n // -----------------------\n uint32_t rng = 987654321u;\n auto start = chrono::steady_clock::now();\n const double TL = 1.93; // leave margin\n\n // Temperature schedule: start high enough to accept big negative moves early\n // Typical gain magnitudes: delta(<=10) * sumA(<=100k) => up to ~1e6\n const double T0 = 20000.0;\n const double T1 = 50.0;\n\n auto currentTime = [&](){\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - start).count();\n };\n\n vector st;\n vector sub;\n st.reserve(N);\n sub.reserve(N);\n\n int it = 0;\n while (true) {\n if ((it & 2047) == 0) {\n if (currentTime() > TL) break;\n }\n it++;\n\n double t = currentTime() / TL;\n if (t > 1.0) t = 1.0;\n double T = T0 * pow(T1 / T0, t); // exponential cooling\n\n int moveType = (int)(xorshift32(rng) % 100);\n\n if (moveType < 85) {\n // Reparent along a random edge: make u parent of v\n auto [a, b] = edges[xorshift32(rng) % M];\n int u, v;\n if (xorshift32(rng) & 1) { u = a; v = b; }\n else { u = b; v = a; }\n\n if (u == v) continue;\n if (parent[v] == u) continue;\n\n // new depth of v determined by u\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n\n // cycle check\n if (isAncestor(v, u)) continue;\n\n int delta = newDepthV - depth[v];\n if (delta == 0) {\n // allow delta==0 sometimes (structural change)\n // but must still be valid for subtree (always, since delta=0)\n // still do it with some probability to diversify\n if (rand01(rng) > 0.10) continue;\n }\n\n // enumerate subtree(v), compute sumA and min/max depth inside subtree\n long long sumA = 0;\n int minD = INT_MAX, maxD = -INT_MAX;\n\n sub.clear();\n st.clear();\n st.push_back(v);\n while (!st.empty()) {\n int x = st.back(); st.pop_back();\n sub.push_back(x);\n sumA += A[x];\n minD = min(minD, depth[x]);\n maxD = max(maxD, depth[x]);\n for (int ch : children[x]) st.push_back(ch);\n }\n\n // check bounds after shift\n if (minD + delta < 0) continue;\n if (maxD + delta > H) continue;\n\n long long gain = 1LL * delta * sumA;\n\n bool accept = false;\n if (gain >= 0) accept = true;\n else {\n double prob = exp((double)gain / T);\n if (rand01(rng) < prob) accept = true;\n }\n if (!accept) continue;\n\n // apply\n int oldp = parent[v];\n if (oldp != -1) removeChild(oldp, v);\n parent[v] = u;\n addChild(u, v);\n\n for (int x : sub) depth[x] += delta;\n score += gain;\n\n } else {\n // Cut move: make v a root (parent[v] = -1)\n int v = (int)(xorshift32(rng) % N);\n if (parent[v] == -1) continue;\n\n int oldp = parent[v];\n\n int delta = -depth[v]; // new depth of v is 0\n // enumerate subtree(v)\n long long sumA = 0;\n int minD = INT_MAX, maxD = -INT_MAX;\n\n sub.clear();\n st.clear();\n st.push_back(v);\n while (!st.empty()) {\n int x = st.back(); st.pop_back();\n sub.push_back(x);\n sumA += A[x];\n minD = min(minD, depth[x]);\n maxD = max(maxD, depth[x]);\n for (int ch : children[x]) st.push_back(ch);\n }\n\n if (minD + delta < 0) continue; // should be 0 always for v, but keep safe\n if (maxD + delta > H) continue; // becomes smaller, should always pass\n\n long long gain = 1LL * delta * sumA; // negative or zero\n\n bool accept = false;\n if (gain >= 0) accept = true;\n else {\n double prob = exp((double)gain / T);\n if (rand01(rng) < prob) accept = true;\n }\n if (!accept) continue;\n\n // apply cut\n removeChild(oldp, v);\n parent[v] = -1;\n\n for (int x : sub) depth[x] += delta;\n score += gain;\n }\n }\n\n // -----------------------\n // 5) Final rebuild children & enforce validity (just in case)\n // -----------------------\n // Ensure parent edges exist\n for (int v = 0; v < N; v++) {\n if (parent[v] != -1) {\n if (!edgeSet.count(keyEdge(v, parent[v]))) parent[v] = -1;\n }\n }\n\n // rebuild children from parent\n children.assign(N, {});\n idxInChild.assign(N, -1);\n for (int v = 0; v < N; v++) {\n if (parent[v] != -1) {\n addChild(parent[v], v);\n }\n }\n\n // recompute depths from roots; break cycles if any by cutting\n vector dep2(N, -1);\n deque q;\n for (int v = 0; v < N; v++) {\n if (parent[v] == -1) {\n dep2[v] = 0;\n q.push_back(v);\n }\n }\n while (!q.empty()) {\n int x = q.front(); q.pop_front();\n for (int ch : children[x]) {\n if (dep2[ch] != -1) continue;\n dep2[ch] = dep2[x] + 1;\n q.push_back(ch);\n }\n }\n // cut unreachable nodes (cycles)\n for (int v = 0; v < N; v++) {\n if (dep2[v] == -1) parent[v] = -1;\n }\n // rebuild again\n children.assign(N, {});\n idxInChild.assign(N, -1);\n for (int v = 0; v < N; v++) if (parent[v] != -1) addChild(parent[v], v);\n\n // recompute depths and enforce height by cutting\n dep2.assign(N, -1);\n q.clear();\n for (int v = 0; v < N; v++) if (parent[v] == -1) {\n dep2[v] = 0;\n q.push_back(v);\n }\n while (!q.empty()) {\n int x = q.front(); q.pop_front();\n for (int ch : children[x]) {\n if (dep2[ch] != -1) continue;\n dep2[ch] = dep2[x] + 1;\n q.push_back(ch);\n }\n }\n for (int v = 0; v < N; v++) {\n if (dep2[v] > H) parent[v] = -1;\n if (dep2[v] == -1) parent[v] = -1;\n }\n\n // Output parent array\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << \"\\n\";\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstruct Action {\n char dir; // L,R,U,D (forward)\n int p; // row or col\n int k; // forward steps; also backward steps\n uint64_t mask; // oni covered (initial ids)\n int cost; // 2*k\n array bits;\n int bsz;\n};\n\nstatic inline char opposite_dir(char d){\n if(d=='L') return 'R';\n if(d=='R') return 'L';\n if(d=='U') return 'D';\n return 'U';\n}\n\nstatic inline int popcount_u64(uint64_t x){ return __builtin_popcountll(x); }\n\nstruct XorShift {\n uint64_t x=88172645463325252ull;\n explicit XorShift(uint64_t seed=0){\n if(seed) x ^= seed + 0x9e3779b97f4a7c15ull;\n }\n uint64_t next_u64(){\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int n){ return (int)(next_u64() % (uint64_t)n); }\n double next_double(){\n // [0,1)\n return (next_u64() >> 11) * (1.0/9007199254740992.0);\n }\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N; // 20\n vector C(N);\n for(int i=0;i> C[i];\n\n // Index Oni\n vector> oniPos;\n vector> oniId(N, vector(N, -1));\n for(int i=0;i>> rowOnis(N), colOnis(N);\n for(int id=0; id rowFirstFuku(N, N), rowLastFuku(N, -1);\n vector colFirstFuku(N, N), colLastFuku(N, -1);\n for(int i=0;i acts;\n acts.reserve(2000);\n\n auto push_action = [&](char dir, int p, int k, uint64_t mask){\n if(k<=0 || mask==0) return;\n Action a;\n a.dir = dir; a.p = p; a.k = k;\n a.mask = mask;\n a.cost = 2*k;\n a.bsz = 0;\n uint64_t tmp = mask;\n while(tmp){\n int b = __builtin_ctzll(tmp);\n a.bits[a.bsz++] = b;\n tmp &= (tmp-1);\n }\n acts.push_back(a);\n };\n\n // Row actions: safe prefixes/suffixes bounded by fuku\n for(int i=0;i=0; t--){\n int col = rowOnis[i][t].first;\n int id = rowOnis[i][t].second;\n if(col > lastF){\n sufMask |= (1ULL<=0; t--){\n int row = colOnis[j][t].first;\n int id = colOnis[j][t].second;\n if(row > lastF){\n sufMask |= (1ULL< sol;\n sol.reserve(64);\n\n while(uncovered){\n int best = -1;\n int bestGain = 0;\n int bestCost = 1;\n for(int i=0;i<(int)acts.size(); i++){\n uint64_t g = acts[i].mask & uncovered;\n int gain = popcount_u64(g);\n if(gain==0) continue;\n int cost = acts[i].cost;\n // maximize gain/cost; tie-break gain; then cost\n if(best==-1 ||\n 1LL*gain*bestCost > 1LL*bestGain*cost ||\n (1LL*gain*bestCost == 1LL*bestGain*cost && (gain > bestGain ||\n (gain==bestGain && cost < bestCost)))){\n best = i; bestGain = gain; bestCost = cost;\n }\n }\n if(best==-1) break;\n sol.push_back(best);\n uncovered &= ~acts[best].mask;\n }\n\n // If somehow uncovered remains (shouldn't), do per-oni safe actions\n if(uncovered){\n for(int id=0; id>id)&1ULL)==0) continue;\n auto [i,j] = oniPos[id];\n if(rowFirstFuku[i] >= j){\n uint64_t m=0; for(auto [c,oid]: rowOnis[i]) if(c<=j) m|=1ULL<=j) m|=1ULL<= i){\n uint64_t m=0; for(auto [r,oid]: colOnis[j]) if(r<=i) m|=1ULL<=i) m|=1ULL< &s){\n // remove redundant actions\n vector cnt(M,0);\n for(int idx: s){\n for(int t=0;t(startTime.time_since_epoch()).count();\n XorShift rng(seed);\n\n int A = (int)acts.size();\n vector inSet(A, 0);\n vector sel = sol;\n\n // coverage counts\n vector cov(M,0);\n int uncoveredCnt = M;\n int totalCost = 0;\n\n auto add_action = [&](int idx){\n inSet[idx] = 1;\n sel.push_back(idx);\n totalCost += acts[idx].cost;\n for(int t=0;tlong long{\n const long long PEN = 10000; // big enough vs cost range (~<=1600)\n return (long long)cost + PEN * (long long)un;\n };\n\n long long bestObj = objective(totalCost, uncoveredCnt);\n vector bestSel = sel;\n int bestCost = totalCost;\n int bestUn = uncoveredCnt;\n\n double t0 = 0.0, t1 = 1.0;\n // temperatures (tuned for integer deltas)\n const double Tstart = 2000.0;\n const double Tend = 0.5;\n\n int iter = 0;\n while(true){\n double elapsed = chrono::duration(now() - startTime).count();\n if(elapsed > TIME_LIMIT) break;\n iter++;\n\n double progress = elapsed / TIME_LIMIT;\n double temp = Tstart * pow(Tend / Tstart, progress);\n\n int moveType = rng.next_int(100);\n // 0..44 add, 45..89 remove, 90..99 swap\n if(moveType < 45){\n // add random not-selected\n int tries = 10;\n int idx = -1;\n while(tries--){\n int cand = rng.next_int(A);\n if(!inSet[cand]){ idx=cand; break; }\n }\n if(idx==-1) continue;\n\n long long oldObj = objective(totalCost, uncoveredCnt);\n // apply\n add_action(idx);\n long long newObj = objective(totalCost, uncoveredCnt);\n\n long long delta = newObj - oldObj;\n bool accept = (delta <= 0) || (rng.next_double() < exp(-(double)delta/temp));\n if(!accept){\n // rollback: remove the just-added at end\n remove_action_at((int)sel.size()-1);\n }else{\n if(newObj < bestObj){\n bestObj = newObj;\n bestSel = sel;\n bestCost = totalCost;\n bestUn = uncoveredCnt;\n }\n }\n } else if(moveType < 90){\n // remove random selected (if any)\n if(sel.empty()) continue;\n int pos = rng.next_int((int)sel.size());\n\n long long oldObj = objective(totalCost, uncoveredCnt);\n int removedIdx = sel[pos];\n\n // apply remove\n remove_action_at(pos);\n long long newObj = objective(totalCost, uncoveredCnt);\n\n long long delta = newObj - oldObj;\n bool accept = (delta <= 0) || (rng.next_double() < exp(-(double)delta/temp));\n if(!accept){\n // rollback: re-add removedIdx\n add_action(removedIdx);\n }else{\n if(newObj < bestObj){\n bestObj = newObj;\n bestSel = sel;\n bestCost = totalCost;\n bestUn = uncoveredCnt;\n }\n }\n } else {\n // swap: remove one, add one\n if(sel.empty()) continue;\n\n int pos = rng.next_int((int)sel.size());\n int removedIdx = sel[pos];\n\n int tries = 10;\n int addIdx = -1;\n while(tries--){\n int cand = rng.next_int(A);\n if(!inSet[cand] || cand==removedIdx){ addIdx=cand; break; }\n }\n if(addIdx==-1) continue;\n if(inSet[addIdx] && addIdx!=removedIdx) continue;\n\n long long oldObj = objective(totalCost, uncoveredCnt);\n\n // do remove\n remove_action_at(pos);\n // do add\n add_action(addIdx);\n\n long long newObj = objective(totalCost, uncoveredCnt);\n long long delta = newObj - oldObj;\n bool accept = (delta <= 0) || (rng.next_double() < exp(-(double)delta/temp));\n if(!accept){\n // rollback: remove added (end), re-add removedIdx\n remove_action_at((int)sel.size()-1);\n add_action(removedIdx);\n }else{\n if(newObj < bestObj){\n bestObj = newObj;\n bestSel = sel;\n bestCost = totalCost;\n bestUn = uncoveredCnt;\n }\n }\n }\n }\n\n // Use best feasible found; if infeasible, fallback to greedy solution\n vector finalSel;\n if(bestUn == 0) finalSel = bestSel;\n else finalSel = sol;\n\n prune_solution(finalSel);\n\n // Ensure total operations <= 1600; if not, fallback to per-oni guaranteed method.\n int T = 0;\n for(int idx: finalSel) T += acts[idx].cost;\n\n vector> ops;\n auto emit_from_selection = [&](const vector& selection){\n vector> out;\n out.reserve(2000);\n for(int idx: selection){\n const auto &a = acts[idx];\n for(int t=0;t 4*N*N){\n // Guaranteed-safe per-oni method (always within 1600 by problem guarantee)\n ops.clear();\n for(int id=0; id= j){\n int k = j+1;\n for(int t=0;t= i){\n int k = i+1;\n for(int t=0;t 4*N*N){\n // Extremely unlikely; output nothing to avoid WA due to too many lines.\n return 0;\n }\n }\n\n for(auto [d,p] : ops){\n cout << d << \" \" << p << \"\\n\";\n }\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic constexpr int NMAX = 100;\n\nstatic inline long long simulate_plan(int N, int L,\n const int a[NMAX], const int b[NMAX],\n const int T[NMAX],\n int outCnt[NMAX]) {\n for (int i = 0; i < N; i++) outCnt[i] = 0;\n\n int x = 0;\n outCnt[x] = 1;\n\n for (int step = 1; step < L; step++) {\n // parity of visits to x so far decides next\n int nx = (outCnt[x] & 1) ? a[x] : b[x];\n x = nx;\n outCnt[x]++;\n }\n\n long long err = 0;\n for (int i = 0; i < N; i++) err += llabs((long long)outCnt[i] - (long long)T[i]);\n return err;\n}\n\n// Fast assignment optimizer for b:\n// Minimize sum_j |binSum[j] - D[j]| where binSum[j] = sum_{i: b[i]=j} T[i].\n// O(1) delta update per move.\nstruct FastBAssignOptimizer {\n int N;\n const int *T;\n const long long *D;\n XorShift64 *rng;\n\n vector b; // b[i]=bin\n array binSum{};\n long long cost = (1LL<<62);\n\n static inline long long absll(long long x){ return x<0?-x:x; }\n\n long long compute_cost() const {\n long long c = 0;\n for (int j = 0; j < N; j++) c += absll(binSum[j] - D[j]);\n return c;\n }\n\n // Greedy init with randomness:\n // place larger items first into the bin with largest remaining need (D - binSum),\n // with some random sampling.\n void greedy_init() {\n b.assign(N, 0);\n for (int j = 0; j < N; j++) binSum[j] = 0;\n\n vector items(N);\n iota(items.begin(), items.end(), 0);\n stable_sort(items.begin(), items.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] > T[j];\n return i < j;\n });\n\n // small shuffle among equal weights to diversify starts\n for (int l = 0; l < N; ) {\n int r = l;\n while (r < N && T[items[r]] == T[items[l]]) r++;\n for (int k = l; k < r; k++) {\n int s = (*rng).next_int(l, r - 1);\n swap(items[k], items[s]);\n }\n l = r;\n }\n\n for (int idx = 0; idx < N; idx++) {\n int i = items[idx];\n long long w = T[i];\n\n // sample a few bins and pick best by (D - binSum)\n int bestJ = 0;\n long long bestNeed = LLONG_MIN;\n int samples = 10;\n for (int t = 0; t < samples; t++) {\n int j = (*rng).next_int(0, N - 1);\n long long need = D[j] - binSum[j];\n // slight preference to bins where need>=w, but not required\n long long score = need;\n if (need < w) score -= (w - need) / 2;\n if (score > bestNeed) {\n bestNeed = score;\n bestJ = j;\n }\n }\n // also compare against current global best-need bin sometimes\n if ((*rng).next_double() < 0.5) {\n int j2 = 0;\n long long best2 = D[0] - binSum[0];\n for (int j = 1; j < N; j++) {\n long long need = D[j] - binSum[j];\n if (need > best2) { best2 = need; j2 = j; }\n }\n long long need = D[j2] - binSum[j2];\n long long score = need;\n if (need < w) score -= (w - need) / 2;\n if (score > bestNeed) bestJ = j2;\n }\n\n b[i] = bestJ;\n binSum[bestJ] += w;\n }\n\n cost = compute_cost();\n }\n\n void run_sa(int iterations, double t0, double t1) {\n // Prepare heavy items list for biased selection\n vector heavy(N);\n iota(heavy.begin(), heavy.end(), 0);\n stable_sort(heavy.begin(), heavy.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] > T[j];\n return i < j;\n });\n int Kheavy = min(N, 30);\n\n for (int it = 0; it < iterations; it++) {\n double prog = (double)it / max(1, iterations - 1);\n double temp = t0 * pow(t1 / t0, prog);\n\n int i = heavy[(*rng).next_int(0, Kheavy - 1)];\n int from = b[i];\n if (T[i] == 0) continue;\n\n // pick candidate bin: sample and choose most \"needed\"\n int to = from;\n long long bestNeed = LLONG_MIN;\n for (int s = 0; s < 8; s++) {\n int j = (*rng).next_int(0, N - 1);\n long long need = D[j] - binSum[j];\n if (need > bestNeed) { bestNeed = need; to = j; }\n }\n if (to == from) continue;\n\n long long w = T[i];\n long long oldPart = llabs(binSum[from] - D[from]) + llabs(binSum[to] - D[to]);\n\n long long newFromSum = binSum[from] - w;\n long long newToSum = binSum[to] + w;\n long long newPart = llabs(newFromSum - D[from]) + llabs(newToSum - D[to]);\n\n long long newCost = cost + (newPart - oldPart);\n\n bool accept = false;\n if (newCost <= cost) accept = true;\n else {\n double prob = exp((double)(cost - newCost) / temp);\n if ((*rng).next_double() < prob) accept = true;\n }\n if (accept) {\n b[i] = to;\n binSum[from] -= w;\n binSum[to] += w;\n cost = newCost;\n }\n }\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, L;\n cin >> N >> L;\n static int T[NMAX];\n for (int i = 0; i < N; i++) cin >> T[i];\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift64 rng(seed);\n\n // ---- Build a as ascending-by-T Hamiltonian cycle, rotated so order[0]=0 ----\n vector order(N);\n iota(order.begin(), order.end(), 0);\n stable_sort(order.begin(), order.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] < T[j];\n return i < j;\n });\n // rotate to put employee 0 at position 0 (slightly reduces start transient weirdness)\n {\n int pos0 = 0;\n for (int k = 0; k < N; k++) if (order[k] == 0) { pos0 = k; break; }\n rotate(order.begin(), order.begin() + pos0, order.end());\n }\n\n static int a[NMAX], b_cur[NMAX], b_best[NMAX];\n static int predOf[NMAX];\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n a[u] = v;\n }\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n predOf[v] = u;\n }\n\n // residual demand for b-slots in the stationary-equation sense:\n // 2*T[j] should equal sum of incoming slot-weights T[i] (one per outgoing edge-slot).\n // a-cycle already contributes one slot weight T[predOf[j]] into j.\n static long long D[NMAX];\n for (int j = 0; j < N; j++) D[j] = 2LL * T[j] - (long long)T[predOf[j]];\n // With ascending cycle, T[pred] <= T[j] => D[j] >= T[j] >= 0.\n\n // ---- Fast multi-start optimization of b assignment (cheap objective) ----\n vector best_b_assign;\n long long best_assign_cost = (1LL<<62);\n\n // decide time budget split\n auto tStart = chrono::high_resolution_clock::now();\n const double TL = 1.90; // overall\n const double TL_FAST = 0.55; // spend ~0.55s in cheap b-optimizer\n\n int restarts = 8;\n for (int r = 0; r < restarts; r++) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - tStart).count();\n if (elapsed > TL_FAST) break;\n\n FastBAssignOptimizer opt;\n opt.N = N;\n opt.T = T;\n opt.D = D;\n opt.rng = &rng;\n\n opt.greedy_init();\n // more iterations on first restart, fewer later\n int iters = (r == 0 ? 250000 : 150000);\n opt.run_sa(iters, 8000.0, 5.0);\n\n if (opt.cost < best_assign_cost) {\n best_assign_cost = opt.cost;\n best_b_assign = opt.b;\n }\n }\n\n if (best_b_assign.empty()) {\n best_b_assign.assign(N, 0);\n }\n for (int i = 0; i < N; i++) b_cur[i] = best_b_assign[i];\n\n // ---- Evaluate by true simulation ----\n static int cnt_cur[NMAX], cnt_tmp[NMAX];\n long long err_cur = simulate_plan(N, L, a, b_cur, T, cnt_cur);\n long long err_best = err_cur;\n for (int i = 0; i < N; i++) b_best[i] = b_cur[i];\n\n // ---- Expensive SA on true error, remaining time ----\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - tStart).count();\n if (elapsed > TL) break;\n\n double progress = (elapsed - TL_FAST) / max(1e-9, (TL - TL_FAST));\n progress = min(1.0, max(0.0, progress));\n double temp0 = 1500.0, temp1 = 10.0;\n double temp = temp0 * pow(temp1 / temp0, progress);\n\n // Build biased lists occasionally (cheap)\n // Pick i among those with large cnt (affects more future path)\n array idxByCnt;\n for (int i = 0; i < N; i++) idxByCnt[i] = i;\n nth_element(idxByCnt.begin(), idxByCnt.begin() + min(N, 30), idxByCnt.begin() + N,\n [&](int i, int j){ return cnt_cur[i] > cnt_cur[j]; });\n int i = idxByCnt[rng.next_int(0, min(N, 30) - 1)];\n\n bool doSwap = (rng.next_double() < 0.40);\n\n int old_bi = b_cur[i];\n int i2 = -1, old_bi2 = -1;\n\n if (!doSwap) {\n // Move b_i to a deficit node with bias\n // Choose candidate among top deficits by sampling\n int bestJ = old_bi;\n int bestDef = INT_MIN;\n for (int s = 0; s < 12; s++) {\n int j = rng.next_int(0, N - 1);\n int def = T[j] - cnt_cur[j];\n if (def > bestDef) { bestDef = def; bestJ = j; }\n }\n int j = bestJ;\n if (j == old_bi) continue;\n b_cur[i] = j;\n } else {\n // Swap two b's\n i2 = idxByCnt[rng.next_int(0, min(N, 30) - 1)];\n if (i2 == i) i2 = rng.next_int(0, N - 1);\n if (i2 == i) continue;\n old_bi2 = b_cur[i2];\n if (old_bi2 == old_bi) continue;\n swap(b_cur[i], b_cur[i2]);\n }\n\n long long err_new = simulate_plan(N, L, a, b_cur, T, cnt_tmp);\n\n bool accept = false;\n if (err_new <= err_cur) accept = true;\n else {\n double prob = exp((double)(err_cur - err_new) / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n err_cur = err_new;\n for (int k = 0; k < N; k++) cnt_cur[k] = cnt_tmp[k];\n if (err_cur < err_best) {\n err_best = err_cur;\n for (int k = 0; k < N; k++) b_best[k] = b_cur[k];\n }\n } else {\n // revert\n if (!doSwap) {\n b_cur[i] = old_bi;\n } else {\n swap(b_cur[i], b_cur[i2]);\n }\n }\n }\n\n // Output\n for (int i = 0; i < N; i++) {\n cout << a[i] << ' ' << b_best[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nstruct DSU {\n int n;\n vector p, r;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n p.resize(n);\n r.assign(n,0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){ return p[a]==a?a:p[a]=find(p[a]);}\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a] 0; s /= 2) {\n int rx = (x & s) ? 1 : 0;\n int ry = (y & s) ? 1 : 0;\n d += (uint32_t)s * (uint32_t)s * (uint32_t)((3 * rx) ^ ry);\n rot(s, x, y, rx, ry);\n }\n return d;\n}\n\nstatic inline long long dist2_est(int ax, int ay, int bx, int by){\n long long dx = ax - bx;\n long long dy = ay - by;\n return dx*dx + dy*dy;\n}\n\nstruct GroupInfo {\n vector nodes;\n bool exactKnown = false;\n vector> exactEdges; // size = g-1 if exactKnown\n vector> queryEdges; // partial edges from block queries\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for(int i=0;i> G[i];\n\n vector lx(N), rx(N), ly(N), ry(N);\n for(int i=0;i> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n // Estimated coordinate = center of rectangle\n vector ex(N), ey(N);\n for(int i=0;iint{\n return (int)llround((long double)v * 65535.0L / 10000.0L);\n };\n\n vector hkey(N);\n for(int i=0;i order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int a, int b){\n if(hkey[a] != hkey[b]) return hkey[a] < hkey[b];\n if(ex[a] != ex[b]) return ex[a] < ex[b];\n return ey[a] < ey[b];\n });\n\n // Prefix sum of consecutive squared distances along Hilbert order (for O(1) segment chain-cost)\n vector pref(N, 0);\n for(int i=0;i+1long long{\n if(s <= 1) return 0LL;\n // sum of (p..p+s-2) edges => pref[p+s-1]-pref[p]\n return pref[p+s-1] - pref[p];\n };\n\n // Build multiset of required sizes (we will create groups in any order, then map by size)\n map cnt;\n for(int x: G) cnt[x]++;\n\n auto pop_size = [&](int s){\n auto it = cnt.find(s);\n if(it == cnt.end()) return false;\n if(--it->second == 0) cnt.erase(it);\n return true;\n };\n\n // Candidate size extraction helper\n auto collect_candidates = [&](int nrem, int grem)->vector{\n vector cands;\n cands.reserve(32);\n\n // smallest few\n for(auto it = cnt.begin(); it != cnt.end() && (int)cands.size() < 6; ++it){\n if(it->first <= nrem) cands.push_back(it->first);\n }\n // largest few\n int added = 0;\n for(auto it = cnt.rbegin(); it != cnt.rend() && added < 4; ++it){\n if(it->first <= nrem) { cands.push_back(it->first); added++; }\n }\n\n // around target\n double target = (grem > 0) ? (double)nrem / (double)grem : (double)nrem;\n vector keys;\n keys.reserve(cnt.size());\n for(auto &kv: cnt) keys.push_back(kv.first);\n auto it = lower_bound(keys.begin(), keys.end(), (int)llround(target));\n for(int d=-3; d<=3; d++){\n int idx = (int)(it - keys.begin()) + d;\n if(0 <= idx && idx < (int)keys.size()){\n int s = keys[idx];\n if(s <= nrem) cands.push_back(s);\n }\n }\n\n // remove duplicates\n sort(cands.begin(), cands.end());\n cands.erase(unique(cands.begin(), cands.end()), cands.end());\n if(cands.empty()){\n // should not happen (max size <= nrem always), but keep safe:\n for(auto &kv: cnt) if(kv.first <= nrem) { cands.push_back(kv.first); break; }\n }\n return cands;\n };\n\n // Greedy grouping along Hilbert order choosing next size from remaining multiset\n vector glist;\n glist.reserve(M);\n\n int p = 0;\n int groupsRem = M;\n while(groupsRem > 0){\n int nrem = N - p;\n // If only one group left, it must take everything\n if(groupsRem == 1){\n int s = nrem;\n // s must exist in multiset\n if(!pop_size(s)){\n // fallback: take the largest remaining size (shouldn't happen)\n s = cnt.rbegin()->first;\n pop_size(s);\n }\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+s);\n glist.push_back(std::move(gi));\n p += s;\n groupsRem--;\n break;\n }\n\n auto cands = collect_candidates(nrem, groupsRem);\n\n // Choose size with minimum score\n // score = avg chain cost + lambda*|s-target|\n long double target = (long double)nrem / (long double)groupsRem;\n const long double lambda = 1e4L; // mild regularization to avoid pathological size usage\n int bestS = -1;\n long double bestVal = 1e100L;\n\n for(int s: cands){\n if(s > nrem) continue;\n long double avg = 0;\n if(s >= 2){\n avg = (long double)chainCost(p, s) / (long double)(s - 1);\n }\n long double val = avg + lambda * fabsl((long double)s - target);\n if(val < bestVal){\n bestVal = val;\n bestS = s;\n }\n }\n\n if(bestS < 1 || bestS > nrem){\n bestS = cnt.begin()->first;\n if(bestS > nrem) bestS = cnt.rbegin()->first;\n }\n\n pop_size(bestS);\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+bestS);\n glist.push_back(std::move(gi));\n p += bestS;\n groupsRem--;\n }\n\n // Map created groups to output indices by size\n vector outIdx(M);\n iota(outIdx.begin(), outIdx.end(), 0);\n sort(outIdx.begin(), outIdx.end(), [&](int a, int b){\n if(G[a] != G[b]) return G[a] < G[b];\n return a < b;\n });\n\n vector grpIdx(M);\n iota(grpIdx.begin(), grpIdx.end(), 0);\n sort(grpIdx.begin(), grpIdx.end(), [&](int a, int b){\n int sa = (int)glist[a].nodes.size();\n int sb = (int)glist[b].nodes.size();\n if(sa != sb) return sa < sb;\n return a < b;\n });\n\n // This assumes multisets match (they do by construction)\n vector groupForOut(M, -1);\n for(int i=0;i& subset)->vector>{\n int l = (int)subset.size();\n cout << \"? \" << l;\n for(int v: subset) cout << \" \" << v;\n cout << \"\\n\" << flush;\n vector> ret;\n ret.reserve(l-1);\n for(int i=0;i> a >> b;\n if(a>b) swap(a,b);\n ret.push_back({a,b});\n }\n return ret;\n };\n\n // Query allocation:\n // 1) exact query for groups of size 3..L (best ROI)\n // 2) remaining queries used for large groups with overlapping windows\n int usedQ = 0;\n\n vector allGroups(M);\n iota(allGroups.begin(), allGroups.end(), 0);\n\n // exact-first: small groups\n sort(allGroups.begin(), allGroups.end(), [&](int a, int b){\n int sa = (int)glist[a].nodes.size();\n int sb = (int)glist[b].nodes.size();\n if(sa != sb) return sa < sb;\n return a < b;\n });\n\n for(int gi : allGroups){\n if(usedQ >= Q) break;\n int g = (int)glist[gi].nodes.size();\n if(3 <= g && g <= L){\n auto ret = do_query(glist[gi].nodes);\n glist[gi].exactKnown = true;\n glist[gi].exactEdges = std::move(ret);\n usedQ++;\n }\n }\n\n // large groups: partial queries if budget remains\n vector largeGroups;\n for(int gi=0; gi L) largeGroups.push_back(gi);\n }\n sort(largeGroups.begin(), largeGroups.end(), [&](int a, int b){\n int sa = (int)glist[a].nodes.size();\n int sb = (int)glist[b].nodes.size();\n return sa > sb;\n });\n\n for(int gi : largeGroups){\n if(usedQ >= Q) break;\n auto &vec = glist[gi].nodes;\n int g = (int)vec.size();\n int pos = 0;\n // overlap by 1, step = L-1\n while(pos < g-1 && usedQ < Q){\n int l = min(L, g - pos);\n if(l < 2) break;\n vector subset(vec.begin()+pos, vec.begin()+pos+l);\n auto ret = do_query(subset);\n glist[gi].queryEdges.insert(glist[gi].queryEdges.end(), ret.begin(), ret.end());\n usedQ++;\n pos += (l - 1);\n }\n }\n\n // Output\n cout << \"!\\n\" << flush;\n\n // For per-group edge building\n auto add_unique_edge = [&](unordered_set &seen, vector> &edges, int u, int v){\n if(u==v) return;\n if(u>v) swap(u,v);\n // key: u*1024+v (N<=800)\n int key = u*1024 + v;\n if(seen.insert(key).second){\n edges.push_back({u,v});\n }\n };\n\n for(int outk=0; outkv) swap(u,v);\n cout << u << \" \" << v << \"\\n\";\n continue;\n }\n\n // Build candidate edges\n unordered_set seen;\n seen.reserve((size_t)g * 64);\n\n vector> candQuery;\n candQuery.reserve(info.queryEdges.size());\n for(auto &e: info.queryEdges){\n add_unique_edge(seen, candQuery, e.first, e.second);\n }\n\n vector> candOther;\n candOther.reserve((size_t)g * 32);\n\n // Chain edges (guarantee basic connectivity possibility)\n for(int i=0;i byx = vec, byy = vec;\n sort(byx.begin(), byx.end(), [&](int a,int b){\n if(ex[a]!=ex[b]) return ex[a]> tmp;\n tmp.reserve(g-1);\n for(int jj=0; jj lid;\n lid.reserve((size_t)g*2);\n for(int i=0;i all;\n all.reserve(candQuery.size() + candOther.size());\n\n auto pushE = [&](int u,int v,bool isQ){\n long long d2 = dist2_est(ex[u], ey[u], ex[v], ey[v]);\n all.push_back({u,v,d2,isQ});\n };\n for(auto &e: candQuery) pushE(e.first, e.second, true);\n for(auto &e: candOther) pushE(e.first, e.second, false);\n\n sort(all.begin(), all.end(), [&](const CandE& a, const CandE& b){\n // Prefer query edges, but still consider estimated length\n long double wa = (long double)a.d2 * (a.isQuery ? 0.70L : 1.0L);\n long double wb = (long double)b.d2 * (b.isQuery ? 0.70L : 1.0L);\n if(wa != wb) return wa < wb;\n if(a.isQuery != b.isQuery) return a.isQuery > b.isQuery;\n if(a.u != b.u) return a.u < b.u;\n return a.v < b.v;\n });\n\n DSU dsu(g);\n vector> chosen;\n chosen.reserve(g-1);\n\n for(auto &e: all){\n int a = lid[e.u], b = lid[e.v];\n if(dsu.unite(a,b)){\n int u=e.u, v=e.v;\n if(u>v) swap(u,v);\n chosen.push_back({u,v});\n if((int)chosen.size() == g-1) break;\n }\n }\n\n // If still disconnected, connect components by cheapest estimated edges (O(g^2), g<=800 ok)\n while((int)chosen.size() < g-1){\n for(int i=0;iv) swap(u,v);\n chosen.push_back({u,v});\n }\n\n // Ultimate fallback: star\n if((int)chosen.size() != g-1){\n chosen.clear();\n int c = vec[0];\n for(int i=1;iv) swap(u,v);\n chosen.push_back({u,v});\n }\n }\n\n for(auto &e: chosen){\n cout << e.first << \" \" << e.second << \"\\n\";\n }\n }\n\n cout << flush;\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nstatic constexpr int N = 20;\n\nstruct Pos {\n int r, c;\n};\nstatic inline int pid(int r, int c) { return r * N + c; }\nstatic inline bool inside(int r, int c) { return 0 <= r && r < N && 0 <= c && c < N; }\n\nstruct Prev {\n int pstate = -1;\n char act = '?';\n char dir = '?';\n};\n\nstatic const int dr[4] = {-1, 1, 0, 0};\nstatic const int dc[4] = {0, 0, -1, 1};\nstatic const char dch[4] = {'U', 'D', 'L', 'R'};\n\nstruct Planner {\n // candidate cells (<=8)\n vector cand;\n array cand_id; // -1 if not candidate, else index\n int C = 0;\n\n Planner() {\n cand_id.fill(-1);\n }\n\n void build_candidates(const Pos& start, const Pos& target) {\n cand.clear();\n cand_id.fill(-1);\n\n auto add = [&](int r, int c) {\n if (!inside(r,c)) return;\n int id = pid(r,c);\n if (cand_id[id] != -1) return;\n cand_id[id] = (int)cand.size();\n cand.push_back({r,c});\n };\n\n // neighbors of start\n for (int k = 0; k < 4; k++) add(start.r + dr[k], start.c + dc[k]);\n // neighbors of target\n for (int k = 0; k < 4; k++) add(target.r + dr[k], target.c + dc[k]);\n\n C = (int)cand.size();\n }\n\n inline bool is_blocked_cell(int r, int c, int mask) const {\n int idx = cand_id[pid(r,c)];\n if (idx == -1) return false; // board is otherwise empty\n return (mask >> idx) & 1;\n }\n\n int slide_endpoint(int r, int c, int dir, int mask) const {\n // Find nearest candidate-block in that ray; otherwise boundary.\n int bestDist = INT_MAX;\n\n // scan candidate blocks only (C <= 8)\n for (int i = 0; i < C; i++) if ((mask >> i) & 1) {\n int br = cand[i].r, bc = cand[i].c;\n if (dir == 0) { // U\n if (bc == c && br < r) bestDist = min(bestDist, r - br);\n } else if (dir == 1) { // D\n if (bc == c && br > r) bestDist = min(bestDist, br - r);\n } else if (dir == 2) { // L\n if (br == r && bc < c) bestDist = min(bestDist, c - bc);\n } else { // R\n if (br == r && bc > c) bestDist = min(bestDist, bc - c);\n }\n }\n\n if (bestDist != INT_MAX) {\n // stop right before the block\n int nr = r + dr[dir] * (bestDist - 1);\n int nc = c + dc[dir] * (bestDist - 1);\n return pid(nr, nc);\n } else {\n // stop at boundary edge cell\n if (dir == 0) return pid(0, c);\n if (dir == 1) return pid(N - 1, c);\n if (dir == 2) return pid(r, 0);\n return pid(r, N - 1);\n }\n }\n\n // BFS shortest path from start to target, with mask starting at 0 and ending at 0\n vector> plan(const Pos& start, const Pos& target) {\n build_candidates(start, target);\n const int MASKS = 1 << C;\n const int STATES = (N*N) * MASKS;\n\n vector dist(STATES, -1);\n vector prv(STATES);\n\n auto sid = [&](int pos, int mask) {\n return pos * MASKS + mask;\n };\n\n int sPos = pid(start.r, start.c);\n int tPos = pid(target.r, target.c);\n int sState = sid(sPos, 0);\n int gState = sid(tPos, 0);\n\n deque q;\n dist[sState] = 0;\n q.push_back(sState);\n\n while (!q.empty()) {\n int cur = q.front(); q.pop_front();\n if (cur == gState) break;\n\n int pos = cur / MASKS;\n int mask = cur % MASKS;\n int r = pos / N;\n int c = pos % N;\n\n for (int d = 0; d < 4; d++) {\n // Move\n {\n int nr = r + dr[d], nc = c + dc[d];\n if (inside(nr,nc) && !is_blocked_cell(nr,nc,mask)) {\n int np = pid(nr,nc);\n int ns = sid(np, mask);\n if (dist[ns] == -1) {\n dist[ns] = dist[cur] + 1;\n prv[ns] = {cur, 'M', dch[d]};\n q.push_back(ns);\n }\n }\n }\n // Slide\n {\n int np = slide_endpoint(r,c,d,mask);\n int ns = sid(np, mask);\n if (dist[ns] == -1) {\n dist[ns] = dist[cur] + 1;\n prv[ns] = {cur, 'S', dch[d]};\n q.push_back(ns);\n }\n }\n // Alter (only if adjacent cell is in candidate set)\n {\n int ar = r + dr[d], ac = c + dc[d];\n if (inside(ar,ac)) {\n int idx = cand_id[pid(ar,ac)];\n if (idx != -1) {\n int nmask = mask ^ (1 << idx);\n int ns = sid(pos, nmask);\n if (dist[ns] == -1) {\n dist[ns] = dist[cur] + 1;\n prv[ns] = {cur, 'A', dch[d]};\n q.push_back(ns);\n }\n }\n }\n }\n }\n }\n\n if (dist[gState] == -1) {\n // Should not happen, but fallback: Manhattan moves (board is empty).\n vector> res;\n int r = start.r, c = start.c;\n while (r < target.r) { res.push_back({'M','D'}); r++; }\n while (r > target.r) { res.push_back({'M','U'}); r--; }\n while (c < target.c) { res.push_back({'M','R'}); c++; }\n while (c > target.c) { res.push_back({'M','L'}); c--; }\n return res;\n }\n\n // Reconstruct\n vector> rev;\n int cur = gState;\n while (cur != sState) {\n Prev p = prv[cur];\n rev.push_back({p.act, p.dir});\n cur = p.pstate;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n }\n\n // For debug/safety: simulate within the same per-leg candidate/mask model\n void simulate_leg(Pos &cur, const Pos& target, const vector>& acts) {\n // candidates already built by plan() before calling this, but to be safe rebuild:\n build_candidates(cur, target);\n int mask = 0;\n\n auto dirIndex = [&](char d)->int{\n if (d=='U') return 0;\n if (d=='D') return 1;\n if (d=='L') return 2;\n return 3;\n };\n\n for (auto [a,d] : acts) {\n int di = dirIndex(d);\n if (a=='M') {\n int nr = cur.r + dr[di], nc = cur.c + dc[di];\n if (!inside(nr,nc) || is_blocked_cell(nr,nc,mask)) {\n // illegal; ignore in release builds\n // but we keep it strict:\n cerr << \"Illegal move\\n\";\n exit(0);\n }\n cur = {nr,nc};\n } else if (a=='S') {\n int np = slide_endpoint(cur.r, cur.c, di, mask);\n cur = {np / N, np % N};\n } else if (a=='A') {\n int ar = cur.r + dr[di], ac = cur.c + dc[di];\n if (!inside(ar,ac)) { cerr << \"Illegal alter\\n\"; exit(0); }\n int idx = cand_id[pid(ar,ac)];\n if (idx == -1) { cerr << \"Alter outside candidates (shouldn't happen)\\n\"; exit(0); }\n mask ^= (1<> n >> M;\n vector pts(M);\n for (int i = 0; i < M; i++) cin >> pts[i].r >> pts[i].c;\n\n Pos cur = pts[0];\n vector> answer;\n answer.reserve(1600);\n\n Planner planner;\n\n for (int k = 1; k < M; k++) {\n Pos tgt = pts[k];\n auto acts = planner.plan(cur, tgt);\n\n // Safety simulate (cheap) and advance cur\n planner.simulate_leg(cur, tgt, acts);\n\n for (auto &p : acts) answer.push_back(p);\n }\n\n // Output\n for (auto [a,d] : answer) {\n cout << a << ' ' << d << \"\\n\";\n }\n return 0;\n}"},"4":{"ahc001":"#include \nusing namespace std;\n\nstatic constexpr int W = 10000;\nstatic constexpr int H = 10000;\n\nstruct Rect {\n int lx, ly, rx, ry; // [lx,rx) x [ly,ry)\n};\n\nstatic inline long long areaLL(const Rect& r) {\n return 1LL * (r.rx - r.lx) * (r.ry - r.ly);\n}\nstatic inline bool overlapPosArea(const Rect& a, const Rect& b) {\n int x0 = max(a.lx, b.lx);\n int x1 = min(a.rx, b.rx);\n if (x0 >= x1) return false;\n int y0 = max(a.ly, b.ly);\n int y1 = min(a.ry, b.ry);\n return y0 < y1;\n}\nstatic inline double sat(long long r, long long s) {\n long long mn = min(r, s);\n long long mx = max(r, s);\n double a = (double)mn / (double)mx;\n double t = 1.0 - a;\n return 1.0 - t * t;\n}\n\n// splitmix64 RNG\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t nextU64() {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n }\n uint32_t nextU32() { return (uint32_t)nextU64(); }\n double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Solver {\n int n;\n vector x, y;\n vector r;\n vector rects;\n vector p;\n RNG rng;\n\n using clk = chrono::high_resolution_clock;\n clk::time_point start;\n\n double elapsedSec() const {\n return chrono::duration(clk::now() - start).count();\n }\n\n bool containsPoint(int i, const Rect& rc) const {\n return (rc.lx <= x[i] && rc.rx >= x[i] + 1 && rc.ly <= y[i] && rc.ry >= y[i] + 1);\n }\n bool inBounds(const Rect& rc) const {\n return (0 <= rc.lx && rc.lx < rc.rx && rc.rx <= W &&\n 0 <= rc.ly && rc.ly < rc.ry && rc.ry <= H);\n }\n bool validNoOverlapOne(int i, const Rect& rc) const {\n if (!inBounds(rc)) return false;\n if (!containsPoint(i, rc)) return false;\n for (int j = 0; j < n; j++) if (j != i) {\n if (overlapPosArea(rc, rects[j])) return false;\n }\n return true;\n }\n bool validNoOverlapTwo(int i, const Rect& ri, int j, const Rect& rj) const {\n if (!inBounds(ri) || !inBounds(rj)) return false;\n if (!containsPoint(i, ri) || !containsPoint(j, rj)) return false;\n if (overlapPosArea(ri, rj)) return false;\n for (int k = 0; k < n; k++) if (k != i && k != j) {\n if (overlapPosArea(ri, rects[k])) return false;\n if (overlapPosArea(rj, rects[k])) return false;\n }\n return true;\n }\n\n // Directional nearest blockers\n int blockerRight(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestL = W + 1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.lx >= a.rx && b.lx < bestL) {\n bestL = b.lx;\n best = j;\n }\n }\n }\n return best;\n }\n int blockerLeft(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestR = -1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.rx <= a.lx && b.rx > bestR) {\n bestR = b.rx;\n best = j;\n }\n }\n }\n return best;\n }\n int blockerUp(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestB = H + 1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ly >= a.ry && b.ly < bestB) {\n bestB = b.ly;\n best = j;\n }\n }\n }\n return best;\n }\n int blockerDown(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestT = -1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ry <= a.ly && b.ry > bestT) {\n bestT = b.ry;\n best = j;\n }\n }\n }\n return best;\n }\n\n int limitRight(int i) const {\n const Rect& a = rects[i];\n int lim = W;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.lx >= a.rx) lim = min(lim, b.lx);\n }\n }\n return lim;\n }\n int limitLeft(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.rx <= a.lx) lim = max(lim, b.rx);\n }\n }\n return lim;\n }\n int limitUp(int i) const {\n const Rect& a = rects[i];\n int lim = H;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ly >= a.ry) lim = min(lim, b.ly);\n }\n }\n return lim;\n }\n int limitDown(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ry <= a.ly) lim = max(lim, b.ry);\n }\n }\n return lim;\n }\n\n void init() {\n rects.resize(n);\n p.assign(n, 0.0);\n for (int i = 0; i < n; i++) {\n rects[i] = Rect{x[i], y[i], x[i] + 1, y[i] + 1};\n p[i] = sat(r[i], 1);\n }\n }\n\n void greedyExpand(int rounds = 7) {\n vector ord(n);\n iota(ord.begin(), ord.end(), 0);\n\n for (int rep = 0; rep < rounds; rep++) {\n shuffle(ord.begin(), ord.end(), std::mt19937((unsigned)rng.nextU32()));\n for (int idx = 0; idx < n; idx++) {\n int i = ord[idx];\n for (;;) {\n Rect cur = rects[i];\n long long s0 = areaLL(cur);\n if (s0 >= r[i]) break;\n\n double bestGain = 1e-18;\n Rect bestR = cur;\n\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n\n // Right\n {\n int lim = limitRight(i);\n if (lim > cur.rx) {\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.lx + (int)needW;\n vector cands = {cur.rx + 1, ideal - 1, ideal, ideal + 1, lim};\n for (int rx2 : cands) {\n rx2 = max(rx2, cur.rx + 1);\n rx2 = min(rx2, lim);\n if (rx2 <= cur.rx) continue;\n Rect cand = cur; cand.rx = rx2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n // Left\n {\n int lim = limitLeft(i);\n if (lim < cur.lx) {\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.rx - (int)needW;\n vector cands = {cur.lx - 1, ideal - 1, ideal, ideal + 1, lim};\n for (int lx2 : cands) {\n lx2 = min(lx2, cur.lx - 1);\n lx2 = max(lx2, lim);\n lx2 = min(lx2, x[i]);\n if (lx2 >= cur.lx) continue;\n Rect cand = cur; cand.lx = lx2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n // Up\n {\n int lim = limitUp(i);\n if (lim > cur.ry) {\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ly + (int)needH;\n vector cands = {cur.ry + 1, ideal - 1, ideal, ideal + 1, lim};\n for (int ry2 : cands) {\n ry2 = max(ry2, cur.ry + 1);\n ry2 = min(ry2, lim);\n if (ry2 <= cur.ry) continue;\n Rect cand = cur; cand.ry = ry2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n // Down\n {\n int lim = limitDown(i);\n if (lim < cur.ly) {\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ry - (int)needH;\n vector cands = {cur.ly - 1, ideal - 1, ideal, ideal + 1, lim};\n for (int ly2 : cands) {\n ly2 = min(ly2, cur.ly - 1);\n ly2 = max(ly2, lim);\n ly2 = min(ly2, y[i]);\n if (ly2 >= cur.ly) continue;\n Rect cand = cur; cand.ly = ly2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n\n if (bestGain <= 1e-18) break;\n rects[i] = bestR;\n p[i] = sat(r[i], areaLL(bestR));\n }\n }\n }\n }\n\n // shrink-only overshoot fixer (safe)\n Rect fitInsideShrink(int i, const Rect& cur) const {\n int w0 = cur.rx - cur.lx;\n int h0 = cur.ry - cur.ly;\n long long ri = r[i];\n\n auto place1D = [&](int L, int R, int pos, int len)->pair{\n int minL = L;\n int maxL = R - len;\n int l = pos - (len - 1) / 2;\n l = max(minL, min(maxL, l));\n int rr = l + len;\n if (!(l <= pos && pos + 1 <= rr)) {\n l = max(minL, min(maxL, pos + 1 - len));\n rr = l + len;\n }\n return {l, rr};\n };\n\n Rect best = cur;\n double bestP = sat(ri, areaLL(cur));\n\n vector Ws, Hs;\n auto add = [&](vector& v, int val, int cap){\n val = max(1, min(val, cap));\n v.push_back(val);\n };\n int sq = (int)floor(sqrt((double)ri));\n add(Ws, sq, w0); add(Ws, sq+1, w0); add(Ws, w0, w0);\n add(Hs, sq, h0); add(Hs, sq+1, h0); add(Hs, h0, h0);\n\n add(Ws, (int)max(1LL, (ri + h0 - 1) / h0), w0);\n add(Hs, (int)max(1LL, (ri + w0 - 1) / w0), h0);\n\n sort(Ws.begin(), Ws.end());\n Ws.erase(unique(Ws.begin(), Ws.end()), Ws.end());\n sort(Hs.begin(), Hs.end());\n Hs.erase(unique(Hs.begin(), Hs.end()), Hs.end());\n\n for (int w : Ws) {\n int h = (int)max(1LL, min(h0, (ri + w - 1) / w));\n for (int dh : {0, -1, +1}) {\n int hh = h + dh;\n if (hh < 1 || hh > h0) continue;\n auto [lx, rx] = place1D(cur.lx, cur.rx, x[i], w);\n auto [ly, ry] = place1D(cur.ly, cur.ry, y[i], hh);\n Rect cand{lx, ly, rx, ry};\n double pp = sat(ri, areaLL(cand));\n if (pp > bestP + 1e-15) { bestP = pp; best = cand; }\n }\n }\n for (int h : Hs) {\n int w = (int)max(1LL, min(w0, (ri + h - 1) / h));\n for (int dw : {0, -1, +1}) {\n int ww = w + dw;\n if (ww < 1 || ww > w0) continue;\n auto [lx, rx] = place1D(cur.lx, cur.rx, x[i], ww);\n auto [ly, ry] = place1D(cur.ly, cur.ry, y[i], h);\n Rect cand{lx, ly, rx, ry};\n double pp = sat(ri, areaLL(cand));\n if (pp > bestP + 1e-15) { bestP = pp; best = cand; }\n }\n }\n return best;\n }\n\n int pickIndexTournament() {\n auto badness = [&](int i)->double{\n long long s = areaLL(rects[i]);\n double err = (double)llabs(s - r[i]) / (double)r[i];\n return (1.0 - p[i]) + 0.20 * err;\n };\n int best = rng.nextInt(0, n - 1);\n double bb = badness(best);\n for (int t = 0; t < 4; t++) {\n int j = rng.nextInt(0, n - 1);\n double bj = badness(j);\n if (bj > bb) { bb = bj; best = j; }\n }\n return best;\n }\n\n // New move: expand i while shrinking its nearest blocking neighbor j.\n bool tryStealMove(int i, Rect& outRi, int& outJ, Rect& outRj) {\n outRi = rects[i];\n outJ = -1;\n outRj = Rect{0,0,0,0};\n\n if (areaLL(rects[i]) >= r[i]) return false; // mostly use for deficit\n\n int dir = rng.nextInt(0, 3); // 0:R 1:L 2:U 3:D\n if (dir == 0) {\n int j = blockerRight(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // max delta constrained by b's left moving right while still containing its point\n int maxDelta = min(b.rx - b.lx - 1, x[j] - b.lx);\n if (maxDelta <= 0) return false;\n\n // also can expand into current gap for free; delta can exceed gap because we shrink b\n int h = a.ry - a.ly;\n long long needW = (r[i] + h - 1) / h;\n int want = max(1, (int)needW - (a.rx - a.lx));\n int d = min(maxDelta, max(1, want));\n // small randomness\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.rx += d;\n nb.lx += d;\n if (!containsPoint(j, nb)) return false;\n // ensure still ordered\n if (na.rx > nb.lx) na.rx = nb.lx;\n if (na.rx <= na.lx) return false;\n if (nb.lx >= nb.rx) return false;\n\n // Validate strictly to be safe\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n\n outRi = na; outJ = j; outRj = nb;\n return true;\n } else if (dir == 1) {\n int j = blockerLeft(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // shrink b from right (move rx left)\n int maxDelta = min(b.rx - b.lx - 1, b.rx - (x[j] + 1));\n if (maxDelta <= 0) return false;\n\n int h = a.ry - a.ly;\n long long needW = (r[i] + h - 1) / h;\n int want = max(1, (int)needW - (a.rx - a.lx));\n int d = min(maxDelta, max(1, want));\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.lx -= d;\n nb.rx -= d;\n if (!containsPoint(j, nb)) return false;\n if (nb.rx > na.lx) na.lx = nb.rx;\n if (na.lx >= na.rx) return false;\n if (nb.lx >= nb.rx) return false;\n\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n outRi = na; outJ = j; outRj = nb;\n return true;\n } else if (dir == 2) {\n int j = blockerUp(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // shrink b from bottom (move ly up)\n int maxDelta = min(b.ry - b.ly - 1, y[j] - b.ly);\n if (maxDelta <= 0) return false;\n\n int w = a.rx - a.lx;\n long long needH = (r[i] + w - 1) / w;\n int want = max(1, (int)needH - (a.ry - a.ly));\n int d = min(maxDelta, max(1, want));\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.ry += d;\n nb.ly += d;\n if (!containsPoint(j, nb)) return false;\n if (na.ry > nb.ly) na.ry = nb.ly;\n if (na.ry <= na.ly) return false;\n if (nb.ly >= nb.ry) return false;\n\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n outRi = na; outJ = j; outRj = nb;\n return true;\n } else {\n int j = blockerDown(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // shrink b from top (move ry down)\n int maxDelta = min(b.ry - b.ly - 1, b.ry - (y[j] + 1));\n if (maxDelta <= 0) return false;\n\n int w = a.rx - a.lx;\n long long needH = (r[i] + w - 1) / w;\n int want = max(1, (int)needH - (a.ry - a.ly));\n int d = min(maxDelta, max(1, want));\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.ly -= d;\n nb.ry -= d;\n if (!containsPoint(j, nb)) return false;\n if (nb.ry > na.ly) na.ly = nb.ry;\n if (na.ly >= na.ry) return false;\n if (nb.ly >= nb.ry) return false;\n\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n outRi = na; outJ = j; outRj = nb;\n return true;\n }\n }\n\n void anneal(double endTimeSec) {\n const double T0 = 0.06;\n const double T1 = 0.0016;\n\n while (elapsedSec() < endTimeSec) {\n double prog = elapsedSec() / endTimeSec;\n double temp = T0 * pow(T1 / T0, prog);\n\n int i = pickIndexTournament();\n Rect cur = rects[i];\n long long s0 = areaLL(cur);\n double p0 = p[i];\n\n double op = rng.nextDouble();\n\n if (op < 0.16) {\n // NEW: steal space from nearest blocker\n Rect ni, njr;\n int j;\n if (!tryStealMove(i, ni, j, njr)) continue;\n\n double pi1 = sat(r[i], areaLL(ni));\n double pj1 = sat(r[j], areaLL(njr));\n double delta = (pi1 + pj1) - (p[i] + p[j]);\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.nextDouble() < exp(delta / temp)) accept = true;\n\n if (accept) {\n rects[i] = ni; p[i] = pi1;\n rects[j] = njr; p[j] = pj1;\n }\n continue;\n }\n\n Rect cand = cur;\n\n if (op < 0.76) {\n // Resize one side (expand/shrink)\n int side = (int)(rng.nextU32() % 4); // 0:L 1:R 2:D 3:U\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n\n bool wantExpand = (s0 < r[i]) ? (rng.nextDouble() < 0.85) : (rng.nextDouble() < 0.18);\n\n if (wantExpand) {\n if (side == 1) { // right\n int lim = limitRight(i);\n if (lim <= cur.rx) continue;\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.lx + (int)needW;\n vector cands = {cur.rx + 1, ideal - 1, ideal, ideal + 1, lim};\n int rx2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n rx2 = max(rx2, cur.rx + 1);\n rx2 = min(rx2, lim);\n cand.rx = rx2;\n } else if (side == 0) { // left\n int lim = limitLeft(i);\n if (lim >= cur.lx) continue;\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.rx - (int)needW;\n vector cands = {cur.lx - 1, ideal - 1, ideal, ideal + 1, lim};\n int lx2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n lx2 = min(lx2, cur.lx - 1);\n lx2 = max(lx2, lim);\n lx2 = min(lx2, x[i]);\n cand.lx = lx2;\n } else if (side == 3) { // up\n int lim = limitUp(i);\n if (lim <= cur.ry) continue;\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ly + (int)needH;\n vector cands = {cur.ry + 1, ideal - 1, ideal, ideal + 1, lim};\n int ry2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n ry2 = max(ry2, cur.ry + 1);\n ry2 = min(ry2, lim);\n cand.ry = ry2;\n } else { // down\n int lim = limitDown(i);\n if (lim >= cur.ly) continue;\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ry - (int)needH;\n vector cands = {cur.ly - 1, ideal - 1, ideal, ideal + 1, lim};\n int ly2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n ly2 = min(ly2, cur.ly - 1);\n ly2 = max(ly2, lim);\n ly2 = min(ly2, y[i]);\n cand.ly = ly2;\n }\n } else {\n // shrink (always overlap-safe)\n if (side == 1) { // right shrink\n int minRx = x[i] + 1;\n int maxRx = cur.rx - 1;\n if (minRx > maxRx) continue;\n cand.rx = rng.nextInt(minRx, maxRx);\n } else if (side == 0) { // left shrink\n int minLx = cur.lx + 1;\n int maxLx = x[i];\n if (minLx > maxLx) continue;\n cand.lx = rng.nextInt(minLx, maxLx);\n } else if (side == 3) { // up shrink\n int minRy = y[i] + 1;\n int maxRy = cur.ry - 1;\n if (minRy > maxRy) continue;\n cand.ry = rng.nextInt(minRy, maxRy);\n } else { // down shrink\n int minLy = cur.ly + 1;\n int maxLy = y[i];\n if (minLy > maxLy) continue;\n cand.ly = rng.nextInt(minLy, maxLy);\n }\n }\n if (!inBounds(cand) || !containsPoint(i, cand)) continue;\n // expansions done by limits are safe; shrink safe. Still, for safety, validate occasionally:\n if (rng.nextDouble() < 0.03) {\n if (!validNoOverlapOne(i, cand)) continue;\n }\n } else if (op < 0.86) {\n // shrink-only fit\n Rect shr = fitInsideShrink(i, cur);\n if (shr.lx == cur.lx && shr.ly == cur.ly && shr.rx == cur.rx && shr.ry == cur.ry) continue;\n cand = shr;\n } else {\n // shift (needs overlap check)\n bool horizontal = (rng.nextDouble() < 0.5);\n if (horizontal) {\n int kmin = max(-cur.lx, (x[i] + 1) - cur.rx);\n int kmax = min(W - cur.rx, x[i] - cur.lx);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int lim = 320;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n int k;\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n cand.lx += k; cand.rx += k;\n } else {\n int kmin = max(-cur.ly, (y[i] + 1) - cur.ry);\n int kmax = min(H - cur.ry, y[i] - cur.ly);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int lim = 320;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n int k;\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n cand.ly += k; cand.ry += k;\n }\n if (!validNoOverlapOne(i, cand)) continue;\n }\n\n long long s1 = areaLL(cand);\n double p1 = sat(r[i], s1);\n double delta = p1 - p0;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.nextDouble() < exp(delta / temp)) accept = true;\n\n if (accept) {\n rects[i] = cand;\n p[i] = p1;\n }\n }\n }\n\n void finalTighten(int passes = 2) {\n for (int it = 0; it < passes; it++) {\n bool improved = false;\n for (int i = 0; i < n; i++) {\n Rect cur = rects[i];\n Rect cand = fitInsideShrink(i, cur);\n if (cand.lx == cur.lx && cand.ly == cur.ly && cand.rx == cur.rx && cand.ry == cur.ry) continue;\n double p1 = sat(r[i], areaLL(cand));\n if (p1 > p[i] + 1e-15) {\n rects[i] = cand;\n p[i] = p1;\n improved = true;\n }\n }\n if (!improved) break;\n }\n }\n\n void solve() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n start = clk::now();\n\n cin >> n;\n x.resize(n); y.resize(n); r.resize(n);\n for (int i = 0; i < n; i++) cin >> x[i] >> y[i] >> r[i];\n\n init();\n\n // Robust baseline\n greedyExpand(7);\n\n // SA with new \"steal\" move to fix boxed-in cases\n anneal(4.75);\n\n // After redistribution, expand again a little to fill freed space\n greedyExpand(2);\n\n // Safe overshoot tightening\n finalTighten(2);\n\n for (int i = 0; i < n; i++) {\n const Rect& rc = rects[i];\n cout << rc.lx << ' ' << rc.ly << ' ' << rc.rx << ' ' << rc.ry << \"\\n\";\n }\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nstatic const int N = 50;\nstatic const int V = N * N;\n\nstatic const int di[4] = {-1, 1, 0, 0};\nstatic const int dj[4] = {0, 0, -1, 1};\nstatic const char dc[4] = {'U','D','L','R'};\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n explicit XorShift(uint64_t seed = 0) { x ^= seed + 0x9e3779b97f4a7c15ULL; }\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Path {\n vector moves;\n long long score = 0;\n};\n\nint si, sj;\nint tgrid[N][N];\nint pgrid[N][N];\nint Mtiles = 0;\n\ninline bool inside(int i, int j) { return (unsigned)i < N && (unsigned)j < N; }\ninline int vid(int i, int j) { return i * N + j; }\n\nint tileOf[V];\nint valOf[V];\n\nstruct Neis {\n int to[4];\n int deg = 0;\n};\nNeis nei[V];\n\n// stamping for used tiles\nvector usedStamp;\nint curStamp = 1;\ninline bool isUsedTile(int tile) { return usedStamp[tile] == curStamp; }\ninline void markTile(int tile) { usedStamp[tile] = curStamp; }\n\n// mobility / lookahead helpers\ninline int mobility1(int v, int extra1 = -1) {\n int tv = tileOf[v];\n int cnt = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1) continue;\n if (isUsedTile(tu)) continue;\n cnt++;\n }\n return cnt;\n}\n\ninline int mobility2(int v, int extra1, int extra2) {\n int tv = tileOf[v];\n int cnt = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1 || tu == extra2) continue;\n if (isUsedTile(tu)) continue;\n cnt++;\n }\n return cnt;\n}\n\ninline int bestNextValue(int v, int extra1 = -1) {\n int tv = tileOf[v];\n int best = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1) continue;\n if (isUsedTile(tu)) continue;\n best = max(best, valOf[u]);\n }\n return best;\n}\n\ninline int bestSecondStep(int v, int extraFirstTile) {\n int tv = tileOf[v];\n int best = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extraFirstTile) continue;\n if (isUsedTile(tu)) continue;\n\n int mob = mobility2(u, extraFirstTile, tu);\n int v2 = valOf[u] + 14 * mob;\n best = max(best, v2);\n }\n return best;\n}\n\ninline int dirFromTo(int a, int b) {\n int ai = a / N, aj = a % N;\n int bi = b / N, bj = b % N;\n if (bi == ai - 1 && bj == aj) return 0;\n if (bi == ai + 1 && bj == aj) return 1;\n if (bi == ai && bj == aj - 1) return 2;\n return 3;\n}\n\n// Rollout from (cur vertex), assuming current usedStamp is already set.\n// We will mark/unmark tiles during rollout via rollback list.\nlong long rolloutGain(int startV, XorShift &rng, int depth, double epsRoll) {\n int cur = startV;\n long long gain = 0;\n vector addedTiles;\n addedTiles.reserve(depth + 4);\n\n for (int step = 0; step < depth; step++) {\n int ct = tileOf[cur];\n\n int candV[4];\n double H[4];\n int csz = 0;\n\n const auto &ng = nei[cur];\n for (int k = 0; k < ng.deg; k++) {\n int nxt = ng.to[k];\n int nt = tileOf[nxt];\n if (nt == ct) continue;\n if (isUsedTile(nt)) continue;\n\n int mob = mobility1(nxt, nt);\n // cheap rollout heuristic (fast)\n double h = (double)valOf[nxt] + 18.0 * (double)mob + 0.25 * (double)bestNextValue(nxt, nt);\n candV[csz] = nxt;\n H[csz] = h;\n csz++;\n }\n if (csz == 0) break;\n\n int pick = 0;\n if (rng.nextDouble() < epsRoll) {\n pick = rng.nextInt(0, csz - 1);\n } else {\n for (int i = 1; i < csz; i++) if (H[i] > H[pick]) pick = i;\n }\n\n int nxt = candV[pick];\n int nt = tileOf[nxt];\n if (!isUsedTile(nt)) { // should always be true here\n markTile(nt);\n addedTiles.push_back(nt);\n }\n cur = nxt;\n gain += valOf[cur];\n }\n\n // rollback\n for (int t : addedTiles) usedStamp[t] = 0; // 0 != curStamp always holds\n return gain;\n}\n\nPath buildFromPrefix(const vector& prefix, int cutLen, XorShift &rng, double epsMain) {\n // new stamp\n curStamp++;\n if (curStamp == INT_MAX) {\n fill(usedStamp.begin(), usedStamp.end(), 0);\n curStamp = 1;\n }\n\n int cur = vid(si, sj);\n long long score = valOf[cur];\n markTile(tileOf[cur]);\n\n Path res;\n res.moves.reserve(2600);\n\n // replay prefix safely\n for (int k = 0; k < cutLen; k++) {\n char c = prefix[k];\n int d = (c=='U'?0:(c=='D'?1:(c=='L'?2:3)));\n int ni = (cur / N) + di[d];\n int nj = (cur % N) + dj[d];\n if (!inside(ni,nj)) break;\n int nxt = vid(ni,nj);\n int ct = tileOf[cur], nt = tileOf[nxt];\n if (nt == ct) break;\n if (isUsedTile(nt)) break;\n markTile(nt);\n cur = nxt;\n score += valOf[cur];\n res.moves.push_back(c);\n }\n\n // main heuristic weights (similar to your best-performing version)\n const int Wmob = 24;\n const double Wbest1 = 0.45;\n const double Wbest2 = 0.65;\n const int deadPenalty = 95;\n\n // rollout parameters\n const int rolloutDepth = 10;\n const int rolloutTries = 6;\n const double epsRoll = 0.20;\n const double Wroll = 0.55; // scale rollout gain\n\n while (true) {\n int candV[4];\n double H[4];\n int csz = 0;\n\n int ct = tileOf[cur];\n const auto &ng = nei[cur];\n for (int k = 0; k < ng.deg; k++) {\n int nxt = ng.to[k];\n int nt = tileOf[nxt];\n if (nt == ct) continue;\n if (isUsedTile(nt)) continue;\n\n int mob1 = mobility1(nxt, nt);\n int b1 = bestNextValue(nxt, nt);\n int b2 = bestSecondStep(nxt, nt);\n\n double h = (double)valOf[nxt]\n + (double)Wmob * (double)mob1\n + Wbest1 * (double)b1\n + Wbest2 * (double)b2;\n if (mob1 == 0) h -= deadPenalty;\n\n // risky decisions: add rollout estimate\n if (mob1 <= 2) {\n // temporarily mark nt and compute rollout from nxt\n vector added;\n if (!isUsedTile(nt)) { markTile(nt); added.push_back(nt); }\n\n long long bestG = 0;\n for (int r = 0; r < rolloutTries; r++) {\n bestG = max(bestG, rolloutGain(nxt, rng, rolloutDepth, epsRoll));\n }\n\n // rollback mark(nt)\n for (int t : added) usedStamp[t] = 0;\n\n h += Wroll * (double)bestG;\n }\n\n candV[csz] = nxt;\n H[csz] = h;\n csz++;\n }\n\n if (csz == 0) break;\n\n int pick = 0;\n if (rng.nextDouble() < epsMain) {\n pick = rng.nextInt(0, csz - 1);\n } else {\n for (int i = 1; i < csz; i++) if (H[i] > H[pick]) pick = i;\n }\n\n int nxt = candV[pick];\n int d = dirFromTo(cur, nxt);\n\n markTile(tileOf[nxt]);\n cur = nxt;\n score += valOf[cur];\n res.moves.push_back(dc[d]);\n\n if ((int)res.moves.size() >= 2600) break;\n }\n\n res.score = score;\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> si >> sj;\n int mxT = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n cin >> tgrid[i][j];\n mxT = max(mxT, tgrid[i][j]);\n }\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> pgrid[i][j];\n Mtiles = mxT + 1;\n\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v = vid(i,j);\n tileOf[v] = tgrid[i][j];\n valOf[v] = pgrid[i][j];\n }\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v = vid(i,j);\n nei[v].deg = 0;\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d], nj = j + dj[d];\n if (!inside(ni,nj)) continue;\n nei[v].to[nei[v].deg++] = vid(ni,nj);\n }\n }\n\n usedStamp.assign(Mtiles, 0);\n\n XorShift rng(1234567);\n\n auto start = chrono::high_resolution_clock::now();\n const double TL = 1.95;\n\n Path best;\n best.score = -1;\n\n // Initial multi-start\n for (int it = 0; it < 350; it++) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > TL * 0.35) break;\n\n double eps = 0.25;\n auto cand = buildFromPrefix({}, 0, rng, eps);\n if (cand.score > best.score) best = std::move(cand);\n }\n\n // Local search: tail-biased cut & regrow + small chance of full restart\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > TL) break;\n double progress = min(1.0, elapsed / TL);\n\n if (rng.nextDouble() < 0.06) {\n double eps = 0.28 * (1.0 - progress) + 0.06;\n auto cand = buildFromPrefix({}, 0, rng, eps);\n if (cand.score > best.score) best = std::move(cand);\n continue;\n }\n\n int L = (int)best.moves.size();\n int cutLen = 0;\n if (L > 0) {\n if (rng.nextDouble() < 0.75) {\n int lo = max(0, L - 230);\n cutLen = rng.nextInt(lo, L);\n } else {\n cutLen = rng.nextInt(0, L);\n }\n }\n\n double eps = 0.20 * (1.0 - progress) + 0.03;\n\n Path bestCand;\n bestCand.score = -1;\n\n int TRIES = (progress < 0.6 ? 6 : 4);\n for (int k = 0; k < TRIES; k++) {\n auto cand = buildFromPrefix(best.moves, cutLen, rng, eps);\n if (cand.score > bestCand.score) bestCand = std::move(cand);\n }\n if (bestCand.score > best.score) best = std::move(bestCand);\n }\n\n string out;\n out.reserve(best.moves.size());\n for (char c : best.moves) out.push_back(c);\n cout << out << \"\\n\";\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nstatic constexpr int N = 30;\nstatic constexpr int V = N * N;\n\nstruct EdgeRef {\n bool horiz; // true: h[i][j] between (i,j)-(i,j+1), false: v[i][j] between (i,j)-(i+1,j)\n int i, j;\n};\n\nstatic inline int vid(int i, int j) { return i * N + j; }\nstatic inline pair vpos(int id){ return {id / N, id % N}; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Estimated weights\n static double h[N][N-1];\n static double v[N-1][N];\n static int hc[N][N-1];\n static int vc[N-1][N];\n\n for(int i=0;i unif01(0.0, 1.0);\n\n auto clamp_w = [](double x)->double{\n if (x < 100.0) return 100.0;\n if (x > 10000.0) return 10000.0;\n return x;\n };\n\n auto get_base_w = [&](int i1,int j1,int i2,int j2)->double{\n if (i1 == i2) {\n int i = i1;\n int j = min(j1, j2);\n return h[i][j];\n } else {\n int i = min(i1, i2);\n int j = j1;\n return v[i][j];\n }\n };\n\n auto add_smoothing = [&](double beta){\n // Horizontal smoothing per row\n for(int i=0;i> si >> sj >> ti >> tj)) return 0;\n int s = vid(si, sj), t = vid(ti, tj);\n\n // Exploration schedule (early queries explore more)\n // eps: max relative perturbation amplitude\n double eps = 0.0;\n if (k < 250) {\n double x = 1.0 - (double)k / 250.0; // from 1 -> 0\n eps = 0.30 * x; // up to 30% perturbation early\n }\n\n // Dijkstra\n static double dist[V];\n static int prevv[V];\n static char prevMove[V];\n\n const double INF = 1e100;\n for(int i=0;i;\n priority_queue, greater

> pq;\n dist[s] = 0;\n pq.push({0.0, s});\n\n auto relax = [&](int from, int to, char mv, double w){\n double nd = dist[from] + w;\n if (nd < dist[to]) {\n dist[to] = nd;\n prevv[to] = from;\n prevMove[to] = mv;\n pq.push({nd, to});\n }\n };\n\n while(!pq.empty()){\n auto [d,u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n if (u == t) break;\n auto [i,j] = vpos(u);\n\n // neighbor cost = base_w * (1 + noise) for exploration\n auto perturbed = [&](double base)->double{\n if (eps <= 0.0) return base;\n double r = (unif01(rng) * 2.0 - 1.0) * eps; // [-eps, eps]\n double w = base * (1.0 + r);\n if (w < 1.0) w = 1.0;\n return w;\n };\n\n if (i > 0) {\n double base = v[i-1][j];\n relax(u, vid(i-1,j), 'U', perturbed(base));\n }\n if (i+1 < N) {\n double base = v[i][j];\n relax(u, vid(i+1,j), 'D', perturbed(base));\n }\n if (j > 0) {\n double base = h[i][j-1];\n relax(u, vid(i,j-1), 'L', perturbed(base));\n }\n if (j+1 < N) {\n double base = h[i][j];\n relax(u, vid(i,j+1), 'R', perturbed(base));\n }\n }\n\n // Reconstruct path (also collect edges)\n string path;\n vector used_edges;\n if (prevv[t] == -1 && s != t) {\n // Should never happen on a connected grid; fallback to Manhattan.\n int ci=si, cj=sj;\n while (ci < ti) { path.push_back('D'); ci++; }\n while (ci > ti) { path.push_back('U'); ci--; }\n while (cj < tj) { path.push_back('R'); cj++; }\n while (cj > tj) { path.push_back('L'); cj--; }\n // Build used_edges from this path\n ci=si; cj=sj;\n for(char c: path){\n int ni=ci, nj=cj;\n if (c=='U') ni--;\n if (c=='D') ni++;\n if (c=='L') nj--;\n if (c=='R') nj++;\n if (ci == ni) {\n used_edges.push_back({true, ci, min(cj,nj)});\n } else {\n used_edges.push_back({false, min(ci,ni), cj});\n }\n ci=ni; cj=nj;\n }\n } else {\n // Walk back from t to s\n int cur = t;\n vector rev;\n vector> nodes_rev;\n nodes_rev.push_back(vpos(cur));\n while(cur != s){\n char mv = prevMove[cur];\n rev.push_back(mv);\n cur = prevv[cur];\n nodes_rev.push_back(vpos(cur));\n }\n reverse(rev.begin(), rev.end());\n path.assign(rev.begin(), rev.end());\n\n // nodes_rev is reversed along backtracking; rebuild forward nodes to extract edges\n // nodes_rev currently: [t, ..., s]; reverse:\n reverse(nodes_rev.begin(), nodes_rev.end()); // [s, ..., t]\n for (int idx = 0; idx+1 < (int)nodes_rev.size(); idx++){\n auto [i1,j1] = nodes_rev[idx];\n auto [i2,j2] = nodes_rev[idx+1];\n if (i1 == i2) used_edges.push_back({true, i1, min(j1,j2)});\n else used_edges.push_back({false, min(i1,i2), j1});\n }\n }\n\n cout << path << \"\\n\" << flush;\n\n long long obs;\n cin >> obs;\n\n // Update model\n double pred = 0.0;\n for (auto &e: used_edges){\n pred += e.horiz ? h[e.i][e.j] : v[e.i][e.j];\n }\n if (pred < 1.0) pred = 1.0;\n\n double r = (double)obs / pred;\n // cap extreme ratios (stability)\n r = max(0.2, min(5.0, r));\n double logr = log(r);\n\n // Multiplicative per-edge update with decaying learning rate\n const double base_lr = 0.45; // overall aggressiveness\n for (auto &e: used_edges){\n int cnt;\n double *wptr;\n if (e.horiz) { cnt = ++hc[e.i][e.j]; wptr = &h[e.i][e.j]; }\n else { cnt = ++vc[e.i][e.j]; wptr = &v[e.i][e.j]; }\n\n double lr = base_lr / sqrt((double)cnt + 2.0); // decays\n // w *= exp(lr * log(r))\n double nw = (*wptr) * exp(lr * logr);\n *wptr = clamp_w(nw);\n }\n\n // Periodic smoothing to exploit row/column base structure\n if ((k+1) % 25 == 0) {\n double beta = 0.10;\n if (k >= 300) beta = 0.06;\n if (k >= 700) beta = 0.04;\n add_smoothing(beta);\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20;\nstatic const int LMIN = 2;\nstatic const int LMAX = 12;\nstatic const int ALPHA = 9; // A-H + '.'\n\nstruct XorShift64 {\n uint64_t x;\n explicit XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n inline uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n inline double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline uint8_t ch2code(char ch) {\n if (ch == '.') return 8;\n return (uint8_t)(ch - 'A'); // A..H -> 0..7\n}\nstatic inline char code2ch(uint8_t c) {\n if (c == 8) return '.';\n return (char)('A' + c);\n}\n\nusing u128 = unsigned __int128;\n\nstruct LineHash {\n array dig{};\n array pref{}; // exact base-9 prefix in u128\n const array* pow9 = nullptr;\n\n void rebuild_pref() {\n pref[0] = 0;\n for (int i = 0; i < 2 * N; i++) {\n pref[i + 1] = pref[i] * (u128)ALPHA + (u128)dig[i];\n }\n }\n inline uint64_t substr_val_exact(int start, int len) const {\n // exact integer for base-9 length<=12, guaranteed < 9^12 < 2^64\n u128 v = pref[start + len] - pref[start] * (*pow9)[len];\n return (uint64_t)v;\n }\n};\n\nstruct Delta {\n int dBase = 0;\n int dLen = 0;\n int dBonus = 0;\n};\n\nstruct Solver {\n int M;\n vector inputS;\n\n // unique strings\n int U;\n vector weight; // multiplicity in input\n vector slen; // length\n vector> sdig; // digits A..H\n unordered_map key2id;\n\n array pow9{};\n\n array, N> grid{};\n array rows, cols;\n\n vector>> affected; // for each pos: list of (start,len) substrings that include it\n\n vector occ;\n long long baseSat = 0; // sum weight*(occ>0)\n long long lenSat = 0; // sum len*(occ>0)\n long long occBonus = 0; // sum min(occ,2)\n\n XorShift64 rng;\n\n Solver(int M_, vector s_)\n : M(M_), inputS(std::move(s_)),\n rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count()) {\n\n pow9[0] = 1;\n for (int i = 1; i <= LMAX; i++) pow9[i] = pow9[i-1] * (u128)ALPHA;\n\n for (int i = 0; i < N; i++) { rows[i].pow9 = &pow9; cols[i].pow9 = &pow9; }\n\n auto encode_key_exact = [&](const string& t) -> uint64_t {\n // exact base-9 integer for len<=12 fits in uint64\n uint64_t v = 0;\n for (char ch : t) v = v * (uint64_t)ALPHA + (uint64_t)ch2code(ch);\n return v * 16ull + (uint64_t)t.size();\n };\n\n key2id.reserve((size_t)M * 2);\n for (int i = 0; i < M; i++) {\n uint64_t key = encode_key_exact(inputS[i]);\n auto it = key2id.find(key);\n if (it == key2id.end()) {\n int id = (int)weight.size();\n key2id.emplace(key, id);\n weight.push_back(1);\n slen.push_back((int)inputS[i].size());\n vector d;\n d.reserve(inputS[i].size());\n for (char ch : inputS[i]) d.push_back(ch2code(ch));\n sdig.push_back(std::move(d));\n } else {\n weight[it->second]++;\n }\n }\n U = (int)weight.size();\n occ.assign(U, 0);\n\n affected.assign(N, {});\n for (int pos = 0; pos < N; pos++) {\n vector> v;\n v.reserve(77);\n for (int len = LMIN; len <= LMAX; len++) {\n for (int t = 0; t < len; t++) {\n int start = pos - t;\n start %= N;\n if (start < 0) start += N;\n v.emplace_back(start, len);\n }\n }\n affected[pos] = move(v);\n }\n }\n\n inline uint64_t make_key(uint64_t val, int len) const {\n return val * 16ull + (uint64_t)len;\n }\n inline int bonus_of(int x) const { return x >= 2 ? 2 : x; }\n\n inline void rebuild_all_lines_from_grid() {\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n rows[r].dig[c] = grid[r][c];\n rows[r].dig[c + N] = grid[r][c];\n }\n rows[r].rebuild_pref();\n }\n for (int c = 0; c < N; c++) {\n for (int r = 0; r < N; r++) {\n cols[c].dig[r] = grid[r][c];\n cols[c].dig[r + N] = grid[r][c];\n }\n cols[c].rebuild_pref();\n }\n }\n\n void recount_occ_slow() {\n fill(occ.begin(), occ.end(), 0);\n baseSat = lenSat = occBonus = 0;\n\n auto add_key = [&](uint64_t key) {\n auto it = key2id.find(key);\n if (it == key2id.end()) return;\n int id = it->second;\n if (occ[id] == 0) {\n baseSat += weight[id];\n lenSat += slen[id];\n }\n occ[id]++;\n };\n\n for (int r = 0; r < N; r++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = rows[r].substr_val_exact(start, len);\n add_key(make_key(v, len));\n }\n }\n }\n for (int c = 0; c < N; c++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = cols[c].substr_val_exact(start, len);\n add_key(make_key(v, len));\n }\n }\n }\n for (int id = 0; id < U; id++) occBonus += bonus_of(occ[id]);\n }\n\n inline void adjust_occ(int id, int delta, Delta &D) {\n int before = occ[id];\n int after = before + delta;\n occ[id] = after;\n\n if (before == 0 && after > 0) {\n baseSat += weight[id]; D.dBase += weight[id];\n lenSat += slen[id]; D.dLen += slen[id];\n } else if (before > 0 && after == 0) {\n baseSat -= weight[id]; D.dBase -= weight[id];\n lenSat -= slen[id]; D.dLen -= slen[id];\n }\n\n int b0 = bonus_of(before), b1 = bonus_of(after);\n occBonus += (b1 - b0);\n D.dBonus += (b1 - b0);\n }\n\n inline void update_key_change(uint64_t oldKey, uint64_t newKey, Delta &D) {\n if (oldKey == newKey) return;\n auto itOld = key2id.find(oldKey);\n if (itOld != key2id.end()) adjust_occ(itOld->second, -1, D);\n auto itNew = key2id.find(newKey);\n if (itNew != key2id.end()) adjust_occ(itNew->second, +1, D);\n }\n\n // apply single cell change, updates row+col affected substrings incrementally\n Delta doChange(int r, int c, uint8_t newv) {\n uint8_t oldv = grid[r][c];\n if (oldv == newv) return {};\n\n Delta D;\n\n // Row r substrings that include position c\n const auto &affRow = affected[c];\n array oldKeysRow;\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first, len = affRow[i].second;\n oldKeysRow[i] = make_key(rows[r].substr_val_exact(start, len), len);\n }\n\n rows[r].dig[c] = newv;\n rows[r].dig[c + N] = newv;\n rows[r].rebuild_pref();\n\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first, len = affRow[i].second;\n uint64_t newKey = make_key(rows[r].substr_val_exact(start, len), len);\n update_key_change(oldKeysRow[i], newKey, D);\n }\n\n // Column c substrings that include position r\n const auto &affCol = affected[r];\n array oldKeysCol;\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first, len = affCol[i].second;\n oldKeysCol[i] = make_key(cols[c].substr_val_exact(start, len), len);\n }\n\n cols[c].dig[r] = newv;\n cols[c].dig[r + N] = newv;\n cols[c].rebuild_pref();\n\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first, len = affCol[i].second;\n uint64_t newKey = make_key(cols[c].substr_val_exact(start, len), len);\n update_key_change(oldKeysCol[i], newKey, D);\n }\n\n grid[r][c] = newv;\n return D;\n }\n\n inline double evalDeltaF(const Delta &D, double lambda, double beta) const {\n return (double)D.dBase + lambda * (double)D.dLen + beta * (double)D.dBonus;\n }\n\n int pick_unsatisfied_id() {\n for (int t = 0; t < 60; t++) {\n int id = rng.next_int(U);\n if (occ[id] == 0) return id;\n }\n for (int id = 0; id < U; id++) if (occ[id] == 0) return id;\n return -1;\n }\n\n struct ChangeRec { int r, c; uint8_t oldv; };\n\n pair> apply_embed_move(int id, int orient, int idx, int start) {\n Delta total;\n vector rec;\n rec.reserve(slen[id]);\n\n for (int t = 0; t < slen[id]; t++) {\n int r = (orient == 0) ? idx : (start + t) % N;\n int c = (orient == 0) ? (start + t) % N : idx;\n uint8_t nv = sdig[id][t];\n uint8_t ov = grid[r][c];\n if (ov == nv) continue;\n rec.push_back({r, c, ov});\n Delta d = doChange(r, c, nv);\n total.dBase += d.dBase;\n total.dLen += d.dLen;\n total.dBonus+= d.dBonus;\n }\n return {total, rec};\n }\n\n void revert_changes(const vector &rec) {\n for (int i = (int)rec.size() - 1; i >= 0; i--) {\n doChange(rec[i].r, rec[i].c, rec[i].oldv);\n }\n }\n\n // Find best placement by minimizing mismatch count against current grid\n tuple best_embed_placement(int id) {\n int bestMis = 1e9;\n int bestOrient = 0, bestIdx = 0, bestStart = 0;\n\n int L = slen[id];\n for (int orient = 0; orient < 2; orient++) {\n for (int idx = 0; idx < N; idx++) {\n for (int start = 0; start < N; start++) {\n int mis = 0;\n for (int t = 0; t < L; t++) {\n int r = (orient == 0) ? idx : (start + t) % N;\n int c = (orient == 0) ? (start + t) % N : idx;\n mis += (grid[r][c] != sdig[id][t]);\n if (mis >= bestMis) break;\n }\n if (mis < bestMis) {\n bestMis = mis;\n bestOrient = orient;\n bestIdx = idx;\n bestStart = start;\n if (bestMis == 0) return {bestMis, bestOrient, bestIdx, bestStart};\n }\n }\n }\n }\n return {bestMis, bestOrient, bestIdx, bestStart};\n }\n\n pair> apply_shift_move(int orient, int idx, int k) {\n array newvals;\n if (orient == 0) {\n for (int c = 0; c < N; c++) newvals[(c + k) % N] = grid[idx][c];\n } else {\n for (int r = 0; r < N; r++) newvals[(r + k) % N] = grid[r][idx];\n }\n\n Delta total;\n vector rec;\n rec.reserve(N);\n\n for (int t = 0; t < N; t++) {\n int r = (orient == 0) ? idx : t;\n int c = (orient == 0) ? t : idx;\n uint8_t nv = newvals[t];\n uint8_t ov = grid[r][c];\n if (ov == nv) continue;\n rec.push_back({r, c, ov});\n Delta d = doChange(r, c, nv);\n total.dBase += d.dBase;\n total.dLen += d.dLen;\n total.dBonus+= d.dBonus;\n }\n return {total, rec};\n }\n\n array, N> run_sa(double duration_sec, long long &outBestBase) {\n // random init A-H\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) grid[r][c] = (uint8_t)rng.next_int(8);\n\n rebuild_all_lines_from_grid();\n recount_occ_slow();\n\n auto bestGrid = grid;\n long long bestBase = baseSat;\n long long bestLen = lenSat;\n long long bestBonus= occBonus;\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n };\n\n const double Tstart = 6.0;\n const double Tend = 0.18;\n\n const double lambda0 = 0.08; // reduced: avoid sacrificing baseSat\n const double beta = 0.01;\n\n while (true) {\n double e = elapsed();\n if (e >= duration_sec) break;\n double p = e / duration_sec;\n\n double T = Tstart * pow(Tend / Tstart, p);\n double lambda = lambda0 * (1.0 - p);\n\n // decreasing disruptive move probabilities\n double pShift = 0.04 * (1.0 - p) + 0.005;\n double pEmbed = 0.25 * (1.0 - p) + 0.03;\n\n double rm = rng.next_double();\n\n if (rm < pShift) {\n int orient = rng.next_int(2);\n int idx = rng.next_int(N);\n int k = 1 + rng.next_int(N - 1);\n\n auto [D, rec] = apply_shift_move(orient, idx, k);\n double dF = evalDeltaF(D, lambda, beta);\n\n bool accept = false;\n if (dF >= 0) accept = true;\n else if (rng.next_double() < exp(dF / T)) accept = true;\n\n if (!accept) revert_changes(rec);\n }\n else if (rm < pShift + pEmbed) {\n int id = pick_unsatisfied_id();\n if (id == -1) continue;\n\n auto [mis, orient, idx, start] = best_embed_placement(id);\n auto [D, rec] = apply_embed_move(id, orient, idx, start);\n double dF = evalDeltaF(D, lambda, beta);\n\n bool accept = false;\n if (dF >= 0) accept = true;\n else if (rng.next_double() < exp(dF / T)) accept = true;\n\n if (!accept) revert_changes(rec);\n }\n else {\n int r = rng.next_int(N);\n int c = rng.next_int(N);\n uint8_t oldv = grid[r][c];\n uint8_t newv = (uint8_t)rng.next_int(8);\n if (newv == oldv) continue;\n\n Delta D = doChange(r, c, newv);\n double dF = evalDeltaF(D, lambda, beta);\n\n bool accept = false;\n if (dF >= 0) accept = true;\n else if (rng.next_double() < exp(dF / T)) accept = true;\n\n if (!accept) doChange(r, c, oldv);\n }\n\n if (baseSat > bestBase ||\n (baseSat == bestBase && (lenSat > bestLen ||\n (lenSat == bestLen && occBonus > bestBonus)))) {\n bestBase = baseSat;\n bestLen = lenSat;\n bestBonus = occBonus;\n bestGrid = grid;\n }\n }\n\n outBestBase = bestBase;\n return bestGrid;\n }\n\n void dot_removal(double time_limit_sec, chrono::high_resolution_clock::time_point globalStart) {\n auto elapsed_global = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - globalStart).count();\n };\n if (baseSat != M) return;\n\n vector cells(N*N);\n iota(cells.begin(), cells.end(), 0);\n\n for (int rd = 0; rd < 10; rd++) {\n if (elapsed_global() >= time_limit_sec) break;\n for (int i = (int)cells.size() - 1; i > 0; i--) {\n int j = rng.next_int(i + 1);\n swap(cells[i], cells[j]);\n }\n for (int idx : cells) {\n if (elapsed_global() >= time_limit_sec) break;\n int r = idx / N, c = idx % N;\n uint8_t oldv = grid[r][c];\n if (oldv == 8) continue;\n doChange(r, c, 8);\n if (baseSat != M) doChange(r, c, oldv);\n }\n }\n }\n\n array, N> solve() {\n auto globalStart = chrono::high_resolution_clock::now();\n const double TL = 2.95;\n\n // Use a couple restarts (longer per run now that evaluation is correct)\n const int RESTARTS = 2;\n const double SA_TIME = 2.70;\n const double per = SA_TIME / RESTARTS;\n\n array, N> bestGrid{};\n long long bestBase = -1;\n\n for (int t = 0; t < RESTARTS; t++) {\n long long localBest = 0;\n auto g = run_sa(per, localBest);\n if (localBest > bestBase) {\n bestBase = localBest;\n bestGrid = g;\n if (bestBase == M) break;\n }\n double eg = chrono::duration(chrono::high_resolution_clock::now() - globalStart).count();\n if (eg >= TL - 0.20) break;\n }\n\n // restore best and attempt dot bonus\n grid = bestGrid;\n rebuild_all_lines_from_grid();\n recount_occ_slow();\n\n dot_removal(TL, globalStart);\n return grid;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, M;\n cin >> Nin >> M;\n vector s(M);\n for (int i = 0; i < M; i++) cin >> s[i];\n\n Solver solver(M, std::move(s));\n auto ans = solver.solve();\n\n for (int r = 0; r < N; r++) {\n string line;\n line.reserve(N);\n for (int c = 0; c < N; c++) line.push_back(code2ch(ans[r][c]));\n cout << line << \"\\n\";\n }\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstatic const long long INFLL = (1LL<<60);\nstatic const int INF = 1e9;\n\nstruct HopcroftKarp {\n int nL, nR;\n vector> adj;\n vector dist;\n vector pairU, pairV;\n\n HopcroftKarp(int nL=0, int nR=0) { init(nL, nR); }\n void init(int _nL, int _nR) {\n nL=_nL; nR=_nR;\n adj.assign(nL, {});\n dist.assign(nL, 0);\n pairU.assign(nL, -1);\n pairV.assign(nR, -1);\n }\n void add_edge(int u, int v){ adj[u].push_back(v); }\n\n bool bfs() {\n queue q;\n for(int u=0; u, vector> min_vertex_cover() {\n vector visL(nL,0), visR(nR,0);\n queue q;\n for(int u=0; u coverL(nL,0), coverR(nR,0);\n for(int u=0; u dist; // int is enough here\n vector prev;\n vector prevDir;\n};\n\nstruct TargetsInfo {\n vector cells;\n vector needRow, needCol; // required segments to activate (after excluding start segs)\n};\n\nstruct Solver {\n int N, si, sj;\n vector g;\n int startId;\n vector cellCost;\n\n vector rowSeg, colSeg;\n int R=0, C=0;\n vector> rowCells, colCells;\n vector> adjV;\n vector> adjCell;\n\n inline int id(int i,int j) const { return i*N+j; }\n inline int ri(int v) const { return v/N; }\n inline int rj(int v) const { return v%N; }\n inline bool isRoad(int v) const { return g[ri(v)][rj(v)]!='#'; }\n\n DijkstraResult dijkstra_full(int src) const {\n int V=N*N;\n DijkstraResult res;\n res.dist.assign(V, INF);\n res.prev.assign(V, -1);\n res.prevDir.assign(V, 0);\n\n priority_queue, vector>, greater>> pq;\n res.dist[src]=0;\n pq.push({0,src});\n\n static const int di[4] = {-1,1,0,0};\n static const int dj[4] = {0,0,-1,1};\n static const char mv[4] = {'U','D','L','R'};\n\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=res.dist[u]) continue;\n int ui=ri(u), uj=rj(u);\n for(int k=0;k<4;k++){\n int vi=ui+di[k], vj=uj+dj[k];\n if(vi<0||vi>=N||vj<0||vj>=N) continue;\n int v=id(vi,vj);\n if(!isRoad(v)) continue;\n int nd = d + cellCost[v];\n if(nd < res.dist[v]){\n res.dist[v]=nd;\n res.prev[v]=u;\n res.prevDir[v]=mv[k];\n pq.push({nd,v});\n }\n }\n }\n return res;\n }\n\n string reconstruct_path(int src, int dst, const vector& prev, const vector& prevDir) const {\n if(src==dst) return \"\";\n string rev;\n int cur=dst;\n while(cur!=src){\n int p=prev[cur];\n if(p==-1) return \"\";\n rev.push_back(prevDir[cur]);\n cur=p;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n }\n\n void build_segments() {\n int V=N*N;\n rowSeg.assign(V, -1);\n colSeg.assign(V, -1);\n\n R=0;\n for(int i=0;i& distStart) {\n HopcroftKarp hk(R, C);\n hk.adj = adjV;\n hk.pairU.assign(R, -1);\n hk.pairV.assign(C, -1);\n hk.dist.assign(R, 0);\n hk.max_matching();\n auto [coverL, coverR] = hk.min_vertex_cover();\n\n // start already activates its row/col segment\n int sRow=rowSeg[startId], sCol=colSeg[startId];\n if(sRow>=0) coverL[sRow]=0;\n if(sCol>=0) coverR[sCol]=0;\n\n vector reqL, reqR;\n vector mapL(R, -1), mapR(C, -1);\n for(int u=0; u> edgeCell(nL);\n hk2.adj.assign(nL, {});\n edgeCell.assign(nL, {});\n for(int i=0;i needL = coverL;\n vector needR = coverR;\n vector doneL(R,0), doneR(C,0);\n\n vector picked(N*N,0);\n vector targets;\n\n auto pick_cell = [&](int cell){\n if(cell<0) return;\n if(!picked[cell]){\n picked[cell]=1;\n targets.push_back(cell);\n }\n };\n\n // matched edges\n for(int i=0;iint{\n int best=-1;\n long long bestKey=INFLL;\n for(int cell: rowCells[u]){\n int v=colSeg[cell];\n long long key = (long long)distStart[cell] + cellCost[cell];\n if(needR[v] && !doneR[v]) key -= 1000000;\n if(key < bestKey){ bestKey=key; best=cell; }\n }\n return best;\n };\n auto best_cell_for_col = [&](int v)->int{\n int best=-1;\n long long bestKey=INFLL;\n for(int cell: colCells[v]){\n int u=rowSeg[cell];\n long long key = (long long)distStart[cell] + cellCost[cell];\n if(needL[u] && !doneL[u]) key -= 1000000;\n if(key < bestKey){ bestKey=key; best=cell; }\n }\n return best;\n };\n\n for(int u=0;u cntL(R,0), cntR(C,0);\n for(int cell: targets){\n int u=rowSeg[cell], v=colSeg[cell];\n if(needL[u]) cntL[u]++;\n if(needR[v]) cntR[v]++;\n }\n vector order=targets;\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n shuffle(order.begin(), order.end(), rng);\n\n vector removed(N*N,0);\n for(int cell: order){\n int u=rowSeg[cell], v=colSeg[cell];\n bool okU = (!needL[u]) || (cntL[u] >= 2);\n bool okV = (!needR[v]) || (cntR[v] >= 2);\n if(okU && okV){\n removed[cell]=1;\n if(needL[u]) cntL[u]--;\n if(needR[v]) cntR[v]--;\n }\n }\n vector pruned;\n for(int cell: targets) if(!removed[cell]) pruned.push_back(cell);\n\n TargetsInfo info;\n info.cells = std::move(pruned);\n info.needRow = std::move(needL);\n info.needCol = std::move(needR);\n return info;\n }\n\n // compute dist matrix between nodes and also store:\n // - distAll[s][cell] for incoming computations to arbitrary candidate cells\n // - prev arrays for path reconstruction\n void compute_all_for_nodes(const vector& nodes,\n vector>& distM,\n vector>& distAll,\n vector>& prevM,\n vector>& prevDirM) const {\n int M=(int)nodes.size();\n int V=N*N;\n distM.assign(M, vector(M, INF));\n distAll.assign(M, vector(V, INF));\n prevM.assign(M, vector(V, -1));\n prevDirM.assign(M, vector(V, 0));\n\n for(int s=0;s> build_W(const vector>& distM, const vector& nodes) const {\n int M=(int)nodes.size();\n vector> W(M, vector(M, 0));\n for(int i=0;i& tour, const vector>& W) const {\n int M=(int)tour.size();\n long long s=0;\n for(int i=0;i> build_candidates(const vector>& W, int K) const {\n int M=(int)W.size();\n vector> cand(M);\n for(int i=0;i> tmp;\n tmp.reserve(M-1);\n for(int j=0;j& tour, vector& pos,\n const vector>& W,\n const vector>& cand) const {\n int M=(int)tour.size();\n for(int i=1;ijj) swap(ii,jj);\n if(jj-ii<1) continue;\n int x = tour[ii-1];\n int y = tour[ii];\n int u = tour[jj];\n int v = tour[(jj+1)%M];\n long long delta = (long long)W[x][u] + W[y][v] - W[x][y] - W[u][v];\n if(delta < 0){\n reverse(tour.begin()+ii, tour.begin()+jj+1);\n for(int k=ii;k<=jj;k++) pos[tour[k]]=k;\n return true;\n }\n }\n }\n return false;\n }\n\n void double_bridge(vector& tour, vector& pos, mt19937& rng) const {\n int M=(int)tour.size();\n if(M < 10) return;\n uniform_int_distribution dist(1, M-1);\n int a=dist(rng), b=dist(rng), c=dist(rng), d=dist(rng);\n vector cuts = {a,b,c,d};\n sort(cuts.begin(), cuts.end());\n a=cuts[0]; b=cuts[1]; c=cuts[2]; d=cuts[3];\n if(a==b||b==c||c==d) return;\n if(a<2 || b-a<2 || c-b<2 || d-c<2) return;\n\n vector nt;\n nt.reserve(M);\n nt.push_back(tour[0]);\n auto app = [&](int l,int r){ for(int i=l;i<=r;i++) nt.push_back(tour[i]); };\n // [1..a-1], [a..b-1], [b..c-1], [c..d-1], [d..M-1]\n app(1, a-1);\n app(b, c-1);\n app(a, b-1);\n app(c, d-1);\n app(d, M-1);\n tour.swap(nt);\n for(int i=0;i build_initial_cycle_cheapest_insertion(const vector>& W, mt19937& rng) const {\n int M=(int)W.size();\n vector tour;\n tour.reserve(M);\n tour.push_back(0);\n vector rem;\n for(int i=1;i optimize_cycle_ILS(vector tour, const vector>& W, double timeLimitSec) const {\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n auto t0=chrono::high_resolution_clock::now();\n auto elapsed=[&](){ return chrono::duration(chrono::high_resolution_clock::now()-t0).count(); };\n\n int M=(int)tour.size();\n vector pos(M, -1);\n for(int i=0;i bestTour = tour;\n\n int it=0;\n while(elapsed() < timeLimitSec){\n it++;\n auto curTour = tour;\n auto curPos = pos;\n\n double_bridge(curTour, curPos, rng);\n\n while(elapsed() < timeLimitSec && apply_first_2opt(curTour, curPos, W, cand)) {}\n\n long long cst = cycle_cost(curTour, W);\n if(cst < bestC){\n bestC = cst;\n bestTour = curTour;\n tour = curTour;\n pos = curPos;\n } else {\n if((it%3)==0){\n tour = curTour;\n pos = curPos;\n }\n }\n }\n return bestTour;\n }\n\n // Relocate activation cells along their row/col segment without breaking coverage.\n void relocate_targets(vector& nodes,\n vector& tour,\n vector>& distM,\n vector>& distAll,\n vector>& prevM,\n vector>& prevDirM,\n const vector& needRow,\n const vector& needCol,\n double timeLimitSec) const {\n int M=(int)nodes.size();\n int V=N*N;\n if(M <= 2) return;\n\n // used cell to avoid duplicates (helps tour)\n vector usedCell(V, 0);\n for(int i=0;i cntRseg(R,0), cntCseg(C,0);\n for(int i=1;i posInTour(M, -1);\n for(int i=0;i pickNode(1, M-1);\n\n auto t0=chrono::high_resolution_clock::now();\n auto elapsed=[&](){ return chrono::duration(chrono::high_resolution_clock::now()-t0).count(); };\n\n while(elapsed() < timeLimitSec){\n int x = pickNode(rng); // node index (not start)\n int px = posInTour[x];\n int p = tour[(px-1+M)%M];\n int n = tour[(px+1)%M];\n\n int curCell = nodes[x];\n int curRS = rowSeg[curCell];\n int curCS = colSeg[curCell];\n\n // candidate search in same row segment (keep row satisfied), and same col segment\n auto scoreHeu = [&](int candCell)->long long{\n int pi=ri(nodes[p]), pj=rj(nodes[p]);\n int ni=ri(nodes[n]), nj=rj(nodes[n]);\n int ci=ri(candCell), cj=rj(candCell);\n long long h = llabs(ci-pi)+llabs(cj-pj) + llabs(ci-ni)+llabs(cj-nj);\n h = h*10 + cellCost[candCell]*3;\n return h;\n };\n\n int bestCand = -1;\n long long bestHeu = scoreHeu(curCell);\n\n // try row-segment move\n {\n // if we change column segment, ensure we won't drop a required column segment to 0\n bool colLocked = needCol[curCS] && (cntCseg[curCS]==1);\n for(int candCell : rowCells[curRS]){\n if(candCell==curCell) continue;\n if(usedCell[candCell]) continue;\n int candCS = colSeg[candCell];\n if(colLocked && candCS!=curCS) continue;\n long long h = scoreHeu(candCell);\n if(h < bestHeu){\n bestHeu = h;\n bestCand = candCell;\n }\n }\n }\n // try col-segment move\n {\n bool rowLocked = needRow[curRS] && (cntRseg[curRS]==1);\n for(int candCell : colCells[curCS]){\n if(candCell==curCell) continue;\n if(usedCell[candCell]) continue;\n int candRS = rowSeg[candCell];\n if(rowLocked && candRS!=curRS) continue;\n long long h = scoreHeu(candCell);\n if(h < bestHeu){\n bestHeu = h;\n bestCand = candCell;\n }\n }\n }\n\n if(bestCand==-1) continue;\n\n // Exact evaluation needs Dijkstra from candidate (for outgoing x->n etc.)\n auto candRes = dijkstra_full(bestCand);\n\n // directed tour contribution difference (p->x and x->n)\n int oldCost = distM[p][x] + distM[x][n];\n int newCost = distAll[p][bestCand] + candRes.dist[nodes[n]];\n if(newCost >= INF/2) continue;\n\n if(newCost >= oldCost) continue; // only accept improvements (safer & faster)\n\n // Coverage constraints for changing both endpoints at once\n int newRS = rowSeg[bestCand];\n int newCS = colSeg[bestCand];\n // check required segment drop to 0\n if(newRS != curRS){\n if(needRow[curRS] && cntRseg[curRS]==1) continue;\n }\n if(newCS != curCS){\n if(needCol[curCS] && cntCseg[curCS]==1) continue;\n }\n\n // accept\n usedCell[curCell]=0;\n usedCell[bestCand]=1;\n\n // update counts\n if(needRow[curRS]) cntRseg[curRS]--;\n if(needCol[curCS]) cntCseg[curCS]--;\n if(needRow[newRS]) cntRseg[newRS]++;\n if(needCol[newCS]) cntCseg[newCS]++;\n\n nodes[x] = bestCand;\n\n // update distAll/prev for x\n distAll[x] = std::move(candRes.dist);\n prevM[x] = std::move(candRes.prev);\n prevDirM[x] = std::move(candRes.prevDir);\n\n // update distM row/col for x\n for(int j=0;j> N >> si >> sj;\n g.resize(N);\n for(int i=0;i> g[i];\n\n startId = id(si,sj);\n cellCost.assign(N*N, 0);\n for(int i=0;i(chrono::high_resolution_clock::now()-globalStart).count();\n };\n\n build_segments();\n\n // dist-from-start for target selection\n auto startRes = dijkstra_full(startId);\n vector distStart = startRes.dist;\n\n auto tinfo = choose_targets(distStart);\n\n // nodes: start + unique targets\n vector nodes;\n nodes.reserve(1 + tinfo.cells.size());\n nodes.push_back(startId);\n {\n vector used(N*N, 0);\n used[startId]=1;\n for(int c: tinfo.cells){\n if(!used[c]){\n used[c]=1;\n nodes.push_back(c);\n }\n }\n }\n int M=(int)nodes.size();\n\n vector> distM, distAll, prevM;\n vector> prevDirM;\n compute_all_for_nodes(nodes, distM, distAll, prevM, prevDirM);\n\n auto W = build_W(distM, nodes);\n\n // initial multi-start\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n vector bestTour;\n long long bestC = INFLL;\n int trials = (M<=80? 8 : (M<=140? 6 : 4));\n for(int t=0;t\nusing namespace std;\n\nstruct FastRand {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int mod) { return (int)(next_u64() % (uint64_t)mod); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n // Box-Muller for standard normal\n double next_normal() {\n double u1 = max(1e-12, next_double());\n double u2 = next_double();\n return sqrt(-2.0 * log(u1)) * cos(2.0 * M_PI * u2);\n }\n};\n\n// Hungarian algorithm for rectangular min-cost assignment with m>=n.\n// cost is n x m.\nstatic vector hungarian_min_cost(const vector>& cost) {\n int n = (int)cost.size();\n int m = (int)cost[0].size();\n const long long INF = (1LL<<62);\n\n vector u(n+1, 0), v(m+1, 0);\n vector p(m+1, 0), way(m+1, 0);\n\n for (int i = 1; i <= n; i++) {\n p[0] = i;\n int j0 = 0;\n vector minv(m+1, INF);\n vector used(m+1, false);\n do {\n used[j0] = true;\n int i0 = p[j0];\n long long delta = INF;\n int j1 = 0;\n for (int j = 1; j <= m; j++) if (!used[j]) {\n long long cur = cost[i0-1][j-1] - u[i0] - v[j];\n if (cur < minv[j]) minv[j] = cur, way[j] = j0;\n if (minv[j] < delta) delta = minv[j], j1 = j;\n }\n for (int j = 0; j <= m; j++) {\n if (used[j]) u[p[j]] += delta, v[j] -= delta;\n else minv[j] -= delta;\n }\n j0 = j1;\n } while (p[j0] != 0);\n\n // augmenting\n do {\n int j1 = way[j0];\n p[j0] = p[j1];\n j0 = j1;\n } while (j0);\n }\n\n // assignment: for each row i, find column j with p[j]=i\n vector ans(n, -1);\n for (int j = 1; j <= m; j++) {\n if (p[j] >= 1 && p[j] <= n) ans[p[j]-1] = j-1;\n }\n return ans;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector> d(N, vector(K));\n vector sumD(N, 0);\n vector meanD(K, 0.0);\n\n for (int i = 0; i < N; i++) {\n long long s = 0;\n for (int k = 0; k < K; k++) {\n cin >> d[i][k];\n s += d[i][k];\n meanD[k] += d[i][k];\n }\n sumD[i] = (int)s;\n }\n for (int k = 0; k < K; k++) meanD[k] /= max(1, N);\n\n vector> out(N);\n vector indeg0(N, 0);\n for (int e = 0; e < R; e++) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg0[v]++;\n }\n\n // critical path length (in tasks)\n vector crit(N, 1);\n for (int i = N - 1; i >= 0; i--) {\n int best = 1;\n for (int v : out[i]) best = max(best, 1 + crit[v]);\n crit[i] = best;\n }\n\n vector outdeg(N);\n for (int i = 0; i < N; i++) outdeg[i] = (int)out[i].size();\n\n double avgSumD = 0.0;\n for (int i = 0; i < N; i++) avgSumD += sumD[i];\n avgSumD /= max(1, N);\n\n vector indeg = indeg0;\n vector task_state(N, 0); // 0:not started, 1:running, 2:done\n\n vector member_task(M, -1);\n vector start_day(M, -1);\n vector done_cnt(M, 0);\n\n FastRand rng;\n\n // K-dim skill estimate\n vector> s_est(M, vector(K, 0.0));\n for (int j = 0; j < M; j++) {\n // Random direction ~ |N(0,1)|, magnitude ~ 40 (mid of 20..60)\n vector v(K);\n double norm2 = 0.0;\n for (int k = 0; k < K; k++) {\n double x = fabs(rng.next_normal());\n v[k] = x;\n norm2 += x * x;\n }\n double mag = 40.0;\n double scale = (norm2 > 0) ? (mag / sqrt(norm2)) : 0.0;\n for (int k = 0; k < K; k++) {\n // small prior blend toward meanD to avoid pathological starts\n double initv = v[k] * scale;\n s_est[j][k] = 0.7 * initv + 0.3 * (meanD[k] * 2.0);\n if (s_est[j][k] < 0) s_est[j][k] = 0;\n }\n }\n\n auto w_pred = [&](int i, int j) -> double {\n double w = 0.0;\n const auto& sj = s_est[j];\n for (int k = 0; k < K; k++) {\n double diff = (double)d[i][k] - sj[k];\n if (diff > 0) w += diff;\n }\n return w;\n };\n\n auto t_pred = [&](int i, int j) -> double {\n double w = w_pred(i, j);\n if (w <= 0.0) return 1.0;\n // small bias improves robustness against r in [-3,3]\n return max(1.0, w + 0.5);\n };\n\n auto update_member = [&](int j, int i, int t_obs) {\n // target w roughly equals observed days for t>1, else 0\n double target_w = (t_obs <= 1) ? 0.0 : (double)t_obs;\n\n double w = w_pred(i, j);\n double err = w - target_w; // want err -> 0\n\n // Learning rate decays with number of observations\n double lr = 0.12 / sqrt(1.0 + done_cnt[j]); // tuned small & stable\n\n // Gradient: f(s)=sum max(0, d-s), df/ds_k = -1 if active else 0\n // Loss = (f-target)^2 => grad = 2*(f-target)*df/ds\n // Update s_k -= lr * grad => s_k += 2*lr*err for active dims.\n double delta = 2.0 * lr * err;\n\n // cap to avoid huge jumps on noisy tasks\n delta = max(-8.0, min(8.0, delta));\n\n auto &sj = s_est[j];\n for (int k = 0; k < K; k++) {\n if ((double)d[i][k] > sj[k]) {\n sj[k] += delta;\n if (sj[k] < 0) sj[k] = 0;\n }\n }\n\n // mild regularization toward a prior to prevent collapse\n for (int k = 0; k < K; k++) {\n double prior = meanD[k] * 2.0;\n sj[k] = 0.995 * sj[k] + 0.005 * prior;\n if (sj[k] < 0) sj[k] = 0;\n }\n\n done_cnt[j]++;\n };\n\n int day = 0;\n while (true) {\n day++;\n\n vector free_members;\n free_members.reserve(M);\n for (int j = 0; j < M; j++) if (member_task[j] == -1) free_members.push_back(j);\n\n vector avail;\n avail.reserve(N);\n for (int i = 0; i < N; i++) if (task_state[i] == 0 && indeg[i] == 0) avail.push_back(i);\n\n // Prepare candidate tasks:\n // (1) top by criticality\n sort(avail.begin(), avail.end(), [&](int a, int b) {\n if (crit[a] != crit[b]) return crit[a] > crit[b];\n if (outdeg[a] != outdeg[b]) return outdeg[a] > outdeg[b];\n if (sumD[a] != sumD[b]) return sumD[a] > sumD[b];\n return a < b;\n });\n\n unordered_set candset;\n candset.reserve(800);\n int TOP = min(160, (int)avail.size());\n for (int idx = 0; idx < TOP; idx++) candset.insert(avail[idx]);\n\n // (2) for each free member, add tasks predicted fast (and somewhat critical)\n int PER = 24;\n for (int j : free_members) {\n vector> best;\n best.reserve(avail.size());\n for (int i : avail) {\n double tp = t_pred(i, j);\n // smaller is better; incorporate criticality as a tie-breaker\n double key = tp - 0.15 * (double)crit[i] - 0.01 * (double)outdeg[i];\n best.push_back({key, i});\n }\n if ((int)best.size() > PER) {\n nth_element(best.begin(), best.begin() + PER, best.end());\n best.resize(PER);\n }\n for (auto &p : best) candset.insert(p.second);\n }\n\n vector cands;\n cands.reserve(candset.size());\n for (int i : candset) cands.push_back(i);\n\n // stable order for columns\n sort(cands.begin(), cands.end(), [&](int a, int b) {\n if (crit[a] != crit[b]) return crit[a] > crit[b];\n if (outdeg[a] != outdeg[b]) return outdeg[a] > outdeg[b];\n if (sumD[a] != sumD[b]) return sumD[a] > sumD[b];\n return a < b;\n });\n\n vector> assigns; // (member, task) 0-based\n assigns.reserve(free_members.size());\n\n if (!free_members.empty() && !cands.empty()) {\n int F = (int)free_members.size();\n int C = (int)cands.size();\n int W = max(F, C); // columns after padding\n const long long BIG = (long long)4e12;\n\n vector> cost(F, vector(W, BIG));\n\n // Build costs: minimize -score\n // score = A*crit + B*outdeg - D*t_pred + small difficulty term\n for (int r = 0; r < F; r++) {\n int j = free_members[r];\n bool explore = (done_cnt[j] < 4);\n for (int c = 0; c < C; c++) {\n int i = cands[c];\n double tp = t_pred(i, j);\n\n double sc = 120.0 * (double)crit[i]\n + 6.0 * (double)outdeg[i]\n - 1.0 * tp\n + 0.002 * (double)sumD[i];\n\n if (explore) {\n // Early stage: prefer moderate tasks to learn faster and avoid huge stalls\n sc -= 0.03 * fabs((double)sumD[i] - avgSumD);\n }\n\n long long ssc = (long long)llround(sc * 1000.0);\n cost[r][c] = -ssc;\n }\n }\n\n // If C < F, remaining columns are dummy with BIG cost (forces assignment only if no tasks)\n // If C > F, extra columns exist but that's fine.\n\n vector assign_col = hungarian_min_cost(cost);\n\n vector used_task(N, 0);\n for (int r = 0; r < F; r++) {\n int c = assign_col[r];\n if (c < 0 || c >= C) continue;\n int i = cands[c];\n if (task_state[i] != 0) continue;\n if (used_task[i]) continue; // safety\n int j = free_members[r];\n\n used_task[i] = 1;\n task_state[i] = 1;\n member_task[j] = i;\n start_day[j] = day;\n assigns.push_back({j, i});\n }\n }\n\n // Output assignments for today\n cout << assigns.size();\n for (auto [j, i] : assigns) cout << ' ' << (j + 1) << ' ' << (i + 1);\n cout << \"\\n\" << flush;\n\n // Read completion info\n int nfin;\n if (!(cin >> nfin)) return 0;\n if (nfin == -1) return 0;\n\n for (int z = 0; z < nfin; z++) {\n int a; cin >> a;\n int j = a - 1;\n int i = member_task[j];\n if (i < 0) continue; // safety\n\n int t_obs = day - start_day[j] + 1;\n\n // finish task\n member_task[j] = -1;\n start_day[j] = -1;\n task_state[i] = 2;\n\n // unlock successors\n for (int v : out[i]) indeg[v]--;\n\n // update skill estimate\n update_member(j, i, t_obs);\n }\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point { int x, y; };\nstatic inline int manhattan(const Point& a, const Point& b){\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\nstatic const Point OFFICE{400, 400};\n\nstruct Order {\n int id; // 1..1000\n Point P, D;\n int intra;\n int proxy;\n};\n\nstruct XorShift64 {\n uint64_t x;\n explicit XorShift64(uint64_t seed=88172645463325252ull) : x(seed) {}\n uint64_t next() {\n uint64_t y = x;\n y ^= y << 7;\n y ^= y >> 9;\n return x = y;\n }\n int next_int(int lo, int hi){ // inclusive\n return lo + (int)(next() % (uint64_t)(hi - lo + 1));\n }\n double next_double(){ // [0,1)\n return (next() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Solver {\n vector orders; // 1000\n vector pool; // candidate global indices\n vector used; // 1000\n XorShift64 rng;\n\n Solver(): used(1000, 0) {\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n rng = XorShift64(seed);\n }\n\n // node encoding: (g<<1)|t where g in [0,999], t=0 pickup, t=1 delivery\n inline Point node_point(int node) const {\n int g = node >> 1;\n int t = node & 1;\n return (t ? orders[g].D : orders[g].P);\n }\n\n int route_cost(const vector& ev) const {\n int cost = 0;\n Point cur = OFFICE;\n for (int node : ev) {\n Point nxt = node_point(node);\n cost += manhattan(cur, nxt);\n cur = nxt;\n }\n cost += manhattan(cur, OFFICE);\n return cost;\n }\n\n // Build base = ev without nodes A and B, also its point list.\n void remove_pair_with_pts(const vector& ev, int A, int B,\n vector& base, vector& bp) const {\n base.clear(); bp.clear();\n base.reserve(ev.size() - 2);\n bp.reserve(ev.size() - 2);\n for (int node : ev) if (node != A && node != B) {\n base.push_back(node);\n bp.push_back(node_point(node));\n }\n }\n\n struct BestIns { int p, q, delta; };\n\n BestIns best_pair_insertion(const vector& base, const vector& bp,\n const Point& pA, const Point& pB) const {\n // Insert A at position p in [0..Lb], then B at q in [p+1..Lb+1]\n int Lb = (int)base.size();\n BestIns best{0, 1, INT_MAX};\n\n auto distPt = [&](const Point& u, const Point& v){ return manhattan(u, v); };\n\n for (int p = 0; p <= Lb; p++) {\n Point prevP = (p == 0) ? OFFICE : bp[p - 1];\n Point nextP = (p == Lb) ? OFFICE : bp[p];\n int deltaA = distPt(prevP, pA) + distPt(pA, nextP) - distPt(prevP, nextP);\n\n for (int q = p + 1; q <= Lb + 1; q++) {\n Point prevB = (q == p + 1) ? pA : bp[q - 2];\n Point nextB = (q == Lb + 1) ? OFFICE : bp[q - 1];\n\n int deltaB = distPt(prevB, pB) + distPt(pB, nextB) - distPt(prevB, nextB);\n int total = deltaA + deltaB;\n if (total < best.delta) best = {p, q, total};\n }\n }\n return best;\n }\n\n vector build_with_pair_insertion(const vector& base, int A, int B, int p, int q) const {\n vector out = base;\n out.insert(out.begin() + p, A);\n out.insert(out.begin() + q, B); // q is index after A insertion\n return out;\n }\n\n // Best-reinsert an existing order g inside ev; guaranteed precedence-feasible.\n bool best_reinsert_apply(vector& ev, int g, int& curCost) const {\n int A = (g << 1), B = (g << 1) | 1;\n\n vector base;\n vector bp;\n remove_pair_with_pts(ev, A, B, base, bp);\n\n int baseCost = route_cost(base);\n Point pA = orders[g].P;\n Point pB = orders[g].D;\n\n auto best = best_pair_insertion(base, bp, pA, pB);\n int newCost = baseCost + best.delta;\n\n if (newCost <= curCost) {\n ev = build_with_pair_insertion(base, A, B, best.p, best.q);\n bool improved = (newCost < curCost);\n curCost = newCost;\n return improved;\n }\n return false;\n }\n\n void local_optimize_pairs(vector& ev, const vector& chosen, int& curCost, int passes) const {\n for (int it = 0; it < passes; it++) {\n bool improved = false;\n for (int g : chosen) improved |= best_reinsert_apply(ev, g, curCost);\n if (!improved) break;\n }\n }\n\n int pick_unused_candidate() {\n // sample from pool first; fallback to all\n for (int t = 0; t < 50; t++) {\n int g = pool[rng.next_int(0, (int)pool.size() - 1)];\n if (!used[g]) return g;\n }\n for (int t = 0; t < 500; t++) {\n int g = rng.next_int(0, 999);\n if (!used[g]) return g;\n }\n return -1;\n }\n\n vector greedy_init_chosen(int m=50) {\n vector chosen;\n chosen.reserve(m);\n fill(used.begin(), used.end(), 0);\n\n Point cur = OFFICE;\n const double alpha = 0.25;\n\n for (int t = 0; t < m; t++) {\n int best = -1;\n double bestScore = 1e100;\n for (int g : pool) if (!used[g]) {\n const auto& o = orders[g];\n double s = manhattan(cur, o.P) + o.intra + alpha * manhattan(o.D, OFFICE);\n if (s < bestScore) { bestScore = s; best = g; }\n }\n if (best == -1) break;\n used[best] = 1;\n chosen.push_back(best);\n cur = orders[best].D;\n }\n for (int g = 0; (int)chosen.size() < m; g++) if (!used[g]) {\n used[g] = 1;\n chosen.push_back(g);\n }\n return chosen;\n }\n\n vector init_events_consecutive(const vector& chosen) const {\n vector ev;\n ev.reserve(2 * chosen.size());\n for (int g : chosen) {\n ev.push_back(g << 1);\n ev.push_back((g << 1) | 1);\n }\n return ev;\n }\n\n // Replacement move: remove old g_old pair; insert g_new pair at best positions.\n // Returns constructed ev2 and cost2.\n bool try_replace_best(const vector& ev, int curCost, int g_old, int g_new,\n vector& ev2, int& cost2) const {\n int Aold = (g_old << 1), Bold = (g_old << 1) | 1;\n int Anew = (g_new << 1), Bnew = (g_new << 1) | 1;\n\n vector base;\n vector bp;\n remove_pair_with_pts(ev, Aold, Bold, base, bp);\n\n int baseCost = route_cost(base);\n auto best = best_pair_insertion(base, bp, orders[g_new].P, orders[g_new].D);\n cost2 = baseCost + best.delta;\n ev2 = build_with_pair_insertion(base, Anew, Bnew, best.p, best.q);\n (void)curCost;\n return true;\n }\n\n void solve() {\n // Build pool by proxy\n vector idxs(1000);\n iota(idxs.begin(), idxs.end(), 0);\n sort(idxs.begin(), idxs.end(), [&](int i, int j){\n return orders[i].proxy < orders[j].proxy;\n });\n int K = 950; // widen: improves subset quality\n pool.assign(idxs.begin(), idxs.begin() + K);\n\n const int m = 50;\n\n // Multi-start initialization (cheap but helps avoid weak starts)\n vector bestChosenInit, bestEvInit;\n int bestInitCost = INT_MAX;\n for (int s = 0; s < 6; s++) {\n // slightly vary alpha by permuting pool prefix (random shuffle small prefix)\n vector poolBak = pool;\n int pref = 200;\n for (int i = 0; i < pref; i++) swap(pool[i], pool[rng.next_int(0, pref-1)]);\n\n vector chosen = greedy_init_chosen(m);\n vector ev = init_events_consecutive(chosen);\n int c = route_cost(ev);\n local_optimize_pairs(ev, chosen, c, 4);\n\n if (c < bestInitCost) {\n bestInitCost = c;\n bestChosenInit = chosen;\n bestEvInit = ev;\n }\n\n pool = poolBak;\n }\n\n vector chosen = bestChosenInit;\n vector ev = bestEvInit;\n fill(used.begin(), used.end(), 0);\n for (int g : chosen) used[g] = 1;\n int curCost = bestInitCost;\n\n int bestCost = curCost;\n vector bestChosen = chosen;\n vector bestEv = ev;\n\n auto start = chrono::steady_clock::now();\n const double TL = 1.95;\n\n int iter = 0;\n while (true) {\n double elapsed = chrono::duration(chrono::steady_clock::now() - start).count();\n if (elapsed >= TL) break;\n double frac = elapsed / TL;\n\n double T0 = 1800.0, T1 = 12.0;\n double temp = T0 * pow(T1 / T0, frac);\n\n double r = rng.next_double();\n\n vector chosen2 = chosen;\n vector ev2;\n int cost2 = curCost;\n\n bool accepted = false;\n\n if (r < 0.82) {\n // subset replace (main driver)\n int posOld = rng.next_int(0, m-1);\n int g_old = chosen2[posOld];\n int g_new = pick_unused_candidate();\n if (g_new == -1) { iter++; continue; }\n\n try_replace_best(ev, curCost, g_old, g_new, ev2, cost2);\n int delta = cost2 - curCost;\n\n if (delta <= 0) accepted = true;\n else {\n double prob = exp(-delta / temp);\n if (rng.next_double() < prob) accepted = true;\n }\n\n if (accepted) {\n // update structures\n chosen2[posOld] = g_new;\n used[g_old] = 0;\n used[g_new] = 1;\n\n // quick re-opt\n local_optimize_pairs(ev2, chosen2, cost2, 2);\n\n chosen.swap(chosen2);\n ev.swap(ev2);\n curCost = cost2;\n }\n } else {\n // route perturbation: random feasible pair reinsertion (exploration)\n int g = chosen[rng.next_int(0, m-1)];\n int A = (g << 1), B = (g << 1) | 1;\n\n vector base;\n vector bp;\n remove_pair_with_pts(ev, A, B, base, bp);\n int Lb = (int)base.size();\n\n int p = rng.next_int(0, Lb);\n int q = rng.next_int(p+1, Lb+1);\n ev2 = build_with_pair_insertion(base, A, B, p, q);\n cost2 = route_cost(ev2);\n int delta = cost2 - curCost;\n\n if (delta <= 0) accepted = true;\n else {\n double prob = exp(-delta / temp);\n if (rng.next_double() < prob) accepted = true;\n }\n\n if (accepted) {\n // polish a bit\n local_optimize_pairs(ev2, chosen, cost2, 1);\n ev.swap(ev2);\n curCost = cost2;\n }\n }\n\n if (accepted && curCost < bestCost) {\n bestCost = curCost;\n bestChosen = chosen;\n bestEv = ev;\n }\n\n iter++;\n }\n\n // Final deterministic improvement: try a few strong replacements (hill-climb)\n // (helps squeeze last bit and reduce \"bad case\" risk)\n {\n chosen = bestChosen;\n ev = bestEv;\n fill(used.begin(), used.end(), 0);\n for (int g : chosen) used[g] = 1;\n curCost = route_cost(ev);\n local_optimize_pairs(ev, chosen, curCost, 4);\n\n for (int step = 0; step < 120; step++) {\n int g_new = pick_unused_candidate();\n if (g_new == -1) break;\n\n // test a few random removals, take best improving\n int bestPos = -1;\n vector bestEv2;\n int bestC2 = curCost;\n\n for (int t = 0; t < 6; t++) {\n int posOld = rng.next_int(0, m-1);\n int g_old = chosen[posOld];\n\n vector candEv;\n int candC;\n try_replace_best(ev, curCost, g_old, g_new, candEv, candC);\n if (candC < bestC2) {\n bestC2 = candC;\n bestPos = posOld;\n bestEv2 = std::move(candEv);\n }\n }\n if (bestPos != -1) {\n int g_old = chosen[bestPos];\n used[g_old] = 0;\n used[g_new] = 1;\n chosen[bestPos] = g_new;\n ev.swap(bestEv2);\n curCost = bestC2;\n local_optimize_pairs(ev, chosen, curCost, 2);\n }\n }\n\n if (curCost < bestCost) {\n bestCost = curCost;\n bestChosen = chosen;\n bestEv = ev;\n }\n }\n\n // Output\n cout << m;\n for (int g : bestChosen) cout << ' ' << (g + 1);\n cout << \"\\n\";\n\n vector route;\n route.reserve(2*m + 2);\n route.push_back(OFFICE);\n for (int node : bestEv) route.push_back(node_point(node));\n route.push_back(OFFICE);\n\n cout << (int)route.size();\n for (auto &p : route) cout << ' ' << p.x << ' ' << p.y;\n cout << \"\\n\";\n }\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Solver solver;\n solver.orders.resize(1000);\n for (int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n solver.orders[i].id = i + 1;\n solver.orders[i].P = {a,b};\n solver.orders[i].D = {c,d};\n solver.orders[i].intra = manhattan(solver.orders[i].P, solver.orders[i].D);\n solver.orders[i].proxy = manhattan(OFFICE, solver.orders[i].P)\n + solver.orders[i].intra\n + manhattan(solver.orders[i].D, OFFICE);\n }\n\n solver.solve();\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct DSU {\n int n;\n int comps;\n vector p, sz;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n comps = n;\n p.resize(n);\n sz.assign(n, 1);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){\n while(p[a]!=a){\n p[a] = p[p[a]];\n a = p[a];\n }\n return a;\n }\n bool same(int a,int b){ return find(a)==find(b); }\n bool merge(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 comps--;\n return true;\n }\n};\n\nstatic constexpr int N = 400;\nstatic constexpr int M = 1995;\nstatic constexpr int INF = 1e9;\n\nstruct Ctx {\n vector root; // chosen.find(v)\n vector cid; // cid[root] -> 0..k-1\n int k;\n};\n\nstatic Ctx build_ctx(DSU &chosen){\n Ctx ctx;\n ctx.root.resize(N);\n for(int i=0;i &u, const vector &v){\n if(ctx.k <= 1) return true;\n DSU dsu2(ctx.k);\n for(int j=i+1;j depth;\n vector> up;\n vector> mx; // max edge weight to ancestor\n vector outCnt; // number of remaining outgoing (cross-component) edges\n vector minOutW; // minimum expected outgoing weight (2*d)\n};\n\nstatic FutureInfo build_future_info(\n int i, const Ctx &ctx,\n const vector &u, const vector &v, const vector &d, int maxD)\n{\n FutureInfo info;\n info.k = ctx.k;\n info.ok = true;\n\n info.outCnt.assign(ctx.k, 0);\n info.minOutW.assign(ctx.k, INF);\n\n if(ctx.k <= 1){\n info.LOG = 1;\n info.depth.assign(ctx.k, 0);\n info.up.assign(1, vector(ctx.k, -1));\n info.mx.assign(1, vector(ctx.k, 0));\n return info;\n }\n\n // bucket by d for fast \"sort\"\n vector>> bucket(maxD + 1);\n\n for(int j=i+1;j maxD) dj = maxD;\n bucket[dj].push_back({a,b});\n\n // scarcity stats\n int w = 2 * dj;\n info.outCnt[a]++; info.outCnt[b]++;\n info.minOutW[a] = min(info.minOutW[a], w);\n info.minOutW[b] = min(info.minOutW[b], w);\n }\n\n // Build MST on future edges using expected weights w=2*d\n vector>> adj(ctx.k);\n DSU mst(ctx.k);\n for(int dist=1; dist<=maxD && mst.comps>1; dist++){\n int w = 2 * dist;\n for(auto [a,b] : bucket[dist]){\n if(mst.merge(a,b)){\n adj[a].push_back({b,w});\n adj[b].push_back({a,w});\n if(mst.comps == 1) break;\n }\n }\n }\n if(mst.comps != 1){\n info.ok = false;\n info.LOG = 1;\n info.depth.assign(ctx.k, 0);\n info.up.assign(1, vector(ctx.k, -1));\n info.mx.assign(1, vector(ctx.k, 0));\n return info;\n }\n\n int LOG=1;\n while((1<(ctx.k, -1));\n info.mx.assign(LOG, vector(ctx.k, 0));\n\n // Root at 0\n stack st;\n info.depth[0] = 0;\n st.push(0);\n while(!st.empty()){\n int x = st.top(); st.pop();\n for(auto [to,w] : adj[x]){\n if(info.depth[to] != -1) continue;\n info.depth[to] = info.depth[x] + 1;\n info.up[0][to] = x;\n info.mx[0][to] = w;\n st.push(to);\n }\n }\n\n for(int t=1;t=0; t--){\n if(info.up[t][a] != info.up[t][b]){\n res = max(res, info.mx[t][a]);\n res = max(res, info.mx[t][b]);\n a = info.up[t][a];\n b = info.up[t][b];\n }\n }\n res = max(res, info.mx[0][a]);\n res = max(res, info.mx[0][b]);\n return res;\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> x[i] >> y[i];\n vector u(M), v(M);\n for(int i=0;i> u[i] >> v[i];\n\n vector d(M);\n int maxD = 1;\n for(int i=0;i> li;\n\n int ans = 0;\n if(chosen.same(u[i], v[i])){\n ans = 0;\n } else {\n Ctx ctx = build_ctx(chosen);\n bool ok_reject = feasible_if_reject(i, ctx, u, v);\n if(!ok_reject){\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n int a = ctx.cid[ ctx.root[u[i]] ];\n int b = ctx.cid[ ctx.root[v[i]] ];\n\n FutureInfo finfo = build_future_info(i, ctx, u, v, d, maxD);\n\n long double ratio = (long double)li / (long double)d[i];\n long double rem_edges = (long double)(M - i);\n long double urgency = (ctx.k <= 1 ? 0.0L : (long double)(ctx.k - 1) / rem_edges);\n\n // Scarcity: if either side has very few future outgoing edges, be less picky.\n int outA = (a>=0 && a=0 && b=0 && a=0 && b(1.060L, max(0.970L, theta));\n if((long double)li <= theta * (long double)maxW) take = true;\n }\n\n // Conservative fallback acceptance (mainly to avoid being too stingy late)\n if(!take){\n long double allow = 1.26L + 1.70L * urgency;\n if(scarce <= 2) allow += 0.12L;\n if(allow > 2.05L) allow = 2.05L;\n if(ratio <= allow) take = true;\n }\n\n if(take){\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n ans = 0;\n }\n }\n }\n\n cout << ans << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nstatic const int H = 30, W = 30;\nstatic const int TURNS = 300;\n\nstruct Pet { int x, y, t; };\nstruct Human { int x, y; };\n\nstatic inline bool in_grid(int x, int y){ return 1<=x && x<=H && 1<=y && y<=W; }\n\nint dx4[4] = {-1, +1, 0, 0};\nint dy4[4] = {0, 0, -1, +1};\nchar dirMove[4] = {'U','D','L','R'};\nchar dirWall[4] = {'u','d','l','r'};\n\nstruct BFSResult {\n int dist[H+1][W+1];\n char first[H+1][W+1];\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N; cin >> N;\n vector pets(N);\n for(int i=0;i> pets[i].x >> pets[i].y >> pets[i].t;\n int M; cin >> M;\n vector humans(M);\n for(int i=0;i> humans[i].x >> humans[i].y;\n\n static bool wall[H+1][W+1];\n for(int x=1;x<=H;x++) for(int y=1;y<=W;y++) wall[x][y]=false;\n\n // ----- rectangle selection -----\n auto petsInside = [&](int x1,int y1,int S)->int{\n int x2=x1+S-1, y2=y1+S-1;\n int c=0;\n for(auto &p: pets) if(x1<=p.x && p.x<=x2 && y1<=p.y && p.y<=y2) c++;\n return c;\n };\n auto humanTravelCost = [&](int x1,int y1,int S)->long long{\n int x2=x1+S-1, y2=y1+S-1;\n long long sum=0;\n for(auto &h: humans){\n int tx=min(max(h.x,x1),x2);\n int ty=min(max(h.y,y1),y2);\n sum += llabs(h.x-tx)+llabs(h.y-ty);\n }\n return sum;\n };\n auto distPetToRect = [&](const Pet& p, int x1,int y1,int S)->int{\n int x2=x1+S-1, y2=y1+S-1;\n int dx=0, dy=0;\n if(p.x < x1) dx = x1 - p.x;\n else if(p.x > x2) dx = p.x - x2;\n if(p.y < y1) dy = y1 - p.y;\n else if(p.y > y2) dy = p.y - y2;\n return dx + dy;\n };\n auto nearPetsCount = [&](int x1,int y1,int S, int th)->int{\n int c=0;\n for(auto &p: pets){\n int d = distPetToRect(p,x1,y1,S);\n if(d<=th) c++;\n }\n return c;\n };\n\n int best_x1=2, best_y1=2, bestS=16;\n long long bestScore = LLONG_MIN;\n\n // Require perimeter to be within grid: x1>=2,y1>=2,x2<=29,y2<=29\n // Strongly prefer 0 pets inside.\n for(int pass=0; pass<2; pass++){\n // pass=0: only 0 pets inside, pass=1: allow up to 1\n int allowInside = (pass==0 ? 0 : 1);\n for(int S=26; S>=14; S--){\n for(int x1=2; x1+S-1<=29; x1++){\n for(int y1=2; y1+S-1<=29; y1++){\n int pin = petsInside(x1,y1,S);\n if(pin>allowInside) continue;\n\n long long area = 1LL*S*S;\n long long hcost = humanTravelCost(x1,y1,S);\n int near2 = nearPetsCount(x1,y1,S,2); // pets close => block perimeter placement\n int near1 = nearPetsCount(x1,y1,S,1);\n\n long long score = area*1000LL\n - (long long)pin*2000000000LL\n - (long long)near1*300000LL\n - (long long)near2*120000LL\n - hcost*25LL;\n\n if(score > bestScore){\n bestScore=score;\n best_x1=x1; best_y1=y1; bestS=S;\n }\n }\n }\n }\n if(bestScore!=LLONG_MIN && petsInside(best_x1,best_y1,bestS)<=allowInside) {\n if(pass==0 && petsInside(best_x1,best_y1,bestS)==0) break;\n }\n }\n\n int x1=best_x1, y1=best_y1;\n int x2=x1+bestS-1, y2=y1+bestS-1;\n\n auto inInterior = [&](int x,int y)->bool{ return x1<=x && x<=x2 && y1<=y && y<=y2; };\n\n // perimeter cells (one step outside rectangle)\n vector> perimeter;\n {\n set> s;\n for(int y=y1-1;y<=y2+1;y++) s.insert({x1-1,y});\n for(int y=y1-1;y<=y2+1;y++) s.insert({x2+1,y});\n for(int x=x1;x<=x2;x++) s.insert({x,y1-1});\n for(int x=x1;x<=x2;x++) s.insert({x,y2+1});\n perimeter.assign(s.begin(), s.end());\n }\n auto isPerimeterCell = [&](int x,int y)->bool{\n bool onTop = (x==x1-1 && (y1-1)<=y && y<=(y2+1));\n bool onBot = (x==x2+1 && (y1-1)<=y && y<=(y2+1));\n bool onL = (y==y1-1 && x1<=x && x<=x2);\n bool onR = (y==y2+1 && x1<=x && x<=x2);\n return onTop||onBot||onL||onR;\n };\n\n auto bfsFrom = [&](int sx,int sy)->BFSResult{\n BFSResult res;\n const int INF = 1e9;\n for(int x=1;x<=H;x++) for(int y=1;y<=W;y++){\n res.dist[x][y]=INF;\n res.first[x][y]='?';\n }\n deque> q;\n res.dist[sx][sy]=0;\n res.first[sx][sy]='.';\n q.push_back({sx,sy});\n while(!q.empty()){\n auto [x,y]=q.front(); q.pop_front();\n for(int k=0;k<4;k++){\n int nx=x+dx4[k], ny=y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) continue;\n if(res.dist[nx][ny]!=INF) continue;\n res.dist[nx][ny]=res.dist[x][y]+1;\n res.first[nx][ny] = (x==sx && y==sy) ? dirMove[k] : res.first[x][y];\n q.push_back({nx,ny});\n }\n }\n return res;\n };\n\n auto placeableWall = [&](int tx,int ty,\n const vector>& petCnt,\n const vector>& humanCnt)->bool{\n if(!in_grid(tx,ty)) return false;\n if(humanCnt[tx][ty]>0) return false;\n if(petCnt[tx][ty]>0) return false;\n for(int k=0;k<4;k++){\n int ax=tx+dx4[k], ay=ty+dy4[k];\n if(in_grid(ax,ay) && petCnt[ax][ay]>0) return false;\n }\n return true;\n };\n\n // Internal cut planning\n enum Phase { BUILD_PERIM=0, CUT=1, DONE=2 };\n Phase phase = BUILD_PERIM;\n\n // Cut representation\n bool cutVertical=false;\n int cutPos=-1; // y for vertical, x for horizontal\n bool keepRightOrDown=true; // if vertical: keep right side; if horizontal: keep down side\n vector> cutCells; // all cells of cut wall\n\n auto cutComplete = [&]()->bool{\n for(auto &c: cutCells) if(!wall[c.first][c.second]) return false;\n return true;\n };\n\n auto allHumansInSafeSide = [&]()->bool{\n if(phase!=CUT) return true;\n for(auto &h: humans){\n if(!inInterior(h.x,h.y)) return false; // should be enclosed by then\n if(cutVertical){\n if(keepRightOrDown){\n if(h.y <= cutPos) return false; // cut wall at cutPos is blocked; safe side y>=cutPos+1\n }else{\n if(h.y >= cutPos) return false; // safe side y<=cutPos-1\n }\n }else{\n if(keepRightOrDown){\n if(h.x <= cutPos) return false; // safe side x>=cutPos+1\n }else{\n if(h.x >= cutPos) return false; // safe side x<=cutPos-1\n }\n }\n }\n return true;\n };\n\n auto safeTargetCell = [&]()->pair{\n if(phase!=CUT){\n // center of rectangle\n return {(x1+x2)/2, (y1+y2)/2};\n }\n int tx, ty;\n if(cutVertical){\n if(keepRightOrDown){\n tx=(x1+x2)/2;\n ty=(cutPos+1 + y2)/2;\n }else{\n tx=(x1+x2)/2;\n ty=(y1 + cutPos-1)/2;\n }\n }else{\n if(keepRightOrDown){\n tx=(cutPos+1 + x2)/2;\n ty=(y1+y2)/2;\n }else{\n tx=(x1 + cutPos-1)/2;\n ty=(y1+y2)/2;\n }\n }\n tx = min(max(tx,1),30);\n ty = min(max(ty,1),30);\n return {tx,ty};\n };\n\n // Attempt to find a buffered cut separating all current inside pets to one side.\n // We require buffer >= BUF so that while building the cut, pets are unlikely to reach adjacency.\n auto tryPlanCut = [&](const vector& petsNow)->bool{\n vector insidePets;\n insidePets.reserve(N);\n for(auto &p: petsNow) if(inInterior(p.x,p.y)) insidePets.push_back(p);\n if(insidePets.empty()) return false;\n\n int minPX=31,maxPX=0,minPY=31,maxPY=0;\n for(auto &p: insidePets){\n minPX=min(minPX,p.x); maxPX=max(maxPX,p.x);\n minPY=min(minPY,p.y); maxPY=max(maxPY,p.y);\n }\n\n // Buffer. Rabbits move 3, dogs/cats can also move 2; pick 4 for safety.\n const int BUF = 4;\n\n long long bestArea=-1;\n bool bestVert=false;\n int bestPos=-1;\n bool bestKeep=true;\n\n // vertical cuts: wall at y=pos, pos in (y1..y2) excluding border so both sides have space\n for(int pos=y1+1; pos<=y2-1; pos++){\n // keep right side (pets on left with buffer): maxPY <= pos-BUF\n if(maxPY <= pos - BUF){\n long long area = 1LL*(x2-x1+1) * (y2-(pos+1)+1);\n if(area > bestArea){\n bestArea=area; bestVert=true; bestPos=pos; bestKeep=true;\n }\n }\n // keep left side (pets on right with buffer): minPY >= pos+BUF\n if(minPY >= pos + BUF){\n long long area = 1LL*(x2-x1+1) * ((pos-1)-y1+1);\n if(area > bestArea){\n bestArea=area; bestVert=true; bestPos=pos; bestKeep=false;\n }\n }\n }\n // horizontal cuts: wall at x=pos\n for(int pos=x1+1; pos<=x2-1; pos++){\n // keep down side (pets up with buffer): maxPX <= pos-BUF\n if(maxPX <= pos - BUF){\n long long area = 1LL*(y2-y1+1) * (x2-(pos+1)+1);\n if(area > bestArea){\n bestArea=area; bestVert=false; bestPos=pos; bestKeep=true;\n }\n }\n // keep up side (pets down with buffer): minPX >= pos+BUF\n if(minPX >= pos + BUF){\n long long area = 1LL*(y2-y1+1) * ((pos-1)-x1+1);\n if(area > bestArea){\n bestArea=area; bestVert=false; bestPos=pos; bestKeep=false;\n }\n }\n }\n\n if(bestArea < 0) return false;\n\n cutVertical = bestVert;\n cutPos = bestPos;\n keepRightOrDown = bestKeep;\n cutCells.clear();\n if(cutVertical){\n for(int x=x1; x<=x2; x++) cutCells.push_back({x, cutPos});\n }else{\n for(int y=y1; y<=y2; y++) cutCells.push_back({cutPos, y});\n }\n return true;\n };\n\n for(int turn=0; turn> petCnt(H+1, vector(W+1,0));\n vector> humanCnt(H+1, vector(W+1,0));\n for(auto &p: pets) petCnt[p.x][p.y]++;\n for(auto &h: humans) humanCnt[h.x][h.y]++;\n\n bool perimComplete=true;\n for(auto &c: perimeter){\n if(!wall[c.first][c.second]) { perimComplete=false; break; }\n }\n\n int trappedPets=0;\n for(auto &p: pets) if(inInterior(p.x,p.y)) trappedPets++;\n\n // Phase transitions\n if(phase==BUILD_PERIM){\n if(perimComplete){\n if(trappedPets==0) phase=DONE;\n else{\n // attempt immediate cut planning; otherwise remain BUILD_PERIM but do nothing special\n if(tryPlanCut(pets)) phase=CUT;\n else {\n // Still better to be sealed than catastrophic; remain sealed and try cut later.\n phase=CUT; // enter CUT mode but may have no cut yet -> we'll replan\n cutCells.clear();\n cutPos=-1;\n }\n }\n }\n } else if(phase==CUT){\n if(perimComplete && trappedPets==0) phase=DONE;\n else{\n // if no active cut, retry planning when possible\n if(cutPos==-1 || cutCells.empty()){\n tryPlanCut(pets);\n } else {\n if(cutComplete() && allHumansInSafeSide()) phase=DONE;\n }\n }\n }\n\n // BFS per human\n vector bfsRes(M);\n for(int i=0;i act(M, '.');\n set> plannedWalls;\n set> plannedMoveDest;\n\n auto planWallAt = [&](int i, int wx, int wy)->bool{\n int x=humans[i].x, y=humans[i].y;\n int k=-1;\n for(int kk=0;kk<4;kk++) if(x+dx4[kk]==wx && y+dy4[kk]==wy){ k=kk; break; }\n if(k==-1) return false;\n if(plannedMoveDest.count({wx,wy})) return false;\n if(!placeableWall(wx,wy,petCnt,humanCnt)) return false;\n plannedWalls.insert({wx,wy});\n act[i]=dirWall[k];\n return true;\n };\n\n auto planMoveToward = [&](int i, int tx, int ty)->void{\n auto &b=bfsRes[i];\n if(!in_grid(tx,ty)) return;\n if(b.dist[tx][ty]>= (int)1e9) return;\n char fd=b.first[tx][ty];\n if(fd=='.' || fd=='?') return;\n int k=-1;\n for(int kk=0;kk<4;kk++) if(dirMove[kk]==fd){ k=kk; break; }\n if(k==-1) return;\n int nx=humans[i].x+dx4[k], ny=humans[i].y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) return;\n if(plannedWalls.count({nx,ny})) return;\n plannedMoveDest.insert({nx,ny});\n act[i]=fd;\n };\n\n // Find nearest build task among a set of target wall cells\n auto findBuildTask = [&](int i, const vector>& targets)->tuple{\n const int INF=1e9;\n int best=INF;\n int bestWorkX=-1,bestWorkY=-1,bestWallX=-1,bestWallY=-1;\n auto &b=bfsRes[i];\n for(auto &cell: targets){\n int wx=cell.first, wy=cell.second;\n if(wall[wx][wy]) continue;\n // need adjacent work cell\n for(int k=0;k<4;k++){\n int px=wx+dx4[k], py=wy+dy4[k];\n if(!in_grid(px,py) || wall[px][py]) continue;\n int d=b.dist[px][py];\n if(d>=INF) continue;\n // Prefer building from interior when perimeter building\n int penalty=0;\n if(isPerimeterCell(wx,wy)){\n // work cell inside rectangle is preferred\n penalty = inInterior(px,py) ? 0 : 3;\n }\n int val=d+penalty;\n if(val= (int)1e9){ act[i]='.'; continue; }\n if(humans[i].x==workX && humans[i].y==workY){\n if(!planWallAt(i, wallX, wallY)){\n // fallback: try any adjacent missing perimeter cell\n bool done=false;\n for(int k=0;k<4;k++){\n int wx=humans[i].x+dx4[k], wy=humans[i].y+dy4[k];\n if(!in_grid(wx,wy)) continue;\n if(!isPerimeterCell(wx,wy)) continue;\n if(wall[wx][wy]) continue;\n if(planWallAt(i, wx, wy)){ done=true; break; }\n }\n if(!done) act[i]='.';\n }\n } else {\n planMoveToward(i, workX, workY);\n }\n }\n } else if(phase==CUT){\n // If cut not decided, just stand (perimeter already should be complete soon; no catastrophic gate anymore).\n // If cut decided, move humans to safe side, then build cut quickly.\n if(cutPos==-1 || cutCells.empty()){\n for(int i=0;i= cutPos+1);\n else onSafe = (humans[i].y <= cutPos-1);\n }else{\n if(keepRightOrDown) onSafe = (humans[i].x >= cutPos+1);\n else onSafe = (humans[i].x <= cutPos-1);\n }\n if(!onSafe){\n planMoveToward(i, tx, ty);\n continue;\n }\n // Build cut\n auto [best, workX, workY, wallX, wallY] = findBuildTask(i, cutCells);\n if(best >= (int)1e9){ act[i]='.'; continue; }\n if(humans[i].x==workX && humans[i].y==workY){\n if(!planWallAt(i, wallX, wallY)) act[i]='.';\n }else{\n planMoveToward(i, workX, workY);\n }\n }\n }\n }\n\n // Output\n string out; out.reserve(M);\n for(int i=0;i mv(N);\n for(int i=0;i> mv[i])) return 0;\n }\n for(int i=0;i\nusing namespace std;\n\nstatic constexpr int H = 20;\nstatic constexpr int W = 20;\nstatic constexpr int N = H * W;\nstatic constexpr int LMAX = 200;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto time_start = chrono::high_resolution_clock::now();\n auto elapsed_sec = [&]() -> double {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - time_start).count();\n };\n\n int si, sj, ti, tj;\n double p_d;\n cin >> si >> sj >> ti >> tj >> p_d;\n\n vector h(H), v(H - 1);\n for (int i = 0; i < H; i++) cin >> h[i]; // length 19\n for (int i = 0; i < H - 1; i++) cin >> v[i]; // length 20\n\n auto id = [&](int i, int j) { return i * W + j; };\n int s = id(si, sj);\n int t = id(ti, tj);\n\n float p = (float)p_d;\n float q = 1.0f - p;\n\n // mv[state][dir], dir: 0=U,1=D,2=L,3=R\n int mv[N][4];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) {\n int cur = id(i, j);\n // U\n if (i == 0 || v[i - 1][j] == '1') mv[cur][0] = cur;\n else mv[cur][0] = id(i - 1, j);\n // D\n if (i == H - 1 || v[i][j] == '1') mv[cur][1] = cur;\n else mv[cur][1] = id(i + 1, j);\n // L\n if (j == 0 || h[i][j - 1] == '1') mv[cur][2] = cur;\n else mv[cur][2] = id(i, j - 1);\n // R\n if (j == W - 1 || h[i][j] == '1') mv[cur][3] = cur;\n else mv[cur][3] = id(i, j + 1);\n }\n\n // G[turn][x] = optimistic (state-dependent) best additional expected score\n static float G[LMAX + 2][N];\n for (int x = 0; x < N; x++) G[LMAX + 1][x] = 0.0f;\n for (int turn = LMAX; turn >= 1; --turn) {\n float reward = (float)(401 - turn);\n for (int x = 0; x < N; x++) {\n if (x == t) { G[turn][x] = 0.0f; continue; }\n float stay_part = p * G[turn + 1][x];\n float best = 0.0f;\n for (int a = 0; a < 4; a++) {\n int y = mv[x][a];\n float val = stay_part;\n if (y == t) val += q * reward;\n else val += q * G[turn + 1][y];\n if (val > best) best = val;\n }\n G[turn][x] = best;\n }\n G[turn][t] = 0.0f;\n }\n\n // Q[turn][a][x] = expected additional score if at cell x at absolute 'turn', take action a now,\n // then act optimally (state-dependent) afterward using G.\n static float Q[LMAX + 1][4][N];\n for (int turn = 1; turn <= LMAX; ++turn) {\n float reward = (float)(401 - turn);\n for (int x = 0; x < N; x++) {\n if (x == t) {\n for (int a = 0; a < 4; a++) Q[turn][a][x] = 0.0f;\n continue;\n }\n float stay_part = p * G[turn + 1][x];\n for (int a = 0; a < 4; a++) {\n int y = mv[x][a];\n float val = stay_part;\n if (y == t) val += q * reward;\n else val += q * G[turn + 1][y];\n Q[turn][a][x] = val;\n }\n }\n }\n\n auto heuristic_openloop_1step = [&](const array& prob, int turn) -> float {\n if (turn > LMAX) return 0.0f;\n float best = 0.0f;\n for (int a = 0; a < 4; a++) {\n const float* qax = Q[turn][a];\n float sum = 0.0f;\n // dot(prob, Q[turn][a])\n for (int x = 0; x < N; x++) sum += prob[x] * qax[x];\n if (sum > best) best = sum;\n }\n return best;\n };\n\n struct Node {\n int len = 0;\n float score = 0.0f; // exact expected score accumulated so far\n float key = 0.0f; // score + heuristic\n array path{};\n array prob{}; // distribution over \"not yet reached\"\n };\n\n auto compute_key = [&](const Node& nd) -> float {\n int turn = nd.len + 1;\n return nd.score + heuristic_openloop_1step(nd.prob, turn);\n };\n\n auto extend = [&](const Node& cur, int a) -> Node {\n static const char dc[4] = {'U','D','L','R'};\n Node nxt;\n nxt.len = cur.len + 1;\n nxt.score = cur.score;\n nxt.path = cur.path;\n nxt.path[cur.len] = dc[a];\n nxt.prob.fill(0.0f);\n\n float reach = 0.0f;\n // Transition distribution\n for (int x = 0; x < N; x++) {\n float px = cur.prob[x];\n if (px == 0.0f) continue;\n\n // forget -> stay\n nxt.prob[x] += px * p;\n\n // remember -> move attempt\n int y = mv[x][a];\n float mvprob = px * q;\n if (y == t) reach += mvprob;\n else nxt.prob[y] += mvprob;\n }\n nxt.prob[t] = 0.0f;\n\n int turn = nxt.len;\n nxt.score += reach * (float)(401 - turn);\n nxt.key = compute_key(nxt);\n return nxt;\n };\n\n auto eval_exact = [&](const string& path) -> double {\n array prob{};\n prob.fill(0.0f);\n prob[s] = 1.0f;\n prob[t] = 0.0f;\n\n double score = 0.0;\n for (int i = 0; i < (int)path.size(); i++) {\n int a;\n char c = path[i];\n if (c == 'U') a = 0;\n else if (c == 'D') a = 1;\n else if (c == 'L') a = 2;\n else a = 3;\n\n array nxt{};\n nxt.fill(0.0f);\n double reach = 0.0;\n for (int x = 0; x < N; x++) {\n float px = prob[x];\n if (px == 0.0f) continue;\n nxt[x] += px * p;\n int y = mv[x][a];\n double mvprob = (double)px * (double)q;\n if (y == t) reach += mvprob;\n else nxt[y] += (float)mvprob;\n }\n nxt[t] = 0.0f;\n int turn = i + 1;\n score += reach * (401.0 - turn);\n prob = nxt;\n }\n return score;\n };\n\n // Beam search\n const int BEAM_WIDTH = 320;\n\n Node init;\n init.len = 0;\n init.score = 0.0f;\n init.prob.fill(0.0f);\n init.prob[s] = 1.0f;\n init.prob[t] = 0.0f;\n init.key = compute_key(init);\n\n vector beam;\n beam.reserve(BEAM_WIDTH);\n beam.push_back(init);\n\n Node best_any = init; // best exact over all lengths\n Node best_len200 = init; // best exact among length==200 (set later)\n\n for (int step = 0; step < LMAX; step++) {\n vector cand;\n cand.reserve(beam.size() * 4);\n\n for (const auto& nd : beam) {\n for (int a = 0; a < 4; a++) {\n Node child = extend(nd, a);\n if (child.score > best_any.score) best_any = child;\n cand.push_back(std::move(child));\n }\n }\n\n int take = min((int)cand.size(), BEAM_WIDTH);\n nth_element(cand.begin(), cand.begin() + take, cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n cand.resize(take);\n sort(cand.begin(), cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n\n beam.swap(cand);\n\n if (step == LMAX - 1) {\n // find best exact at len=200 among generated nodes\n best_len200 = beam[0];\n for (auto &nd : beam) if (nd.score > best_len200.score) best_len200 = nd;\n }\n }\n\n auto node_to_string = [&](const Node& nd) -> string {\n string out;\n out.reserve(nd.len);\n for (int i = 0; i < nd.len; i++) out.push_back(nd.path[i]);\n return out;\n };\n\n // Greedy completion of best_any to length 200 using open-loop one-step heuristic.\n auto greedy_complete_to_200 = [&](Node nd) -> Node {\n while (nd.len < LMAX) {\n int turn = nd.len + 1;\n int besta = 0;\n float bestv = -1e30f;\n for (int a = 0; a < 4; a++) {\n const float* qax = Q[turn][a];\n float sum = 0.0f;\n for (int x = 0; x < N; x++) sum += nd.prob[x] * qax[x];\n if (sum > bestv) { bestv = sum; besta = a; }\n }\n nd = extend(nd, besta);\n }\n return nd;\n };\n\n Node best_full_from_any = greedy_complete_to_200(best_any);\n\n // Choose initial best for local search among candidates\n string best_str = node_to_string(best_any);\n double best_score = eval_exact(best_str);\n\n {\n string s200 = node_to_string(best_len200);\n double sc200 = eval_exact(s200);\n if (sc200 > best_score) { best_score = sc200; best_str = s200; }\n }\n {\n string sfull = node_to_string(best_full_from_any);\n double scfull = eval_exact(sfull);\n if (scfull > best_score) { best_score = scfull; best_str = sfull; }\n }\n\n // Local search (hill-climb) on the best string found.\n XorShift rng;\n const double TIME_LIMIT = 1.95; // seconds\n int L = (int)best_str.size();\n if (L == 0) L = 1;\n\n // If too short, pad to 200 to allow more robustness improvements.\n // (Usually longer is better unless it actively moves away; local search can fix.)\n while ((int)best_str.size() < LMAX) best_str.push_back('D');\n best_score = eval_exact(best_str);\n\n auto mutate_char = [&](char c, int r) -> char {\n static const char ds[4] = {'U','D','L','R'};\n int idx = 0;\n for (; idx < 4; idx++) if (ds[idx] == c) break;\n // pick among other 3 deterministically by r in [0..2]\n int k = 0;\n for (int j = 0; j < 4; j++) {\n if (j == idx) continue;\n if (k == r) return ds[j];\n k++;\n }\n return 'U';\n };\n\n int iters = 0;\n while (elapsed_sec() < TIME_LIMIT) {\n iters++;\n string cand = best_str;\n\n double r = rng.next_double();\n if (r < 0.80) {\n // single-point change\n int i = rng.next_int(0, (int)cand.size() - 1);\n cand[i] = mutate_char(cand[i], rng.next_int(0, 2));\n } else {\n // small block randomization\n int i = rng.next_int(0, (int)cand.size() - 1);\n int len = rng.next_int(2, 6);\n static const char ds[4] = {'U','D','L','R'};\n for (int k = 0; k < len; k++) {\n int pos = i + k;\n if (pos >= (int)cand.size()) break;\n cand[pos] = ds[rng.next_int(0, 3)];\n }\n }\n\n double sc = eval_exact(cand);\n if (sc > best_score) {\n best_score = sc;\n best_str.swap(cand);\n }\n }\n\n // Ensure <=200 (it is) and output\n if ((int)best_str.size() > LMAX) best_str.resize(LMAX);\n cout << best_str << \"\\n\";\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nstatic const int N = 30;\nstatic const int CELLS = N * N;\nstatic const int PORTS = CELLS * 4;\n\n// Directions: 0:left, 1:up, 2:right, 3:down\nstatic const int dj[4] = {-1, 0, 1, 0};\nstatic const int di[4] = {0, -1, 0, 1};\nstatic const int opp[4] = {2, 3, 0, 1};\n\nstatic const int to_table[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\n// rotate CCW by 90 degrees mapping\nstatic const int rot1[8] = {1,2,3,0, 5,4, 7,6};\n\nstruct XorShift {\n uint64_t x;\n explicit XorShift(uint64_t seed=88172645463325252ull) : x(seed) {}\n inline uint32_t nextU32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU32() % (uint32_t)(hi - lo + 1));\n }\n inline double nextDouble() { // [0,1)\n return (nextU32() + 0.5) / 4294967296.0;\n }\n};\n\nstruct Timer {\n chrono::high_resolution_clock::time_point st;\n Timer() : st(chrono::high_resolution_clock::now()) {}\n double elapsedSec() const {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nstruct EvalResult {\n int L1=0, L2=0;\n int loopsCnt=0;\n int score=0;\n\n int matchedBorders=0;\n int boundaryPorts=0;\n int unmatchedPorts=0;\n\n int sumLen=0;\n int sumLen2=0;\n\n int openSizeSum=0; // sum compSize over open components\n int openMiss2Sum=0; // sum (miss^2) over open components\n\n int aux=0;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector init(CELLS);\n for (int i = 0; i < N; i++) {\n string s; cin >> s;\n for (int j = 0; j < N; j++) init[i*N + j] = s[j] - '0';\n }\n\n // Precompute state after r rotations\n uint8_t stateAfterRot[8][4];\n for (int t = 0; t < 8; t++) {\n int cur = t;\n for (int r = 0; r < 4; r++) {\n stateAfterRot[t][r] = (uint8_t)cur;\n cur = rot1[cur];\n }\n }\n\n bool hasPort[8][4];\n int partner[8][4];\n for (int t = 0; t < 8; t++) {\n for (int d = 0; d < 4; d++) {\n int d2 = to_table[t][d];\n hasPort[t][d] = (d2 != -1);\n partner[t][d] = d2;\n }\n }\n\n // buffers for evaluation\n static uint8_t existPort[PORTS];\n static int16_t ext[PORTS];\n static uint16_t visStamp[PORTS];\n uint16_t curStamp = 1;\n static int stk[PORTS];\n\n auto evaluate = [&](const vector& state) -> EvalResult {\n EvalResult res;\n\n // existPort, boundaryPorts\n res.boundaryPorts = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int cell = i*N + j;\n int t = state[cell];\n int base = cell*4;\n for (int s = 0; s < 4; s++) existPort[base+s] = hasPort[t][s] ? 1 : 0;\n\n if (j == 0 && hasPort[t][0]) res.boundaryPorts++;\n if (i == 0 && hasPort[t][1]) res.boundaryPorts++;\n if (j == N-1 && hasPort[t][2]) res.boundaryPorts++;\n if (i == N-1 && hasPort[t][3]) res.boundaryPorts++;\n }\n\n // build ext and matchedBorders\n for (int p = 0; p < PORTS; p++) ext[p] = -1;\n res.matchedBorders = 0;\n\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int cell = i*N + j;\n int base = cell*4;\n\n if (j+1 < N) {\n int cellR = i*N + (j+1);\n int a = base + 2;\n int b = cellR*4 + 0;\n if (existPort[a] && existPort[b]) {\n ext[a] = (int16_t)b;\n ext[b] = (int16_t)a;\n res.matchedBorders++;\n }\n }\n if (i+1 < N) {\n int cellD = (i+1)*N + j;\n int a = base + 3;\n int b = cellD*4 + 1;\n if (existPort[a] && existPort[b]) {\n ext[a] = (int16_t)b;\n ext[b] = (int16_t)a;\n res.matchedBorders++;\n }\n }\n }\n\n // unmatchedPorts\n res.unmatchedPorts = 0;\n for (int p = 0; p < PORTS; p++) if (existPort[p] && ext[p] == -1) res.unmatchedPorts++;\n\n // traverse port-components\n if (++curStamp == 0) { // extremely unlikely; reset\n memset(visStamp, 0, sizeof(visStamp));\n curStamp = 1;\n }\n\n int best1 = 0, best2 = 0;\n\n for (int p = 0; p < PORTS; p++) {\n if (!existPort[p] || visStamp[p] == curStamp) continue;\n\n int compSize = 0;\n int miss = 0;\n\n int sp = 0;\n stk[sp++] = p;\n visStamp[p] = curStamp;\n\n while (sp) {\n int v = stk[--sp];\n compSize++;\n\n if (ext[v] == -1) miss++;\n\n int cell = v / 4;\n int side = v % 4;\n int t = state[cell];\n\n int u_int = cell*4 + partner[t][side];\n if (existPort[u_int] && visStamp[u_int] != curStamp) {\n visStamp[u_int] = curStamp;\n stk[sp++] = u_int;\n }\n int u_ext = ext[v];\n if (u_ext != -1 && visStamp[u_ext] != curStamp) {\n visStamp[u_ext] = curStamp;\n stk[sp++] = u_ext;\n }\n }\n\n if (miss == 0) {\n int len = compSize / 2;\n res.loopsCnt++;\n res.sumLen += len;\n res.sumLen2 += len * len;\n if (len > best1) { best2 = best1; best1 = len; }\n else if (len > best2) { best2 = len; }\n } else {\n res.openSizeSum += compSize;\n res.openMiss2Sum += miss * miss;\n }\n }\n\n res.L1 = best1;\n res.L2 = best2;\n res.score = (res.loopsCnt >= 2 ? best1 * best2 : 0);\n\n // Auxiliary objective (tuned to push closing + merging)\n long long aux = 0;\n aux += 500000LL * min(res.loopsCnt, 2); // must get 2 loops\n aux += 30000LL * res.score; // then maximize true score\n aux += 3000LL * res.L2 + 800LL * res.L1; // stabilize improving 2nd loop\n aux += 120LL * res.sumLen2; // prefer longer cycles\n aux += 25LL * res.matchedBorders; // encourage connections\n aux -= 20LL * res.unmatchedPorts; // close open ends\n aux -= 120LL * res.boundaryPorts; // avoid boundary leaks\n aux += 2LL * res.openSizeSum; // keep big components\n aux -= 10LL * res.openMiss2Sum; // but strongly reduce missing ends\n\n if (aux > INT_MAX) aux = INT_MAX;\n if (aux < INT_MIN) aux = INT_MIN;\n res.aux = (int)aux;\n return res;\n };\n\n Timer timer;\n double TL = 1.90;\n\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n // local best rotation proposal for a cell (fast heuristic move)\n auto bestLocalRotation = [&](int cell, const vector& state) -> uint8_t {\n int i = cell / N, j = cell % N;\n\n // weights for local scoring\n const int W_MATCH = 6;\n const int W_MISM = 7;\n const int W_BOUND = 10;\n\n int bestVal = INT_MIN;\n uint8_t bestR = 0;\n\n for (int r = 0; r < 4; r++) {\n int t = stateAfterRot[init[cell]][r];\n int val = 0;\n\n for (int s = 0; s < 4; s++) {\n bool p = hasPort[t][s];\n int ni = i + di[s], nj = j + dj[s];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) {\n if (p) val -= W_BOUND;\n } else {\n int nb = ni*N + nj;\n bool q = hasPort[state[nb]][opp[s]];\n if (p && q) val += W_MATCH;\n else if (p ^ q) val -= W_MISM;\n }\n }\n\n // small bias to avoid boundary ports even if neighbor absent\n if (val > bestVal) {\n bestVal = val;\n bestR = (uint8_t)r;\n }\n }\n return bestR;\n };\n\n // Global best tracking\n vector globalBestRot(CELLS, 0);\n vector globalBestState(CELLS, 0);\n int globalBestScore = 0;\n\n auto initRandomSolution = [&](vector& rot, vector& state) {\n rot.resize(CELLS);\n state.resize(CELLS);\n for (int c = 0; c < CELLS; c++) {\n rot[c] = (uint8_t)rng.nextInt(0, 3);\n state[c] = stateAfterRot[init[c]][rot[c]];\n }\n };\n\n auto runSA = [&](vector& rot, vector& state, double timeSlice) {\n double startT = timer.elapsedSec();\n EvalResult cur = evaluate(state);\n\n // SA temps\n const double T0 = 350000.0;\n const double T1 = 30.0;\n\n while (timer.elapsedSec() - startT < timeSlice && timer.elapsedSec() < TL) {\n double tt = (timer.elapsedSec() - startT) / max(1e-9, timeSlice);\n double Temp = T0 * (1.0 - tt) + T1 * tt;\n\n int cell = rng.nextInt(0, CELLS - 1);\n\n uint8_t oldr = rot[cell];\n uint8_t olds = state[cell];\n\n uint8_t newr;\n uint32_t rv = rng.nextU32();\n\n // mix moves: random / local-best\n if ((rv & 15) == 0) {\n newr = bestLocalRotation(cell, state);\n } else {\n // random different rotation\n int add = (int)(rv % 3) + 1;\n newr = (uint8_t)((oldr + add) & 3);\n }\n if (newr == oldr) continue;\n\n rot[cell] = newr;\n state[cell] = stateAfterRot[init[cell]][newr];\n\n EvalResult nxt = evaluate(state);\n int delta = nxt.aux - cur.aux;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / Temp);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (accept) {\n cur = nxt;\n if (cur.score > globalBestScore) {\n globalBestScore = cur.score;\n globalBestRot = rot;\n globalBestState = state;\n }\n } else {\n rot[cell] = oldr;\n state[cell] = olds;\n }\n }\n };\n\n // Phase 1: multi-start exploration\n const double phase1End = 0.85; // seconds\n while (timer.elapsedSec() < min(TL, phase1End)) {\n vector rot, state;\n initRandomSolution(rot, state);\n runSA(rot, state, 0.17); // short runs\n }\n\n // If somehow no best stored (very unlikely), set from random\n if (globalBestState[0] == 0 && globalBestRot[0] == 0) {\n initRandomSolution(globalBestRot, globalBestState);\n globalBestScore = evaluate(globalBestState).score;\n }\n\n // Phase 2: long refinement from the best found\n {\n vector rot = globalBestRot;\n vector state = globalBestState;\n double remaining = TL - timer.elapsedSec();\n runSA(rot, state, max(0.0, remaining));\n }\n\n // Output\n string out(CELLS, '0');\n for (int c = 0; c < CELLS; c++) out[c] = char('0' + globalBestRot[c]);\n cout << out << \"\\n\";\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n};\n\nstatic inline int hexval(char c) {\n if ('0' <= c && c <= '9') return c - '0';\n return 10 + (c - 'a');\n}\nstatic inline bool hasL(int m){ return m & 1; }\nstatic inline bool hasU(int m){ return m & 2; }\nstatic inline bool hasR(int m){ return m & 4; }\nstatic inline bool hasD(int m){ return m & 8; }\n\nstatic inline int dsu_find(int a, int parent[]) {\n while (parent[a] != a) {\n parent[a] = parent[parent[a]];\n a = parent[a];\n }\n return a;\n}\nstatic inline void dsu_unite(int a, int b, int parent[], uint8_t rnk[]) {\n a = dsu_find(a, parent);\n b = dsu_find(b, parent);\n if (a == b) return;\n if (rnk[a] < rnk[b]) swap(a, b);\n parent[b] = a;\n if (rnk[a] == rnk[b]) rnk[a]++;\n}\n\nstruct Eval {\n int maxTree = 0; // largest tree component size\n int maxComp = 0; // largest connected component size (may have cycles)\n int maxTreeable = 0; // max over components of (v - excess), excess=e-(v-1) if cyclic\n int matchEdges = 0; // total matched edges\n int cycleExcess = 0; // total excess across components\n int scalar = 0;\n};\n\nEval evaluate_board(const array& a, int N) {\n int NN = N * N;\n\n int parent[100];\n uint8_t rnk[100];\n for(int i=0;i= 1) {\n int need = v - 1;\n if(e > need) excess = e - need;\n }\n cycleExcess += excess;\n maxTreeable = max(maxTreeable, v - excess); // \u201calmost tree\u201d guidance\n if(excess == 0) maxTree = max(maxTree, v); // tree iff connected and no excess (DSU connectivity implies e>=v-1)\n }\n\n // Strongly prioritize maxTree, but also guide via maxTreeable.\n // Penalize cycles hard; matchEdges small helper.\n int scalar = maxTree * 1000000\n + maxTreeable * 6000\n + maxComp * 1500\n + matchEdges * 10\n - cycleExcess * 22000;\n\n return Eval{maxTree, maxComp, maxTreeable, matchEdges, cycleExcess, scalar};\n}\n\nstatic const char DIRCH[4] = {'U','D','L','R'};\nstatic const int dr[4] = {-1, +1, 0, 0};\nstatic const int dc[4] = {0, 0, -1, +1};\n\nstatic inline int revdir(int d){\n if(d==0) return 1;\n if(d==1) return 0;\n if(d==2) return 3;\n return 2;\n}\n\nstatic inline bool apply_move(array& a, int N, int &er, int &ec, int d){\n int nr = er + dr[d], nc = ec + dc[d];\n if(nr<0||nr>=N||nc<0||nc>=N) return false;\n int u = er*N + ec;\n int v = nr*N + nc;\n swap(a[u], a[v]);\n er = nr; ec = nc;\n return true;\n}\n\nstatic inline bool better_solution(const Eval& A, int KA, const Eval& B, int KB, int targetFull){\n bool Afull = (A.maxTree == targetFull);\n bool Bfull = (B.maxTree == targetFull);\n if(Afull != Bfull) return Afull;\n if(Afull && Bfull) return KA < KB;\n\n if(A.maxTree != B.maxTree) return A.maxTree > B.maxTree;\n if(A.maxTreeable != B.maxTreeable) return A.maxTreeable > B.maxTreeable;\n if(A.maxComp != B.maxComp) return A.maxComp > B.maxComp;\n if(A.cycleExcess != B.cycleExcess) return A.cycleExcess < B.cycleExcess;\n if(A.matchEdges != B.matchEdges) return A.matchEdges > B.matchEdges;\n return KA < KB;\n}\n\nstruct State {\n array a;\n int er=0, ec=0;\n int lastDir=-1;\n int scalar=0;\n Eval ev;\n string path;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T;\n cin >> N >> T;\n\n array init{};\n int er=-1, ec=-1;\n for(int i=0;i> s;\n for(int j=0;j(\n chrono::steady_clock::now()-start).count();\n };\n const double TIME_LIMIT_MS = 2850.0;\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n seed ^= (uint64_t)(N*10007 + T*1000003);\n XorShift64 rng(seed);\n\n string bestAns = \"\";\n Eval bestEv = evaluate_board(init, N);\n int bestK = 0;\n\n if(bestEv.maxTree == targetFull){\n cout << \"\\n\";\n return 0;\n }\n\n // ----------------------------\n // Beam search prefix (stronger)\n // ----------------------------\n int beamWidth = (N <= 7 ? 500 : 400);\n int beamDepth = min(220, max(80, T/7)); // slightly deeper\n double beamTimeFrac = 0.38; // spend less than half time on beam\n\n vector cur, nxt;\n cur.reserve(beamWidth);\n nxt.reserve(beamWidth*4);\n\n State s0;\n s0.a = init; s0.er = er; s0.ec = ec; s0.lastDir = -1;\n s0.ev = bestEv; s0.scalar = bestEv.scalar;\n s0.path.clear();\n cur.push_back(s0);\n\n for(int depth=0; depth beamWidth){\n nth_element(nxt.begin(), nxt.begin()+beamWidth, nxt.end(),\n [](const State& a, const State& b){ return a.scalar > b.scalar; });\n nxt.resize(beamWidth);\n }\n // keep sorted for later seed selection\n sort(nxt.begin(), nxt.end(), [](const State& a, const State& b){ return a.scalar > b.scalar; });\n cur.swap(nxt);\n }\n\n // Build SA seeds: initial + top beam states + a few random-perturbed copies for diversity\n vector seeds;\n seeds.reserve(24);\n seeds.push_back(s0);\n\n int topM = min(10, (int)cur.size());\n for(int i=0;i=N||nc<0||nc>=N) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n int d = cand[rng.next_int(ccnt)];\n apply_move(rs.a, N, rs.er, rs.ec, d);\n rs.lastDir = d;\n rs.path.push_back(DIRCH[d]);\n }\n rs.ev = evaluate_board(rs.a, N);\n rs.scalar = rs.ev.scalar;\n seeds.push_back(std::move(rs));\n }\n\n // ----------------------------\n // Simulated annealing from seeds (with kick)\n // ----------------------------\n for(int si=0; si<(int)seeds.size() && elapsed_ms() a = st.a;\n int cur_er = st.er, cur_ec = st.ec;\n int lastDir = st.lastDir;\n Eval curE = st.ev;\n\n string moves = st.path;\n moves.reserve(T);\n\n int runBestIdx = (int)moves.size();\n Eval runBestEv = curE;\n\n int accepted = 0;\n int stagnate = 0;\n\n // schedule\n double temp0 = 1600.0;\n double temp1 = 10.0;\n\n while(accepted < remaining && elapsed_ms() < TIME_LIMIT_MS){\n double prog = (double)accepted / max(1, remaining);\n double temp = temp0 * pow(temp1 / temp0, prog);\n\n // Kick: escape hard local minima (best-prefix tracking makes this safe)\n if(stagnate > 900){\n int kickLen = min(35, remaining - accepted);\n for(int kk=0; kk=N||nc<0||nc>=N) continue;\n // allow reverse but discourage\n if(lastDir!=-1 && d==revdir(lastDir) && rng.next_double() < 0.7) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n int d = cand[rng.next_int(ccnt)];\n apply_move(a, N, cur_er, cur_ec, d);\n moves.push_back(DIRCH[d]);\n accepted++;\n lastDir = d;\n }\n curE = evaluate_board(a, N);\n stagnate = 0;\n continue;\n }\n\n int cand[4], ccnt=0;\n for(int d=0; d<4; d++){\n int nr = cur_er + dr[d], nc = cur_ec + dc[d];\n if(nr<0||nr>=N||nc<0||nc>=N) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n\n int d;\n if(lastDir!=-1 && ccnt>=2){\n int rev = revdir(lastDir);\n if(rng.next_double() < 0.88){\n int tmp[4], tcnt=0;\n for(int k=0;k= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if(rng.next_double() < prob) accept = true;\n }\n\n if(accept){\n curE = newE;\n moves.push_back(DIRCH[d]);\n accepted++;\n lastDir = d;\n\n bool improved = false;\n if(better_solution(curE, (int)moves.size(), runBestEv, runBestIdx, targetFull)){\n runBestEv = curE;\n runBestIdx = (int)moves.size();\n improved = true;\n }\n stagnate = improved ? 0 : (stagnate + 1);\n\n if(improved && better_solution(runBestEv, runBestIdx, bestEv, bestK, targetFull)){\n bestEv = runBestEv;\n bestK = runBestIdx;\n bestAns = moves.substr(0, runBestIdx);\n if(bestEv.maxTree == targetFull){\n cout << bestAns << \"\\n\";\n return 0;\n }\n }\n } else {\n int u = old_er*N + old_ec;\n int v = cur_er*N + cur_ec;\n swap(a[u], a[v]);\n cur_er = old_er; cur_ec = old_ec;\n stagnate++;\n }\n }\n\n string candAns = moves.substr(0, runBestIdx);\n if(better_solution(runBestEv, (int)candAns.size(), bestEv, bestK, targetFull)){\n bestEv = runBestEv;\n bestK = (int)candAns.size();\n bestAns = candAns;\n }\n }\n\n if((int)bestAns.size() > T) bestAns.resize(T);\n cout << bestAns << \"\\n\";\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\n\n// ---------- RNG (splitmix64) ----------\nstatic inline uint64_t splitmix64(uint64_t x) {\n x += 0x9e3779b97f4a7c15ULL;\n x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;\n x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;\n return x ^ (x >> 31);\n}\n\nstruct RNG {\n uint64_t s;\n explicit RNG(uint64_t seed=1) : s(seed) {}\n uint64_t next_u64() { return s = splitmix64(s); }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n double next_double(double l, double r) {\n return l + (r - l) * next_double();\n }\n};\n\n// ---------- Geometry ----------\nstruct Point { int x, y; };\n\nstruct Line {\n int64 px, py, qx, qy;\n};\n\nstatic inline bool is_valid_line(const Line& ln) {\n auto inRange = [&](int64 v){ return -1000000000LL <= v && v <= 1000000000LL; };\n if (!inRange(ln.px) || !inRange(ln.py) || !inRange(ln.qx) || !inRange(ln.qy)) return false;\n if (ln.px == ln.qx && ln.py == ln.qy) return false;\n return true;\n}\n\nstatic inline int side_of(const Line& ln, int x, int y) {\n int64 dx = ln.qx - ln.px;\n int64 dy = ln.qy - ln.py;\n int64 ax = (int64)x - ln.px;\n int64 ay = (int64)y - ln.py;\n __int128 cross = (__int128)dx * ay - (__int128)dy * ax;\n if (cross > 0) return 1;\n if (cross < 0) return -1;\n return 0;\n}\n\nstatic inline uint64_t hash_line(const Line& ln) {\n uint64_t h = 0;\n auto mix = [&](int64 v) {\n h ^= splitmix64((uint64_t)v + 0x9e3779b97f4a7c15ULL + (h<<6) + (h>>2));\n };\n mix(ln.px); mix(ln.py); mix(ln.qx); mix(ln.qy);\n return h;\n}\n\n// squared distance condition: C^2 <= (A^2+B^2)R^2\nstatic inline bool line_intersects_disk(const Line& ln, long double R) {\n long double x1 = (long double)ln.px, y1 = (long double)ln.py;\n long double x2 = (long double)ln.qx, y2 = (long double)ln.qy;\n long double A = y2 - y1;\n long double B = x1 - x2;\n long double C = -(A * x1 + B * y1);\n long double lhs = C * C;\n long double rhs = (A * A + B * B) * (R * R);\n return lhs < rhs;\n}\n\nstatic Line make_line_from_angle_offset(long double theta, long double offset) {\n long double nx = cos(theta), ny = sin(theta);\n long double dx = -sin(theta), dy = cos(theta);\n long double x0 = nx * offset;\n long double y0 = ny * offset;\n long double L = 20000.0L;\n long double x1 = x0 + dx * L, y1 = y0 + dy * L;\n long double x2 = x0 - dx * L, y2 = y0 - dy * L;\n Line ln;\n ln.px = llround(x1); ln.py = llround(y1);\n ln.qx = llround(x2); ln.qy = llround(y2);\n if (ln.px == ln.qx && ln.py == ln.qy) ln.qx += 1;\n return ln;\n}\n\n// ---------- Fast flat hash table (key->count) ----------\nstruct FlatHash {\n int cap, mask;\n vector keys;\n vector vals;\n vector vis;\n int stamp = 1;\n vector used;\n\n explicit FlatHash(int capPow2 = 1<<15) { init(capPow2); }\n\n void init(int capPow2) {\n cap = capPow2;\n mask = cap - 1;\n keys.assign(cap, 0);\n vals.assign(cap, 0);\n vis.assign(cap, 0);\n stamp = 1;\n used.reserve(6000);\n }\n\n inline void reset() {\n ++stamp;\n used.clear();\n if (stamp == INT_MAX) {\n fill(vis.begin(), vis.end(), 0);\n stamp = 1;\n }\n }\n\n inline int find_pos(uint64_t k) const {\n uint64_t h = k * 11995408973635179863ULL;\n int pos = (int)(h & (uint64_t)mask);\n while (vis[pos] == stamp && keys[pos] != k) pos = (pos + 1) & mask;\n return pos;\n }\n\n inline void add(uint64_t k) {\n int pos = find_pos(k);\n if (vis[pos] != stamp) {\n vis[pos] = stamp;\n keys[pos] = k;\n vals[pos] = 1;\n used.push_back(pos);\n } else {\n vals[pos]++;\n }\n }\n\n inline int get(uint64_t k) const {\n int pos = find_pos(k);\n if (vis[pos] != stamp) return 0;\n return vals[pos];\n }\n};\n\nstruct Score {\n int dist; // sum min(a_d,b_d)\n int good; // number of regions with size in [1..10] (tie-break)\n};\nstatic inline bool better(const Score& a, const Score& b) {\n if (a.dist != b.dist) return a.dist > b.dist;\n return a.good > b.good;\n}\n\n// ---------- Solver ----------\nstruct Solver {\n static constexpr long double R = 10000.0L;\n\n int N, K;\n array a{};\n int totalA = 0;\n vector pts;\n\n vector key; // region signature per strawberry\n FlatHash fh;\n\n // per-step info\n vector largeKeys; // keys with count > 10\n\n Solver(int N_, int K_, const array& a_, vector pts_)\n : N(N_), K(K_), a(a_), pts(std::move(pts_)), key(N_, 0), fh(1<<15) {\n for (int d=1; d<=10; d++) totalA += a[d];\n largeKeys.reserve(4096);\n }\n\n void build_current_counts() {\n fh.reset();\n for (int i=0;i 10) largeKeys.push_back(fh.keys[pos]);\n }\n }\n\n Score score_current_from_fh() const {\n int b[11] = {};\n int good = 0;\n for (int pos : fh.used) {\n int sz = fh.vals[pos];\n if (1 <= sz && sz <= 10) { b[sz]++; good++; }\n }\n int dist = 0;\n for (int d=1; d<=10; d++) dist += min(a[d], b[d]);\n return {dist, good};\n }\n\n Score score_current() {\n build_current_counts();\n return score_current_from_fh();\n }\n\n Score eval_add(const Line& ln) {\n uint64_t h = hash_line(ln);\n uint64_t negMask = splitmix64(h ^ 0x243f6a8885a308d3ULL);\n uint64_t posMask = splitmix64(h ^ 0x9e3779b97f4a7c15ULL);\n\n fh.reset();\n for (int i=0;i 0 ? posMask : negMask);\n fh.add(nk);\n }\n return score_current_from_fh();\n }\n\n void apply_add(const Line& ln) {\n uint64_t h = hash_line(ln);\n uint64_t negMask = splitmix64(h ^ 0x243f6a8885a308d3ULL);\n uint64_t posMask = splitmix64(h ^ 0x9e3779b97f4a7c15ULL);\n for (int i=0;i 0 ? posMask : negMask);\n }\n }\n\n // Try to sample an index with given region key (by rejection sampling).\n int sample_index_with_key(uint64_t k, RNG& rng) const {\n // Large regions (count > 10) => expected tries <= N/11 ~ 500 on worst N=5500 (still OK for occasional use).\n // We cap tries; fallback to random.\n for (int t=0; t<80; t++) {\n int i = rng.next_int(0, N-1);\n if (key[i] == k) return i;\n }\n return rng.next_int(0, N-1);\n }\n\n bool gen_candidate(Line& out, RNG& rng) {\n // mixture:\n // - 40%: uniform\n // - 30%: near random point\n // - 20%: bisector of two random points\n // - 10%: targeted split of an oversized region (count>10)\n for (int it=0; it<30; it++) {\n int mode = rng.next_int(0, 99);\n long double theta = rng.next_double(0.0, acosl(-1.0L));\n long double offset = 0;\n\n if (mode < 40) {\n offset = rng.next_double(-0.98*R, 0.98*R);\n } else if (mode < 70) {\n const auto& p = pts[rng.next_int(0, N-1)];\n long double nx = cos(theta), ny = sin(theta);\n long double base = nx * (long double)p.x + ny * (long double)p.y;\n offset = base + rng.next_double(-1200.0, 1200.0);\n offset = max(-0.98L*R, min(0.98L*R, offset));\n } else if (mode < 90) {\n const auto& p = pts[rng.next_int(0, N-1)];\n const auto& q = pts[rng.next_int(0, N-1)];\n long double dx = (long double)q.x - (long double)p.x;\n long double dy = (long double)q.y - (long double)p.y;\n long double len = sqrt(dx*dx + dy*dy);\n if (len < 1e-9) continue;\n long double nx = dx / len; // use segment direction as normal => perpendicular bisector\n long double ny = dy / len;\n theta = atan2(ny, nx);\n long double mx = 0.5L * ((long double)p.x + (long double)q.x);\n long double my = 0.5L * ((long double)p.y + (long double)q.y);\n offset = nx * mx + ny * my + rng.next_double(-600.0, 600.0);\n offset = max(-0.98L*R, min(0.98L*R, offset));\n } else {\n // targeted: split a large region\n if (largeKeys.empty()) continue;\n uint64_t k = largeKeys[rng.next_int(0, (int)largeKeys.size()-1)];\n int i = sample_index_with_key(k, rng);\n int j = sample_index_with_key(k, rng);\n if (i == j) continue;\n const auto& p = pts[i];\n const auto& q = pts[j];\n\n long double dx = (long double)q.x - (long double)p.x;\n long double dy = (long double)q.y - (long double)p.y;\n long double len = sqrt(dx*dx + dy*dy);\n if (len < 1e-9) continue;\n\n long double nx = dx / len;\n long double ny = dy / len;\n theta = atan2(ny, nx);\n long double mx = 0.5L * ((long double)p.x + (long double)q.x);\n long double my = 0.5L * ((long double)p.y + (long double)q.y);\n // smaller noise to actually split this region\n offset = nx * mx + ny * my + rng.next_double(-250.0, 250.0);\n offset = max(-0.98L*R, min(0.98L*R, offset));\n }\n\n Line ln = make_line_from_angle_offset(theta, offset);\n if (!is_valid_line(ln)) continue;\n if (!line_intersects_disk(ln, R)) continue;\n\n out = ln;\n return true;\n }\n return false;\n }\n\n vector run_one(RNG& rng, int kTarget, int candPerStep) {\n fill(key.begin(), key.end(), 0);\n vector lines;\n lines.reserve(kTarget);\n\n Score cur = score_current(); // also builds largeKeys\n Score bestPref = cur;\n int bestLen = 0;\n\n // SA schedule\n const double T0 = 2.0, T1 = 0.25;\n\n for (int step=0; step= 0) accept = true;\n else {\n double prob = exp(delta / max(1e-9, T));\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n lines.push_back(bestLn);\n apply_add(bestLn);\n // next iteration will rebuild counts anyway\n if (better(bestSc, bestPref)) {\n bestPref = bestSc;\n bestLen = (int)lines.size();\n if (bestPref.dist == totalA) break;\n }\n }\n }\n\n lines.resize(bestLen);\n return lines;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n cin >> N >> K;\n array a{};\n for (int d=1; d<=10; d++) cin >> a[d];\n vector pts(N);\n for (int i=0;i> pts[i].x >> pts[i].y;\n\n uint64_t seed = 123456789ULL;\n seed ^= splitmix64((uint64_t)N * 1009 + (uint64_t)K);\n for (int d=1; d<=10; d++) seed ^= splitmix64((uint64_t)a[d] * (d*10007ULL));\n for (int i=0;i bestLines;\n Score bestScore{-1, -1};\n\n for (int r=0; r\nusing namespace std;\n\nstruct Pt{ int x,y; };\nstatic inline int sgn(int a){ return (a>0) - (a<0); }\n\nstatic inline uint64_t rangeMask(int l, int r){\n if(l > r) return 0ULL;\n uint64_t len = (uint64_t)(r - l + 1);\n if(len >= 64) return ~0ULL;\n return ((1ULL << len) - 1ULL) << l;\n}\n\nstruct RunParams{\n int LIM; // candidates per line\n int nearCount; // how many from nearest extractor, rest from extremes\n long long perimPen; // penalty per step in evaluation\n bool diagEnable = true;\n};\n\nstruct Solver {\n int N, M;\n int c;\n vector> dot;\n vector rowMask, colMask;\n\n // used unit segments\n vector hUsed; // size N, bits 0..N-2\n vector vUsed; // size N, bits 0..N-2\n vector d1Used; // size N-1, bits 0..N-2\n vector d2Used; // size N-1, bits 0..N-2\n\n vector> W;\n long long sumW = 0;\n\n vector> ops;\n\n Solver(){}\n Solver(int N_, int M_): N(N_), M(M_) {\n c = (N-1)/2;\n dot.assign(N, vector(N,0));\n rowMask.assign(N,0);\n colMask.assign(N,0);\n\n hUsed.assign(N,0);\n vUsed.assign(N,0);\n d1Used.assign(max(0,N-1),0);\n d2Used.assign(max(0,N-1),0);\n\n W.assign(N, vector(N,1));\n for(int x=0;x gatherLine(uint64_t mask, int pos, int LIM, int nearCount) const {\n vector res;\n res.reserve(LIM);\n\n // remove pos itself if set (not needed but harmless)\n mask &= ~(1ULL<=0 && xr>=0){\n if(pos - xl <= xr - pos){\n res.push_back(xl);\n left &= ~(1ULL<=0){\n res.push_back(xl);\n left &= ~(1ULL<= dmn){\n res.push_back(mx);\n rem &= ~(1ULL< collectDiag(Pt p, int dx, int dy, int LIM) const {\n vector res;\n res.reserve(LIM);\n for(int step=1; (int)res.size()& bestOp) const {\n if(dot[p1.x][p1.y]) return false;\n\n vector xs = gatherLine(rowMask[p1.y], p1.x, par.LIM, par.nearCount);\n vector ys = gatherLine(colMask[p1.x], p1.y, par.LIM, par.nearCount);\n\n vector diagPlus, diagMinus;\n if(par.diagEnable){\n auto a = collectDiag(p1, 1, 1, par.LIM);\n auto b = collectDiag(p1, -1, -1, par.LIM);\n diagPlus.reserve(a.size()+b.size());\n diagPlus.insert(diagPlus.end(), a.begin(), a.end());\n diagPlus.insert(diagPlus.end(), b.begin(), b.end());\n\n auto c = collectDiag(p1, 1, -1, par.LIM);\n auto d = collectDiag(p1, -1, 1, par.LIM);\n diagMinus.reserve(c.size()+d.size());\n diagMinus.insert(diagMinus.end(), c.begin(), c.end());\n diagMinus.insert(diagMinus.end(), d.begin(), d.end());\n }\n\n bool found=false;\n long long bestVal=LLONG_MIN;\n\n auto consider = [&](Pt p2, Pt p3, Pt p4){\n if(!validRect(p1,p2,p3,p4)) return;\n int perim = edgeLen(p1,p2)+edgeLen(p2,p3)+edgeLen(p3,p4)+edgeLen(p4,p1);\n // weight-dominant but with adjustable perimeter penalty\n long long val = (long long)W[p1.x][p1.y] * 100000LL - (long long)perim * par.perimPen;\n // mild tie-breaker: prefer smaller perim if equal\n val = val * 1024LL - perim;\n if(val > bestVal){\n bestVal = val;\n bestOp = {p1.x,p1.y, p2.x,p2.y, p3.x,p3.y, p4.x,p4.y};\n found = true;\n }\n };\n\n // axis-aligned\n for(int x2: xs){\n Pt p2{x2, p1.y};\n for(int y4: ys){\n if(x2==p1.x || y4==p1.y) continue;\n Pt p4{p1.x, y4};\n Pt p3{x2, y4};\n if(!inside(p3.x,p3.y)) continue;\n if(!dot[p3.x][p3.y]) continue;\n consider(p2,p3,p4);\n }\n }\n\n // 45-degree\n if(par.diagEnable){\n for(const Pt& p2: diagPlus){\n for(const Pt& p4: diagMinus){\n Pt p3{p2.x + p4.x - p1.x, p2.y + p4.y - p1.y};\n if(!inside(p3.x,p3.y)) continue;\n if(!dot[p3.x][p3.y]) continue;\n consider(p2,p3,p4);\n }\n }\n }\n\n return found;\n }\n\n // One full greedy build (far-first scan repeatedly until stuck)\n void runGreedy(const RunParams& par, double timeLimitSec,\n const vector& farOrder,\n chrono::steady_clock::time_point startTime)\n {\n bool progressed=true;\n while(progressed){\n auto now = chrono::steady_clock::now();\n if(chrono::duration(now-startTime).count() > timeLimitSec) break;\n\n progressed=false;\n for(const Pt& p1: farOrder){\n now = chrono::steady_clock::now();\n if(chrono::duration(now-startTime).count() > timeLimitSec) break;\n if(dot[p1.x][p1.y]) continue;\n\n array op;\n if(!tryBestForP1(p1, par, op)) continue;\n Pt P1{op[0],op[1]}, P2{op[2],op[3]}, P3{op[4],op[5]}, P4{op[6],op[7]};\n // safety: should always be valid but keep assert-like guard\n if(!validRect(P1,P2,P3,P4)) continue;\n applyRect(P1,P2,P3,P4);\n progressed=true;\n }\n }\n }\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 Solver base(N,M);\n vector initDots;\n initDots.reserve(M);\n for(int i=0;i> x >> y;\n base.dot[x][y]=1;\n base.rowMask[y] |= (1ULL< farOrder;\n farOrder.reserve(N*N);\n for(int x=0;xwb;\n if(a.x!=b.x) return a.x params = {\n // close to original behavior but faster + broader candidates\n {8, 8, 0, true},\n {12, 8, 2000, true},\n {12, 8, 5000, true},\n {16, 10, 8000, true},\n // sometimes disabling diagonals reduces blocking in some seeds\n {12, 8, 2000, false},\n };\n\n auto start = chrono::steady_clock::now();\n const double TL = 4.90;\n\n long long bestSumW = -1;\n vector> bestOps;\n\n for(int i=0;i<(int)params.size();i++){\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now-start).count();\n if(elapsed > TL) break;\n\n // allocate remaining time roughly equally for remaining runs\n int remRuns = (int)params.size() - i;\n double perRunLimit = min(TL, elapsed + (TL - elapsed) * (1.0 / remRuns));\n // We give each run up to perRunLimit overall time checkpoint; the greedy stops on that.\n\n Solver s = base; // copy state\n s.runGreedy(params[i], perRunLimit, farOrder, start);\n\n if(s.sumW > bestSumW){\n bestSumW = s.sumW;\n bestOps = move(s.ops);\n }\n }\n\n cout << bestOps.size() << \"\\n\";\n for(auto &a: bestOps){\n for(int i=0;i<8;i++){\n if(i) cout << ' ';\n cout << a[i];\n }\n cout << \"\\n\";\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstatic constexpr int H = 10, W = 10, C = 100;\n\nstruct XorShift {\n uint64_t x;\n explicit XorShift(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline uint32_t nextU32() { return (uint32_t)(nextU64() >> 32); }\n};\n\nstruct State {\n // row-major idx=y*W+x, 0 empty, 1..3 flavors\n array a{};\n\n inline uint8_t at(int y, int x) const { return a[y * W + x]; }\n inline uint8_t& at(int y, int x) { return a[y * W + x]; }\n\n void clear() { a.fill(0); }\n\n void placeByP(int p, uint8_t f) {\n int cnt = 0;\n for (int i = 0; i < C; i++) {\n if (a[i] == 0) {\n cnt++;\n if (cnt == p) { a[i] = f; return; }\n }\n }\n }\n\n inline void tiltInPlace(char dir) {\n if (dir == 'L') {\n for (int y = 0; y < H; y++) {\n uint8_t tmp[W]; int k = 0;\n int base = y * W;\n for (int x = 0; x < W; x++) if (a[base + x]) tmp[k++] = a[base + x];\n for (int x = 0; x < W; x++) a[base + x] = 0;\n for (int x = 0; x < k; x++) a[base + x] = tmp[x];\n }\n } else if (dir == 'R') {\n for (int y = 0; y < H; y++) {\n uint8_t tmp[W]; int k = 0;\n int base = y * W;\n for (int x = 0; x < W; x++) if (a[base + x]) tmp[k++] = a[base + x];\n for (int x = 0; x < W; x++) a[base + x] = 0;\n for (int i = 0; i < k; i++) a[base + (W - k + i)] = tmp[i];\n }\n } else if (dir == 'F') { // to smaller y\n for (int x = 0; x < W; x++) {\n uint8_t tmp[H]; int k = 0;\n for (int y = 0; y < H; y++) {\n uint8_t v = a[y * W + x];\n if (v) tmp[k++] = v;\n }\n for (int y = 0; y < H; y++) a[y * W + x] = 0;\n for (int y = 0; y < k; y++) a[y * W + x] = tmp[y];\n }\n } else { // 'B' to larger y\n for (int x = 0; x < W; x++) {\n uint8_t tmp[H]; int k = 0;\n for (int y = 0; y < H; y++) {\n uint8_t v = a[y * W + x];\n if (v) tmp[k++] = v;\n }\n for (int y = 0; y < H; y++) a[y * W + x] = 0;\n for (int i = 0; i < k; i++) a[(H - k + i) * W + x] = tmp[i];\n }\n }\n }\n\n inline State afterTilt(char dir) const {\n State s = *this;\n s.tiltInPlace(dir);\n return s;\n }\n\n // Choose idx-th empty cell (0-indexed) in scan order, assume idx < #empties.\n inline int chooseEmptyByIndex(int idx) const {\n for (int i = 0; i < C; i++) {\n if (a[i] == 0) {\n if (idx == 0) return i;\n idx--;\n }\n }\n return -1; // should not happen\n }\n\n inline int emptyCount() const {\n int m = 0;\n for (int i = 0; i < C; i++) if (a[i] == 0) m++;\n return m;\n }\n};\n\nstatic inline int componentSumSq(const State& s) {\n bool vis[C];\n memset(vis, 0, sizeof(vis));\n int sumsq = 0;\n int q[C];\n\n for (int i = 0; i < C; i++) {\n if (s.a[i] == 0 || vis[i]) continue;\n uint8_t f = s.a[i];\n int head = 0, tail = 0;\n vis[i] = true;\n q[tail++] = i;\n int cnt = 0;\n while (head < tail) {\n int v = q[head++];\n cnt++;\n int y = v / W, x = v % W;\n if (y > 0) {\n int u = v - W;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (y + 1 < H) {\n int u = v + W;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (x > 0) {\n int u = v - 1;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (x + 1 < W) {\n int u = v + 1;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n }\n sumsq += cnt * cnt;\n }\n return sumsq;\n}\n\n// Cheap heuristic guiding rollouts (same family as the good 25.87M version)\nstruct CheapEval {\n double wAdj = 2.0;\n double wVar = 0.05;\n double wOrd = 8.0;\n double wSep = 0.4;\n\n double operator()(const State& s) const {\n int adjSame = 0;\n for (int y = 0; y < H; y++) for (int x = 0; x < W; x++) {\n uint8_t f = s.at(y, x);\n if (!f) continue;\n if (x + 1 < W && s.at(y, x + 1) == f) adjSame++;\n if (y + 1 < H && s.at(y + 1, x) == f) adjSame++;\n }\n\n double cnt[4] = {0,0,0,0};\n double sx[4] = {0,0,0,0}, sy[4] = {0,0,0,0};\n double sx2[4] = {0,0,0,0}, sy2[4] = {0,0,0,0};\n\n for (int y = 0; y < H; y++) for (int x = 0; x < W; x++) {\n uint8_t f = s.at(y, x);\n if (!f) continue;\n cnt[f] += 1.0;\n sx[f] += x; sy[f] += y;\n sx2[f] += 1.0 * x * x;\n sy2[f] += 1.0 * y * y;\n }\n\n double ax[4] = {0,0,0,0}, ay[4] = {0,0,0,0};\n for (int f = 1; f <= 3; f++) if (cnt[f] > 0) {\n ax[f] = sx[f] / cnt[f];\n ay[f] = sy[f] / cnt[f];\n }\n\n double varSum = 0.0;\n for (int f = 1; f <= 3; f++) if (cnt[f] > 0) {\n double ex = ax[f], ey = ay[f];\n varSum += (sx2[f] - cnt[f]*ex*ex) + (sy2[f] - cnt[f]*ey*ey);\n }\n\n // Order penalty: encourage ax[1] <= ax[2] <= ax[3] but softly; this is only for rollouts\n auto ordPenaltyPair = [&](int a, int b) -> double {\n if (cnt[a] == 0 || cnt[b] == 0) return 0.0;\n return max(0.0, ax[a] - ax[b]);\n };\n double ordPenalty = ordPenaltyPair(1,2) + ordPenaltyPair(2,3);\n\n double sep = 0.0;\n for (int i = 1; i <= 3; i++) for (int j = i+1; j <= 3; j++) {\n if (cnt[i] == 0 || cnt[j] == 0) continue;\n double dx = ax[i] - ax[j];\n double dy = ay[i] - ay[j];\n sep += dx*dx + dy*dy;\n }\n\n return wAdj * adjSame - wVar * varSum - wOrd * ordPenalty + wSep * sep;\n }\n};\n\n// Coupled rollout:\n// - For each future step k, we use rPos[k] to choose a uniform empty cell via idx=floor(u*m)\n// - and rAct[k] for epsilon-greedy noise.\n// This same (rPos,rAct) is reused across all 4 candidate first moves.\nstatic int rolloutCoupled(State s, int tNext, const array& f,\n const CheapEval& cev,\n const uint32_t* rPos, const uint32_t* rAct, int L) {\n static constexpr array DIRS = {'F','B','L','R'};\n constexpr uint32_t TH = (uint32_t)(0.06 * 4294967296.0); // EPS * 2^32\n\n for (int step = 0; step < L; step++) {\n int t = tNext + step;\n\n int m = s.emptyCount();\n if (m == 0) break;\n\n int idx = (int)(((uint64_t)rPos[step] * (uint64_t)m) >> 32); // in [0,m)\n int pos = s.chooseEmptyByIndex(idx);\n s.a[pos] = (uint8_t)f[t];\n\n // greedy tilt by cheap eval\n double bestV = -1e100, secondV = -1e100;\n char bestD = 'L', secondD = 'L';\n for (char d : DIRS) {\n State ns = s.afterTilt(d);\n double v = cev(ns);\n if (v > bestV) {\n secondV = bestV; secondD = bestD;\n bestV = v; bestD = d;\n } else if (v > secondV) {\n secondV = v; secondD = d;\n }\n }\n\n char chosen = bestD;\n if (rAct[step] < TH) {\n // occasionally choose second best (still \u201creasonable\u201d), helps escape deterministic traps\n chosen = secondD;\n }\n s.tiltInPlace(chosen);\n }\n return componentSumSq(s);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n array f{};\n for (int t = 1; t <= 100; t++) {\n if (!(cin >> f[t])) return 0;\n }\n\n // deterministic per-instance seed\n uint64_t seed = 1469598103934665603ULL;\n for (int t = 1; t <= 100; t++) seed = (seed ^ (uint64_t)f[t]) * 1099511628211ULL;\n XorShift rng(seed);\n\n State cur;\n cur.clear();\n CheapEval cev;\n static constexpr array DIRS = {'F','B','L','R'};\n\n auto timeStart = chrono::high_resolution_clock::now();\n const double TL = 1.95;\n\n // Buffers for coupled rollout randomness (max remaining steps = 99)\n uint32_t rPos[100], rAct[100];\n\n for (int t = 1; t <= 100; t++) {\n int p;\n cin >> p;\n\n cur.placeByP(p, (uint8_t)f[t]);\n\n // decide tilt\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - timeStart).count();\n double remaining = max(0.0, TL - elapsed);\n int stepsLeft = max(1, 101 - t);\n\n double alloc = remaining * 0.90 / stepsLeft;\n alloc = min(alloc, 0.060);\n alloc = max(alloc, 0.001);\n\n auto deadline = now + chrono::duration(alloc);\n\n array cand;\n array baseH{};\n for (int i = 0; i < 4; i++) {\n cand[i] = cur.afterTilt(DIRS[i]);\n baseH[i] = cev(cand[i]);\n }\n\n if (t == 100) {\n int bestI = 0;\n double bestScore = -1e100;\n for (int i = 0; i < 4; i++) {\n // final exact objective proxy; only once per action\n int cc = componentSumSq(cand[i]);\n double score = (double)cc + 0.2 * baseH[i];\n if (score > bestScore) bestScore = score, bestI = i;\n }\n char out = DIRS[bestI];\n cout << out << \"\\n\" << flush;\n cur = cand[bestI];\n continue;\n }\n\n array sum{};\n long long samples = 0;\n\n int L = 100 - t; // remaining candies count\n while (chrono::high_resolution_clock::now() < deadline) {\n // generate one coupled random stream\n for (int k = 0; k < L; k++) {\n rPos[k] = rng.nextU32();\n rAct[k] = rng.nextU32();\n }\n\n // evaluate all 4 actions on the same stream\n for (int i = 0; i < 4; i++) {\n int res = rolloutCoupled(cand[i], t + 1, f, cev, rPos, rAct, L);\n sum[i] += res;\n }\n samples++;\n }\n\n int bestI = 0;\n double bestScore = -1e100;\n for (int i = 0; i < 4; i++) {\n double mean = (samples ? (double)sum[i] / (double)samples : -1e100);\n // small stabilization using cheap heuristic only (don\u2019t override MC)\n double score = mean + 1.2 * baseH[i];\n if (score > bestScore) bestScore = score, bestI = i;\n }\n\n char out = DIRS[bestI];\n cout << out << \"\\n\" << flush;\n cur = cand[bestI];\n }\n\n return 0;\n}","ahc016":"#include \n#include \nusing namespace std;\n\nstruct Adj100 {\n array w{};\n};\n\nstatic inline void set_edge(vector& adj, int u, int v) {\n adj[u].w[v >> 6] |= 1ULL << (v & 63);\n adj[v].w[u >> 6] |= 1ULL << (u & 63);\n}\nstatic inline bool has_edge(const vector& adj, int u, int v) {\n return (adj[u].w[v >> 6] >> (v & 63)) & 1ULL;\n}\nstatic inline int popcnt2(const array& a) {\n return __builtin_popcountll(a[0]) + __builtin_popcountll(a[1]);\n}\nstatic inline int popcnt_and2(const array& a, const array& b) {\n return __builtin_popcountll(a[0] & b[0]) + __builtin_popcountll(a[1] & b[1]);\n}\n\nstatic vector string_to_adj(const string& s, int N) {\n vector adj(N);\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (s[idx++] == '1') set_edge(adj, i, j);\n }\n }\n return adj;\n}\nstatic string adj_to_string(const vector& adj, int N) {\n string s;\n s.reserve((size_t)N * (N - 1) / 2);\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++)\n s.push_back(has_edge(adj, i, j) ? '1' : '0');\n return s;\n}\n\nstruct AnalyzedCounts {\n long long m = 0;\n long long tri = 0;\n vector deg;\n};\n\nstatic AnalyzedCounts analyze_observed(const vector& adj, int N) {\n AnalyzedCounts res;\n res.deg.assign(N, 0);\n\n long long sum_deg = 0;\n for (int i = 0; i < N; i++) {\n int d = popcnt2(adj[i].w);\n res.deg[i] = d;\n sum_deg += d;\n }\n res.m = sum_deg / 2;\n\n long long sumCommon = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (has_edge(adj, i, j)) {\n sumCommon += popcnt_and2(adj[i].w, adj[j].w);\n }\n }\n }\n res.tri = sumCommon / 3;\n return res;\n}\n\n// Count triples by how many original edges among the 3 pairs (0..3)\nstatic void compute_triple_edge_histogram(\n const vector& adj, int N,\n long long &c0, long long &c1, long long &c2, long long &c3\n) {\n vector deg(N);\n for (int i = 0; i < N; i++) deg[i] = popcnt2(adj[i].w);\n\n vector triEdgeSum(N, 0);\n long long sumCommon = 0;\n\n for (int u = 0; u < N; u++) {\n for (int v = u + 1; v < N; v++) {\n if (!has_edge(adj, u, v)) continue;\n int common = popcnt_and2(adj[u].w, adj[v].w);\n sumCommon += common;\n triEdgeSum[u] += common;\n triEdgeSum[v] += common;\n }\n }\n c3 = sumCommon / 3;\n\n vector triInc(N, 0);\n for (int v = 0; v < N; v++) triInc[v] = triEdgeSum[v] / 2;\n\n c2 = 0;\n for (int v = 0; v < N; v++) {\n long long wedges = 1LL * deg[v] * (deg[v] - 1) / 2;\n c2 += (wedges - triInc[v]);\n }\n\n c1 = 0;\n for (int u = 0; u < N; u++) {\n for (int v = u + 1; v < N; v++) {\n if (!has_edge(adj, u, v)) continue;\n int common = popcnt_and2(adj[u].w, adj[v].w);\n c1 += (long long)N - deg[u] - deg[v] + common;\n }\n }\n\n long long totalTriples = 1LL * N * (N - 1) * (N - 2) / 6;\n c0 = totalTriples - c1 - c2 - c3;\n if (c0 < 0) c0 = 0;\n}\n\nstatic vector build_graph(int N, int hubSize, const vector& smallSizes, int mask) {\n vector adj(N);\n int B = (int)smallSizes.size();\n vector start(B+1, 0);\n start[0] = hubSize;\n for (int i = 0; i < B; i++) start[i+1] = start[i] + smallSizes[i];\n\n auto add_clique = [&](int L, int R) {\n for (int i = L; i < R; i++) for (int j = i + 1; j < R; j++) set_edge(adj, i, j);\n };\n\n add_clique(0, hubSize);\n for (int i = 0; i < B; i++) add_clique(start[i], start[i+1]);\n\n for (int i = 0; i < B; i++) if ((mask >> i) & 1) {\n for (int u = 0; u < hubSize; u++)\n for (int v = start[i]; v < start[i+1]; v++)\n set_edge(adj, u, v);\n }\n return adj;\n}\n\nstatic vector eigenvalues_symmetric(const Eigen::MatrixXd& M) {\n Eigen::SelfAdjointEigenSolver es(M, /* computeEigenvectors = */ false);\n Eigen::VectorXd ev = es.eigenvalues(); // ascending\n vector vals(ev.size());\n for (int i = 0; i < (int)ev.size(); i++) vals[i] = ev[i];\n return vals; // ascending\n}\n\nstruct Proto {\n vector mu_sorted_deg; // expected noisy sorted degrees\n double Em = 0.0;\n double Etri = 0.0;\n double VarTri = 1.0;\n vector eigA_asc; // eigenvalues of original adjacency (ascending)\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 // Revert to original, stronger public behavior\n int N;\n if (eps <= 0.15) N = 60;\n else if (eps <= 0.25) N = 80;\n else N = 100;\n\n vector smallSizes = {3,4,5,6,7,8,9}; // 7 bits\n int sumSmall = accumulate(smallSizes.begin(), smallSizes.end(), 0);\n int hubSize = N - sumSmall;\n if (hubSize < 4) { N = 100; hubSize = N - sumSmall; }\n\n const int B = (int)smallSizes.size();\n\n // constants\n const double p1 = 1.0 - eps;\n const double p0 = eps;\n const double scale = 1.0 - 2.0 * eps;\n const double degOffset = eps * (N - 1);\n const double sigma2_deg = (N - 1) * eps * (1.0 - eps) + 1e-9;\n const double Tedges = 1.0 * N * (N - 1) / 2.0;\n const double var_m = Tedges * eps * (1.0 - eps) + 1e-9;\n\n vector prot(M);\n\n cout << N << \"\\n\";\n for (int k = 0; k < M; k++) {\n auto G = build_graph(N, hubSize, smallSizes, k);\n cout << adj_to_string(G, N) << \"\\n\";\n\n // degrees\n vector deg0(N, 0);\n for (int v = 0; v < N; v++) deg0[v] = popcnt2(G[v].w);\n\n // expected noisy sorted degrees\n vector mu(N);\n for (int v = 0; v < N; v++) mu[v] = degOffset + scale * deg0[v];\n sort(mu.begin(), mu.end());\n prot[k].mu_sorted_deg = move(mu);\n\n // expected noisy edge count\n long long m0 = 0;\n for (int v = 0; v < N; v++) m0 += deg0[v];\n m0 /= 2;\n prot[k].Em = m0 * p1 + (Tedges - m0) * p0;\n\n // expected noisy triangle count\n long long c0, c1, c2, c3;\n compute_triple_edge_histogram(G, N, c0, c1, c2, c3);\n double eTri =\n c3 * (p1*p1*p1) +\n c2 * (p1*p1*p0) +\n c1 * (p1*p0*p0) +\n c0 * (p0*p0*p0);\n prot[k].Etri = eTri;\n\n double totalTriples = 1.0 * N * (N - 1) * (N - 2) / 6.0;\n double pbar = (totalTriples > 0 ? eTri / totalTriples : 0.0);\n pbar = min(1.0, max(0.0, pbar));\n prot[k].VarTri = totalTriples * pbar * (1.0 - pbar) + 1.0;\n\n // eigenvalues of original adjacency\n Eigen::MatrixXd A(N, N);\n A.setZero();\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (has_edge(G, i, j)) {\n A(i, j) = A(j, i) = 1.0;\n }\n }\n }\n prot[k].eigA_asc = eigenvalues_symmetric(A);\n }\n cout.flush();\n\n // spectral compare settings\n const int L = 8; // compare L smallest + L largest eigenvalues\n auto spectral_distance = [&](const vector& eigH_asc, const vector& eigA_asc) -> double {\n // both ascending, size N\n double dist = 0.0;\n for (int i = 0; i < L; i++) {\n double d = eigH_asc[i] - eigA_asc[i];\n dist += d * d;\n }\n for (int i = 0; i < L; i++) {\n int ih = (int)eigH_asc.size() - 1 - i;\n int ia = (int)eigA_asc.size() - 1 - i;\n double d = eigH_asc[ih] - eigA_asc[ia];\n dist += d * d;\n }\n return dist;\n };\n\n for (int q = 0; q < 100; q++) {\n string hs;\n cin >> hs;\n if (!cin) break;\n\n auto H = string_to_adj(hs, N);\n auto obs = analyze_observed(H, N);\n\n vector degSorted = obs.deg;\n sort(degSorted.begin(), degSorted.end());\n\n // Build centered matrix B for H and take eigenvalues\n Eigen::MatrixXd Bmat(N, N);\n Bmat.setZero();\n if (eps == 0.0) {\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++) {\n if (has_edge(H, i, j)) Bmat(i, j) = Bmat(j, i) = 1.0;\n }\n } else {\n double denom = 1.0 - 2.0 * eps; // >0 since eps<=0.4\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++) {\n double hij = has_edge(H, i, j) ? 1.0 : 0.0;\n double val = (hij - eps) / denom;\n Bmat(i, j) = Bmat(j, i) = val;\n }\n }\n vector eigH_asc = eigenvalues_symmetric(Bmat);\n\n // weights: put more emphasis on spectrum when eps is high\n double wDeg = 1.0;\n double wM = 0.30;\n double wTri = 0.10;\n double wEig = (eps >= 0.30 ? 0.10 : (eps >= 0.20 ? 0.06 : 0.03));\n\n int best = 0;\n double bestScore = 1e300;\n\n for (int k = 0; k < M; k++) {\n // degree SSE against expected noisy sorted degrees\n const auto &mu = prot[k].mu_sorted_deg;\n double sse = 0.0;\n for (int i = 0; i < N; i++) {\n double diff = (double)degSorted[i] - mu[i];\n sse += diff * diff;\n }\n double z_deg = sse / (sigma2_deg * N);\n\n // edge count term\n double dm = (double)obs.m - prot[k].Em;\n double z_m = (dm * dm) / var_m;\n\n // triangle term\n double dt = (double)obs.tri - prot[k].Etri;\n double z_t = (dt * dt) / prot[k].VarTri;\n\n // spectral term\n double z_e = spectral_distance(eigH_asc, prot[k].eigA_asc) / (double)(2 * L);\n\n double score = wDeg * z_deg + wM * z_m + wTri * z_t + wEig * z_e;\n\n if (score < bestScore) {\n bestScore = score;\n best = k;\n }\n }\n\n cout << best << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n int w;\n};\n\nstatic inline long long sqll(long long x) { return x * x; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n\n vector edges(M);\n vector>> g(N); // (to, edgeId)\n vector> gw(N); // weights aligned with g\n g.assign(N, {});\n gw.assign(N, {});\n\n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n edges[i] = {u, v, w};\n g[u].push_back({v, i});\n gw[u].push_back(w);\n g[v].push_back({u, i});\n gw[v].push_back(w);\n }\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937_64 rng(seed);\n\n const long long INF = (1LL<<62);\n\n // --- 1) Importance estimation (sampled Dijkstra + SPT subtree contribution) ---\n int S = min(36, N);\n vector sources(N);\n iota(sources.begin(), sources.end(), 0);\n shuffle(sources.begin(), sources.end(), rng);\n sources.resize(S);\n\n vector importance(M, 0);\n vector dist(N);\n vector parentV(N), parentE(N);\n vector order(N), subtree(N);\n\n for (int si = 0; si < S; si++) {\n int s = sources[si];\n fill(dist.begin(), dist.end(), INF);\n fill(parentV.begin(), parentV.end(), -1);\n fill(parentE.begin(), parentE.end(), -1);\n\n using P = pair;\n priority_queue, greater

> pq;\n dist[s] = 0;\n pq.push({0, s});\n\n while (!pq.empty()) {\n auto [dcur, v] = pq.top(); pq.pop();\n if (dcur != dist[v]) continue;\n for (int idx = 0; idx < (int)g[v].size(); idx++) {\n auto [to, eid] = g[v][idx];\n long long nd = dcur + gw[v][idx];\n if (nd < dist[to]) {\n dist[to] = nd;\n parentV[to] = v;\n parentE[to] = eid;\n pq.push({nd, to});\n }\n }\n }\n\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int a, int b){ return dist[a] > dist[b]; });\n\n fill(subtree.begin(), subtree.end(), 1);\n for (int v : order) {\n int p = parentV[v];\n if (p != -1) subtree[p] += subtree[v];\n }\n for (int v = 0; v < N; v++) {\n if (v == s) continue;\n int eid = parentE[v];\n if (eid < 0) continue;\n long long sz = subtree[v];\n importance[eid] += sz * (long long)(N - sz);\n }\n }\n\n long long totalImp = 0;\n for (auto x : importance) totalImp += x;\n long double impScale = (M > 0 ? (long double)totalImp / (long double)M : 1.0L);\n if (impScale < 1.0L) impScale = 1.0L;\n\n // Edge order by importance\n vector eorder(M);\n iota(eorder.begin(), eorder.end(), 0);\n sort(eorder.begin(), eorder.end(), [&](int a, int b){\n if (importance[a] != importance[b]) return importance[a] > importance[b];\n return edges[a].w > edges[b].w;\n });\n\n // --- 2) Conflict graph via replacement paths ---\n vector>> conf(M); // (otherEdge, weight)\n\n auto add_conf = [&](int a, int b, int w){\n if (a == b) return;\n for (auto &p : conf[a]) {\n if (p.first == b) { p.second = max(p.second, w); return; }\n }\n conf[a].push_back({b, w});\n };\n\n vector dist2(N);\n vector parV2(N), parE2(N);\n\n auto replacement_path_edges = [&](int s, int t, int bannedEid) -> pair> {\n fill(dist2.begin(), dist2.end(), INF);\n fill(parV2.begin(), parV2.end(), -1);\n fill(parE2.begin(), parE2.end(), -1);\n\n using P = pair;\n priority_queue, greater

> pq;\n dist2[s] = 0;\n pq.push({0, s});\n\n while (!pq.empty()) {\n auto [dcur, v] = pq.top(); pq.pop();\n if (dcur != dist2[v]) continue;\n if (v == t) break;\n for (int idx = 0; idx < (int)g[v].size(); idx++) {\n auto [to, eid] = g[v][idx];\n if (eid == bannedEid) continue;\n long long nd = dcur + gw[v][idx];\n if (nd < dist2[to]) {\n dist2[to] = nd;\n parV2[to] = v;\n parE2[to] = eid;\n pq.push({nd, to});\n }\n }\n }\n if (dist2[t] >= INF/4) return {INF, {}};\n\n vector pathE;\n int cur = t;\n while (cur != s) {\n int pe = parE2[cur];\n if (pe < 0) break;\n pathE.push_back(pe);\n cur = parV2[cur];\n }\n return {dist2[t], pathE};\n };\n\n int T = min(M, 900); // analyze more edges\n int L = 12; // take more strong edges from replacement path\n\n for (int idx = 0; idx < T; idx++) {\n int e = eorder[idx];\n int u = edges[e].u, v = edges[e].v;\n\n auto [repDist, pathE] = replacement_path_edges(u, v, e);\n if (pathE.empty() || repDist >= INF/4) continue;\n\n sort(pathE.begin(), pathE.end());\n pathE.erase(unique(pathE.begin(), pathE.end()), pathE.end());\n pathE.erase(remove(pathE.begin(), pathE.end(), e), pathE.end());\n if (pathE.empty()) continue;\n\n sort(pathE.begin(), pathE.end(), [&](int a, int b){\n return importance[a] > importance[b];\n });\n if ((int)pathE.size() > L) pathE.resize(L);\n\n long double stretch = (long double)repDist / (long double)max(1, edges[e].w);\n stretch = min(stretch, 10.0L);\n\n int base = (int)llround(80.0L * (long double)importance[e] / impScale); // stronger than before\n base = max(10, min(base, 600));\n int wconf = (int)llround((long double)base * stretch);\n wconf = max(10, min(wconf, 2500));\n\n for (int f : pathE) {\n add_conf(e, f, wconf);\n add_conf(f, e, wconf);\n }\n }\n\n // --- 3) Balanced targets ---\n vector target(D, M / D);\n for (int d = 0; d < (M % D); d++) target[d]++;\n\n // --- 4) Greedy initial assignment (importance + endpoint concentration + conflict) ---\n vector dayOfEdge(M, -1);\n vector> edgesInDay(D);\n for (int d = 0; d < D; d++) edgesInDay[d].reserve(target[d]);\n\n vector cnt(D, 0);\n vector daySumImp(D, 0);\n\n vector> inc(D, vector(N, 0));\n vector dayVertexPenalty(D, 0);\n\n auto deltaAddEdgeVP = [&](int d, int u, int v) -> long long {\n long long delta = 0;\n long long a = inc[d][u], b = a + 1;\n delta += b*b - a*a;\n a = inc[d][v], b = a + 1;\n delta += b*b - a*a;\n if (u == v) delta -= 1;\n return delta;\n };\n\n auto applyAddEdge = [&](int d, int eid) {\n int u = edges[eid].u, v = edges[eid].v;\n {\n long long a = inc[d][u], b = a + 1;\n dayVertexPenalty[d] += b*b - a*a;\n inc[d][u] = (int16_t)b;\n }\n {\n long long a = inc[d][v], b = a + 1;\n dayVertexPenalty[d] += b*b - a*a;\n inc[d][v] = (int16_t)b;\n }\n if (u == v) dayVertexPenalty[d] -= 1;\n daySumImp[d] += importance[eid];\n dayOfEdge[eid] = d;\n edgesInDay[d].push_back(eid);\n cnt[d]++;\n };\n\n auto conflictCostIfPut = [&](int eid, int d) -> long long {\n long long s = 0;\n for (auto [f, w] : conf[eid]) {\n int df = dayOfEdge[f];\n if (df == d) s += w;\n }\n return s;\n };\n\n const long double alphaVP = 0.7L * impScale;\n const long double betaCnt = 0.02L * impScale;\n const long double alphaConfGreedy = (long double)(impScale * 0.08L);\n\n for (int eid : eorder) {\n int u = edges[eid].u, v = edges[eid].v;\n int bestD = -1;\n long double bestCost = numeric_limits::infinity();\n\n for (int d = 0; d < D; d++) {\n if (cnt[d] >= target[d]) continue;\n long long dvp = deltaAddEdgeVP(d, u, v);\n long long cconf = conflictCostIfPut(eid, d);\n long double cost = (long double)daySumImp[d]\n + alphaVP * (long double)dvp\n + betaCnt * (long double)cnt[d]\n + alphaConfGreedy * (long double)cconf;\n if (cost < bestCost) {\n bestCost = cost;\n bestD = d;\n }\n }\n if (bestD < 0) bestD = 0;\n applyAddEdge(bestD, eid);\n }\n\n // positions for swap\n vector posInDay(M, -1);\n for (int d = 0; d < D; d++) {\n for (int i = 0; i < (int)edgesInDay[d].size(); i++) posInDay[edgesInDay[d][i]] = i;\n }\n\n // --- 5) SA swaps with correct conflict delta (directed conflict sum) ---\n auto makeChanges = [&](int eidRemove, int eidAdd) {\n array vs = {edges[eidRemove].u, edges[eidRemove].v, edges[eidAdd].u, edges[eidAdd].v};\n array ds = {-1, -1, +1, +1};\n vector> tmp;\n tmp.reserve(4);\n for (int i = 0; i < 4; i++) {\n int v = vs[i], del = ds[i];\n bool found = false;\n for (auto &p : tmp) if (p.first == v) { p.second += del; found = true; break; }\n if (!found) tmp.push_back({v, del});\n }\n vector> ch;\n ch.reserve(tmp.size());\n for (auto &p : tmp) if (p.second != 0) ch.push_back(p);\n return ch;\n };\n\n auto deltaVPForDay = [&](int d, const vector>& changes) -> long long {\n long long delta = 0;\n for (auto [v, del] : changes) {\n long long a = inc[d][v];\n long long b = a + del;\n delta += b*b - a*a;\n }\n return delta;\n };\n\n auto applyVPChanges = [&](int d, const vector>& changes) {\n long long delta = 0;\n for (auto [v, del] : changes) {\n long long a = inc[d][v];\n long long b = a + del;\n delta += b*b - a*a;\n inc[d][v] = (int16_t)b;\n }\n dayVertexPenalty[d] += delta;\n };\n\n // Directed conflict sum (easy correct deltas)\n long long totalConfDir = 0;\n for (int e = 0; e < M; e++) {\n int de = dayOfEdge[e];\n for (auto [f, w] : conf[e]) {\n if (dayOfEdge[f] == de) totalConfDir += w;\n }\n }\n\n auto deltaConfMoveDir = [&](int e, int oldDay, int newDay) -> long long {\n long long delta = 0;\n for (auto [f, w] : conf[e]) {\n int df = dayOfEdge[f];\n if (df == oldDay) delta -= w;\n if (df == newDay) delta += w;\n }\n return delta;\n };\n\n long long sumSqImp = 0;\n long long totalVP = 0;\n for (int d = 0; d < D; d++) {\n sumSqImp += sqll(daySumImp[d]);\n totalVP += dayVertexPenalty[d];\n }\n\n long double coeffVP = (long double)(impScale * impScale * 0.5L);\n long double coeffConf = (long double)(impScale * impScale * 0.012L); // directed; tuned a bit stronger\n\n auto objective = [&]() -> long double {\n return (long double)sumSqImp + coeffVP * (long double)totalVP + coeffConf * (long double)totalConfDir;\n };\n\n long double curObj = objective();\n\n auto startTime = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 5.85;\n uniform_real_distribution uni01(0.0, 1.0);\n\n long double T0 = max((long double)1.0, curObj * 1e-4L);\n long double T1 = max((long double)1e-3, curObj * 1e-7L);\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - startTime).count();\n if (elapsed > TIME_LIMIT) break;\n double tt = elapsed / TIME_LIMIT;\n long double T = T0 * pow((double)(T1 / T0), tt);\n\n int a = (int)(rng() % D);\n int b = (int)(rng() % (D - 1));\n if (b >= a) b++;\n if (edgesInDay[a].empty() || edgesInDay[b].empty()) continue;\n\n int ia = (int)(rng() % edgesInDay[a].size());\n int ib = (int)(rng() % edgesInDay[b].size());\n int e1 = edgesInDay[a][ia];\n int e2 = edgesInDay[b][ib];\n if (e1 == e2) continue;\n\n // importance balance term\n long long p1 = importance[e1], p2 = importance[e2];\n long long A = daySumImp[a], B = daySumImp[b];\n long long A2 = A - p1 + p2;\n long long B2 = B - p2 + p1;\n long long deltaSumSq = sqll(A2) + sqll(B2) - sqll(A) - sqll(B);\n\n // vertex concentration term\n auto chA = makeChanges(e1, e2);\n auto chB = makeChanges(e2, e1);\n long long deltaVP = deltaVPForDay(a, chA) + deltaVPForDay(b, chB);\n\n // conflict term (directed; correct)\n long long deltaConf = 0;\n deltaConf += deltaConfMoveDir(e1, a, b);\n deltaConf += deltaConfMoveDir(e2, b, a);\n\n long double deltaObj = (long double)deltaSumSq\n + coeffVP * (long double)deltaVP\n + coeffConf * (long double)deltaConf;\n\n bool accept = false;\n if (deltaObj <= 0) accept = true;\n else {\n long double prob = expl(-(double)(deltaObj / T));\n if (uni01(rng) < (double)prob) accept = true;\n }\n\n if (accept) {\n sumSqImp += deltaSumSq;\n daySumImp[a] = A2;\n daySumImp[b] = B2;\n\n totalVP += deltaVP;\n applyVPChanges(a, chA);\n applyVPChanges(b, chB);\n\n totalConfDir += deltaConf;\n\n // swap in day lists\n edgesInDay[a][ia] = e2;\n edgesInDay[b][ib] = e1;\n posInDay[e2] = ia;\n posInDay[e1] = ib;\n\n dayOfEdge[e1] = b;\n dayOfEdge[e2] = a;\n\n curObj += deltaObj;\n }\n }\n\n for (int i = 0; i < M; i++) {\n if (i) cout << ' ';\n cout << (dayOfEdge[i] + 1);\n }\n cout << '\\n';\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstatic inline int idx3(int D, int x, int y, int z) { return x * D * D + y * D + z; }\n\nstruct Stick {\n int axis; // 0=x,1=y,2=z\n int x, y, z; // start (min along axis)\n int cur;\n int rem;\n};\n\nstruct BuildResult {\n int n = 0;\n vector b1, b2;\n long double obj = 1e100L; // exact: r1+r2 + sum_{shared} 1/v\n};\n\nstatic inline void stick_cell(int D, const Stick& s, int offset, int &x, int &y, int &z) {\n x = s.x; y = s.y; z = s.z;\n if (s.axis == 0) x += offset;\n else if (s.axis == 1) y += offset;\n else z += offset;\n}\n\nstatic inline void cut_piece(int D, Stick& s, int L, vector& b, int blockId) {\n for (int t=0; t build_sticks(int D, const vector& occ, int axis) {\n vector sticks;\n if (axis == 0) { // x\n for (int y=0;y build_occ_full(int D, const vector& f, const vector& r) {\n vector occ(D*D*D, 0);\n for (int z=0; z build_occ_min(int D, const vector& f, const vector& r) {\n vector occ(D*D*D, 0);\n for (int z=0; z X, Y;\n for (int x=0; x= cy) {\n for (int t=0;t build_occ_star(int D, const vector& f, const vector& r) {\n int bestX=0, bestY=0, bestXcnt=-1, bestYcnt=-1;\n for (int x=0;xbestXcnt) bestXcnt=c, bestX=x;\n }\n for (int y=0;ybestYcnt) bestYcnt=c, bestY=y;\n }\n\n vector occ(D*D*D, 0);\n for (int z=0; z X, Y;\n for (int x=0;x get_Vmin_Vmax(int D, const vector& f, const vector& r) {\n int Vmin=0, Vmax=0;\n for (int z=0; z build_occ_target(int D,\n const vector& f,\n const vector& r,\n int consAxis, // 0 or 1\n int T) {\n vector> X(D), Y(D);\n vector minz(D), maxz(D);\n for (int z=0; z mz = minz;\n int E = T - Vmin;\n while (E > 0) {\n int best=-1, bestCap=0;\n for (int z=0; z bestCap) bestCap = cap, best = z;\n }\n if (bestCap == 0) break;\n int add = min(E, bestCap);\n mz[best] += add;\n E -= add;\n }\n\n vector occ(D*D*D, 0);\n vector> used(D, vector(D, 0));\n\n for (int z=0; z= cy) {\n for (int t=0;t build_occ_column(int D, const vector& f, const vector& r, int level) {\n vector> X(D), Y(D);\n for (int z=0; z> cnt(D, vector(D, 0));\n for (int z=0; z occ(D*D*D, 0);\n vector> used(D, vector(D, 0));\n\n for (int z=0; zint{\n int bestY = ys[0], bestW = -1;\n for (int y: ys) {\n int w = cnt[x][y];\n if (w > bestW) bestW = w, bestY = y;\n }\n return bestY;\n };\n auto best_x_for_y = [&](int y)->int{\n int bestX = xs[0], bestW = -1;\n for (int x: xs) {\n int w = cnt[x][y];\n if (w > bestW) bestW = w, bestX = x;\n }\n return bestX;\n };\n\n int placed = 0;\n vector covX(D,0), covY(D,0);\n\n if (cx >= cy) {\n // assign each x\n for (int x: xs) {\n int y = best_y_for_x(x);\n if (!used[x][y]) {\n used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++;\n }\n covX[x]=1; covY[y]=1;\n }\n // cover missing y\n for (int y: ys) if (!covY[y]) {\n int x = best_x_for_y(y);\n if (!used[x][y]) {\n used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++;\n }\n covY[y]=1;\n }\n } else {\n // assign each y\n for (int y: ys) {\n int x = best_x_for_y(y);\n if (!used[x][y]) {\n used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++;\n }\n covY[y]=1; covX[x]=1;\n }\n // cover missing x\n for (int x: xs) if (!covX[x]) {\n int y = best_y_for_x(x);\n if (!used[x][y]) {\n used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++;\n }\n covX[x]=1;\n }\n }\n\n // add extras by descending co-occurrence weight\n if (placed < target) {\n vector> pairs; // (w,x,y)\n pairs.reserve(cx*cy);\n for (int x: xs) for (int y: ys) pairs.emplace_back(cnt[x][y], x, y);\n sort(pairs.begin(), pairs.end(), [&](auto &a, auto &b){\n if (get<0>(a) != get<0>(b)) return get<0>(a) > get<0>(b);\n if (get<1>(a) != get<1>(b)) return get<1>(a) < get<1>(b);\n return get<2>(a) < get<2>(b);\n });\n for (auto &[w,x,y] : pairs) {\n if (placed >= target) break;\n if (used[x][y]) continue;\n used[x][y]=1;\n occ[idx3(D,x,y,z)] = 1;\n placed++;\n }\n }\n }\n\n return occ;\n}\n\n// ---------- exact evaluation from block volumes + usage ----------\nlong double eval_exact(int n, const vector& b1, const vector& b2) {\n vector u1(n+1, 0), u2(n+1, 0);\n int N = (int)b1.size();\n vector v1(n+1,0), v2(n+1,0);\n for (int i=0;i vol(n+1,0);\n for (int k=1;k<=n;k++) vol[k]=max(v1[k], v2[k]);\n\n long double r1=0, r2=0, sp=0;\n for (int k=1;k<=n;k++) {\n if (!u1[k]) r1 += vol[k];\n if (!u2[k]) r2 += vol[k];\n if (u1[k] && u2[k]) sp += 1.0L / (long double)vol[k];\n }\n return r1 + r2 + sp;\n}\n\n// ---------- sharing methods ----------\nint find_best_stick_lenmatch(const vector& sticks, int L) {\n int bestDiv=-1, best=-1;\n int bestDivLen=-1, bestLen=-1;\n for (int i=0;i<(int)sticks.size();i++) {\n const auto &s=sticks[i];\n if (s.rem < L) continue;\n if (s.rem % L == 0) {\n if (s.rem > bestDivLen) bestDivLen=s.rem, bestDiv=i;\n } else {\n if (s.rem > bestLen) bestLen=s.rem, best=i;\n }\n }\n return (bestDiv!=-1)?bestDiv:best;\n}\n\nBuildResult simulate_lenmatch(int D,\n const vector& occ1, const vector& occ2,\n int axis1, int axis2) {\n BuildResult res;\n res.b1.assign(D*D*D, 0);\n res.b2.assign(D*D*D, 0);\n\n vector s1=build_sticks(D, occ1, axis1);\n vector s2=build_sticks(D, occ2, axis2);\n\n int blockId=0;\n for (int L=D; L>=1; L--) {\n while (true) {\n int i1=find_best_stick_lenmatch(s1,L);\n int i2=find_best_stick_lenmatch(s2,L);\n if (i1<0 || i2<0) break;\n blockId++;\n cut_piece(D, s1[i1], L, res.b1, blockId);\n cut_piece(D, s2[i2], L, res.b2, blockId);\n }\n }\n for (auto &s: s1) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b1, blockId); }\n for (auto &s: s2) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b2, blockId); }\n\n res.n = blockId;\n res.obj = eval_exact(res.n, res.b1, res.b2);\n return res;\n}\n\nBuildResult simulate_pq(int D,\n const vector& occ1, const vector& occ2,\n int axis1, int axis2) {\n BuildResult res;\n res.b1.assign(D*D*D, 0);\n res.b2.assign(D*D*D, 0);\n\n vector s1=build_sticks(D, occ1, axis1);\n vector s2=build_sticks(D, occ2, axis2);\n\n priority_queue> pq1,pq2;\n for (int i=0;i<(int)s1.size();i++) if (s1[i].rem>0) pq1.push({s1[i].rem,i});\n for (int i=0;i<(int)s2.size();i++) if (s2[i].rem>0) pq2.push({s2[i].rem,i});\n\n auto pop_valid = [&](auto &pq, vector& ss)->int{\n while(!pq.empty()){\n auto [len,id]=pq.top();\n if (ss[id].rem!=len) { pq.pop(); continue; }\n return id;\n }\n return -1;\n };\n\n int blockId=0;\n while(true){\n int i1=pop_valid(pq1,s1);\n int i2=pop_valid(pq2,s2);\n if(i1<0||i2<0) break;\n int L=min(s1[i1].rem, s2[i2].rem);\n blockId++;\n cut_piece(D,s1[i1],L,res.b1,blockId);\n cut_piece(D,s2[i2],L,res.b2,blockId);\n pq1.pop(); pq2.pop();\n if(s1[i1].rem>0) pq1.push({s1[i1].rem,i1});\n if(s2[i2].rem>0) pq2.push({s2[i2].rem,i2});\n }\n for (auto &s: s1) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b1, blockId); }\n for (auto &s: s2) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b2, blockId); }\n\n res.n=blockId;\n res.obj=eval_exact(res.n,res.b1,res.b2);\n return res;\n}\n\nBuildResult simulate_mixed(int D,\n const vector& occ1, const vector& occ2,\n int axis1, int axis2) {\n BuildResult res;\n res.b1.assign(D*D*D, 0);\n res.b2.assign(D*D*D, 0);\n\n vector s1=build_sticks(D, occ1, axis1);\n vector s2=build_sticks(D, occ2, axis2);\n\n int blockId=0;\n for (int L=D; L>=2; L--) {\n while (true) {\n int i1=find_best_stick_lenmatch(s1,L);\n int i2=find_best_stick_lenmatch(s2,L);\n if (i1<0 || i2<0) break;\n blockId++;\n cut_piece(D, s1[i1], L, res.b1, blockId);\n cut_piece(D, s2[i2], L, res.b2, blockId);\n }\n }\n\n priority_queue> pq1,pq2;\n for (int i=0;i<(int)s1.size();i++) if (s1[i].rem>0) pq1.push({s1[i].rem,i});\n for (int i=0;i<(int)s2.size();i++) if (s2[i].rem>0) pq2.push({s2[i].rem,i});\n\n auto pop_valid = [&](auto &pq, vector& ss)->int{\n while(!pq.empty()){\n auto [len,id]=pq.top();\n if (ss[id].rem!=len) { pq.pop(); continue; }\n return id;\n }\n return -1;\n };\n\n while(true){\n int i1=pop_valid(pq1,s1);\n int i2=pop_valid(pq2,s2);\n if(i1<0||i2<0) break;\n int L=min(s1[i1].rem, s2[i2].rem);\n blockId++;\n cut_piece(D,s1[i1],L,res.b1,blockId);\n cut_piece(D,s2[i2],L,res.b2,blockId);\n pq1.pop(); pq2.pop();\n if(s1[i1].rem>0) pq1.push({s1[i1].rem,i1});\n if(s2[i2].rem>0) pq2.push({s2[i2].rem,i2});\n }\n\n for (auto &s: s1) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b1, blockId); }\n for (auto &s: s2) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b2, blockId); }\n\n res.n=blockId;\n res.obj=eval_exact(res.n,res.b1,res.b2);\n return res;\n}\n\n// ---------- main search ----------\nstruct OccVariant { vector occ; };\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D;\n cin >> D;\n vector> F(2, vector(D)), R(2, vector(D));\n for(int i=0;i<2;i++){\n for(int z=0;z> F[i][z];\n for(int z=0;z> R[i][z];\n }\n\n vector vars[2];\n\n for (int i=0;i<2;i++) {\n // Baselines\n vars[i].push_back({build_occ_full(D, F[i], R[i])});\n vars[i].push_back({build_occ_min(D, F[i], R[i])});\n vars[i].push_back({build_occ_star(D, F[i], R[i])});\n\n // New: column-reuse biased\n vars[i].push_back({build_occ_column(D, F[i], R[i], 0)}); // COLUMN_MIN\n vars[i].push_back({build_occ_column(D, F[i], R[i], 1)}); // COLUMN_MID\n\n // Target-fill variants (kept, but not dominant)\n auto [Vmin, Vmax] = get_Vmin_Vmax(D, F[i], R[i]);\n vector Ts = {Vmin, (Vmin+Vmax)/2, Vmax};\n sort(Ts.begin(), Ts.end());\n Ts.erase(unique(Ts.begin(), Ts.end()), Ts.end());\n for (int T: Ts) {\n for (int biasAxis : {0,1}) {\n vars[i].push_back({build_occ_target(D, F[i], R[i], biasAxis, T)});\n }\n }\n }\n\n vector axes = {0,1,2};\n BuildResult best;\n\n // Search (small enough)\n for (auto &v1 : vars[0]) for (auto &v2 : vars[1]) {\n for (int a1 : axes) for (int a2 : axes) {\n {\n auto res = simulate_lenmatch(D, v1.occ, v2.occ, a1, a2);\n if (res.obj < best.obj) best = std::move(res);\n }\n {\n auto res = simulate_mixed(D, v1.occ, v2.occ, a1, a2);\n if (res.obj < best.obj) best = std::move(res);\n }\n {\n auto res = simulate_pq(D, v1.occ, v2.occ, a1, a2);\n if (res.obj < best.obj) best = std::move(res);\n }\n }\n }\n\n cout << best.n << \"\\n\";\n for (int i=0;i\nusing namespace std;\n\nstatic const long long INFLL = (1LL << 60);\nstatic const int MAXP = 5000;\nstatic const int MAXD = 5001; // 0..5000 valid distances\n\nstruct Edge {\n int u, v;\n long long w;\n};\n\nstruct DSU {\n vector p, r;\n DSU(int n=0): p(n), r(n,0) { iota(p.begin(), p.end(), 0); }\n int find(int a){ return p[a]==a? a : p[a]=find(p[a]); }\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a]0 && (r-1)*(r-1) >= x) --r;\n if (r > MAXP) return MAXP+1;\n return (int)r;\n}\n\nstruct EvalResult {\n bool valid = false;\n long long S = INFLL;\n vector P; // N\n vector B; // M\n vector cnt; // N\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K;\n cin >> N >> M >> K;\n\n vector x(N), y(N);\n for (int i = 0; i < N; i++) cin >> x[i] >> y[i];\n\n vector edges(M);\n\n vector> dist(N, vector(N, INFLL));\n vector> nxt(N, vector(N, -1));\n vector> edgeId(N, vector(N, -1));\n for (int i = 0; i < N; i++) {\n dist[i][i] = 0;\n nxt[i][i] = i;\n }\n\n for (int j = 0; j < M; j++) {\n int u, v; long long w;\n cin >> u >> v >> w;\n --u; --v;\n edges[j] = {u, v, w};\n if (w < dist[u][v]) {\n dist[u][v] = dist[v][u] = w;\n nxt[u][v] = v;\n nxt[v][u] = u;\n edgeId[u][v] = edgeId[v][u] = j;\n }\n }\n\n vector a(K), b(K);\n for (int k = 0; k < K; k++) cin >> a[k] >> b[k];\n\n // resident -> station distance (ceil euclid), clipped to 5001 for \"too far\"\n vector> d(K);\n for (int k = 0; k < K; k++) {\n for (int i = 0; i < N; i++) {\n long long dx = (long long)a[k] - x[i];\n long long dy = (long long)b[k] - y[i];\n long long dsq = dx*dx + dy*dy;\n int cd = ceil_sqrt_ll(dsq);\n if (cd > MAXP) cd = MAXP+1;\n d[k][i] = (uint16_t)cd;\n }\n }\n\n // Candidate stations per resident (within 5000), sorted by distance\n vector>> cand(K);\n for (int k = 0; k < K; k++) {\n vector> v;\n v.reserve(N);\n for (int i = 0; i < N; i++) {\n int di = (int)d[k][i];\n if (di <= MAXP) v.push_back({di, i});\n }\n sort(v.begin(), v.end());\n cand[k] = std::move(v);\n }\n\n // Floyd-Warshall + next matrix\n for (int k = 0; k < N; k++) {\n for (int i = 0; i < N; i++) if (dist[i][k] < INFLL) {\n for (int j = 0; j < N; j++) if (dist[k][j] < INFLL) {\n long long nd = dist[i][k] + dist[k][j];\n if (nd < dist[i][j]) {\n dist[i][j] = nd;\n nxt[i][j] = nxt[i][k];\n }\n }\n }\n }\n vector distRoot(N);\n for (int i = 0; i < N; i++) distRoot[i] = dist[0][i];\n\n auto reconstruct_path_edges = [&](int s, int t, vector& mark) {\n int cur = s;\n while (cur != t) {\n int nx = nxt[cur][t];\n if (nx < 0) return;\n int eid = edgeId[cur][nx];\n if (eid >= 0) mark[eid] = 1;\n cur = nx;\n }\n };\n\n // Precompute global MST of original graph (for candidate #3)\n vector mstEdges;\n {\n vector ids(M);\n iota(ids.begin(), ids.end(), 0);\n sort(ids.begin(), ids.end(), [&](int i, int j){ return edges[i].w < edges[j].w; });\n DSU dsu(N);\n for (int id : ids) {\n if (dsu.unite(edges[id].u, edges[id].v)) mstEdges.push_back(id);\n if ((int)mstEdges.size() == N-1) break;\n }\n }\n vector isMst(M, 0);\n for (int id : mstEdges) isMst[id] = 1;\n\n // Prune non-terminal leaves in a forest, then keep only root component. Return cost and B.\n auto prune_and_root = [&](vector alive, const vector& terminal) -> pair, long long> {\n vector>> g(N);\n vector deg(N, 0);\n for (int id = 0; id < M; id++) if (alive[id]) {\n int u = edges[id].u, v = edges[id].v;\n g[u].push_back({v, id});\n g[v].push_back({u, id});\n deg[u]++; deg[v]++;\n }\n\n deque q;\n vector inq(N, 0);\n for (int i = 0; i < N; i++) if (!terminal[i] && deg[i] <= 1) {\n q.push_back(i); inq[i] = 1;\n }\n auto remove_edge = [&](int v, int to, int eid) {\n if (!alive[eid]) return;\n alive[eid] = 0;\n deg[v]--; deg[to]--;\n if (!terminal[to] && deg[to] <= 1 && !inq[to]) { q.push_back(to); inq[to] = 1; }\n };\n while (!q.empty()) {\n int v = q.front(); q.pop_front();\n if (terminal[v]) continue;\n if (deg[v] != 1) continue;\n for (auto [to, eid] : g[v]) if (alive[eid]) { remove_edge(v, to, eid); break; }\n }\n\n // keep only root component\n vector vis(N, 0);\n deque bfs;\n vis[0] = 1;\n bfs.push_back(0);\n while (!bfs.empty()) {\n int v = bfs.front(); bfs.pop_front();\n for (auto [to, eid] : g[v]) if (alive[eid] && !vis[to]) {\n vis[to] = 1;\n bfs.push_back(to);\n }\n }\n for (int id = 0; id < M; id++) if (alive[id]) {\n if (!vis[edges[id].u] || !vis[edges[id].v]) alive[id] = 0;\n }\n\n long long cost = 0;\n vector B(M, 0);\n for (int id = 0; id < M; id++) if (alive[id]) {\n B[id] = 1;\n cost += edges[id].w;\n }\n return {B, cost};\n };\n\n // For marked edge set, remove cycles by Kruskal (min spanning forest), then prune.\n auto kruskal_then_prune = [&](const vector& marked, const vector& terminal) -> pair, long long> {\n vector ids;\n ids.reserve(M);\n for (int id = 0; id < M; id++) if (marked[id]) ids.push_back(id);\n sort(ids.begin(), ids.end(), [&](int a, int b){ return edges[a].w < edges[b].w; });\n\n DSU dsu(N);\n vector alive(M, 0);\n for (int id : ids) if (dsu.unite(edges[id].u, edges[id].v)) alive[id] = 1;\n\n return prune_and_root(std::move(alive), terminal);\n };\n\n // Build cable set from P: try multiple constructions and take best.\n auto build_cables = [&](const vector& P) -> pair, long long> {\n vector terminal(N, 0);\n terminal[0] = 1;\n vector terms;\n terms.reserve(N);\n terms.push_back(0);\n for (int i = 1; i < N; i++) if (P[i] > 0) {\n terminal[i] = 1;\n terms.push_back(i);\n }\n\n pair, long long> best = {vector(M, 0), INFLL};\n\n // Candidate #1: KMB (metric MST on terminals, expand paths)\n {\n int T = (int)terms.size();\n vector bestd(T, INFLL);\n vector parent(T, -1);\n vector used(T, 0);\n bestd[0] = 0;\n\n bool ok = true;\n for (int it = 0; it < T; it++) {\n int v = -1;\n for (int i = 0; i < T; i++) if (!used[i]) {\n if (v < 0 || bestd[i] < bestd[v]) v = i;\n }\n if (v < 0 || bestd[v] >= INFLL/2) { ok = false; break; }\n used[v] = 1;\n int vv = terms[v];\n for (int i = 0; i < T; i++) if (!used[i]) {\n int uu = terms[i];\n long long w = dist[vv][uu];\n if (w < bestd[i]) { bestd[i] = w; parent[i] = v; }\n }\n }\n\n if (ok) {\n vector mark(M, 0);\n for (int i = 1; i < T; i++) {\n int u = terms[i];\n int p = terms[parent[i]];\n reconstruct_path_edges(u, p, mark);\n }\n auto cand1 = kruskal_then_prune(mark, terminal);\n if (cand1.second < best.second) best = std::move(cand1);\n }\n }\n\n // Candidate #2: union of shortest paths from root to each terminal, then prune\n {\n vector mark(M, 0);\n for (int i = 0; i < (int)terms.size(); i++) {\n int t = terms[i];\n reconstruct_path_edges(0, t, mark);\n }\n auto cand2 = kruskal_then_prune(mark, terminal);\n if (cand2.second < best.second) best = std::move(cand2);\n }\n\n // Candidate #3: subtree of global MST connecting terminals\n {\n vector alive = isMst;\n auto cand3 = prune_and_root(std::move(alive), terminal);\n if (cand3.second < best.second) best = std::move(cand3);\n }\n\n return best;\n };\n\n auto t_start = chrono::steady_clock::now();\n auto elapsed_ms = [&]() -> long long {\n return chrono::duration_cast(chrono::steady_clock::now() - t_start).count();\n };\n\n std::mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n // Evaluate: greedy marginal assignment + local reassignment (hill-climb) passes.\n auto evaluate = [&](const vector& U, int trials, bool shuffleResOrder, int improvePasses) -> EvalResult {\n EvalResult best;\n best.valid = false;\n best.S = INFLL;\n\n vector order(K);\n iota(order.begin(), order.end(), 0);\n\n // penalty for opening a station (to discourage too many terminals -> cable cost)\n const double openGamma = 0.22;\n\n for (int tr = 0; tr < trials; tr++) {\n if (shuffleResOrder || tr > 0) shuffle(order.begin(), order.end(), rng);\n\n vector P(N, 0), cnt(N, 0);\n vector assign(K, -1), adist(K, 0);\n\n // greedy marginal assignment\n bool ok = true;\n for (int idx = 0; idx < K; idx++) {\n int k = order[idx];\n long long bestDelta = INFLL;\n int besti = -1, bestNewP = 0, bestDi = 0;\n\n for (auto [di, i] : cand[k]) {\n if (!U[i]) continue;\n int pi = P[i];\n int newp = (pi >= di) ? pi : di;\n long long delta = 1LL*newp*newp - 1LL*pi*pi;\n if (i != 0 && cnt[i] == 0 && pi == 0) {\n delta += (long long) llround(openGamma * (long double)distRoot[i]);\n }\n if (delta < bestDelta) {\n bestDelta = delta;\n besti = i;\n bestNewP = newp;\n bestDi = di;\n }\n }\n if (besti < 0) { ok = false; break; }\n assign[k] = besti;\n adist[k] = bestDi;\n if (bestNewP > P[besti]) P[besti] = bestNewP;\n cnt[besti]++;\n }\n if (!ok) continue;\n\n // local reassignment improvement\n if (improvePasses > 0) {\n vector counts(N * (MAXD+1), 0);\n auto idxc = [&](int s, int distv){ return s*(MAXD+1) + distv; };\n\n for (int k = 0; k < K; k++) counts[idxc(assign[k], adist[k])]++;\n\n auto recompute_max_down = [&](int s, int start)->int{\n for (int dd = start; dd >= 1; dd--) if (counts[idxc(s, dd)] > 0) return dd;\n return 0;\n };\n\n for (int s = 0; s < N; s++) {\n if (cnt[s] == 0) P[s] = 0;\n else P[s] = recompute_max_down(s, P[s]);\n }\n\n vector resOrder(K);\n iota(resOrder.begin(), resOrder.end(), 0);\n\n for (int pass = 0; pass < improvePasses; pass++) {\n shuffle(resOrder.begin(), resOrder.end(), rng);\n bool any = false;\n\n for (int k : resOrder) {\n int s = assign[k];\n int ds = adist[k];\n int Ps = P[s];\n\n auto Ps_after_remove = [&]()->int{\n if (cnt[s] == 1) return 0;\n if (ds < Ps) return Ps;\n if (counts[idxc(s, Ps)] >= 2) return Ps;\n return recompute_max_down(s, Ps-1);\n };\n int PsRem = Ps_after_remove();\n\n long long bestDelta = 0;\n int bestT = -1, bestDt = 0;\n\n for (auto [dt, t] : cand[k]) {\n if (!U[t] || t == s) continue;\n int Pt = P[t];\n int PtAdd = max(Pt, dt);\n long long delta = 1LL*PsRem*PsRem + 1LL*PtAdd*PtAdd\n - 1LL*Ps*Ps - 1LL*Pt*Pt;\n if (delta < bestDelta) {\n bestDelta = delta;\n bestT = t;\n bestDt = dt;\n }\n }\n\n if (bestT >= 0) {\n int t = bestT, dt = bestDt;\n\n counts[idxc(s, ds)]--;\n counts[idxc(t, dt)]++;\n\n cnt[s]--;\n cnt[t]++;\n\n if (cnt[s] == 0) P[s] = 0;\n else {\n int old = P[s];\n if (ds == old && counts[idxc(s, old)] == 0) {\n P[s] = recompute_max_down(s, old-1);\n }\n }\n if (dt > P[t]) P[t] = dt;\n\n assign[k] = t;\n adist[k] = dt;\n\n any = true;\n }\n }\n if (!any) break;\n }\n }\n\n long long radCost = 0;\n for (int i = 0; i < N; i++) radCost += 1LL*P[i]*P[i];\n\n auto [B, edgeCost] = build_cables(P);\n if (edgeCost >= INFLL/2) continue;\n\n long long S = radCost + edgeCost;\n if (S < best.S) {\n best.valid = true;\n best.S = S;\n best.P = std::move(P);\n best.B = std::move(B);\n best.cnt = std::move(cnt);\n }\n }\n return best;\n };\n\n EvalResult bestGlobal;\n bestGlobal.valid = false;\n bestGlobal.S = INFLL;\n\n // Search: SA on U using fast eval, then finalize with stronger eval.\n int outerRestarts = 3;\n for (int rep = 0; rep < outerRestarts && elapsed_ms() < 1850; rep++) {\n vector U(N, 1);\n U[0] = 1;\n\n EvalResult cur = evaluate(U, /*trials=*/1, /*shuffle=*/true, /*improvePasses=*/0);\n if (!cur.valid) continue;\n\n vector bestU = U;\n long long bestS = cur.S;\n\n const int SA_IT = 320;\n double T0 = 7e7, T1 = 6e5;\n\n for (int it = 0; it < SA_IT && elapsed_ms() < 1650; it++) {\n double tt = (double)it / max(1, SA_IT-1);\n double T = T0 * (1.0 - tt) + T1 * tt;\n\n int v = uniform_int_distribution(1, N-1)(rng);\n U[v] ^= 1;\n\n EvalResult nxt = evaluate(U, /*trials=*/1, /*shuffle=*/true, /*improvePasses=*/0);\n if (!nxt.valid) { U[v] ^= 1; continue; }\n\n long long diff = nxt.S - cur.S;\n bool accept = false;\n if (diff <= 0) accept = true;\n else {\n double prob = exp(-(double)diff / T);\n double r = uniform_real_distribution(0.0, 1.0)(rng);\n accept = (r < prob);\n }\n\n if (accept) {\n cur = std::move(nxt);\n if (cur.S < bestS) { bestS = cur.S; bestU = U; }\n } else {\n U[v] ^= 1;\n }\n }\n\n // Finalize bestU with stronger assignment + local improvement\n EvalResult fin = evaluate(bestU, /*trials=*/3, /*shuffle=*/true, /*improvePasses=*/4);\n if (fin.valid && fin.S < bestGlobal.S) bestGlobal = std::move(fin);\n\n // Greedy removals with improved eval\n if (elapsed_ms() < 1900) {\n vector U2 = bestU;\n EvalResult base = evaluate(U2, 1, true, 3);\n if (base.valid) {\n bool improved = true;\n while (improved && elapsed_ms() < 1900) {\n improved = false;\n vector candStations;\n for (int i = 1; i < N; i++) if (U2[i]) candStations.push_back(i);\n\n sort(candStations.begin(), candStations.end(), [&](int a, int b){\n if (base.cnt[a] != base.cnt[b]) return base.cnt[a] < base.cnt[b];\n if (base.P[a] != base.P[b]) return base.P[a] < base.P[b];\n return distRoot[a] > distRoot[b];\n });\n\n for (int v : candStations) {\n if (elapsed_ms() > 1900) break;\n U2[v] = 0;\n EvalResult nxt = evaluate(U2, 1, true, 3);\n if (nxt.valid && nxt.S < base.S) {\n base = std::move(nxt);\n improved = true;\n break;\n } else {\n U2[v] = 1;\n }\n }\n }\n if (base.valid && base.S < bestGlobal.S) bestGlobal = std::move(base);\n }\n }\n }\n\n if (!bestGlobal.valid) {\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << 0;\n }\n cout << \"\\n\";\n for (int j = 0; j < M; j++) {\n if (j) cout << ' ';\n cout << 0;\n }\n cout << \"\\n\";\n return 0;\n }\n\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << bestGlobal.P[i];\n }\n cout << \"\\n\";\n for (int j = 0; j < M; j++) {\n if (j) cout << ' ';\n cout << bestGlobal.B[j];\n }\n cout << \"\\n\";\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nstruct Op { int x1,y1,x2,y2; };\n\nstatic constexpr int N = 30;\nstatic constexpr int M = N*(N+1)/2;\n\nenum class UpPolicy {\n LargerParent,\n SmallerParent,\n RandomParent\n};\n\nstruct Result {\n vector ops;\n int K() const { return (int)ops.size(); }\n};\n\nstruct Runner {\n vector> initb;\n\n Runner(const vector>& b): initb(b) {}\n\n Result run(int L, UpPolicy policy, uint64_t seed) {\n vector> b = initb;\n vector> pos(M);\n for (int x = 0; x < N; x++) for (int y = 0; y <= x; y++) pos[b[x][y]] = {x,y};\n\n vector ops;\n ops.reserve(6000);\n\n std::mt19937_64 rng(seed);\n\n auto do_swap = [&](int x1,int y1,int x2,int y2){\n int v1 = b[x1][y1], v2 = b[x2][y2];\n swap(b[x1][y1], b[x2][y2]);\n pos[v1] = {x2,y2};\n pos[v2] = {x1,y1};\n\n // cancellation: if we swapped the same edge twice in a row, remove both.\n if (!ops.empty()) {\n auto &p = ops.back();\n bool same_dir = (p.x1==x1 && p.y1==y1 && p.x2==x2 && p.y2==y2);\n bool opp_dir = (p.x1==x2 && p.y1==y2 && p.x2==x1 && p.y2==y1);\n if (same_dir || opp_dir) {\n ops.pop_back();\n return;\n }\n }\n ops.push_back({x1,y1,x2,y2});\n };\n\n auto can_more = [&](){ return (int)ops.size() < 10000; };\n\n // Phase 1: bubble up small values\n L = min(L, M);\n for (int v = 0; v < L && can_more(); v++) {\n while (can_more()) {\n auto [x,y] = pos[v];\n if (x == 0) break;\n\n int cur = b[x][y];\n vector> cand; // parents that are larger than cur\n if (y-1 >= 0 && b[x-1][y-1] > cur) cand.push_back({x-1,y-1});\n if (y <= x-1 && b[x-1][y] > cur) cand.push_back({x-1,y});\n\n if (cand.empty()) break;\n\n pair pick = cand[0];\n if (cand.size() == 2) {\n auto p0 = cand[0], p1 = cand[1];\n int a = b[p0.first][p0.second];\n int c = b[p1.first][p1.second];\n if (policy == UpPolicy::LargerParent) {\n pick = (a > c ? p0 : p1);\n } else if (policy == UpPolicy::SmallerParent) {\n pick = (a < c ? p0 : p1);\n } else { // random\n pick = cand[(rng() & 1ULL)];\n }\n }\n\n do_swap(x,y,pick.first,pick.second);\n }\n }\n\n // Phase 2: Floyd heapify (bottom-up sift-down) to guarantee E=0\n auto siftDown = [&](int sx, int sy){\n int x = sx, y = sy;\n while (can_more() && x < N-1) {\n int lx = x+1, ly = y;\n int rx = x+1, ry = y+1;\n\n int bestx = x, besty = y;\n if (b[lx][ly] < b[bestx][besty]) { bestx = lx; besty = ly; }\n if (b[rx][ry] < b[bestx][besty]) { bestx = rx; besty = ry; }\n\n if (bestx == x && besty == y) break;\n do_swap(x,y,bestx,besty);\n x = bestx; y = besty;\n }\n };\n\n for (int x = N-2; x >= 0 && can_more(); x--) {\n for (int y = 0; y <= x && can_more(); y++) {\n siftDown(x,y);\n }\n }\n\n return Result{ops};\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector> b(N, vector(N, -1));\n for (int x = 0; x < N; x++) for (int y = 0; y <= x; y++) cin >> b[x][y];\n\n Runner runner(b);\n\n // Deterministic seed from input (so results are reproducible per instance)\n uint64_t h = 1469598103934665603ULL;\n for (int x = 0; x < N; x++) for (int y = 0; y <= x; y++) {\n h ^= (uint64_t)b[x][y] + 0x9e3779b97f4a7c15ULL + (h<<6) + (h>>2);\n }\n\n Result best;\n best.ops.assign(10001, Op{0,0,0,0}); // large placeholder\n int bestK = 10001;\n\n // A few fixed candidates first (fast baseline coverage)\n vector baseL = {0, 20, 40, 60, 80, 100, 120, 150, 180, 210, 240};\n vector policies = {UpPolicy::LargerParent, UpPolicy::SmallerParent, UpPolicy::RandomParent};\n\n for (int L : baseL) for (auto pol : policies) {\n Result r = runner.run(L, pol, h ^ (uint64_t)L * 10007ULL);\n if (r.K() < bestK) { bestK = r.K(); best = std::move(r); }\n }\n\n // Time-bounded random exploration of (L, policy)\n auto start = chrono::high_resolution_clock::now();\n mt19937_64 rng(h ^ 0x1234567890abcdefULL);\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double ms = chrono::duration(now - start).count();\n if (ms > 1900.0) break; // keep margin for output\n\n int L = (int)(rng() % 261); // 0..260\n UpPolicy pol = policies[(size_t)(rng() % policies.size())];\n Result r = runner.run(L, pol, rng());\n if (r.K() < bestK) { bestK = r.K(); best = std::move(r); }\n }\n\n cout << bestK << \"\\n\";\n for (auto &op : best.ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nstatic constexpr int D = 9;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n uint32_t next_u32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n int next_int(int n) { return (int)(next_u32() % (uint32_t)n); }\n};\n\nstruct Cell { int r, c; };\n\n// Fenwick for n<=80 with fixed storage (cheap copy).\nstruct FenwickFixed {\n int n = 0;\n array bit{};\n FenwickFixed(int n_=0): n(n_) { bit.fill(0); }\n void reset(int n_) { n=n_; bit.fill(0); }\n void add(int i, int v) { // 0-indexed\n for (i++; i <= n; i += i & -i) bit[i] += v;\n }\n int sumPrefix(int i) const { // sum [0..i), i in [0..n]\n int s = 0;\n for (; i > 0; i -= i & -i) s += bit[i];\n return s;\n }\n int sumLess(int x) const { // count of < x\n return sumPrefix(x);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Din, N;\n cin >> Din >> N;\n int ent_r = 0, ent_c = (D - 1) / 2;\n\n bool obstacle[D][D]{};\n for (int k = 0; k < N; k++) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n }\n\n int M = D * D - 1 - N; // labels 0..M-1\n\n int dr[4] = {1,-1,0,0};\n int dc[4] = {0,0,1,-1};\n\n auto idx = [&](int r, int c){ return r*D + c; };\n auto rc = [&](int id)->Cell{ return {id/D, id%D}; };\n\n // Static BFS distance (obstacles only).\n const int INF = 1e9;\n int dist0[D][D];\n for(int i=0;i q;\n dist0[ent_r][ent_c]=0;\n q.push({ent_r, ent_c});\n while(!q.empty()){\n auto [r,c]=q.front(); q.pop();\n for(int k=0;k<4;k++){\n int nr=r+dr[k], nc=c+dc[k];\n if(nr<0||nr>=D||nc<0||nc>=D) continue;\n if(obstacle[nr][nc]) continue;\n if(dist0[nr][nc]!=INF) continue;\n dist0[nr][nc]=dist0[r][c]+1;\n q.push({nr,nc});\n }\n }\n\n // distance rank (near -> far)\n vector usable;\n usable.reserve(M);\n for(int i=0;i nodes;\n nodes.reserve(81);\n for(int i=0;i> art(D, vector(D,0));\n int root = id[ent_r][ent_c];\n if(root<0) return art;\n\n int V = (int)nodes.size();\n vector disc(V,0), low(V,0), parent(V,-1);\n vector isArt(V,0);\n int timer=0;\n\n function dfs = [&](int u){\n disc[u]=low[u]=++timer;\n int children=0;\n auto [r,c]=nodes[u];\n for(int k=0;k<4;k++){\n int nr=r+dr[k], nc=c+dc[k];\n if(nr<0||nr>=D||nc<0||nc>=D) continue;\n int v = id[nr][nc];\n if(v<0) continue;\n if(!disc[v]){\n parent[v]=u;\n children++;\n dfs(v);\n low[u]=min(low[u], low[v]);\n if(parent[u]==-1){\n if(children>1) isArt[u]=1;\n }else{\n if(low[v]>=disc[u]) isArt[u]=1;\n }\n }else if(v!=parent[u]){\n low[u]=min(low[u], disc[v]);\n }\n }\n };\n dfs(root);\n\n for(int u=0;u=D||nc<0||nc>=D) continue;\n if(obstacle[nr][nc]) continue;\n if(emptyCell[nr][nc]) d++;\n }\n return d;\n };\n\n // peelIndex precompute\n int peelIndex[D][D];\n for(int i=0;id2) best={i,j}; }\n else if(g1!=g2){ if(g1> t;\n\n auto art = compute_articulation(emptyCell);\n\n int desiredPeel = (M - 1 - t);\n int desiredDist = t;\n\n Cell chosen{-1,-1};\n long long bestScore = (1LL<<60);\n\n for(int i=0;i isObs;\n for(int i=0;iint{\n auto [r,c]=rc(id);\n return labelAt[r][c];\n };\n\n auto bfs_reachable = [&](const bitset<81>& removedMask){\n bitset<81> reach; reach.reset();\n queue qq;\n reach.set(entId);\n qq.push(entId);\n\n auto isEmptyNow = [&](int id)->bool{\n if(isObs.test(id)) return false;\n if(id==entId) return true;\n return removedMask.test(id);\n };\n\n while(!qq.empty()){\n int v=qq.front(); qq.pop();\n auto [r,c]=rc(v);\n for(int k=0;k<4;k++){\n int nr=r+dr[k], nc=c+dc[k];\n if(nr<0||nr>=D||nc<0||nc>=D) continue;\n int to=idx(nr,nc);\n if(reach.test(to)) continue;\n if(isEmptyNow(to)){\n reach.set(to);\n qq.push(to);\n }\n }\n }\n return reach;\n };\n\n auto frontier_list = [&](const bitset<81>& removedMask, const bitset<81>& reach, array& inFront){\n inFront.fill(0);\n vector front;\n front.reserve(40);\n for(int i=0;i=D||nj<0||nj>=D) continue;\n if(reach.test(idx(ni,nj))){ ok=true; break; }\n }\n if(ok){\n inFront[idc]=1;\n front.push_back(idc);\n }\n }\n return front;\n };\n\n auto unlock_score = [&](int idc, const bitset<81>& removedMask, const array& inFront){\n // After removing idc, that cell becomes reachable empty.\n // Neighbors that are containers and currently NOT frontier will become frontier => \"unlock\".\n auto [r,c]=rc(idc);\n int sc=0;\n for(int k=0;k<4;k++){\n int nr=r+dr[k], nc=c+dc[k];\n if(nr<0||nr>=D||nc<0||nc>=D) continue;\n int nb=idx(nr,nc);\n if(isObs.test(nb)) continue;\n if(nb==entId) continue;\n if(removedMask.test(nb)) continue; // already empty\n if(inFront[nb]) continue; // already frontier\n sc++;\n }\n return sc;\n };\n\n struct Node {\n bitset<81> removed;\n FenwickFixed fw;\n long long inv = 0;\n int firstMove = -1;\n };\n\n bitset<81> removed; removed.reset();\n FenwickFixed fw(M);\n for(int x=0;x beam;\n beam.reserve(W);\n beam.push_back(Node{removed, fw, 0LL, -1});\n\n for(int depth=0; depth next;\n next.reserve(W * 12);\n\n for(const auto& nd : beam){\n auto reach = bfs_reachable(nd.removed);\n array inFront;\n auto front = frontier_list(nd.removed, reach, inFront);\n if(front.empty()) continue;\n\n // Build candidate set:\n // - several smallest labels\n // - several best unlockers\n vector cand = front;\n\n // smallest-label subset\n sort(cand.begin(), cand.end(), [&](int a, int b){\n int la=label_of(a), lb=label_of(b);\n if(la!=lb) return la chosenCands(cand.begin(), cand.begin()+takeSmall);\n\n // unlockers among the rest (or all if small)\n vector> unlocks; // (-score, id)\n unlocks.reserve((int)front.size());\n for(int idc: front){\n int sc = unlock_score(idc, nd.removed, inFront);\n unlocks.push_back({-sc, idc});\n }\n sort(unlocks.begin(), unlocks.end(), [&](auto &x, auto &y){\n if(x.first!=y.first) return x.first 12){\n for(int i=0;i<2;i++) chosenCands.push_back(front[rng.next_int((int)front.size())]);\n }\n\n sort(chosenCands.begin(), chosenCands.end());\n chosenCands.erase(unique(chosenCands.begin(), chosenCands.end()), chosenCands.end());\n\n for(int idc: chosenCands){\n Node ch = nd;\n int lab = label_of(idc);\n\n ch.inv += ch.fw.sumLess(lab);\n ch.fw.add(lab, -1);\n ch.removed.set(idc);\n\n if(depth==0) ch.firstMove = idc;\n\n next.push_back(std::move(ch));\n }\n }\n\n if(next.empty()) break;\n\n // Keep best W nodes by (inv, tie by first label).\n nth_element(next.begin(),\n next.begin() + min(W, (int)next.size()),\n next.end(),\n [&](const Node& a, const Node& b){\n if(a.inv != b.inv) return a.inv < b.inv;\n int la = (a.firstMove==-1)? INT_MAX : label_of(a.firstMove);\n int lb = (b.firstMove==-1)? INT_MAX : label_of(b.firstMove);\n if(la != lb) return la < lb;\n return a.firstMove < b.firstMove;\n });\n int newSize = min(W, (int)next.size());\n next.resize(newSize);\n\n sort(next.begin(), next.end(), [&](const Node& a, const Node& b){\n if(a.inv != b.inv) return a.inv < b.inv;\n int la = (a.firstMove==-1)? INT_MAX : label_of(a.firstMove);\n int lb = (b.firstMove==-1)? INT_MAX : label_of(b.firstMove);\n if(la != lb) return la < lb;\n return a.firstMove < b.firstMove;\n });\n\n beam.swap(next);\n }\n\n // Choose best first move among beam states.\n int chosen = -1;\n long long bestInv = (1LL<<62);\n int bestFirstLabel = INT_MAX;\n\n for(const auto& nd : beam){\n if(nd.firstMove==-1) continue;\n int fl = label_of(nd.firstMove);\n if(nd.inv < bestInv || (nd.inv==bestInv && fl < bestFirstLabel)){\n bestInv = nd.inv;\n bestFirstLabel = fl;\n chosen = nd.firstMove;\n }\n }\n\n // Fallback if something went wrong (shouldn't).\n if(chosen==-1){\n auto reach = bfs_reachable(removed);\n array inFront;\n auto front = frontier_list(removed, reach, inFront);\n chosen = *min_element(front.begin(), front.end(), [&](int a,int b){\n return label_of(a) < label_of(b);\n });\n }\n\n auto [r,c]=rc(chosen);\n cout << r << \" \" << c << endl;\n\n int lab = labelAt[r][c];\n fw.add(lab, -1);\n removed.set(chosen);\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nstatic const int N = 50;\nstatic const int M = 100;\n\nstruct Pos { int r, c; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m; // fixed n=50, m=100\n vector> g(n, vector(n));\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) cin >> g[i][j];\n\n const int V = m + 1; // colors 0..m\n auto inside = [&](int r, int c){ return 0 <= r && r < n && 0 <= c && c < n; };\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n\n // origAdj[a][b] = whether adjacency must exist (undirected)\n vector> origAdj(V, vector(V, 0));\n auto setOrigAdj = [&](int a, int b){\n if (a == b) return;\n origAdj[a][b] = origAdj[b][a] = 1;\n };\n\n // Build original adjacency from internal edges\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n if (i + 1 < n) setOrigAdj(g[i][j], g[i+1][j]);\n if (j + 1 < n) setOrigAdj(g[i][j], g[i][j+1]);\n }\n // Adjacency to outside (0) via boundary\n for (int i = 0; i < n; i++) {\n setOrigAdj(0, g[i][0]);\n setOrigAdj(0, g[i][n-1]);\n }\n for (int j = 0; j < n; j++) {\n setOrigAdj(0, g[0][j]);\n setOrigAdj(0, g[n-1][j]);\n }\n\n // inB[c] <=> originally adjacent to 0\n vector inB(V, 0);\n for (int c = 1; c <= m; c++) inB[c] = origAdj[0][c];\n\n // edgeCnt[a][b] for a> edgeCnt(V, vector(V, 0));\n auto addEdgeCnt = [&](int a, int b, int delta){\n if (a == b) return;\n if (a > b) swap(a, b);\n edgeCnt[a][b] += delta;\n };\n auto getEdgeCnt = [&](int a, int b)->int{\n if (a == b) return 0;\n if (a > b) swap(a, b);\n return edgeCnt[a][b];\n };\n\n // Initialize edgeCnt from current grid (initially original, no internal 0)\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n if (i + 1 < n) {\n int a = g[i][j], b = g[i+1][j];\n if (a != b) addEdgeCnt(a, b, +1);\n }\n if (j + 1 < n) {\n int a = g[i][j], b = g[i][j+1];\n if (a != b) addEdgeCnt(a, b, +1);\n }\n }\n // Boundary-outside edges\n for (int i = 0; i < n; i++) {\n addEdgeCnt(0, g[i][0], +1);\n addEdgeCnt(0, g[i][n-1], +1);\n }\n for (int j = 0; j < n; j++) {\n addEdgeCnt(0, g[0][j], +1);\n addEdgeCnt(0, g[n-1][j], +1);\n }\n\n // size and representative for each color 1..m\n vector sz(V, 0);\n vector rep(V, Pos{-1, -1});\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n int c = g[i][j];\n if (c != 0) {\n sz[c]++;\n rep[c] = Pos{i, j};\n }\n }\n\n // BFS visited stamp (for connectivity checks)\n static int vis[N][N];\n int stamp = 1;\n\n auto find_rep_scan = [&](int col)->Pos{\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++)\n if (g[i][j] == col) return Pos{i, j};\n return Pos{-1, -1};\n };\n\n auto count_same_neighbors = [&](int r, int c, int col)->int{\n int cnt = 0;\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 if (g[nr][nc] == col) cnt++;\n }\n return cnt;\n };\n\n // Check connectivity of `col` after removing cell (r,c) from that color (cell will become something else).\n auto connected_after_removal = [&](int col, int r, int c)->bool{\n // leaf shortcut: if removed cell has <=1 same-color neighbor, it cannot disconnect the remainder.\n if (sz[col] <= 2) return true;\n if (count_same_neighbors(r, c, col) <= 1) return true;\n\n Pos st = rep[col];\n if (!(st.r >= 0 && g[st.r][st.c] == col) || (st.r == r && st.c == c)) {\n bool found = false;\n for (int k = 0; k < 4 && !found; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr,nc) && g[nr][nc] == col) {\n st = Pos{nr,nc};\n found = true;\n }\n }\n if (!found) st = find_rep_scan(col);\n if (st.r < 0) return false;\n }\n\n stamp++;\n deque q;\n vis[st.r][st.c] = stamp;\n q.push_back(st);\n int reached = 0;\n\n while (!q.empty()) {\n auto p = q.front(); q.pop_front();\n reached++;\n for (int k = 0; k < 4; k++) {\n int nr = p.r + dr[k], nc = p.c + dc[k];\n if (!inside(nr,nc)) continue;\n if (nr == r && nc == c) continue;\n if (g[nr][nc] != col) continue;\n if (vis[nr][nc] == stamp) continue;\n vis[nr][nc] = stamp;\n q.push_back(Pos{nr,nc});\n }\n }\n return reached == sz[col] - 1;\n };\n\n auto boundary_sides = [&](int r, int c)->int{\n int b = 0;\n if (r == 0) b++;\n if (r == n-1) b++;\n if (c == 0) b++;\n if (c == n-1) b++;\n return b;\n };\n\n // Frontier cells to try deletions more often (boundary + neighbors of existing 0)\n vector frontier;\n frontier.reserve(n*n*4);\n for (int i = 0; i < n; i++) {\n frontier.push_back(Pos{i, 0});\n frontier.push_back(Pos{i, n-1});\n }\n for (int j = 0; j < n; j++) {\n frontier.push_back(Pos{0, j});\n frontier.push_back(Pos{n-1, j});\n }\n\n // RNG + time\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937_64 rng(seed);\n auto startTime = chrono::high_resolution_clock::now();\n const double TL = 1.95;\n\n auto time_ok = [&](){\n double t = chrono::duration(chrono::high_resolution_clock::now() - startTime).count();\n return t < TL;\n };\n\n auto is_neighbor0 = [&](int r, int c)->bool{\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 if (g[nr][nc] == 0) return true;\n }\n return false;\n };\n\n // Try painting cell (r,c) to newCol (0..m), oldCol != 0.\n auto try_paint = [&](int r, int c, int newCol)->bool{\n int oldCol = g[r][c];\n if (oldCol == 0) return false;\n if (oldCol == newCol) return false;\n\n // oldCol must remain non-empty\n if (sz[oldCol] <= 1) return false;\n\n // Collect neighbor colors with multiplicity, including virtual outside(0) for each boundary side.\n vector neigh;\n neigh.reserve(8);\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr,nc)) neigh.push_back(g[nr][nc]);\n }\n int bnd = boundary_sides(r, c);\n for (int t = 0; t < bnd; t++) neigh.push_back(0);\n\n // Constraints for newCol == 0: must not create isolated 0 component.\n if (newCol == 0) {\n if (bnd == 0 && !is_neighbor0(r, c)) return false;\n // Also, 0 must not become adjacent to colors not adjacent-to-0 in original.\n // (i.e., origAdj[0][x] must hold for any neighbor x != 0)\n for (int x : neigh) {\n if (x != 0 && !origAdj[0][x]) return false;\n }\n } else {\n // Adding cell to newCol must keep newCol connected => need adjacent existing newCol cell.\n bool adjNew = false;\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 if (g[nr][nc] == newCol) { adjNew = true; break; }\n }\n if (!adjNew) return false;\n }\n\n // Compute affected pair deltas (small list of at most ~16 entries)\n struct Delta { int a,b, d; };\n array ds;\n int dsz = 0;\n auto add_delta = [&](int a, int b, int dd){\n if (a == b || dd == 0) return;\n if (a > b) swap(a, b);\n for (int i = 0; i < dsz; i++) {\n if (ds[i].a == a && ds[i].b == b) { ds[i].d += dd; return; }\n }\n ds[dsz++] = Delta{a,b,dd};\n };\n\n // Local edge updates: for each neighbor x,\n // oldCol-x edge is removed if oldCol!=x, newCol-x edge is added if newCol!=x.\n // Also forbid creating any adjacency not in original.\n for (int x : neigh) {\n if (oldCol != x) add_delta(oldCol, x, -1);\n if (newCol != x) {\n // If this introduces an edge between newCol and x, it must be allowed in original.\n if (!origAdj[newCol][x]) return false;\n add_delta(newCol, x, +1);\n }\n }\n\n // Connectivity check of oldCol after removing this cell\n if (!connected_after_removal(oldCol, r, c)) return false;\n\n // Check adjacency constraints for affected pairs\n for (int i = 0; i < dsz; i++) {\n int a = ds[i].a, b = ds[i].b, dd = ds[i].d;\n int cur = edgeCnt[a][b];\n int nxt = cur + dd;\n if (nxt < 0) return false;\n if (origAdj[a][b]) {\n if (nxt == 0) return false; // required adjacency must remain\n } else {\n if (nxt != 0) return false; // forbidden adjacency must not appear\n }\n }\n\n // Additionally ensure (0,color) pairs touched still satisfy required/non-required:\n // Already covered by above checks because any created 0-x edge requires origAdj[0][x].\n // But we also might remove 0-x edges. The rule says if origAdj[0][x]==1, must stay >0.\n // Also covered in pair checks.\n\n // Accept move: apply deltas\n for (int i = 0; i < dsz; i++) {\n edgeCnt[ds[i].a][ds[i].b] += ds[i].d;\n }\n\n // Apply recolor\n g[r][c] = newCol;\n sz[oldCol]--;\n if (newCol != 0) {\n sz[newCol]++;\n rep[newCol] = Pos{r,c}; // safe to update to something valid\n }\n if (rep[oldCol].r == r && rep[oldCol].c == c) {\n // try to pick a neighbor, else scan\n Pos cand{-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] == oldCol) { cand = Pos{nr,nc}; break; }\n }\n if (cand.r < 0) cand = find_rep_scan(oldCol);\n rep[oldCol] = cand;\n }\n\n // If we created a 0 cell, its neighbors become good deletion candidates (frontier)\n if (newCol == 0) {\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 if (g[nr][nc] != 0) frontier.push_back(Pos{nr,nc});\n }\n }\n return true;\n };\n\n // Heuristic: do not increase \"internal area\" (colors not originally adjacent to 0).\n auto internal_flag = [&](int col)->int{\n if (col == 0) return 0;\n return inB[col] ? 0 : 1;\n };\n\n // Main loop: mix deletions and recolors\n while (time_ok()) {\n // Choose a cell. Prefer frontier for deletion attempts.\n int r, c;\n bool pickFront = (!frontier.empty() && (rng() % 100) < 70);\n if (pickFront) {\n int idx = (int)(rng() % frontier.size());\n r = frontier[idx].r;\n c = frontier[idx].c;\n frontier[idx] = frontier.back();\n frontier.pop_back();\n } else {\n r = (int)(rng() % n);\n c = (int)(rng() % n);\n }\n if (g[r][c] == 0) continue;\n\n // Try deletion to 0 with decent probability; otherwise try recolor to neighbor color.\n bool tryZero = ((rng() % 100) < 55);\n if (tryZero) {\n (void)try_paint(r, c, 0);\n continue;\n }\n\n // Propose recolor to a neighboring non-zero color\n int oldCol = g[r][c];\n array cand;\n int ksz = 0;\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 x = g[nr][nc];\n if (x == 0 || x == oldCol) continue;\n cand[ksz++] = x;\n }\n if (ksz == 0) continue;\n int newCol = cand[(int)(rng() % ksz)];\n\n // Acceptance rule: never increase internal area; neutral moves accepted with small probability.\n int deltaInternal = internal_flag(newCol) - internal_flag(oldCol);\n if (deltaInternal > 0) continue; // forbid making internal mass larger\n if (deltaInternal == 0) {\n // neutral moves: accept rarely, just to rearrange / escape minor dead-ends\n if ((rng() % 100) >= 7) continue;\n }\n (void)try_paint(r, c, newCol);\n }\n\n // Output final grid\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j) cout << ' ';\n cout << g[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n};\n\nstruct Solver {\n int N, D, Q;\n int used = 0;\n int used_sort = 0;\n\n XorShift rng;\n\n // cache[a][b] = -1 if ab, 0 if equal, 2 unknown\n vector> cache;\n\n vector order; // ascending (light -> heavy), approximate\n vector rankPos; // position in order\n vector west; // pseudo weights\n\n vector> bins;\n vector binSumEst;\n vector binOf;\n\n Solver() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cin >> N >> D >> Q;\n cache.assign(N, vector(N, 2));\n for (int i = 0; i < N; i++) cache[i][i] = 0;\n order.clear();\n rankPos.assign(N, 0);\n west.assign(N, 1.0);\n binOf.assign(N, -1);\n }\n\n char query_sets(const vector& L, const vector& R) {\n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << \"\\n\" << flush;\n string s;\n cin >> s;\n used++;\n return s[0];\n }\n\n int8_t cmp_item(int a, int b) {\n if (a == b) return 0;\n int8_t &c = cache[a][b];\n if (c != 2) return c;\n char res = query_sets(vector{a}, vector{b});\n int8_t ab;\n if (res == '<') ab = -1;\n else if (res == '>') ab = +1;\n else ab = 0;\n cache[a][b] = ab;\n cache[b][a] = (ab == 0 ? 0 : (int8_t)-ab);\n return ab;\n }\n\n // Insert x into current order using up to k comparisons (binary-search-ish).\n void insert_with_budget(int x, int k) {\n int m = (int)order.size();\n if (m == 0) { order.push_back(x); return; }\n if (k <= 0) { order.push_back(x); return; }\n\n // do binary search but stop after k comparisons; then insert at narrowed interval\n int lo = 0, hi = m;\n while (lo < hi && k > 0) {\n int mid = (lo + hi) >> 1;\n int8_t r = cmp_item(x, order[mid]);\n used_sort++;\n k--;\n if (r == -1) hi = mid;\n else if (r == +1) lo = mid + 1;\n else { // equal\n lo = mid;\n hi = mid;\n }\n }\n // If we stopped early, lo..hi is narrowed; insert at lo.\n order.insert(order.begin() + lo, x);\n }\n\n void build_order() {\n vector items(N);\n iota(items.begin(), items.end(), 0);\n for (int i = N - 1; i >= 1; i--) swap(items[i], items[rng.next_int(0, i)]);\n\n // Allocate queries:\n // - If Q is small, spend almost all on ordering.\n // - Else reserve some for balancing.\n int reserve = 3 * D; // minimal for balancing\n reserve = min(reserve, Q / 3);\n if (Q <= 3 * N) reserve = 0; // small Q: prioritize ordering\n int sortBudget = max(0, Q - reserve);\n\n order.clear();\n order.reserve(N);\n\n int idx = 0;\n order.push_back(items[idx++]);\n\n while (idx < N && used < sortBudget) {\n int remItems = N - idx;\n int remQ = sortBudget - used;\n\n // comparisons per insertion: proportional to remaining budget\n int k = max(1, remQ / remItems);\n // allow more work when Q is large, but don't go crazy\n k = min(k, 24);\n\n insert_with_budget(items[idx], k);\n idx++;\n }\n // append remaining without comparisons if budget exhausted\n while (idx < N) order.push_back(items[idx++]);\n\n // Build rank positions\n for (int i = 0; i < N; i++) rankPos[order[i]] = i;\n\n // Pseudo weights: mild exponential across ranks (ratio ~ e^4)\n double base = exp(4.0 / max(1, N - 1));\n for (int i = 0; i < N; i++) {\n west[order[i]] = pow(base, i);\n }\n }\n\n void initial_partition() {\n bins.assign(D, {});\n binSumEst.assign(D, 0.0);\n binOf.assign(N, -1);\n\n // Heaviest-first\n vector heavy(order.rbegin(), order.rend());\n\n // Seed: one item each to avoid empty bins\n int ptr = 0;\n for (int b = 0; b < D; b++) {\n int it = heavy[ptr++];\n bins[b].push_back(it);\n binSumEst[b] += west[it];\n binOf[it] = b;\n }\n\n // LPT fill\n for (; ptr < (int)heavy.size(); ptr++) {\n int it = heavy[ptr];\n int best = 0;\n for (int b = 1; b < D; b++) if (binSumEst[b] < binSumEst[best]) best = b;\n bins[best].push_back(it);\n binSumEst[best] += west[it];\n binOf[it] = best;\n }\n }\n\n int pick_bin_max_est() {\n int b = 0;\n for (int i = 1; i < D; i++) if (binSumEst[i] > binSumEst[b]) b = i;\n return b;\n }\n int pick_bin_min_est() {\n int b = 0;\n for (int i = 1; i < D; i++) if (binSumEst[i] < binSumEst[b]) b = i;\n return b;\n }\n\n int heaviest_item_in_bin(int b) {\n int best = bins[b][0];\n for (int x : bins[b]) if (rankPos[x] > rankPos[best]) best = x;\n return best;\n }\n\n vector candidates_by_rank(int bHeavy) {\n auto v = bins[bHeavy];\n sort(v.begin(), v.end(), [&](int a, int b){\n return rankPos[a] < rankPos[b];\n });\n return v;\n }\n\n bool guided_move(int bHeavy, int bLight, int maxSteps) {\n if ((int)bins[bHeavy].size() <= 1) return false;\n\n vector cand = candidates_by_rank(bHeavy);\n\n auto test_move = [&](int x)->char {\n vector L, R;\n L.reserve(bins[bHeavy].size() - 1);\n R.reserve(bins[bLight].size() + 1);\n for (int it : bins[bHeavy]) if (it != x) L.push_back(it);\n for (int it : bins[bLight]) R.push_back(it);\n R.push_back(x);\n return query_sets(L, R);\n };\n\n int lo = 0, hi = (int)cand.size() - 1;\n int ans = -1;\n for (int step = 0; step < maxSteps && lo <= hi && used < Q; step++) {\n int mid = (lo + hi) >> 1;\n char res = test_move(cand[mid]);\n // '>' => heavy_without_x still heavier => x too light => go heavier\n if (res == '>') lo = mid + 1;\n else { ans = mid; hi = mid - 1; }\n }\n if (ans == -1) ans = (int)cand.size() - 1;\n int x = cand[ans];\n\n auto &A = bins[bHeavy];\n auto it = find(A.begin(), A.end(), x);\n if (it == A.end()) return false;\n A.erase(it);\n bins[bLight].push_back(x);\n\n binOf[x] = bLight;\n binSumEst[bHeavy] -= west[x];\n binSumEst[bLight] += west[x];\n return true;\n }\n\n void safe_move_heaviest(int bHeavy, int bLight) {\n if ((int)bins[bHeavy].size() <= 1) return;\n int x = heaviest_item_in_bin(bHeavy);\n\n auto &A = bins[bHeavy];\n A.erase(find(A.begin(), A.end(), x));\n bins[bLight].push_back(x);\n\n binOf[x] = bLight;\n binSumEst[bHeavy] -= west[x];\n binSumEst[bLight] += west[x];\n }\n\n void balancing_phase() {\n // confidence: if we used enough comparisons in ordering, allow guided moves\n double need = N * log2((double)N + 1.0);\n bool confident = (used_sort >= 0.75 * need);\n\n while (used < Q) {\n int bMax = pick_bin_max_est();\n int bMin = pick_bin_min_est();\n if (bMax == bMin) {\n // consume queries in a minimally harmful way: compare two bins, maybe do safe move\n int a = rng.next_int(0, D - 1);\n int b = rng.next_int(0, D - 1);\n if (a == b) b = (b + 1) % D;\n if (bins[a].empty() || bins[b].empty()) {\n query_sets(vector{0}, vector{1});\n continue;\n }\n char res = query_sets(bins[a], bins[b]);\n if (used >= Q) break;\n if (res == '>') safe_move_heaviest(a, b);\n else if (res == '<') safe_move_heaviest(b, a);\n continue;\n }\n\n if (bins[bMax].empty() || bins[bMin].empty()) {\n query_sets(vector{0}, vector{1});\n continue;\n }\n\n char res = query_sets(bins[bMax], bins[bMin]);\n if (used >= Q) break;\n\n int heavy = -1, light = -1;\n if (res == '>') { heavy = bMax; light = bMin; }\n else if (res == '<') { heavy = bMin; light = bMax; }\n else continue;\n\n if (!confident || (Q - used) < 3) {\n safe_move_heaviest(heavy, light);\n } else {\n // small guided search (avoid spending too many queries per step)\n int maxSteps = min(5, Q - used);\n bool ok = guided_move(heavy, light, maxSteps);\n if (!ok) safe_move_heaviest(heavy, light);\n }\n }\n }\n\n void output_answer() {\n vector ans(N, 0);\n for (int b = 0; b < D; b++) for (int x : bins[b]) ans[x] = b;\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << ans[i];\n }\n cout << \"\\n\" << flush;\n }\n\n void solve() {\n build_order();\n initial_partition();\n balancing_phase();\n\n // safety: exactly Q queries\n while (used < Q) query_sets(vector{0}, vector{1});\n\n output_answer();\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstatic constexpr int N = 200;\nstatic constexpr int M = 10;\n\nstruct XorShift {\n uint64_t x;\n XorShift() {\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n x = seed ? seed : 88172645463325252ULL;\n }\n uint32_t next_u32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)(x & 0xffffffffu);\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u32() % (uint32_t)(r - l + 1));\n }\n};\n\nstruct SimState {\n vector> st; // bottom -> top\n array, N+1> pos; // value -> (stack, index), (-1,-1) removed\n int cur;\n};\n\nstatic inline int stack_min(const vector& s) {\n int mn = INT_MAX;\n for (int v : s) mn = min(mn, v);\n return mn;\n}\n\nstatic inline int count_leq(const vector& s, int x) {\n int c = 0;\n for (int v : s) c += (v <= x);\n return c;\n}\n\n// Lower is better.\nstatic inline long long eval_dest(const vector>& st, int cur, int src, int dst,\n int blockSize, int bottomMoved) {\n const auto &d = st[dst];\n int hd = (int)d.size();\n int mind = d.empty() ? INT_MAX : stack_min(d);\n int topd = d.empty() ? INT_MAX : d.back();\n\n const int W1 = 30;\n const int W2 = 10;\n int soon = d.empty() ? 0 : count_leq(d, cur + W1);\n int vsoon = d.empty() ? 0 : count_leq(d, cur + W2);\n\n long long e = 0;\n\n // burying soon-needed stuff is costly ~ blockSize per buried soon box\n e += 120LL * blockSize * soon;\n e += 260LL * blockSize * vsoon;\n\n // buffers\n if (d.empty()) e -= 28000;\n\n // keep stacks not too tall\n e += 70LL * hd;\n\n // prefer large minimum / top\n if (mind != INT_MAX) e -= 9LL * mind;\n if (topd != INT_MAX) e -= 2LL * topd;\n\n // structure penalty\n if (!d.empty() && topd <= bottomMoved) e += 2500;\n\n // hard avoid stacks whose min is extremely soon\n if (mind != INT_MAX && mind <= cur + 8) e += 65000;\n\n (void)src;\n return e;\n}\n\n// Move tail [fromIdx..end) from src to dst, update pos.\nstatic inline void move_tail(SimState &s, int src, int fromIdx, int dst) {\n auto &A = s.st[src];\n auto &B = s.st[dst];\n int oldB = (int)B.size();\n\n for (int k = fromIdx; k < (int)A.size(); k++) {\n int v = A[k];\n s.pos[v] = {dst, oldB + (k - fromIdx)};\n B.push_back(v);\n }\n A.resize(fromIdx);\n}\n\nstatic inline void pop_cur(SimState &s, int stackIdx) {\n int v = s.cur;\n auto &A = s.st[stackIdx];\n A.pop_back();\n s.pos[v] = {-1, -1};\n s.cur++;\n}\n\nstatic long long rollout_energy(SimState s, int steps) {\n long long energy = 0;\n for (int t = 0; t < steps && s.cur <= N; t++) {\n auto [si, idx] = s.pos[s.cur];\n if (si < 0) break;\n auto &A = s.st[si];\n\n if (!A.empty() && A.back() == s.cur) {\n pop_cur(s, si);\n continue;\n }\n\n int start = idx + 1;\n int h = (int)A.size();\n int blockSize = h - start;\n if (blockSize <= 0) break;\n int bottomMoved = A[start];\n\n long long best = (1LL<<62);\n int bestd = -1;\n for (int d = 0; d < M; d++) if (d != si) {\n long long e = eval_dest(s.st, s.cur, si, d, blockSize, bottomMoved);\n if (e < best) { best = e; bestd = d; }\n }\n\n move_tail(s, si, start, bestd);\n energy += (long long)blockSize + 1;\n\n if (!s.st[si].empty() && s.st[si].back() == s.cur) pop_cur(s, si);\n else break;\n }\n return energy;\n}\n\n// Pick top K destinations by eval_dest for a given move signature.\nstatic vector topK_dests(const vector>& st, int cur, int src,\n int blockSize, int bottomMoved, int K) {\n vector> v;\n v.reserve(M-1);\n for (int d = 0; d < M; d++) if (d != src) {\n long long e = eval_dest(st, cur, src, d, blockSize, bottomMoved);\n v.push_back({e, d});\n }\n sort(v.begin(), v.end());\n vector res;\n for (int i = 0; i < (int)v.size() && i < K; i++) res.push_back(v[i].second);\n\n // Ensure at least one empty stack is included if exists (often valuable buffer).\n int bestEmpty = -1;\n long long bestEmptyEval = (1LL<<62);\n for (int d = 0; d < M; d++) if (d != src && st[d].empty()) {\n long long e = eval_dest(st, cur, src, d, blockSize, bottomMoved);\n if (e < bestEmptyEval) { bestEmptyEval = e; bestEmpty = d; }\n }\n if (bestEmpty != -1 && find(res.begin(), res.end(), bestEmpty) == res.end()) {\n res.push_back(bestEmpty);\n }\n return res;\n}\n\n// Real execution helper: move tail and record op1.\nstatic inline void real_move_tail(vector>& st,\n array, N+1>& pos,\n vector>& ops,\n int src, int fromIdx, int dst) {\n auto &A = st[src];\n auto &B = st[dst];\n int bottomMoved = A[fromIdx];\n ops.emplace_back(bottomMoved, dst + 1);\n\n int oldB = (int)B.size();\n for (int k = fromIdx; k < (int)A.size(); k++) {\n int v = A[k];\n pos[v] = {dst, oldB + (k - fromIdx)};\n B.push_back(v);\n }\n A.resize(fromIdx);\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> st(m);\n for (int i = 0; i < m; i++) {\n st[i].resize(n / m);\n for (int j = 0; j < n / m; j++) cin >> st[i][j];\n }\n\n array, N+1> pos;\n for (auto &p : pos) p = {-1,-1};\n for (int i = 0; i < m; i++) for (int j = 0; j < (int)st[i].size(); j++) pos[st[i][j]] = {i,j};\n\n vector> ops;\n ops.reserve(5000);\n\n XorShift rng;\n\n const int ROLLOUT_STEPS = 22;\n const int KDEST_MAIN = 5;\n const int KDEST_SPLIT = 4;\n const int SPLIT_W = 24; // if peeled top contains value <= cur+SPLIT_W, peeling is considered\n const int MAX_PEEL = 3;\n\n int cur = 1;\n while (cur <= n) {\n auto [sidx, idx] = pos[cur];\n auto &S = st[sidx];\n\n if (!S.empty() && S.back() == cur) {\n ops.emplace_back(cur, 0);\n S.pop_back();\n pos[cur] = {-1,-1};\n cur++;\n continue;\n }\n\n int start = idx + 1;\n int h = (int)S.size();\n int blockSize = h - start;\n int bottomMovedMain = S[start];\n\n auto build_sim = [&]() -> SimState {\n SimState sim;\n sim.st = st;\n sim.pos = pos;\n sim.cur = cur;\n return sim;\n };\n\n struct Plan {\n // type 0: whole block -> d2\n // type 1: peel t -> d1, then remaining above cur -> d2 (if remaining >0)\n int type;\n int t;\n int d1, d2;\n long long score;\n };\n\n vector plans;\n\n // Whole block plans (pruned destinations)\n {\n vector Ds = topK_dests(st, cur, sidx, blockSize, bottomMovedMain, KDEST_MAIN);\n for (int d2 : Ds) {\n SimState sim = build_sim();\n move_tail(sim, sidx, start, d2);\n long long energy = (long long)blockSize + 1;\n\n if (!sim.st[sidx].empty() && sim.st[sidx].back() == cur) pop_cur(sim, sidx);\n\n long long future = rollout_energy(sim, ROLLOUT_STEPS);\n long long imm = eval_dest(st, cur, sidx, d2, blockSize, bottomMovedMain);\n\n long long total = (energy + future) * 100000LL + imm;\n plans.push_back({0, 0, -1, d2, total});\n }\n }\n\n // Peel t=1..3 plans (only if peeled part contains \"soon\" value)\n for (int t = 1; t <= MAX_PEEL && t <= blockSize; t++) {\n bool needPeel = false;\n for (int k = h - t; k < h; k++) {\n if (S[k] <= cur + SPLIT_W) { needPeel = true; break; }\n }\n if (!needPeel) continue;\n\n int peelFrom = h - t;\n int bottomMovedPeel = S[peelFrom];\n\n vector D1 = topK_dests(st, cur, sidx, t, bottomMovedPeel, KDEST_SPLIT);\n // After peeling, remaining above cur has size blockSize - t (maybe 0)\n int remainSize = blockSize - t;\n\n // For the remaining move, bottomMoved stays bottomMovedMain unless t == blockSize (no move).\n vector D2;\n if (remainSize > 0) {\n D2 = topK_dests(st, cur, sidx, remainSize, bottomMovedMain, KDEST_SPLIT);\n } else {\n D2 = {-1};\n }\n\n for (int d1 : D1) for (int d2 : D2) {\n SimState sim = build_sim();\n\n // peel\n move_tail(sim, sidx, peelFrom, d1);\n long long energy = (long long)t + 1;\n long long imm = eval_dest(st, cur, sidx, d1, t, bottomMovedPeel);\n\n // move remaining above cur if any\n auto [ss, ii] = sim.pos[cur];\n if (ss < 0) continue;\n if (!sim.st[ss].empty() && sim.st[ss].back() == cur) {\n // already on top\n } else {\n int start2 = ii + 1;\n int h2 = (int)sim.st[ss].size();\n int rem = h2 - start2;\n if (rem > 0) {\n int bottom2 = sim.st[ss][start2];\n if (d2 < 0) continue;\n move_tail(sim, ss, start2, d2);\n energy += (long long)rem + 1;\n imm += eval_dest(st, cur, sidx, d2, rem, bottom2);\n }\n }\n\n // pop cur\n auto [sss, iii] = sim.pos[cur];\n if (sss < 0) continue;\n if (!sim.st[sss].empty() && sim.st[sss].back() == cur) pop_cur(sim, sss);\n else continue;\n\n long long future = rollout_energy(sim, ROLLOUT_STEPS);\n long long total = (energy + future) * 100000LL + imm;\n\n plans.push_back({1, t, d1, d2, total});\n }\n }\n\n // Choose best plan\n long long bestScore = (1LL<<62);\n vector bestIds;\n for (int i = 0; i < (int)plans.size(); i++) {\n if (plans[i].score < bestScore) {\n bestScore = plans[i].score;\n bestIds = {i};\n } else if (plans[i].score == bestScore) {\n bestIds.push_back(i);\n }\n }\n int pick = bestIds[rng.next_int(0, (int)bestIds.size() - 1)];\n Plan best = plans[pick];\n\n // Execute in real state\n if (best.type == 0) {\n // move all above cur\n real_move_tail(st, pos, ops, sidx, start, best.d2);\n\n // pop cur\n ops.emplace_back(cur, 0);\n st[sidx].pop_back();\n pos[cur] = {-1,-1};\n cur++;\n } else {\n // peel t\n int t = best.t;\n int peelFrom = (int)st[sidx].size() - t;\n real_move_tail(st, pos, ops, sidx, peelFrom, best.d1);\n\n // move remaining above cur if any\n auto [ss, ii] = pos[cur];\n if (ss >= 0 && !st[ss].empty() && st[ss].back() != cur) {\n int start2 = ii + 1;\n if (start2 < (int)st[ss].size()) {\n // choose d2 (guaranteed valid in plan when needed)\n real_move_tail(st, pos, ops, ss, start2, best.d2);\n }\n }\n\n // pop cur\n auto [sss, iii] = pos[cur];\n (void)iii;\n ops.emplace_back(cur, 0);\n st[sss].pop_back();\n pos[cur] = {-1,-1};\n cur++;\n }\n\n if ((int)ops.size() > 5000) break; // should never happen with this approach\n }\n\n for (auto [v, i] : ops) cout << v << \" \" << i << \"\\n\";\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstatic inline char opp(char c){\n if(c=='U') return 'D';\n if(c=='D') return 'U';\n if(c=='L') return 'R';\n return 'L';\n}\n\nstruct BFSResult{\n vector prev;\n vector pmove;\n vector dist;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector h(N-1), v(N);\n for(int i=0;i> h[i];\n for(int i=0;i> v[i];\n vector> d(N, vector(N));\n for(int i=0;i> d[i][j];\n\n int V = N*N;\n auto id = [&](int i,int j){ return i*N + j; };\n auto rc = [&](int x){ return pair(x/N, x%N); };\n\n vector>> g(V);\n auto add_edge = [&](int a,int b,char c){\n g[a].push_back({b,c});\n };\n for(int i=0;iBFSResult{\n BFSResult br;\n br.prev.assign(V, -1);\n br.pmove.assign(V, 0);\n br.dist.assign(V, -1);\n deque q;\n q.push_back(s);\n br.prev[s]=s;\n br.dist[s]=0;\n while(!q.empty()){\n int u=q.front(); q.pop_front();\n for(auto [to,mv]: g[u]){\n if(br.prev[to]!=-1) continue;\n br.prev[to]=u;\n br.pmove[to]=mv;\n br.dist[to]=br.dist[u]+1;\n q.push_back(to);\n }\n }\n return br;\n };\n\n auto path_using_bfs = [&](int s,int t,const BFSResult& br)->string{\n if(s==t) return \"\";\n if(br.prev[t]==-1) return \"\";\n string rev;\n int cur=t;\n while(cur!=s){\n rev.push_back(br.pmove[cur]);\n cur=br.prev[cur];\n }\n reverse(rev.begin(), rev.end());\n return rev;\n };\n\n auto reverse_opp = [&](const string& p)->string{\n string r;\n r.reserve(p.size());\n for(int i=(int)p.size()-1;i>=0;i--) r.push_back(opp(p[i]));\n return r;\n };\n\n // Exact evaluation via visit gaps\n auto eval_route = [&](const string& route)->long double{\n int L = (int)route.size();\n vector first(V,-1), last(V,-1);\n vector sumG(V,0);\n\n int ci=0,cj=0;\n for(int t=1;t<=L;t++){\n char c=route[t-1];\n if(c=='U') ci--;\n else if(c=='D') ci++;\n else if(c=='L') cj--;\n else cj++;\n if(ci<0||ci>=N||cj<0||cj>=N) return (long double)1e30;\n int u=id(ci,cj);\n if(first[u]==-1) first[u]=t;\n if(last[u]!=-1){\n long long gap=t-last[u];\n sumG[u] += gap*(gap-1)/2;\n }\n last[u]=t;\n }\n if(ci!=0||cj!=0) return (long double)1e30;\n\n for(int u=0;ustring{\n vector vis(V,0);\n int pos=start;\n vis[pos]=1;\n int unvisited=V-1;\n\n string route;\n route.reserve(min(100000, maxLen));\n\n const long double alpha = 1.25L;\n const int slack = 6;\n\n while(unvisited>0 && (int)route.size() < maxLen-500){\n BFSResult br = bfs_from(pos);\n\n int minDist=INT_MAX;\n for(int u=0;u=0) minDist = min(minDist, br.dist[u]);\n }\n if(minDist==INT_MAX) break;\n\n int limit = minDist + slack;\n int chosen=-1;\n long double best=-1;\n\n for(int u=0;u limit) continue;\n auto [i,j]=rc(u);\n long double sc = (long double)d[i][j] / pow((long double)(br.dist[u]+1), alpha);\n if(sc > best){\n best=sc;\n chosen=u;\n }\n }\n if(chosen==-1){\n for(int u=0;u= maxLen-500) break;\n }\n }\n\n // return to start\n if(pos!=start && (int)route.size() < maxLen){\n BFSResult br = bfs_from(pos);\n string back = path_using_bfs(pos, start, br);\n for(char mv: back){\n route.push_back(mv);\n apply_move(mv, pos);\n if((int)route.size() >= maxLen) break;\n }\n }\n\n // If failed to visit all nodes, fallback to DFS Euler from start (guaranteed)\n // (This should be rare, mostly a safety net).\n if(pos!=start || (int)route.size()>=maxLen){\n // We'll still accept; legality checked later by eval when embedded into 0..0.\n }\n return route;\n };\n\n // Importance selection (same idea as before but used to choose anchors/loop targets)\n BFSResult bfs0 = bfs_from(0);\n vector dist0 = bfs0.dist;\n vector all(V); iota(all.begin(), all.end(), 0);\n\n auto top_by = [&](auto scoreFn, int take)->vector{\n vector vec=all;\n sort(vec.begin(), vec.end(), [&](int a,int b){\n long double sa=scoreFn(a), sb=scoreFn(b);\n if(sa!=sb) return sa>sb;\n auto [ai,aj]=rc(a); auto [bi,bj]=rc(b);\n return d[ai][aj] > d[bi][bj];\n });\n vector res;\n for(int x: vec){\n if(x==0) continue;\n res.push_back(x);\n if((int)res.size()>=take) break;\n }\n return res;\n };\n\n auto byD = top_by([&](int u){\n auto [i,j]=rc(u);\n return (long double)d[i][j];\n }, 18);\n auto byNear = top_by([&](int u){\n auto [i,j]=rc(u);\n return (long double)d[i][j] / (long double)(dist0[u]+1);\n }, 18);\n const long double beta = 0.35L;\n auto byFar = top_by([&](int u){\n auto [i,j]=rc(u);\n return (long double)d[i][j] * pow((long double)(dist0[u]+1), beta);\n }, 18);\n\n vector important;\n {\n vector tmp;\n tmp.insert(tmp.end(), byD.begin(), byD.end());\n tmp.insert(tmp.end(), byNear.begin(), byNear.end());\n tmp.insert(tmp.end(), byFar.begin(), byFar.end());\n sort(tmp.begin(), tmp.end());\n tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());\n important = tmp;\n }\n\n // Anchor candidates: include 0 plus some important cells\n vector anchors;\n anchors.push_back(0);\n for(int x: byD) anchors.push_back(x);\n for(int x: byFar) anchors.push_back(x);\n sort(anchors.begin(), anchors.end());\n anchors.erase(unique(anchors.begin(), anchors.end()), anchors.end());\n if((int)anchors.size() > 14) anchors.resize(14);\n\n mt19937 rng(1234567);\n\n auto build_r_list_limited = [&](int maxR)->vector{\n vector r;\n auto add=[&](int x){ if(0<=x && x<=maxR) r.push_back(x); };\n add(0);\n for(int i=1;i<=5;i++) add(i);\n int a=1,b=2;\n while(a<=maxR){\n add(a);\n int c=a+b; a=b; b=c;\n }\n add(maxR);\n add(maxR/2);\n add(maxR/4);\n add((maxR*3)/4);\n sort(r.begin(), r.end());\n r.erase(unique(r.begin(), r.end()), r.end());\n if((int)r.size() > 18){\n // keep small + some large\n vector small, large;\n for(int x: r){\n if(x<=20) small.push_back(x);\n else large.push_back(x);\n }\n while((int)small.size() < 12 && !large.empty()){\n small.push_back(large.back());\n large.pop_back();\n }\n sort(small.begin(), small.end());\n small.erase(unique(small.begin(), small.end()), small.end());\n r = small;\n }\n return r;\n };\n\n auto append_repeat = [&](string &out, const string& s, int k){\n for(int i=0;ivector{\n vector loops;\n\n // 2-step neighbor loops at anchor\n for(auto [to,mv]: g[anchor]){\n string lp;\n lp.push_back(mv);\n lp.push_back(opp(mv));\n loops.push_back(lp);\n }\n\n BFSResult bfsA = bfs_from(anchor);\n\n // choose some good target cells by d/(distA+1)\n vector cand = important;\n sort(cand.begin(), cand.end(), [&](int a,int b){\n auto [ai,aj]=rc(a); auto [bi,bj]=rc(b);\n long double sa = (long double)d[ai][aj] / (long double)(bfsA.dist[a]+1);\n long double sb = (long double)d[bi][bj] / (long double)(bfsA.dist[b]+1);\n return sa>sb;\n });\n if((int)cand.size() > 10) cand.resize(10);\n\n auto pathA = [&](int t)->string{\n string p = path_using_bfs(anchor, t, bfsA);\n return p;\n };\n\n // star loops: (a->c->a)...\n auto build_star = [&](const vector& centers)->string{\n string cyc;\n for(int c: centers){\n string p = pathA(c);\n if(p.empty() && c!=anchor) continue;\n cyc += p;\n cyc += reverse_opp(p);\n if((int)cyc.size() > 4000) return \"\";\n }\n return cyc;\n };\n\n // chain loops: a->c1->c2->...->a\n auto build_chain = [&](vector centers)->string{\n string cyc;\n int cur = anchor;\n for(int c: centers){\n BFSResult br = bfs_from(cur);\n string seg = path_using_bfs(cur, c, br);\n if(seg.empty() && cur!=c) return \"\";\n cyc += seg;\n cur = c;\n if((int)cyc.size() > 4000) return \"\";\n }\n BFSResult br = bfs_from(cur);\n string back = path_using_bfs(cur, anchor, br);\n if(back.empty() && cur!=anchor) return \"\";\n cyc += back;\n if((int)cyc.size() > 4000) return \"\";\n return cyc;\n };\n\n for(int m=2;m<=5;m++){\n if((int)cand.size() base(cand.begin(), cand.begin()+m);\n\n // deterministic order: nearer first\n {\n auto ord=base;\n sort(ord.begin(), ord.end(), [&](int a,int b){ return bfsA.dist[a] < bfsA.dist[b]; });\n string cyc = build_star(ord);\n if(!cyc.empty()) loops.push_back(cyc);\n }\n // random a few\n for(int t=0;t<4;t++){\n auto ord=base;\n shuffle(ord.begin(), ord.end(), rng);\n string cyc = build_star(ord);\n if(!cyc.empty()) loops.push_back(cyc);\n }\n\n // chain variant (can be better if centers are close to each other)\n for(int t=0;t<3;t++){\n auto ord=base;\n shuffle(ord.begin(), ord.end(), rng);\n string cyc = build_chain(ord);\n if(!cyc.empty()) loops.push_back(cyc);\n }\n }\n\n sort(loops.begin(), loops.end());\n loops.erase(unique(loops.begin(), loops.end()), loops.end());\n if((int)loops.size() > 30) loops.resize(30);\n return loops;\n };\n\n // -------- global best search over anchors --------\n string bestRoute; bestRoute.reserve(100000);\n long double bestScore = 1e30;\n\n for(int anchor: anchors){\n // shortest path 0->anchor (undirected => anchor->0 is reverse_opp)\n string p0a = path_using_bfs(0, anchor, bfs0);\n string pa0 = reverse_opp(p0a);\n\n // cover all cells from anchor and return to anchor\n // leave budget for travel to/from 0 and loops\n int travelLen = (int)p0a.size() + (int)pa0.size();\n int maxCover = max(0, 90000 - travelLen); // allow loops too\n string coverA = build_cover_route(anchor, maxCover);\n\n // base route: 0->a->coverA->a->0\n string base;\n base.reserve(travelLen + (int)coverA.size());\n base += p0a;\n base += coverA;\n base += pa0;\n\n if((int)base.size() > 100000) continue;\n\n // Evaluate base\n {\n long double sc = eval_route(base);\n if(sc < bestScore){\n bestScore = sc;\n bestRoute = base;\n }\n }\n\n // loops at anchor\n vector loops = build_anchor_loops(anchor);\n\n // Combine: 0->a->loop^r1->coverA->loop^r2->a->0\n int fixedLen = travelLen + (int)coverA.size();\n for(const string& loop: loops){\n int c = (int)loop.size();\n if(c==0) continue;\n if(fixedLen + c > 100000) continue;\n int maxR = (100000 - fixedLen) / c;\n auto rlist = build_r_list_limited(maxR);\n\n for(int r: rlist){\n int r1 = r/2;\n int r2 = r - r1;\n\n string route;\n route.reserve(fixedLen + r*c);\n route += p0a;\n append_repeat(route, loop, r1);\n route += coverA;\n append_repeat(route, loop, r2);\n route += pa0;\n\n if((int)route.size() > 100000) continue;\n long double sc = eval_route(route);\n if(sc < bestScore){\n bestScore = sc;\n bestRoute = std::move(route);\n }\n }\n }\n }\n\n // Absolute fallback (should never happen)\n if(bestRoute.empty()){\n // trivial: DFS Euler from 0\n vector visited(V,0);\n vector itidx(V,0);\n vector st;\n vector entered;\n string base;\n base.reserve(2*V+10);\n\n // neighbor order by high d\n auto g2 = g;\n for(int u=0;u d[bi][bj];\n });\n }\n\n st.push_back(0);\n entered.push_back(0);\n visited[0]=1;\n while(!st.empty()){\n int u=st.back();\n int &it=itidx[u];\n if(it==(int)g2[u].size()){\n st.pop_back();\n char mv=entered.back();\n entered.pop_back();\n if(!st.empty()) base.push_back(opp(mv));\n continue;\n }\n auto [to,mv]=g2[u][it++];\n if(visited[to]) continue;\n visited[to]=1;\n base.push_back(mv);\n st.push_back(to);\n entered.push_back(mv);\n }\n bestRoute = base;\n }\n\n cout << bestRoute << \"\\n\";\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstatic const long long INF = (1LL<<60);\n\nstruct Timer {\n chrono::steady_clock::time_point st;\n Timer() : st(chrono::steady_clock::now()) {}\n double elapsed_sec() const {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n vector t(M);\n for (int i = 0; i < M; i++) cin >> t[i];\n\n const int V = N * N;\n vector x(V), y(V);\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int id = i * N + j;\n x[id] = i; y[id] = j;\n }\n auto manhattan = [&](int a, int b) -> int {\n return abs(x[a] - x[b]) + abs(y[a] - y[b]);\n };\n\n // positions[c] = list of cell ids having letter c\n array, 26> positions;\n for (int i = 0; i < 26; i++) positions[i].clear();\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n positions[A[i][j] - 'A'].push_back(i * N + j);\n }\n\n // idxInLetter[c][cellId] = index in positions[c], else -1\n array, 26> idxInLetter;\n for (int c = 0; c < 26; c++) {\n idxInLetter[c].fill(-1);\n for (int k = 0; k < (int)positions[c].size(); k++) {\n idxInLetter[c][positions[c][k]] = k;\n }\n }\n\n int startCell = si * N + sj;\n\n // Overlap between current string S and next pattern p (length 5), max 4\n auto overlap_suffix_prefix = [&](const string &S, const string &p) -> int {\n int maxL = min(4, (int)S.size());\n for (int l = maxL; l >= 0; l--) {\n bool ok = true;\n for (int i = 0; i < l; i++) {\n if (S[(int)S.size() - l + i] != p[i]) { ok = false; break; }\n }\n if (ok) return l;\n }\n return 0;\n };\n\n // Exact minimal typing cost for given S (no reconstruction)\n auto typing_cost = [&](const string &S) -> long long {\n vector prevIds(1, startCell);\n vector prevCost(1, 0);\n\n for (char ch : S) {\n int c = ch - 'A';\n const auto &curIds = positions[c];\n vector curCost(curIds.size(), INF);\n\n for (int i = 0; i < (int)curIds.size(); i++) {\n int v = curIds[i];\n long long best = INF;\n for (int j = 0; j < (int)prevIds.size(); j++) {\n long long cand = prevCost[j] + manhattan(prevIds[j], v);\n if (cand < best) best = cand;\n }\n curCost[i] = best + 1; // press cost\n }\n prevIds = curIds;\n prevCost.swap(curCost);\n }\n\n long long ans = INF;\n for (auto v : prevCost) ans = min(ans, v);\n return ans;\n };\n\n // Build candidate S by greedy extension with randomness\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto build_candidate = [&]() -> string {\n vector used(M, 0);\n int start = uniform_int_distribution(0, M - 1)(rng);\n used[start] = 1;\n int usedCnt = 1;\n\n string S = t[start];\n\n while (usedCnt < M) {\n int bestOv = -1;\n vector cand;\n cand.reserve(M);\n\n // Find best overlap\n for (int k = 0; k < M; k++) if (!used[k]) {\n int ov = overlap_suffix_prefix(S, t[k]);\n if (ov > bestOv) {\n bestOv = ov;\n cand.clear();\n cand.push_back(k);\n } else if (ov == bestOv) {\n cand.push_back(k);\n }\n }\n\n // random tie-break\n int pick = cand[uniform_int_distribution(0, (int)cand.size() - 1)(rng)];\n used[pick] = 1;\n usedCnt++;\n\n int ov = overlap_suffix_prefix(S, t[pick]);\n S += t[pick].substr(ov);\n }\n\n return S;\n };\n\n Timer timer;\n double TIME_LIMIT = 1.85; // seconds, leave margin\n\n string bestS;\n long long bestT = INF;\n\n // A few deterministic tries first: start from each of some indices\n // (still using the random builder is fine; it is fast)\n int iters = 0;\n while (timer.elapsed_sec() < TIME_LIMIT) {\n string S = build_candidate();\n if ((int)S.size() > 5000) continue; // should never happen here\n\n long long T = typing_cost(S);\n if (T < bestT) {\n bestT = T;\n bestS = std::move(S);\n }\n iters++;\n }\n\n if (bestS.empty()) {\n // Fallback: just concatenate\n bestS = t[0];\n for (int i = 1; i < M; i++) bestS += t[i];\n }\n\n // DP with parent reconstruction for bestS\n int L = (int)bestS.size();\n vector letters(L);\n for (int i = 0; i < L; i++) letters[i] = bestS[i] - 'A';\n\n vector> parent(L); // parent[p][k] = previous cellId (0..224)\n vector prevIds(1, startCell);\n vector prevCost(1, 0);\n\n // We'll also keep the last layer's ids/cost to choose end.\n vector lastIds;\n vector lastCost;\n\n for (int p = 0; p < L; p++) {\n int c = letters[p];\n const auto &curIds = positions[c];\n vector curCost(curIds.size(), INF);\n parent[p].assign(curIds.size(), (int16_t)-1);\n\n for (int i = 0; i < (int)curIds.size(); i++) {\n int v = curIds[i];\n long long best = INF;\n int bestPrevCell = -1;\n for (int j = 0; j < (int)prevIds.size(); j++) {\n long long cand = prevCost[j] + manhattan(prevIds[j], v);\n if (cand < best) {\n best = cand;\n bestPrevCell = prevIds[j];\n }\n }\n curCost[i] = best + 1;\n parent[p][i] = (int16_t)bestPrevCell;\n }\n\n prevIds = curIds;\n prevCost.swap(curCost);\n lastIds = prevIds;\n lastCost = prevCost;\n }\n\n // Choose best ending cell\n int bestK = 0;\n for (int i = 1; i < (int)lastCost.size(); i++) {\n if (lastCost[i] < lastCost[bestK]) bestK = i;\n }\n\n // Backtrack\n vector answerCells(L);\n int curCell = lastIds[bestK];\n\n for (int p = L - 1; p >= 0; p--) {\n answerCells[p] = curCell;\n int c = letters[p];\n int k = idxInLetter[c][curCell];\n // k should be valid\n int prevCell = (int)parent[p][k];\n curCell = prevCell;\n }\n\n // Output coordinates for each operation\n for (int p = 0; p < L; p++) {\n int id = answerCells[p];\n cout << (id / N) << ' ' << (id % N) << '\\n';\n }\n\n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n explicit XorShift(uint64_t seed = 0) {\n if (seed) x ^= seed;\n for (int i = 0; i < 10; i++) next_u64();\n }\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Placement {\n vector cells; // indices in [0, N*N)\n vector contrib; // per mask: sum of signs on those cells\n};\n\nstatic inline void flush_out() { cout << flush; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed_ms = [&]() -> double {\n auto t1 = chrono::high_resolution_clock::now();\n return chrono::duration(t1 - t0).count();\n };\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector>> shapes(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n shapes[k].resize(d);\n for (int i = 0; i < d; i++) {\n int r, c;\n cin >> r >> c;\n shapes[k][i] = {r, c};\n }\n }\n\n const int V = N * N;\n\n // Choose number of random masks (T). Keep it moderate for speed.\n // With N<=20, V<=400. T=50~60 is usually enough for a decent fit.\n int T = 50;\n if (V <= 144) T = 45;\n if (V >= 361) T = 55;\n // One repetition per mask pair\n int R = 1;\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n // Random balanced masks: sign[t][idx] in {-1,+1}\n vector> sign(T, vector(V, -1));\n vector> Aset(T), Bset(T);\n vector perm(V);\n\n for (int t = 0; t < T; t++) {\n iota(perm.begin(), perm.end(), 0);\n for (int i = V - 1; i >= 1; i--) {\n int j = (int)(rng.next_u64() % (uint64_t)(i + 1));\n swap(perm[i], perm[j]);\n }\n int half = V / 2;\n Aset[t].clear(); Bset[t].clear();\n Aset[t].reserve(half + 1);\n Bset[t].reserve(V - half + 1);\n for (int i = 0; i < V; i++) {\n int idx = perm[i];\n if (i < half) { sign[t][idx] = +1; Aset[t].push_back(idx); }\n else { sign[t][idx] = -1; Bset[t].push_back(idx); }\n }\n }\n\n auto inv_est = [&](long long y, int k) -> float {\n // E[y] = k*eps + (1-2eps)*v(S)\n double denom = (1.0 - 2.0 * eps);\n double vhat = ((double)y - (double)k * eps) / denom;\n if (vhat < 0.0) vhat = 0.0;\n double hi = (double)k * (double)M;\n if (vhat > hi) vhat = hi;\n return (float)vhat;\n };\n\n auto query_set = [&](const vector& idxs) -> long long {\n int d = (int)idxs.size();\n cout << \"q \" << d;\n for (int idx : idxs) {\n int i = idx / N, j = idx % N;\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n flush_out();\n long long resp;\n cin >> resp;\n return resp;\n };\n\n // Observe random projections: obs[t] ~ sum sign[t][idx] * v(idx)\n vector obs(T, 0.0f);\n for (int t = 0; t < T; t++) {\n float acc = 0.0f;\n for (int rep = 0; rep < R; rep++) {\n long long yA = query_set(Aset[t]);\n long long yB = query_set(Bset[t]);\n float vA = inv_est(yA, (int)Aset[t].size());\n float vB = inv_est(yB, (int)Bset[t].size());\n acc += (vA - vB);\n }\n obs[t] = acc / (float)R;\n }\n\n // Enumerate placements + contrib precompute\n vector> placements(M);\n for (int k = 0; k < M; k++) {\n int maxr = 0, maxc = 0;\n for (auto [r, c] : shapes[k]) {\n maxr = max(maxr, r);\n maxc = max(maxc, c);\n }\n int H = maxr + 1, W = maxc + 1;\n int diMax = N - H, djMax = N - W;\n\n vector ps;\n ps.reserve((diMax + 1) * (djMax + 1));\n\n for (int di = 0; di <= diMax; di++) {\n for (int dj = 0; dj <= djMax; dj++) {\n Placement p;\n p.cells.reserve(shapes[k].size());\n for (auto [r, c] : shapes[k]) {\n int ii = di + r, jj = dj + c;\n p.cells.push_back(ii * N + jj);\n }\n p.contrib.assign(T, 0);\n\n // Cache-friendly: for each t, sum signs over cells\n for (int t = 0; t < T; t++) {\n int s = 0;\n const auto &st = sign[t];\n for (int idx : p.cells) s += (int)st[idx];\n p.contrib[t] = (int16_t)s;\n }\n\n ps.push_back(std::move(p));\n }\n }\n placements[k] = std::move(ps);\n }\n\n // Coordinate descent optimization over placements\n vector choice(M, 0);\n for (int k = 0; k < M; k++) {\n choice[k] = rng.next_int(0, (int)placements[k].size() - 1);\n }\n\n vector pred(T, 0);\n for (int t = 0; t < T; t++) {\n int s = 0;\n for (int k = 0; k < M; k++) s += (int)placements[k][choice[k]].contrib[t];\n pred[t] = s;\n }\n\n // A few sweeps; stop if time is close.\n // This is extremely fast compared to SA.\n int maxSweeps = 60;\n for (int sweep = 0; sweep < maxSweeps; sweep++) {\n if (elapsed_ms() > 2100.0) break; // time guard (leave room for fallback I/O)\n\n bool changed = false;\n for (int k = 0; k < M; k++) {\n const int curP = choice[k];\n\n // base_pred = pred - contrib(curP)\n // objective for placement p:\n // sum_t (base_pred[t] + contrib[p][t] - obs[t])^2\n vector base_res(T);\n for (int t = 0; t < T; t++) {\n int base_pred_t = pred[t] - (int)placements[k][curP].contrib[t];\n base_res[t] = (float)base_pred_t - obs[t];\n }\n\n int bestP = curP;\n double bestObj = 1e100;\n\n const auto &pk = placements[k];\n for (int p = 0; p < (int)pk.size(); p++) {\n double o = 0.0;\n const auto &con = pk[p].contrib;\n for (int t = 0; t < T; t++) {\n float r = base_res[t] + (float)con[t];\n o += (double)r * (double)r;\n }\n if (o < bestObj) {\n bestObj = o;\n bestP = p;\n }\n }\n\n if (bestP != curP) {\n // apply update to pred\n for (int t = 0; t < T; t++) {\n pred[t] += (int)placements[k][bestP].contrib[t] - (int)placements[k][curP].contrib[t];\n }\n choice[k] = bestP;\n changed = true;\n }\n }\n if (!changed) break;\n }\n\n // Build union cells from inferred placements\n vector oil(V, 0);\n for (int k = 0; k < M; k++) {\n for (int idx : placements[k][choice[k]].cells) oil[idx] = 1;\n }\n vector> ansCells;\n ansCells.reserve(V);\n for (int idx = 0; idx < V; idx++) if (oil[idx]) ansCells.push_back({idx / N, idx % N});\n\n auto output_answer = [&](const vector>& cells) -> int {\n cout << \"a \" << (int)cells.size();\n for (auto [i, j] : cells) cout << \" \" << i << \" \" << j;\n cout << \"\\n\";\n flush_out();\n int ok;\n cin >> ok;\n return ok;\n };\n\n // First attempt\n {\n int ok = output_answer(ansCells);\n if (ok == 1) return 0;\n }\n\n // Fallback: drill everything (guaranteed)\n vector> finalCells;\n finalCells.reserve(V);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n flush_out();\n long long v;\n cin >> v;\n if (v > 0) finalCells.push_back({i, j});\n }\n }\n (void)output_answer(finalCells);\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstatic const int W = 1000;\n\nstruct DemInfo {\n vector s; // sorted demands over days\n vector pref; // pref sums, size D+1\n ll total = 0;\n int D = 0;\n\n void build(const vector& v) {\n s = v;\n sort(s.begin(), s.end());\n D = (int)s.size();\n pref.assign(D + 1, 0);\n for (int i = 0; i < D; i++) pref[i + 1] = pref[i] + s[i];\n total = pref[D];\n }\n\n // cost = 100 * sum max(0, a - cap)\n ll cost_cap(ll cap) const {\n int pos = upper_bound(s.begin(), s.end(), (int)cap) - s.begin(); // first > cap\n int cnt = D - pos;\n if (cnt <= 0) return 0;\n ll sum_gt = total - pref[pos];\n ll shortage = sum_gt - cap * 1LL * cnt;\n return 100LL * shortage;\n }\n};\n\nstruct Column {\n int l = 0, r = 0; // rank indices [l,r)\n int w = 1;\n vector h; // heights for stacked rects, size r-l, sum=1000\n};\n\nstruct Rect {\n int i0, j0, i1, j1;\n int area() const { return (i1 - i0) * (j1 - j0); }\n};\n\nstruct Node {\n ll gain;\n int p;\n bool operator<(const Node& o) const { return gain < o.gain; } // max heap\n};\n\n// Allocate heights in a column by greedy marginal gain on each item's cap=w*h\nstatic Column recompute_column(int l, int r, int w, const vector& demRank) {\n Column col;\n col.l = l; col.r = r; col.w = w;\n int m = r - l;\n col.h.assign(m, 1);\n if (m <= 0) return col;\n\n int remaining = W - m;\n int maxH = W - (m - 1);\n\n struct Item { int h; ll c0, c1; };\n vector it(m);\n\n priority_queue pq;\n for (int p = 0; p < m; p++) {\n int rank = l + p;\n it[p].h = 1;\n it[p].c0 = demRank[rank].cost_cap(1LL * w * 1);\n it[p].c1 = (maxH >= 2) ? demRank[rank].cost_cap(1LL * w * 2) : it[p].c0;\n pq.push({it[p].c0 - it[p].c1, p});\n }\n\n while (remaining > 0 && !pq.empty()) {\n auto [gain, p] = pq.top(); pq.pop();\n if (it[p].h >= maxH) continue;\n\n // apply +1\n it[p].h++;\n it[p].c0 = it[p].c1;\n if (it[p].h < maxH) {\n it[p].c1 = demRank[l + p].cost_cap(1LL * w * (it[p].h + 1));\n pq.push({it[p].c0 - it[p].c1, p});\n }\n remaining--;\n }\n\n for (int p = 0; p < m; p++) col.h[p] = it[p].h;\n return col;\n}\n\nstatic vector build_rects(const vector& cols) {\n vector rects;\n rects.reserve(60);\n int x = 0;\n for (auto &c : cols) {\n int y = 0;\n for (int hh : c.h) {\n rects.push_back({y, x, y + hh, x + c.w});\n y += hh;\n }\n x += c.w;\n }\n return rects;\n}\n\nstatic ll eval_score_sorted_areas(const vector& rects, const vector& demRank) {\n int N = (int)rects.size();\n vector areas(N);\n for (int i = 0; i < N; i++) areas[i] = rects[i].area();\n sort(areas.begin(), areas.end());\n ll tot = 0;\n for (int k = 0; k < N; k++) tot += demRank[k].cost_cap(areas[k]);\n return tot;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int W_in, D, N;\n cin >> W_in >> D >> N;\n\n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) for (int k = 0; k < N; k++) cin >> a[d][k];\n\n // demRank[k] corresponds to the k-th smallest demand each day (fixed by input order)\n vector demRank(N);\n for (int k = 0; k < N; k++) {\n vector v(D);\n for (int d = 0; d < D; d++) v[d] = a[d][k];\n demRank[k].build(v);\n }\n\n // avg demand per rank\n vector avgA(N, 0.0);\n for (int k = 0; k < N; k++) {\n ll s = 0;\n for (int d = 0; d < D; d++) s += a[d][k];\n avgA[k] = (double)s / (double)D;\n }\n\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n auto st = chrono::high_resolution_clock::now();\n auto ms = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - st).count();\n };\n const double TL_MS = 2850.0;\n\n // Try a few candidate column counts and pick best initial\n vector bestCols;\n ll bestScore = (1LL<<62);\n\n int maxC = min(20, N);\n for (int C : {2, 3, 4, 5, 6, 8, 10, 12, 15, 18, 20}) {\n if (C > maxC) continue;\n // equal consecutive groups\n vector start(C + 1, 0);\n int base = N / C, rem = N % C;\n int cur = 0;\n start[0] = 0;\n for (int c = 0; c < C; c++) {\n int sz = base + (c < rem ? 1 : 0);\n cur += sz;\n start[c + 1] = cur;\n }\n\n // widths proportional to group avg sum\n vector width(C, 1);\n vector gsum(C, 0.0);\n double total = 0.0;\n for (int c = 0; c < C; c++) {\n double s = 0.0;\n for (int k = start[c]; k < start[c + 1]; k++) s += avgA[k];\n gsum[c] = s;\n total += s;\n }\n vector frac(C, 0.0);\n int used = 0;\n for (int c = 0; c < C; c++) {\n double x = (total > 0 ? 1000.0 * gsum[c] / total : 1000.0 / C);\n int w = (int)floor(x);\n w = max(1, w);\n width[c] = w;\n used += w;\n frac[c] = x - floor(x);\n }\n while (used < 1000) {\n int best = 0;\n for (int c = 1; c < C; c++) if (frac[c] > frac[best]) best = c;\n width[best]++; used++;\n frac[best] = -1e9;\n }\n while (used > 1000) {\n int best = -1;\n for (int c = 0; c < C; c++) if (width[c] > 1) {\n if (best < 0 || frac[c] < frac[best]) best = c;\n }\n if (best < 0) break;\n width[best]--; used--;\n frac[best] = 1e9;\n }\n\n vector cols(C);\n for (int c = 0; c < C; c++) cols[c] = recompute_column(start[c], start[c + 1], width[c], demRank);\n\n auto rects = build_rects(cols);\n ll sc = eval_score_sorted_areas(rects, demRank);\n if (sc < bestScore) {\n bestScore = sc;\n bestCols = std::move(cols);\n }\n if (ms() > TL_MS * 0.35) break;\n }\n\n // Local search on bestCols: boundary move / width transfer, accept if true score improves\n vector cols = bestCols;\n\n auto current_rects = build_rects(cols);\n ll curScore = eval_score_sorted_areas(current_rects, demRank);\n\n int C = (int)cols.size();\n auto get_start = [&]() {\n vector start(C + 1, 0);\n start[0] = cols[0].l;\n for (int c = 0; c < C; c++) start[c] = cols[c].l;\n start[C] = cols[C - 1].r;\n for (int c = 0; c < C; c++) start[c + 1] = cols[c].r;\n return start;\n };\n auto get_widths = [&]() {\n vector w(C);\n for (int c = 0; c < C; c++) w[c] = cols[c].w;\n return w;\n };\n\n int iters = 0;\n while (ms() < TL_MS) {\n iters++;\n int c = uniform_int_distribution(0, C - 2)(rng);\n bool doBoundary = (uniform_int_distribution(0, 1)(rng) == 0);\n\n vector start = get_start();\n vector width = get_widths();\n\n if (doBoundary) {\n int b = c + 1;\n int dir = uniform_int_distribution(0, 1)(rng) ? +1 : -1;\n int leftSize = start[b] - start[b - 1];\n int rightSize = start[b + 1] - start[b];\n if (dir == -1) { if (leftSize <= 1) continue; start[b]--; }\n else { if (rightSize <= 1) continue; start[b]++; }\n\n // rebuild affected columns\n vector ncols = cols;\n ncols[c] = recompute_column(start[c], start[c + 1], width[c], demRank);\n ncols[c + 1] = recompute_column(start[c + 1], start[c + 2], width[c + 1], demRank);\n\n auto rects = build_rects(ncols);\n ll sc = eval_score_sorted_areas(rects, demRank);\n if (sc < curScore) {\n cols.swap(ncols);\n curScore = sc;\n current_rects.swap(rects);\n }\n } else {\n int dir = uniform_int_distribution(0, 1)(rng) ? +1 : -1;\n if (dir == +1) { // c -> c+1\n if (width[c] <= 1) continue;\n width[c]--; width[c + 1]++;\n } else { // c+1 -> c\n if (width[c + 1] <= 1) continue;\n width[c]++; width[c + 1]--;\n }\n\n vector ncols = cols;\n ncols[c].w = width[c];\n ncols[c + 1].w = width[c + 1];\n // l,r unchanged\n ncols[c] = recompute_column(ncols[c].l, ncols[c].r, ncols[c].w, demRank);\n ncols[c + 1] = recompute_column(ncols[c + 1].l, ncols[c + 1].r, ncols[c + 1].w, demRank);\n\n auto rects = build_rects(ncols);\n ll sc = eval_score_sorted_areas(rects, demRank);\n if (sc < curScore) {\n cols.swap(ncols);\n curScore = sc;\n current_rects.swap(rects);\n }\n }\n }\n\n // Final rectangles\n auto rects = build_rects(cols);\n\n // IMPORTANT FIX: output rectangles sorted by area so reservation k (sorted demand) gets k-th smallest area\n vector ord(N);\n iota(ord.begin(), ord.end(), 0);\n stable_sort(ord.begin(), ord.end(), [&](int i, int j) {\n return rects[i].area() < rects[j].area();\n });\n\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n const Rect &rc = rects[ord[k]];\n cout << rc.i0 << ' ' << rc.j0 << ' ' << rc.i1 << ' ' << rc.j1 << \"\\n\";\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nstatic constexpr int N = 9;\nstatic constexpr int M = 20;\nstatic constexpr int POS = 7;\nstatic constexpr int A = M * POS * POS; // 980 actions\nstatic constexpr int MOD = 998244353;\nstatic constexpr int CELLS = N * N;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline int nextInt(int n) { return (int)(nextU64() % (uint64_t)n); }\n inline double nextDouble01() {\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Entry {\n uint8_t cell; // 0..80\n int v; // 0..MOD-1\n};\n\nstatic inline int contribCell(int r, int v) {\n // (r+v mod MOD) - r\n int t = r + v;\n if (t >= MOD) return v - MOD;\n return v;\n}\n\nstruct State {\n array board{};\n array delta{}; // marginal gain of adding each action once\n long long score = 0;\n vector ops; // size K, each in [-1, A-1]\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, K;\n cin >> Nin >> Min >> K;\n\n array a{};\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v; cin >> v;\n a[i * N + j] = v;\n }\n\n int s[M][3][3];\n for (int m = 0; m < M; m++)\n for (int i = 0; i < 3; i++)\n for (int j = 0; j < 3; j++)\n cin >> s[m][i][j];\n\n // Precompute actions as 9 entries (cell, v)\n array, A> action{};\n for (int m = 0; m < M; m++) {\n for (int p = 0; p < POS; p++) for (int q = 0; q < POS; q++) {\n int id = m * 49 + p * 7 + q;\n int k = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int x = p + di, y = q + dj;\n int cell = x * N + y;\n action[id][k++] = Entry{(uint8_t)cell, s[m][di][dj]};\n }\n }\n }\n\n // For each cell, list of (action_id, v_in_that_action_for_this_cell)\n array>, CELLS> affects;\n for (int c = 0; c < CELLS; c++) affects[c].clear();\n for (int id = 0; id < A; id++) {\n for (auto &e : action[id]) {\n affects[e.cell].push_back({id, e.v});\n }\n }\n\n auto decode = [&](int id) {\n int m = id / 49;\n int r = id % 49;\n int p = r / 7;\n int q = r % 7;\n return array{m,p,q};\n };\n\n XorShift64 rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto initState = [&]() -> State {\n State st;\n st.ops.assign(K, -1);\n st.score = 0;\n for (int c = 0; c < CELLS; c++) {\n st.board[c] = a[c];\n st.score += st.board[c];\n }\n // init delta from scratch\n for (int id = 0; id < A; id++) {\n long long d = 0;\n for (auto &e : action[id]) d += contribCell(st.board[e.cell], e.v);\n st.delta[id] = d;\n }\n return st;\n };\n\n auto applyAction = [&](State &st, int id, int sign) {\n if (id < 0) return;\n // Update board, score, and delta[] incrementally via affected cells.\n for (auto &e : action[id]) {\n int c = e.cell;\n int v = e.v;\n int oldr = st.board[c];\n int newr;\n if (sign == +1) {\n newr = oldr + v;\n if (newr >= MOD) newr -= MOD;\n } else {\n newr = oldr - v;\n if (newr < 0) newr += MOD;\n }\n if (newr == oldr) continue;\n st.board[c] = newr;\n st.score += (long long)(newr - oldr);\n\n // This cell's residue changed => update delta for all actions touching this cell\n for (auto &[aid, vv] : affects[c]) {\n st.delta[aid] += (long long)contribCell(newr, vv) - (long long)contribCell(oldr, vv);\n }\n }\n };\n\n auto bestInsert = [&](const State &st) -> pair {\n long long bestD = 0;\n int bestId = -1;\n for (int id = 0; id < A; id++) {\n long long d = st.delta[id];\n if (d > bestD) { bestD = d; bestId = id; }\n }\n return {bestD, bestId};\n };\n\n auto randomTopInsert = [&](const State &st, int TOPT, XorShift64 &rng) -> int {\n // keep top TOPT by delta (positive only), then weighted random by delta\n vector> top;\n top.reserve(TOPT);\n for (int id = 0; id < A; id++) {\n long long d = st.delta[id];\n if (d <= 0) continue;\n if ((int)top.size() < TOPT) {\n top.push_back({d,id});\n if ((int)top.size() == TOPT) {\n make_heap(top.begin(), top.end(), greater<>());\n }\n } else if (d > top.front().first) {\n pop_heap(top.begin(), top.end(), greater<>());\n top.back() = {d,id};\n push_heap(top.begin(), top.end(), greater<>());\n }\n }\n if (top.empty()) return -1;\n long double sum = 0;\n for (auto &p : top) sum += (long double)p.first;\n long double r = (long double)rng.nextDouble01() * sum;\n for (auto &p : top) {\n r -= (long double)p.first;\n if (r <= 0) return p.second;\n }\n return top.back().second;\n };\n\n auto coordPass = [&](State &st) -> bool {\n // 1-slot best response for each slot, shuffled\n vector order(K);\n iota(order.begin(), order.end(), 0);\n for (int i = K - 1; i > 0; i--) swap(order[i], order[rng.nextInt(i + 1)]);\n\n bool changed = false;\n for (int idx : order) {\n int oldId = st.ops[idx];\n if (oldId >= 0) applyAction(st, oldId, -1);\n\n auto [bd, bestId] = bestInsert(st);\n st.ops[idx] = bestId;\n if (bestId >= 0) applyAction(st, bestId, +1);\n\n if (bestId != oldId) changed = true;\n }\n return changed;\n };\n\n auto localOptimize = [&](State &st) {\n for (int it = 0; it < 8; it++) {\n if (!coordPass(st)) break;\n }\n };\n\n auto greedyBuild = [&](State &st, int TOPT) {\n for (int t = 0; t < K; t++) {\n int id;\n if (rng.nextInt(100) < 70) id = randomTopInsert(st, TOPT, rng);\n else id = bestInsert(st).second;\n if (id < 0) break;\n st.ops[t] = id;\n applyAction(st, id, +1);\n }\n };\n\n const double TIME_LIMIT = 1.95;\n auto t0 = chrono::steady_clock::now();\n auto elapsedSec = [&]() -> double {\n return chrono::duration(chrono::steady_clock::now() - t0).count();\n };\n\n // Multi-start initialization (more starts thanks to speedup)\n State best;\n best.score = LLONG_MIN;\n {\n int starts = 10;\n for (int i = 0; i < starts; i++) {\n State st = initState();\n greedyBuild(st, 14);\n localOptimize(st);\n if (st.score > best.score) best = st;\n }\n }\n State cur = best;\n\n // LNS + SA acceptance between local optima\n const double T0 = 3.0e9;\n const double T1 = 5.0e4;\n\n vector contrib(K);\n vector idxs(K);\n\n while (true) {\n double et = elapsedSec();\n if (et >= TIME_LIMIT) break;\n double prog = et / TIME_LIMIT;\n double T = T0 * pow(T1 / T0, prog);\n\n State trial = cur;\n\n // Ruin size schedule: larger early, smaller late\n int ruin = 20 - (int)(12 * prog); // 20 -> 8\n ruin = max(8, min(20, ruin));\n\n // Approx contribution of each op by temporary removal\n for (int i = 0; i < K; i++) {\n idxs[i] = i;\n int id = trial.ops[i];\n if (id < 0) { contrib[i] = 0; continue; }\n long long before = trial.score;\n applyAction(trial, id, -1);\n long long after = trial.score;\n applyAction(trial, id, +1);\n contrib[i] = before - after; // positive if it helps\n }\n\n nth_element(idxs.begin(), idxs.begin() + ruin, idxs.end(),\n [&](int x, int y){ return contrib[x] < contrib[y]; });\n\n vector ruined;\n ruined.reserve(ruin + 8);\n int takeWorst = (ruin * 7) / 10;\n for (int i = 0; i < takeWorst; i++) ruined.push_back(idxs[i]);\n while ((int)ruined.size() < ruin) ruined.push_back(rng.nextInt(K));\n sort(ruined.begin(), ruined.end());\n ruined.erase(unique(ruined.begin(), ruined.end()), ruined.end());\n\n // Ruin\n for (int i : ruined) {\n int id = trial.ops[i];\n if (id >= 0) applyAction(trial, id, -1);\n trial.ops[i] = -1;\n }\n\n // Recreate\n int TOPT = 18;\n for (int i : ruined) {\n int id;\n if (rng.nextInt(100) < 45) id = randomTopInsert(trial, TOPT, rng);\n else id = bestInsert(trial).second;\n trial.ops[i] = id;\n if (id >= 0) applyAction(trial, id, +1);\n }\n\n // Intensify\n localOptimize(trial);\n\n long long deltaScore = trial.score - cur.score;\n bool accept = false;\n if (deltaScore >= 0) accept = true;\n else {\n double prob = exp((double)deltaScore / T);\n if (rng.nextDouble01() < prob) accept = true;\n }\n if (accept) cur = std::move(trial);\n if (cur.score > best.score) best = cur;\n\n if (rng.nextInt(100) < 4) cur = best; // occasional reset to best\n }\n\n // Output non-null ops\n vector> out;\n out.reserve(K);\n for (int i = 0; i < K; i++) {\n if (best.ops[i] >= 0) out.push_back(decode(best.ops[i]));\n }\n\n cout << out.size() << \"\\n\";\n for (auto &x : out) {\n cout << x[0] << \" \" << x[1] << \" \" << x[2] << \"\\n\";\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstatic constexpr int N = 5;\nstatic constexpr int MAXT = 10000;\n\nstruct Pos { int x, y; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin;\n cin >> Nin;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> A[i][j];\n\n // For each container id, where/when it will arrive (receiving row, index).\n vector recv_row(N*N, -1), recv_idx(N*N, -1);\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int id = A[i][j];\n recv_row[id] = i;\n recv_idx[id] = j;\n }\n\n // Grid: -1 empty, otherwise container id.\n int grid[N][N];\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) grid[i][j] = -1;\n\n // Container positions:\n // (-2,-2) unspawned, (-1,-1) dispatched, otherwise location on grid.\n vector cont_pos(N*N, Pos{-2,-2});\n\n // Receiving pointer per row: next container index to spawn from that receiving gate.\n int next_in[N] = {0,0,0,0,0};\n\n // Large crane state (only crane 0 is used after bombing others)\n Pos crane{0,0};\n int holding = -1; // container id, -1 if none\n\n // Output action strings\n vector out(N);\n deque plan; // planned actions for large crane\n\n auto in_bounds = [&](int x, int y)->bool{\n return 0 <= x && x < N && 0 <= y && y < N;\n };\n\n auto manhattan_plan = [&](Pos from, Pos to) {\n // Simple Manhattan route: vertical then horizontal.\n while (from.x < to.x) { plan.push_back('D'); from.x++; }\n while (from.x > to.x) { plan.push_back('U'); from.x--; }\n while (from.y < to.y) { plan.push_back('R'); from.y++; }\n while (from.y > to.y) { plan.push_back('L'); from.y--; }\n };\n\n auto is_empty = [&](int x, int y)->bool{\n return grid[x][y] == -1;\n };\n\n auto find_storage = [&]()->Pos{\n // Prefer interior columns 1..3 (never dispatch column 4).\n for (int y = 1; y <= 3; y++) {\n for (int x = 0; x < N; x++) {\n if (grid[x][y] == -1) return Pos{x,y};\n }\n }\n // Next, allow left edge rows already fully spawned.\n for (int x = 0; x < N; x++) {\n if (next_in[x] >= N && grid[x][0] == -1) return Pos{x,0};\n }\n // Finally, any empty non-dispatch cell.\n for (int x = 0; x < N; x++) for (int y = 0; y < N; y++) {\n if (y == N-1) continue;\n if (grid[x][y] == -1) return Pos{x,y};\n }\n // Should never happen; at least current cell is empty after a pick, but return it.\n return crane;\n };\n\n auto next_target = [&]()->int{\n for (int t = 0; t < N*N; t++) {\n if (!(cont_pos[t].x == -1 && cont_pos[t].y == -1)) {\n // not dispatched\n // But if unspawned (-2,-2) it's still not dispatched, keep as target.\n return t;\n }\n }\n return -1;\n };\n\n auto dispatched_count = [&]()->int{\n int c = 0;\n for (int t = 0; t < N*N; t++) if (cont_pos[t].x == -1) c++;\n return c;\n };\n\n // Simulation loop\n for (int turn = 0; turn < MAXT; turn++) {\n // Step 1: receiving\n for (int i = 0; i < N; i++) {\n if (next_in[i] >= N) continue;\n // Condition: no container at (i,0) and no crane holding a container at (i,0).\n // We have only large crane. It can stand there empty-handed without blocking.\n bool crane_holding_here = (holding != -1 && crane.x == i && crane.y == 0);\n if (grid[i][0] == -1 && !crane_holding_here) {\n int id = A[i][next_in[i]];\n next_in[i]++;\n grid[i][0] = id;\n cont_pos[id] = Pos{i,0};\n }\n }\n\n // Ensure output strings have current turn slot.\n for (int i = 0; i < N; i++) out[i].push_back('.');\n\n // Small cranes: bomb at turn 0, then do nothing\n if (turn == 0) {\n for (int i = 1; i < N; i++) out[i][turn] = 'B';\n }\n\n // Large crane action planning\n int tgt = next_target();\n if (tgt == -1) {\n // all dispatched, we can stop early (but need at least 1 length; already have).\n // Trim trailing '.' is allowed but not necessary.\n break;\n }\n\n if (plan.empty()) {\n int target = tgt;\n\n // If holding something, decide where to put it.\n if (holding != -1) {\n int want = target;\n int dr = holding / N;\n // If holding is exactly the next target, go dispatch it.\n if (holding == want) {\n Pos gate{dr, N-1};\n if (!(crane.x == gate.x && crane.y == gate.y)) {\n manhattan_plan(crane, gate);\n }\n plan.push_back('Q');\n } else {\n // Drop to storage\n Pos st = find_storage();\n if (!(crane.x == st.x && crane.y == st.y)) {\n manhattan_plan(crane, st);\n }\n plan.push_back('Q');\n }\n } else {\n // Not holding: if target is on grid, pick and dispatch.\n if (cont_pos[target].x >= 0) {\n Pos p = cont_pos[target];\n if (!(crane.x == p.x && crane.y == p.y)) {\n manhattan_plan(crane, p);\n }\n plan.push_back('P');\n Pos gate{target / N, N-1};\n // after pick, crane remains on p; route from p to gate\n manhattan_plan(p, gate);\n plan.push_back('Q');\n } else {\n // Target not spawned yet: go to its receiving gate and clear until it appears.\n int rr = recv_row[target];\n Pos g{rr, 0};\n if (!(crane.x == g.x && crane.y == g.y)) {\n manhattan_plan(crane, g);\n } else {\n // We're on the gate. After receiving step, there should be a container unless exhausted.\n if (grid[rr][0] != -1) {\n int c = grid[rr][0];\n if (c == target) {\n plan.push_back('P');\n Pos gate{target / N, N-1};\n manhattan_plan(g, gate);\n plan.push_back('Q');\n } else {\n // Pick and store it away.\n plan.push_back('P');\n // after pick, need a place to drop\n Pos st = find_storage();\n manhattan_plan(g, st);\n plan.push_back('Q');\n }\n } else {\n // Shouldn't happen unless the row is exhausted; just wait.\n plan.push_back('.');\n }\n }\n }\n }\n }\n\n // Execute one action for the large crane this turn\n char act0 = plan.empty() ? '.' : plan.front();\n if (!plan.empty()) plan.pop_front();\n out[0][turn] = act0;\n\n // Step 2: apply large crane action\n auto do_move = [&](int dx, int dy) {\n int nx = crane.x + dx, ny = crane.y + dy;\n if (!in_bounds(nx, ny)) return false;\n crane = Pos{nx, ny};\n return true;\n };\n\n bool ok = true;\n if (act0 == '.') {\n // nothing\n } else if (act0 == 'U') ok = do_move(-1, 0);\n else if (act0 == 'D') ok = do_move(1, 0);\n else if (act0 == 'L') ok = do_move(0, -1);\n else if (act0 == 'R') ok = do_move(0, 1);\n else if (act0 == 'P') {\n if (holding != -1) ok = false;\n else {\n int &cell = grid[crane.x][crane.y];\n if (cell == -1) ok = false;\n else {\n holding = cell;\n cont_pos[holding] = Pos{-3,-3}; // held\n cell = -1;\n }\n }\n } else if (act0 == 'Q') {\n if (holding == -1) ok = false;\n else {\n int &cell = grid[crane.x][crane.y];\n if (cell != -1) ok = false;\n else {\n cell = holding;\n cont_pos[holding] = crane;\n holding = -1;\n }\n }\n } else {\n // 'B' not used for large\n ok = false;\n }\n\n // If something went wrong, fall back to safe no-op from now (avoid UB),\n // but in normal operation this should never trigger.\n if (!ok) {\n // Output a minimal valid solution instead of crashing:\n // just stop planning further.\n // (In contest you'd rather assert(false), but keep it safe.)\n plan.clear();\n }\n\n // Step 3: dispatch\n for (int i = 0; i < N; i++) {\n int &cell = grid[i][N-1];\n if (cell != -1) {\n int id = cell;\n cell = -1;\n cont_pos[id] = Pos{-1,-1}; // dispatched\n\n // We don't strictly need to verify correctness, but you can sanity-check:\n // if (id/5 != i) { /* wrong gate */ }\n }\n }\n\n // If all dispatched, we can stop early (keeping current length is fine).\n if (dispatched_count() == N*N) break;\n }\n\n // Remove trailing '.' uniformly? Not required. Just output as-is.\n // Ensure at least length 1 (guaranteed by loop or by turn==0 push).\n for (int i = 0; i < N; i++) {\n if (out[i].empty()) out[i] = \".\";\n cout << out[i] << \"\\n\";\n }\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstatic inline uint64_t splitmix64(uint64_t &x) {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n}\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed=1) : x(seed) {}\n uint64_t nextU64() { return splitmix64(x); }\n int nextInt(int lo, int hi) { return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1)); }\n double nextDouble() {\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline int vid(int r,int c,int N){ return r*N+c; }\n\nstruct EvalResult {\n long long cost = (1LL<<62);\n int firstChoice = 0; // which neighbor of start to take first\n long long B = 0;\n};\n\nstatic inline bool hasEdge(const array& nb, int v) {\n return nb[0] == v || nb[1] == v;\n}\nstatic inline void replaceNeighbor(array& nb, int oldv, int newv) {\n if (nb[0] == oldv) nb[0] = newv;\n else if (nb[1] == oldv) nb[1] = newv;\n}\n\nstatic inline char dirChar(int u, int v, int N) {\n int ur=u/N, uc=u%N;\n int vr=v/N, vc=v%N;\n if (vr==ur-1 && vc==uc) return 'U';\n if (vr==ur+1 && vc==uc) return 'D';\n if (vr==ur && vc==uc-1) return 'L';\n if (vr==ur && vc==uc+1) return 'R';\n return '?';\n}\n\n// Traverse the undirected cycle starting at 0, picking neighbor choice 0/1 for the first step.\n// Returns ok and order of visited vertices excluding start, length V-1.\nstatic pair> traverseCycle(const vector>& nei, int N, int firstChoice) {\n int V = N*N;\n int start = 0;\n int first = nei[start][firstChoice];\n if (first < 0) return {false, {}};\n\n vector order;\n order.reserve(V-1);\n vector vis(V, 0);\n vis[start] = 1;\n\n int prev = start;\n int cur = first;\n for (int step=0; step=V) return {false, {}};\n if (vis[cur]) return {false, {}};\n vis[cur]=1;\n order.push_back(cur);\n\n int n0=nei[cur][0], n1=nei[cur][1];\n int nxt = (n0==prev)? n1 : n0;\n prev = cur;\n cur = nxt;\n }\n if (cur != start) return {false, {}};\n for (int i=0;i& H, const vector>& nei, int N, int firstChoice) {\n auto [ok, proc] = traverseCycle(nei, N, firstChoice);\n if (!ok) return {};\n\n int h00 = H[0];\n\n long long pref=0, minPref=0;\n for (int v: proc) {\n pref += H[v];\n minPref = min(minPref, pref);\n }\n long long B = max({0LL, -minPref, (long long)h00});\n\n long long cost=0;\n long long load=0;\n\n // initial +B at start\n cost += B;\n load += B;\n\n // traverse V-1 edges, fixing each visited cell\n for (int v: proc) {\n cost += 100 + load; // move\n cost += llabs((long long)H[v]); // load/unload\n load += H[v];\n if (load < 0) return {}; // should not happen with computed B\n }\n\n // final move back to start (cycle closure)\n cost += 100 + load;\n // unload everything at start\n cost += load;\n\n EvalResult res;\n res.cost = cost;\n res.firstChoice = firstChoice;\n res.B = B;\n return res;\n}\n\nstatic EvalResult evalCycle(const vector& H, const vector>& nei, int N) {\n EvalResult a = evalDirection(H, nei, N, 0);\n EvalResult b = evalDirection(H, nei, N, 1);\n return (a.cost <= b.cost ? a : b);\n}\n\nstatic vector> neighborsFromProcCycle(int N, const vector& proc) {\n int V=N*N;\n vector> nei(V);\n for (int i=0;i>& nei, int N) {\n auto [ok0, _0] = traverseCycle(nei, N, 0);\n if (ok0) return true;\n auto [ok1, _1] = traverseCycle(nei, N, 1);\n return ok1;\n}\n\n// 2x2 plaquette flip\nstruct FlipRecord { int a,b,c,d; int mode; bool applied=false; };\n\nstatic FlipRecord tryFlip(vector>& nei, int N, int r, int c) {\n int a=vid(r,c,N);\n int b=vid(r,c+1,N);\n int c1=vid(r+1,c,N);\n int d=vid(r+1,c+1,N);\n\n bool ab = hasEdge(nei[a], b);\n bool cd = hasEdge(nei[c1], d);\n bool ac = hasEdge(nei[a], c1);\n bool bd = hasEdge(nei[b], d);\n\n FlipRecord rec;\n if (ab && cd && !ac && !bd) {\n // horiz -> vert\n replaceNeighbor(nei[a], b, c1);\n replaceNeighbor(nei[b], a, d);\n replaceNeighbor(nei[c1], d, a);\n replaceNeighbor(nei[d], c1, b);\n rec = {a,b,c1,d,0,true};\n } else if (ac && bd && !ab && !cd) {\n // vert -> horiz\n replaceNeighbor(nei[a], c1, b);\n replaceNeighbor(nei[b], d, a);\n replaceNeighbor(nei[c1], a, d);\n replaceNeighbor(nei[d], b, c1);\n rec = {a,b,c1,d,1,true};\n } else {\n rec.applied=false;\n }\n return rec;\n}\n\nstatic void undoFlip(vector>& nei, const FlipRecord& rec) {\n if (!rec.applied) return;\n int a=rec.a,b=rec.b,c1=rec.c,d=rec.d;\n if (rec.mode==0) {\n // undo vert->horiz\n replaceNeighbor(nei[a], c1, b);\n replaceNeighbor(nei[b], d, a);\n replaceNeighbor(nei[c1], a, d);\n replaceNeighbor(nei[d], b, c1);\n } else {\n // undo horiz->vert\n replaceNeighbor(nei[a], b, c1);\n replaceNeighbor(nei[b], a, d);\n replaceNeighbor(nei[c1], d, a);\n replaceNeighbor(nei[d], c1, b);\n }\n}\n\n// Build output ops for the best cycle+direction\nstatic vector buildOutput(const vector& H, const vector>& nei, int N, int firstChoice, long long B) {\n auto [ok, proc] = traverseCycle(nei, N, firstChoice);\n if (!ok) return {};\n\n vector ops;\n ops.reserve(1200);\n\n auto emitMove=[&](char ch){ ops.push_back(string(1,ch)); };\n auto emitLoad=[&](long long d){ if(d>0) ops.push_back(\"+\"+to_string(d)); };\n auto emitUnload=[&](long long d){ if(d>0) ops.push_back(\"-\"+to_string(d)); };\n\n long long load=0;\n int cur=0;\n if (B>0) { emitLoad(B); load+=B; }\n\n for (int v: proc) {\n emitMove(dirChar(cur, v, N));\n cur=v;\n int hv=H[v];\n if (hv>0) { emitLoad(hv); load+=hv; }\n else if (hv<0) { emitUnload(- (long long)hv); load+=hv; }\n }\n // cycle closure move\n emitMove(dirChar(cur, 0, N));\n cur=0;\n\n if (load>0) { emitUnload(load); load=0; }\n return ops;\n}\n\n// Two diverse base cycles (proc order excluding start), both ensure last adjacent to start.\n\nstatic vector baseCycleA(int N) {\n // Down column 0, then rows bottom->top serpentine over columns 1..N-1.\n // Ends at (0,1) for even N=20 => adjacent to start.\n vector seq; seq.reserve(N*N-1);\n for (int r=1;r=0;r--) {\n int t = (N-1-r);\n if (t%2==0) {\n for (int c=1;c=1;c--) seq.push_back(vid(r,c,N));\n }\n }\n return seq;\n}\n\nstatic vector baseCycleB(int N) {\n // Right along row 0, then columns from right->left with rows 1..N-1 serpentine.\n // For even N=20 ends at (1,0) => adjacent to start.\n vector seq; seq.reserve(N*N-1);\n for (int c=1;c=0;c--) {\n int t = (N-1-c);\n if (t%2==0) {\n for (int r=1;r=1;r--) seq.push_back(vid(r,c,N));\n }\n }\n return seq;\n}\n\n// 8 symmetries mapping (r,c) -> (r',c')\nstatic inline pair symMap(int s, int r, int c, int N) {\n switch(s) {\n case 0: return {r,c}; // identity\n case 1: return {c, N-1-r}; // rot90\n case 2: return {N-1-r, N-1-c}; // rot180\n case 3: return {N-1-c, r}; // rot270\n case 4: return {r, N-1-c}; // mirror vertical\n case 5: return {N-1-r, c}; // mirror horizontal\n case 6: return {c, r}; // transpose\n case 7: return {N-1-c, N-1-r}; // anti-diagonal reflection\n }\n return {r,c};\n}\n\nstatic vector> applySymmetryToCycle(const vector>& nei, int N, int s) {\n int V=N*N;\n vector mp(V);\n for (int r=0;r> out(V);\n for (int v=0; v out[nv][1]) swap(out[nv][0], out[nv][1]);\n }\n return out;\n}\n\nstruct Candidate {\n vector> nei;\n EvalResult eval;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N; cin >> N;\n int V=N*N;\n vector H(V);\n for (int r=0;r> x;\n H[vid(r,c,N)] = x;\n }\n\n // Build base cycles and their symmetries\n vector> baseProcs;\n baseProcs.push_back(baseCycleA(N));\n baseProcs.push_back(baseCycleB(N));\n\n vector cands;\n cands.reserve(16);\n\n for (auto &proc : baseProcs) {\n auto baseNei = neighborsFromProcCycle(N, proc);\n for (int s=0;s<8;s++) {\n auto nei = applySymmetryToCycle(baseNei, N, s);\n if (!isSingleCycleFromStart(nei, N)) continue;\n Candidate cand;\n cand.nei = std::move(nei);\n cand.eval = evalCycle(H, cand.nei, N);\n cands.push_back(std::move(cand));\n }\n }\n\n // Fallback if something went wrong (shouldn't)\n if (cands.empty()) {\n auto proc = baseCycleA(N);\n Candidate cand;\n cand.nei = neighborsFromProcCycle(N, proc);\n cand.eval = evalCycle(H, cand.nei, N);\n cands.push_back(std::move(cand));\n }\n\n sort(cands.begin(), cands.end(), [&](const Candidate& a, const Candidate& b){\n return a.eval.cost < b.eval.cost;\n });\n\n // Multi-start SA: run on top K candidates with split time\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n RNG rng(seed);\n\n auto globalStart = chrono::high_resolution_clock::now();\n const double TL = 1.90;\n\n vector> bestNei = cands[0].nei;\n EvalResult bestEval = cands[0].eval;\n long long bestCost = bestEval.cost;\n\n int K = min(4, (int)cands.size());\n for (int k=0;k> curNei = cands[k].nei;\n EvalResult curEval = cands[k].eval;\n long long curCost = curEval.cost;\n\n auto start = chrono::high_resolution_clock::now();\n // allocate remaining time fairly\n auto nowG = chrono::high_resolution_clock::now();\n double elapsedG = chrono::duration(nowG - globalStart).count();\n double rem = TL - elapsedG;\n if (rem <= 0.02) break;\n double each = rem / (K - k);\n double Tlimit = max(0.05, each);\n\n const double T0 = 20000.0, T1 = 50.0;\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double e = chrono::duration(now - start).count();\n if (e > Tlimit) break;\n\n double prog = e / Tlimit;\n double temp = T0 * pow(T1 / T0, prog);\n\n int r = rng.nextInt(0, N-2);\n int c = rng.nextInt(0, N-2);\n\n auto rec = tryFlip(curNei, N, r, c);\n if (!rec.applied) continue;\n\n if (!isSingleCycleFromStart(curNei, N)) {\n undoFlip(curNei, rec);\n continue;\n }\n\n EvalResult newEval = evalCycle(H, curNei, N);\n long long newCost = newEval.cost;\n\n bool accept=false;\n if (newCost <= curCost) accept=true;\n else {\n double prob = exp((double)(curCost - newCost) / temp);\n if (rng.nextDouble() < prob) accept=true;\n }\n\n if (accept) {\n curCost = newCost;\n curEval = newEval;\n if (newCost < bestCost) {\n bestCost = newCost;\n bestEval = newEval;\n bestNei = curNei;\n }\n } else {\n undoFlip(curNei, rec);\n }\n }\n }\n\n auto ops = buildOutput(H, bestNei, N, bestEval.firstChoice, bestEval.B);\n for (auto &s: ops) cout << s << \"\\n\";\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nstatic constexpr int N = 6;\nstatic constexpr int M = 15;\n\nstruct XorShift64 {\n uint64_t x = 88172645463325252ull;\n explicit XorShift64(uint64_t seed = 0) {\n if (seed) x ^= seed + 0x9e3779b97f4a7c15ULL;\n }\n uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int lo, int hi) { // [lo, hi)\n return lo + (int)(nextU64() % (uint64_t)(hi - lo));\n }\n double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Seed {\n array x{};\n int v = 0;\n int mx = 0;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, T;\n cin >> Nin >> Min >> T;\n const int S = 2 * Nin * (Nin - 1); // 60\n\n vector seeds(S);\n\n auto readSeeds = [&]() {\n for (int i = 0; i < S; i++) {\n int sum = 0, mx = 0;\n for (int l = 0; l < M; l++) {\n int a; cin >> a;\n seeds[i].x[l] = a;\n sum += a;\n mx = max(mx, a);\n }\n seeds[i].v = sum;\n seeds[i].mx = mx;\n }\n };\n\n readSeeds();\n\n auto pid = [&](int r, int c){ return r * N + c; };\n\n vector> edges;\n edges.reserve(60);\n for (int r = 0; r < N; r++) for (int c = 0; c < N - 1; c++)\n edges.push_back({pid(r,c), pid(r,c+1)});\n for (int r = 0; r < N - 1; r++) for (int c = 0; c < N; c++)\n edges.push_back({pid(r,c), pid(r+1,c)});\n\n array, 36> nbr;\n for (auto [a,b] : edges) {\n nbr[a].push_back(b);\n nbr[b].push_back(a);\n }\n\n // Checkerboard positions\n vector blackPos, whitePos;\n blackPos.reserve(18); whitePos.reserve(18);\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) {\n if (((r + c) & 1) == 0) blackPos.push_back(pid(r,c));\n else whitePos.push_back(pid(r,c));\n }\n\n XorShift64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());\n\n // Pair utility matrix\n vector> w(S, vector(S, 0.0));\n\n auto buildPairUtility = [&](int turn) {\n // More \"tail seeking\" early, more \"stable\" later\n double zTail = 3.2 - 0.1 * turn; // t=0 -> 3.2, t=9 -> 2.3\n double tau = 80.0; // moderate max-like behavior\n\n for (int i = 0; i < S; i++) {\n for (int j = i + 1; j < S; j++) {\n double mean = 0.5 * (seeds[i].v + seeds[j].v);\n\n double diff2 = 0.0;\n int best = 0;\n for (int l = 0; l < M; l++) {\n int a = seeds[i].x[l], b = seeds[j].x[l];\n double d = double(a - b);\n diff2 += d * d;\n best += max(a, b);\n }\n double st = 0.5 * sqrt(diff2);\n\n // Tail-ish proxy but bounded by the theoretical max-of-components\n double pot = min(best, mean + zTail * st);\n\n double val = exp(pot / tau);\n w[i][j] = w[j][i] = val;\n }\n w[i][i] = exp(seeds[i].v / 80.0);\n }\n };\n\n auto select36 = [&]() -> vector {\n // Combined score keeps elites + spiky seeds\n const double beta = 5.0; // mx up to 100 => +500 max\n vector ids(S);\n iota(ids.begin(), ids.end(), 0);\n\n vector score(S);\n for (int i = 0; i < S; i++) score[i] = seeds[i].v + beta * seeds[i].mx;\n\n sort(ids.begin(), ids.end(), [&](int a, int b){\n if (score[a] != score[b]) return score[a] > score[b];\n return seeds[a].v > seeds[b].v;\n });\n\n vector picked(ids.begin(), ids.begin() + 36);\n vector in(S, 0);\n for (int x : picked) in[x] = 1;\n\n // Enforce per-criterion maxima (important to keep specialists)\n for (int l = 0; l < M; l++) {\n int bestId = 0;\n for (int i = 1; i < S; i++) if (seeds[i].x[l] > seeds[bestId].x[l]) bestId = i;\n if (in[bestId]) continue;\n\n // replace worst by score in picked\n int worstIdx = 0;\n for (int i = 1; i < 36; i++) {\n if (score[picked[i]] < score[picked[worstIdx]]) worstIdx = i;\n }\n in[picked[worstIdx]] = 0;\n picked[worstIdx] = bestId;\n in[bestId] = 1;\n }\n\n // Also ensure top-by-sum elites are present (stabilizer)\n vector byV(S);\n iota(byV.begin(), byV.end(), 0);\n sort(byV.begin(), byV.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n\n int mustKeep = 12;\n for (int i = 0; i < mustKeep; i++) {\n int id = byV[i];\n if (in[id]) continue;\n // replace worst again (but avoid kicking out another elite if possible)\n int worstIdx = -1;\n double worstSc = 1e100;\n for (int j = 0; j < 36; j++) {\n // try not to remove a top-elite already inside\n bool isElite = false;\n for (int k = 0; k < mustKeep; k++) if (picked[j] == byV[k]) { isElite = true; break; }\n if (isElite) continue;\n if (score[picked[j]] < worstSc) {\n worstSc = score[picked[j]];\n worstIdx = j;\n }\n }\n if (worstIdx == -1) {\n // fallback: replace absolute worst\n worstIdx = 0;\n for (int j = 1; j < 36; j++) if (score[picked[j]] < score[picked[worstIdx]]) worstIdx = j;\n }\n in[picked[worstIdx]] = 0;\n picked[worstIdx] = id;\n in[id] = 1;\n }\n\n return picked;\n };\n\n auto calcObjective = [&](const vector& grid) -> double {\n double obj = 0.0;\n for (auto [a,b] : edges) obj += w[grid[a]][grid[b]];\n return obj;\n };\n\n auto swapDelta = [&](const vector& grid, int p, int q) -> double {\n int A = grid[p], B = grid[q];\n double delta = 0.0;\n\n for (int n : nbr[p]) {\n if (n == q) continue;\n int C = grid[n];\n delta += w[B][C] - w[A][C];\n }\n for (int n : nbr[q]) {\n if (n == p) continue;\n int C = grid[n];\n delta += w[A][C] - w[B][C];\n }\n return delta;\n };\n\n auto initLayouts = [&](const vector& picked) -> vector> {\n vector> inits;\n\n // 1) Random\n {\n vector perm = picked;\n for (int i = 35; i >= 1; i--) {\n int j = rng.nextInt(0, i + 1);\n swap(perm[i], perm[j]);\n }\n vector grid(36);\n for (int i = 0; i < 36; i++) grid[i] = perm[i];\n inits.push_back(grid);\n }\n\n // 2) Sorted by V row-major\n {\n vector perm = picked;\n sort(perm.begin(), perm.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n vector grid(36);\n for (int i = 0; i < 36; i++) grid[i] = perm[i];\n inits.push_back(grid);\n }\n\n // 3) Checkerboard high/low split\n {\n vector perm = picked;\n sort(perm.begin(), perm.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n\n vector grid(36, -1);\n for (int i = 0; i < 18; i++) grid[blackPos[i]] = perm[i];\n for (int i = 0; i < 18; i++) grid[whitePos[i]] = perm[18 + i];\n inits.push_back(grid);\n }\n\n // 4) Another random (different)\n {\n vector perm = picked;\n for (int i = 35; i >= 1; i--) {\n int j = rng.nextInt(0, i + 1);\n swap(perm[i], perm[j]);\n }\n vector grid(36);\n for (int i = 0; i < 36; i++) grid[i] = perm[i];\n inits.push_back(grid);\n }\n\n return inits;\n };\n\n auto solvePlacementSA = [&](const vector& picked, double timeLimitSec) -> vector {\n auto start = chrono::steady_clock::now();\n auto deadline = start + chrono::duration(timeLimitSec);\n\n vector bestGrid(36);\n double bestObj = -1e100;\n\n auto inits = initLayouts(picked);\n\n // SA schedule parameters\n const double T0 = 3000.0;\n const double T1 = 8.0;\n\n for (auto curGrid : inits) {\n double curObj = calcObjective(curGrid);\n vector localBestGrid = curGrid;\n double localBestObj = curObj;\n\n while (chrono::steady_clock::now() < deadline) {\n double tprog = chrono::duration(chrono::steady_clock::now() - start).count() / timeLimitSec;\n if (tprog > 1.0) tprog = 1.0;\n double temp = T0 * pow(T1 / T0, tprog);\n\n int p = rng.nextInt(0, 36);\n int q = rng.nextInt(0, 36);\n if (p == q) continue;\n\n double delta = swapDelta(curGrid, p, q);\n if (delta >= 0.0 || rng.nextDouble() < exp(delta / temp)) {\n swap(curGrid[p], curGrid[q]);\n curObj += delta;\n if (curObj > localBestObj) {\n localBestObj = curObj;\n localBestGrid = curGrid;\n }\n }\n }\n\n if (localBestObj > bestObj) {\n bestObj = localBestObj;\n bestGrid = localBestGrid;\n }\n\n if (chrono::steady_clock::now() >= deadline) break;\n }\n\n return bestGrid;\n };\n\n auto allStart = chrono::steady_clock::now();\n auto allDeadline = allStart + chrono::milliseconds(1900);\n\n for (int t = 0; t < T; t++) {\n buildPairUtility(t);\n vector picked = select36();\n\n auto now = chrono::steady_clock::now();\n double remain = chrono::duration(allDeadline - now).count();\n if (remain < 0.02) remain = 0.02;\n double perTurn = remain / (T - t);\n\n vector grid = solvePlacementSA(picked, perTurn * 0.95);\n\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n if (c) cout << ' ';\n cout << grid[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n\n readSeeds();\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Pos { int x, y; };\n\nstatic inline int mod4(int x){ x%=4; if(x<0) x+=4; return x; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n\n vector> cur(N, vector(N, 0));\n vector> surplus(N, vector(N, 0)); // cur=1, target=0\n vector> deficit(N, vector(N, 0)); // cur=0, target=1\n\n int surplusCnt = 0, deficitCnt = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n cur[i][j] = (s[i][j] == '1');\n int T = (t[i][j] == '1');\n if (cur[i][j] == 1 && T == 0) surplus[i][j] = 1, surplusCnt++;\n if (cur[i][j] == 0 && T == 1) deficit[i][j] = 1, deficitCnt++;\n }\n\n auto inside = [&](int x, int y)->bool {\n return 0 <= x && x < N && 0 <= y && y < N;\n };\n\n // Arm: root(0) + 4 leaves length 1\n const int Vp = 5;\n cout << Vp << \"\\n\";\n for (int u = 1; u < Vp; u++) cout << 0 << \" \" << 1 << \"\\n\";\n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n\n // Directions: 0=Up,1=Right,2=Down,3=Left\n int dx4[4] = {-1, 0, 1, 0};\n int dy4[4] = {0, 1, 0, -1};\n\n // Per-leaf direction and holding state\n array dir; dir.fill(1); // initially all edges to the right\n array hold{}; hold.fill(0);\n\n auto holdingCount = [&](){\n int c = 0;\n for (int u = 1; u <= 4; u++) c += (hold[u] != 0);\n return c;\n };\n\n auto done = [&]() {\n if (surplusCnt != 0 || deficitCnt != 0) return false;\n for (int u = 1; u <= 4; u++) if (hold[u]) return false;\n return true;\n };\n\n auto rotCharToReach = [&](int from, int to)->char {\n if (from == to) return '.';\n if (mod4(from + 1) == to) return 'R';\n if (mod4(from + 3) == to) return 'L';\n return '?'; // needs 2 steps\n };\n auto minRotDist = [&](int from, int to)->int {\n int cw = mod4(to - from);\n int ccw = mod4(from - to);\n return min(cw, ccw); // 0,1,2\n };\n\n struct Plan {\n array rot; // for vertices 1..4\n array actP; // 'P' or '.'\n int places = 0;\n int picks = 0;\n };\n\n // Immediate (<=1 rotation) placements then picks, maximizing counts.\n auto planImmediateAt = [&](int px, int py)->Plan {\n Plan out;\n out.rot.fill('.');\n out.actP.fill('.');\n out.places = 0;\n out.picks = 0;\n\n array isDef{}, isSur{};\n for (int d = 0; d < 4; d++) {\n int nx = px + dx4[d], ny = py + dy4[d];\n if (!inside(nx, ny)) { isDef[d] = 0; isSur[d] = 0; continue; }\n isDef[d] = deficit[nx][ny];\n isSur[d] = surplus[nx][ny];\n }\n\n array rotTmp; rotTmp.fill('.');\n array actTmp; actTmp.fill('.');\n array usedDir{}; usedDir.fill(0);\n\n int bestPlace = -1, bestPlaceCost = 1e9;\n array bestRotP, bestActP;\n array bestUsedP;\n\n function dfsPlace = [&](int u, int placeCnt, int rotCost) {\n if (u == 5) {\n if (placeCnt > bestPlace || (placeCnt == bestPlace && rotCost < bestPlaceCost)) {\n bestPlace = placeCnt;\n bestPlaceCost = rotCost;\n bestRotP = rotTmp;\n bestActP = actTmp;\n bestUsedP = usedDir;\n }\n return;\n }\n if (u == 0) { dfsPlace(u+1, placeCnt, rotCost); return; }\n\n // do nothing\n dfsPlace(u+1, placeCnt, rotCost);\n\n if (!hold[u]) return;\n\n for (int d = 0; d < 4; d++) if (isDef[d] && !usedDir[d]) {\n if (minRotDist(dir[u], d) > 1) continue;\n char rc = rotCharToReach(dir[u], d);\n if (rc == '?') continue;\n\n usedDir[d] = 1;\n char pr = rotTmp[u], pa = actTmp[u];\n rotTmp[u] = rc;\n actTmp[u] = 'P';\n dfsPlace(u+1, placeCnt+1, rotCost + (rc!='.'));\n rotTmp[u] = pr;\n actTmp[u] = pa;\n usedDir[d] = 0;\n }\n };\n dfsPlace(1, 0, 0);\n\n rotTmp = bestRotP;\n actTmp = bestActP;\n usedDir = bestUsedP;\n\n int bestPick = -1, bestPickCost = 1e9;\n array bestRot, bestAct;\n\n function dfsPick = [&](int u, int pickCnt, int rotCost) {\n if (u == 5) {\n if (pickCnt > bestPick || (pickCnt == bestPick && rotCost < bestPickCost)) {\n bestPick = pickCnt;\n bestPickCost = rotCost;\n bestRot = rotTmp;\n bestAct = actTmp;\n }\n return;\n }\n if (u == 0) { dfsPick(u+1, pickCnt, rotCost); return; }\n\n // do nothing\n dfsPick(u+1, pickCnt, rotCost);\n\n if (hold[u]) return;\n\n for (int d = 0; d < 4; d++) if (isSur[d] && !usedDir[d]) {\n if (minRotDist(dir[u], d) > 1) continue;\n char rc = rotCharToReach(dir[u], d);\n if (rc == '?') continue;\n\n usedDir[d] = 1;\n char pr = rotTmp[u], pa = actTmp[u];\n rotTmp[u] = rc;\n actTmp[u] = 'P';\n dfsPick(u+1, pickCnt+1, rotCost + (rc!='.'));\n rotTmp[u] = pr;\n actTmp[u] = pa;\n usedDir[d] = 0;\n }\n };\n dfsPick(1, 0, 0);\n\n out.rot = bestRot;\n out.actP = bestAct;\n out.places = max(0, bestPlace);\n out.picks = max(0, bestPick);\n return out;\n };\n\n // If an adjacent actionable cell exists but needs 180-degree (2-step) rotation, do one prep rotation.\n // We implement BOTH for placing (holding finger) and picking (free finger).\n auto planPrep180At = [&](int px, int py)->optional> {\n // Prefer placing prep (usually more urgent), else picking prep.\n // For a required direction d, if dist==2, rotate once ('R') to make dist==1 next turn.\n for (int d = 0; d < 4; d++) {\n int nx = px + dx4[d], ny = py + dy4[d];\n if (!inside(nx, ny) || !deficit[nx][ny]) continue;\n for (int u = 1; u <= 4; u++) if (hold[u]) {\n if (minRotDist(dir[u], d) == 2) return make_pair(u, 'R');\n }\n }\n for (int d = 0; d < 4; d++) {\n int nx = px + dx4[d], ny = py + dy4[d];\n if (!inside(nx, ny) || !surplus[nx][ny]) continue;\n for (int u = 1; u <= 4; u++) if (!hold[u]) {\n if (minRotDist(dir[u], d) == 2) return make_pair(u, 'R');\n }\n }\n return nullopt;\n };\n\n auto applyTurn = [&](char mv, const array& rotCmd, const array& actCmd)->int {\n // returns number of changes (pick/place)\n int changes = 0;\n\n // move\n if (mv == 'U') rx--;\n else if (mv == 'D') rx++;\n else if (mv == 'L') ry--;\n else if (mv == 'R') ry++;\n\n // rotate\n for (int u = 1; u <= 4; u++) {\n if (rotCmd[u] == 'L') dir[u] = mod4(dir[u] + 3);\n else if (rotCmd[u] == 'R') dir[u] = mod4(dir[u] + 1);\n }\n\n // actions (vertex order)\n for (int u = 1; u <= 4; u++) {\n if (actCmd[u] != 'P') continue;\n int d = dir[u];\n int x = rx + dx4[d], y = ry + dy4[d];\n if (!inside(x, y)) continue;\n\n if (hold[u]) {\n if (deficit[x][y]) {\n hold[u] = 0;\n cur[x][y] = 1;\n deficit[x][y] = 0;\n deficitCnt--;\n changes++;\n }\n } else {\n if (surplus[x][y]) {\n hold[u] = 1;\n cur[x][y] = 0;\n surplus[x][y] = 0;\n surplusCnt--;\n changes++;\n }\n }\n }\n return changes;\n };\n\n // Choose goal root position (neighbor of an active deficit/surplus cell) minimizing manhattan distance.\n auto chooseGoal = [&]()->optional {\n int h = holdingCount();\n bool wantPlace = (h > 0 && deficitCnt > 0);\n bool wantPick = (h < 4 && surplusCnt > 0);\n\n auto bestNeighborOf = [&](const vector>& grid)->optional {\n int bestDist = INT_MAX;\n Pos best{-1,-1};\n for (int x = 0; x < N; x++) for (int y = 0; y < N; y++) if (grid[x][y]) {\n for (int d = 0; d < 4; d++) {\n int nx = x - dx4[d];\n int ny = y - dy4[d];\n if (!inside(nx, ny)) continue;\n int dist = abs(nx - rx) + abs(ny - ry);\n if (dist < bestDist) {\n bestDist = dist;\n best = {nx, ny};\n }\n }\n }\n if (bestDist == INT_MAX) return nullopt;\n return best;\n };\n\n if (wantPlace) {\n if (auto g = bestNeighborOf(deficit)) return g;\n }\n if (wantPick) {\n if (auto g = bestNeighborOf(surplus)) return g;\n }\n // Fallback\n if (deficitCnt > 0) if (auto g = bestNeighborOf(deficit)) return g;\n if (surplusCnt > 0) if (auto g = bestNeighborOf(surplus)) return g;\n return nullopt;\n };\n\n auto stepToward = [&](Pos goal)->char {\n if (rx < goal.x) return 'D';\n if (rx > goal.x) return 'U';\n if (ry < goal.y) return 'R';\n if (ry > goal.y) return 'L';\n return '.';\n };\n\n // Build snake route for fallback sweep\n vector snake;\n snake.reserve(N * N);\n for (int i = 0; i < N; i++) {\n if (i % 2 == 0) for (int j = 0; j < N; j++) snake.push_back({i, j});\n else for (int j = N - 1; j >= 0; j--) snake.push_back({i, j});\n }\n int snakeIdx = 0;\n\n auto moveChar = [&](Pos a, Pos b)->char {\n int dx = b.x - a.x, dy = b.y - a.y;\n if (dx == -1 && dy == 0) return 'U';\n if (dx == 1 && dy == 0) return 'D';\n if (dx == 0 && dy == -1) return 'L';\n if (dx == 0 && dy == 1) return 'R';\n return '.';\n };\n\n const int MAXT = 100000;\n int turns = 0;\n\n // Init: spread leaves a bit (as before)\n {\n string cmd(2*Vp, '.');\n cmd[1] = 'L';\n cmd[3] = 'R';\n cmd[4] = 'R';\n cout << cmd << \"\\n\";\n turns++;\n array rotCmd; rotCmd.fill('.');\n rotCmd[1]='L'; rotCmd[3]='R'; rotCmd[4]='R';\n array actCmd; actCmd.fill('.');\n applyTurn('.', rotCmd, actCmd);\n }\n if (turns < MAXT) {\n string cmd(2*Vp, '.');\n cmd[4] = 'R';\n cout << cmd << \"\\n\";\n turns++;\n array rotCmd; rotCmd.fill('.');\n rotCmd[4]='R';\n array actCmd; actCmd.fill('.');\n applyTurn('.', rotCmd, actCmd);\n }\n\n int noChangeTurns = 0;\n bool sweepMode = false;\n\n while (turns < MAXT && !done()) {\n // Try immediate action at current cell\n Plan stay = planImmediateAt(rx, ry);\n if (stay.places + stay.picks > 0) {\n string cmd(2*Vp, '.');\n cmd[0] = '.';\n for (int u = 1; u <= 4; u++) cmd[u] = stay.rot[u];\n cmd[Vp] = '.';\n for (int u = 1; u <= 4; u++) cmd[Vp + u] = stay.actP[u];\n cout << cmd << \"\\n\";\n turns++;\n int ch = applyTurn('.', stay.rot, stay.actP);\n if (ch > 0) noChangeTurns = 0; else noChangeTurns++;\n if (ch > 0) sweepMode = false;\n continue;\n }\n\n // Try 180-degree prep at current cell (for place OR pick)\n if (auto prep = planPrep180At(rx, ry)) {\n array rotCmd; rotCmd.fill('.');\n array actCmd; actCmd.fill('.');\n rotCmd[prep->first] = prep->second;\n\n string cmd(2*Vp, '.');\n cmd[0] = '.';\n for (int u = 1; u <= 4; u++) cmd[u] = rotCmd[u];\n cout << cmd << \"\\n\";\n turns++;\n int ch = applyTurn('.', rotCmd, actCmd);\n (void)ch;\n noChangeTurns++; // no pick/place\n continue;\n }\n\n // If we made no progress for long, enable sweep fallback\n if (noChangeTurns > 200) sweepMode = true;\n\n // Decide movement\n char mv = '.';\n int nRx = rx, nRy = ry;\n\n if (sweepMode) {\n // move along snake route toward next position (re-sync snakeIdx if needed)\n // find current index if mismatch occasionally\n if (!(snake[snakeIdx].x == rx && snake[snakeIdx].y == ry)) {\n int best = 0, bestDist = INT_MAX;\n for (int i = 0; i < (int)snake.size(); i++) {\n int dist = abs(snake[i].x - rx) + abs(snake[i].y - ry);\n if (dist < bestDist) bestDist = dist, best = i;\n }\n snakeIdx = best;\n }\n int nxt = (snakeIdx + 1) % (int)snake.size();\n mv = moveChar(snake[snakeIdx], snake[nxt]);\n snakeIdx = nxt;\n } else {\n auto goalOpt = chooseGoal();\n if (goalOpt) mv = stepToward(*goalOpt);\n }\n\n if (mv == 'U') nRx--;\n else if (mv == 'D') nRx++;\n else if (mv == 'L') nRy--;\n else if (mv == 'R') nRy++;\n if (!inside(nRx, nRy)) { mv = '.'; nRx = rx; nRy = ry; }\n\n // Plan actions after move\n Plan after = planImmediateAt(nRx, nRy);\n\n // If mv='.' and still no action, do a prep even here to avoid idling at a \"goal\"\n array rotCmd = after.rot;\n array actCmd = after.actP;\n\n if (mv == '.' && after.places + after.picks == 0) {\n if (auto prep = planPrep180At(rx, ry)) {\n rotCmd.fill('.');\n actCmd.fill('.');\n rotCmd[prep->first] = prep->second;\n }\n }\n\n string cmd(2*Vp, '.');\n cmd[0] = mv;\n for (int u = 1; u <= 4; u++) cmd[u] = rotCmd[u];\n cmd[Vp] = '.';\n for (int u = 1; u <= 4; u++) cmd[Vp + u] = actCmd[u];\n\n cout << cmd << \"\\n\";\n turns++;\n int ch = applyTurn(mv, rotCmd, actCmd);\n if (ch > 0) {\n noChangeTurns = 0;\n sweepMode = false;\n } else {\n noChangeTurns++;\n }\n }\n\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int l, int r) { return l + (int)(next_u64() % (uint64_t)(r - l + 1)); } // inclusive\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n};\n\nstatic inline double now_sec() {\n using namespace std::chrono;\n return duration_cast>(steady_clock::now().time_since_epoch()).count();\n}\n\nstruct Point {\n int x, y;\n int w; // +1 mackerel, -1 sardine\n};\n\nstruct Rect { // inclusive\n int xl, xr, yb, yt;\n};\n\nstatic inline Rect clamp_rect(Rect r) {\n r.xl = max(0, min(100000, r.xl));\n r.xr = max(0, min(100000, r.xr));\n r.yb = max(0, min(100000, r.yb));\n r.yt = max(0, min(100000, r.yt));\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n if (w + h > 200000) {\n int cx = (r.xl + r.xr) / 2;\n int cy = (r.yb + r.yt) / 2;\n long long over = (w + h) - 200000;\n long long rw = min(over, w - 1);\n long long rh = min(over - rw, h - 1);\n long long neww = max(1LL, w - rw);\n long long newh = max(1LL, h - rh);\n\n r.xl = cx - (int)(neww / 2);\n r.xr = r.xl + (int)neww;\n r.yb = cy - (int)(newh / 2);\n r.yt = r.yb + (int)newh;\n\n if (r.xl < 0) { r.xr -= r.xl; r.xl = 0; }\n if (r.yb < 0) { r.yt -= r.yb; r.yb = 0; }\n if (r.xr > 100000) { int d = r.xr - 100000; r.xl -= d; r.xr = 100000; if (r.xl < 0) r.xl = 0; }\n if (r.yt > 100000) { int d = r.yt - 100000; r.yb -= d; r.yt = 100000; if (r.yb < 0) r.yb = 0; }\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n }\n return r;\n}\nstatic inline bool rect_ok(const Rect& r) {\n if (r.xl < 0 || r.xr > 100000 || r.yb < 0 || r.yt > 100000) return false;\n if (r.xl >= r.xr || r.yb >= r.yt) return false;\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n return (w + h <= 200000);\n}\n\n// ---- Static 2D BIT for fast rectangle evaluation ----\nstruct BIT2DStatic {\n struct Node {\n vector ys;\n vector pref; // size = ys.size()+1\n vector> tmp;\n };\n int M;\n vector xs;\n vector bit;\n\n void build(const vector& pts) {\n xs.clear();\n xs.reserve(pts.size());\n for (auto &p: pts) xs.push_back(p.x);\n sort(xs.begin(), xs.end());\n xs.erase(unique(xs.begin(), xs.end()), xs.end());\n M = (int)xs.size();\n bit.assign(M+1, Node());\n\n for (auto &p: pts) {\n int xi = (int)(lower_bound(xs.begin(), xs.end(), p.x) - xs.begin()) + 1;\n for (int j = xi; j <= M; j += j & -j) bit[j].tmp.push_back({p.y, p.w});\n }\n\n for (int j = 1; j <= M; j++) {\n auto &t = bit[j].tmp;\n sort(t.begin(), t.end());\n vector ys;\n vector sums;\n ys.reserve(t.size());\n sums.reserve(t.size());\n for (int k = 0; k < (int)t.size();) {\n int y = t[k].first;\n int s = 0;\n while (k < (int)t.size() && t[k].first == y) {\n s += t[k].second;\n k++;\n }\n ys.push_back(y);\n sums.push_back(s);\n }\n bit[j].ys = move(ys);\n bit[j].pref.assign(bit[j].ys.size()+1, 0);\n for (int i = 0; i < (int)sums.size(); i++) bit[j].pref[i+1] = bit[j].pref[i] + sums[i];\n bit[j].tmp.clear();\n bit[j].tmp.shrink_to_fit();\n }\n }\n\n inline int node_query(const Node& nd, int yBound) const {\n // sum for y <= yBound\n int pos = (int)(upper_bound(nd.ys.begin(), nd.ys.end(), yBound) - nd.ys.begin());\n return nd.pref[pos];\n }\n\n inline int prefix_query(int xBound, int yBound) const {\n if (xBound < 0 || yBound < 0) return 0;\n int xi = (int)(upper_bound(xs.begin(), xs.end(), xBound) - xs.begin()); // 0..M\n int res = 0;\n for (int j = xi; j > 0; j -= j & -j) res += node_query(bit[j], yBound);\n return res;\n }\n\n inline int rect_sum_inclusive(const Rect& r) const {\n int A = prefix_query(r.xr, r.yt);\n int B = prefix_query(r.xl - 1, r.yt);\n int C = prefix_query(r.xr, r.yb - 1);\n int D = prefix_query(r.xl - 1, r.yb - 1);\n return A - B - C + D;\n }\n};\n\n// ----- Staircase (x-monotone orthogonal polygon) -----\n\n// strict overlap to avoid degeneracy/self-touch\nstatic inline bool gap_ok(int Li, int Ui, int Lj, int Uj) {\n return max(Li, Lj) < min(Ui, Uj);\n}\n\nstatic inline long long Vlen_full(const vector& L, const vector& U) {\n int K = (int)L.size();\n long long v = 0;\n v += (long long)U[0] - L[0];\n v += (long long)U[K-1] - L[K-1];\n for (int i = 1; i < K; i++) {\n v += llabs((long long)L[i] - L[i-1]);\n v += llabs((long long)U[i] - U[i-1]);\n }\n return v;\n}\nstatic inline bool perim_ok(int XL, int XR, long long Vlen) {\n long long H = 2LL * (XR - XL);\n return H + Vlen <= 400000;\n}\n\nstruct SlabDS {\n vector ys; // sorted\n vector pref; // pref[0]=0, pref[i+1]=sum(0..i)\n // for candidate making\n vector> yw; // (y,w) sorted by y\n vector my; // mackerel ys sorted\n inline int range_sum(int L, int U) const {\n auto itl = lower_bound(ys.begin(), ys.end(), L);\n auto itu = upper_bound(ys.begin(), ys.end(), U);\n int l = (int)(itl - ys.begin());\n int r = (int)(itu - ys.begin());\n return pref[r] - pref[l];\n }\n};\n\nstatic inline vector build_xs(int XL, int XR, int K) {\n vector xs(K+1);\n xs[0] = XL;\n xs[K] = XR;\n long long width = (long long)XR - XL;\n for (int i = 1; i < K; i++) {\n int x = XL + (int)(width * i / K);\n xs[i] = x;\n }\n // enforce strict increasing\n for (int i = 1; i <= K; i++) xs[i] = max(xs[i], xs[i-1] + 1);\n xs[K] = XR;\n for (int i = K-1; i >= 0; i--) xs[i] = min(xs[i], xs[i+1] - 1);\n xs[0] = XL; xs[K] = XR;\n // final strict fix (fallback)\n for (int i = 1; i <= K; i++) if (xs[i] <= xs[i-1]) xs[i] = xs[i-1] + 1;\n if (xs[K] != XR) xs[K] = XR;\n return xs;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector pts;\n pts.reserve(2*N);\n vector macks;\n macks.reserve(N);\n for (int i = 0; i < 2*N; i++) {\n int x,y; cin >> x >> y;\n int w = (i < N) ? +1 : -1;\n pts.push_back({x,y,w});\n if (i < N) macks.push_back({x,y,+1});\n }\n\n double t0 = now_sec();\n const double TL = 1.95;\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n seed ^= (uint64_t)(pts[0].x * 1000003u + pts[0].y * 9176u + 12345u);\n XorShift64 rng(seed);\n\n BIT2DStatic bit2d;\n bit2d.build(pts);\n\n auto eval_rect_fast = [&](const Rect& r)->int { return bit2d.rect_sum_inclusive(r); };\n\n auto make_around = [&](const Point& c, int w, int h)->Rect{\n Rect r{c.x - w/2, c.x + w/2, c.y - h/2, c.y + h/2};\n r = clamp_rect(r);\n if (!(r.xl <= c.x && c.x <= r.xr && r.yb <= c.y && c.y <= r.yt)) {\n r = clamp_rect(Rect{c.x, c.x+1, c.y, c.y+1});\n }\n return r;\n };\n\n // ---- 1) collect good warm rectangles (more than before) ----\n vector> cand;\n cand.reserve(200);\n\n int trials = 120000; // cheap due to fast eval\n for (int it = 0; it < trials; it++) {\n const auto& c = macks[rng.next_int(0, (int)macks.size()-1)];\n double rr = rng.next_double();\n int w,h;\n if (rr < 0.60) { w = rng.next_int(200, 12000); h = rng.next_int(200, 12000); }\n else if (rr < 0.92) { w = rng.next_int(2000, 55000); h = rng.next_int(2000, 55000); }\n else { w = rng.next_int(12000, 95000); h = rng.next_int(12000, 95000); }\n if (w + h > 200000) {\n int over = w + h - 200000;\n w = max(1, w - over/2);\n h = max(1, h - (over - over/2));\n }\n Rect r = make_around(c, w, h);\n if (!rect_ok(r)) continue;\n int diff = eval_rect_fast(r);\n cand.push_back({diff, r});\n }\n sort(cand.begin(), cand.end(), [&](auto &a, auto &b){ return a.first > b.first; });\n\n int R = 10; // restarts\n vector starts;\n for (int i = 0; i < (int)cand.size() && (int)starts.size() < R; i++) starts.push_back(cand[i].second);\n if (starts.empty()) starts.push_back(clamp_rect(Rect{0,1,0,1}));\n while ((int)starts.size() < R) starts.push_back(starts[0]);\n\n // ---- 2) Staircase SA per restart ----\n int globalBestTot = -1e9;\n vector> globalBestPoly;\n\n // distribute time roughly\n for (int rs = 0; rs < R; rs++) {\n double t = now_sec() - t0;\n if (t > TL) break;\n\n Rect base = clamp_rect(starts[rs]);\n int XL = base.xl, XR = base.xr;\n int YB = base.yb, YT = base.yt;\n int width = XR - XL;\n if (width < 40) { // avoid too narrow -> too few slabs\n XR = min(100000, XL + 40);\n width = XR - XL;\n if (width < 4) { XL = max(0, 100000-50); XR = XL + 40; width = 40; }\n }\n\n // choose K: more expressive than 120 but keep vertex <= 1000\n int K = 80 + width / 500; // ~80..280\n K = max(60, min(220, K)); // cap\n K = min(K, width); // must allow strictly increasing xs\n if (K < 4) K = 4;\n if (width < K) K = width;\n\n vector xs = build_xs(XL, XR, K);\n\n // build slabs: assign by upper_bound(xs, x)-1\n vector slabs(K);\n for (int i = 0; i < K; i++) slabs[i].yw.clear();\n\n for (auto &p: pts) {\n if (p.x < XL || p.x > XR) continue;\n int idx = (int)(upper_bound(xs.begin(), xs.end(), p.x) - xs.begin()) - 1;\n if (idx < 0) idx = 0;\n if (idx >= K) idx = K-1;\n slabs[idx].yw.push_back({p.y, p.w});\n }\n\n for (int i = 0; i < K; i++) {\n auto &v = slabs[i].yw;\n sort(v.begin(), v.end());\n slabs[i].ys.clear();\n slabs[i].pref.assign(v.size()+1, 0);\n slabs[i].my.clear();\n slabs[i].ys.reserve(v.size());\n for (int j = 0; j < (int)v.size(); j++) {\n slabs[i].ys.push_back(v[j].first);\n slabs[i].pref[j+1] = slabs[i].pref[j] + v[j].second;\n if (v[j].second == +1) slabs[i].my.push_back(v[j].first);\n }\n }\n\n struct CandIvl { int L,U; };\n vector> cands(K);\n\n // candidates per slab\n for (int i = 0; i < K; i++) {\n cands[i][0] = {YB, YT};\n\n // Kadane best on sorted y list\n CandIvl kad{YB, YT};\n auto &v = slabs[i].yw;\n if (!v.empty()) {\n int M = (int)v.size();\n int bestSum = INT_MIN, curSum = 0;\n int start = 0, bestL = 0, bestR = -1;\n for (int j = 0; j < M; j++) {\n int w = v[j].second;\n if (curSum <= 0) { curSum = w; start = j; }\n else curSum += w;\n if (curSum > bestSum) { bestSum = curSum; bestL = start; bestR = j; }\n }\n if (bestSum > 0 && bestR >= bestL) {\n int l = v[bestL].first;\n int u = v[bestR].first;\n if (u <= l) u = min(100000, l + 1);\n kad = {max(0,l), min(100000,u)};\n }\n }\n cands[i][1] = kad;\n\n // mackerel percentile window (if enough macks)\n CandIvl perc{YB, YT};\n auto my = slabs[i].my;\n if ((int)my.size() >= 8) {\n sort(my.begin(), my.end());\n int p25 = my[(int)(0.25 * (my.size()-1))];\n int p75 = my[(int)(0.75 * (my.size()-1))];\n int margin = 250;\n int l = max(0, p25 - margin);\n int u = min(100000, p75 + margin);\n if (u <= l) u = min(100000, l + 1);\n perc = {l,u};\n }\n cands[i][2] = perc;\n\n // very small window around a random mackerel y in slab (or keep base)\n CandIvl small{YB, YT};\n if (!slabs[i].my.empty()) {\n int y0 = slabs[i].my[rng.next_int(0, (int)slabs[i].my.size()-1)];\n int m = 120;\n int l = max(0, y0 - m);\n int u = min(100000, y0 + m);\n if (u <= l) u = min(100000, l + 1);\n small = {l,u};\n }\n cands[i][3] = small;\n }\n\n // initial L/U: base rectangle\n vector L(K, YB), U(K, YT);\n // if invalid due to gap, slightly enforce overlap by smoothing\n for (int i = 1; i < K; i++) {\n if (!gap_ok(L[i-1], U[i-1], L[i], U[i])) {\n // force overlap by copying previous\n L[i] = L[i-1];\n U[i] = U[i-1];\n }\n }\n // compute contribution\n vector contrib(K, 0);\n int total = 0;\n for (int i = 0; i < K; i++) {\n contrib[i] = slabs[i].range_sum(L[i], U[i]);\n total += contrib[i];\n }\n long long Vlen = Vlen_full(L, U);\n if (!perim_ok(XL, XR, Vlen)) {\n // shrink height a lot\n for (int i = 0; i < K; i++) { U[i] = min(100000, L[i] + 1); }\n total = 0;\n for (int i = 0; i < K; i++) { contrib[i] = slabs[i].range_sum(L[i], U[i]); total += contrib[i]; }\n Vlen = Vlen_full(L, U);\n }\n\n auto local_V_delta = [&](int i, int oldL, int oldU, int newL, int newU,\n const vector& Lc, const vector& Uc)->long long {\n long long d = 0;\n auto endterm = [&](int idx, int a, int b)->long long {\n if (idx == 0 || idx == K-1) return (long long)b - a;\n return 0LL;\n };\n d -= endterm(i, oldL, oldU);\n d += endterm(i, newL, newU);\n\n if (i-1 >= 0) {\n d -= llabs((long long)oldL - Lc[i-1]);\n d += llabs((long long)newL - Lc[i-1]);\n d -= llabs((long long)oldU - Uc[i-1]);\n d += llabs((long long)newU - Uc[i-1]);\n }\n if (i+1 < K) {\n d -= llabs((long long)Lc[i+1] - oldL);\n d += llabs((long long)Lc[i+1] - newL);\n d -= llabs((long long)Uc[i+1] - oldU);\n d += llabs((long long)Uc[i+1] - newU);\n }\n return d;\n };\n\n // best within this restart\n int bestTot = total;\n long long bestV = Vlen;\n vector bestL = L, bestU = U;\n\n // SA parameters\n const double T0 = 28.0;\n const double T1 = 0.6;\n\n // Time slice for this restart\n double sliceL = (double)rs / R * TL;\n double sliceR = (double)(rs + 1) / R * TL;\n // allow some flexibility if earlier restarts ended quickly\n sliceR += 0.02;\n\n int iter = 0;\n while (true) {\n double tt = now_sec() - t0;\n if (tt > TL) break;\n if (rs < R-1 && tt > sliceR) break;\n\n double prog = 0.0;\n if (sliceR > sliceL) prog = min(1.0, max(0.0, (tt - sliceL) / (sliceR - sliceL)));\n double temp = T0 * pow(T1 / T0, prog);\n\n int i = rng.next_int(0, K-1);\n int oldL = L[i], oldU = U[i];\n int newL = oldL, newU = oldU;\n\n double dice = rng.next_double();\n if (dice < 0.22) {\n int maxD = (int)(9000 * (1.0 - prog) + 25);\n newL += rng.next_int(-maxD, maxD);\n } else if (dice < 0.44) {\n int maxD = (int)(9000 * (1.0 - prog) + 25);\n newU += rng.next_int(-maxD, maxD);\n } else if (dice < 0.62) {\n int maxD = (int)(7000 * (1.0 - prog) + 20);\n int d = rng.next_int(-maxD, maxD);\n newL += d; newU += d;\n } else if (dice < 0.78) {\n // copy neighbor to reduce perimeter / repair\n if (i > 0 && rng.next_double() < 0.5) { newL = L[i-1]; newU = U[i-1]; }\n else if (i+1 < K) { newL = L[i+1]; newU = U[i+1]; }\n } else {\n int c = rng.next_int(0, 3);\n newL = cands[i][c].L;\n newU = cands[i][c].U;\n }\n\n newL = max(0, min(100000, newL));\n newU = max(0, min(100000, newU));\n if (newU <= newL) newU = min(100000, newL + 1);\n\n // gap constraints with neighbors\n if (i-1 >= 0 && !gap_ok(L[i-1], U[i-1], newL, newU)) { iter++; continue; }\n if (i+1 < K && !gap_ok(newL, newU, L[i+1], U[i+1])) { iter++; continue; }\n\n long long dV = local_V_delta(i, oldL, oldU, newL, newU, L, U);\n long long newV = Vlen + dV;\n if (!perim_ok(XL, XR, newV)) { iter++; continue; }\n\n int newC = slabs[i].range_sum(newL, newU);\n int newTot = total - contrib[i] + newC;\n int dScore = newTot - total;\n\n bool accept = false;\n if (dScore > 0) accept = true;\n else if (dScore == 0) {\n // accept if perimeter becomes smaller (gives more future slack)\n if (newV < Vlen) accept = true;\n else accept = (rng.next_double() < 0.10);\n } else {\n double prob = exp((double)dScore / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n L[i] = newL; U[i] = newU;\n Vlen = newV;\n total = newTot;\n contrib[i] = newC;\n\n if (total > bestTot || (total == bestTot && Vlen < bestV)) {\n bestTot = total;\n bestV = Vlen;\n bestL = L;\n bestU = U;\n }\n }\n\n iter++;\n }\n\n // build polygon from bestL/bestU\n L = move(bestL);\n U = move(bestU);\n\n vector> poly;\n poly.reserve(4*K + 10);\n auto pushv = [&](int x, int y) {\n if (!poly.empty() && poly.back().first == x && poly.back().second == y) return;\n poly.push_back({x,y});\n };\n\n // bottom chain\n pushv(xs[0], L[0]);\n for (int i = 0; i < K-1; i++) {\n pushv(xs[i+1], L[i]);\n if (L[i+1] != L[i]) pushv(xs[i+1], L[i+1]);\n }\n pushv(xs[K], L[K-1]);\n\n // right vertical\n if (U[K-1] != L[K-1]) pushv(xs[K], U[K-1]);\n\n // top chain\n for (int i = K-1; i >= 1; i--) {\n pushv(xs[i], U[i]);\n if (U[i-1] != U[i]) pushv(xs[i], U[i-1]);\n }\n pushv(xs[0], U[0]);\n\n // left vertical close\n if (L[0] != U[0]) pushv(xs[0], L[0]);\n if (!poly.empty() && poly.front() == poly.back()) poly.pop_back();\n\n // validate vertex count and distinctness; otherwise fallback to base rectangle\n bool ok = (poly.size() >= 4 && poly.size() <= 1000);\n if (ok) {\n unordered_set seen;\n seen.reserve(poly.size()*2);\n for (auto &v: poly) {\n long long key = (long long)v.first * 200001LL + v.second;\n if (seen.count(key)) { ok = false; break; }\n seen.insert(key);\n }\n }\n if (!ok) {\n // fallback to base rectangle\n Rect r = clamp_rect(base);\n poly.clear();\n poly.push_back({r.xl, r.yb});\n poly.push_back({r.xr, r.yb});\n poly.push_back({r.xr, r.yt});\n poly.push_back({r.xl, r.yt});\n bestTot = eval_rect_fast(r);\n }\n\n if (bestTot > globalBestTot) {\n globalBestTot = bestTot;\n globalBestPoly = move(poly);\n }\n }\n\n // Output final\n if (globalBestPoly.empty()) {\n globalBestPoly = {{0,0},{1,0},{1,1},{0,1}};\n }\n cout << globalBestPoly.size() << \"\\n\";\n for (auto &v: globalBestPoly) cout << v.first << \" \" << v.second << \"\\n\";\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct Op {\n int p;\n int r;\n char d; // 'L' or 'U'\n int b; // -1 or previous index\n};\n\nstruct Placed {\n ll x=0, y=0, w=0, h=0;\n};\n\nstatic inline bool overlapPosLen(ll a1, ll a2, ll b1, ll b2) {\n return max(a1, b1) < min(a2, b2);\n}\n\nstruct RNG {\n uint64_t x;\n explicit RNG(uint64_t seed=88172645463325252ULL) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\npair place_one(\n const vector& placed, int i,\n ll w, ll h, char d, int b\n) {\n ll x=0, y=0;\n if (d == 'U') {\n x = 0;\n if (b != -1) x = placed[b].x + placed[b].w;\n y = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(x, x+w, pj.x, pj.x+pj.w)) {\n y = max(y, pj.y + pj.h);\n }\n }\n } else { // 'L'\n y = 0;\n if (b != -1) y = placed[b].y + placed[b].h;\n x = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(y, y+h, pj.y, pj.y+pj.h)) {\n x = max(x, pj.x + pj.w);\n }\n }\n }\n return {x,y};\n}\n\npair simulate_ops(const vector& ops, const vector& W, const vector& H) {\n int N = (int)ops.size();\n vector placed(N);\n ll maxX=0, maxY=0;\n\n for (int i = 0; i < N; i++) {\n const auto& op = ops[i];\n int idx = op.p;\n ll w = W[idx], h = H[idx];\n if (op.r) swap(w,h);\n\n auto [x,y] = place_one(placed, i, w, h, op.d, op.b);\n placed[i] = Placed{x,y,w,h};\n maxX = max(maxX, x+w);\n maxY = max(maxY, y+h);\n }\n return {maxX, maxY};\n}\n\nstruct Candidate {\n vector ops;\n ll estW = (1LL<<62), estH = (1LL<<62), estObj = (1LL<<62);\n string tag;\n};\n\nCandidate make_all_one_row(const vector& w, const vector& h, uint64_t seed, string tag=\"oneRow\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n for (int i=0;i& w, const vector& h, uint64_t seed, string tag=\"oneCol\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n for (int i=0;i& w, const vector& h, ll Wlim, uint64_t seed, string tag=\"rowShelf\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n int prevAnchor=-1;\n ll rowW=0, rowH=0;\n int rowTall=-1; ll rowTallH=-1;\n\n auto finish_row = [&](){\n prevAnchor = rowTall;\n rowW=0; rowH=0;\n rowTall=-1; rowTallH=-1;\n };\n\n for(int i=0;i0){\n bool fit0 = (rowW+w0<=Wlim);\n bool fit1 = (rowW+w1<=Wlim);\n if(!fit0 && !fit1) finish_row();\n else if(rowW > (ll)llround((long double)Wlim*0.94L) && rng.next_double()<0.25) finish_row();\n }\n\n // choose rotation by row height then fit\n int r=0;\n bool fit0 = (rowW+w0<=Wlim);\n bool fit1 = (rowW+w1<=Wlim);\n if(fit0 && fit1){\n ll rh0=max(rowH,h0), rh1=max(rowH,h1);\n if(rh1rowTallH){ rowTallH=hh; rowTall=i; }\n }\n\n auto [W,H] = simulate_ops(c.ops,w,h);\n c.estW=W; c.estH=H; c.estObj=W+H;\n c.tag = tag + \"(Wlim=\" + to_string(Wlim) + \")\";\n return c;\n}\n\nCandidate make_col_shelf(const vector& w, const vector& h, ll Hlim, uint64_t seed, string tag=\"colShelf\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n int prevAnchor=-1;\n ll colH=0, colW=0;\n int colWide=-1; ll colWideW=-1;\n\n auto finish_col = [&](){\n prevAnchor = colWide;\n colH=0; colW=0;\n colWide=-1; colWideW=-1;\n };\n\n for(int i=0;i0){\n bool fit0 = (colH+h0<=Hlim);\n bool fit1 = (colH+h1<=Hlim);\n if(!fit0 && !fit1) finish_col();\n else if(colH > (ll)llround((long double)Hlim*0.94L) && rng.next_double()<0.25) finish_col();\n }\n\n int r=0;\n bool fit0 = (colH+h0<=Hlim);\n bool fit1 = (colH+h1<=Hlim);\n if(fit0 && fit1){\n ll cw0=max(colW,w0), cw1=max(colW,w1);\n if(cw1colWideW){ colWideW=ww; colWide=i; }\n }\n\n auto [W,H] = simulate_ops(c.ops,w,h);\n c.estW=W; c.estH=H; c.estObj=W+H;\n c.tag = tag + \"(Hlim=\" + to_string(Hlim) + \")\";\n return c;\n}\n\n// Greedy mosaic: each step tries (r,d,b) from small candidate sets and chooses best.\nCandidate make_greedy_mosaic(\n const vector& w, const vector& h,\n uint64_t seed,\n double aspectPenalty, // weight for |W-H|\n double areaPenalty, // small weight for W*H\n double pPreferL, // bias for L vs U\n int Kanchor, // top-K anchors for each direction\n string tag=\"mosaic\"\n) {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n vector placed(N);\n ll curW=0, curH=0;\n\n auto get_topK_indices = [&](int i, bool byBottom, int K)->vector{\n vector idx(i);\n iota(idx.begin(), idx.end(), 0);\n auto key = [&](int j)->ll{\n const auto& pj = placed[j];\n return byBottom ? (pj.y+pj.h) : (pj.x+pj.w);\n };\n sort(idx.begin(), idx.end(), [&](int a,int b){\n return key(a) > key(b);\n });\n if ((int)idx.size() > K) idx.resize(K);\n return idx;\n };\n\n for(int i=0;i BL = {-1}, BU = {-1};\n if(i>0){\n auto topBottom = get_topK_indices(i, true, Kanchor);\n auto topRight = get_topK_indices(i, false, Kanchor);\n BL.insert(BL.end(), topBottom.begin(), topBottom.end());\n BU.insert(BU.end(), topRight.begin(), topRight.end());\n\n // add a few random anchors for diversity\n for(int t=0;t<3;t++){\n BL.push_back(rng.next_int(0,i-1));\n BU.push_back(rng.next_int(0,i-1));\n }\n // ensure i-1 is included\n BL.push_back(i-1);\n BU.push_back(i-1);\n }\n\n // dedup\n auto dedup = [&](vector& v){\n sort(v.begin(), v.end());\n v.erase(unique(v.begin(), v.end()), v.end());\n };\n dedup(BL); dedup(BU);\n\n // Try options\n double bestScore = 1e100;\n Op bestOp{i,0,'L',-1};\n ll bestNX=0, bestNY=0, bestNW=0, bestNH=0;\n\n auto eval = [&](ll nW, ll nH)->double{\n long double Wd=nW, Hd=nH;\n long double score = Wd + Hd;\n score += (long double)aspectPenalty * fabsl(Wd - Hd);\n score += (long double)areaPenalty * (Wd * Hd) / 1e6L; // scale down\n return (double)score;\n };\n\n auto consider = [&](int r, char d, int b){\n ll ww = (r? w1:w0);\n ll hh = (r? h1:h0);\n\n auto [x,y] = place_one(placed, i, ww, hh, d, b);\n ll nW = max(curW, x+ww);\n ll nH = max(curH, y+hh);\n\n double sc = eval(nW,nH);\n\n // mild bias to prefer L or U (to create varied candidates)\n if (d=='L') sc *= (1.0 - 0.02*(pPreferL-0.5));\n else sc *= (1.0 + 0.02*(pPreferL-0.5));\n\n // small randomness to escape ties\n sc *= (1.0 + 0.0005 * (rng.next_double() - 0.5));\n\n if (sc < bestScore) {\n bestScore=sc;\n bestOp = Op{i,r,d,b};\n bestNX=x; bestNY=y; bestNW=ww; bestNH=hh;\n }\n };\n\n // Direction set with bias\n bool tryLFirst = (rng.next_double() < pPreferL);\n for(int rr=0; rr<2; rr++){\n // sometimes only try the \"natural\" rotation first\n // but still consider both in most cases\n int r = rr;\n if (rng.next_double() < 0.08) r ^= 1;\n\n if (tryLFirst) {\n for (int b : BL) consider(r,'L',b);\n for (int b : BU) consider(r,'U',b);\n } else {\n for (int b : BU) consider(r,'U',b);\n for (int b : BL) consider(r,'L',b);\n }\n }\n\n // Commit\n c.ops[i]=bestOp;\n placed[i]=Placed{bestNX,bestNY,bestNW,bestNH};\n curW = max(curW, bestNX+bestNW);\n curH = max(curH, bestNY+bestNH);\n }\n\n c.estW=curW; c.estH=curH; c.estObj=curW+curH;\n c.tag = tag + \"(asp=\" + to_string(aspectPenalty) + \",area=\" + to_string(areaPenalty) + \")\";\n return c;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T, sigma;\n cin >> N >> T >> sigma;\n vector wp(N), hp(N);\n for(int i=0;i> wp[i] >> hp[i];\n\n long double areaSum=0;\n ll sumW=0, sumH=0;\n for(int i=0;i(1, (ll)floor(sqrt(areaSum)));\n\n vector pool;\n pool.push_back(make_all_one_row(wp,hp,1,\"oneRow\"));\n pool.push_back(make_all_one_col(wp,hp,2,\"oneCol\"));\n\n // Shelves\n vector factors = {0.55L,0.70L,0.85L,1.00L,1.15L,1.35L,1.60L};\n uint64_t seedBase = 1234567;\n\n for(int fi=0; fi<(int)factors.size(); fi++){\n ll Wlim = (ll)llround((long double)sq * factors[fi]);\n Wlim = max(1, min(Wlim, sumW));\n for(int k=0;k<5;k++){\n pool.push_back(make_row_shelf(wp,hp,Wlim,seedBase + 1000ULL*fi + k, \"rowShelf\"));\n }\n }\n for(int fi=0; fi<(int)factors.size(); fi++){\n ll Hlim = (ll)llround((long double)sq * factors[fi]);\n Hlim = max(1, min(Hlim, sumH));\n for(int k=0;k<5;k++){\n pool.push_back(make_col_shelf(wp,hp,Hlim,seedBase + 20000ULL + 1000ULL*fi + k, \"colShelf\"));\n }\n }\n\n // Greedy mosaic variants (main improvement)\n vector asp = {0.00, 0.03, 0.06, 0.10};\n vector areaPen = {0.0, 0.0008, 0.0016};\n vector biasL = {0.30, 0.50, 0.70}; // prefer U, balanced, prefer L\n\n uint64_t s2 = 7777777;\n for (double a : asp) for (double ap : areaPen) for (double bl : biasL) {\n for(int rep=0; rep<5; rep++){\n pool.push_back(make_greedy_mosaic(wp,hp, s2++, a, ap, bl, 12, \"mosaic\"));\n }\n }\n\n // Evaluate precisely (still using wp/hp) and keep best K\n for (auto &c : pool) {\n auto [W,H] = simulate_ops(c.ops, wp, hp);\n c.estW=W; c.estH=H; c.estObj=W+H;\n }\n sort(pool.begin(), pool.end(), [](const Candidate& a, const Candidate& b){\n if (a.estObj != b.estObj) return a.estObj < b.estObj;\n if (a.estW != b.estW) return a.estW < b.estW;\n return a.estH < b.estH;\n });\n\n int KEEP = min((int)pool.size(), 80);\n pool.resize(KEEP);\n\n ll bestMeasured = (1LL<<62);\n int bestIdx = 0;\n\n for(int t=0;t> Wm >> Hm)) return 0;\n ll measured = Wm + Hm;\n if(measured < bestMeasured){\n bestMeasured = measured;\n bestIdx = useIdx;\n }\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nstatic inline uint32_t xorshift32(uint32_t &x) {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n}\nstatic inline double rand01(uint32_t &x) {\n return (double)xorshift32(x) / 4294967296.0;\n}\n\nstruct BFSResult {\n vector dist;\n vector prev;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n\n vector> edges(M);\n vector> g(N);\n g.assign(N, {});\n\n unordered_set edgeSet;\n edgeSet.reserve(M * 2);\n\n auto keyEdge = [&](int u, int v)->long long{\n if (u > v) swap(u, v);\n return (long long)u * N + v;\n };\n\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n edges[i] = {u, v};\n g[u].push_back(v);\n g[v].push_back(u);\n edgeSet.insert(keyEdge(u, v));\n }\n // coords unused\n for (int i = 0; i < N; i++) { int x, y; cin >> x >> y; }\n\n auto multiSourceBFS = [&](const vector& roots)->BFSResult{\n const int INF = 1e9;\n BFSResult res;\n res.dist.assign(N, INF);\n res.prev.assign(N, -1);\n deque q;\n for (int r : roots) {\n res.dist[r] = 0;\n res.prev[r] = -1;\n q.push_back(r);\n }\n while (!q.empty()) {\n int v = q.front(); q.pop_front();\n int nd = res.dist[v] + 1;\n for (int to : g[v]) {\n if (res.dist[to] > nd) {\n res.dist[to] = nd;\n res.prev[to] = v;\n q.push_back(to);\n }\n }\n }\n return res;\n };\n\n // -----------------------\n // 1) Root selection to ensure all vertices within distance <= H\n // -----------------------\n int root0 = (int)(min_element(A.begin(), A.end()) - A.begin());\n vector roots = {root0};\n\n while (true) {\n auto bfs = multiSourceBFS(roots);\n int far = -1, farD = -1;\n for (int i = 0; i < N; i++) {\n if (bfs.dist[i] > farD) { farD = bfs.dist[i]; far = i; }\n }\n if (farD <= H) break;\n\n int cur = far;\n int steps = farD - H;\n\n int child1 = -1, child2 = -1;\n for (int s = 0; s < steps; s++) {\n child2 = child1;\n child1 = cur;\n cur = bfs.prev[cur];\n if (cur == -1) break;\n }\n if (cur == -1) { roots.push_back(far); continue; }\n\n int best = cur;\n auto consider = [&](int v){\n if (v == -1) return;\n if (A[v] < A[best]) best = v;\n };\n consider(child1);\n consider(child2);\n roots.push_back(best);\n }\n\n // Remove redundant roots\n {\n uint32_t rng = 123456789u;\n vector order = roots;\n for (int i = (int)order.size() - 1; i > 0; i--) {\n int j = (int)(xorshift32(rng) % (i + 1));\n swap(order[i], order[j]);\n }\n vector alive(N, 0);\n for (int r : roots) alive[r] = 1;\n\n for (int r : order) {\n if (!alive[r]) continue;\n vector tmp;\n tmp.reserve(roots.size());\n for (int rr : roots) if (alive[rr] && rr != r) tmp.push_back(rr);\n if (tmp.empty()) continue;\n\n auto bfs = multiSourceBFS(tmp);\n int mx = 0;\n for (int i = 0; i < N; i++) mx = max(mx, bfs.dist[i]);\n if (mx <= H) alive[r] = 0;\n }\n vector newRoots;\n for (int r : roots) if (alive[r]) newRoots.push_back(r);\n roots.swap(newRoots);\n }\n\n // -----------------------\n // 2) Initial forest by BFS\n // -----------------------\n auto bfs = multiSourceBFS(roots);\n vector parent(N, -1), depth(N, 0);\n for (int v = 0; v < N; v++) {\n if (bfs.dist[v] <= H) {\n parent[v] = bfs.prev[v];\n depth[v] = bfs.dist[v];\n } else {\n parent[v] = -1;\n depth[v] = 0;\n }\n }\n\n // -----------------------\n // 3) Children structure\n // -----------------------\n vector> children(N);\n vector idxInChild(N, -1);\n\n auto addChild = [&](int p, int v) {\n idxInChild[v] = (int)children[p].size();\n children[p].push_back(v);\n };\n auto removeChild = [&](int p, int v) {\n int idx = idxInChild[v];\n if (idx < 0) return;\n int last = children[p].back();\n children[p][idx] = last;\n idxInChild[last] = idx;\n children[p].pop_back();\n idxInChild[v] = -1;\n };\n\n children.assign(N, {});\n idxInChild.assign(N, -1);\n for (int v = 0; v < N; v++) if (parent[v] != -1) addChild(parent[v], v);\n\n long long score = 0;\n for (int v = 0; v < N; v++) score += 1LL * (depth[v] + 1) * A[v];\n\n // subtree marking to avoid cycles quickly\n vector mark(N, 0);\n int markToken = 1;\n\n vector st, sub;\n st.reserve(N);\n sub.reserve(N);\n\n auto collectSubtree = [&](int v, long long &sumA, int &maxD) {\n sumA = 0;\n maxD = -1;\n sub.clear();\n st.clear();\n st.push_back(v);\n markToken++;\n if (markToken == INT_MAX) { mark.assign(N, 0); markToken = 1; }\n while (!st.empty()) {\n int x = st.back(); st.pop_back();\n sub.push_back(x);\n mark[x] = markToken;\n sumA += A[x];\n maxD = max(maxD, depth[x]);\n for (int ch : children[x]) st.push_back(ch);\n }\n };\n\n // -----------------------\n // 4) SA: best-neighbor reparent + occasional random-edge move\n // -----------------------\n uint32_t rng = 987654321u;\n auto start = chrono::steady_clock::now();\n auto elapsed = [&]() {\n return chrono::duration(chrono::steady_clock::now() - start).count();\n };\n\n const double TL = 1.93;\n const double T0 = 20000.0;\n const double T1 = 50.0;\n\n auto acceptGain = [&](long long gain, double T)->bool {\n if (gain >= 0) return true;\n double p = exp((double)gain / T);\n return rand01(rng) < p;\n };\n\n auto pickVertexBiased = [&]()->int{\n // tournament selection among a few random vertices\n // prefer high A and still shallow (more room to deepen)\n int best = (int)(xorshift32(rng) % N);\n long long bestKey = 1LL * A[best] * (H - depth[best] + 1);\n for (int k = 0; k < 3; k++) {\n int v = (int)(xorshift32(rng) % N);\n long long key = 1LL * A[v] * (H - depth[v] + 1);\n if (key > bestKey) { bestKey = key; best = v; }\n }\n return best;\n };\n\n int it = 0;\n while (true) {\n if ((it & 2047) == 0) {\n if (elapsed() > TL) break;\n }\n it++;\n\n double prog = elapsed() / TL;\n if (prog > 1.0) prog = 1.0;\n double T = T0 * pow(T1 / T0, prog);\n\n int mode = (int)(xorshift32(rng) % 100);\n\n if (mode < 80) {\n // Best-neighbor reparent for a chosen vertex v\n int v = pickVertexBiased();\n\n long long sumA; int maxD;\n collectSubtree(v, sumA, maxD);\n\n // Candidate: cut to root (only if not already root)\n int bestU = -2; // -1 means root, >=0 means parent, -2 none\n int bestDelta = 0;\n long long bestGain = LLONG_MIN;\n\n if (parent[v] != -1) {\n int delta = -depth[v];\n long long gain = 1LL * delta * sumA;\n bestU = -1;\n bestDelta = delta;\n bestGain = gain;\n }\n\n // Try each neighbor as new parent\n for (int u : g[v]) {\n if (u == parent[v]) continue;\n if (mark[u] == markToken) continue; // would create cycle\n\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n\n int delta = newDepthV - depth[v];\n if (maxD + delta > H) continue;\n\n long long gain = 1LL * delta * sumA;\n if (gain > bestGain) {\n bestGain = gain;\n bestU = u;\n bestDelta = delta;\n }\n }\n\n if (bestU == -2) continue;\n\n // Exploration: sometimes pick a random feasible neighbor (or cut)\n if (rand01(rng) < 0.12) {\n vector> cand; // (u, delta), u=-1 allowed\n cand.reserve(g[v].size() + 1);\n if (parent[v] != -1) cand.push_back({-1, -depth[v]});\n for (int u : g[v]) {\n if (u == parent[v]) continue;\n if (mark[u] == markToken) continue;\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n int delta = newDepthV - depth[v];\n if (maxD + delta > H) continue;\n cand.push_back({u, delta});\n }\n if (!cand.empty()) {\n auto [u, delta] = cand[xorshift32(rng) % cand.size()];\n bestU = u;\n bestDelta = delta;\n bestGain = 1LL * bestDelta * sumA;\n }\n }\n\n if (!acceptGain(bestGain, T)) continue;\n\n // Apply\n int oldp = parent[v];\n if (oldp != -1) removeChild(oldp, v);\n\n if (bestU == -1) {\n parent[v] = -1;\n } else {\n parent[v] = bestU;\n addChild(bestU, v);\n }\n\n for (int x : sub) depth[x] += bestDelta;\n score += bestGain;\n\n } else {\n // Random edge reparent (diversity)\n auto [a, b] = edges[xorshift32(rng) % M];\n int u, v;\n if (xorshift32(rng) & 1) { u = a; v = b; }\n else { u = b; v = a; }\n\n if (u == v) continue;\n if (parent[v] == u) continue;\n\n // cheap cycle check: v not ancestor of u (H small)\n bool cycle = false;\n int cur = u;\n while (cur != -1) {\n if (cur == v) { cycle = true; break; }\n cur = parent[cur];\n }\n if (cycle) continue;\n\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n int delta = newDepthV - depth[v];\n\n long long sumA; int maxD;\n collectSubtree(v, sumA, maxD);\n if (maxD + delta > H) continue;\n\n long long gain = 1LL * delta * sumA;\n if (!acceptGain(gain, T)) continue;\n\n int oldp = parent[v];\n if (oldp != -1) removeChild(oldp, v);\n parent[v] = u;\n addChild(u, v);\n\n for (int x : sub) depth[x] += delta;\n score += gain;\n }\n }\n\n // -----------------------\n // 5) Final legality enforcement\n // -----------------------\n for (int v = 0; v < N; v++) {\n if (parent[v] != -1 && !edgeSet.count(keyEdge(v, parent[v]))) parent[v] = -1;\n }\n\n // rebuild children\n children.assign(N, {});\n idxInChild.assign(N, -1);\n for (int v = 0; v < N; v++) if (parent[v] != -1) addChild(parent[v], v);\n\n // recompute depths from roots; cut cycles/unreachable; enforce height\n auto fixDepths = [&](){\n vector dep(N, -1);\n deque q;\n for (int v = 0; v < N; v++) if (parent[v] == -1) {\n dep[v] = 0;\n q.push_back(v);\n }\n while (!q.empty()) {\n int x = q.front(); q.pop_front();\n for (int ch : children[x]) {\n if (dep[ch] != -1) continue;\n dep[ch] = dep[x] + 1;\n q.push_back(ch);\n }\n }\n bool changed = false;\n for (int v = 0; v < N; v++) {\n if (dep[v] == -1 || dep[v] > H) {\n parent[v] = -1;\n changed = true;\n }\n }\n if (changed) {\n children.assign(N, {});\n idxInChild.assign(N, -1);\n for (int v = 0; v < N; v++) if (parent[v] != -1) addChild(parent[v], v);\n // recompute again\n dep.assign(N, -1);\n q.clear();\n for (int v = 0; v < N; v++) if (parent[v] == -1) {\n dep[v] = 0;\n q.push_back(v);\n }\n while (!q.empty()) {\n int x = q.front(); q.pop_front();\n for (int ch : children[x]) {\n if (dep[ch] != -1) continue;\n dep[ch] = dep[x] + 1;\n q.push_back(ch);\n }\n }\n }\n depth.swap(dep);\n };\n fixDepths();\n\n // Output\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << \"\\n\";\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstatic inline char opposite_dir(char d){\n if(d=='L') return 'R';\n if(d=='R') return 'L';\n if(d=='U') return 'D';\n return 'U';\n}\n\nstruct Candidate {\n char dir; // L/R/U/D\n int p; // row or col\n int k; // number of shifts\n int gain; // removed oni count\n};\n\nstruct XorShift {\n uint64_t x=88172645463325252ull;\n explicit XorShift(uint64_t seed=0){\n if(seed) x ^= seed + 0x9e3779b97f4a7c15ull;\n }\n uint64_t next_u64(){\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int n){ return (int)(next_u64() % (uint64_t)n); }\n};\n\nstatic constexpr int NMAX = 20;\n\nstruct Board {\n int N;\n array, NMAX> a{};\n int oniCnt = 0;\n\n void init(int n, const vector& C){\n N=n;\n oniCnt=0;\n for(int i=0;i=1;j--) a[i][j]=a[i][j-1];\n a[i][0]='.';\n }\n void shiftColUp(int j){\n char removed = a[0][j];\n if(removed=='x') oniCnt--;\n for(int i=0;i=1;i--) a[i][j]=a[i-1][j];\n a[0][j]='.';\n }\n\n bool legalSingle(char dir, int p) const{\n if(dir=='L') return a[p][0] != 'o';\n if(dir=='R') return a[p][N-1] != 'o';\n if(dir=='U') return a[0][p] != 'o';\n return a[N-1][p] != 'o'; // D\n }\n\n void applySingle(char dir, int p){\n if(dir=='L') shiftRowLeft(p);\n else if(dir=='R') shiftRowRight(p);\n else if(dir=='U') shiftColUp(p);\n else shiftColDown(p);\n }\n\n // Apply multi-step flush; requires removed segment to have no 'o' in current state.\n void applyFlush(char dir, int p, int k){\n for(int t=0;t rhs;\n if(a.gain != b.gain) return a.gain > b.gain;\n return a.k < b.k;\n}\n\nstatic int bestGainRemovable(const Board& bd){\n int N = bd.N;\n int bestGain = 0;\n\n // rows\n for(int i=0;i0){\n Candidate c{'L', i, k, gain};\n if(!found || betterCandidate(c, best)){\n best = c; found = true;\n }\n }\n }\n\n // Right flush candidates\n int maxK = N - (lastF+1);\n gain = 0;\n for(int k=1;k<=maxK;k++){\n if(bd.a[i][N-k]=='x') gain++;\n if(gain>0){\n Candidate c{'R', i, k, gain};\n if(!found || betterCandidate(c, best)){\n best = c; found = true;\n }\n }\n }\n }\n\n // cols\n for(int j=0;j0){\n Candidate c{'U', j, k, gain};\n if(!found || betterCandidate(c, best)){\n best = c; found = true;\n }\n }\n }\n\n // Down flush\n int maxK = N - (lastF+1);\n gain = 0;\n for(int k=1;k<=maxK;k++){\n if(bd.a[N-k][j]=='x') gain++;\n if(gain>0){\n Candidate c{'D', j, k, gain};\n if(!found || betterCandidate(c, best)){\n best = c; found = true;\n }\n }\n }\n }\n\n return found;\n}\n\n// Guaranteed baseline (reversible per-oni) computed from the *initial* board only.\nstatic vector> buildBaselineGuaranteed(int N, const vector& C){\n vector rowFirstF(N, N), rowLastF(N, -1);\n vector colFirstF(N, N), colLastF(N, -1);\n vector> oni;\n\n for(int i=0;i> ops;\n ops.reserve(1600);\n\n for(auto [i,j] : oni){\n // pick any safe direction guaranteed by statement (on initial board)\n if(rowFirstF[i] > j){\n int k = j+1;\n for(int t=0;t i){\n int k = i+1;\n for(int t=0;t 4*N*N){\n // extremely unlikely with guarantee; return empty to avoid WA\n return {};\n }\n return ops;\n}\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector C(N);\n for(int i=0;i> C[i];\n\n // baseline (always safe)\n vector> baseline = buildBaselineGuaranteed(N, C);\n\n Board bd;\n bd.init(N, C);\n\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n vector> ops;\n ops.reserve(1600);\n\n const int MOVE_LIMIT = 4*N*N;\n\n int stagnant = 0;\n while(bd.oniCnt > 0 && (int)ops.size() < MOVE_LIMIT){\n Candidate best;\n if(findBestFlushRemovingX(bd, best)){\n // apply k steps\n for(int t=0; t> legalMoves;\n legalMoves.reserve(80);\n for(int p=0;p bestScore || (score==bestScore && rng.next_int(4)==0)){\n bestScore = score;\n bestDir = d;\n bestP = p;\n }\n }\n\n // if no improvement possible, do a random legal move to shake\n if(bestScore <= 0){\n stagnant++;\n auto [d,p] = legalMoves[rng.next_int((int)legalMoves.size())];\n bestDir = d; bestP = p;\n } else stagnant = 0;\n\n ops.push_back({bestDir, bestP});\n bd.applySingle(bestDir, bestP);\n\n // If we seem to be cycling too much, stop and fallback to baseline\n if(stagnant > 400) break;\n }\n\n // Use heuristic result if solved and within limit; else fallback to baseline\n if(bd.oniCnt == 0 && (int)ops.size() <= MOVE_LIMIT && !ops.empty()){\n for(auto [d,p] : ops){\n cout << d << \" \" << p << \"\\n\";\n }\n } else {\n // baseline is guaranteed safe from initial state\n for(auto [d,p] : baseline){\n cout << d << \" \" << p << \"\\n\";\n }\n }\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic constexpr int NMAX = 100;\n\nstatic inline long long simulate_plan(int N, int L,\n const int a[NMAX], const int b[NMAX],\n const int T[NMAX],\n int outCnt[NMAX]) {\n for (int i = 0; i < N; i++) outCnt[i] = 0;\n\n int x = 0;\n outCnt[x] = 1;\n\n for (int step = 1; step < L; step++) {\n // parity of visits to x so far decides next\n int nx = (outCnt[x] & 1) ? a[x] : b[x];\n x = nx;\n outCnt[x]++;\n }\n\n long long err = 0;\n for (int i = 0; i < N; i++) err += llabs((long long)outCnt[i] - (long long)T[i]);\n return err;\n}\n\n// Fast assignment optimizer for b:\n// Minimize sum_j |binSum[j] - D[j]| where binSum[j] = sum_{i: b[i]=j} T[i].\n// O(1) delta update per move.\nstruct FastBAssignOptimizer {\n int N;\n const int *T;\n const long long *D;\n XorShift64 *rng;\n\n vector b; // b[i]=bin\n array binSum{};\n long long cost = (1LL<<62);\n\n static inline long long absll(long long x){ return x<0?-x:x; }\n\n long long compute_cost() const {\n long long c = 0;\n for (int j = 0; j < N; j++) c += absll(binSum[j] - D[j]);\n return c;\n }\n\n // Greedy init with randomness:\n // place larger items first into the bin with largest remaining need (D - binSum),\n // with some random sampling.\n void greedy_init() {\n b.assign(N, 0);\n for (int j = 0; j < N; j++) binSum[j] = 0;\n\n vector items(N);\n iota(items.begin(), items.end(), 0);\n stable_sort(items.begin(), items.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] > T[j];\n return i < j;\n });\n\n // small shuffle among equal weights to diversify starts\n for (int l = 0; l < N; ) {\n int r = l;\n while (r < N && T[items[r]] == T[items[l]]) r++;\n for (int k = l; k < r; k++) {\n int s = (*rng).next_int(l, r - 1);\n swap(items[k], items[s]);\n }\n l = r;\n }\n\n for (int idx = 0; idx < N; idx++) {\n int i = items[idx];\n long long w = T[i];\n\n // sample a few bins and pick best by (D - binSum)\n int bestJ = 0;\n long long bestNeed = LLONG_MIN;\n int samples = 10;\n for (int t = 0; t < samples; t++) {\n int j = (*rng).next_int(0, N - 1);\n long long need = D[j] - binSum[j];\n // slight preference to bins where need>=w, but not required\n long long score = need;\n if (need < w) score -= (w - need) / 2;\n if (score > bestNeed) {\n bestNeed = score;\n bestJ = j;\n }\n }\n // also compare against current global best-need bin sometimes\n if ((*rng).next_double() < 0.5) {\n int j2 = 0;\n long long best2 = D[0] - binSum[0];\n for (int j = 1; j < N; j++) {\n long long need = D[j] - binSum[j];\n if (need > best2) { best2 = need; j2 = j; }\n }\n long long need = D[j2] - binSum[j2];\n long long score = need;\n if (need < w) score -= (w - need) / 2;\n if (score > bestNeed) bestJ = j2;\n }\n\n b[i] = bestJ;\n binSum[bestJ] += w;\n }\n\n cost = compute_cost();\n }\n\n void run_sa(int iterations, double t0, double t1) {\n // Prepare heavy items list for biased selection\n vector heavy(N);\n iota(heavy.begin(), heavy.end(), 0);\n stable_sort(heavy.begin(), heavy.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] > T[j];\n return i < j;\n });\n int Kheavy = min(N, 30);\n\n for (int it = 0; it < iterations; it++) {\n double prog = (double)it / max(1, iterations - 1);\n double temp = t0 * pow(t1 / t0, prog);\n\n int i = heavy[(*rng).next_int(0, Kheavy - 1)];\n int from = b[i];\n if (T[i] == 0) continue;\n\n // pick candidate bin: sample and choose most \"needed\"\n int to = from;\n long long bestNeed = LLONG_MIN;\n for (int s = 0; s < 8; s++) {\n int j = (*rng).next_int(0, N - 1);\n long long need = D[j] - binSum[j];\n if (need > bestNeed) { bestNeed = need; to = j; }\n }\n if (to == from) continue;\n\n long long w = T[i];\n long long oldPart = llabs(binSum[from] - D[from]) + llabs(binSum[to] - D[to]);\n\n long long newFromSum = binSum[from] - w;\n long long newToSum = binSum[to] + w;\n long long newPart = llabs(newFromSum - D[from]) + llabs(newToSum - D[to]);\n\n long long newCost = cost + (newPart - oldPart);\n\n bool accept = false;\n if (newCost <= cost) accept = true;\n else {\n double prob = exp((double)(cost - newCost) / temp);\n if ((*rng).next_double() < prob) accept = true;\n }\n if (accept) {\n b[i] = to;\n binSum[from] -= w;\n binSum[to] += w;\n cost = newCost;\n }\n }\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, L;\n cin >> N >> L;\n static int T[NMAX];\n for (int i = 0; i < N; i++) cin >> T[i];\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift64 rng(seed);\n\n // ---- Build a as ascending-by-T Hamiltonian cycle, rotated so order[0]=0 ----\n vector order(N);\n iota(order.begin(), order.end(), 0);\n stable_sort(order.begin(), order.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] < T[j];\n return i < j;\n });\n // rotate to put employee 0 at position 0 (slightly reduces start transient weirdness)\n {\n int pos0 = 0;\n for (int k = 0; k < N; k++) if (order[k] == 0) { pos0 = k; break; }\n rotate(order.begin(), order.begin() + pos0, order.end());\n }\n\n static int a[NMAX], b_cur[NMAX], b_best[NMAX];\n static int predOf[NMAX];\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n a[u] = v;\n }\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n predOf[v] = u;\n }\n\n // residual demand for b-slots in the stationary-equation sense:\n // 2*T[j] should equal sum of incoming slot-weights T[i] (one per outgoing edge-slot).\n // a-cycle already contributes one slot weight T[predOf[j]] into j.\n static long long D[NMAX];\n for (int j = 0; j < N; j++) D[j] = 2LL * T[j] - (long long)T[predOf[j]];\n // With ascending cycle, T[pred] <= T[j] => D[j] >= T[j] >= 0.\n\n // ---- Fast multi-start optimization of b assignment (cheap objective) ----\n vector best_b_assign;\n long long best_assign_cost = (1LL<<62);\n\n // decide time budget split\n auto tStart = chrono::high_resolution_clock::now();\n const double TL = 1.90; // overall\n const double TL_FAST = 0.55; // spend ~0.55s in cheap b-optimizer\n\n int restarts = 8;\n for (int r = 0; r < restarts; r++) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - tStart).count();\n if (elapsed > TL_FAST) break;\n\n FastBAssignOptimizer opt;\n opt.N = N;\n opt.T = T;\n opt.D = D;\n opt.rng = &rng;\n\n opt.greedy_init();\n // more iterations on first restart, fewer later\n int iters = (r == 0 ? 250000 : 150000);\n opt.run_sa(iters, 8000.0, 5.0);\n\n if (opt.cost < best_assign_cost) {\n best_assign_cost = opt.cost;\n best_b_assign = opt.b;\n }\n }\n\n if (best_b_assign.empty()) {\n best_b_assign.assign(N, 0);\n }\n for (int i = 0; i < N; i++) b_cur[i] = best_b_assign[i];\n\n // ---- Evaluate by true simulation ----\n static int cnt_cur[NMAX], cnt_tmp[NMAX];\n long long err_cur = simulate_plan(N, L, a, b_cur, T, cnt_cur);\n long long err_best = err_cur;\n for (int i = 0; i < N; i++) b_best[i] = b_cur[i];\n\n // ---- Expensive SA on true error, remaining time ----\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - tStart).count();\n if (elapsed > TL) break;\n\n double progress = (elapsed - TL_FAST) / max(1e-9, (TL - TL_FAST));\n progress = min(1.0, max(0.0, progress));\n double temp0 = 1500.0, temp1 = 10.0;\n double temp = temp0 * pow(temp1 / temp0, progress);\n\n // Build biased lists occasionally (cheap)\n // Pick i among those with large cnt (affects more future path)\n array idxByCnt;\n for (int i = 0; i < N; i++) idxByCnt[i] = i;\n nth_element(idxByCnt.begin(), idxByCnt.begin() + min(N, 30), idxByCnt.begin() + N,\n [&](int i, int j){ return cnt_cur[i] > cnt_cur[j]; });\n int i = idxByCnt[rng.next_int(0, min(N, 30) - 1)];\n\n bool doSwap = (rng.next_double() < 0.40);\n\n int old_bi = b_cur[i];\n int i2 = -1, old_bi2 = -1;\n\n if (!doSwap) {\n // Move b_i to a deficit node with bias\n // Choose candidate among top deficits by sampling\n int bestJ = old_bi;\n int bestDef = INT_MIN;\n for (int s = 0; s < 12; s++) {\n int j = rng.next_int(0, N - 1);\n int def = T[j] - cnt_cur[j];\n if (def > bestDef) { bestDef = def; bestJ = j; }\n }\n int j = bestJ;\n if (j == old_bi) continue;\n b_cur[i] = j;\n } else {\n // Swap two b's\n i2 = idxByCnt[rng.next_int(0, min(N, 30) - 1)];\n if (i2 == i) i2 = rng.next_int(0, N - 1);\n if (i2 == i) continue;\n old_bi2 = b_cur[i2];\n if (old_bi2 == old_bi) continue;\n swap(b_cur[i], b_cur[i2]);\n }\n\n long long err_new = simulate_plan(N, L, a, b_cur, T, cnt_tmp);\n\n bool accept = false;\n if (err_new <= err_cur) accept = true;\n else {\n double prob = exp((double)(err_cur - err_new) / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n err_cur = err_new;\n for (int k = 0; k < N; k++) cnt_cur[k] = cnt_tmp[k];\n if (err_cur < err_best) {\n err_best = err_cur;\n for (int k = 0; k < N; k++) b_best[k] = b_cur[k];\n }\n } else {\n // revert\n if (!doSwap) {\n b_cur[i] = old_bi;\n } else {\n swap(b_cur[i], b_cur[i2]);\n }\n }\n }\n\n // Output\n for (int i = 0; i < N; i++) {\n cout << a[i] << ' ' << b_best[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nstruct DSU {\n int n;\n vector p, r;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n p.resize(n);\n r.assign(n,0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){ return p[a]==a?a:p[a]=find(p[a]);}\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a] 0; s /= 2) {\n int rx = (x & s) ? 1 : 0;\n int ry = (y & s) ? 1 : 0;\n d += (uint32_t)s * (uint32_t)s * (uint32_t)((3 * rx) ^ ry);\n rot(s, x, y, rx, ry);\n }\n return d;\n}\n\nstatic inline long long dist2_est(int ax, int ay, int bx, int by){\n long long dx = ax - bx;\n long long dy = ay - by;\n return dx*dx + dy*dy;\n}\n\nstruct GroupInfo {\n vector nodes;\n bool exactKnown = false;\n vector> exactEdges;\n vector> queryEdges;\n};\n\n// Build groups along a given order using the same greedy size-picking logic as before,\n// and return total \"chain cost\" for evaluation.\nstatic pair, long long> build_groups_greedy(\n const vector& order,\n const vector& ex,\n const vector& ey,\n const vector& G\n){\n const int N = (int)order.size();\n const int M = (int)G.size();\n\n // pref of consecutive squared dist along this order\n vector pref(N, 0);\n for(int i=0;i+1long long{\n if(s <= 1) return 0LL;\n return pref[p+s-1] - pref[p];\n };\n\n map cnt;\n for(int x: G) cnt[x]++;\n\n auto pop_size = [&](int s){\n auto it = cnt.find(s);\n if(it == cnt.end()) return false;\n if(--it->second == 0) cnt.erase(it);\n return true;\n };\n\n auto collect_candidates = [&](int nrem, int grem)->vector{\n vector cands;\n cands.reserve(32);\n\n for(auto it = cnt.begin(); it != cnt.end() && (int)cands.size() < 6; ++it){\n if(it->first <= nrem) cands.push_back(it->first);\n }\n int added = 0;\n for(auto it = cnt.rbegin(); it != cnt.rend() && added < 4; ++it){\n if(it->first <= nrem) { cands.push_back(it->first); added++; }\n }\n\n double target = (grem > 0) ? (double)nrem / (double)grem : (double)nrem;\n vector keys;\n keys.reserve(cnt.size());\n for(auto &kv: cnt) keys.push_back(kv.first);\n auto it = lower_bound(keys.begin(), keys.end(), (int)llround(target));\n for(int d=-3; d<=3; d++){\n int idx = (int)(it - keys.begin()) + d;\n if(0 <= idx && idx < (int)keys.size()){\n int s = keys[idx];\n if(s <= nrem) cands.push_back(s);\n }\n }\n sort(cands.begin(), cands.end());\n cands.erase(unique(cands.begin(), cands.end()), cands.end());\n if(cands.empty()){\n for(auto &kv: cnt) if(kv.first <= nrem) { cands.push_back(kv.first); break; }\n }\n return cands;\n };\n\n vector glist;\n glist.reserve(M);\n\n int p = 0;\n int groupsRem = M;\n long long totalChain = 0;\n\n while(groupsRem > 0){\n int nrem = N - p;\n if(groupsRem == 1){\n int s = nrem;\n if(!pop_size(s)){\n // should not happen\n s = cnt.rbegin()->first;\n pop_size(s);\n }\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+s);\n totalChain += chainCost(p, s);\n glist.push_back(std::move(gi));\n p += s;\n groupsRem--;\n break;\n }\n\n auto cands = collect_candidates(nrem, groupsRem);\n\n long double target = (long double)nrem / (long double)groupsRem;\n const long double lambda = 1e4L;\n int bestS = -1;\n long double bestVal = 1e100L;\n\n for(int s: cands){\n if(s > nrem) continue;\n long double avg = 0;\n if(s >= 2){\n avg = (long double)chainCost(p, s) / (long double)(s - 1);\n }\n long double val = avg + lambda * fabsl((long double)s - target);\n if(val < bestVal){\n bestVal = val;\n bestS = s;\n }\n }\n if(bestS < 1 || bestS > nrem){\n bestS = cnt.begin()->first;\n if(bestS > nrem) bestS = cnt.rbegin()->first;\n }\n\n pop_size(bestS);\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+bestS);\n totalChain += chainCost(p, bestS);\n glist.push_back(std::move(gi));\n p += bestS;\n groupsRem--;\n }\n\n return {glist, totalChain};\n}\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for(int i=0;i> G[i];\n\n vector lx(N), rx(N), ly(N), ry(N);\n for(int i=0;i> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n vector ex(N), ey(N);\n for(int i=0;iint{\n return (int)llround((long double)v * 65535.0L / 10000.0L);\n };\n\n // Prepare 4 candidate orders\n vector> orders;\n\n // 1) Hilbert(x,y)\n {\n vector key(N);\n for(int i=0;i ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(key[a]!=key[b]) return key[a] key(N);\n for(int i=0;i ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(key[a]!=key[b]) return key[a] ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(ex[a]!=ex[b]) return ex[a] ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(ey[a]!=ey[b]) return ey[a] glist;\n for(auto &ord: orders){\n auto [tmp, sc] = build_groups_greedy(ord, ex, ey, G);\n if(sc < bestScore){\n bestScore = sc;\n glist = std::move(tmp);\n }\n }\n\n // Map created groups to output indices by size\n vector outIdx(M);\n iota(outIdx.begin(), outIdx.end(), 0);\n sort(outIdx.begin(), outIdx.end(), [&](int a, int b){\n if(G[a] != G[b]) return G[a] < G[b];\n return a < b;\n });\n\n vector grpIdx(M);\n iota(grpIdx.begin(), grpIdx.end(), 0);\n sort(grpIdx.begin(), grpIdx.end(), [&](int a, int b){\n int sa = (int)glist[a].nodes.size();\n int sb = (int)glist[b].nodes.size();\n if(sa != sb) return sa < sb;\n return a < b;\n });\n\n vector groupForOut(M, -1);\n for(int i=0;i& subset)->vector>{\n int l = (int)subset.size();\n cout << \"? \" << l;\n for(int v: subset) cout << \" \" << v;\n cout << \"\\n\" << flush;\n vector> ret;\n ret.reserve(l-1);\n for(int i=0;i> a >> b;\n if(a>b) swap(a,b);\n ret.push_back({a,b});\n }\n return ret;\n };\n\n int usedQ = 0;\n\n // 1) exact query for size 3..L (skip 2, trivial)\n vector allGroups(M);\n iota(allGroups.begin(), allGroups.end(), 0);\n sort(allGroups.begin(), allGroups.end(), [&](int a, int b){\n int sa = (int)glist[a].nodes.size();\n int sb = (int)glist[b].nodes.size();\n if(sa != sb) return sa < sb;\n return a < b;\n });\n\n for(int gi : allGroups){\n if(usedQ >= Q) break;\n int g = (int)glist[gi].nodes.size();\n if(3 <= g && g <= L){\n auto ret = do_query(glist[gi].nodes);\n glist[gi].exactKnown = true;\n glist[gi].exactEdges = std::move(ret);\n usedQ++;\n }\n }\n\n // 2) large groups: diversified block queries (two offset passes + random windows)\n vector largeGroups;\n for(int gi=0; gi L) largeGroups.push_back(gi);\n }\n sort(largeGroups.begin(), largeGroups.end(), [&](int a,int b){\n return glist[a].nodes.size() > glist[b].nodes.size();\n });\n\n // RNG for random window starts (deterministic-ish)\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n seed ^= (uint64_t)N * 1000003ULL + (uint64_t)M * 911382323ULL + (uint64_t)L;\n mt19937_64 rng(seed);\n\n for(int gi : largeGroups){\n if(usedQ >= Q) break;\n auto &vec = glist[gi].nodes;\n int g = (int)vec.size();\n\n auto do_pass = [&](int startPos){\n int step = L - 1;\n for(int pos = startPos; pos < g-1 && usedQ < Q; pos += step){\n int l = min(L, g - pos);\n if(l < 2) break;\n vector subset(vec.begin()+pos, vec.begin()+pos+l);\n auto ret = do_query(subset);\n glist[gi].queryEdges.insert(glist[gi].queryEdges.end(), ret.begin(), ret.end());\n usedQ++;\n }\n };\n\n // Pass 1: aligned\n do_pass(0);\n if(usedQ >= Q) continue;\n\n // Pass 2: offset (adds diversity)\n int offset = (L - 1) / 2;\n if(offset > 0) do_pass(offset);\n\n if(usedQ >= Q) continue;\n\n // Random windows if still have budget and group is big enough\n if(g >= L + 3){\n uniform_int_distribution dist(0, g - L);\n int trials = 0;\n int maxTrials = 8; // keep moderate\n while(usedQ < Q && trials < maxTrials){\n int pos = dist(rng);\n vector subset(vec.begin()+pos, vec.begin()+pos+L);\n auto ret = do_query(subset);\n glist[gi].queryEdges.insert(glist[gi].queryEdges.end(), ret.begin(), ret.end());\n usedQ++;\n trials++;\n }\n }\n }\n\n // Answer\n cout << \"!\\n\" << flush;\n\n auto add_unique_edge = [&](unordered_set &seen, vector> &edges, int u, int v){\n if(u==v) return;\n if(u>v) swap(u,v);\n int key = u*1024 + v; // N<=800\n if(seen.insert(key).second){\n edges.push_back({u,v});\n }\n };\n\n for(int outk=0; outkv) swap(u,v);\n cout << u << \" \" << v << \"\\n\";\n continue;\n }\n\n unordered_set seen;\n seen.reserve((size_t)g * 64);\n\n vector> candQuery;\n candQuery.reserve(info.queryEdges.size());\n for(auto &e: info.queryEdges){\n add_unique_edge(seen, candQuery, e.first, e.second);\n }\n\n vector> candOther;\n candOther.reserve((size_t)g * 32);\n\n // Chain\n for(int i=0;i byx = vec, byy = vec;\n sort(byx.begin(), byx.end(), [&](int a,int b){\n if(ex[a]!=ex[b]) return ex[a]> tmp;\n tmp.reserve(g-1);\n for(int jj=0; jj kNN){\n nth_element(tmp.begin(), tmp.begin()+kNN, tmp.end());\n }\n int take = min(kNN, (int)tmp.size());\n for(int t=0;t lid;\n lid.reserve((size_t)g*2);\n for(int i=0;i all;\n all.reserve(candQuery.size() + candOther.size());\n\n auto pushE = [&](int u,int v,bool isQ){\n all.push_back({u,v, dist2_est(ex[u], ey[u], ex[v], ey[v]), isQ});\n };\n for(auto &e: candQuery) pushE(e.first, e.second, true);\n for(auto &e: candOther) pushE(e.first, e.second, false);\n\n sort(all.begin(), all.end(), [&](const CandE& a, const CandE& b){\n // Stronger preference for query edges, but still weight by estimated length\n long double wa = (long double)a.d2 * (a.isQuery ? 0.62L : 1.0L);\n long double wb = (long double)b.d2 * (b.isQuery ? 0.62L : 1.0L);\n if(wa != wb) return wa < wb;\n if(a.isQuery != b.isQuery) return a.isQuery > b.isQuery;\n if(a.u != b.u) return a.u < b.u;\n return a.v < b.v;\n });\n\n DSU dsu(g);\n vector> chosen;\n chosen.reserve(g-1);\n\n for(auto &e: all){\n int a = lid[e.u], b = lid[e.v];\n if(dsu.unite(a,b)){\n int u=e.u, v=e.v;\n if(u>v) swap(u,v);\n chosen.push_back({u,v});\n if((int)chosen.size() == g-1) break;\n }\n }\n\n // Connect remaining components by best estimated edges (fallback)\n while((int)chosen.size() < g-1){\n for(int i=0;iv) swap(u,v);\n chosen.push_back({u,v});\n }\n\n if((int)chosen.size() != g-1){\n chosen.clear();\n int c = vec[0];\n for(int i=1;iv) swap(u,v);\n chosen.push_back({u,v});\n }\n }\n\n for(auto &e: chosen){\n cout << e.first << \" \" << e.second << \"\\n\";\n }\n }\n\n cout << flush;\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nstatic constexpr int N = 20;\n\nstruct Pos {\n int r, c;\n};\nstatic inline int pid(int r, int c) { return r * N + c; }\nstatic inline bool inside(int r, int c) { return 0 <= r && r < N && 0 <= c && c < N; }\n\nstruct Prev {\n int pstate = -1;\n char act = '?';\n char dir = '?';\n};\n\nstatic const int dr[4] = {-1, 1, 0, 0};\nstatic const int dc[4] = {0, 0, -1, 1};\nstatic const char dch[4] = {'U', 'D', 'L', 'R'};\n\nstruct Planner {\n // candidate cells (<=8)\n vector cand;\n array cand_id; // -1 if not candidate, else index\n int C = 0;\n\n Planner() {\n cand_id.fill(-1);\n }\n\n void build_candidates(const Pos& start, const Pos& target) {\n cand.clear();\n cand_id.fill(-1);\n\n auto add = [&](int r, int c) {\n if (!inside(r,c)) return;\n int id = pid(r,c);\n if (cand_id[id] != -1) return;\n cand_id[id] = (int)cand.size();\n cand.push_back({r,c});\n };\n\n // neighbors of start\n for (int k = 0; k < 4; k++) add(start.r + dr[k], start.c + dc[k]);\n // neighbors of target\n for (int k = 0; k < 4; k++) add(target.r + dr[k], target.c + dc[k]);\n\n C = (int)cand.size();\n }\n\n inline bool is_blocked_cell(int r, int c, int mask) const {\n int idx = cand_id[pid(r,c)];\n if (idx == -1) return false; // board is otherwise empty\n return (mask >> idx) & 1;\n }\n\n int slide_endpoint(int r, int c, int dir, int mask) const {\n // Find nearest candidate-block in that ray; otherwise boundary.\n int bestDist = INT_MAX;\n\n // scan candidate blocks only (C <= 8)\n for (int i = 0; i < C; i++) if ((mask >> i) & 1) {\n int br = cand[i].r, bc = cand[i].c;\n if (dir == 0) { // U\n if (bc == c && br < r) bestDist = min(bestDist, r - br);\n } else if (dir == 1) { // D\n if (bc == c && br > r) bestDist = min(bestDist, br - r);\n } else if (dir == 2) { // L\n if (br == r && bc < c) bestDist = min(bestDist, c - bc);\n } else { // R\n if (br == r && bc > c) bestDist = min(bestDist, bc - c);\n }\n }\n\n if (bestDist != INT_MAX) {\n // stop right before the block\n int nr = r + dr[dir] * (bestDist - 1);\n int nc = c + dc[dir] * (bestDist - 1);\n return pid(nr, nc);\n } else {\n // stop at boundary edge cell\n if (dir == 0) return pid(0, c);\n if (dir == 1) return pid(N - 1, c);\n if (dir == 2) return pid(r, 0);\n return pid(r, N - 1);\n }\n }\n\n // BFS shortest path from start to target, with mask starting at 0 and ending at 0\n vector> plan(const Pos& start, const Pos& target) {\n build_candidates(start, target);\n const int MASKS = 1 << C;\n const int STATES = (N*N) * MASKS;\n\n vector dist(STATES, -1);\n vector prv(STATES);\n\n auto sid = [&](int pos, int mask) {\n return pos * MASKS + mask;\n };\n\n int sPos = pid(start.r, start.c);\n int tPos = pid(target.r, target.c);\n int sState = sid(sPos, 0);\n int gState = sid(tPos, 0);\n\n deque q;\n dist[sState] = 0;\n q.push_back(sState);\n\n while (!q.empty()) {\n int cur = q.front(); q.pop_front();\n if (cur == gState) break;\n\n int pos = cur / MASKS;\n int mask = cur % MASKS;\n int r = pos / N;\n int c = pos % N;\n\n for (int d = 0; d < 4; d++) {\n // Move\n {\n int nr = r + dr[d], nc = c + dc[d];\n if (inside(nr,nc) && !is_blocked_cell(nr,nc,mask)) {\n int np = pid(nr,nc);\n int ns = sid(np, mask);\n if (dist[ns] == -1) {\n dist[ns] = dist[cur] + 1;\n prv[ns] = {cur, 'M', dch[d]};\n q.push_back(ns);\n }\n }\n }\n // Slide\n {\n int np = slide_endpoint(r,c,d,mask);\n int ns = sid(np, mask);\n if (dist[ns] == -1) {\n dist[ns] = dist[cur] + 1;\n prv[ns] = {cur, 'S', dch[d]};\n q.push_back(ns);\n }\n }\n // Alter (only if adjacent cell is in candidate set)\n {\n int ar = r + dr[d], ac = c + dc[d];\n if (inside(ar,ac)) {\n int idx = cand_id[pid(ar,ac)];\n if (idx != -1) {\n int nmask = mask ^ (1 << idx);\n int ns = sid(pos, nmask);\n if (dist[ns] == -1) {\n dist[ns] = dist[cur] + 1;\n prv[ns] = {cur, 'A', dch[d]};\n q.push_back(ns);\n }\n }\n }\n }\n }\n }\n\n if (dist[gState] == -1) {\n // Should not happen, but fallback: Manhattan moves (board is empty).\n vector> res;\n int r = start.r, c = start.c;\n while (r < target.r) { res.push_back({'M','D'}); r++; }\n while (r > target.r) { res.push_back({'M','U'}); r--; }\n while (c < target.c) { res.push_back({'M','R'}); c++; }\n while (c > target.c) { res.push_back({'M','L'}); c--; }\n return res;\n }\n\n // Reconstruct\n vector> rev;\n int cur = gState;\n while (cur != sState) {\n Prev p = prv[cur];\n rev.push_back({p.act, p.dir});\n cur = p.pstate;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n }\n\n // For debug/safety: simulate within the same per-leg candidate/mask model\n void simulate_leg(Pos &cur, const Pos& target, const vector>& acts) {\n // candidates already built by plan() before calling this, but to be safe rebuild:\n build_candidates(cur, target);\n int mask = 0;\n\n auto dirIndex = [&](char d)->int{\n if (d=='U') return 0;\n if (d=='D') return 1;\n if (d=='L') return 2;\n return 3;\n };\n\n for (auto [a,d] : acts) {\n int di = dirIndex(d);\n if (a=='M') {\n int nr = cur.r + dr[di], nc = cur.c + dc[di];\n if (!inside(nr,nc) || is_blocked_cell(nr,nc,mask)) {\n // illegal; ignore in release builds\n // but we keep it strict:\n cerr << \"Illegal move\\n\";\n exit(0);\n }\n cur = {nr,nc};\n } else if (a=='S') {\n int np = slide_endpoint(cur.r, cur.c, di, mask);\n cur = {np / N, np % N};\n } else if (a=='A') {\n int ar = cur.r + dr[di], ac = cur.c + dc[di];\n if (!inside(ar,ac)) { cerr << \"Illegal alter\\n\"; exit(0); }\n int idx = cand_id[pid(ar,ac)];\n if (idx == -1) { cerr << \"Alter outside candidates (shouldn't happen)\\n\"; exit(0); }\n mask ^= (1<> n >> M;\n vector pts(M);\n for (int i = 0; i < M; i++) cin >> pts[i].r >> pts[i].c;\n\n Pos cur = pts[0];\n vector> answer;\n answer.reserve(1600);\n\n Planner planner;\n\n for (int k = 1; k < M; k++) {\n Pos tgt = pts[k];\n auto acts = planner.plan(cur, tgt);\n\n // Safety simulate (cheap) and advance cur\n planner.simulate_leg(cur, tgt, acts);\n\n for (auto &p : acts) answer.push_back(p);\n }\n\n // Output\n for (auto [a,d] : answer) {\n cout << a << ' ' << d << \"\\n\";\n }\n return 0;\n}"},"8":{"ahc001":"#include \nusing namespace std;\n\nstatic constexpr int W = 10000;\nstatic constexpr int H = 10000;\n\nstruct Rect {\n int lx, ly, rx, ry; // [lx,rx) x [ly,ry)\n};\n\nstatic inline long long areaLL(const Rect& r) {\n return 1LL * (r.rx - r.lx) * (r.ry - r.ly);\n}\nstatic inline bool overlapPosArea(const Rect& a, const Rect& b) {\n int x0 = max(a.lx, b.lx);\n int x1 = min(a.rx, b.rx);\n if (x0 >= x1) return false;\n int y0 = max(a.ly, b.ly);\n int y1 = min(a.ry, b.ry);\n return y0 < y1;\n}\nstatic inline double sat(long long r, long long s) {\n long long mn = min(r, s);\n long long mx = max(r, s);\n double a = (double)mn / (double)mx;\n double t = 1.0 - a;\n return 1.0 - t * t;\n}\n\n// splitmix64 RNG\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t nextU64() {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n }\n uint32_t nextU32() { return (uint32_t)nextU64(); }\n double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Solver {\n int n;\n vector x, y;\n vector r;\n vector rects;\n vector p;\n RNG rng;\n\n using clk = chrono::high_resolution_clock;\n clk::time_point start;\n\n double elapsedSec() const {\n return chrono::duration(clk::now() - start).count();\n }\n\n bool containsPoint(int i, const Rect& rc) const {\n return (rc.lx <= x[i] && rc.rx >= x[i] + 1 && rc.ly <= y[i] && rc.ry >= y[i] + 1);\n }\n bool inBounds(const Rect& rc) const {\n return (0 <= rc.lx && rc.lx < rc.rx && rc.rx <= W &&\n 0 <= rc.ly && rc.ly < rc.ry && rc.ry <= H);\n }\n bool validNoOverlapOne(int i, const Rect& rc) const {\n if (!inBounds(rc)) return false;\n if (!containsPoint(i, rc)) return false;\n for (int j = 0; j < n; j++) if (j != i) {\n if (overlapPosArea(rc, rects[j])) return false;\n }\n return true;\n }\n bool validNoOverlapTwo(int i, const Rect& ri, int j, const Rect& rj) const {\n if (!inBounds(ri) || !inBounds(rj)) return false;\n if (!containsPoint(i, ri) || !containsPoint(j, rj)) return false;\n if (overlapPosArea(ri, rj)) return false;\n for (int k = 0; k < n; k++) if (k != i && k != j) {\n if (overlapPosArea(ri, rects[k])) return false;\n if (overlapPosArea(rj, rects[k])) return false;\n }\n return true;\n }\n\n // Directional nearest blockers\n int blockerRight(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestL = W + 1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.lx >= a.rx && b.lx < bestL) {\n bestL = b.lx;\n best = j;\n }\n }\n }\n return best;\n }\n int blockerLeft(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestR = -1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.rx <= a.lx && b.rx > bestR) {\n bestR = b.rx;\n best = j;\n }\n }\n }\n return best;\n }\n int blockerUp(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestB = H + 1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ly >= a.ry && b.ly < bestB) {\n bestB = b.ly;\n best = j;\n }\n }\n }\n return best;\n }\n int blockerDown(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestT = -1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ry <= a.ly && b.ry > bestT) {\n bestT = b.ry;\n best = j;\n }\n }\n }\n return best;\n }\n\n int limitRight(int i) const {\n const Rect& a = rects[i];\n int lim = W;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.lx >= a.rx) lim = min(lim, b.lx);\n }\n }\n return lim;\n }\n int limitLeft(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.rx <= a.lx) lim = max(lim, b.rx);\n }\n }\n return lim;\n }\n int limitUp(int i) const {\n const Rect& a = rects[i];\n int lim = H;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ly >= a.ry) lim = min(lim, b.ly);\n }\n }\n return lim;\n }\n int limitDown(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ry <= a.ly) lim = max(lim, b.ry);\n }\n }\n return lim;\n }\n\n void init() {\n rects.resize(n);\n p.assign(n, 0.0);\n for (int i = 0; i < n; i++) {\n rects[i] = Rect{x[i], y[i], x[i] + 1, y[i] + 1};\n p[i] = sat(r[i], 1);\n }\n }\n\n void greedyExpand(int rounds = 7) {\n vector ord(n);\n iota(ord.begin(), ord.end(), 0);\n\n for (int rep = 0; rep < rounds; rep++) {\n shuffle(ord.begin(), ord.end(), std::mt19937((unsigned)rng.nextU32()));\n for (int idx = 0; idx < n; idx++) {\n int i = ord[idx];\n for (;;) {\n Rect cur = rects[i];\n long long s0 = areaLL(cur);\n if (s0 >= r[i]) break;\n\n double bestGain = 1e-18;\n Rect bestR = cur;\n\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n\n // Right\n {\n int lim = limitRight(i);\n if (lim > cur.rx) {\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.lx + (int)needW;\n vector cands = {cur.rx + 1, ideal - 1, ideal, ideal + 1, lim};\n for (int rx2 : cands) {\n rx2 = max(rx2, cur.rx + 1);\n rx2 = min(rx2, lim);\n if (rx2 <= cur.rx) continue;\n Rect cand = cur; cand.rx = rx2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n // Left\n {\n int lim = limitLeft(i);\n if (lim < cur.lx) {\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.rx - (int)needW;\n vector cands = {cur.lx - 1, ideal - 1, ideal, ideal + 1, lim};\n for (int lx2 : cands) {\n lx2 = min(lx2, cur.lx - 1);\n lx2 = max(lx2, lim);\n lx2 = min(lx2, x[i]);\n if (lx2 >= cur.lx) continue;\n Rect cand = cur; cand.lx = lx2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n // Up\n {\n int lim = limitUp(i);\n if (lim > cur.ry) {\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ly + (int)needH;\n vector cands = {cur.ry + 1, ideal - 1, ideal, ideal + 1, lim};\n for (int ry2 : cands) {\n ry2 = max(ry2, cur.ry + 1);\n ry2 = min(ry2, lim);\n if (ry2 <= cur.ry) continue;\n Rect cand = cur; cand.ry = ry2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n // Down\n {\n int lim = limitDown(i);\n if (lim < cur.ly) {\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ry - (int)needH;\n vector cands = {cur.ly - 1, ideal - 1, ideal, ideal + 1, lim};\n for (int ly2 : cands) {\n ly2 = min(ly2, cur.ly - 1);\n ly2 = max(ly2, lim);\n ly2 = min(ly2, y[i]);\n if (ly2 >= cur.ly) continue;\n Rect cand = cur; cand.ly = ly2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n\n if (bestGain <= 1e-18) break;\n rects[i] = bestR;\n p[i] = sat(r[i], areaLL(bestR));\n }\n }\n }\n }\n\n // shrink-only overshoot fixer (safe)\n Rect fitInsideShrink(int i, const Rect& cur) const {\n int w0 = cur.rx - cur.lx;\n int h0 = cur.ry - cur.ly;\n long long ri = r[i];\n\n auto place1D = [&](int L, int R, int pos, int len)->pair{\n int minL = L;\n int maxL = R - len;\n int l = pos - (len - 1) / 2;\n l = max(minL, min(maxL, l));\n int rr = l + len;\n if (!(l <= pos && pos + 1 <= rr)) {\n l = max(minL, min(maxL, pos + 1 - len));\n rr = l + len;\n }\n return {l, rr};\n };\n\n Rect best = cur;\n double bestP = sat(ri, areaLL(cur));\n\n vector Ws, Hs;\n auto add = [&](vector& v, int val, int cap){\n val = max(1, min(val, cap));\n v.push_back(val);\n };\n int sq = (int)floor(sqrt((double)ri));\n add(Ws, sq, w0); add(Ws, sq+1, w0); add(Ws, w0, w0);\n add(Hs, sq, h0); add(Hs, sq+1, h0); add(Hs, h0, h0);\n\n add(Ws, (int)max(1LL, (ri + h0 - 1) / h0), w0);\n add(Hs, (int)max(1LL, (ri + w0 - 1) / w0), h0);\n\n sort(Ws.begin(), Ws.end());\n Ws.erase(unique(Ws.begin(), Ws.end()), Ws.end());\n sort(Hs.begin(), Hs.end());\n Hs.erase(unique(Hs.begin(), Hs.end()), Hs.end());\n\n for (int w : Ws) {\n int h = (int)max(1LL, min(h0, (ri + w - 1) / w));\n for (int dh : {0, -1, +1}) {\n int hh = h + dh;\n if (hh < 1 || hh > h0) continue;\n auto [lx, rx] = place1D(cur.lx, cur.rx, x[i], w);\n auto [ly, ry] = place1D(cur.ly, cur.ry, y[i], hh);\n Rect cand{lx, ly, rx, ry};\n double pp = sat(ri, areaLL(cand));\n if (pp > bestP + 1e-15) { bestP = pp; best = cand; }\n }\n }\n for (int h : Hs) {\n int w = (int)max(1LL, min(w0, (ri + h - 1) / h));\n for (int dw : {0, -1, +1}) {\n int ww = w + dw;\n if (ww < 1 || ww > w0) continue;\n auto [lx, rx] = place1D(cur.lx, cur.rx, x[i], ww);\n auto [ly, ry] = place1D(cur.ly, cur.ry, y[i], h);\n Rect cand{lx, ly, rx, ry};\n double pp = sat(ri, areaLL(cand));\n if (pp > bestP + 1e-15) { bestP = pp; best = cand; }\n }\n }\n return best;\n }\n\n int pickIndexTournament() {\n auto badness = [&](int i)->double{\n long long s = areaLL(rects[i]);\n double err = (double)llabs(s - r[i]) / (double)r[i];\n return (1.0 - p[i]) + 0.20 * err;\n };\n int best = rng.nextInt(0, n - 1);\n double bb = badness(best);\n for (int t = 0; t < 4; t++) {\n int j = rng.nextInt(0, n - 1);\n double bj = badness(j);\n if (bj > bb) { bb = bj; best = j; }\n }\n return best;\n }\n\n // New move: expand i while shrinking its nearest blocking neighbor j.\n bool tryStealMove(int i, Rect& outRi, int& outJ, Rect& outRj) {\n outRi = rects[i];\n outJ = -1;\n outRj = Rect{0,0,0,0};\n\n if (areaLL(rects[i]) >= r[i]) return false; // mostly use for deficit\n\n int dir = rng.nextInt(0, 3); // 0:R 1:L 2:U 3:D\n if (dir == 0) {\n int j = blockerRight(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // max delta constrained by b's left moving right while still containing its point\n int maxDelta = min(b.rx - b.lx - 1, x[j] - b.lx);\n if (maxDelta <= 0) return false;\n\n // also can expand into current gap for free; delta can exceed gap because we shrink b\n int h = a.ry - a.ly;\n long long needW = (r[i] + h - 1) / h;\n int want = max(1, (int)needW - (a.rx - a.lx));\n int d = min(maxDelta, max(1, want));\n // small randomness\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.rx += d;\n nb.lx += d;\n if (!containsPoint(j, nb)) return false;\n // ensure still ordered\n if (na.rx > nb.lx) na.rx = nb.lx;\n if (na.rx <= na.lx) return false;\n if (nb.lx >= nb.rx) return false;\n\n // Validate strictly to be safe\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n\n outRi = na; outJ = j; outRj = nb;\n return true;\n } else if (dir == 1) {\n int j = blockerLeft(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // shrink b from right (move rx left)\n int maxDelta = min(b.rx - b.lx - 1, b.rx - (x[j] + 1));\n if (maxDelta <= 0) return false;\n\n int h = a.ry - a.ly;\n long long needW = (r[i] + h - 1) / h;\n int want = max(1, (int)needW - (a.rx - a.lx));\n int d = min(maxDelta, max(1, want));\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.lx -= d;\n nb.rx -= d;\n if (!containsPoint(j, nb)) return false;\n if (nb.rx > na.lx) na.lx = nb.rx;\n if (na.lx >= na.rx) return false;\n if (nb.lx >= nb.rx) return false;\n\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n outRi = na; outJ = j; outRj = nb;\n return true;\n } else if (dir == 2) {\n int j = blockerUp(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // shrink b from bottom (move ly up)\n int maxDelta = min(b.ry - b.ly - 1, y[j] - b.ly);\n if (maxDelta <= 0) return false;\n\n int w = a.rx - a.lx;\n long long needH = (r[i] + w - 1) / w;\n int want = max(1, (int)needH - (a.ry - a.ly));\n int d = min(maxDelta, max(1, want));\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.ry += d;\n nb.ly += d;\n if (!containsPoint(j, nb)) return false;\n if (na.ry > nb.ly) na.ry = nb.ly;\n if (na.ry <= na.ly) return false;\n if (nb.ly >= nb.ry) return false;\n\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n outRi = na; outJ = j; outRj = nb;\n return true;\n } else {\n int j = blockerDown(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // shrink b from top (move ry down)\n int maxDelta = min(b.ry - b.ly - 1, b.ry - (y[j] + 1));\n if (maxDelta <= 0) return false;\n\n int w = a.rx - a.lx;\n long long needH = (r[i] + w - 1) / w;\n int want = max(1, (int)needH - (a.ry - a.ly));\n int d = min(maxDelta, max(1, want));\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.ly -= d;\n nb.ry -= d;\n if (!containsPoint(j, nb)) return false;\n if (nb.ry > na.ly) na.ly = nb.ry;\n if (na.ly >= na.ry) return false;\n if (nb.ly >= nb.ry) return false;\n\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n outRi = na; outJ = j; outRj = nb;\n return true;\n }\n }\n\n void anneal(double endTimeSec) {\n const double T0 = 0.06;\n const double T1 = 0.0016;\n\n while (elapsedSec() < endTimeSec) {\n double prog = elapsedSec() / endTimeSec;\n double temp = T0 * pow(T1 / T0, prog);\n\n int i = pickIndexTournament();\n Rect cur = rects[i];\n long long s0 = areaLL(cur);\n double p0 = p[i];\n\n double op = rng.nextDouble();\n\n if (op < 0.16) {\n // NEW: steal space from nearest blocker\n Rect ni, njr;\n int j;\n if (!tryStealMove(i, ni, j, njr)) continue;\n\n double pi1 = sat(r[i], areaLL(ni));\n double pj1 = sat(r[j], areaLL(njr));\n double delta = (pi1 + pj1) - (p[i] + p[j]);\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.nextDouble() < exp(delta / temp)) accept = true;\n\n if (accept) {\n rects[i] = ni; p[i] = pi1;\n rects[j] = njr; p[j] = pj1;\n }\n continue;\n }\n\n Rect cand = cur;\n\n if (op < 0.76) {\n // Resize one side (expand/shrink)\n int side = (int)(rng.nextU32() % 4); // 0:L 1:R 2:D 3:U\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n\n bool wantExpand = (s0 < r[i]) ? (rng.nextDouble() < 0.85) : (rng.nextDouble() < 0.18);\n\n if (wantExpand) {\n if (side == 1) { // right\n int lim = limitRight(i);\n if (lim <= cur.rx) continue;\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.lx + (int)needW;\n vector cands = {cur.rx + 1, ideal - 1, ideal, ideal + 1, lim};\n int rx2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n rx2 = max(rx2, cur.rx + 1);\n rx2 = min(rx2, lim);\n cand.rx = rx2;\n } else if (side == 0) { // left\n int lim = limitLeft(i);\n if (lim >= cur.lx) continue;\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.rx - (int)needW;\n vector cands = {cur.lx - 1, ideal - 1, ideal, ideal + 1, lim};\n int lx2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n lx2 = min(lx2, cur.lx - 1);\n lx2 = max(lx2, lim);\n lx2 = min(lx2, x[i]);\n cand.lx = lx2;\n } else if (side == 3) { // up\n int lim = limitUp(i);\n if (lim <= cur.ry) continue;\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ly + (int)needH;\n vector cands = {cur.ry + 1, ideal - 1, ideal, ideal + 1, lim};\n int ry2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n ry2 = max(ry2, cur.ry + 1);\n ry2 = min(ry2, lim);\n cand.ry = ry2;\n } else { // down\n int lim = limitDown(i);\n if (lim >= cur.ly) continue;\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ry - (int)needH;\n vector cands = {cur.ly - 1, ideal - 1, ideal, ideal + 1, lim};\n int ly2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n ly2 = min(ly2, cur.ly - 1);\n ly2 = max(ly2, lim);\n ly2 = min(ly2, y[i]);\n cand.ly = ly2;\n }\n } else {\n // shrink (always overlap-safe)\n if (side == 1) { // right shrink\n int minRx = x[i] + 1;\n int maxRx = cur.rx - 1;\n if (minRx > maxRx) continue;\n cand.rx = rng.nextInt(minRx, maxRx);\n } else if (side == 0) { // left shrink\n int minLx = cur.lx + 1;\n int maxLx = x[i];\n if (minLx > maxLx) continue;\n cand.lx = rng.nextInt(minLx, maxLx);\n } else if (side == 3) { // up shrink\n int minRy = y[i] + 1;\n int maxRy = cur.ry - 1;\n if (minRy > maxRy) continue;\n cand.ry = rng.nextInt(minRy, maxRy);\n } else { // down shrink\n int minLy = cur.ly + 1;\n int maxLy = y[i];\n if (minLy > maxLy) continue;\n cand.ly = rng.nextInt(minLy, maxLy);\n }\n }\n if (!inBounds(cand) || !containsPoint(i, cand)) continue;\n // expansions done by limits are safe; shrink safe. Still, for safety, validate occasionally:\n if (rng.nextDouble() < 0.03) {\n if (!validNoOverlapOne(i, cand)) continue;\n }\n } else if (op < 0.86) {\n // shrink-only fit\n Rect shr = fitInsideShrink(i, cur);\n if (shr.lx == cur.lx && shr.ly == cur.ly && shr.rx == cur.rx && shr.ry == cur.ry) continue;\n cand = shr;\n } else {\n // shift (needs overlap check)\n bool horizontal = (rng.nextDouble() < 0.5);\n if (horizontal) {\n int kmin = max(-cur.lx, (x[i] + 1) - cur.rx);\n int kmax = min(W - cur.rx, x[i] - cur.lx);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int lim = 320;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n int k;\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n cand.lx += k; cand.rx += k;\n } else {\n int kmin = max(-cur.ly, (y[i] + 1) - cur.ry);\n int kmax = min(H - cur.ry, y[i] - cur.ly);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int lim = 320;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n int k;\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n cand.ly += k; cand.ry += k;\n }\n if (!validNoOverlapOne(i, cand)) continue;\n }\n\n long long s1 = areaLL(cand);\n double p1 = sat(r[i], s1);\n double delta = p1 - p0;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.nextDouble() < exp(delta / temp)) accept = true;\n\n if (accept) {\n rects[i] = cand;\n p[i] = p1;\n }\n }\n }\n\n void finalTighten(int passes = 2) {\n for (int it = 0; it < passes; it++) {\n bool improved = false;\n for (int i = 0; i < n; i++) {\n Rect cur = rects[i];\n Rect cand = fitInsideShrink(i, cur);\n if (cand.lx == cur.lx && cand.ly == cur.ly && cand.rx == cur.rx && cand.ry == cur.ry) continue;\n double p1 = sat(r[i], areaLL(cand));\n if (p1 > p[i] + 1e-15) {\n rects[i] = cand;\n p[i] = p1;\n improved = true;\n }\n }\n if (!improved) break;\n }\n }\n\n void solve() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n start = clk::now();\n\n cin >> n;\n x.resize(n); y.resize(n); r.resize(n);\n for (int i = 0; i < n; i++) cin >> x[i] >> y[i] >> r[i];\n\n init();\n\n // Robust baseline\n greedyExpand(7);\n\n // SA with new \"steal\" move to fix boxed-in cases\n anneal(4.75);\n\n // After redistribution, expand again a little to fill freed space\n greedyExpand(2);\n\n // Safe overshoot tightening\n finalTighten(2);\n\n for (int i = 0; i < n; i++) {\n const Rect& rc = rects[i];\n cout << rc.lx << ' ' << rc.ly << ' ' << rc.rx << ' ' << rc.ry << \"\\n\";\n }\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nstatic const int N = 50;\nstatic const int V = N * N;\n\nstatic const int di[4] = {-1, 1, 0, 0};\nstatic const int dj[4] = {0, 0, -1, 1};\nstatic const char dc[4] = {'U','D','L','R'};\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n explicit XorShift(uint64_t seed = 0) { x ^= seed + 0x9e3779b97f4a7c15ULL; }\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Path {\n vector moves;\n long long score = 0;\n};\n\nint si, sj;\nint tgrid[N][N];\nint pgrid[N][N];\nint Mtiles = 0;\n\ninline bool inside(int i, int j) { return (unsigned)i < N && (unsigned)j < N; }\ninline int vid(int i, int j) { return i * N + j; }\n\nint tileOf[V];\nint valOf[V];\n\nstruct Neis {\n int to[4];\n int deg = 0;\n};\nNeis nei[V];\n\n// stamping used tiles\nvector usedStamp;\nint curStamp = 1;\ninline bool isUsedTile(int tile) { return usedStamp[tile] == curStamp; }\ninline void markTile(int tile) { usedStamp[tile] = curStamp; }\n\n// helpers\ninline int mobility1(int v, int extra1 = -1) {\n int tv = tileOf[v];\n int cnt = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1) continue;\n if (isUsedTile(tu)) continue;\n cnt++;\n }\n return cnt;\n}\ninline int mobility2(int v, int extra1, int extra2) {\n int tv = tileOf[v];\n int cnt = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1 || tu == extra2) continue;\n if (isUsedTile(tu)) continue;\n cnt++;\n }\n return cnt;\n}\ninline int bestNextValue(int v, int extra1 = -1) {\n int tv = tileOf[v];\n int best = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1) continue;\n if (isUsedTile(tu)) continue;\n best = max(best, valOf[u]);\n }\n return best;\n}\ninline int bestSecondStep(int v, int extraFirstTile) {\n int tv = tileOf[v];\n int best = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extraFirstTile) continue;\n if (isUsedTile(tu)) continue;\n int mob = mobility2(u, extraFirstTile, tu);\n int v2 = valOf[u] + 14 * mob;\n best = max(best, v2);\n }\n return best;\n}\n\ninline int dirFromTo(int a, int b) {\n int ai = a / N, aj = a % N;\n int bi = b / N, bj = b % N;\n if (bi == ai - 1 && bj == aj) return 0;\n if (bi == ai + 1 && bj == aj) return 1;\n if (bi == ai && bj == aj - 1) return 2;\n return 3;\n}\n\n// rollout from startV with rollback\nlong long rolloutGain(int startV, XorShift &rng, int depth, double epsRoll) {\n int cur = startV;\n long long gain = 0;\n int added[56];\n int asz = 0;\n\n for (int step = 0; step < depth; step++) {\n int ct = tileOf[cur];\n\n int candV[4];\n double H[4];\n int csz = 0;\n\n const auto &ng = nei[cur];\n for (int k = 0; k < ng.deg; k++) {\n int nxt = ng.to[k];\n int nt = tileOf[nxt];\n if (nt == ct) continue;\n if (isUsedTile(nt)) continue;\n\n int mob = mobility1(nxt, nt);\n double h = (double)valOf[nxt] + 18.0 * (double)mob + 0.25 * (double)bestNextValue(nxt, nt);\n candV[csz] = nxt;\n H[csz] = h;\n csz++;\n }\n if (csz == 0) break;\n\n int pick = 0;\n if (rng.nextDouble() < epsRoll) {\n pick = rng.nextInt(0, csz - 1);\n } else {\n for (int i = 1; i < csz; i++) if (H[i] > H[pick]) pick = i;\n }\n\n int nxt = candV[pick];\n int nt = tileOf[nxt];\n markTile(nt);\n added[asz++] = nt;\n\n cur = nxt;\n gain += valOf[cur];\n\n if (asz >= 56) break;\n }\n\n for (int i = 0; i < asz; i++) usedStamp[added[i]] = 0;\n return gain;\n}\n\nstruct BuildParams {\n // selection\n double epsMain = 0.18; // probability to use stochastic choice (softmax)\n double randTemp = 18.0; // softmax temperature (larger => more random)\n\n // rollout\n int depthEarly = 12, depthLate = 9;\n int triesEarly = 6, triesLate = 4;\n int earlySteps = 600; // within first this many moves, use \"early\" rollout strength\n double epsRoll = 0.20;\n double Wroll = 0.55;\n\n // rollout triggers\n int rolloutBudget = 440; // per build: candidate-evaluations allowed to run rollouts\n int closeCallThr = 35; // base-score difference threshold\n int closeTopK = 3; // run close-call rollouts among top-K candidates\n};\n\nPath buildFromPrefix(const vector& prefix, int cutLen, XorShift &rng, const BuildParams &par) {\n curStamp++;\n if (curStamp == INT_MAX) {\n fill(usedStamp.begin(), usedStamp.end(), 0);\n curStamp = 1;\n }\n\n int cur = vid(si, sj);\n long long score = valOf[cur];\n markTile(tileOf[cur]);\n\n Path res;\n res.moves.reserve(2600);\n\n // replay prefix safely\n for (int k = 0; k < cutLen; k++) {\n char c = prefix[k];\n int d = (c=='U'?0:(c=='D'?1:(c=='L'?2:3)));\n int ni = (cur / N) + di[d];\n int nj = (cur % N) + dj[d];\n if (!inside(ni,nj)) break;\n int nxt = vid(ni,nj);\n int ct = tileOf[cur], nt = tileOf[nxt];\n if (nt == ct) break;\n if (isUsedTile(nt)) break;\n markTile(nt);\n cur = nxt;\n score += valOf[cur];\n res.moves.push_back(c);\n }\n\n // base heuristic weights (unchanged)\n const int Wmob = 24;\n const double Wbest1 = 0.45;\n const double Wbest2 = 0.65;\n const int deadPenalty = 95;\n\n int rolloutUsed = 0;\n\n while (true) {\n int candV[4], candT[4], candMob[4];\n double baseH[4], H[4];\n int csz = 0;\n\n int ct = tileOf[cur];\n const auto &ng = nei[cur];\n\n double bestBase = -1e100;\n for (int k = 0; k < ng.deg; k++) {\n int nxt = ng.to[k];\n int nt = tileOf[nxt];\n if (nt == ct) continue;\n if (isUsedTile(nt)) continue;\n\n int mob1 = mobility1(nxt, nt);\n int b1 = bestNextValue(nxt, nt);\n int b2 = bestSecondStep(nxt, nt);\n\n double h = (double)valOf[nxt]\n + (double)Wmob * (double)mob1\n + Wbest1 * (double)b1\n + Wbest2 * (double)b2;\n if (mob1 == 0) h -= deadPenalty;\n\n candV[csz] = nxt;\n candT[csz] = nt;\n candMob[csz] = mob1;\n baseH[csz] = h;\n bestBase = max(bestBase, h);\n csz++;\n }\n if (csz == 0) break;\n\n for (int i = 0; i < csz; i++) H[i] = baseH[i];\n\n // order by baseH\n int ord[4] = {0,1,2,3};\n sort(ord, ord + csz, [&](int a, int b){ return baseH[a] > baseH[b]; });\n\n auto currentRollParams = [&]() -> pair {\n int step = (int)res.moves.size();\n if (step < par.earlySteps) return {par.depthEarly, par.triesEarly};\n return {par.depthLate, par.triesLate};\n };\n\n auto do_roll = [&](int idx, int depth, int tries) {\n int nxt = candV[idx];\n int nt = candT[idx];\n\n // temporarily mark entering tile\n markTile(nt);\n\n long long bestG = 0;\n for (int r = 0; r < tries; r++) {\n bestG = max(bestG, rolloutGain(nxt, rng, depth, par.epsRoll));\n }\n\n usedStamp[nt] = 0; // rollback\n H[idx] += par.Wroll * (double)bestG;\n };\n\n // Mandatory risk rollouts (mob <= 2), budgeted\n for (int i = 0; i < csz; i++) {\n if (candMob[i] <= 2 && rolloutUsed < par.rolloutBudget) {\n rolloutUsed++;\n auto [depth, tries] = currentRollParams();\n do_roll(i, depth, tries);\n }\n }\n\n // Close-call rollouts among top-K (even if mob > 2), budgeted\n int topK = min(par.closeTopK, csz);\n for (int r = 0; r < topK && rolloutUsed < par.rolloutBudget; r++) {\n int i = ord[r];\n if (candMob[i] <= 2) continue; // already handled above\n if (bestBase - baseH[i] > par.closeCallThr) continue;\n\n rolloutUsed++;\n auto [depth, tries] = currentRollParams();\n // lighter for close-call\n depth = max(7, depth - 3);\n tries = max(3, tries - 2);\n do_roll(i, depth, tries);\n }\n\n // Choose move: greedy or softmax (better than uniform random)\n int pick = 0;\n if (rng.nextDouble() < par.epsMain) {\n double mx = H[0];\n for (int i = 1; i < csz; i++) mx = max(mx, H[i]);\n double sum = 0.0;\n double w[4];\n double temp = max(1e-6, par.randTemp);\n for (int i = 0; i < csz; i++) {\n double e = exp((H[i] - mx) / temp);\n w[i] = e;\n sum += e;\n }\n double r = rng.nextDouble() * sum;\n pick = csz - 1;\n for (int i = 0; i < csz; i++) {\n r -= w[i];\n if (r <= 0) { pick = i; break; }\n }\n } else {\n for (int i = 1; i < csz; i++) if (H[i] > H[pick]) pick = i;\n }\n\n int nxt = candV[pick];\n int d = dirFromTo(cur, nxt);\n\n markTile(tileOf[nxt]);\n cur = nxt;\n score += valOf[cur];\n res.moves.push_back(dc[d]);\n\n if ((int)res.moves.size() >= 2600) break;\n }\n\n res.score = score;\n return res;\n}\n\n// small archive\nstruct Archive {\n int K;\n vector a; // sorted desc\n explicit Archive(int K_=7): K(K_) {}\n void add(Path &&p) {\n a.push_back(std::move(p));\n sort(a.begin(), a.end(), [](const Path& x, const Path& y){ return x.score > y.score; });\n if ((int)a.size() > K) a.resize(K);\n }\n const Path& best() const { return a.front(); }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> si >> sj;\n int mxT = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n cin >> tgrid[i][j];\n mxT = max(mxT, tgrid[i][j]);\n }\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> pgrid[i][j];\n Mtiles = mxT + 1;\n\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v = vid(i,j);\n tileOf[v] = tgrid[i][j];\n valOf[v] = pgrid[i][j];\n }\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v = vid(i,j);\n nei[v].deg = 0;\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d], nj = j + dj[d];\n if (!inside(ni,nj)) continue;\n nei[v].to[nei[v].deg++] = vid(ni,nj);\n }\n }\n\n usedStamp.assign(Mtiles, 0);\n XorShift rng(1234567);\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n };\n const double TL = 1.95;\n\n Archive arch(7);\n\n // Initial multi-start\n while (elapsed() < TL * 0.42) {\n BuildParams par;\n // mix: some quite greedy, some exploratory\n if (rng.nextDouble() < 0.40) {\n par.epsMain = 0.06; // mostly greedy\n par.randTemp = 10.0;\n } else {\n par.epsMain = 0.22;\n par.randTemp = 20.0;\n }\n par.depthEarly = 12; par.depthLate = 9;\n par.triesEarly = 6; par.triesLate = 4;\n par.earlySteps = 650;\n par.epsRoll = 0.20;\n par.Wroll = 0.55;\n par.rolloutBudget = 450;\n par.closeCallThr = 35;\n par.closeTopK = 3;\n\n auto cand = buildFromPrefix({}, 0, rng, par);\n arch.add(std::move(cand));\n }\n\n // Improvement loop\n while (elapsed() < TL) {\n double prog = min(1.0, elapsed() / TL);\n\n const Path* base = nullptr;\n double r = rng.nextDouble();\n if (r < 0.05) base = nullptr; // restart\n else if (r < 0.15 && (int)arch.a.size() >= 2) base = &arch.a[rng.nextInt(0, (int)arch.a.size() - 1)];\n else base = &arch.best();\n\n int cutLen = 0;\n vector empty;\n const vector *pref = ∅\n\n if (base) {\n pref = &base->moves;\n int L = (int)pref->size();\n if (L > 0) {\n if (rng.nextDouble() < 0.80) {\n int tail = min(L, 260);\n int back = rng.nextInt(0, tail);\n cutLen = L - back;\n } else cutLen = rng.nextInt(0, L);\n }\n }\n\n BuildParams par;\n par.epsMain = 0.18 * (1.0 - prog) + 0.02;\n par.randTemp = 18.0 * (1.0 - prog) + 10.0;\n\n par.depthEarly = 12; par.depthLate = 9;\n par.triesEarly = 6; par.triesLate = 4;\n par.earlySteps = 650;\n\n par.epsRoll = 0.20;\n par.Wroll = 0.55;\n\n par.rolloutBudget = (prog < 0.65 ? 450 : 360);\n par.closeCallThr = 35;\n par.closeTopK = 3;\n\n int TRIES = (prog < 0.6 ? 6 : 4);\n Path bestCand; bestCand.score = -1;\n for (int k = 0; k < TRIES; k++) {\n auto cand = buildFromPrefix(*pref, cutLen, rng, par);\n if (cand.score > bestCand.score) bestCand = std::move(cand);\n }\n arch.add(std::move(bestCand));\n }\n\n const Path &best = arch.best();\n string out;\n out.reserve(best.moves.size());\n for (char c : best.moves) out.push_back(c);\n cout << out << \"\\n\";\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nstatic constexpr int N = 30;\nstatic constexpr int V = N * N;\n\nstruct EdgeRef {\n bool horiz; // true: h[i][j] between (i,j)-(i,j+1), false: v[i][j] between (i,j)-(i+1,j)\n int i, j;\n};\n\nstatic inline int vid(int i, int j) { return i * N + j; }\nstatic inline pair vpos(int id){ return {id / N, id % N}; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Estimated weights\n static double h[N][N-1];\n static double v[N-1][N];\n static int hc[N][N-1];\n static int vc[N-1][N];\n\n for(int i=0;i unif01(0.0, 1.0);\n\n auto clamp_w = [](double x)->double{\n if (x < 100.0) return 100.0;\n if (x > 10000.0) return 10000.0;\n return x;\n };\n\n auto get_base_w = [&](int i1,int j1,int i2,int j2)->double{\n if (i1 == i2) {\n int i = i1;\n int j = min(j1, j2);\n return h[i][j];\n } else {\n int i = min(i1, i2);\n int j = j1;\n return v[i][j];\n }\n };\n\n auto add_smoothing = [&](double beta){\n // Horizontal smoothing per row\n for(int i=0;i> si >> sj >> ti >> tj)) return 0;\n int s = vid(si, sj), t = vid(ti, tj);\n\n // Exploration schedule (early queries explore more)\n // eps: max relative perturbation amplitude\n double eps = 0.0;\n if (k < 250) {\n double x = 1.0 - (double)k / 250.0; // from 1 -> 0\n eps = 0.30 * x; // up to 30% perturbation early\n }\n\n // Dijkstra\n static double dist[V];\n static int prevv[V];\n static char prevMove[V];\n\n const double INF = 1e100;\n for(int i=0;i;\n priority_queue, greater

> pq;\n dist[s] = 0;\n pq.push({0.0, s});\n\n auto relax = [&](int from, int to, char mv, double w){\n double nd = dist[from] + w;\n if (nd < dist[to]) {\n dist[to] = nd;\n prevv[to] = from;\n prevMove[to] = mv;\n pq.push({nd, to});\n }\n };\n\n while(!pq.empty()){\n auto [d,u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n if (u == t) break;\n auto [i,j] = vpos(u);\n\n // neighbor cost = base_w * (1 + noise) for exploration\n auto perturbed = [&](double base)->double{\n if (eps <= 0.0) return base;\n double r = (unif01(rng) * 2.0 - 1.0) * eps; // [-eps, eps]\n double w = base * (1.0 + r);\n if (w < 1.0) w = 1.0;\n return w;\n };\n\n if (i > 0) {\n double base = v[i-1][j];\n relax(u, vid(i-1,j), 'U', perturbed(base));\n }\n if (i+1 < N) {\n double base = v[i][j];\n relax(u, vid(i+1,j), 'D', perturbed(base));\n }\n if (j > 0) {\n double base = h[i][j-1];\n relax(u, vid(i,j-1), 'L', perturbed(base));\n }\n if (j+1 < N) {\n double base = h[i][j];\n relax(u, vid(i,j+1), 'R', perturbed(base));\n }\n }\n\n // Reconstruct path (also collect edges)\n string path;\n vector used_edges;\n if (prevv[t] == -1 && s != t) {\n // Should never happen on a connected grid; fallback to Manhattan.\n int ci=si, cj=sj;\n while (ci < ti) { path.push_back('D'); ci++; }\n while (ci > ti) { path.push_back('U'); ci--; }\n while (cj < tj) { path.push_back('R'); cj++; }\n while (cj > tj) { path.push_back('L'); cj--; }\n // Build used_edges from this path\n ci=si; cj=sj;\n for(char c: path){\n int ni=ci, nj=cj;\n if (c=='U') ni--;\n if (c=='D') ni++;\n if (c=='L') nj--;\n if (c=='R') nj++;\n if (ci == ni) {\n used_edges.push_back({true, ci, min(cj,nj)});\n } else {\n used_edges.push_back({false, min(ci,ni), cj});\n }\n ci=ni; cj=nj;\n }\n } else {\n // Walk back from t to s\n int cur = t;\n vector rev;\n vector> nodes_rev;\n nodes_rev.push_back(vpos(cur));\n while(cur != s){\n char mv = prevMove[cur];\n rev.push_back(mv);\n cur = prevv[cur];\n nodes_rev.push_back(vpos(cur));\n }\n reverse(rev.begin(), rev.end());\n path.assign(rev.begin(), rev.end());\n\n // nodes_rev is reversed along backtracking; rebuild forward nodes to extract edges\n // nodes_rev currently: [t, ..., s]; reverse:\n reverse(nodes_rev.begin(), nodes_rev.end()); // [s, ..., t]\n for (int idx = 0; idx+1 < (int)nodes_rev.size(); idx++){\n auto [i1,j1] = nodes_rev[idx];\n auto [i2,j2] = nodes_rev[idx+1];\n if (i1 == i2) used_edges.push_back({true, i1, min(j1,j2)});\n else used_edges.push_back({false, min(i1,i2), j1});\n }\n }\n\n cout << path << \"\\n\" << flush;\n\n long long obs;\n cin >> obs;\n\n // Update model\n double pred = 0.0;\n for (auto &e: used_edges){\n pred += e.horiz ? h[e.i][e.j] : v[e.i][e.j];\n }\n if (pred < 1.0) pred = 1.0;\n\n double r = (double)obs / pred;\n // cap extreme ratios (stability)\n r = max(0.2, min(5.0, r));\n double logr = log(r);\n\n // Multiplicative per-edge update with decaying learning rate\n const double base_lr = 0.45; // overall aggressiveness\n for (auto &e: used_edges){\n int cnt;\n double *wptr;\n if (e.horiz) { cnt = ++hc[e.i][e.j]; wptr = &h[e.i][e.j]; }\n else { cnt = ++vc[e.i][e.j]; wptr = &v[e.i][e.j]; }\n\n double lr = base_lr / sqrt((double)cnt + 2.0); // decays\n // w *= exp(lr * log(r))\n double nw = (*wptr) * exp(lr * logr);\n *wptr = clamp_w(nw);\n }\n\n // Periodic smoothing to exploit row/column base structure\n if ((k+1) % 25 == 0) {\n double beta = 0.10;\n if (k >= 300) beta = 0.06;\n if (k >= 700) beta = 0.04;\n add_smoothing(beta);\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20;\nstatic const int LMIN = 2;\nstatic const int LMAX = 12;\nstatic const int ALPHA = 9; // A-H + '.'\n\nstruct XorShift64 {\n uint64_t x;\n explicit XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n inline uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n inline int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n inline double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline uint8_t ch2code(char ch) { return ch == '.' ? 8 : (uint8_t)(ch - 'A'); }\nstatic inline char code2ch(uint8_t c) { return c == 8 ? '.' : (char)('A' + c); }\n\nusing u128 = unsigned __int128;\n\nstruct LineHash {\n array dig{};\n array pref{};\n const array* pow9 = nullptr;\n\n void rebuild_pref() {\n pref[0] = 0;\n for (int i = 0; i < 2 * N; i++) pref[i + 1] = pref[i] * (u128)ALPHA + (u128)dig[i];\n }\n inline uint64_t substr_val_exact(int start, int len) const {\n u128 v = pref[start + len] - pref[start] * (*pow9)[len];\n return (uint64_t)v; // len<=12 fits in u64\n }\n};\n\nstruct Delta {\n int dBase = 0;\n int dLen = 0;\n int dBonus = 0;\n long long dPair = 0;\n};\n\nstruct Solver {\n int M;\n vector inputS;\n\n int U;\n vector weight, slen;\n vector> sdig;\n unordered_map key2id;\n\n array pow9{};\n\n array, N> grid{};\n array rows, cols;\n\n vector>> affected;\n\n vector occ;\n long long baseSat = 0;\n long long lenSat = 0;\n long long occBonus = 0;\n\n // pair guidance\n long long wPair[ALPHA][ALPHA]{};\n long long totalPairs = 0;\n long long pairScore = 0;\n double pairScale = 1.0;\n\n XorShift64 rng;\n\n Solver(int M_, vector s_)\n : M(M_), inputS(std::move(s_)),\n rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count()) {\n\n pow9[0] = 1;\n for (int i = 1; i <= LMAX; i++) pow9[i] = pow9[i - 1] * (u128)ALPHA;\n for (int i = 0; i < N; i++) { rows[i].pow9 = &pow9; cols[i].pow9 = &pow9; }\n\n // bigram counts from reads (A..H only)\n for (const string &t : inputS) {\n for (int i = 0; i + 1 < (int)t.size(); i++) {\n uint8_t a = ch2code(t[i]);\n uint8_t b = ch2code(t[i+1]);\n wPair[a][b] += 1;\n totalPairs += 1;\n }\n }\n // typical dPair magnitude for 4 directed edges is about totalPairs/16\n pairScale = (double)totalPairs / 16.0 + 1.0;\n\n auto encode_key_exact = [&](const string& t) -> uint64_t {\n uint64_t v = 0;\n for (char ch : t) v = v * (uint64_t)ALPHA + (uint64_t)ch2code(ch); // A..H only\n return v * 16ull + (uint64_t)t.size();\n };\n\n key2id.reserve((size_t)M * 2);\n for (int i = 0; i < M; i++) {\n uint64_t key = encode_key_exact(inputS[i]);\n auto it = key2id.find(key);\n if (it == key2id.end()) {\n int id = (int)weight.size();\n key2id.emplace(key, id);\n weight.push_back(1);\n slen.push_back((int)inputS[i].size());\n vector d;\n d.reserve(inputS[i].size());\n for (char ch : inputS[i]) d.push_back(ch2code(ch));\n sdig.push_back(std::move(d));\n } else {\n weight[it->second]++;\n }\n }\n U = (int)weight.size();\n occ.assign(U, 0);\n\n affected.assign(N, {});\n for (int pos = 0; pos < N; pos++) {\n vector> v;\n v.reserve(77);\n for (int len = LMIN; len <= LMAX; len++) {\n for (int t = 0; t < len; t++) {\n int start = pos - t;\n start %= N;\n if (start < 0) start += N;\n v.emplace_back(start, len);\n }\n }\n affected[pos] = move(v);\n }\n }\n\n inline uint64_t make_key(uint64_t val, int len) const { return val * 16ull + (uint64_t)len; }\n inline int bonus_of(int x) const { return x >= 2 ? 2 : x; }\n\n inline void rebuild_all_lines_from_grid() {\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n rows[r].dig[c] = grid[r][c];\n rows[r].dig[c + N] = grid[r][c];\n }\n rows[r].rebuild_pref();\n }\n for (int c = 0; c < N; c++) {\n for (int r = 0; r < N; r++) {\n cols[c].dig[r] = grid[r][c];\n cols[c].dig[r + N] = grid[r][c];\n }\n cols[c].rebuild_pref();\n }\n }\n\n void recount_all_slow() {\n fill(occ.begin(), occ.end(), 0);\n baseSat = lenSat = occBonus = 0;\n\n auto add_key = [&](uint64_t key) {\n auto it = key2id.find(key);\n if (it == key2id.end()) return;\n int id = it->second;\n if (occ[id] == 0) {\n baseSat += weight[id];\n lenSat += slen[id];\n }\n occ[id]++;\n };\n\n for (int r = 0; r < N; r++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = rows[r].substr_val_exact(start, len);\n add_key(make_key(v, len));\n }\n }\n }\n for (int c = 0; c < N; c++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = cols[c].substr_val_exact(start, len);\n add_key(make_key(v, len));\n }\n }\n }\n for (int id = 0; id < U; id++) occBonus += bonus_of(occ[id]);\n\n // pairScore for right+down directed edges\n pairScore = 0;\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) {\n uint8_t a = grid[r][c];\n uint8_t b = grid[r][(c+1)%N];\n uint8_t d = grid[(r+1)%N][c];\n pairScore += wPair[a][b];\n pairScore += wPair[a][d];\n }\n }\n\n inline void adjust_occ(int id, int delta, Delta &D) {\n int before = occ[id];\n int after = before + delta;\n occ[id] = after;\n\n if (before == 0 && after > 0) {\n baseSat += weight[id]; D.dBase += weight[id];\n lenSat += slen[id]; D.dLen += slen[id];\n } else if (before > 0 && after == 0) {\n baseSat -= weight[id]; D.dBase -= weight[id];\n lenSat -= slen[id]; D.dLen -= slen[id];\n }\n\n int b0 = bonus_of(before), b1 = bonus_of(after);\n occBonus += (b1 - b0);\n D.dBonus += (b1 - b0);\n }\n\n inline void update_key_change(uint64_t oldKey, uint64_t newKey, Delta &D) {\n if (oldKey == newKey) return;\n auto itOld = key2id.find(oldKey);\n if (itOld != key2id.end()) adjust_occ(itOld->second, -1, D);\n auto itNew = key2id.find(newKey);\n if (itNew != key2id.end()) adjust_occ(itNew->second, +1, D);\n }\n\n inline void update_pair_delta_cell(int r, int c, uint8_t oldv, uint8_t newv, Delta &D) {\n int lc = (c - 1 + N) % N, rc = (c + 1) % N;\n int ur = (r - 1 + N) % N, dr = (r + 1) % N;\n uint8_t L = grid[r][lc];\n uint8_t R = grid[r][rc];\n uint8_t Uc = grid[ur][c];\n uint8_t Dn = grid[dr][c];\n\n long long delta = 0;\n delta += wPair[L][newv] - wPair[L][oldv];\n delta += wPair[newv][R] - wPair[oldv][R];\n delta += wPair[Uc][newv] - wPair[Uc][oldv];\n delta += wPair[newv][Dn] - wPair[oldv][Dn];\n\n pairScore += delta;\n D.dPair += delta;\n }\n\n Delta doChange(int r, int c, uint8_t newv) {\n uint8_t oldv = grid[r][c];\n if (oldv == newv) return {};\n\n Delta D;\n\n // pair delta uses neighbors from current grid\n update_pair_delta_cell(r, c, oldv, newv, D);\n\n // row affected\n const auto &affRow = affected[c];\n array oldKeysRow;\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first, len = affRow[i].second;\n oldKeysRow[i] = make_key(rows[r].substr_val_exact(start, len), len);\n }\n rows[r].dig[c] = newv;\n rows[r].dig[c + N] = newv;\n rows[r].rebuild_pref();\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first, len = affRow[i].second;\n uint64_t newKey = make_key(rows[r].substr_val_exact(start, len), len);\n update_key_change(oldKeysRow[i], newKey, D);\n }\n\n // col affected\n const auto &affCol = affected[r];\n array oldKeysCol;\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first, len = affCol[i].second;\n oldKeysCol[i] = make_key(cols[c].substr_val_exact(start, len), len);\n }\n cols[c].dig[r] = newv;\n cols[c].dig[r + N] = newv;\n cols[c].rebuild_pref();\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first, len = affCol[i].second;\n uint64_t newKey = make_key(cols[c].substr_val_exact(start, len), len);\n update_key_change(oldKeysCol[i], newKey, D);\n }\n\n grid[r][c] = newv;\n return D;\n }\n\n inline double evalDeltaF(const Delta &D, double lambda, double beta, double gamma) const {\n // gamma already normalized by pairScale\n return (double)D.dBase + lambda * (double)D.dLen + beta * (double)D.dBonus + gamma * (double)D.dPair;\n }\n\n int pick_unsatisfied_id() {\n for (int t = 0; t < 60; t++) {\n int id = rng.next_int(U);\n if (occ[id] == 0) return id;\n }\n for (int id = 0; id < U; id++) if (occ[id] == 0) return id;\n return -1;\n }\n\n struct ChangeRec { int r, c; uint8_t oldv; };\n\n pair> apply_embed_move(int id, int orient, int idx, int start) {\n Delta total;\n vector rec;\n rec.reserve(slen[id]);\n\n for (int t = 0; t < slen[id]; t++) {\n int r = (orient == 0) ? idx : (start + t) % N;\n int c = (orient == 0) ? (start + t) % N : idx;\n uint8_t nv = sdig[id][t];\n uint8_t ov = grid[r][c];\n if (ov == nv) continue;\n rec.push_back({r, c, ov});\n Delta d = doChange(r, c, nv);\n total.dBase += d.dBase;\n total.dLen += d.dLen;\n total.dBonus+= d.dBonus;\n total.dPair += d.dPair;\n }\n return {total, rec};\n }\n\n void revert_changes(const vector &rec) {\n for (int i = (int)rec.size() - 1; i >= 0; i--) doChange(rec[i].r, rec[i].c, rec[i].oldv);\n }\n\n tuple best_embed_placement(int id) {\n int bestMis = 1e9;\n int bestOrient = 0, bestIdx = 0, bestStart = 0;\n int L = slen[id];\n\n for (int orient = 0; orient < 2; orient++) {\n for (int idx = 0; idx < N; idx++) {\n for (int start = 0; start < N; start++) {\n int mis = 0;\n for (int t = 0; t < L; t++) {\n int r = (orient == 0) ? idx : (start + t) % N;\n int c = (orient == 0) ? (start + t) % N : idx;\n mis += (grid[r][c] != sdig[id][t]);\n if (mis >= bestMis) break;\n }\n if (mis < bestMis) {\n bestMis = mis;\n bestOrient = orient;\n bestIdx = idx;\n bestStart = start;\n if (bestMis == 0) return {bestMis, bestOrient, bestIdx, bestStart};\n }\n }\n }\n }\n return {bestMis, bestOrient, bestIdx, bestStart};\n }\n\n pair> apply_shift_move(int orient, int idx, int k) {\n array newvals;\n if (orient == 0) {\n for (int c = 0; c < N; c++) newvals[(c + k) % N] = grid[idx][c];\n } else {\n for (int r = 0; r < N; r++) newvals[(r + k) % N] = grid[r][idx];\n }\n\n Delta total;\n vector rec;\n rec.reserve(N);\n\n for (int t = 0; t < N; t++) {\n int r = (orient == 0) ? idx : t;\n int c = (orient == 0) ? t : idx;\n uint8_t nv = newvals[t];\n uint8_t ov = grid[r][c];\n if (ov == nv) continue;\n rec.push_back({r, c, ov});\n Delta d = doChange(r, c, nv);\n total.dBase += d.dBase;\n total.dLen += d.dLen;\n total.dBonus+= d.dBonus;\n total.dPair += d.dPair;\n }\n return {total, rec};\n }\n\n // swap two cells (r1,c1) and (r2,c2) via two changes; record revert info\n pair> apply_swap_move(int r1, int c1, int r2, int c2) {\n uint8_t a = grid[r1][c1], b = grid[r2][c2];\n if (a == b) return {Delta{}, {}};\n\n vector rec;\n rec.reserve(2);\n Delta total;\n\n rec.push_back({r1, c1, a});\n Delta d1 = doChange(r1, c1, b);\n total.dBase += d1.dBase; total.dLen += d1.dLen; total.dBonus += d1.dBonus; total.dPair += d1.dPair;\n\n rec.push_back({r2, c2, b});\n Delta d2 = doChange(r2, c2, a);\n total.dBase += d2.dBase; total.dLen += d2.dLen; total.dBonus += d2.dBonus; total.dPair += d2.dPair;\n\n return {total, rec};\n }\n\n array, N> run_sa(double duration_sec, long long &outBestBase) {\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) grid[r][c] = (uint8_t)rng.next_int(8);\n\n rebuild_all_lines_from_grid();\n recount_all_slow();\n\n auto bestGrid = grid;\n long long bestBase = baseSat;\n long long bestLen = lenSat;\n long long bestBonus= occBonus;\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n };\n\n const double Tstart = 6.0;\n const double Tend = 0.18;\n\n const double lambda0 = 0.08; // keep from best (3.30e9) version\n const double beta = 0.01;\n\n // Pair guidance: gentle, normalized, only early\n const double gamma0_raw = 1.0; // will be divided by pairScale\n\n while (true) {\n double e = elapsed();\n if (e >= duration_sec) break;\n double p = e / duration_sec;\n\n double T = Tstart * pow(Tend / Tstart, p);\n double lambda = lambda0 * (1.0 - p);\n\n // use pair guidance only in first 40%\n double gamma = 0.0;\n if (p < 0.40) {\n double q = (0.40 - p) / 0.40; // 1 -> 0\n gamma = (gamma0_raw * q) / pairScale;\n }\n\n // move probabilities (slightly less disruptive late)\n double pShift = 0.03 * (1.0 - p) + 0.004;\n double pEmbed = 0.22 * (1.0 - p) + 0.03;\n double pSwap = 0.03;\n\n double rm = rng.next_double();\n\n if (rm < pShift) {\n int orient = rng.next_int(2);\n int idx = rng.next_int(N);\n int k = 1 + rng.next_int(N - 1);\n\n auto [D, rec] = apply_shift_move(orient, idx, k);\n double dF = evalDeltaF(D, lambda, beta, gamma);\n bool accept = (dF >= 0) || (rng.next_double() < exp(dF / T));\n if (!accept) revert_changes(rec);\n }\n else if (rm < pShift + pEmbed) {\n int id = pick_unsatisfied_id();\n if (id == -1) continue;\n\n auto [mis, orient, idx, start] = best_embed_placement(id);\n auto [D, rec] = apply_embed_move(id, orient, idx, start);\n\n double dF = evalDeltaF(D, lambda, beta, gamma);\n bool accept = (dF >= 0) || (rng.next_double() < exp(dF / T));\n if (!accept) revert_changes(rec);\n }\n else if (rm < pShift + pEmbed + pSwap) {\n int r1 = rng.next_int(N), c1 = rng.next_int(N);\n int r2 = rng.next_int(N), c2 = rng.next_int(N);\n if (r1 == r2 && c1 == c2) continue;\n\n auto [D, rec] = apply_swap_move(r1, c1, r2, c2);\n if (rec.empty()) continue;\n double dF = evalDeltaF(D, lambda, beta, gamma);\n bool accept = (dF >= 0) || (rng.next_double() < exp(dF / T));\n if (!accept) revert_changes(rec);\n }\n else {\n int r = rng.next_int(N);\n int c = rng.next_int(N);\n uint8_t oldv = grid[r][c];\n uint8_t newv = (uint8_t)rng.next_int(8);\n if (newv == oldv) continue;\n\n Delta D = doChange(r, c, newv);\n double dF = evalDeltaF(D, lambda, beta, gamma);\n bool accept = (dF >= 0) || (rng.next_double() < exp(dF / T));\n if (!accept) doChange(r, c, oldv);\n }\n\n // Best is judged primarily by baseSat (actual score), then lenSat, then occBonus\n if (baseSat > bestBase ||\n (baseSat == bestBase && (lenSat > bestLen ||\n (lenSat == bestLen && occBonus > bestBonus)))) {\n bestBase = baseSat;\n bestLen = lenSat;\n bestBonus = occBonus;\n bestGrid = grid;\n }\n }\n\n outBestBase = bestBase;\n return bestGrid;\n }\n\n void dot_removal(double time_limit_sec, chrono::high_resolution_clock::time_point globalStart) {\n auto elapsed_global = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - globalStart).count();\n };\n if (baseSat != M) return;\n\n vector cells(N*N);\n iota(cells.begin(), cells.end(), 0);\n\n for (int rd = 0; rd < 10; rd++) {\n if (elapsed_global() >= time_limit_sec) break;\n for (int i = (int)cells.size() - 1; i > 0; i--) {\n int j = rng.next_int(i + 1);\n swap(cells[i], cells[j]);\n }\n for (int idx : cells) {\n if (elapsed_global() >= time_limit_sec) break;\n int r = idx / N, c = idx % N;\n uint8_t oldv = grid[r][c];\n if (oldv == 8) continue;\n doChange(r, c, 8);\n if (baseSat != M) doChange(r, c, oldv);\n }\n }\n }\n\n array, N> solve() {\n auto globalStart = chrono::high_resolution_clock::now();\n const double TL = 2.95;\n\n // The 3.30e9 version did well with 2 restarts; keep 2 but allow a bit more SA time.\n const int RESTARTS = 2;\n const double SA_TIME = 2.75;\n const double per = SA_TIME / RESTARTS;\n\n array, N> bestGrid{};\n long long bestBase = -1;\n\n for (int t = 0; t < RESTARTS; t++) {\n long long localBest = 0;\n auto g = run_sa(per, localBest);\n if (localBest > bestBase) {\n bestBase = localBest;\n bestGrid = g;\n if (bestBase == M) break;\n }\n double eg = chrono::duration(chrono::high_resolution_clock::now() - globalStart).count();\n if (eg >= TL - 0.20) break;\n }\n\n grid = bestGrid;\n rebuild_all_lines_from_grid();\n recount_all_slow();\n dot_removal(TL, globalStart);\n\n return grid;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, M;\n cin >> Nin >> M;\n vector s(M);\n for (int i = 0; i < M; i++) cin >> s[i];\n\n Solver solver(M, std::move(s));\n auto ans = solver.solve();\n\n for (int r = 0; r < N; r++) {\n string line;\n line.reserve(N);\n for (int c = 0; c < N; c++) line.push_back(code2ch(ans[r][c]));\n cout << line << \"\\n\";\n }\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstatic const int INF = 1e9;\nstatic const long long INFLL = (1LL<<60);\n\nstruct HopcroftKarp {\n int nL, nR;\n vector> adj;\n vector dist;\n vector pairU, pairV;\n HopcroftKarp(int nL=0,int nR=0){ init(nL,nR); }\n void init(int _nL,int _nR){\n nL=_nL; nR=_nR;\n adj.assign(nL,{});\n dist.assign(nL,0);\n pairU.assign(nL,-1);\n pairV.assign(nR,-1);\n }\n bool bfs(){\n queue q;\n for(int u=0;u> G;\n vector level, it;\n Dinic(int n=0){ init(n); }\n void init(int n){\n N=n;\n G.assign(N,{});\n level.assign(N,0);\n it.assign(N,0);\n }\n void add_edge(int fr,int to,long long cap){\n Edge a{to,(int)G[to].size(),cap};\n Edge b{fr,(int)G[fr].size(),0};\n G[fr].push_back(a);\n G[to].push_back(b);\n }\n bool bfs(int s,int t){\n fill(level.begin(), level.end(), -1);\n queue q;\n level[s]=0;\n q.push(s);\n while(!q.empty()){\n int v=q.front(); q.pop();\n for(const auto& e: G[v]){\n if(e.cap>0 && level[e.to]<0){\n level[e.to]=level[v]+1;\n q.push(e.to);\n }\n }\n }\n return level[t]>=0;\n }\n long long dfs(int v,int t,long long f){\n if(v==t) return f;\n for(int &i=it[v]; i<(int)G[v].size(); i++){\n Edge &e=G[v][i];\n if(e.cap<=0 || level[e.to]!=level[v]+1) continue;\n long long ret=dfs(e.to,t,min(f,e.cap));\n if(ret>0){\n e.cap-=ret;\n G[e.to][e.rev].cap+=ret;\n return ret;\n }\n }\n return 0;\n }\n long long maxflow(int s,int t){\n long long flow=0;\n while(bfs(s,t)){\n fill(it.begin(), it.end(), 0);\n while(true){\n long long f=dfs(s,t,INFLL);\n if(!f) break;\n flow+=f;\n }\n }\n return flow;\n }\n vector mincut_reachable(int s){\n vector vis(N,0);\n queue q;\n vis[s]=1; q.push(s);\n while(!q.empty()){\n int v=q.front(); q.pop();\n for(const auto& e: G[v]){\n if(e.cap>0 && !vis[e.to]){\n vis[e.to]=1;\n q.push(e.to);\n }\n }\n }\n return vis;\n }\n};\n\nstruct DijkstraFull {\n vector dist;\n vector prev;\n vector prevDir;\n};\n\nstruct TargetsInfo {\n vector cells;\n vector needRow, needCol;\n};\n\nstruct Candidate {\n long long quickDirCost = INFLL;\n TargetsInfo tinfo;\n vector nodes; // start + unique targets\n};\n\nstruct FinalSol {\n long long dirCost = INFLL;\n vector nodes;\n vector tour;\n vector> prevM;\n vector> prevDirM;\n};\n\nstruct Solver {\n int N, si, sj;\n vector g;\n int startId;\n vector cellCost;\n\n // segments\n vector rowSeg, colSeg;\n int R=0, C=0;\n vector> rowCells, colCells;\n vector> adjV, adjCell;\n\n // precomputed moves for road graph\n vector> to4;\n vector> dir4;\n vector deg;\n\n inline int id(int i,int j) const { return i*N+j; }\n inline int ri(int v) const { return v/N; }\n inline int rj(int v) const { return v%N; }\n inline bool isRoad(int v) const { return g[ri(v)][rj(v)]!='#'; }\n\n void build_moves(){\n int V=N*N;\n to4.assign(V, array{-1,-1,-1,-1});\n dir4.assign(V, array{'U','D','L','R'});\n deg.assign(V,0);\n static const int di[4]={-1,1,0,0};\n static const int dj[4]={0,0,-1,1};\n static const char mv[4]={'U','D','L','R'};\n for(int u=0;u=N||vj<0||vj>=N) continue;\n int v=id(vi,vj);\n if(!isRoad(v)) continue;\n to4[u][d]=v;\n dir4[u][d]=mv[k];\n d++;\n }\n deg[u]=d;\n }\n }\n\n vector dijkstra_dist_only(int src, const vector* isTarget=nullptr, int targetCount=0) const {\n int V=N*N;\n vector dist(V, INF);\n priority_queue, vector>, greater>> pq;\n dist[src]=0;\n pq.push({0,src});\n int rem=targetCount;\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=dist[u]) continue;\n if(isTarget && (*isTarget)[u]){\n rem--;\n if(rem<=0) break;\n }\n for(int t=0;t, vector>, greater>> pq;\n res.dist[src]=0;\n pq.push({0,src});\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=res.dist[u]) continue;\n for(int t=0;t& prev,const vector& prevDir) const {\n if(src==dst) return \"\";\n string rev;\n int cur=dst;\n while(cur!=src){\n int p=prev[cur];\n if(p==-1) return \"\";\n rev.push_back(prevDir[cur]);\n cur=p;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n }\n\n void build_segments(){\n int V=N*N;\n rowSeg.assign(V,-1);\n colSeg.assign(V,-1);\n\n R=0;\n for(int i=0;i, vector> min_weight_vertex_cover(const vector& wL, const vector& wR) {\n int S=0;\n int baseL=1;\n int baseR=baseL+R;\n int T=baseR+C;\n Dinic din(T+1);\n\n long long sumW=0;\n for(long long x: wL) sumW += x;\n for(long long x: wR) sumW += x;\n long long INF_CAP = sumW + 1;\n\n for(int u=0;u coverL(R,0), coverR(C,0);\n for(int u=0;u& coverL_in, const vector& coverR_in,\n const vector& distStart, uint32_t seed) {\n mt19937 rng(seed);\n\n vector needL = coverL_in;\n vector needR = coverR_in;\n\n // start already activated\n int sRow=rowSeg[startId], sCol=colSeg[startId];\n if(sRow>=0) needL[sRow]=0;\n if(sCol>=0) needR[sCol]=0;\n\n vector reqL, reqR;\n vector mapL(R,-1), mapR(C,-1);\n for(int u=0;u> edgeCell(nL);\n for(int i=0;i ord(adjV[u].size());\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng);\n for(int idx: ord){\n int v=adjV[u][idx];\n int j=mapR[v];\n if(j==-1) continue;\n hk.adj[i].push_back(j);\n edgeCell[i].push_back(adjCell[u][idx]);\n }\n }\n hk.max_matching();\n\n vector doneL(R,0), doneR(C,0);\n vector picked(N*N,0);\n vector targets;\n\n auto pick_cell=[&](int cell){\n if(cell<0) return;\n if(!picked[cell]){\n picked[cell]=1;\n targets.push_back(cell);\n }\n };\n\n for(int i=0;i>& vec, int K)->int{\n if(vec.empty()) return -1;\n int kk=min(K,(int)vec.size());\n nth_element(vec.begin(), vec.begin()+kk, vec.end());\n vec.resize(kk);\n sort(vec.begin(), vec.end());\n int choose = uniform_int_distribution(0, min(kk-1,2))(rng);\n return vec[choose].second;\n };\n\n auto best_cell_for_row = [&](int u)->int{\n vector> cand;\n cand.reserve(rowCells[u].size());\n for(int cell: rowCells[u]){\n int v=colSeg[cell];\n long long key = (long long)distStart[cell] + cellCost[cell];\n if(needR[v] && !doneR[v]) key -= 1000000;\n key += (rng()%13);\n cand.push_back({key, cell});\n }\n return pick_top(cand, 8);\n };\n auto best_cell_for_col = [&](int v)->int{\n vector> cand;\n cand.reserve(colCells[v].size());\n for(int cell: colCells[v]){\n int u=rowSeg[cell];\n long long key = (long long)distStart[cell] + cellCost[cell];\n if(needL[u] && !doneL[u]) key -= 1000000;\n key += (rng()%13);\n cand.push_back({key, cell});\n }\n return pick_top(cand, 8);\n };\n\n for(int u=0;u cntL(R,0), cntR(C,0);\n for(int cell: targets){\n int u=rowSeg[cell], v=colSeg[cell];\n if(needL[u]) cntL[u]++;\n if(needR[v]) cntR[v]++;\n }\n vector order=targets;\n shuffle(order.begin(), order.end(), rng);\n vector removed(N*N,0);\n for(int cell: order){\n int u=rowSeg[cell], v=colSeg[cell];\n bool okU = (!needL[u]) || (cntL[u] >= 2);\n bool okV = (!needR[v]) || (cntR[v] >= 2);\n if(okU && okV){\n removed[cell]=1;\n if(needL[u]) cntL[u]--;\n if(needR[v]) cntR[v]--;\n }\n }\n vector pruned;\n pruned.reserve(targets.size());\n for(int cell: targets) if(!removed[cell]) pruned.push_back(cell);\n\n TargetsInfo info;\n info.cells = std::move(pruned);\n info.needRow = std::move(needL);\n info.needCol = std::move(needR);\n return info;\n }\n\n // Compute distM between nodes using early-stop dijkstra\n vector> compute_distM_only(const vector& nodes) const {\n int M=(int)nodes.size();\n vector> distM(M, vector(M, INF));\n vector isTarget(N*N,0);\n for(int v: nodes) isTarget[v]=1;\n for(int s=0;s& nodes,\n vector>& distM,\n vector>& distAll,\n vector>& prevM,\n vector>& prevDirM) const {\n int M=(int)nodes.size();\n int V=N*N;\n distM.assign(M, vector(M, INF));\n distAll.assign(M, vector(V, INF));\n prevM.assign(M, vector(V, -1));\n prevDirM.assign(M, vector(V, 0));\n for(int s=0;s> build_W(const vector>& distM, const vector& nodes) const {\n int M=(int)nodes.size();\n vector> W(M, vector(M,0));\n for(int i=0;i& tour, const vector>& distM) const {\n int M=(int)tour.size();\n long long s=0;\n for(int i=0;i& tour, const vector>& W) const {\n int M=(int)tour.size();\n long long s=0;\n for(int i=0;i> build_candidates(const vector>& W, int K) const {\n int M=(int)W.size();\n vector> cand(M);\n for(int i=0;i> tmp;\n tmp.reserve(M-1);\n for(int j=0;j& tour, vector& pos,\n const vector>& W,\n const vector>& cand) const {\n int M=(int)tour.size();\n for(int i=1;ijj) swap(ii,jj);\n if(jj-ii<1) continue;\n int x=tour[ii-1], y=tour[ii];\n int u=tour[jj], v=tour[(jj+1)%M];\n long long delta = (long long)W[x][u] + W[y][v] - W[x][y] - W[u][v];\n if(delta < 0){\n reverse(tour.begin()+ii, tour.begin()+jj+1);\n for(int k=ii;k<=jj;k++) pos[tour[k]]=k;\n return true;\n }\n }\n }\n return false;\n }\n\n void double_bridge(vector& tour, vector& pos, mt19937& rng) const {\n int M=(int)tour.size();\n if(M<10) return;\n uniform_int_distribution dist(1, M-1);\n int a=dist(rng), b=dist(rng), c=dist(rng), d=dist(rng);\n vector cuts={a,b,c,d};\n sort(cuts.begin(), cuts.end());\n a=cuts[0]; b=cuts[1]; c=cuts[2]; d=cuts[3];\n if(a<2 || b-a<2 || c-b<2 || d-c<2) return;\n\n vector nt; nt.reserve(M);\n nt.push_back(tour[0]);\n auto app=[&](int l,int r){ for(int i=l;i<=r;i++) nt.push_back(tour[i]); };\n app(1, a-1);\n app(b, c-1);\n app(a, b-1);\n app(c, d-1);\n app(d, M-1);\n tour.swap(nt);\n for(int i=0;i build_initial_cycle_cheapest_insertion(const vector>& W, mt19937& rng) const {\n int M=(int)W.size();\n vector tour; tour.reserve(M);\n tour.push_back(0);\n vector rem;\n for(int i=1;i optimize_cycle_ILS_2opt(vector tour, const vector>& W, double timeLimitSec) const {\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n auto t0=chrono::high_resolution_clock::now();\n auto elapsed=[&](){ return chrono::duration(chrono::high_resolution_clock::now()-t0).count(); };\n\n int M=(int)tour.size();\n vector pos(M,-1);\n for(int i=0;i bestTour=tour;\n\n int it=0;\n while(elapsed()& nodes,\n const vector& tour,\n vector>& distM,\n vector>& distAll,\n vector>& prevM,\n vector>& prevDirM,\n const vector& needRow,\n const vector& needCol,\n double timeLimitSec) const {\n int M=(int)nodes.size();\n int V=N*N;\n if(M<=2) return;\n\n vector usedCell(V,0);\n for(int i=0;i cntRseg(R,0), cntCseg(C,0);\n for(int i=1;i posInTour(M,-1);\n for(int i=0;i pickNode(1, M-1);\n\n auto t0=chrono::high_resolution_clock::now();\n auto elapsed=[&](){ return chrono::duration(chrono::high_resolution_clock::now()-t0).count(); };\n\n while(elapsed()long long{\n int pi=ri(nodes[p]), pj=rj(nodes[p]);\n int ni=ri(nodes[n]), nj=rj(nodes[n]);\n int ci=ri(candCell), cj=rj(candCell);\n long long h = llabs(ci-pi)+llabs(cj-pj) + llabs(ci-ni)+llabs(cj-nj);\n return h*10 + cellCost[candCell]*3;\n };\n\n int bestCand=-1;\n long long bestHeu=scoreHeu(curCell);\n\n {\n bool colLocked = needCol[curCS] && (cntCseg[curCS]==1);\n for(int candCell: rowCells[curRS]){\n if(candCell==curCell) continue;\n if(usedCell[candCell]) continue;\n int candCS=colSeg[candCell];\n if(colLocked && candCS!=curCS) continue;\n long long h=scoreHeu(candCell);\n if(h=INF/2) continue;\n if(newCost>=oldCost) continue;\n\n int newRS=rowSeg[bestCand], newCS=colSeg[bestCand];\n if(newRS!=curRS && needRow[curRS] && cntRseg[curRS]==1) continue;\n if(newCS!=curCS && needCol[curCS] && cntCseg[curCS]==1) continue;\n\n usedCell[curCell]=0;\n usedCell[bestCand]=1;\n\n if(needRow[curRS]) cntRseg[curRS]--;\n if(needCol[curCS]) cntCseg[curCS]--;\n if(needRow[newRS]) cntRseg[newRS]++;\n if(needCol[newCS]) cntCseg[newCS]++;\n\n nodes[x]=bestCand;\n\n distAll[x] = std::move(candRes.dist);\n prevM[x] = std::move(candRes.prev);\n prevDirM[x] = std::move(candRes.prevDir);\n\n for(int j=0;j& distStart, long long lambda, uint32_t seed) {\n // compute base weights from min distStart in each segment\n vector minRow(R, INFLL), minCol(C, INFLL);\n for(int u=0;u(minRow[u], distStart[cell]);\n if(minRow[u]>=INF/2) minRow[u]=1000000;\n }\n for(int v=0;v(minCol[v], distStart[cell]);\n if(minCol[v]>=INF/2) minCol[v]=1000000;\n }\n\n mt19937 rng(seed);\n vector wL(R), wR(C);\n for(int u=0;u=0) wL[sRow]=0;\n if(sCol>=0) wR[sCol]=0;\n\n auto [coverL, coverR] = min_weight_vertex_cover(wL, wR);\n TargetsInfo tinfo = build_targets_from_cover(coverL, coverR, distStart, seed ^ 0xA341316C);\n\n Candidate cand;\n cand.tinfo = std::move(tinfo);\n\n cand.nodes.clear();\n cand.nodes.reserve(1 + cand.tinfo.cells.size());\n cand.nodes.push_back(startId);\n {\n vector used(N*N,0);\n used[startId]=1;\n for(int c: cand.tinfo.cells){\n if(!used[c]){\n used[c]=1;\n cand.nodes.push_back(c);\n }\n }\n }\n\n auto distM = compute_distM_only(cand.nodes);\n auto W = build_W(distM, cand.nodes);\n\n mt19937 rng2(seed ^ 0x9e3779b9u);\n int M=(int)cand.nodes.size();\n vector bestTour;\n long long bestW=INFLL;\n int trials = (M<=90? 4 : 3);\n for(int t=0;t pos(M,-1);\n for(int i=0;i(chrono::high_resolution_clock::now()-t0).count(); };\n\n FinalSol fs;\n fs.nodes = cand.nodes;\n\n vector> distM, distAll, prevM;\n vector> prevDirM;\n compute_all_full(fs.nodes, distM, distAll, prevM, prevDirM);\n\n auto W = build_W(distM, fs.nodes);\n int M=(int)fs.nodes.size();\n\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n vector tour;\n long long bestW=INFLL;\n int trials = (M<=90? 6 : 4);\n for(int t=0;t 0.10) tour = optimize_cycle_ILS_2opt(tour, W, tOpt2);\n\n fs.dirCost = directed_cycle_cost(tour, distM);\n fs.tour = std::move(tour);\n fs.prevM = std::move(prevM);\n fs.prevDirM = std::move(prevDirM);\n return fs;\n }\n\n void solve() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> si >> sj;\n g.resize(N);\n for(int i=0;i> g[i];\n\n startId=id(si,sj);\n cellCost.assign(N*N,0);\n for(int i=0;i(chrono::high_resolution_clock::now()-globalStart).count();\n };\n\n vector distStart = dijkstra_dist_only(startId);\n\n // Candidate generation: lambda sweep (including huge lambda ~= min cardinality)\n vector lambdas = {\n 200, 400, 800, 1600, 3200, 50000\n };\n int Kcands = (int)lambdas.size();\n\n uint32_t baseSeed = (uint32_t)(987654321u + (uint32_t)N*97u + (uint32_t)si*131u + (uint32_t)sj*911u);\n\n vector cands;\n cands.reserve(Kcands);\n for(int k=0;k\nusing namespace std;\n\nstruct FastRand {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int mod) { return (int)(next_u64() % (uint64_t)mod); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n // Box-Muller for standard normal\n double next_normal() {\n double u1 = max(1e-12, next_double());\n double u2 = next_double();\n return sqrt(-2.0 * log(u1)) * cos(2.0 * M_PI * u2);\n }\n};\n\n// Hungarian algorithm for rectangular min-cost assignment with m>=n.\n// cost is n x m.\nstatic vector hungarian_min_cost(const vector>& cost) {\n int n = (int)cost.size();\n int m = (int)cost[0].size();\n const long long INF = (1LL<<62);\n\n vector u(n+1, 0), v(m+1, 0);\n vector p(m+1, 0), way(m+1, 0);\n\n for (int i = 1; i <= n; i++) {\n p[0] = i;\n int j0 = 0;\n vector minv(m+1, INF);\n vector used(m+1, false);\n do {\n used[j0] = true;\n int i0 = p[j0];\n long long delta = INF;\n int j1 = 0;\n for (int j = 1; j <= m; j++) if (!used[j]) {\n long long cur = cost[i0-1][j-1] - u[i0] - v[j];\n if (cur < minv[j]) minv[j] = cur, way[j] = j0;\n if (minv[j] < delta) delta = minv[j], j1 = j;\n }\n for (int j = 0; j <= m; j++) {\n if (used[j]) u[p[j]] += delta, v[j] -= delta;\n else minv[j] -= delta;\n }\n j0 = j1;\n } while (p[j0] != 0);\n\n // augmenting\n do {\n int j1 = way[j0];\n p[j0] = p[j1];\n j0 = j1;\n } while (j0);\n }\n\n // assignment: for each row i, find column j with p[j]=i\n vector ans(n, -1);\n for (int j = 1; j <= m; j++) {\n if (p[j] >= 1 && p[j] <= n) ans[p[j]-1] = j-1;\n }\n return ans;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector> d(N, vector(K));\n vector sumD(N, 0);\n vector meanD(K, 0.0);\n\n for (int i = 0; i < N; i++) {\n long long s = 0;\n for (int k = 0; k < K; k++) {\n cin >> d[i][k];\n s += d[i][k];\n meanD[k] += d[i][k];\n }\n sumD[i] = (int)s;\n }\n for (int k = 0; k < K; k++) meanD[k] /= max(1, N);\n\n vector> out(N);\n vector indeg0(N, 0);\n for (int e = 0; e < R; e++) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg0[v]++;\n }\n\n // critical path length (in tasks)\n vector crit(N, 1);\n for (int i = N - 1; i >= 0; i--) {\n int best = 1;\n for (int v : out[i]) best = max(best, 1 + crit[v]);\n crit[i] = best;\n }\n\n vector outdeg(N);\n for (int i = 0; i < N; i++) outdeg[i] = (int)out[i].size();\n\n double avgSumD = 0.0;\n for (int i = 0; i < N; i++) avgSumD += sumD[i];\n avgSumD /= max(1, N);\n\n vector indeg = indeg0;\n vector task_state(N, 0); // 0:not started, 1:running, 2:done\n\n vector member_task(M, -1);\n vector start_day(M, -1);\n vector done_cnt(M, 0);\n\n FastRand rng;\n\n // K-dim skill estimate\n vector> s_est(M, vector(K, 0.0));\n for (int j = 0; j < M; j++) {\n // Random direction ~ |N(0,1)|, magnitude ~ 40 (mid of 20..60)\n vector v(K);\n double norm2 = 0.0;\n for (int k = 0; k < K; k++) {\n double x = fabs(rng.next_normal());\n v[k] = x;\n norm2 += x * x;\n }\n double mag = 40.0;\n double scale = (norm2 > 0) ? (mag / sqrt(norm2)) : 0.0;\n for (int k = 0; k < K; k++) {\n // small prior blend toward meanD to avoid pathological starts\n double initv = v[k] * scale;\n s_est[j][k] = 0.7 * initv + 0.3 * (meanD[k] * 2.0);\n if (s_est[j][k] < 0) s_est[j][k] = 0;\n }\n }\n\n auto w_pred = [&](int i, int j) -> double {\n double w = 0.0;\n const auto& sj = s_est[j];\n for (int k = 0; k < K; k++) {\n double diff = (double)d[i][k] - sj[k];\n if (diff > 0) w += diff;\n }\n return w;\n };\n\n auto t_pred = [&](int i, int j) -> double {\n double w = w_pred(i, j);\n if (w <= 0.0) return 1.0;\n // small bias improves robustness against r in [-3,3]\n return max(1.0, w + 0.5);\n };\n\n auto update_member = [&](int j, int i, int t_obs) {\n // target w roughly equals observed days for t>1, else 0\n double target_w = (t_obs <= 1) ? 0.0 : (double)t_obs;\n\n double w = w_pred(i, j);\n double err = w - target_w; // want err -> 0\n\n // Learning rate decays with number of observations\n double lr = 0.12 / sqrt(1.0 + done_cnt[j]); // tuned small & stable\n\n // Gradient: f(s)=sum max(0, d-s), df/ds_k = -1 if active else 0\n // Loss = (f-target)^2 => grad = 2*(f-target)*df/ds\n // Update s_k -= lr * grad => s_k += 2*lr*err for active dims.\n double delta = 2.0 * lr * err;\n\n // cap to avoid huge jumps on noisy tasks\n delta = max(-8.0, min(8.0, delta));\n\n auto &sj = s_est[j];\n for (int k = 0; k < K; k++) {\n if ((double)d[i][k] > sj[k]) {\n sj[k] += delta;\n if (sj[k] < 0) sj[k] = 0;\n }\n }\n\n // mild regularization toward a prior to prevent collapse\n for (int k = 0; k < K; k++) {\n double prior = meanD[k] * 2.0;\n sj[k] = 0.995 * sj[k] + 0.005 * prior;\n if (sj[k] < 0) sj[k] = 0;\n }\n\n done_cnt[j]++;\n };\n\n int day = 0;\n while (true) {\n day++;\n\n vector free_members;\n free_members.reserve(M);\n for (int j = 0; j < M; j++) if (member_task[j] == -1) free_members.push_back(j);\n\n vector avail;\n avail.reserve(N);\n for (int i = 0; i < N; i++) if (task_state[i] == 0 && indeg[i] == 0) avail.push_back(i);\n\n // Prepare candidate tasks:\n // (1) top by criticality\n sort(avail.begin(), avail.end(), [&](int a, int b) {\n if (crit[a] != crit[b]) return crit[a] > crit[b];\n if (outdeg[a] != outdeg[b]) return outdeg[a] > outdeg[b];\n if (sumD[a] != sumD[b]) return sumD[a] > sumD[b];\n return a < b;\n });\n\n unordered_set candset;\n candset.reserve(800);\n int TOP = min(160, (int)avail.size());\n for (int idx = 0; idx < TOP; idx++) candset.insert(avail[idx]);\n\n // (2) for each free member, add tasks predicted fast (and somewhat critical)\n int PER = 24;\n for (int j : free_members) {\n vector> best;\n best.reserve(avail.size());\n for (int i : avail) {\n double tp = t_pred(i, j);\n // smaller is better; incorporate criticality as a tie-breaker\n double key = tp - 0.15 * (double)crit[i] - 0.01 * (double)outdeg[i];\n best.push_back({key, i});\n }\n if ((int)best.size() > PER) {\n nth_element(best.begin(), best.begin() + PER, best.end());\n best.resize(PER);\n }\n for (auto &p : best) candset.insert(p.second);\n }\n\n vector cands;\n cands.reserve(candset.size());\n for (int i : candset) cands.push_back(i);\n\n // stable order for columns\n sort(cands.begin(), cands.end(), [&](int a, int b) {\n if (crit[a] != crit[b]) return crit[a] > crit[b];\n if (outdeg[a] != outdeg[b]) return outdeg[a] > outdeg[b];\n if (sumD[a] != sumD[b]) return sumD[a] > sumD[b];\n return a < b;\n });\n\n vector> assigns; // (member, task) 0-based\n assigns.reserve(free_members.size());\n\n if (!free_members.empty() && !cands.empty()) {\n int F = (int)free_members.size();\n int C = (int)cands.size();\n int W = max(F, C); // columns after padding\n const long long BIG = (long long)4e12;\n\n vector> cost(F, vector(W, BIG));\n\n // Build costs: minimize -score\n // score = A*crit + B*outdeg - D*t_pred + small difficulty term\n for (int r = 0; r < F; r++) {\n int j = free_members[r];\n bool explore = (done_cnt[j] < 4);\n for (int c = 0; c < C; c++) {\n int i = cands[c];\n double tp = t_pred(i, j);\n\n double sc = 120.0 * (double)crit[i]\n + 6.0 * (double)outdeg[i]\n - 1.0 * tp\n + 0.002 * (double)sumD[i];\n\n if (explore) {\n // Early stage: prefer moderate tasks to learn faster and avoid huge stalls\n sc -= 0.03 * fabs((double)sumD[i] - avgSumD);\n }\n\n long long ssc = (long long)llround(sc * 1000.0);\n cost[r][c] = -ssc;\n }\n }\n\n // If C < F, remaining columns are dummy with BIG cost (forces assignment only if no tasks)\n // If C > F, extra columns exist but that's fine.\n\n vector assign_col = hungarian_min_cost(cost);\n\n vector used_task(N, 0);\n for (int r = 0; r < F; r++) {\n int c = assign_col[r];\n if (c < 0 || c >= C) continue;\n int i = cands[c];\n if (task_state[i] != 0) continue;\n if (used_task[i]) continue; // safety\n int j = free_members[r];\n\n used_task[i] = 1;\n task_state[i] = 1;\n member_task[j] = i;\n start_day[j] = day;\n assigns.push_back({j, i});\n }\n }\n\n // Output assignments for today\n cout << assigns.size();\n for (auto [j, i] : assigns) cout << ' ' << (j + 1) << ' ' << (i + 1);\n cout << \"\\n\" << flush;\n\n // Read completion info\n int nfin;\n if (!(cin >> nfin)) return 0;\n if (nfin == -1) return 0;\n\n for (int z = 0; z < nfin; z++) {\n int a; cin >> a;\n int j = a - 1;\n int i = member_task[j];\n if (i < 0) continue; // safety\n\n int t_obs = day - start_day[j] + 1;\n\n // finish task\n member_task[j] = -1;\n start_day[j] = -1;\n task_state[i] = 2;\n\n // unlock successors\n for (int v : out[i]) indeg[v]--;\n\n // update skill estimate\n update_member(j, i, t_obs);\n }\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point { int x, y; };\nstatic inline int manhattan(const Point& a, const Point& b){\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\nstatic const Point OFFICE{400, 400};\n\nstruct Order {\n int id; // 1..1000\n Point P, D;\n int intra;\n int proxy;\n};\n\nstruct XorShift64 {\n uint64_t x;\n explicit XorShift64(uint64_t seed=88172645463325252ull) : x(seed) {}\n uint64_t next() {\n uint64_t y = x;\n y ^= y << 7;\n y ^= y >> 9;\n return x = y;\n }\n int next_int(int lo, int hi){ // inclusive\n return lo + (int)(next() % (uint64_t)(hi - lo + 1));\n }\n double next_double(){ // [0,1)\n return (next() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Solver {\n vector orders; // 1000\n vector pool; // candidate global indices\n vector used; // 1000\n XorShift64 rng;\n\n Solver(): used(1000, 0) {\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n rng = XorShift64(seed);\n }\n\n // node encoding: (g<<1)|t, g in [0..999], t=0 pickup, t=1 delivery\n inline Point node_point(int node) const {\n int g = node >> 1;\n int t = node & 1;\n return t ? orders[g].D : orders[g].P;\n }\n\n int route_cost(const vector& ev) const {\n int cost = 0;\n Point cur = OFFICE;\n for (int node : ev) {\n Point nxt = node_point(node);\n cost += manhattan(cur, nxt);\n cur = nxt;\n }\n cost += manhattan(cur, OFFICE);\n return cost;\n }\n\n // ---- Pair reinsertion core ----\n void remove_pair_with_pts(const vector& ev, int A, int B,\n vector& base, vector& bp) const {\n base.clear(); bp.clear();\n base.reserve(ev.size() - 2);\n bp.reserve(ev.size() - 2);\n for (int node : ev) if (node != A && node != B) {\n base.push_back(node);\n bp.push_back(node_point(node));\n }\n }\n\n struct BestIns { int p, q, delta; };\n\n BestIns best_pair_insertion(const vector& base, const vector& bp,\n const Point& pA, const Point& pB) const {\n int Lb = (int)base.size();\n BestIns best{0, 1, INT_MAX};\n\n for (int p = 0; p <= Lb; p++) {\n Point prevP = (p == 0) ? OFFICE : bp[p - 1];\n Point nextP = (p == Lb) ? OFFICE : bp[p];\n int deltaA = manhattan(prevP, pA) + manhattan(pA, nextP) - manhattan(prevP, nextP);\n\n for (int q = p + 1; q <= Lb + 1; q++) {\n Point prevB = (q == p + 1) ? pA : bp[q - 2];\n Point nextB = (q == Lb + 1) ? OFFICE : bp[q - 1];\n int deltaB = manhattan(prevB, pB) + manhattan(pB, nextB) - manhattan(prevB, nextB);\n int total = deltaA + deltaB;\n if (total < best.delta) best = {p, q, total};\n }\n }\n return best;\n }\n\n vector build_with_pair_insertion(const vector& base, int A, int B, int p, int q) const {\n vector out = base;\n out.insert(out.begin() + p, A);\n out.insert(out.begin() + q, B); // q is index after A insertion\n return out;\n }\n\n bool best_reinsert_apply(vector& ev, int g, int& curCost) const {\n int A = (g << 1), B = (g << 1) | 1;\n vector base;\n vector bp;\n remove_pair_with_pts(ev, A, B, base, bp);\n\n int baseCost = route_cost(base);\n auto best = best_pair_insertion(base, bp, orders[g].P, orders[g].D);\n int newCost = baseCost + best.delta;\n\n if (newCost <= curCost) {\n ev = build_with_pair_insertion(base, A, B, best.p, best.q);\n bool improved = (newCost < curCost);\n curCost = newCost;\n return improved;\n }\n return false;\n }\n\n void local_optimize_pairs(vector& ev, const vector& chosen, int& curCost, int passes) const {\n for (int it = 0; it < passes; it++) {\n bool improved = false;\n for (int g : chosen) improved |= best_reinsert_apply(ev, g, curCost);\n if (!improved) break;\n }\n }\n\n // ---- Light single-node relocation (few attempts only) ----\n // Returns true if improved at least once.\n bool single_relocate_light(vector& ev, int& curCost, int attempts) {\n int L = (int)ev.size();\n if (L <= 2) return false;\n bool improvedAny = false;\n\n // positions for nodes (max node id is 1999)\n static array pos;\n for (int t = 0; t < attempts; t++) {\n pos.fill(-1);\n for (int i = 0; i < L; i++) pos[ev[i]] = i;\n\n int idx = rng.next_int(0, L - 1);\n int node = ev[idx];\n int g = node >> 1;\n int typ = node & 1;\n int pickup = (g << 1);\n int delivery = (g << 1) | 1;\n\n // remove delta\n Point pn = node_point(node);\n Point prev = (idx == 0) ? OFFICE : node_point(ev[idx - 1]);\n Point next = (idx == L - 1) ? OFFICE : node_point(ev[idx + 1]);\n int removeDelta = manhattan(prev, pn) + manhattan(pn, next) - manhattan(prev, next);\n int baseCost = curCost - removeDelta;\n\n // build base\n vector base;\n base.reserve(L - 1);\n for (int i = 0; i < L; i++) if (i != idx) base.push_back(ev[i]);\n int Lb = L - 1;\n\n int lo = 0, hi = Lb;\n if (typ == 0) {\n int posDel = pos[delivery];\n if (posDel < 0) continue;\n int delBase = posDel - 1; // pickup removed; delivery shifts left by 1\n hi = delBase;\n } else {\n int posPick = pos[pickup];\n if (posPick < 0) continue;\n lo = posPick + 1; // delivery must be after pickup\n }\n lo = max(lo, 0);\n hi = min(hi, Lb);\n if (lo > hi) continue;\n\n int bestP = -1;\n int bestInsDelta = INT_MAX;\n for (int p = lo; p <= hi; p++) {\n Point pPrev = (p == 0) ? OFFICE : node_point(base[p - 1]);\n Point pNext = (p == Lb) ? OFFICE : node_point(base[p]);\n int insDelta = manhattan(pPrev, pn) + manhattan(pn, pNext) - manhattan(pPrev, pNext);\n if (insDelta < bestInsDelta) {\n bestInsDelta = insDelta;\n bestP = p;\n }\n }\n\n if (bestP >= 0) {\n int newCost = baseCost + bestInsDelta;\n if (newCost < curCost) {\n base.insert(base.begin() + bestP, node);\n ev.swap(base);\n curCost = newCost;\n improvedAny = true;\n // update L if changed (still same), but keep consistent\n L = (int)ev.size();\n }\n }\n }\n return improvedAny;\n }\n\n // ---- Candidate selection / init ----\n int pick_unused_from_pool() {\n for (int t=0; t<50; t++){\n int g = pool[rng.next_int(0, (int)pool.size()-1)];\n if (!used[g]) return g;\n }\n for (int t=0; t<500; t++){\n int g = rng.next_int(0,999);\n if (!used[g]) return g;\n }\n return -1;\n }\n\n vector greedy_init_chosen(int m=50) {\n vector chosen;\n chosen.reserve(m);\n fill(used.begin(), used.end(), 0);\n\n Point cur = OFFICE;\n const double alpha = 0.25;\n\n for (int t = 0; t < m; t++) {\n int best = -1;\n double bestScore = 1e100;\n for (int g : pool) if (!used[g]) {\n const auto& o = orders[g];\n double s = manhattan(cur, o.P) + o.intra + alpha * manhattan(o.D, OFFICE);\n if (s < bestScore) { bestScore = s; best = g; }\n }\n if (best == -1) break;\n used[best] = 1;\n chosen.push_back(best);\n cur = orders[best].D;\n }\n for (int g = 0; (int)chosen.size() < m; g++) if (!used[g]) {\n used[g] = 1;\n chosen.push_back(g);\n }\n return chosen;\n }\n\n vector init_events_consecutive(const vector& chosen) const {\n vector ev;\n ev.reserve(2 * chosen.size());\n for (int g : chosen) {\n ev.push_back(g << 1);\n ev.push_back((g << 1) | 1);\n }\n return ev;\n }\n\n // Replacement: remove old g pair, insert new g pair at best positions\n bool try_replace_best(const vector& ev, int g_old, int g_new,\n vector& ev2, int& cost2) const {\n int Aold = (g_old << 1), Bold = (g_old << 1) | 1;\n int Anew = (g_new << 1), Bnew = (g_new << 1) | 1;\n\n vector base;\n vector bp;\n remove_pair_with_pts(ev, Aold, Bold, base, bp);\n\n int baseCost = route_cost(base);\n auto best = best_pair_insertion(base, bp, orders[g_new].P, orders[g_new].D);\n cost2 = baseCost + best.delta;\n ev2 = build_with_pair_insertion(base, Anew, Bnew, best.p, best.q);\n return true;\n }\n\n void solve() {\n // Pool by proxy\n vector idxs(1000);\n iota(idxs.begin(), idxs.end(), 0);\n sort(idxs.begin(), idxs.end(), [&](int i, int j){\n return orders[i].proxy < orders[j].proxy;\n });\n int K = 950;\n pool.assign(idxs.begin(), idxs.begin() + K);\n\n const int m = 50;\n\n // Multi-start init (as in strong version)\n vector bestChosenInit, bestEvInit;\n int bestInitCost = INT_MAX;\n\n vector poolBak = pool;\n for (int s = 0; s < 6; s++) {\n pool = poolBak;\n int pref = 200;\n for (int i = 0; i < pref; i++) swap(pool[i], pool[rng.next_int(0, pref-1)]);\n\n vector chosen = greedy_init_chosen(m);\n vector ev = init_events_consecutive(chosen);\n int c = route_cost(ev);\n local_optimize_pairs(ev, chosen, c, 4);\n single_relocate_light(ev, c, 8); // very light polish\n\n if (c < bestInitCost) {\n bestInitCost = c;\n bestChosenInit = chosen;\n bestEvInit = ev;\n }\n }\n\n vector chosen = bestChosenInit;\n vector ev = bestEvInit;\n fill(used.begin(), used.end(), 0);\n for (int g : chosen) used[g] = 1;\n\n int curCost = bestInitCost;\n int bestCost = curCost;\n vector bestChosen = chosen;\n vector bestEv = ev;\n\n auto start = chrono::steady_clock::now();\n const double TL = 1.95;\n int iter = 0;\n\n while (true) {\n double elapsed = chrono::duration(chrono::steady_clock::now() - start).count();\n if (elapsed >= TL) break;\n double frac = elapsed / TL;\n\n double T0 = 1800.0, T1 = 12.0;\n double temp = T0 * pow(T1 / T0, frac);\n\n double r = rng.next_double();\n bool doReplace = (r < 0.82);\n\n if (doReplace) {\n int posOld = rng.next_int(0, m-1);\n int g_old = chosen[posOld];\n int g_new = pick_unused_from_pool();\n if (g_new == -1) { iter++; continue; }\n\n vector ev2;\n int cost2;\n try_replace_best(ev, g_old, g_new, ev2, cost2);\n\n int delta = cost2 - curCost;\n bool accept = false;\n if (delta <= 0) accept = true;\n else if (rng.next_double() < exp(-delta / temp)) accept = true;\n\n if (accept) {\n used[g_old] = 0;\n used[g_new] = 1;\n chosen[posOld] = g_new;\n\n // Keep main polishing cheap to preserve iteration count\n local_optimize_pairs(ev2, chosen, cost2, 2);\n single_relocate_light(ev2, cost2, 3);\n\n ev.swap(ev2);\n curCost = cost2;\n\n if (curCost < bestCost) {\n bestCost = curCost;\n bestChosen = chosen;\n bestEv = ev;\n }\n }\n } else {\n // route perturbation: random pair reinsertion (exploration)\n int g = chosen[rng.next_int(0, m-1)];\n int A = (g << 1), B = (g << 1) | 1;\n\n vector base;\n vector bp;\n remove_pair_with_pts(ev, A, B, base, bp);\n int Lb = (int)base.size();\n\n int p = rng.next_int(0, Lb);\n int q = rng.next_int(p+1, Lb+1);\n vector ev2 = build_with_pair_insertion(base, A, B, p, q);\n int cost2 = route_cost(ev2);\n\n int delta = cost2 - curCost;\n bool accept = false;\n if (delta <= 0) accept = true;\n else if (rng.next_double() < exp(-delta / temp)) accept = true;\n\n if (accept) {\n local_optimize_pairs(ev2, chosen, cost2, 1);\n single_relocate_light(ev2, cost2, 2);\n ev.swap(ev2);\n curCost = cost2;\n\n if (curCost < bestCost) {\n bestCost = curCost;\n bestChosen = chosen;\n bestEv = ev;\n }\n }\n }\n\n iter++;\n }\n\n // Final hill-climb replacement stage (restored from strong version)\n {\n chosen = bestChosen;\n ev = bestEv;\n fill(used.begin(), used.end(), 0);\n for (int g : chosen) used[g] = 1;\n\n curCost = route_cost(ev);\n local_optimize_pairs(ev, chosen, curCost, 4);\n\n for (int step = 0; step < 120; step++) {\n int g_new = pick_unused_from_pool();\n if (g_new == -1) break;\n\n int bestPos = -1;\n vector bestEv2;\n int bestC2 = curCost;\n\n for (int t = 0; t < 6; t++) {\n int posOld = rng.next_int(0, m-1);\n int g_old = chosen[posOld];\n\n vector candEv;\n int candC;\n try_replace_best(ev, g_old, g_new, candEv, candC);\n if (candC < bestC2) {\n bestC2 = candC;\n bestPos = posOld;\n bestEv2 = std::move(candEv);\n }\n }\n\n if (bestPos != -1) {\n int g_old = chosen[bestPos];\n used[g_old] = 0;\n used[g_new] = 1;\n chosen[bestPos] = g_new;\n ev.swap(bestEv2);\n curCost = bestC2;\n\n local_optimize_pairs(ev, chosen, curCost, 2);\n single_relocate_light(ev, curCost, 10);\n }\n }\n\n if (curCost < bestCost) {\n bestCost = curCost;\n bestChosen = chosen;\n bestEv = ev;\n }\n }\n\n // Final polishing\n int finalCost = route_cost(bestEv);\n local_optimize_pairs(bestEv, bestChosen, finalCost, 5);\n single_relocate_light(bestEv, finalCost, 20);\n\n // Output\n cout << m;\n for (int g : bestChosen) cout << ' ' << (g + 1);\n cout << \"\\n\";\n\n vector route;\n route.reserve(2*m + 2);\n route.push_back(OFFICE);\n for (int node : bestEv) route.push_back(node_point(node));\n route.push_back(OFFICE);\n\n cout << (int)route.size();\n for (auto &p : route) cout << ' ' << p.x << ' ' << p.y;\n cout << \"\\n\";\n }\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Solver solver;\n solver.orders.resize(1000);\n for (int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n solver.orders[i].id = i + 1;\n solver.orders[i].P = {a,b};\n solver.orders[i].D = {c,d};\n solver.orders[i].intra = manhattan(solver.orders[i].P, solver.orders[i].D);\n solver.orders[i].proxy = manhattan(OFFICE, solver.orders[i].P)\n + solver.orders[i].intra\n + manhattan(solver.orders[i].D, OFFICE);\n }\n\n solver.solve();\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct DSU {\n int n, comps;\n vector p, sz;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n comps = n;\n p.resize(n);\n sz.assign(n, 1);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){\n while(p[a]!=a){\n p[a] = p[p[a]];\n a = p[a];\n }\n return a;\n }\n bool same(int a,int b){ return find(a)==find(b); }\n bool merge(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 comps--;\n return true;\n }\n};\n\nstatic constexpr int N = 400;\nstatic constexpr int M = 1995;\nstatic constexpr int INF = 1e9;\n\nstruct Ctx {\n vector root; // chosen.find(v)\n vector cid; // cid[root] -> 0..k-1\n int k;\n};\n\nstatic Ctx build_ctx(DSU &chosen){\n Ctx ctx;\n ctx.root.resize(N);\n for(int i=0;i &u, const vector &v){\n if(ctx.k <= 1) return true;\n DSU dsu2(ctx.k);\n for(int j=i+1;j depth;\n vector> up;\n vector> mx; // max edge weight to ancestor\n vector outCnt; // number of remaining outgoing (cross-component) edges\n vector minOutW1; // smallest expected outgoing weight\n vector minOutW2; // second smallest expected outgoing weight\n};\n\nstatic FutureInfo build_future_info(\n int i, const Ctx &ctx,\n const vector &u, const vector &v, const vector &d, int maxD)\n{\n FutureInfo info;\n info.k = ctx.k;\n info.ok = true;\n\n info.outCnt.assign(ctx.k, 0);\n info.minOutW1.assign(ctx.k, INF);\n info.minOutW2.assign(ctx.k, INF);\n\n if(ctx.k <= 1){\n info.LOG = 1;\n info.depth.assign(ctx.k, 0);\n info.up.assign(1, vector(ctx.k, -1));\n info.mx.assign(1, vector(ctx.k, 0));\n return info;\n }\n\n auto relax2 = [&](int c, int w){\n if(w < info.minOutW1[c]){\n info.minOutW2[c] = info.minOutW1[c];\n info.minOutW1[c] = w;\n } else if(w < info.minOutW2[c]) {\n info.minOutW2[c] = w;\n }\n };\n\n // Bucket by d to avoid sorting\n vector>> bucket(maxD + 1);\n\n for(int j=i+1;j>> adj(ctx.k);\n DSU mst(ctx.k);\n for(int dist=1; dist<=maxD && mst.comps>1; dist++){\n int w = 2 * dist;\n for(auto [a,b] : bucket[dist]){\n if(mst.merge(a,b)){\n adj[a].push_back({b,w});\n adj[b].push_back({a,w});\n if(mst.comps == 1) break;\n }\n }\n }\n if(mst.comps != 1){\n info.ok = false;\n info.LOG = 1;\n info.depth.assign(ctx.k, 0);\n info.up.assign(1, vector(ctx.k, -1));\n info.mx.assign(1, vector(ctx.k, 0));\n return info;\n }\n\n int LOG=1;\n while((1<(ctx.k, -1));\n info.mx.assign(LOG, vector(ctx.k, 0));\n\n // Root MST at 0\n stack st;\n info.depth[0] = 0;\n st.push(0);\n while(!st.empty()){\n int x = st.top(); st.pop();\n for(auto [to,w] : adj[x]){\n if(info.depth[to] != -1) continue;\n info.depth[to] = info.depth[x] + 1;\n info.up[0][to] = x;\n info.mx[0][to] = w;\n st.push(to);\n }\n }\n\n for(int t=1;t=0; t--){\n if(info.up[t][a] != info.up[t][b]){\n res = max(res, info.mx[t][a]);\n res = max(res, info.mx[t][b]);\n a = info.up[t][a];\n b = info.up[t][b];\n }\n }\n res = max(res, info.mx[0][a]);\n res = max(res, info.mx[0][b]);\n return res;\n}\n\nstatic long double clamp_ld(long double x, long double lo, long double hi){\n if(x < lo) return lo;\n if(x > hi) return hi;\n return x;\n}\n\n// Expected saving if we can replace a future edge with base db (Lb~Unif[db,3db]) by known cost li:\n// saving = E[Lb - min(Lb, li)] = E[max(0, Lb - li)]\nstatic long double expected_saving_replace(int li, int db){\n if(db <= 0) return 0.0L;\n long double L = (long double)li;\n long double d = (long double)db;\n if(L <= d){\n // always replace; E[Lb] = 2d\n return 2.0L*d - L;\n } else if(L < 3.0L*d){\n // integrate (x-L) over [L,3d] divided by (2d)\n long double t = 3.0L*d - L;\n return (t*t) / (4.0L*d);\n } else {\n return 0.0L;\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> x[i] >> y[i];\n vector u(M), v(M);\n for(int i=0;i> u[i] >> v[i];\n\n vector d(M);\n int maxD = 1;\n for(int i=0;i> li;\n\n if(chosen.comps == 1){\n cout << 0 << \"\\n\" << flush;\n continue;\n }\n\n int ans = 0;\n if(chosen.same(u[i], v[i])){\n ans = 0;\n } else {\n Ctx ctx = build_ctx(chosen);\n bool ok_reject = feasible_if_reject(i, ctx, u, v);\n\n if(!ok_reject){\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n int a = ctx.cid[ ctx.root[u[i]] ];\n int b = ctx.cid[ ctx.root[v[i]] ];\n\n FutureInfo finfo = build_future_info(i, ctx, u, v, d, maxD);\n\n long double ratio = (long double)li / (long double)d[i];\n long double rem_edges = (long double)(M - i);\n long double urgency = (ctx.k <= 1 ? 0.0L : (long double)(ctx.k - 1) / rem_edges);\n\n int outA = finfo.ok ? finfo.outCnt[a] : 0;\n int outB = finfo.ok ? finfo.outCnt[b] : 0;\n int scarce = min(outA, outB);\n\n bool take = false;\n\n // 1) Very strong bargains\n const long double BARGAIN = 1.13L;\n if(ratio <= BARGAIN) take = true;\n\n // 2) Compete with cheapest expected outgoing (and 2nd cheapest if extremely scarce)\n if(!take && finfo.ok){\n int min1 = min(finfo.minOutW1[a], finfo.minOutW1[b]);\n int min2 = min(finfo.minOutW2[a], finfo.minOutW2[b]);\n\n if(min1 < INF){\n long double phi = 1.06L + 0.05L * urgency;\n if(scarce <= 2) phi += 0.05L;\n if((long double)li <= phi * (long double)min1) take = true;\n }\n if(!take && scarce <= 1 && min2 < INF){\n long double phi2 = 1.04L + 0.08L * urgency;\n if((long double)li <= phi2 * (long double)min2) take = true;\n }\n }\n\n // 3) Replacement vs future-MST bottleneck: accept if expected saving is large enough\n if(!take && finfo.ok){\n int maxW = max_on_path(a, b, finfo); // = 2*db\n int db = maxW / 2;\n if(db > 0){\n if(li <= maxW){\n // already better than expected bottleneck\n take = true;\n } else {\n long double sav = expected_saving_replace(li, db);\n\n // required saving as fraction of db (tuned):\n long double reqFactor = 0.17L - 0.08L * urgency;\n if(scarce <= 2) reqFactor -= 0.03L;\n if(scarce <= 1) reqFactor -= 0.02L;\n reqFactor = clamp_ld(reqFactor, 0.06L, 0.20L);\n\n long double req = reqFactor * (long double)db;\n if(sav >= req) take = true;\n }\n }\n }\n\n // 4) Conservative fallback ratio threshold (late-stage safety)\n if(!take){\n long double allow = 1.20L + 1.62L * urgency;\n if(scarce <= 2) allow += 0.10L;\n allow = min(allow, 2.00L);\n if(ratio <= allow) take = true;\n }\n\n if(take){\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n ans = 0;\n }\n }\n }\n\n cout << ans << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nstatic const int H = 30, W = 30;\nstatic const int TURNS = 300;\n\nstruct Pet { int x, y, t; };\nstruct Human { int x, y; };\n\nstatic inline bool in_grid(int x,int y){ return 1<=x && x<=H && 1<=y && y<=W; }\n\nint dx4[4] = {-1, +1, 0, 0};\nint dy4[4] = {0, 0, -1, +1};\nchar dirMove[4] = {'U','D','L','R'};\nchar dirWall[4] = {'u','d','l','r'};\n\nstruct BFSResult{\n int dist[H+1][W+1];\n char first[H+1][W+1];\n};\n\nstruct TaskCand{\n int val;\n int workX, workY;\n int wallX, wallY;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N; cin >> N;\n vector pets(N);\n for(int i=0;i> pets[i].x >> pets[i].y >> pets[i].t;\n int M; cin >> M;\n vector humans(M);\n for(int i=0;i> humans[i].x >> humans[i].y;\n\n static bool wall[H+1][W+1];\n for(int x=1;x<=H;x++) for(int y=1;y<=W;y++) wall[x][y]=false;\n\n // ---- Choose sanctuary rectangle (prefer 0 pets inside) ----\n auto petsInsideRect = [&](int x1,int y1,int S)->int{\n int x2=x1+S-1, y2=y1+S-1;\n int c=0;\n for(auto &p: pets) if(x1<=p.x && p.x<=x2 && y1<=p.y && p.y<=y2) c++;\n return c;\n };\n auto humanTravelCost = [&](int x1,int y1,int S)->long long{\n int x2=x1+S-1, y2=y1+S-1;\n long long sum=0;\n for(auto &h: humans){\n int tx=min(max(h.x,x1),x2);\n int ty=min(max(h.y,y1),y2);\n sum += llabs(h.x-tx)+llabs(h.y-ty);\n }\n return sum;\n };\n auto distPetToRect = [&](const Pet& p, int x1,int y1,int S)->int{\n int x2=x1+S-1, y2=y1+S-1;\n int dx=0, dy=0;\n if(p.x < x1) dx = x1 - p.x; else if(p.x > x2) dx = p.x - x2;\n if(p.y < y1) dy = y1 - p.y; else if(p.y > y2) dy = p.y - y2;\n return dx+dy;\n };\n auto nearPetsCount = [&](int x1,int y1,int S,int th)->int{\n int c=0;\n for(auto &p: pets) if(distPetToRect(p,x1,y1,S)<=th) c++;\n return c;\n };\n\n int best_x1=2,best_y1=2,bestS=16;\n long long bestScore = LLONG_MIN;\n\n for(int pass=0; pass<2; pass++){\n int allowInside = (pass==0?0:1);\n for(int S=28; S>=14; S--){\n for(int x1=2; x1+S-1<=29; x1++){\n for(int y1=2; y1+S-1<=29; y1++){\n int pin = petsInsideRect(x1,y1,S);\n if(pin>allowInside) continue;\n long long area = 1LL*S*S;\n long long hcost = humanTravelCost(x1,y1,S);\n int near1 = nearPetsCount(x1,y1,S,1);\n int near2 = nearPetsCount(x1,y1,S,2);\n\n long long perim = 4LL*S;\n long long estTurns = perim / max(1, M-1) + 20;\n long long slowPenalty = (estTurns > 130 ? (estTurns-130)*8000LL : 0);\n\n long long score = area*2000LL\n - 2000000000LL*pin\n - 140000LL*near1\n - 50000LL*near2\n - 22LL*hcost\n - slowPenalty;\n if(score > bestScore){\n bestScore=score;\n best_x1=x1; best_y1=y1; bestS=S;\n }\n }\n }\n }\n if(pass==0 && petsInsideRect(best_x1,best_y1,bestS)==0) break;\n }\n\n int x1=best_x1, y1=best_y1;\n int x2=x1+bestS-1, y2=y1+bestS-1;\n\n auto inInterior = [&](int x,int y)->bool{ return x1<=x && x<=x2 && y1<=y && y<=y2; };\n\n // ---- Outer perimeter (exclude corners) ----\n vector> outerPerim;\n for(int y=y1; y<=y2; y++) outerPerim.push_back({x1-1,y});\n for(int y=y1; y<=y2; y++) outerPerim.push_back({x2+1,y});\n for(int x=x1; x<=x2; x++) outerPerim.push_back({x,y1-1});\n for(int x=x1; x<=x2; x++) outerPerim.push_back({x,y2+1});\n\n auto outerComplete = [&]()->bool{\n for(auto &c: outerPerim) if(!wall[c.first][c.second]) return false;\n return true;\n };\n\n auto bfsFrom = [&](int sx,int sy)->BFSResult{\n BFSResult res;\n const int INF=1e9;\n for(int x=1;x<=H;x++) for(int y=1;y<=W;y++){\n res.dist[x][y]=INF;\n res.first[x][y]='?';\n }\n deque> q;\n res.dist[sx][sy]=0;\n res.first[sx][sy]='.';\n q.push_back({sx,sy});\n while(!q.empty()){\n auto [x,y]=q.front(); q.pop_front();\n for(int k=0;k<4;k++){\n int nx=x+dx4[k], ny=y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) continue;\n if(res.dist[nx][ny]!=INF) continue;\n res.dist[nx][ny]=res.dist[x][y]+1;\n res.first[nx][ny] = (x==sx && y==sy) ? dirMove[k] : res.first[x][y];\n q.push_back({nx,ny});\n }\n }\n return res;\n };\n\n auto placeableWall = [&](int tx,int ty,\n const vector>& petCnt,\n const vector>& humanCnt)->bool{\n if(!in_grid(tx,ty)) return false;\n if(humanCnt[tx][ty]>0) return false;\n if(petCnt[tx][ty]>0) return false;\n for(int k=0;k<4;k++){\n int ax=tx+dx4[k], ay=ty+dy4[k];\n if(in_grid(ax,ay) && petCnt[ax][ay]>0) return false;\n }\n return true;\n };\n\n auto computeReachMaskFromHumans = [&](){\n vector> vis(H+1, vector(W+1,0));\n deque> q;\n for(auto &h: humans){\n if(!in_grid(h.x,h.y) || wall[h.x][h.y]) continue;\n if(!vis[h.x][h.y]){\n vis[h.x][h.y]=1;\n q.push_back({h.x,h.y});\n }\n }\n while(!q.empty()){\n auto [x,y]=q.front(); q.pop_front();\n for(int k=0;k<4;k++){\n int nx=x+dx4[k], ny=y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) continue;\n if(vis[nx][ny]) continue;\n vis[nx][ny]=1;\n q.push_back({nx,ny});\n }\n }\n return vis;\n };\n\n // ---- Prison / Cut state ----\n enum Phase { BUILD_OUTER=0, PRISON=1, CUT=2, DONE=3 };\n Phase phase = BUILD_OUTER;\n\n // prison box inclusive; region is [px1..px2]x[py1..py2], walls are its boundary excluding corners\n bool prisonPlanned=false;\n int px1=0,py1=0,px2=0,py2=0;\n vector> prisonWalls;\n\n auto humanInPrison = [&](const Human& h)->bool{\n return prisonPlanned && (px1<=h.x && h.x<=px2 && py1<=h.y && h.y<=py2);\n };\n auto anyHumanInPrison = [&]()->bool{\n if(!prisonPlanned) return false;\n for(auto &h: humans) if(humanInPrison(h)) return true;\n return false;\n };\n\n auto prisonRemaining = [&]()->vector>{\n vector> rem;\n rem.reserve(prisonWalls.size());\n for(auto &c: prisonWalls) if(!wall[c.first][c.second]) rem.push_back(c);\n return rem;\n };\n\n auto planPrisonOnce = [&](const vector>& petCnt)->bool{\n // Plan around ALL pets currently inside the interior (not only reachable).\n vector> insidePets;\n insidePets.reserve(N);\n for(auto &p: pets) if(inInterior(p.x,p.y)) insidePets.push_back({p.x,p.y});\n if(insidePets.empty()) return false;\n\n int minx=31,maxx=0,miny=31,maxy=0;\n for(auto &q: insidePets){\n minx=min(minx,q.first); maxx=max(maxx,q.first);\n miny=min(miny,q.second); maxy=max(maxy,q.second);\n }\n\n long long totalArea = 1LL*(x2-x1+1)*(y2-y1+1);\n\n long long bestRemain=-1;\n int bestB=-1;\n int bx1=0,by1=0,bx2=0,by2=0;\n vector> bestWalls;\n\n for(int B=4; B>=1; B--){\n int tx1=max(x1, minx-B), tx2=min(x2, maxx+B);\n int ty1=max(y1, miny-B), ty2=min(y2, maxy+B);\n\n if(tx2-tx1 < 2 || ty2-ty1 < 2) continue;\n\n long long prisonArea = 1LL*(tx2-tx1+1)*(ty2-ty1+1);\n long long remainArea = totalArea - prisonArea;\n if(remainArea < 80) continue;\n\n vector> walls;\n // boundary excluding corners\n for(int y=ty1+1; y<=ty2-1; y++){\n walls.push_back({tx1,y});\n walls.push_back({tx2,y});\n }\n for(int x=tx1+1; x<=tx2-1; x++){\n walls.push_back({x,ty1});\n walls.push_back({x,ty2});\n }\n if(walls.empty()) continue;\n\n int okNow=0;\n for(auto &c: walls){\n int wx=c.first, wy=c.second;\n bool ok=true;\n if(petCnt[wx][wy]>0) ok=false;\n for(int k=0;k<4;k++){\n int ax=wx+dx4[k], ay=wy+dy4[k];\n if(in_grid(ax,ay) && petCnt[ax][ay]>0) ok=false;\n }\n if(ok) okNow++;\n }\n if(okNow==0) continue;\n\n // prefer larger remaining area; tie-breaker: larger buffer (more robust), then okNow\n if(remainArea > bestRemain || (remainArea==bestRemain && B>bestB)){\n bestRemain=remainArea;\n bestB=B;\n bx1=tx1; bx2=tx2; by1=ty1; by2=ty2;\n bestWalls.swap(walls);\n }\n }\n\n if(bestB==-1) return false;\n px1=bx1; px2=bx2; py1=by1; py2=by2;\n prisonWalls.swap(bestWalls);\n prisonPlanned=true;\n return true;\n };\n\n // cut\n bool cutPlanned=false;\n bool cutVertical=false;\n int cutPos=-1;\n bool keepRightOrDown=true;\n vector> cutCells;\n\n auto cutRemaining = [&]()->vector>{\n vector> rem;\n rem.reserve(cutCells.size());\n for(auto &c: cutCells) if(!wall[c.first][c.second]) rem.push_back(c);\n return rem;\n };\n\n auto allHumansOnSafeSide = [&]()->bool{\n if(!cutPlanned) return true;\n auto onSafe = [&](int x,int y)->bool{\n if(cutVertical){\n if(keepRightOrDown) return y >= cutPos+1;\n else return y <= cutPos-1;\n }else{\n if(keepRightOrDown) return x >= cutPos+1;\n else return x <= cutPos-1;\n }\n };\n for(auto &h: humans){\n if(!inInterior(h.x,h.y)) return false;\n if(!onSafe(h.x,h.y)) return false;\n }\n return true;\n };\n\n auto planCutOnce = [&](const vector>& reachMask)->bool{\n // Cut is planned against reachable pets (pets in humans component)\n vector> rpets;\n for(auto &p: pets) if(reachMask[p.x][p.y]) rpets.push_back({p.x,p.y});\n if(rpets.empty()) return false;\n\n long long bestKey = LLONG_MAX;\n bool bestV=false; int bestP=-1; bool bestKeep=true;\n\n auto countSafePets = [&](bool vert,int pos,bool keep)->int{\n int c=0;\n for(auto &q: rpets){\n int x=q.first, y=q.second;\n if(vert){\n if(keep){ if(y>=pos+1) c++; } else { if(y<=pos-1) c++; }\n }else{\n if(keep){ if(x>=pos+1) c++; } else { if(x<=pos-1) c++; }\n }\n }\n return c;\n };\n auto safeArea = [&](bool vert,int pos,bool keep)->long long{\n if(vert){\n if(keep) return 1LL*(x2-x1+1)*max(0, y2-(pos+1)+1);\n else return 1LL*(x2-x1+1)*max(0, (pos-1)-y1+1);\n }else{\n if(keep) return 1LL*(y2-y1+1)*max(0, x2-(pos+1)+1);\n else return 1LL*(y2-y1+1)*max(0, (pos-1)-x1+1);\n }\n };\n\n for(int pos=y1+1; pos<=y2-1; pos++){\n for(int keep=0; keep<2; keep++){\n bool kp=(keep==0);\n int sp=countSafePets(true,pos,kp);\n long long area=safeArea(true,pos,kp);\n long long key=1LL*sp*1000000000LL - area;\n if(key> petCnt(H+1, vector(W+1,0));\n vector> humanCnt(H+1, vector(W+1,0));\n for(auto &p: pets) petCnt[p.x][p.y]++;\n for(auto &h: humans) humanCnt[h.x][h.y]++;\n\n if(phase==BUILD_OUTER && outerComplete()){\n // decide whether we need prison/cut\n bool trapped=false;\n for(auto &p: pets) if(inInterior(p.x,p.y)) { trapped=true; break; }\n if(!trapped) phase=DONE;\n else{\n prisonPlanned=false;\n cutPlanned=false;\n if(planPrisonOnce(petCnt)) phase=PRISON;\n else phase=CUT;\n }\n }\n\n // BFS per human for move planning\n vector bfsRes(M);\n for(int i=0;i act(M,'.');\n set> plannedWalls;\n set> plannedMoveDest;\n\n auto planWallAt = [&](int i,int wx,int wy)->bool{\n int x=humans[i].x, y=humans[i].y;\n int k=-1;\n for(int kk=0; kk<4; kk++) if(x+dx4[kk]==wx && y+dy4[kk]==wy){ k=kk; break; }\n if(k==-1) return false;\n if(plannedMoveDest.count({wx,wy})) return false;\n if(!placeableWall(wx,wy,petCnt,humanCnt)) return false;\n plannedWalls.insert({wx,wy});\n act[i]=dirWall[k];\n return true;\n };\n\n auto planMoveToward = [&](int i,int tx,int ty)->void{\n auto &b=bfsRes[i];\n if(!in_grid(tx,ty)) return;\n if(b.dist[tx][ty] >= (int)1e9) return;\n char fd=b.first[tx][ty];\n if(fd=='.' || fd=='?') return;\n int k=-1;\n for(int kk=0; kk<4; kk++) if(dirMove[kk]==fd){ k=kk; break; }\n if(k==-1) return;\n int nx=humans[i].x+dx4[k], ny=humans[i].y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) return;\n if(plannedWalls.count({nx,ny})) return;\n plannedMoveDest.insert({nx,ny});\n act[i]=fd;\n };\n\n auto buildCandidates = [&](int i, const vector>& targets, int K)->vector{\n const int INF=1e9;\n auto &b=bfsRes[i];\n vector cands;\n cands.reserve(K*3);\n for(auto &cell: targets){\n int wx=cell.first, wy=cell.second;\n if(wall[wx][wy]) continue;\n for(int k=0;k<4;k++){\n int px=wx+dx4[k], py=wy+dy4[k];\n if(!in_grid(px,py) || wall[px][py]) continue;\n int d=b.dist[px][py];\n if(d>=INF) continue;\n int stall = placeableWall(wx,wy,petCnt,humanCnt) ? 0 : 8;\n int val = d + stall;\n cands.push_back({val, px, py, wx, wy});\n }\n }\n sort(cands.begin(), cands.end(), [](const TaskCand& a,const TaskCand& b){\n if(a.val!=b.val) return a.valK) cands.resize(K);\n return cands;\n };\n\n auto assignAndActBuild = [&](const vector>& targets){\n const int K=10;\n vector> allC(M);\n vector> order;\n order.reserve(M);\n for(int i=0;i> reservedWall;\n for(auto [_,i]: order){\n if(act[i] != '.') continue;\n if(allC[i].empty()) continue;\n int chosen=-1;\n for(int j=0;j<(int)allC[i].size();j++){\n auto &c=allC[i][j];\n if(!reservedWall.count({c.wallX,c.wallY})){\n chosen=j; break;\n }\n }\n if(chosen==-1) continue;\n auto c=allC[i][chosen];\n reservedWall.insert({c.wallX,c.wallY});\n if(humans[i].x==c.workX && humans[i].y==c.workY){\n if(!planWallAt(i,c.wallX,c.wallY)) act[i]='.';\n }else{\n planMoveToward(i,c.workX,c.workY);\n }\n }\n };\n\n // ---- decide actions ----\n if(phase==DONE){\n // do nothing\n } else if(phase==BUILD_OUTER){\n int cx=(x1+x2)/2, cy=(y1+y2)/2;\n for(int i=0;ibool{\n if(!inInterior(x,y)) return false;\n return !(px1<=x && x<=px2 && py1<=y && y<=py2);\n };\n if(!outsidePrisonCell(tx,ty)){\n vector> cand = {\n {x1+1,y1+1},{x1+1,y2-1},{x2-1,y1+1},{x2-1,y2-1},\n {x1+2,(y1+y2)/2},{x2-2,(y1+y2)/2}\n };\n for(auto [cx,cy]: cand) if(outsidePrisonCell(cx,cy)) { tx=cx; ty=cy; break; }\n }\n\n for(int i=0;ibool{\n if(cutVertical){\n if(keepRightOrDown) return y >= cutPos+1;\n else return y <= cutPos-1;\n }else{\n if(keepRightOrDown) return x >= cutPos+1;\n else return x <= cutPos-1;\n }\n };\n int tx=(x1+x2)/2, ty=(y1+y2)/2;\n if(cutVertical){\n ty = keepRightOrDown ? (cutPos+1+y2)/2 : (y1+cutPos-1)/2;\n }else{\n tx = keepRightOrDown ? (cutPos+1+x2)/2 : (x1+cutPos-1)/2;\n }\n tx=min(max(tx,x1),x2);\n ty=min(max(ty,y1),y2);\n\n for(int i=0;i mv(N);\n for(int i=0;i> mv[i])) return 0;\n }\n // Apply pet moves\n for(int i=0;i\nusing namespace std;\n\nstatic constexpr int H = 20, W = 20, N = 400, LMAX = 200;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int l, int r) { return l + (int)(next_u64() % (uint64_t)(r - l + 1)); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto time_start = chrono::high_resolution_clock::now();\n auto elapsed_sec = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - time_start).count();\n };\n\n int si, sj, ti, tj;\n double p_d;\n cin >> si >> sj >> ti >> tj >> p_d;\n\n vector h(H), v(H - 1);\n for (int i = 0; i < H; i++) cin >> h[i];\n for (int i = 0; i < H - 1; i++) cin >> v[i];\n\n auto id = [&](int i, int j) { return i * W + j; };\n int s = id(si, sj), t = id(ti, tj);\n\n float p = (float)p_d;\n float q = 1.0f - p;\n\n // mv[state][dir] dir: 0 U,1 D,2 L,3 R\n int mv[N][4];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) {\n int cur = id(i, j);\n mv[cur][0] = (i == 0 || v[i - 1][j] == '1') ? cur : id(i - 1, j);\n mv[cur][1] = (i == H - 1 || v[i][j] == '1') ? cur : id(i + 1, j);\n mv[cur][2] = (j == 0 || h[i][j - 1] == '1') ? cur : id(i, j - 1);\n mv[cur][3] = (j == W - 1 || h[i][j] == '1') ? cur : id(i, j + 1);\n }\n\n // Optimistic closed-loop DP G[turn][x]\n static float G[LMAX + 2][N];\n for (int x = 0; x < N; x++) G[LMAX + 1][x] = 0.0f;\n for (int turn = LMAX; turn >= 1; --turn) {\n float reward = (float)(401 - turn);\n for (int x = 0; x < N; x++) {\n if (x == t) { G[turn][x] = 0.0f; continue; }\n float stay_part = p * G[turn + 1][x];\n float best = 0.0f;\n for (int a = 0; a < 4; a++) {\n int y = mv[x][a];\n float val = stay_part + (y == t ? q * reward : q * G[turn + 1][y]);\n best = max(best, val);\n }\n G[turn][x] = best;\n }\n G[turn][t] = 0.0f;\n }\n\n // One-step open-loop lookahead Q[turn][a][x]\n static float Q[LMAX + 1][4][N];\n for (int turn = 1; turn <= LMAX; ++turn) {\n float reward = (float)(401 - turn);\n for (int x = 0; x < N; x++) {\n if (x == t) {\n for (int a = 0; a < 4; a++) Q[turn][a][x] = 0.0f;\n continue;\n }\n float stay_part = p * G[turn + 1][x];\n for (int a = 0; a < 4; a++) {\n int y = mv[x][a];\n Q[turn][a][x] = stay_part + (y == t ? q * reward : q * G[turn + 1][y]);\n }\n }\n }\n\n auto heuristic_openloop_1step = [&](const array& prob, int turn) -> float {\n if (turn > LMAX) return 0.0f;\n float best = 0.0f;\n for (int a = 0; a < 4; a++) {\n const float* qax = Q[turn][a];\n float sum = 0.0f;\n for (int x = 0; x < N; x++) sum += prob[x] * qax[x];\n best = max(best, sum);\n }\n return best;\n };\n\n struct Node {\n int len = 0;\n float score = 0.0f;\n float key = 0.0f;\n array path{};\n array prob{};\n };\n\n auto compute_key = [&](const Node& nd) -> float {\n return nd.score + heuristic_openloop_1step(nd.prob, nd.len + 1);\n };\n\n auto extend = [&](const Node& cur, int a) -> Node {\n static const char dc[4] = {'U','D','L','R'};\n Node nxt;\n nxt.len = cur.len + 1;\n nxt.score = cur.score;\n nxt.path = cur.path;\n nxt.path[cur.len] = dc[a];\n nxt.prob.fill(0.0f);\n\n float reach = 0.0f;\n for (int x = 0; x < N; x++) {\n float px = cur.prob[x];\n if (px == 0.0f) continue;\n nxt.prob[x] += px * p;\n int y = mv[x][a];\n float mvprob = px * q;\n if (y == t) reach += mvprob;\n else nxt.prob[y] += mvprob;\n }\n nxt.prob[t] = 0.0f;\n nxt.score += reach * (float)(401 - nxt.len);\n nxt.key = compute_key(nxt);\n return nxt;\n };\n\n auto node_to_string = [&](const Node& nd) -> string {\n string out;\n out.reserve(nd.len);\n for (int i = 0; i < nd.len; i++) out.push_back(nd.path[i]);\n return out;\n };\n\n // ----- Exact forward DP for a fixed action vector -----\n static float P[LMAX + 1][N]; // P[step][x] prob at x after step actions (not reached yet)\n static double prefixScore[LMAX + 1];\n\n auto forward_eval = [&](const vector& A) -> double {\n for (int x = 0; x < N; x++) P[0][x] = 0.0f;\n P[0][s] = 1.0f;\n P[0][t] = 0.0f;\n prefixScore[0] = 0.0;\n\n for (int step = 0; step < LMAX; step++) {\n int a = A[step];\n float nxtP[N]; for (int x = 0; x < N; x++) nxtP[x] = 0.0f;\n double reach = 0.0;\n for (int x = 0; x < N; x++) {\n float px = P[step][x];\n if (px == 0.0f) continue;\n nxtP[x] += px * p;\n int y = mv[x][a];\n double mvprob = (double)px * (double)q;\n if (y == t) reach += mvprob;\n else nxtP[y] += (float)mvprob;\n }\n nxtP[t] = 0.0f;\n prefixScore[step + 1] = prefixScore[step] + reach * (401.0 - (step + 1));\n for (int x = 0; x < N; x++) P[step + 1][x] = nxtP[x];\n }\n return prefixScore[LMAX];\n };\n\n // ----- Fast right-to-left coordinate improvement pass -----\n // Uses current P/prefixScore (computed from current A) and optimizes A in-place.\n auto right_to_left_pass = [&](vector& A) -> double {\n static float Vnext[N], Vcur[N];\n for (int x = 0; x < N; x++) Vnext[x] = 0.0f;\n\n double total_at_0 = 0.0;\n for (int pos = LMAX - 1; pos >= 0; --pos) {\n float reward = (float)(401 - (pos + 1));\n\n int bestA = A[pos];\n double bestTotal = -1e100;\n\n // Evaluate each action by combining prefix distribution and fixed suffix value Vnext\n for (int a = 0; a < 4; a++) {\n double sum = 0.0;\n for (int x = 0; x < N; x++) {\n float px = P[pos][x];\n if (px == 0.0f) continue;\n int y = mv[x][a];\n float val = p * Vnext[x] + q * (y == t ? reward : Vnext[y]);\n sum += (double)px * (double)val;\n }\n double tot = prefixScore[pos] + sum;\n if (tot > bestTotal) {\n bestTotal = tot;\n bestA = a;\n }\n }\n\n A[pos] = bestA;\n\n // Update Vcur for this chosen action\n for (int x = 0; x < N; x++) {\n if (x == t) { Vcur[x] = 0.0f; continue; }\n int y = mv[x][bestA];\n Vcur[x] = p * Vnext[x] + q * (y == t ? reward : Vnext[y]);\n }\n for (int x = 0; x < N; x++) Vnext[x] = Vcur[x];\n\n if (pos == 0) total_at_0 = bestTotal;\n }\n return total_at_0;\n };\n\n auto greedy_complete_to_200 = [&](Node nd) -> Node {\n while (nd.len < LMAX) {\n int turn = nd.len + 1;\n int besta = 0;\n float bestv = -1e30f;\n for (int a = 0; a < 4; a++) {\n const float* qax = Q[turn][a];\n float sum = 0.0f;\n for (int x = 0; x < N; x++) sum += nd.prob[x] * qax[x];\n if (sum > bestv) { bestv = sum; besta = a; }\n }\n nd = extend(nd, besta);\n }\n return nd;\n };\n\n // ----- Beam search -----\n const int BEAM_WIDTH = 380;\n\n Node init;\n init.len = 0;\n init.score = 0.0f;\n init.prob.fill(0.0f);\n init.prob[s] = 1.0f;\n init.prob[t] = 0.0f;\n init.key = compute_key(init);\n\n vector beam;\n beam.reserve(BEAM_WIDTH);\n beam.push_back(init);\n\n Node best_any = init;\n vector last_beam;\n\n for (int step = 0; step < LMAX; step++) {\n vector cand;\n cand.reserve(beam.size() * 4);\n for (const auto& nd : beam) {\n for (int a = 0; a < 4; a++) {\n Node child = extend(nd, a);\n if (child.score > best_any.score) best_any = child;\n cand.push_back(std::move(child));\n }\n }\n int take = min((int)cand.size(), BEAM_WIDTH);\n nth_element(cand.begin(), cand.begin() + take, cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n cand.resize(take);\n sort(cand.begin(), cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n beam.swap(cand);\n if (step == LMAX - 1) last_beam = beam;\n }\n\n // ----- Build candidate starts, pick best by exact eval -----\n vector> startAs;\n startAs.reserve(64);\n\n auto str_to_A = [&](const string& s) -> vector {\n vector A(LMAX, 1);\n for (int i = 0; i < LMAX; i++) {\n char c = s[i];\n if (c == 'U') A[i] = 0;\n else if (c == 'D') A[i] = 1;\n else if (c == 'L') A[i] = 2;\n else A[i] = 3;\n }\n return A;\n };\n auto A_to_str = [&](const vector& A) -> string {\n static const char dc[4] = {'U','D','L','R'};\n string s; s.resize(LMAX);\n for (int i = 0; i < LMAX; i++) s[i] = dc[A[i]];\n return s;\n };\n\n // take top candidates from final beam (by key), plus greedy completion of best_any\n int TAKE = min(45, (int)last_beam.size());\n vector candStr;\n candStr.reserve(TAKE + 2);\n for (int i = 0; i < TAKE; i++) {\n string s0 = node_to_string(last_beam[i]);\n if ((int)s0.size() < LMAX) s0.append(LMAX - s0.size(), 'D');\n s0.resize(LMAX);\n candStr.push_back(s0);\n }\n {\n Node full = greedy_complete_to_200(best_any);\n string s0 = node_to_string(full);\n if ((int)s0.size() < LMAX) s0.append(LMAX - s0.size(), 'D');\n s0.resize(LMAX);\n candStr.push_back(s0);\n }\n sort(candStr.begin(), candStr.end());\n candStr.erase(unique(candStr.begin(), candStr.end()), candStr.end());\n\n double best0Score = -1e100;\n vector curA;\n for (auto &ss : candStr) {\n auto A = str_to_A(ss);\n double sc = forward_eval(A);\n if (sc > best0Score) { best0Score = sc; curA = std::move(A); }\n }\n double curScore = best0Score;\n\n vector bestA = curA;\n double bestScore = curScore;\n\n // ----- Local optimization: many cheap coordinate passes + kick & improve -----\n XorShift rng;\n const double TIME_LIMIT = 1.95;\n\n auto do_coordinate_until_stall = [&](vector& A, double& score, int maxIters) {\n for (int it = 0; it < maxIters; it++) {\n forward_eval(A); // fill P and prefixScore\n double newScore = right_to_left_pass(A);\n if (newScore > score + 1e-9) {\n score = newScore;\n if (score > bestScore + 1e-9) { bestScore = score; bestA = A; }\n } else {\n break;\n }\n if (elapsed_sec() >= TIME_LIMIT) break;\n }\n };\n\n // initial polishing\n do_coordinate_until_stall(curA, curScore, 60);\n\n // kick loop\n while (elapsed_sec() < TIME_LIMIT) {\n vector savedA = curA;\n double savedScore = curScore;\n\n // random block kick\n int pos = rng.next_int(0, LMAX - 1);\n int len = rng.next_int(4, 16);\n int end = min(LMAX, pos + len);\n for (int i = pos; i < end; i++) curA[i] = rng.next_int(0, 3);\n\n curScore = forward_eval(curA);\n if (curScore > bestScore + 1e-9) { bestScore = curScore; bestA = curA; }\n\n // re-optimize a bit\n do_coordinate_until_stall(curA, curScore, 20);\n\n // accept kick only if it improved current (to keep stability)\n if (curScore + 1e-9 < savedScore) {\n curA = std::move(savedA);\n curScore = savedScore;\n }\n }\n\n cout << A_to_str(bestA) << \"\\n\";\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nstatic const int N = 30;\nstatic const int CELLS = N * N;\nstatic const int PORTS = CELLS * 4;\n\n// Directions: 0:left, 1:up, 2:right, 3:down\nstatic const int dj[4] = {-1, 0, 1, 0};\nstatic const int di[4] = {0, -1, 0, 1};\nstatic const int opp[4] = {2, 3, 0, 1};\n\nstatic const int to_table[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\n// rotate CCW by 90 degrees mapping\nstatic const int rot1[8] = {1,2,3,0, 5,4, 7,6};\n\nstruct XorShift {\n uint64_t x;\n explicit XorShift(uint64_t seed=88172645463325252ull) : x(seed) {}\n inline uint32_t nextU32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU32() % (uint32_t)(hi - lo + 1));\n }\n inline double nextDouble() { // [0,1)\n return (nextU32() + 0.5) / 4294967296.0;\n }\n};\n\nstruct Timer {\n chrono::high_resolution_clock::time_point st;\n Timer() : st(chrono::high_resolution_clock::now()) {}\n double elapsedSec() const {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nstruct EvalResult {\n int L1=0, L2=0;\n int loopsCnt=0;\n int score=0;\n\n int matchedBorders=0;\n int boundaryPorts=0;\n int unmatchedPorts=0;\n\n int sumLen=0;\n int sumLen2=0;\n\n int openSizeSum=0; // sum compSize over open components\n int openMiss2Sum=0; // sum (miss^2) over open components\n\n int aux=0;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector init(CELLS);\n for (int i = 0; i < N; i++) {\n string s; cin >> s;\n for (int j = 0; j < N; j++) init[i*N + j] = s[j] - '0';\n }\n\n // Precompute state after r rotations\n uint8_t stateAfterRot[8][4];\n for (int t = 0; t < 8; t++) {\n int cur = t;\n for (int r = 0; r < 4; r++) {\n stateAfterRot[t][r] = (uint8_t)cur;\n cur = rot1[cur];\n }\n }\n\n bool hasPort[8][4];\n int partner[8][4];\n for (int t = 0; t < 8; t++) {\n for (int d = 0; d < 4; d++) {\n int d2 = to_table[t][d];\n hasPort[t][d] = (d2 != -1);\n partner[t][d] = d2;\n }\n }\n\n // buffers for evaluation\n static uint8_t existPort[PORTS];\n static int16_t ext[PORTS];\n static uint16_t visStamp[PORTS];\n uint16_t curStamp = 1;\n static int stk[PORTS];\n\n auto evaluate = [&](const vector& state) -> EvalResult {\n EvalResult res;\n\n // existPort, boundaryPorts\n res.boundaryPorts = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int cell = i*N + j;\n int t = state[cell];\n int base = cell*4;\n for (int s = 0; s < 4; s++) existPort[base+s] = hasPort[t][s] ? 1 : 0;\n\n if (j == 0 && hasPort[t][0]) res.boundaryPorts++;\n if (i == 0 && hasPort[t][1]) res.boundaryPorts++;\n if (j == N-1 && hasPort[t][2]) res.boundaryPorts++;\n if (i == N-1 && hasPort[t][3]) res.boundaryPorts++;\n }\n\n // build ext and matchedBorders\n for (int p = 0; p < PORTS; p++) ext[p] = -1;\n res.matchedBorders = 0;\n\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int cell = i*N + j;\n int base = cell*4;\n\n if (j+1 < N) {\n int cellR = i*N + (j+1);\n int a = base + 2;\n int b = cellR*4 + 0;\n if (existPort[a] && existPort[b]) {\n ext[a] = (int16_t)b;\n ext[b] = (int16_t)a;\n res.matchedBorders++;\n }\n }\n if (i+1 < N) {\n int cellD = (i+1)*N + j;\n int a = base + 3;\n int b = cellD*4 + 1;\n if (existPort[a] && existPort[b]) {\n ext[a] = (int16_t)b;\n ext[b] = (int16_t)a;\n res.matchedBorders++;\n }\n }\n }\n\n // unmatchedPorts\n res.unmatchedPorts = 0;\n for (int p = 0; p < PORTS; p++) if (existPort[p] && ext[p] == -1) res.unmatchedPorts++;\n\n // traverse port-components\n if (++curStamp == 0) { // extremely unlikely; reset\n memset(visStamp, 0, sizeof(visStamp));\n curStamp = 1;\n }\n\n int best1 = 0, best2 = 0;\n\n for (int p = 0; p < PORTS; p++) {\n if (!existPort[p] || visStamp[p] == curStamp) continue;\n\n int compSize = 0;\n int miss = 0;\n\n int sp = 0;\n stk[sp++] = p;\n visStamp[p] = curStamp;\n\n while (sp) {\n int v = stk[--sp];\n compSize++;\n\n if (ext[v] == -1) miss++;\n\n int cell = v / 4;\n int side = v % 4;\n int t = state[cell];\n\n int u_int = cell*4 + partner[t][side];\n if (existPort[u_int] && visStamp[u_int] != curStamp) {\n visStamp[u_int] = curStamp;\n stk[sp++] = u_int;\n }\n int u_ext = ext[v];\n if (u_ext != -1 && visStamp[u_ext] != curStamp) {\n visStamp[u_ext] = curStamp;\n stk[sp++] = u_ext;\n }\n }\n\n if (miss == 0) {\n int len = compSize / 2;\n res.loopsCnt++;\n res.sumLen += len;\n res.sumLen2 += len * len;\n if (len > best1) { best2 = best1; best1 = len; }\n else if (len > best2) { best2 = len; }\n } else {\n res.openSizeSum += compSize;\n res.openMiss2Sum += miss * miss;\n }\n }\n\n res.L1 = best1;\n res.L2 = best2;\n res.score = (res.loopsCnt >= 2 ? best1 * best2 : 0);\n\n // Auxiliary objective (tuned to push closing + merging)\n long long aux = 0;\n aux += 500000LL * min(res.loopsCnt, 2); // must get 2 loops\n aux += 30000LL * res.score; // then maximize true score\n aux += 3000LL * res.L2 + 800LL * res.L1; // stabilize improving 2nd loop\n aux += 120LL * res.sumLen2; // prefer longer cycles\n aux += 25LL * res.matchedBorders; // encourage connections\n aux -= 20LL * res.unmatchedPorts; // close open ends\n aux -= 120LL * res.boundaryPorts; // avoid boundary leaks\n aux += 2LL * res.openSizeSum; // keep big components\n aux -= 10LL * res.openMiss2Sum; // but strongly reduce missing ends\n\n if (aux > INT_MAX) aux = INT_MAX;\n if (aux < INT_MIN) aux = INT_MIN;\n res.aux = (int)aux;\n return res;\n };\n\n Timer timer;\n double TL = 1.90;\n\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n // local best rotation proposal for a cell (fast heuristic move)\n auto bestLocalRotation = [&](int cell, const vector& state) -> uint8_t {\n int i = cell / N, j = cell % N;\n\n // weights for local scoring\n const int W_MATCH = 6;\n const int W_MISM = 7;\n const int W_BOUND = 10;\n\n int bestVal = INT_MIN;\n uint8_t bestR = 0;\n\n for (int r = 0; r < 4; r++) {\n int t = stateAfterRot[init[cell]][r];\n int val = 0;\n\n for (int s = 0; s < 4; s++) {\n bool p = hasPort[t][s];\n int ni = i + di[s], nj = j + dj[s];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) {\n if (p) val -= W_BOUND;\n } else {\n int nb = ni*N + nj;\n bool q = hasPort[state[nb]][opp[s]];\n if (p && q) val += W_MATCH;\n else if (p ^ q) val -= W_MISM;\n }\n }\n\n // small bias to avoid boundary ports even if neighbor absent\n if (val > bestVal) {\n bestVal = val;\n bestR = (uint8_t)r;\n }\n }\n return bestR;\n };\n\n // Global best tracking\n vector globalBestRot(CELLS, 0);\n vector globalBestState(CELLS, 0);\n int globalBestScore = 0;\n\n auto initRandomSolution = [&](vector& rot, vector& state) {\n rot.resize(CELLS);\n state.resize(CELLS);\n for (int c = 0; c < CELLS; c++) {\n rot[c] = (uint8_t)rng.nextInt(0, 3);\n state[c] = stateAfterRot[init[c]][rot[c]];\n }\n };\n\n auto runSA = [&](vector& rot, vector& state, double timeSlice) {\n double startT = timer.elapsedSec();\n EvalResult cur = evaluate(state);\n\n // SA temps\n const double T0 = 350000.0;\n const double T1 = 30.0;\n\n while (timer.elapsedSec() - startT < timeSlice && timer.elapsedSec() < TL) {\n double tt = (timer.elapsedSec() - startT) / max(1e-9, timeSlice);\n double Temp = T0 * (1.0 - tt) + T1 * tt;\n\n int cell = rng.nextInt(0, CELLS - 1);\n\n uint8_t oldr = rot[cell];\n uint8_t olds = state[cell];\n\n uint8_t newr;\n uint32_t rv = rng.nextU32();\n\n // mix moves: random / local-best\n if ((rv & 15) == 0) {\n newr = bestLocalRotation(cell, state);\n } else {\n // random different rotation\n int add = (int)(rv % 3) + 1;\n newr = (uint8_t)((oldr + add) & 3);\n }\n if (newr == oldr) continue;\n\n rot[cell] = newr;\n state[cell] = stateAfterRot[init[cell]][newr];\n\n EvalResult nxt = evaluate(state);\n int delta = nxt.aux - cur.aux;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / Temp);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (accept) {\n cur = nxt;\n if (cur.score > globalBestScore) {\n globalBestScore = cur.score;\n globalBestRot = rot;\n globalBestState = state;\n }\n } else {\n rot[cell] = oldr;\n state[cell] = olds;\n }\n }\n };\n\n // Phase 1: multi-start exploration\n const double phase1End = 0.85; // seconds\n while (timer.elapsedSec() < min(TL, phase1End)) {\n vector rot, state;\n initRandomSolution(rot, state);\n runSA(rot, state, 0.17); // short runs\n }\n\n // If somehow no best stored (very unlikely), set from random\n if (globalBestState[0] == 0 && globalBestRot[0] == 0) {\n initRandomSolution(globalBestRot, globalBestState);\n globalBestScore = evaluate(globalBestState).score;\n }\n\n // Phase 2: long refinement from the best found\n {\n vector rot = globalBestRot;\n vector state = globalBestState;\n double remaining = TL - timer.elapsedSec();\n runSA(rot, state, max(0.0, remaining));\n }\n\n // Output\n string out(CELLS, '0');\n for (int c = 0; c < CELLS; c++) out[c] = char('0' + globalBestRot[c]);\n cout << out << \"\\n\";\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n};\n\nstatic inline int hexval(char c) {\n if ('0' <= c && c <= '9') return c - '0';\n return 10 + (c - 'a');\n}\n\nstatic const char DIRCH[4] = {'U','D','L','R'};\nstatic const int dr[4] = {-1, +1, 0, 0};\nstatic const int dc[4] = {0, 0, -1, +1};\n\nstatic inline int revdir(int d){\n if(d==0) return 1;\n if(d==1) return 0;\n if(d==2) return 3;\n return 2;\n}\n\nstatic inline int dsu_find(int a, int parent[]) {\n while (parent[a] != a) {\n parent[a] = parent[parent[a]];\n a = parent[a];\n }\n return a;\n}\nstatic inline void dsu_unite(int a, int b, int parent[], uint8_t rnk[]) {\n a = dsu_find(a, parent);\n b = dsu_find(b, parent);\n if (a == b) return;\n if (rnk[a] < rnk[b]) swap(a, b);\n parent[b] = a;\n if (rnk[a] == rnk[b]) rnk[a]++;\n}\n\nstruct EdgeInfo {\n uint8_t u, v;\n uint8_t needU, needV; // bitmasks needed on tile at u/v\n};\n\nstruct Eval {\n int maxTree = 0;\n int maxComp = 0;\n int maxTreeable = 0; // max over components of v - excess\n int matchEdges = 0;\n int cycleExcess = 0;\n int scalar = 0;\n};\n\nstruct Precomp {\n int N=0, NN=0;\n vector edges; // adjacency constraints\n};\n\nEval evaluate_board(const array& a, const Precomp& P) {\n const int NN = P.NN;\n\n int parent[100];\n uint8_t rnk[100];\n for(int i=0;i v-1) excess = e - (v-1);\n cycleExcess += excess;\n maxTreeable = max(maxTreeable, v - excess);\n if(excess == 0) maxTree = max(maxTree, v);\n }\n\n // tuned weights (works reasonably across N=6..10)\n int scalar = maxTree * 1000000\n + maxTreeable * 7000\n + maxComp * 1200\n + matchEdges * 8\n - cycleExcess * 24000;\n\n return Eval{maxTree, maxComp, maxTreeable, matchEdges, cycleExcess, scalar};\n}\n\nstatic inline bool apply_move(array& a, int N, int &er, int &ec, int d){\n int nr = er + dr[d], nc = ec + dc[d];\n if(nr<0||nr>=N||nc<0||nc>=N) return false;\n int u = er*N + ec;\n int v = nr*N + nc;\n swap(a[u], a[v]);\n er = nr; ec = nc;\n return true;\n}\n\nstatic inline bool better_solution(const Eval& A, int KA, const Eval& B, int KB, int targetFull){\n bool Afull = (A.maxTree == targetFull);\n bool Bfull = (B.maxTree == targetFull);\n if(Afull != Bfull) return Afull;\n if(Afull && Bfull) return KA < KB;\n\n if(A.maxTree != B.maxTree) return A.maxTree > B.maxTree;\n if(A.maxTreeable != B.maxTreeable) return A.maxTreeable > B.maxTreeable;\n if(A.maxComp != B.maxComp) return A.maxComp > B.maxComp;\n if(A.cycleExcess != B.cycleExcess) return A.cycleExcess < B.cycleExcess;\n if(A.matchEdges != B.matchEdges) return A.matchEdges > B.matchEdges;\n return KA < KB;\n}\n\nstruct State {\n array a;\n int er=0, ec=0;\n int lastDir=-1;\n int scalar=0;\n Eval ev;\n string path;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T;\n cin >> N >> T;\n const int NN = N*N;\n const int targetFull = NN-1;\n\n array init{};\n int er=-1, ec=-1;\n for(int i=0;i> s;\n for(int j=0;j(\n chrono::steady_clock::now()-start).count();\n };\n const double TIME_LIMIT_MS = 2850.0;\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n seed ^= (uint64_t)(N*10007 + T*1000003);\n XorShift64 rng(seed);\n\n string bestAns = \"\";\n Eval bestEv = evaluate_board(init, P);\n int bestK = 0;\n\n if(bestEv.maxTree == targetFull){\n cout << \"\\n\";\n return 0;\n }\n\n // ----------------------------\n // Beam search prefix\n // ----------------------------\n int beamWidth = (N <= 7 ? 600 : 450);\n int beamDepth = min(240, max(90, T/7));\n double beamTimeFrac = 0.33;\n\n vector cur, nxt;\n cur.reserve(beamWidth);\n nxt.reserve(beamWidth*4);\n\n State s0;\n s0.a = init; s0.er = er; s0.ec = ec; s0.lastDir = -1;\n s0.ev = bestEv; s0.scalar = bestEv.scalar;\n s0.path.clear();\n cur.push_back(s0);\n\n for(int depth=0; depth beamWidth){\n nth_element(nxt.begin(), nxt.begin()+beamWidth, nxt.end(),\n [](const State& a, const State& b){ return a.scalar > b.scalar; });\n nxt.resize(beamWidth);\n }\n sort(nxt.begin(), nxt.end(), [](const State& a, const State& b){ return a.scalar > b.scalar; });\n cur.swap(nxt);\n }\n\n // Seeds: initial + top beam + random-walk perturbed seeds\n vector seeds;\n seeds.reserve(28);\n seeds.push_back(s0);\n\n int topM = min(12, (int)cur.size());\n for(int i=0;i=N||nc<0||nc>=N) continue;\n if(rs.lastDir!=-1 && d==revdir(rs.lastDir) && rng.next_double() < 0.75) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n int d = cand[rng.next_int(ccnt)];\n apply_move(rs.a, N, rs.er, rs.ec, d);\n rs.lastDir = d;\n rs.path.push_back(DIRCH[d]);\n }\n rs.ev = evaluate_board(rs.a, P);\n rs.scalar = rs.ev.scalar;\n seeds.push_back(std::move(rs));\n }\n\n // ----------------------------\n // SA from seeds with \"softmax move selection\"\n // ----------------------------\n for(int si=0; si<(int)seeds.size() && elapsed_ms() a = st.a;\n int cur_er = st.er, cur_ec = st.ec;\n int lastDir = st.lastDir;\n Eval curE = st.ev;\n\n string moves = st.path;\n moves.reserve(T);\n\n int runBestIdx = (int)moves.size();\n Eval runBestEv = curE;\n\n int accepted = 0;\n int stagnate = 0;\n\n double temp0 = 1800.0;\n double temp1 = 12.0;\n\n while(accepted < remaining && elapsed_ms() < TIME_LIMIT_MS){\n double prog = (double)accepted / max(1, remaining);\n double temp = temp0 * pow(temp1 / temp0, prog);\n\n // Kick when stuck\n if(stagnate > 1000){\n int kickLen = min(40, remaining - accepted);\n for(int kk=0; kk=N||nc<0||nc>=N) continue;\n if(lastDir!=-1 && d==revdir(lastDir) && rng.next_double() < 0.6) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n int d = cand[rng.next_int(ccnt)];\n apply_move(a, N, cur_er, cur_ec, d);\n moves.push_back(DIRCH[d]);\n accepted++;\n lastDir = d;\n }\n curE = evaluate_board(a, P);\n stagnate = 0;\n continue;\n }\n\n // Enumerate legal moves (optionally avoid reverse)\n int dirs[4], ccnt=0;\n for(int d=0; d<4; d++){\n int nr = cur_er + dr[d], nc = cur_ec + dc[d];\n if(nr<0||nr>=N||nc<0||nc>=N) continue;\n dirs[ccnt++] = d;\n }\n if(ccnt==0) break;\n\n // Evaluate all candidates and sample via softmax\n int bestIdx = 0;\n int bestScalar = INT_MIN;\n\n Eval candEv[4];\n int candScalar[4];\n\n int old_er = cur_er, old_ec = cur_ec;\n\n for(int k=0;k bestScalar){\n bestScalar = candScalar[k];\n bestIdx = k;\n }\n\n // revert\n int u = old_er*N + old_ec;\n int v = cur_er*N + cur_ec;\n swap(a[u], a[v]);\n cur_er = old_er; cur_ec = old_ec;\n }\n\n // epsilon-greedy + softmax\n int chosen = -1;\n double eps = 0.10;\n if(rng.next_double() < eps){\n chosen = rng.next_int(ccnt);\n }else{\n // softmax over candidate scalars\n double wsum = 0.0;\n double w[4];\n for(int k=0;k T) bestAns.resize(T);\n cout << bestAns << \"\\n\";\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\n\n// ---------- RNG (splitmix64) ----------\nstatic inline uint64_t splitmix64(uint64_t x) {\n x += 0x9e3779b97f4a7c15ULL;\n x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;\n x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;\n return x ^ (x >> 31);\n}\n\nstruct RNG {\n uint64_t s;\n explicit RNG(uint64_t seed=1) : s(seed) {}\n uint64_t next_u64() { return s = splitmix64(s); }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n double next_double(double l, double r) { return l + (r - l) * next_double(); }\n};\n\n// ---------- Geometry ----------\nstruct Point { int x, y; };\nstruct Line { int64 px, py, qx, qy; };\n\nstatic inline bool is_valid_line(const Line& ln) {\n auto inRange = [&](int64 v){ return -1000000000LL <= v && v <= 1000000000LL; };\n if (!inRange(ln.px) || !inRange(ln.py) || !inRange(ln.qx) || !inRange(ln.qy)) return false;\n if (ln.px == ln.qx && ln.py == ln.qy) return false;\n return true;\n}\n\nstatic inline int side_of(const Line& ln, int x, int y) {\n int64 dx = ln.qx - ln.px;\n int64 dy = ln.qy - ln.py;\n int64 ax = (int64)x - ln.px;\n int64 ay = (int64)y - ln.py;\n __int128 cross = (__int128)dx * ay - (__int128)dy * ax;\n if (cross > 0) return 1;\n if (cross < 0) return -1;\n return 0;\n}\n\nstatic inline uint64_t hash_line(const Line& ln) {\n uint64_t h = 0;\n auto mix = [&](int64 v) {\n h ^= splitmix64((uint64_t)v + 0x9e3779b97f4a7c15ULL + (h<<6) + (h>>2));\n };\n mix(ln.px); mix(ln.py); mix(ln.qx); mix(ln.qy);\n return h;\n}\n\n// squared distance criterion: C^2 <= (A^2+B^2)R^2\nstatic inline bool line_intersects_disk(const Line& ln, long double R) {\n long double x1 = (long double)ln.px, y1 = (long double)ln.py;\n long double x2 = (long double)ln.qx, y2 = (long double)ln.qy;\n long double A = y2 - y1;\n long double B = x1 - x2;\n long double C = -(A * x1 + B * y1);\n long double lhs = C * C;\n long double rhs = (A * A + B * B) * (R * R);\n return lhs < rhs;\n}\n\nstatic Line make_line_from_angle_offset(long double theta, long double offset) {\n // normal n=(cos, sin), direction d=(-sin, cos)\n long double nx = cos(theta), ny = sin(theta);\n long double dx = -sin(theta), dy = cos(theta);\n\n long double x0 = nx * offset;\n long double y0 = ny * offset;\n\n long double L = 20000.0L;\n long double x1 = x0 + dx * L, y1 = y0 + dy * L;\n long double x2 = x0 - dx * L, y2 = y0 - dy * L;\n\n Line ln;\n ln.px = llround(x1); ln.py = llround(y1);\n ln.qx = llround(x2); ln.qy = llround(y2);\n if (ln.px == ln.qx && ln.py == ln.qy) ln.qx += 1;\n return ln;\n}\n\n// ---------- Flat hash table (key->count), timestamp clearing ----------\nstruct FlatHash {\n int cap, mask;\n vector keys;\n vector vals;\n vector vis;\n int stamp = 1;\n vector used;\n\n explicit FlatHash(int capPow2 = 1<<16) { init(capPow2); }\n\n void init(int capPow2) {\n cap = capPow2;\n mask = cap - 1;\n keys.assign(cap, 0);\n vals.assign(cap, 0);\n vis.assign(cap, 0);\n stamp = 1;\n used.reserve(8192);\n }\n\n inline void reset() {\n ++stamp;\n used.clear();\n if (stamp == INT_MAX) {\n fill(vis.begin(), vis.end(), 0);\n stamp = 1;\n }\n }\n\n inline int find_pos(uint64_t k) const {\n uint64_t h = k * 11995408973635179863ULL;\n int pos = (int)(h & (uint64_t)mask);\n while (vis[pos] == stamp && keys[pos] != k) pos = (pos + 1) & mask;\n return pos;\n }\n\n inline void add(uint64_t k) {\n int pos = find_pos(k);\n if (vis[pos] != stamp) {\n vis[pos] = stamp;\n keys[pos] = k;\n vals[pos] = 1;\n used.push_back(pos);\n } else {\n vals[pos]++;\n }\n }\n\n inline int get(uint64_t k) const {\n int pos = find_pos(k);\n if (vis[pos] != stamp) return 0;\n return vals[pos];\n }\n};\n\n// ---------- Scoring ----------\nstruct Score {\n int dist; // maximize\n int overflow; // minimize: sum max(0, b_d-a_d) for d<=10\n int excess; // minimize: sum max(0, size-10) over ALL regions\n int good; // maximize: number of regions with size 1..10\n};\n\nstatic inline bool better(const Score& A, const Score& B) {\n if (A.dist != B.dist) return A.dist > B.dist;\n if (A.overflow != B.overflow) return A.overflow < B.overflow;\n if (A.excess != B.excess) return A.excess < B.excess;\n return A.good > B.good;\n}\n\n// ---------- Solver ----------\nstruct Solver {\n static constexpr long double R = 10000.0L;\n\n int N, K;\n array a{};\n int totalA = 0;\n vector pts;\n\n vector key, tmpKey;\n FlatHash fh;\n\n // per-step derived\n vector largeKeys;\n array bcur{}, rem{};\n Score curScore{0,0,0,0};\n\n // time control\n chrono::steady_clock::time_point start;\n double deadlineSec = 2.75;\n\n Solver(int N_, int K_, const array& a_, vector pts_)\n : N(N_), K(K_), a(a_), pts(std::move(pts_)),\n key(N_,0), tmpKey(N_,0), fh(1<<16) {\n for (int d=1; d<=10; d++) totalA += a[d];\n largeKeys.reserve(8192);\n }\n\n inline double elapsed() const {\n return chrono::duration(chrono::steady_clock::now() - start).count();\n }\n inline bool time_up(double margin=0.0) const {\n return elapsed() > deadlineSec - margin;\n }\n\n static inline void line_masks(const Line& ln, uint64_t &posMask, uint64_t &negMask) {\n uint64_t h = hash_line(ln);\n negMask = splitmix64(h ^ 0x243f6a8885a308d3ULL);\n posMask = splitmix64(h ^ 0x9e3779b97f4a7c15ULL);\n }\n\n Score calc_score_from_keys(const vector& keys) {\n fh.reset();\n for (int i=0;i 10) excess += (sz - 10);\n if (1 <= sz && sz <= 10) { b[sz]++; good++; }\n }\n int dist=0, overflow=0;\n for (int d=1; d<=10; d++) {\n dist += min(a[d], b[d]);\n overflow += max(0, b[d] - a[d]);\n }\n return {dist, overflow, excess, good};\n }\n\n void build_current_info() {\n fh.reset();\n for (int i=0;i 10) {\n largeKeys.push_back(fh.keys[pos]);\n excess += (sz - 10);\n }\n if (1 <= sz && sz <= 10) { bcur[sz]++; good++; }\n }\n\n int dist=0, overflow=0;\n for (int d=1; d<=10; d++) {\n dist += min(a[d], bcur[d]);\n overflow += max(0, bcur[d] - a[d]);\n }\n curScore = {dist, overflow, excess, good};\n\n for (int d=1; d<=10; d++) rem[d] = max(0, a[d] - min(a[d], bcur[d]));\n }\n\n Score score_current() { build_current_info(); return curScore; }\n\n Score eval_add(const Line& ln) {\n uint64_t posMask, negMask;\n line_masks(ln, posMask, negMask);\n\n fh.reset();\n for (int i=0;i 0 ? posMask : negMask);\n fh.add(nk);\n }\n\n int b[11] = {};\n int good=0, excess=0;\n for (int pos : fh.used) {\n int sz = fh.vals[pos];\n if (sz > 10) excess += (sz - 10);\n if (1 <= sz && sz <= 10) { b[sz]++; good++; }\n }\n int dist=0, overflow=0;\n for (int d=1; d<=10; d++) {\n dist += min(a[d], b[d]);\n overflow += max(0, b[d] - a[d]);\n }\n return {dist, overflow, excess, good};\n }\n\n void apply_add(const Line& ln) {\n uint64_t posMask, negMask;\n line_masks(ln, posMask, negMask);\n for (int i=0;i 0 ? posMask : negMask);\n }\n }\n\n int sample_index_with_key(uint64_t k, RNG& rng) const {\n for (int t=0; t<150; t++) {\n int i = rng.next_int(0, N-1);\n if (key[i] == k) return i;\n }\n return rng.next_int(0, N-1);\n }\n\n // weighted by rem[d]*d^2, but if S<=20 prefer splits where both sides <=10\n int pick_target_size_for_region(int S, RNG& rng) const {\n long long sum = 0;\n long long bonusSum = 0;\n bool hasBonus = false;\n\n if (S <= 20) {\n int lo = max(1, S - 10);\n int hi = min(10, S - 1);\n for (int d=lo; d<=hi; d++) {\n if (rem[d] > 0) {\n hasBonus = true;\n bonusSum += 1LL * rem[d] * d * d;\n }\n }\n }\n if (hasBonus) {\n long long r = 1 + (long long)(rng.next_u64() % (uint64_t)bonusSum);\n int lo = max(1, S - 10), hi = min(10, S - 1);\n for (int d=lo; d<=hi; d++) {\n long long w = 1LL * rem[d] * d * d;\n if (w == 0) continue;\n r -= w;\n if (r <= 0) return d;\n }\n }\n\n for (int d=1; d<=10; d++) sum += 1LL * rem[d] * d * d;\n if (sum == 0) return min(10, max(1, S/2));\n long long r = 1 + (long long)(rng.next_u64() % (uint64_t)sum);\n for (int d=1; d<=10; d++) {\n r -= 1LL * rem[d] * d * d;\n if (r <= 0) return d;\n }\n return 5;\n }\n\n long double estimate_major_axis_angle(const vector& idxs) const {\n if ((int)idxs.size() < 6) return nanl(\"\");\n long double mx=0, my=0;\n for (int id : idxs) { mx += pts[id].x; my += pts[id].y; }\n mx /= (long double)idxs.size();\n my /= (long double)idxs.size();\n\n long double a=0, b=0, c=0;\n for (int id : idxs) {\n long double dx = (long double)pts[id].x - mx;\n long double dy = (long double)pts[id].y - my;\n a += dx*dx;\n b += dx*dy;\n c += dy*dy;\n }\n long double phi = 0.5L * atan2l(2*b, a - c);\n if (phi < 0) phi += acosl(-1.0L);\n return phi;\n }\n\n // demand-aware candidate generator\n bool gen_candidate(Line& out, RNG& rng) {\n for (int it=0; it<42; it++) {\n int mode = rng.next_int(0, 99);\n long double theta = rng.next_double(0.0, acosl(-1.0L));\n long double offset = 0;\n\n if (mode < 28) {\n offset = rng.next_double(-0.98*R, 0.98*R);\n } else if (mode < 46) {\n const auto& p = pts[rng.next_int(0, N-1)];\n long double nx = cos(theta), ny = sin(theta);\n long double base = nx * (long double)p.x + ny * (long double)p.y;\n offset = base + rng.next_double(-1200.0, 1200.0);\n offset = max(-0.98L*R, min(0.98L*R, offset));\n } else if (mode < 56) {\n const auto& p = pts[rng.next_int(0, N-1)];\n const auto& q = pts[rng.next_int(0, N-1)];\n long double dx = (long double)q.x - (long double)p.x;\n long double dy = (long double)q.y - (long double)p.y;\n long double len = sqrt(dx*dx + dy*dy);\n if (len < 1e-9) continue;\n long double nx = dx / len, ny = dy / len;\n theta = atan2(ny, nx);\n long double mx = 0.5L * ((long double)p.x + (long double)q.x);\n long double my = 0.5L * ((long double)p.y + (long double)q.y);\n offset = nx * mx + ny * my + rng.next_double(-600.0, 600.0);\n offset = max(-0.98L*R, min(0.98L*R, offset));\n } else {\n if (largeKeys.empty()) continue;\n uint64_t k = largeKeys[rng.next_int(0, (int)largeKeys.size()-1)];\n int S = fh.get(k);\n if (S <= 10) continue;\n\n int tsize = pick_target_size_for_region(S, rng);\n long double frac = (long double)tsize / (long double)S;\n frac = max((long double)1.0L / (long double)S, min((long double)0.92L, frac));\n\n int m = min(80, S);\n vector idxs;\n idxs.reserve(m);\n for (int j=0; j= acosl(-1.0L)) phi -= acosl(-1.0L);\n }\n\n long double nx = cos(phi), ny = sin(phi);\n vector proj;\n proj.reserve(m);\n for (int id : idxs) proj.push_back(nx * (long double)pts[id].x + ny * (long double)pts[id].y);\n\n int qpos = (int)floor(frac * (m - 1));\n nth_element(proj.begin(), proj.begin() + qpos, proj.end());\n long double th = proj[qpos];\n\n offset = th + rng.next_double(-130.0, 130.0);\n theta = phi;\n offset = max(-0.98L*R, min(0.98L*R, offset));\n }\n\n Line ln = make_line_from_angle_offset(theta, offset);\n if (!is_valid_line(ln)) continue;\n if (!line_intersects_disk(ln, R)) continue;\n out = ln;\n return true;\n }\n return false;\n }\n\n bool gen_perturb(const Line& base, Line& out, RNG& rng) {\n long double dx = (long double)base.qx - (long double)base.px;\n long double dy = (long double)base.qy - (long double)base.py;\n long double nx = dy, ny = -dx;\n long double len = hypot(nx, ny);\n if (len < 1e-12) return false;\n nx /= len; ny /= len;\n long double baseOffset = nx * (long double)base.px + ny * (long double)base.py;\n long double theta = atan2(ny, nx);\n if (theta < 0) theta += acosl(-1.0L);\n\n theta += rng.next_double(-0.10, 0.10);\n if (theta < 0) theta += acosl(-1.0L);\n if (theta >= acosl(-1.0L)) theta -= acosl(-1.0L);\n\n long double offset = baseOffset + rng.next_double(-260.0, 260.0);\n offset = max(-0.98L*R, min(0.98L*R, offset));\n\n Line ln = make_line_from_angle_offset(theta, offset);\n if (!is_valid_line(ln)) return false;\n if (!line_intersects_disk(ln, R)) return false;\n out = ln;\n return true;\n }\n\n // Constructive SA with best prefix\n vector construct(RNG& rng, int kTarget, int candPerStep) {\n fill(key.begin(), key.end(), 0);\n vector lines;\n lines.reserve(kTarget);\n\n Score cur = score_current();\n Score bestPref = cur;\n int bestLen = 0;\n\n const double T0 = 2.0, T1 = 0.25;\n\n for (int step=0; step= 0) accept = true;\n else {\n double prob = exp(delta / max(1e-9, T));\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n lines.push_back(bestLn);\n apply_add(bestLn);\n if (better(bestSc, bestPref)) {\n bestPref = bestSc;\n bestLen = (int)lines.size();\n if (bestPref.dist == totalA) break;\n }\n }\n }\n\n lines.resize(bestLen);\n return lines;\n }\n\n // Rebuild key[] from line set, also masks\n bool rebuild_from_lines(const vector& lines, vector& posM, vector& negM) {\n fill(key.begin(), key.end(), 0);\n posM.resize(lines.size());\n negM.resize(lines.size());\n for (size_t j=0; j 0 ? posM[j] : negM[j]);\n }\n key[i] = k;\n }\n return true;\n }\n\n // Variable-k SA: replace/add/remove\n vector improve_lines_varK(vector lines, RNG& rng) {\n vector posM, negM;\n if (!rebuild_from_lines(lines, posM, negM)) return lines;\n\n Score cur = score_current();\n vector bestLines = lines;\n Score best = cur;\n\n const double T0 = 1.2, T1 = 0.08;\n\n int iters = 0;\n while (!time_up(0.06)) {\n iters++;\n if (iters % 6 == 0) build_current_info(); // refresh generator state\n\n double t = min(1.0, elapsed() / max(1e-9, deadlineSec));\n double T = T0 * pow(T1 / T0, t);\n\n int k = (int)lines.size();\n int moveRoll = rng.next_int(0, 99);\n\n // Decide move type\n enum {REPL, ADD, REM} move = REPL;\n if (moveRoll < 55) move = REPL;\n else if (moveRoll < 80) move = ADD;\n else move = REM;\n\n if (move == ADD && k >= K) move = REPL;\n if (move == REM && k <= 1) move = REPL;\n\n Score nxt{-1000000000,1000000000,1000000000,-1000000000};\n bool ok = false;\n int idx = -1;\n Line candLine{};\n\n if (move == REPL) {\n idx = rng.next_int(0, k-1);\n bool genok = false;\n if (rng.next_int(0,99) < 50) genok = gen_perturb(lines[idx], candLine, rng);\n if (!genok) genok = gen_candidate(candLine, rng);\n if (!genok) continue;\n\n uint64_t newPos, newNeg;\n line_masks(candLine, newPos, newNeg);\n\n const Line& old = lines[idx];\n uint64_t oldPos = posM[idx], oldNeg = negM[idx];\n\n for (int i=0;i 0 ? oldPos : oldNeg);\n uint64_t nc = (sn > 0 ? newPos : newNeg);\n tmpKey[i] = key[i] ^ oc ^ nc;\n }\n nxt = calc_score_from_keys(tmpKey);\n ok = true;\n\n // accept?\n {\n int dDist = nxt.dist - cur.dist;\n int dGood = nxt.good - cur.good;\n int dOv = nxt.overflow - cur.overflow;\n int dEx = nxt.excess - cur.excess;\n double delta = (double)dDist + 0.02*(double)dGood - 0.03*(double)dOv - 0.008*(double)dEx;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.next_double() < exp(delta / max(1e-9, T))) accept = true;\n\n if (accept) {\n lines[idx] = candLine;\n posM[idx] = newPos;\n negM[idx] = newNeg;\n key.swap(tmpKey);\n cur = nxt;\n if (better(cur, best)) { best = cur; bestLines = lines; }\n }\n }\n } else if (move == ADD) {\n bool genok = gen_candidate(candLine, rng);\n if (!genok) continue;\n\n uint64_t newPos, newNeg;\n line_masks(candLine, newPos, newNeg);\n\n for (int i=0;i 0 ? newPos : newNeg);\n tmpKey[i] = key[i] ^ nc;\n }\n nxt = calc_score_from_keys(tmpKey);\n ok = true;\n\n {\n int dDist = nxt.dist - cur.dist;\n int dGood = nxt.good - cur.good;\n int dOv = nxt.overflow - cur.overflow;\n int dEx = nxt.excess - cur.excess;\n // slight penalty for more cuts (avoid useless over-splitting)\n double delta = (double)dDist + 0.02*(double)dGood - 0.03*(double)dOv - 0.008*(double)dEx - 0.002;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.next_double() < exp(delta / max(1e-9, T))) accept = true;\n\n if (accept) {\n lines.push_back(candLine);\n posM.push_back(newPos);\n negM.push_back(newNeg);\n key.swap(tmpKey);\n cur = nxt;\n if (better(cur, best)) { best = cur; bestLines = lines; }\n }\n }\n } else { // REM\n idx = rng.next_int(0, k-1);\n const Line& old = lines[idx];\n uint64_t oldPos = posM[idx], oldNeg = negM[idx];\n\n for (int i=0;i 0 ? oldPos : oldNeg);\n tmpKey[i] = key[i] ^ oc;\n }\n nxt = calc_score_from_keys(tmpKey);\n ok = true;\n\n {\n int dDist = nxt.dist - cur.dist;\n int dGood = nxt.good - cur.good;\n int dOv = nxt.overflow - cur.overflow;\n int dEx = nxt.excess - cur.excess;\n // small bonus for fewer cuts\n double delta = (double)dDist + 0.02*(double)dGood - 0.03*(double)dOv - 0.008*(double)dEx + 0.002;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.next_double() < exp(delta / max(1e-9, T))) accept = true;\n\n if (accept) {\n lines.erase(lines.begin() + idx);\n posM.erase(posM.begin() + idx);\n negM.erase(negM.begin() + idx);\n key.swap(tmpKey);\n cur = nxt;\n if (better(cur, best)) { best = cur; bestLines = lines; }\n }\n }\n }\n\n NEXT_ITER:\n (void)ok;\n }\n\n return bestLines;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n cin >> N >> K;\n array a{};\n for (int d=1; d<=10; d++) cin >> a[d];\n vector pts(N);\n for (int i=0;i> pts[i].x >> pts[i].y;\n\n uint64_t seed = 123456789ULL;\n seed ^= splitmix64((uint64_t)N * 1009 + (uint64_t)K);\n for (int d=1; d<=10; d++) seed ^= splitmix64((uint64_t)a[d] * (d*10007ULL));\n for (int i=0;i bestLines;\n Score bestScore{-1, 1000000000, 1000000000, -1};\n\n // Phase 1: multi-restart constructive\n int restart = 0;\n while (!solver.time_up(0.55) && restart < 45) {\n RNG rng(seed ^ splitmix64((uint64_t)restart * 1000003ULL));\n auto lines = solver.construct(rng, kTarget, CAND_PER_STEP);\n\n // score (rebuild keys by applying)\n fill(solver.key.begin(), solver.key.end(), 0);\n for (auto &ln : lines) solver.apply_add(ln);\n Score sc = solver.score_current();\n\n if (better(sc, bestScore)) {\n bestScore = sc;\n bestLines = std::move(lines);\n if (bestScore.dist == totalA) break;\n }\n restart++;\n }\n\n // Phase 2: local improvement with variable k (replace/add/remove)\n if (!solver.time_up(0.06) && !bestLines.empty()) {\n RNG rng(seed ^ 0x9b2d3c4f5a6b7c8dULL);\n bestLines = solver.improve_lines_varK(bestLines, rng);\n }\n\n cout << bestLines.size() << \"\\n\";\n for (auto &ln : bestLines) {\n cout << ln.px << \" \" << ln.py << \" \" << ln.qx << \" \" << ln.qy << \"\\n\";\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Pt{ int x,y; };\nstatic inline int sgn(int a){ return (a>0) - (a<0); }\nstatic inline uint64_t rangeMask(int l,int r){\n if(l>r) return 0ULL;\n uint64_t len = (uint64_t)(r-l+1);\n if(len>=64) return ~0ULL;\n return ((1ULL< deterministic only)\n int topT; // sample range among top-weight points\n int diagLim; // diagonal candidates per direction\n bool enableDiag;\n uint32_t seed;\n};\n\nstruct State{\n int N,c;\n vector> dot;\n vector rowMask, colMask;\n\n vector hUsed; // y, bit x: (x,y)-(x+1,y)\n vector vUsed; // x, bit y: (x,y)-(x,y+1)\n vector d1Used;// lowY, bit lowX: (lowX,lowY)-(lowX+1,lowY+1)\n vector d2Used;// lowY, bit lowX: (lowX,lowY+1)-(lowX+1,lowY)\n\n vector> W;\n long long sumW=0;\n vector> ops;\n\n State(){}\n State(int N_): N(N_){\n c=(N-1)/2;\n dot.assign(N, vector(N,0));\n rowMask.assign(N,0);\n colMask.assign(N,0);\n hUsed.assign(N,0);\n vUsed.assign(N,0);\n d1Used.assign(max(0,N-1),0);\n d2Used.assign(max(0,N-1),0);\n W.assign(N, vector(N,1));\n for(int x=0;x{p1.x,p1.y,p2.x,p2.y,p3.x,p3.y,p4.x,p4.y});\n }\n\n // nearest set bits around pos (mix left/right)\n static vector nearestBits(uint64_t mask, int pos, int LIM){\n vector res;\n res.reserve(LIM);\n mask &= ~(1ULL<=0 && xr>=0){\n if(pos-xl <= xr-pos){\n res.push_back(xl);\n left &= ~(1ULL<=0){\n res.push_back(xl);\n left &= ~(1ULL< collectDiag(Pt p, int dx, int dy, int LIM) const{\n vector res;\n res.reserve(LIM);\n for(int step=1; (int)res.size()& outOp) const{\n if(dot[p1.x][p1.y]) return false;\n\n vector xs = nearestBits(rowMask[p1.y], p1.x, LIM);\n vector ys = nearestBits(colMask[p1.x], p1.y, LIM);\n\n bool found=false;\n int bestPerim = INT_MAX;\n array best{};\n\n auto upd = [&](Pt p2, Pt p3, Pt p4){\n if(!validRect(p1,p2,p3,p4)) return;\n int perim = edgeLen(p1,p2)+edgeLen(p2,p3)+edgeLen(p3,p4)+edgeLen(p4,p1);\n if(perim < bestPerim){\n bestPerim = perim;\n best = array{p1.x,p1.y,p2.x,p2.y,p3.x,p3.y,p4.x,p4.y};\n found = true;\n }\n };\n\n // axis-aligned\n for(int x2: xs){\n Pt p2{x2,p1.y};\n for(int y4: ys){\n if(x2==p1.x || y4==p1.y) continue;\n Pt p4{p1.x,y4};\n Pt p3{x2,y4};\n if(!inside(p3.x,p3.y)) continue;\n if(!dot[p3.x][p3.y]) continue;\n upd(p2,p3,p4);\n }\n }\n\n // diagonal\n if(enableDiag && diagLim>0){\n vector dp, dm;\n auto a = collectDiag(p1, 1, 1, diagLim);\n auto b = collectDiag(p1,-1,-1, diagLim);\n dp.reserve(a.size()+b.size());\n dp.insert(dp.end(), a.begin(), a.end());\n dp.insert(dp.end(), b.begin(), b.end());\n\n auto c = collectDiag(p1, 1,-1, diagLim);\n auto d = collectDiag(p1,-1, 1, diagLim);\n dm.reserve(c.size()+d.size());\n dm.insert(dm.end(), c.begin(), c.end());\n dm.insert(dm.end(), d.begin(), d.end());\n\n for(const auto& p2: dp){\n for(const auto& p4: dm){\n Pt p3{p2.x + p4.x - p1.x, p2.y + p4.y - p1.y};\n if(!inside(p3.x,p3.y)) continue;\n if(!dot[p3.x][p3.y]) continue;\n upd(p2,p3,p4);\n }\n }\n }\n\n if(found) outOp = best;\n return found;\n }\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 State base(N);\n for(int i=0;i> x >> y;\n base.dot[x][y]=1;\n base.rowMask[y] |= (1ULL< order;\n order.reserve(N*N);\n for(int x=0;xwb;\n if(a.x!=b.x) return a.x confs = {\n {4, 0, 1, 4, true, 1}, // baseline-like (should match your best)\n {6, 40, 800, 4, true, 1234567u}, // mild random help\n {8, 60, 900, 5, true, 89101112u}, // broader\n };\n\n long long bestSumW = -1;\n vector> bestOps;\n\n for(int rid=0; rid<(int)confs.size(); rid++){\n double elapsed = chrono::duration(chrono::steady_clock::now()-start).count();\n if(elapsed > TL) break;\n int rem = (int)confs.size() - rid;\n double runLimit = elapsed + (TL - elapsed) * (1.0 / rem);\n\n RunConf rc = confs[rid];\n mt19937 rng(rc.seed);\n\n State s = base;\n\n int ptr = 0; // deterministic scan pointer\n int topT = min(rc.topT, (int)order.size());\n if(topT <= 0) topT = 1;\n\n while(true){\n double tnow = chrono::duration(chrono::steady_clock::now()-start).count();\n if(tnow > runLimit) break;\n\n bool found = false;\n array chosen{};\n\n // 1) random sampling tries to find a move quickly\n if(rc.sampleS > 0){\n for(int it=0; it op;\n if(s.findMoveForP1(p1, rc.LIM, rc.diagLim, rc.enableDiag, op)){\n chosen = op;\n found = true;\n break; // take first found (keep it cheap & robust)\n }\n }\n }\n\n // 2) guaranteed-progress fallback: deterministic scan (the key fix)\n if(!found){\n int tried = 0;\n while(tried < (int)order.size()){\n Pt p1 = order[ptr];\n ptr++; if(ptr==(int)order.size()) ptr=0;\n tried++;\n if(s.dot[p1.x][p1.y]) continue;\n array op;\n if(s.findMoveForP1(p1, rc.LIM, rc.diagLim, rc.enableDiag, op)){\n chosen = op;\n found = true;\n break;\n }\n }\n }\n\n if(!found) break;\n\n Pt P1{chosen[0],chosen[1]}, P2{chosen[2],chosen[3]}, P3{chosen[4],chosen[5]}, P4{chosen[6],chosen[7]};\n if(!s.validRect(P1,P2,P3,P4)) continue; // safety\n s.applyRect(P1,P2,P3,P4);\n }\n\n if(s.sumW > bestSumW){\n bestSumW = s.sumW;\n bestOps = move(s.ops);\n }\n }\n\n cout << bestOps.size() << \"\\n\";\n for(const auto &a: bestOps){\n for(int i=0;i<8;i++){\n if(i) cout << ' ';\n cout << a[i];\n }\n cout << \"\\n\";\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstatic constexpr int H = 10, W = 10, C = 100;\n\nstruct XorShift {\n uint64_t x;\n explicit XorShift(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline uint32_t nextU32() { return (uint32_t)(nextU64() >> 32); }\n};\n\nstruct State {\n array a{}; // 0 empty, 1..3\n\n inline uint8_t at(int y, int x) const { return a[y * W + x]; }\n inline uint8_t& at(int y, int x) { return a[y * W + x]; }\n\n void clear() { a.fill(0); }\n\n void placeByP(int p, uint8_t f) {\n int cnt = 0;\n for (int i = 0; i < C; i++) {\n if (a[i] == 0) {\n if (++cnt == p) { a[i] = f; return; }\n }\n }\n }\n\n inline void tiltInPlace(char dir) {\n if (dir == 'L') {\n for (int y = 0; y < H; y++) {\n uint8_t tmp[W]; int k = 0;\n int base = y * W;\n for (int x = 0; x < W; x++) if (a[base + x]) tmp[k++] = a[base + x];\n for (int x = 0; x < W; x++) a[base + x] = 0;\n for (int x = 0; x < k; x++) a[base + x] = tmp[x];\n }\n } else if (dir == 'R') {\n for (int y = 0; y < H; y++) {\n uint8_t tmp[W]; int k = 0;\n int base = y * W;\n for (int x = 0; x < W; x++) if (a[base + x]) tmp[k++] = a[base + x];\n for (int x = 0; x < W; x++) a[base + x] = 0;\n for (int i = 0; i < k; i++) a[base + (W - k + i)] = tmp[i];\n }\n } else if (dir == 'F') { // to smaller y\n for (int x = 0; x < W; x++) {\n uint8_t tmp[H]; int k = 0;\n for (int y = 0; y < H; y++) {\n uint8_t v = a[y * W + x];\n if (v) tmp[k++] = v;\n }\n for (int y = 0; y < H; y++) a[y * W + x] = 0;\n for (int y = 0; y < k; y++) a[y * W + x] = tmp[y];\n }\n } else { // 'B' to larger y\n for (int x = 0; x < W; x++) {\n uint8_t tmp[H]; int k = 0;\n for (int y = 0; y < H; y++) {\n uint8_t v = a[y * W + x];\n if (v) tmp[k++] = v;\n }\n for (int y = 0; y < H; y++) a[y * W + x] = 0;\n for (int i = 0; i < k; i++) a[(H - k + i) * W + x] = tmp[i];\n }\n }\n }\n\n inline State afterTilt(char dir) const {\n State s = *this;\n s.tiltInPlace(dir);\n return s;\n }\n\n inline int emptyCount() const {\n int m = 0;\n for (int i = 0; i < C; i++) if (a[i] == 0) m++;\n return m;\n }\n\n // choose idx-th empty (0-indexed) in scan order\n inline int chooseEmptyByIndex(int idx) const {\n for (int i = 0; i < C; i++) {\n if (a[i] == 0) {\n if (idx == 0) return i;\n idx--;\n }\n }\n return -1;\n }\n};\n\nstatic inline int componentSumSq(const State& s) {\n bool vis[C];\n memset(vis, 0, sizeof(vis));\n int sumsq = 0;\n int q[C];\n\n for (int i = 0; i < C; i++) {\n if (s.a[i] == 0 || vis[i]) continue;\n uint8_t f = s.a[i];\n int head = 0, tail = 0;\n vis[i] = true;\n q[tail++] = i;\n int cnt = 0;\n while (head < tail) {\n int v = q[head++];\n cnt++;\n int y = v / W, x = v % W;\n if (y > 0) {\n int u = v - W;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (y + 1 < H) {\n int u = v + W;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (x > 0) {\n int u = v - 1;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (x + 1 < W) {\n int u = v + 1;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n }\n sumsq += cnt * cnt;\n }\n return sumsq;\n}\n\n// Stable mixing-averse heuristic (label-invariant)\nstruct CheapEval {\n double wSame = 2.2;\n double wDiff = 2.0;\n double wVar = 0.045;\n double wSep = 0.28;\n\n double operator()(const State& s) const {\n int adjSame = 0, adjDiff = 0;\n for (int y = 0; y < H; y++) for (int x = 0; x < W; x++) {\n uint8_t f = s.at(y, x);\n if (!f) continue;\n if (x + 1 < W) {\n uint8_t g = s.at(y, x + 1);\n if (g) (g == f ? adjSame : adjDiff)++;\n }\n if (y + 1 < H) {\n uint8_t g = s.at(y + 1, x);\n if (g) (g == f ? adjSame : adjDiff)++;\n }\n }\n\n double cnt[4] = {0,0,0,0};\n double sx[4] = {0,0,0,0}, sy[4] = {0,0,0,0};\n double sx2[4] = {0,0,0,0}, sy2[4] = {0,0,0,0};\n\n for (int y = 0; y < H; y++) for (int x = 0; x < W; x++) {\n uint8_t f = s.at(y, x);\n if (!f) continue;\n cnt[f] += 1.0;\n sx[f] += x; sy[f] += y;\n sx2[f] += 1.0 * x * x;\n sy2[f] += 1.0 * y * y;\n }\n\n double ax[4] = {0,0,0,0}, ay[4] = {0,0,0,0};\n for (int f = 1; f <= 3; f++) if (cnt[f] > 0) {\n ax[f] = sx[f] / cnt[f];\n ay[f] = sy[f] / cnt[f];\n }\n\n double varSum = 0.0;\n for (int f = 1; f <= 3; f++) if (cnt[f] > 0) {\n double ex = ax[f], ey = ay[f];\n varSum += (sx2[f] - cnt[f]*ex*ex) + (sy2[f] - cnt[f]*ey*ey);\n }\n\n double sep = 0.0;\n for (int i = 1; i <= 3; i++) for (int j = i+1; j <= 3; j++) {\n if (cnt[i] == 0 || cnt[j] == 0) continue;\n double dx = ax[i] - ax[j];\n double dy = ay[i] - ay[j];\n sep += dx*dx + dy*dy;\n }\n\n return wSame * adjSame - wDiff * adjDiff - wVar * varSum + wSep * sep;\n }\n};\n\n// Coupled truncated rollout with terminal evaluation\nstatic double rolloutCoupledTrunc(State s, int tNext, const array& f,\n const CheapEval& cev,\n const uint32_t* rPos, const uint32_t* rAct,\n int K, double alpha) {\n static constexpr array DIRS = {'F','B','L','R'};\n constexpr double eps = 0.05;\n const uint32_t TH = (uint32_t)(eps * 4294967296.0); // choose 2nd best sometimes\n\n for (int step = 0; step < K; step++) {\n int t = tNext + step;\n\n int m = s.emptyCount();\n if (m == 0) break;\n\n int idx = (int)(((uint64_t)rPos[step] * (uint64_t)m) >> 32);\n int pos = s.chooseEmptyByIndex(idx);\n s.a[pos] = (uint8_t)f[t];\n\n double bestV = -1e100, secondV = -1e100;\n char bestD = 'L', secondD = 'L';\n for (char d : DIRS) {\n State ns = s.afterTilt(d);\n double v = cev(ns);\n if (v > bestV) {\n secondV = bestV; secondD = bestD;\n bestV = v; bestD = d;\n } else if (v > secondV) {\n secondV = v; secondD = d;\n }\n }\n\n char chosen = (rAct[step] < TH ? secondD : bestD);\n s.tiltInPlace(chosen);\n }\n\n return (double)componentSumSq(s) + alpha * cev(s);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n array f{};\n for (int t = 1; t <= 100; t++) {\n if (!(cin >> f[t])) return 0;\n }\n\n uint64_t seed = 1469598103934665603ULL;\n for (int t = 1; t <= 100; t++) seed = (seed ^ (uint64_t)f[t]) * 1099511628211ULL;\n XorShift rng(seed);\n\n State cur;\n cur.clear();\n CheapEval cev;\n static constexpr array DIRS = {'F','B','L','R'};\n\n uint32_t rPos[100], rAct[100];\n\n auto timeStart = chrono::high_resolution_clock::now();\n const double TL = 1.96;\n\n for (int t = 1; t <= 100; t++) {\n int p;\n cin >> p;\n cur.placeByP(p, (uint8_t)f[t]);\n\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - timeStart).count();\n double remaining = max(0.0, TL - elapsed);\n int stepsLeft = max(1, 101 - t);\n\n double alloc = remaining * 0.90 / stepsLeft;\n alloc = min(alloc, 0.070);\n alloc = max(alloc, 0.001);\n\n auto deadline = now + chrono::duration(alloc);\n\n array cand;\n array baseH{};\n array ccNow{};\n for (int i = 0; i < 4; i++) {\n cand[i] = cur.afterTilt(DIRS[i]);\n baseH[i] = cev(cand[i]);\n ccNow[i] = componentSumSq(cand[i]);\n }\n\n if (t == 100) {\n int bestI = 0;\n double bestScore = -1e100;\n for (int i = 0; i < 4; i++) {\n double score = (double)ccNow[i] + 0.15 * baseH[i];\n if (score > bestScore) bestScore = score, bestI = i;\n }\n char out = DIRS[bestI];\n cout << out << \"\\n\" << flush;\n cur = cand[bestI];\n continue;\n }\n\n int L = 100 - t;\n\n int K;\n if (L >= 70) K = 34;\n else if (L >= 50) K = 42;\n else if (L >= 30) K = 52;\n else K = L;\n\n // adaptive terminal weight: larger when we truncate more\n double truncRatio = (L > 0 ? (double)(L - K) / (double)L : 0.0); // 0..1\n double alpha = 3.0 + 6.0 * truncRatio; // [3,9]\n\n long long samples = 0;\n array sum{};\n while (chrono::high_resolution_clock::now() < deadline) {\n for (int k = 0; k < K; k++) {\n rPos[k] = rng.nextU32();\n rAct[k] = rng.nextU32();\n }\n for (int i = 0; i < 4; i++) {\n sum[i] += rolloutCoupledTrunc(cand[i], t + 1, f, cev, rPos, rAct, K, alpha);\n }\n samples++;\n }\n\n int bestI = 0;\n double bestScore = -1e100;\n for (int i = 0; i < 4; i++) {\n double mean = samples ? sum[i] / (double)samples : -1e100;\n // small stabilizers only (avoid overriding MC)\n double score = mean + 0.35 * baseH[i] + 0.01 * (double)ccNow[i];\n if (score > bestScore) bestScore = score, bestI = i;\n }\n\n char out = DIRS[bestI];\n cout << out << \"\\n\" << flush;\n cur = cand[bestI];\n }\n\n return 0;\n}","ahc016":"#include \n#include \nusing namespace std;\n\nstruct Adj100 {\n array w{};\n};\n\nstatic inline void set_edge(vector& adj, int u, int v) {\n adj[u].w[v >> 6] |= 1ULL << (v & 63);\n adj[v].w[u >> 6] |= 1ULL << (u & 63);\n}\nstatic inline bool has_edge(const vector& adj, int u, int v) {\n return (adj[u].w[v >> 6] >> (v & 63)) & 1ULL;\n}\nstatic inline int popcnt2(const array& a) {\n return __builtin_popcountll(a[0]) + __builtin_popcountll(a[1]);\n}\nstatic inline int popcnt_and2(const array& a, const array& b) {\n return __builtin_popcountll(a[0] & b[0]) + __builtin_popcountll(a[1] & b[1]);\n}\n\nstatic vector string_to_adj(const string& s, int N) {\n vector adj(N);\n int idx = 0;\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++) {\n if (s[idx++] == '1') set_edge(adj, i, j);\n }\n return adj;\n}\nstatic string adj_to_string(const vector& adj, int N) {\n string s;\n s.reserve((size_t)N * (N - 1) / 2);\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++)\n s.push_back(has_edge(adj, i, j) ? '1' : '0');\n return s;\n}\n\nstruct ObsStats {\n long long m = 0;\n long long tri = 0;\n vector deg;\n vector triDeg; // #triangles incident to each vertex\n};\n\nstatic ObsStats analyze_observed(const vector& adj, int N) {\n ObsStats res;\n res.deg.assign(N, 0);\n res.triDeg.assign(N, 0);\n\n long long sum_deg = 0;\n for (int i = 0; i < N; i++) {\n int d = popcnt2(adj[i].w);\n res.deg[i] = d;\n sum_deg += d;\n }\n res.m = sum_deg / 2;\n\n // Per-vertex triangle count: T_v = (#edges among neighbors of v)\n for (int v = 0; v < N; v++) {\n long long acc = 0;\n for (int u = 0; u < N; u++) if (u != v && has_edge(adj, v, u)) {\n acc += popcnt_and2(adj[v].w, adj[u].w);\n }\n res.triDeg[v] = (int)(acc / 2);\n }\n long long sumTv = 0;\n for (int v = 0; v < N; v++) sumTv += res.triDeg[v];\n res.tri = sumTv / 3;\n return res;\n}\n\nstatic vector build_graph(int N, int hubSize, const vector& smallSizes, int mask) {\n vector adj(N);\n int B = (int)smallSizes.size();\n vector start(B + 1, 0);\n start[0] = hubSize;\n for (int i = 0; i < B; i++) start[i + 1] = start[i] + smallSizes[i];\n\n auto add_clique = [&](int L, int R) {\n for (int i = L; i < R; i++) for (int j = i + 1; j < R; j++) set_edge(adj, i, j);\n };\n\n add_clique(0, hubSize);\n for (int i = 0; i < B; i++) add_clique(start[i], start[i + 1]);\n\n for (int i = 0; i < B; i++) if ((mask >> i) & 1) {\n for (int u = 0; u < hubSize; u++)\n for (int v = start[i]; v < start[i + 1]; v++)\n set_edge(adj, u, v);\n }\n return adj;\n}\n\nstatic vector eigenvalues_asc(const Eigen::MatrixXd& M) {\n Eigen::SelfAdjointEigenSolver es(M, /*computeEigenvectors=*/false);\n Eigen::VectorXd ev = es.eigenvalues(); // ascending\n vector vals(ev.size());\n for (int i = 0; i < (int)ev.size(); i++) vals[i] = ev[i];\n return vals;\n}\n\nstatic double spectral_distance_extremes(const vector& aAsc, const vector& bAsc, int L) {\n int N = (int)aAsc.size();\n L = min(L, N / 2);\n double dist = 0.0;\n for (int i = 0; i < L; i++) {\n double d = aAsc[i] - bAsc[i];\n dist += d * d;\n }\n for (int i = 0; i < L; i++) {\n int ia = N - 1 - i;\n int ib = N - 1 - i;\n double d = aAsc[ia] - bAsc[ib];\n dist += d * d;\n }\n return dist / max(1, 2 * L);\n}\n\nstruct Proto {\n vector mu_sorted_deg; // E[deg] sorted\n vector mu_sorted_trideg; // E[triangle-degree] sorted\n double Em = 0.0; // E[edge count]\n double Etri = 0.0; // E[triangle count]\n double VarTri = 1.0; // approx variance for triangles\n vector eigA_asc; // eigenvalues of original adjacency\n};\n\nstatic vector choose_masks_greedy(int M, const vector& bitW) {\n int B = (int)bitW.size();\n int ALL = 1 << B;\n\n auto distW = [&](int a, int b) -> double {\n int x = a ^ b;\n double s = 0.0;\n for (int i = 0; i < B; i++) if ((x >> i) & 1) s += bitW[i];\n return s;\n };\n\n vector masks;\n masks.reserve(M);\n vector used(ALL, 0);\n\n // Start from 0; could be randomized but deterministic is fine.\n masks.push_back(0);\n used[0] = 1;\n\n for (int t = 1; t < M; t++) {\n int best = -1;\n double bestMin = -1.0;\n for (int cand = 0; cand < ALL; cand++) if (!used[cand]) {\n double mn = 1e100;\n for (int sel : masks) mn = min(mn, distW(cand, sel));\n if (mn > bestMin) {\n bestMin = mn;\n best = cand;\n }\n }\n if (best < 0) best = t; // fallback\n used[best] = 1;\n masks.push_back(best);\n }\n return masks;\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 int N;\n if (eps <= 0.15) N = 60;\n else if (eps <= 0.25) N = 80;\n else N = 100;\n\n vector smallSizes = {3,4,5,6,7,8,9}; // 7 bits => 128 patterns\n int sumSmall = accumulate(smallSizes.begin(), smallSizes.end(), 0);\n int hubSize = N - sumSmall;\n if (hubSize < 4) { N = 100; hubSize = N - sumSmall; }\n\n const int B = (int)smallSizes.size();\n\n // Choose codewords (masks) with large weighted Hamming distance\n vector bitW(B);\n for (int i = 0; i < B; i++) bitW[i] = (double)hubSize * (double)smallSizes[i];\n vector maskOfK = choose_masks_greedy(M, bitW);\n\n // constants for scoring\n const double p1 = 1.0 - eps;\n const double p0 = eps;\n const double scale = 1.0 - 2.0 * eps;\n const double degOffset = eps * (N - 1);\n const double sigma2_deg = (N - 1) * eps * (1.0 - eps) + 1e-9;\n const double Tedges = 1.0 * N * (N - 1) / 2.0;\n const double var_m = Tedges * eps * (1.0 - eps) + 1e-9;\n\n vector prot(M);\n\n cout << N << \"\\n\";\n for (int k = 0; k < M; k++) {\n int mask = maskOfK[k];\n auto G = build_graph(N, hubSize, smallSizes, mask);\n cout << adj_to_string(G, N) << \"\\n\";\n\n // Degrees and edge count in original graph\n vector deg0(N, 0);\n vector> neigh(N);\n long long sumdeg0 = 0;\n for (int v = 0; v < N; v++) {\n deg0[v] = popcnt2(G[v].w);\n sumdeg0 += deg0[v];\n }\n long long m0 = sumdeg0 / 2;\n\n // Build neighbor lists (for faster E11 computation)\n for (int v = 0; v < N; v++) {\n neigh[v].reserve(deg0[v]);\n for (int u = 0; u < N; u++) if (u != v && has_edge(G, v, u)) neigh[v].push_back(u);\n }\n\n // Expected noisy sorted degrees\n vector mu_deg(N);\n for (int v = 0; v < N; v++) mu_deg[v] = degOffset + scale * deg0[v];\n sort(mu_deg.begin(), mu_deg.end());\n prot[k].mu_sorted_deg = move(mu_deg);\n\n // Expected noisy edge count\n prot[k].Em = m0 * p1 + (Tedges - m0) * p0;\n\n // Expected noisy per-vertex triangle degrees, computed via neighbor/non-neighbor edge counts\n vector mu_tdeg(N, 0.0);\n for (int v = 0; v < N; v++) {\n int n1 = deg0[v];\n int n0 = (N - 1) - n1;\n\n // E11: edges among neighbors of v\n long long sumCommon = 0;\n const auto NvMask = G[v].w;\n for (int u : neigh[v]) {\n sumCommon += popcnt_and2(NvMask, G[u].w);\n }\n long long E11 = sumCommon / 2;\n\n // Sum deg in remaining graph from neighbor side\n long long sum_deg_in_rest_Nv = 0;\n for (int u : neigh[v]) sum_deg_in_rest_Nv += (deg0[u] - 1); // remove edge (u,v)\n long long E10 = sum_deg_in_rest_Nv - 2 * E11;\n\n long long m_rest = m0 - deg0[v]; // edges not incident to v\n long long E00 = m_rest - E11 - E10;\n if (E00 < 0) E00 = 0;\n\n // Total pair weight sum among vertices excluding v\n double sumw = n1 * p1 + n0 * p0;\n double sumw2 = n1 * (p1 * p1) + n0 * (p0 * p0);\n double sumTotalPairs = (sumw * sumw - sumw2) * 0.5;\n\n // Sum over edges in the induced graph with weights w_a w_b, where w in {p1,p0}\n double sumEdgeWeighted =\n (p1 * p1) * (double)E11 +\n (p1 * p0) * (double)E10 +\n (p0 * p0) * (double)E00;\n\n // E[T_v] = p0 * sum_{a 0 ? prot[k].Etri / totalTriples : 0.0);\n pbar = min(1.0, max(0.0, pbar));\n prot[k].VarTri = totalTriples * pbar * (1.0 - pbar) + 1.0;\n\n // Eigenvalues of original adjacency A\n Eigen::MatrixXd A(N, N);\n A.setZero();\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++) {\n if (has_edge(G, i, j)) A(i, j) = A(j, i) = 1.0;\n }\n prot[k].eigA_asc = eigenvalues_asc(A);\n }\n cout.flush();\n\n const int L = 8;\n const double comb_v = 1.0 * (N - 1) * (N - 2) / 2.0;\n\n for (int q = 0; q < 100; q++) {\n string hs;\n cin >> hs;\n if (!cin) break;\n\n auto H = string_to_adj(hs, N);\n auto obs = analyze_observed(H, N);\n\n vector degSorted = obs.deg;\n sort(degSorted.begin(), degSorted.end());\n vector tdegSorted = obs.triDeg;\n sort(tdegSorted.begin(), tdegSorted.end());\n\n // Centered matrix eigenvalues for H\n Eigen::MatrixXd Bmat(N, N);\n Bmat.setZero();\n if (eps == 0.0) {\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++)\n if (has_edge(H, i, j)) Bmat(i, j) = Bmat(j, i) = 1.0;\n } else {\n double denom = 1.0 - 2.0 * eps;\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++) {\n double hij = has_edge(H, i, j) ? 1.0 : 0.0;\n double val = (hij - eps) / denom;\n Bmat(i, j) = Bmat(j, i) = val;\n }\n }\n vector eigH = eigenvalues_asc(Bmat);\n\n // Weights\n double wM = 0.30;\n double wTri = 0.10;\n double wEig = (eps >= 0.30 ? 0.10 : (eps >= 0.20 ? 0.06 : 0.03));\n double wTdeg = (eps >= 0.30 ? 0.22 : (eps >= 0.20 ? 0.16 : 0.10));\n\n int best = 0;\n double bestScore = 1e300;\n\n for (int k = 0; k < M; k++) {\n // degree SSE\n const auto &muD = prot[k].mu_sorted_deg;\n double sseD = 0.0;\n for (int i = 0; i < N; i++) {\n double diff = (double)degSorted[i] - muD[i];\n sseD += diff * diff;\n }\n double z_deg = sseD / (sigma2_deg * N);\n\n // edges\n double dm = (double)obs.m - prot[k].Em;\n double z_m = (dm * dm) / var_m;\n\n // triangles total\n double dt = (double)obs.tri - prot[k].Etri;\n double z_t = (dt * dt) / prot[k].VarTri;\n\n // triangle-degree multiset SSE\n const auto &muT = prot[k].mu_sorted_trideg;\n double sseT = 0.0;\n for (int i = 0; i < N; i++) {\n double diff = (double)tdegSorted[i] - muT[i];\n sseT += diff * diff;\n }\n double pbar_v = (comb_v > 0 ? (3.0 * prot[k].Etri / N) / comb_v : 0.0);\n pbar_v = min(1.0, max(0.0, pbar_v));\n double sigma2_tdeg = comb_v * pbar_v * (1.0 - pbar_v) + 1.0;\n double z_tdeg = sseT / (sigma2_tdeg * N);\n\n // spectrum\n double z_e = spectral_distance_extremes(eigH, prot[k].eigA_asc, L);\n\n double score = z_deg + wM * z_m + wTri * z_t + wTdeg * z_tdeg + wEig * z_e;\n\n if (score < bestScore) {\n bestScore = score;\n best = k;\n }\n }\n\n cout << best << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n int w;\n};\n\nstatic inline long long sqll(long long x) { return x * x; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n\n vector edges(M);\n vector>> g(N); // (to, edgeId)\n vector> gw(N); // weights aligned with g\n g.assign(N, {});\n gw.assign(N, {});\n\n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n edges[i] = {u, v, w};\n g[u].push_back({v, i});\n gw[u].push_back(w);\n g[v].push_back({u, i});\n gw[v].push_back(w);\n }\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937_64 rng(seed);\n\n const long long INF = (1LL<<62);\n\n // --- 1) Importance estimation (sampled Dijkstra + SPT subtree contribution) ---\n int S = min(36, N);\n vector sources(N);\n iota(sources.begin(), sources.end(), 0);\n shuffle(sources.begin(), sources.end(), rng);\n sources.resize(S);\n\n vector importance(M, 0);\n vector dist(N);\n vector parentV(N), parentE(N);\n vector order(N), subtree(N);\n\n for (int si = 0; si < S; si++) {\n int s = sources[si];\n fill(dist.begin(), dist.end(), INF);\n fill(parentV.begin(), parentV.end(), -1);\n fill(parentE.begin(), parentE.end(), -1);\n\n using P = pair;\n priority_queue, greater

> pq;\n dist[s] = 0;\n pq.push({0, s});\n\n while (!pq.empty()) {\n auto [dcur, v] = pq.top(); pq.pop();\n if (dcur != dist[v]) continue;\n for (int idx = 0; idx < (int)g[v].size(); idx++) {\n auto [to, eid] = g[v][idx];\n long long nd = dcur + gw[v][idx];\n if (nd < dist[to]) {\n dist[to] = nd;\n parentV[to] = v;\n parentE[to] = eid;\n pq.push({nd, to});\n }\n }\n }\n\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int a, int b){ return dist[a] > dist[b]; });\n\n fill(subtree.begin(), subtree.end(), 1);\n for (int v : order) {\n int p = parentV[v];\n if (p != -1) subtree[p] += subtree[v];\n }\n for (int v = 0; v < N; v++) {\n if (v == s) continue;\n int eid = parentE[v];\n if (eid < 0) continue;\n long long sz = subtree[v];\n importance[eid] += sz * (long long)(N - sz);\n }\n }\n\n long long totalImp = 0;\n for (auto x : importance) totalImp += x;\n long double impScale = (M > 0 ? (long double)totalImp / (long double)M : 1.0L);\n if (impScale < 1.0L) impScale = 1.0L;\n\n // Edge order by importance\n vector eorder(M);\n iota(eorder.begin(), eorder.end(), 0);\n sort(eorder.begin(), eorder.end(), [&](int a, int b){\n if (importance[a] != importance[b]) return importance[a] > importance[b];\n return edges[a].w > edges[b].w;\n });\n\n // --- 2) Conflict graph via replacement paths ---\n vector>> conf(M); // (otherEdge, weight)\n\n auto add_conf = [&](int a, int b, int w){\n if (a == b) return;\n for (auto &p : conf[a]) {\n if (p.first == b) { p.second = max(p.second, w); return; }\n }\n conf[a].push_back({b, w});\n };\n\n vector dist2(N);\n vector parV2(N), parE2(N);\n\n auto replacement_path_edges = [&](int s, int t, int bannedEid) -> pair> {\n fill(dist2.begin(), dist2.end(), INF);\n fill(parV2.begin(), parV2.end(), -1);\n fill(parE2.begin(), parE2.end(), -1);\n\n using P = pair;\n priority_queue, greater

> pq;\n dist2[s] = 0;\n pq.push({0, s});\n\n while (!pq.empty()) {\n auto [dcur, v] = pq.top(); pq.pop();\n if (dcur != dist2[v]) continue;\n if (v == t) break;\n for (int idx = 0; idx < (int)g[v].size(); idx++) {\n auto [to, eid] = g[v][idx];\n if (eid == bannedEid) continue;\n long long nd = dcur + gw[v][idx];\n if (nd < dist2[to]) {\n dist2[to] = nd;\n parV2[to] = v;\n parE2[to] = eid;\n pq.push({nd, to});\n }\n }\n }\n if (dist2[t] >= INF/4) return {INF, {}};\n\n vector pathE;\n int cur = t;\n while (cur != s) {\n int pe = parE2[cur];\n if (pe < 0) break;\n pathE.push_back(pe);\n cur = parV2[cur];\n }\n return {dist2[t], pathE};\n };\n\n int T = min(M, 900); // analyze more edges\n int L = 12; // take more strong edges from replacement path\n\n for (int idx = 0; idx < T; idx++) {\n int e = eorder[idx];\n int u = edges[e].u, v = edges[e].v;\n\n auto [repDist, pathE] = replacement_path_edges(u, v, e);\n if (pathE.empty() || repDist >= INF/4) continue;\n\n sort(pathE.begin(), pathE.end());\n pathE.erase(unique(pathE.begin(), pathE.end()), pathE.end());\n pathE.erase(remove(pathE.begin(), pathE.end(), e), pathE.end());\n if (pathE.empty()) continue;\n\n sort(pathE.begin(), pathE.end(), [&](int a, int b){\n return importance[a] > importance[b];\n });\n if ((int)pathE.size() > L) pathE.resize(L);\n\n long double stretch = (long double)repDist / (long double)max(1, edges[e].w);\n stretch = min(stretch, 10.0L);\n\n int base = (int)llround(80.0L * (long double)importance[e] / impScale); // stronger than before\n base = max(10, min(base, 600));\n int wconf = (int)llround((long double)base * stretch);\n wconf = max(10, min(wconf, 2500));\n\n for (int f : pathE) {\n add_conf(e, f, wconf);\n add_conf(f, e, wconf);\n }\n }\n\n // --- 3) Balanced targets ---\n vector target(D, M / D);\n for (int d = 0; d < (M % D); d++) target[d]++;\n\n // --- 4) Greedy initial assignment (importance + endpoint concentration + conflict) ---\n vector dayOfEdge(M, -1);\n vector> edgesInDay(D);\n for (int d = 0; d < D; d++) edgesInDay[d].reserve(target[d]);\n\n vector cnt(D, 0);\n vector daySumImp(D, 0);\n\n vector> inc(D, vector(N, 0));\n vector dayVertexPenalty(D, 0);\n\n auto deltaAddEdgeVP = [&](int d, int u, int v) -> long long {\n long long delta = 0;\n long long a = inc[d][u], b = a + 1;\n delta += b*b - a*a;\n a = inc[d][v], b = a + 1;\n delta += b*b - a*a;\n if (u == v) delta -= 1;\n return delta;\n };\n\n auto applyAddEdge = [&](int d, int eid) {\n int u = edges[eid].u, v = edges[eid].v;\n {\n long long a = inc[d][u], b = a + 1;\n dayVertexPenalty[d] += b*b - a*a;\n inc[d][u] = (int16_t)b;\n }\n {\n long long a = inc[d][v], b = a + 1;\n dayVertexPenalty[d] += b*b - a*a;\n inc[d][v] = (int16_t)b;\n }\n if (u == v) dayVertexPenalty[d] -= 1;\n daySumImp[d] += importance[eid];\n dayOfEdge[eid] = d;\n edgesInDay[d].push_back(eid);\n cnt[d]++;\n };\n\n auto conflictCostIfPut = [&](int eid, int d) -> long long {\n long long s = 0;\n for (auto [f, w] : conf[eid]) {\n int df = dayOfEdge[f];\n if (df == d) s += w;\n }\n return s;\n };\n\n const long double alphaVP = 0.7L * impScale;\n const long double betaCnt = 0.02L * impScale;\n const long double alphaConfGreedy = (long double)(impScale * 0.08L);\n\n for (int eid : eorder) {\n int u = edges[eid].u, v = edges[eid].v;\n int bestD = -1;\n long double bestCost = numeric_limits::infinity();\n\n for (int d = 0; d < D; d++) {\n if (cnt[d] >= target[d]) continue;\n long long dvp = deltaAddEdgeVP(d, u, v);\n long long cconf = conflictCostIfPut(eid, d);\n long double cost = (long double)daySumImp[d]\n + alphaVP * (long double)dvp\n + betaCnt * (long double)cnt[d]\n + alphaConfGreedy * (long double)cconf;\n if (cost < bestCost) {\n bestCost = cost;\n bestD = d;\n }\n }\n if (bestD < 0) bestD = 0;\n applyAddEdge(bestD, eid);\n }\n\n // positions for swap\n vector posInDay(M, -1);\n for (int d = 0; d < D; d++) {\n for (int i = 0; i < (int)edgesInDay[d].size(); i++) posInDay[edgesInDay[d][i]] = i;\n }\n\n // --- 5) SA swaps with correct conflict delta (directed conflict sum) ---\n auto makeChanges = [&](int eidRemove, int eidAdd) {\n array vs = {edges[eidRemove].u, edges[eidRemove].v, edges[eidAdd].u, edges[eidAdd].v};\n array ds = {-1, -1, +1, +1};\n vector> tmp;\n tmp.reserve(4);\n for (int i = 0; i < 4; i++) {\n int v = vs[i], del = ds[i];\n bool found = false;\n for (auto &p : tmp) if (p.first == v) { p.second += del; found = true; break; }\n if (!found) tmp.push_back({v, del});\n }\n vector> ch;\n ch.reserve(tmp.size());\n for (auto &p : tmp) if (p.second != 0) ch.push_back(p);\n return ch;\n };\n\n auto deltaVPForDay = [&](int d, const vector>& changes) -> long long {\n long long delta = 0;\n for (auto [v, del] : changes) {\n long long a = inc[d][v];\n long long b = a + del;\n delta += b*b - a*a;\n }\n return delta;\n };\n\n auto applyVPChanges = [&](int d, const vector>& changes) {\n long long delta = 0;\n for (auto [v, del] : changes) {\n long long a = inc[d][v];\n long long b = a + del;\n delta += b*b - a*a;\n inc[d][v] = (int16_t)b;\n }\n dayVertexPenalty[d] += delta;\n };\n\n // Directed conflict sum (easy correct deltas)\n long long totalConfDir = 0;\n for (int e = 0; e < M; e++) {\n int de = dayOfEdge[e];\n for (auto [f, w] : conf[e]) {\n if (dayOfEdge[f] == de) totalConfDir += w;\n }\n }\n\n auto deltaConfMoveDir = [&](int e, int oldDay, int newDay) -> long long {\n long long delta = 0;\n for (auto [f, w] : conf[e]) {\n int df = dayOfEdge[f];\n if (df == oldDay) delta -= w;\n if (df == newDay) delta += w;\n }\n return delta;\n };\n\n long long sumSqImp = 0;\n long long totalVP = 0;\n for (int d = 0; d < D; d++) {\n sumSqImp += sqll(daySumImp[d]);\n totalVP += dayVertexPenalty[d];\n }\n\n long double coeffVP = (long double)(impScale * impScale * 0.5L);\n long double coeffConf = (long double)(impScale * impScale * 0.012L); // directed; tuned a bit stronger\n\n auto objective = [&]() -> long double {\n return (long double)sumSqImp + coeffVP * (long double)totalVP + coeffConf * (long double)totalConfDir;\n };\n\n long double curObj = objective();\n\n auto startTime = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 5.85;\n uniform_real_distribution uni01(0.0, 1.0);\n\n long double T0 = max((long double)1.0, curObj * 1e-4L);\n long double T1 = max((long double)1e-3, curObj * 1e-7L);\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - startTime).count();\n if (elapsed > TIME_LIMIT) break;\n double tt = elapsed / TIME_LIMIT;\n long double T = T0 * pow((double)(T1 / T0), tt);\n\n int a = (int)(rng() % D);\n int b = (int)(rng() % (D - 1));\n if (b >= a) b++;\n if (edgesInDay[a].empty() || edgesInDay[b].empty()) continue;\n\n int ia = (int)(rng() % edgesInDay[a].size());\n int ib = (int)(rng() % edgesInDay[b].size());\n int e1 = edgesInDay[a][ia];\n int e2 = edgesInDay[b][ib];\n if (e1 == e2) continue;\n\n // importance balance term\n long long p1 = importance[e1], p2 = importance[e2];\n long long A = daySumImp[a], B = daySumImp[b];\n long long A2 = A - p1 + p2;\n long long B2 = B - p2 + p1;\n long long deltaSumSq = sqll(A2) + sqll(B2) - sqll(A) - sqll(B);\n\n // vertex concentration term\n auto chA = makeChanges(e1, e2);\n auto chB = makeChanges(e2, e1);\n long long deltaVP = deltaVPForDay(a, chA) + deltaVPForDay(b, chB);\n\n // conflict term (directed; correct)\n long long deltaConf = 0;\n deltaConf += deltaConfMoveDir(e1, a, b);\n deltaConf += deltaConfMoveDir(e2, b, a);\n\n long double deltaObj = (long double)deltaSumSq\n + coeffVP * (long double)deltaVP\n + coeffConf * (long double)deltaConf;\n\n bool accept = false;\n if (deltaObj <= 0) accept = true;\n else {\n long double prob = expl(-(double)(deltaObj / T));\n if (uni01(rng) < (double)prob) accept = true;\n }\n\n if (accept) {\n sumSqImp += deltaSumSq;\n daySumImp[a] = A2;\n daySumImp[b] = B2;\n\n totalVP += deltaVP;\n applyVPChanges(a, chA);\n applyVPChanges(b, chB);\n\n totalConfDir += deltaConf;\n\n // swap in day lists\n edgesInDay[a][ia] = e2;\n edgesInDay[b][ib] = e1;\n posInDay[e2] = ia;\n posInDay[e1] = ib;\n\n dayOfEdge[e1] = b;\n dayOfEdge[e2] = a;\n\n curObj += deltaObj;\n }\n }\n\n for (int i = 0; i < M; i++) {\n if (i) cout << ' ';\n cout << (dayOfEdge[i] + 1);\n }\n cout << '\\n';\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstatic inline int idx3(int D, int x, int y, int z) { return x * D * D + y * D + z; }\n\nstruct Stick {\n int axis; // 0=x,1=y,2=z\n int x, y, z; // start (min along axis)\n int cur;\n int rem;\n};\n\nstruct BuildResult {\n int n = 0;\n vector b1, b2;\n long double obj = 1e100L; // exact objective\n};\n\nstatic inline void stick_cell(int D, const Stick& s, int offset, int &x, int &y, int &z) {\n x = s.x; y = s.y; z = s.z;\n if (s.axis == 0) x += offset;\n else if (s.axis == 1) y += offset;\n else z += offset;\n}\n\nstatic inline void cut_piece(int D, Stick& s, int L, vector& b, int blockId) {\n for (int t=0; t build_sticks(int D, const vector& occ, int axis) {\n vector sticks;\n sticks.reserve(D*D*D/2);\n if (axis == 0) { // x\n for (int y=0;y build_occ_full(int D, const vector& f, const vector& r) {\n vector occ(D*D*D, 0);\n for (int z=0; z build_occ_min(int D, const vector& f, const vector& r) {\n vector occ(D*D*D, 0);\n for (int z=0; z X, Y;\n for (int x=0; x= cy) {\n for (int t=0;t build_occ_star(int D, const vector& f, const vector& r) {\n int bestX=0, bestY=0, bestXcnt=-1, bestYcnt=-1;\n for (int x=0;xbestXcnt) bestXcnt=c, bestX=x;\n }\n for (int y=0;ybestYcnt) bestYcnt=c, bestY=y;\n }\n vector occ(D*D*D, 0);\n for (int z=0; z X, Y;\n for (int x=0;x get_Vmin_Vmax(int D, const vector& f, const vector& r) {\n int Vmin=0, Vmax=0;\n for (int z=0; z build_occ_target(int D,\n const vector& f,\n const vector& r,\n int consAxis, // 0 or 1\n int T) {\n vector> X(D), Y(D);\n vector minz(D), maxz(D);\n for (int z=0; z mz = minz;\n int E = T - Vmin;\n while (E > 0) {\n int best=-1, bestCap=0;\n for (int z=0; z bestCap) bestCap = cap, best = z;\n }\n if (bestCap == 0) break;\n int add = min(E, bestCap);\n mz[best] += add;\n E -= add;\n }\n\n vector occ(D*D*D, 0);\n vector> used(D, vector(D, 0));\n\n for (int z=0; z= cy) {\n for (int t=0;t> max_weight_matching_layer(const vector& A, const vector& B,\n const vector>& w) {\n int n = (int)A.size(), m = (int)B.size();\n if (n == 0 || m == 0) return {};\n if (n <= m) {\n int M = 1< dp(M, NEG), ndp(M, NEG);\n vector> parMaskT(n+1, vector(M, -1));\n vector> parPickT(n+1, vector(M, -1));\n dp[0]=0;\n for (int i=0;i NEG/2) {\n for (int j=0;j ndp[nmask]) {\n ndp[nmask]=val;\n parMaskT[i+1][nmask]=mask;\n parPickT[i+1][nmask]=j;\n }\n }\n }\n dp.swap(ndp);\n }\n int bestMask=-1, bestVal=NEG;\n for (int mask=0; mask bestVal) bestVal=dp[mask], bestMask=mask;\n }\n vector> res;\n if (bestMask<0) return res;\n int mask=bestMask;\n for (int i=n;i>=1;i--) {\n int pm = parMaskT[i][mask];\n int pj = parPickT[i][mask];\n res.push_back({A[i-1], B[pj]});\n mask = pm;\n }\n reverse(res.begin(), res.end());\n return res;\n } else {\n int N = 1< dp(N, NEG), ndp(N, NEG);\n vector> parMaskT(m+1, vector(N, -1));\n vector> parPickT(m+1, vector(N, -1));\n dp[0]=0;\n for (int j=0;j NEG/2) {\n for (int i=0;i ndp[nmask]) {\n ndp[nmask]=val;\n parMaskT[j+1][nmask]=mask;\n parPickT[j+1][nmask]=i;\n }\n }\n }\n dp.swap(ndp);\n }\n int bestMask=-1, bestVal=NEG;\n for (int mask=0; mask bestVal) bestVal=dp[mask], bestMask=mask;\n }\n vector> res;\n if (bestMask<0) return res;\n int mask=bestMask;\n for (int j=m;j>=1;j--) {\n int pm = parMaskT[j][mask];\n int pi = parPickT[j][mask];\n res.push_back({A[pi], B[j-1]});\n mask = pm;\n }\n reverse(res.begin(), res.end());\n return res;\n }\n}\n\n// ---------- column greedy reuse with density fraction p/q ----------\nvector build_occ_column_greedy_frac(int D, const vector& f, const vector& r, int p, int q) {\n vector> X(D), Y(D);\n for (int z=0; z> cnt(D, vector(D, 0));\n for (int z=0; z occ(D*D*D, 0);\n vector> used(D, vector(D, 0));\n\n for (int z=0; zint{\n int bestY = ys[0], bestW = -1;\n for (int y: ys) { int w = cnt[x][y]; if (w > bestW) bestW = w, bestY = y; }\n return bestY;\n };\n auto best_x_for_y = [&](int y)->int{\n int bestX = xs[0], bestW = -1;\n for (int x: xs) { int w = cnt[x][y]; if (w > bestW) bestW = w, bestX = x; }\n return bestX;\n };\n\n int placed=0;\n vector covX(D,0), covY(D,0);\n\n if (cx >= cy) {\n for (int x: xs) {\n int y = best_y_for_x(x);\n if (!used[x][y]) { used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covX[x]=1; covY[y]=1;\n }\n for (int y: ys) if (!covY[y]) {\n int x = best_x_for_y(y);\n if (!used[x][y]) { used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covY[y]=1; covX[x]=1;\n }\n } else {\n for (int y: ys) {\n int x = best_x_for_y(y);\n if (!used[x][y]) { used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covY[y]=1; covX[x]=1;\n }\n for (int x: xs) if (!covX[x]) {\n int y = best_y_for_x(x);\n if (!used[x][y]) { used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covX[x]=1; covY[y]=1;\n }\n }\n\n if (placed < target) {\n vector> pairs;\n pairs.reserve(cx*cy);\n for (int x: xs) for (int y: ys) pairs.emplace_back(cnt[x][y], x, y);\n sort(pairs.begin(), pairs.end(), greater<>());\n for (auto &[w,x,y] : pairs) {\n if (placed >= target) break;\n if (used[x][y]) continue;\n used[x][y]=1;\n occ[idx3(D,x,y,z)] = 1;\n placed++;\n }\n }\n }\n return occ;\n}\n\n// ---------- column DP (static weights) with density fraction p/q ----------\nvector build_occ_column_dp_frac(int D, const vector& f, const vector& r, int p, int q) {\n vector> X(D), Y(D);\n for (int z=0; z> cnt(D, vector(D, 0));\n for (int z=0; z occ(D*D*D, 0);\n vector> used(D, vector(D, 0));\n\n for (int z=0; z covX(D,0), covY(D,0);\n int placed=0;\n for (auto [x,y] : matched) {\n if (!used[x][y]) { used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covX[x]=1; covY[y]=1;\n }\n\n auto best_y_for_x = [&](int x)->int{\n int bestY = ys[0], bestW = -1;\n for (int y: ys) { int w = cnt[x][y]; if (w > bestW) bestW=w, bestY=y; }\n return bestY;\n };\n auto best_x_for_y = [&](int y)->int{\n int bestX = xs[0], bestW = -1;\n for (int x: xs) { int w = cnt[x][y]; if (w > bestW) bestW=w, bestX=x; }\n return bestX;\n };\n\n for (int x: xs) if (!covX[x]) {\n int y = best_y_for_x(x);\n if (!used[x][y]) { used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covX[x]=1; covY[y]=1;\n }\n for (int y: ys) if (!covY[y]) {\n int x = best_x_for_y(y);\n if (!used[x][y]) { used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covY[y]=1; covX[x]=1;\n }\n\n if (placed < target) {\n vector> pairs;\n pairs.reserve(cx*cy);\n for (int x: xs) for (int y: ys) pairs.emplace_back(cnt[x][y], x, y);\n sort(pairs.begin(), pairs.end(), greater<>());\n for (auto &[w,x,y] : pairs) {\n if (placed >= target) break;\n if (used[x][y]) continue;\n used[x][y]=1;\n occ[idx3(D,x,y,z)] = 1;\n placed++;\n }\n }\n }\n\n return occ;\n}\n\n// ---------- chain DP column builder with density fraction p/q ----------\nvector build_occ_column_chain_dp_frac(int D, const vector& f, const vector& r,\n int p, int q, int beta, bool rev) {\n vector> X(D), Y(D);\n for (int z=0; z> base(D, vector(D, 0));\n for (int z=0; z order(D);\n iota(order.begin(), order.end(), 0);\n if (rev) reverse(order.begin(), order.end());\n\n vector> run(D, vector(D, 0)), newrun(D, vector(D, 0));\n vector> W(D, vector(D, 0));\n\n vector occ(D*D*D, 0);\n vector> used(D, vector(D, 0));\n\n for (int zi=0; zi covX(D,0), covY(D,0);\n int placed=0;\n vector> chosen;\n chosen.reserve(Vmax);\n\n auto add_edge = [&](int x,int y){\n if (used[x][y]) return;\n used[x][y]=1;\n occ[idx3(D,x,y,z)] = 1;\n placed++;\n chosen.push_back({x,y});\n covX[x]=1; covY[y]=1;\n };\n\n for (auto [x,y] : matched) add_edge(x,y);\n\n auto best_y_for_x = [&](int x)->int{\n int bestY = ys[0], bestW = -1;\n for (int y: ys) { int ww = W[x][y]; if (ww > bestW) bestW=ww, bestY=y; }\n return bestY;\n };\n auto best_x_for_y = [&](int y)->int{\n int bestX = xs[0], bestW = -1;\n for (int x: xs) { int ww = W[x][y]; if (ww > bestW) bestW=ww, bestX=x; }\n return bestX;\n };\n\n for (int x: xs) if (!covX[x]) add_edge(x, best_y_for_x(x));\n for (int y: ys) if (!covY[y]) add_edge(best_x_for_y(y), y);\n\n if (placed < target) {\n vector> pairs;\n pairs.reserve(cx*cy);\n for (int x: xs) for (int y: ys) pairs.emplace_back(W[x][y], x, y);\n sort(pairs.begin(), pairs.end(), greater<>());\n for (auto &[ww,x,y] : pairs) {\n if (placed >= target) break;\n add_edge(x,y);\n }\n }\n\n for (int x=0;x& b1, const vector& b2) {\n vector u1(n+1, 0), u2(n+1, 0);\n int N = (int)b1.size();\n vector v1(n+1,0), v2(n+1,0);\n for (int i=0;i vol(n+1,0);\n for (int k=1;k<=n;k++) vol[k]=max(v1[k], v2[k]);\n\n long double r1=0, r2=0, sp=0;\n for (int k=1;k<=n;k++) {\n if (!u1[k]) r1 += vol[k];\n if (!u2[k]) r2 += vol[k];\n if (u1[k] && u2[k]) sp += 1.0L / (long double)vol[k];\n }\n return r1 + r2 + sp;\n}\n\n// ---------- sharing methods ----------\nint find_best_stick_lenmatch(const vector& sticks, int L) {\n int bestDiv=-1, best=-1;\n int bestDivLen=-1, bestLen=-1;\n for (int i=0;i<(int)sticks.size();i++) {\n const auto &s=sticks[i];\n if (s.rem < L) continue;\n if (s.rem % L == 0) {\n if (s.rem > bestDivLen) bestDivLen=s.rem, bestDiv=i;\n } else {\n if (s.rem > bestLen) bestLen=s.rem, best=i;\n }\n }\n return (bestDiv!=-1)?bestDiv:best;\n}\n\nBuildResult simulate_lenmatch(int D,\n const vector& occ1, const vector& occ2,\n int axis1, int axis2) {\n BuildResult res;\n int N = D*D*D;\n res.b1.assign(N, 0);\n res.b2.assign(N, 0);\n\n vector s1=build_sticks(D, occ1, axis1);\n vector s2=build_sticks(D, occ2, axis2);\n\n int blockId=0;\n for (int L=D; L>=1; L--) {\n while (true) {\n int i1=find_best_stick_lenmatch(s1,L);\n int i2=find_best_stick_lenmatch(s2,L);\n if (i1<0 || i2<0) break;\n blockId++;\n cut_piece(D, s1[i1], L, res.b1, blockId);\n cut_piece(D, s2[i2], L, res.b2, blockId);\n }\n }\n for (auto &s: s1) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b1, blockId); }\n for (auto &s: s2) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b2, blockId); }\n\n res.n = blockId;\n res.obj = eval_exact(res.n, res.b1, res.b2);\n return res;\n}\n\nBuildResult simulate_pq(int D,\n const vector& occ1, const vector& occ2,\n int axis1, int axis2) {\n BuildResult res;\n int N = D*D*D;\n res.b1.assign(N, 0);\n res.b2.assign(N, 0);\n\n vector s1=build_sticks(D, occ1, axis1);\n vector s2=build_sticks(D, occ2, axis2);\n\n priority_queue> pq1,pq2;\n for (int i=0;i<(int)s1.size();i++) if (s1[i].rem>0) pq1.push({s1[i].rem,i});\n for (int i=0;i<(int)s2.size();i++) if (s2[i].rem>0) pq2.push({s2[i].rem,i});\n\n auto pop_valid = [&](auto &pq, vector& ss)->int{\n while(!pq.empty()){\n auto [len,id]=pq.top();\n if (ss[id].rem!=len) { pq.pop(); continue; }\n return id;\n }\n return -1;\n };\n\n int blockId=0;\n while(true){\n int i1=pop_valid(pq1,s1);\n int i2=pop_valid(pq2,s2);\n if(i1<0||i2<0) break;\n int L=min(s1[i1].rem, s2[i2].rem);\n blockId++;\n cut_piece(D,s1[i1],L,res.b1,blockId);\n cut_piece(D,s2[i2],L,res.b2,blockId);\n pq1.pop(); pq2.pop();\n if(s1[i1].rem>0) pq1.push({s1[i1].rem,i1});\n if(s2[i2].rem>0) pq2.push({s2[i2].rem,i2});\n }\n\n for (auto &s: s1) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b1, blockId); }\n for (auto &s: s2) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b2, blockId); }\n\n res.n=blockId;\n res.obj=eval_exact(res.n,res.b1,res.b2);\n return res;\n}\n\nBuildResult simulate_mixed(int D,\n const vector& occ1, const vector& occ2,\n int axis1, int axis2) {\n BuildResult res;\n int N = D*D*D;\n res.b1.assign(N, 0);\n res.b2.assign(N, 0);\n\n vector s1=build_sticks(D, occ1, axis1);\n vector s2=build_sticks(D, occ2, axis2);\n\n int blockId=0;\n for (int L=D; L>=2; L--) {\n while (true) {\n int i1=find_best_stick_lenmatch(s1,L);\n int i2=find_best_stick_lenmatch(s2,L);\n if (i1<0 || i2<0) break;\n blockId++;\n cut_piece(D, s1[i1], L, res.b1, blockId);\n cut_piece(D, s2[i2], L, res.b2, blockId);\n }\n }\n\n priority_queue> pq1,pq2;\n for (int i=0;i<(int)s1.size();i++) if (s1[i].rem>0) pq1.push({s1[i].rem,i});\n for (int i=0;i<(int)s2.size();i++) if (s2[i].rem>0) pq2.push({s2[i].rem,i});\n\n auto pop_valid = [&](auto &pq, vector& ss)->int{\n while(!pq.empty()){\n auto [len,id]=pq.top();\n if (ss[id].rem!=len) { pq.pop(); continue; }\n return id;\n }\n return -1;\n };\n\n while(true){\n int i1=pop_valid(pq1,s1);\n int i2=pop_valid(pq2,s2);\n if(i1<0||i2<0) break;\n int L=min(s1[i1].rem, s2[i2].rem);\n blockId++;\n cut_piece(D,s1[i1],L,res.b1,blockId);\n cut_piece(D,s2[i2],L,res.b2,blockId);\n pq1.pop(); pq2.pop();\n if(s1[i1].rem>0) pq1.push({s1[i1].rem,i1});\n if(s2[i2].rem>0) pq2.push({s2[i2].rem,i2});\n }\n\n for (auto &s: s1) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b1, blockId); }\n for (auto &s: s2) if (s.rem>0) { blockId++; cut_piece(D, s, s.rem, res.b2, blockId); }\n\n res.n=blockId;\n res.obj=eval_exact(res.n,res.b1,res.b2);\n return res;\n}\n\n// ---------- main ----------\nstruct OccVariant { vector occ; };\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D;\n cin >> D;\n vector> F(2, vector(D)), R(2, vector(D));\n for(int i=0;i<2;i++){\n for(int z=0;z> F[i][z];\n for(int z=0;z> R[i][z];\n }\n\n // density fractions for column builders\n // alpha in {0, 1/4, 1/2, 3/4}\n const vector> fracs = {{0,1},{1,4},{1,2},{3,4}};\n\n vector vars[2];\n for (int i=0;i<2;i++) {\n // strong baselines\n vars[i].push_back({build_occ_full(D, F[i], R[i])});\n vars[i].push_back({build_occ_min(D, F[i], R[i])});\n vars[i].push_back({build_occ_star(D, F[i], R[i])});\n\n // column greedy/dp at multiple densities\n for (auto [p,q] : fracs) {\n vars[i].push_back({build_occ_column_greedy_frac(D, F[i], R[i], p, q)});\n vars[i].push_back({build_occ_column_dp_frac(D, F[i], R[i], p, q)});\n }\n\n // chain dp at multiple densities, betas, directions\n for (auto [p,q] : fracs) {\n for (int beta : {3, 12, 30}) {\n for (bool rev : {false, true}) {\n vars[i].push_back({build_occ_column_chain_dp_frac(D, F[i], R[i], p, q, beta, rev)});\n }\n }\n }\n\n // target-fill variants with more T samples\n auto [Vmin, Vmax] = get_Vmin_Vmax(D, F[i], R[i]);\n vector Ts;\n Ts.push_back(Vmin);\n Ts.push_back(Vmax);\n Ts.push_back((Vmin+Vmax)/2);\n Ts.push_back(Vmin + (Vmax-Vmin)/4);\n Ts.push_back(Vmin + (Vmax-Vmin)*3/4);\n sort(Ts.begin(), Ts.end());\n Ts.erase(unique(Ts.begin(), Ts.end()), Ts.end());\n for (int T: Ts) for (int biasAxis : {0,1}) {\n vars[i].push_back({build_occ_target(D, F[i], R[i], biasAxis, T)});\n }\n }\n\n vector axes = {0,1,2};\n BuildResult best;\n\n for (auto &v1 : vars[0]) for (auto &v2 : vars[1]) {\n for (int a1 : axes) for (int a2 : axes) {\n auto r1 = simulate_lenmatch(D, v1.occ, v2.occ, a1, a2);\n if (r1.obj < best.obj) best = std::move(r1);\n\n auto r2 = simulate_mixed(D, v1.occ, v2.occ, a1, a2);\n if (r2.obj < best.obj) best = std::move(r2);\n\n auto r3 = simulate_pq(D, v1.occ, v2.occ, a1, a2);\n if (r3.obj < best.obj) best = std::move(r3);\n }\n }\n\n cout << best.n << \"\\n\";\n for (int i=0;i\nusing namespace std;\n\nstatic const long long INFLL = (1LL << 60);\nstatic const int MAXP = 5000;\nstatic const int MAXD = 5001; // 0..5000\n\nstruct Edge { int u, v; long long w; };\n\nstruct DSU {\n vector p, r;\n DSU(int n=0): p(n), r(n,0) { iota(p.begin(), p.end(), 0); }\n int find(int a){ return p[a]==a? a : p[a]=find(p[a]); }\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a]0 && (r-1)*(r-1) >= x) --r;\n if (r > MAXP) return MAXP+1;\n return (int)r;\n}\n\nstruct EvalResult {\n bool valid = false;\n long long S = INFLL;\n vector P; // N\n vector B; // M\n vector cnt; // N\n vector assign; // K\n vector adist; // K\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K;\n cin >> N >> M >> K;\n\n vector x(N), y(N);\n for (int i = 0; i < N; i++) cin >> x[i] >> y[i];\n\n vector edges(M);\n\n vector> dist(N, vector(N, INFLL));\n vector> nxt(N, vector(N, -1));\n vector> edgeId(N, vector(N, -1));\n\n for (int i = 0; i < N; i++) {\n dist[i][i] = 0;\n nxt[i][i] = i;\n }\n\n for (int j = 0; j < M; j++) {\n int u, v; long long w;\n cin >> u >> v >> w;\n --u; --v;\n edges[j] = {u, v, w};\n if (w < dist[u][v]) {\n dist[u][v] = dist[v][u] = w;\n nxt[u][v] = v;\n nxt[v][u] = u;\n edgeId[u][v] = edgeId[v][u] = j;\n }\n }\n\n vector a(K), b(K);\n for (int k = 0; k < K; k++) cin >> a[k] >> b[k];\n\n // resident -> station distance (ceil euclid), clipped to 5001 for \"too far\"\n vector> d(K);\n for (int k = 0; k < K; k++) {\n for (int i = 0; i < N; i++) {\n long long dx = (long long)a[k] - x[i];\n long long dy = (long long)b[k] - y[i];\n long long dsq = dx*dx + dy*dy;\n int cd = ceil_sqrt_ll(dsq);\n if (cd > MAXP) cd = MAXP+1;\n d[k][i] = (uint16_t)cd;\n }\n }\n\n // Candidate stations per resident (within 5000), sorted by distance\n vector>> cand(K);\n for (int k = 0; k < K; k++) {\n vector> v;\n v.reserve(N);\n for (int i = 0; i < N; i++) {\n int di = (int)d[k][i];\n if (di <= MAXP) v.push_back({di, i});\n }\n sort(v.begin(), v.end());\n cand[k] = std::move(v);\n }\n\n // Floyd-Warshall + next matrix\n for (int k = 0; k < N; k++) {\n for (int i = 0; i < N; i++) if (dist[i][k] < INFLL) {\n for (int j = 0; j < N; j++) if (dist[k][j] < INFLL) {\n long long nd = dist[i][k] + dist[k][j];\n if (nd < dist[i][j]) {\n dist[i][j] = nd;\n nxt[i][j] = nxt[i][k];\n }\n }\n }\n }\n\n auto reconstruct_path_edges = [&](int s, int t, vector& mark) {\n int cur = s;\n while (cur != t) {\n int nx = nxt[cur][t];\n if (nx < 0) return;\n int eid = edgeId[cur][nx];\n if (eid >= 0) mark[eid] = 1;\n cur = nx;\n }\n };\n\n // Precompute global MST of original graph (for candidate cable set #3)\n vector mstEdges;\n {\n vector ids(M);\n iota(ids.begin(), ids.end(), 0);\n sort(ids.begin(), ids.end(), [&](int i, int j){ return edges[i].w < edges[j].w; });\n DSU dsu(N);\n for (int id : ids) {\n if (dsu.unite(edges[id].u, edges[id].v)) mstEdges.push_back(id);\n if ((int)mstEdges.size() == N-1) break;\n }\n }\n vector isMst(M, 0);\n for (int id : mstEdges) isMst[id] = 1;\n\n // Prune non-terminal leaves in a forest, then keep only root component. Return cost and B.\n auto prune_and_root = [&](vector alive, const vector& terminal) -> pair, long long> {\n vector>> g(N);\n vector deg(N, 0);\n for (int id = 0; id < M; id++) if (alive[id]) {\n int u = edges[id].u, v = edges[id].v;\n g[u].push_back({v, id});\n g[v].push_back({u, id});\n deg[u]++; deg[v]++;\n }\n\n deque q;\n vector inq(N, 0);\n for (int i = 0; i < N; i++) if (!terminal[i] && deg[i] <= 1) {\n q.push_back(i); inq[i] = 1;\n }\n auto remove_edge = [&](int v, int to, int eid) {\n if (!alive[eid]) return;\n alive[eid] = 0;\n deg[v]--; deg[to]--;\n if (!terminal[to] && deg[to] <= 1 && !inq[to]) { q.push_back(to); inq[to] = 1; }\n };\n while (!q.empty()) {\n int v = q.front(); q.pop_front();\n if (terminal[v]) continue;\n if (deg[v] != 1) continue;\n for (auto [to, eid] : g[v]) if (alive[eid]) { remove_edge(v, to, eid); break; }\n }\n\n // keep only root component\n vector vis(N, 0);\n deque bfs;\n vis[0] = 1;\n bfs.push_back(0);\n while (!bfs.empty()) {\n int v = bfs.front(); bfs.pop_front();\n for (auto [to, eid] : g[v]) if (alive[eid] && !vis[to]) {\n vis[to] = 1;\n bfs.push_back(to);\n }\n }\n for (int id = 0; id < M; id++) if (alive[id]) {\n if (!vis[edges[id].u] || !vis[edges[id].v]) alive[id] = 0;\n }\n\n long long cost = 0;\n vector B(M, 0);\n for (int id = 0; id < M; id++) if (alive[id]) {\n B[id] = 1;\n cost += edges[id].w;\n }\n return {B, cost};\n };\n\n // For marked edge set, remove cycles by Kruskal (min spanning forest), then prune.\n auto kruskal_then_prune = [&](const vector& marked, const vector& terminal) -> pair, long long> {\n vector ids;\n ids.reserve(M);\n for (int id = 0; id < M; id++) if (marked[id]) ids.push_back(id);\n sort(ids.begin(), ids.end(), [&](int a, int b){ return edges[a].w < edges[b].w; });\n\n DSU dsu(N);\n vector alive(M, 0);\n for (int id : ids) if (dsu.unite(edges[id].u, edges[id].v)) alive[id] = 1;\n\n return prune_and_root(std::move(alive), terminal);\n };\n\n // Build cable set from P: try multiple constructions and take best.\n auto build_cables = [&](const vector& P) -> pair, long long> {\n vector terminal(N, 0);\n terminal[0] = 1;\n vector terms;\n terms.reserve(N);\n terms.push_back(0);\n for (int i = 1; i < N; i++) if (P[i] > 0) {\n terminal[i] = 1;\n terms.push_back(i);\n }\n\n pair, long long> best = {vector(M, 0), INFLL};\n\n // Candidate #1: KMB (metric MST on terminals, expand paths)\n {\n int T = (int)terms.size();\n vector bestd(T, INFLL);\n vector parent(T, -1);\n vector used(T, 0);\n bestd[0] = 0;\n\n bool ok = true;\n for (int it = 0; it < T; it++) {\n int v = -1;\n for (int i = 0; i < T; i++) if (!used[i]) {\n if (v < 0 || bestd[i] < bestd[v]) v = i;\n }\n if (v < 0 || bestd[v] >= INFLL/2) { ok = false; break; }\n used[v] = 1;\n int vv = terms[v];\n for (int i = 0; i < T; i++) if (!used[i]) {\n int uu = terms[i];\n long long w = dist[vv][uu];\n if (w < bestd[i]) { bestd[i] = w; parent[i] = v; }\n }\n }\n if (ok) {\n vector mark(M, 0);\n for (int i = 1; i < T; i++) {\n int u = terms[i];\n int p = terms[parent[i]];\n reconstruct_path_edges(u, p, mark);\n }\n auto cand1 = kruskal_then_prune(mark, terminal);\n if (cand1.second < best.second) best = std::move(cand1);\n }\n }\n\n // Candidate #2: union of shortest paths from root to each terminal\n {\n vector mark(M, 0);\n for (int t : terms) reconstruct_path_edges(0, t, mark);\n auto cand2 = kruskal_then_prune(mark, terminal);\n if (cand2.second < best.second) best = std::move(cand2);\n }\n\n // Candidate #3: subtree of global MST connecting terminals (via pruning)\n {\n vector alive = isMst;\n auto cand3 = prune_and_root(std::move(alive), terminal);\n if (cand3.second < best.second) best = std::move(cand3);\n }\n\n return best;\n };\n\n auto t_start = chrono::steady_clock::now();\n auto elapsed_ms = [&]() -> long long {\n return chrono::duration_cast(chrono::steady_clock::now() - t_start).count();\n };\n\n std::mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto evaluate = [&](const vector& U, int trials, bool shuffleResOrder,\n int improvePasses, bool doTerminalElim) -> EvalResult {\n EvalResult best;\n best.valid = false;\n best.S = INFLL;\n\n vector order(K);\n iota(order.begin(), order.end(), 0);\n\n // opening penalty coefficient\n const double openLambda = 0.20;\n\n for (int tr = 0; tr < trials; tr++) {\n if (shuffleResOrder || tr > 0) shuffle(order.begin(), order.end(), rng);\n\n vector P(N, 0), cnt(N, 0);\n vector assign(K, -1), adist(K, 0);\n\n vector opened;\n opened.reserve(N);\n vector isOpened(N, 0);\n isOpened[0] = 1;\n opened.push_back(0);\n\n auto minDistToOpened = [&](int i)->long long {\n long long md = INFLL;\n for (int j : opened) md = min(md, dist[i][j]);\n return md;\n };\n\n // greedy marginal assignment with \"cable-aware\" opening penalty\n bool ok = true;\n for (int idx = 0; idx < K; idx++) {\n int k = order[idx];\n long long bestDelta = INFLL;\n int besti = -1, bestNewP = 0, bestDi = 0;\n\n for (auto [di, i] : cand[k]) {\n if (!U[i]) continue;\n int pi = P[i];\n int newp = max(pi, di);\n long long delta = 1LL*newp*newp - 1LL*pi*pi;\n\n if (i != 0 && !isOpened[i]) {\n delta += (long long) llround(openLambda * (long double)minDistToOpened(i));\n }\n\n if (delta < bestDelta) {\n bestDelta = delta;\n besti = i;\n bestNewP = newp;\n bestDi = di;\n }\n }\n\n if (besti < 0) { ok = false; break; }\n\n assign[k] = besti;\n adist[k] = bestDi;\n if (bestNewP > P[besti]) P[besti] = bestNewP;\n cnt[besti]++;\n\n if (!isOpened[besti]) {\n isOpened[besti] = 1;\n opened.push_back(besti);\n }\n }\n if (!ok) continue;\n\n // local reassignment improvement (hill-climb on sum P^2), using histograms\n vector counts(N * (MAXD+1), 0);\n auto idxc = [&](int s, int distv){ return s*(MAXD+1) + distv; };\n for (int k = 0; k < K; k++) counts[idxc(assign[k], adist[k])]++;\n\n auto recompute_max_down = [&](int s, int start)->int{\n for (int dd = start; dd >= 1; dd--) if (counts[idxc(s, dd)] > 0) return dd;\n return 0;\n };\n for (int s = 0; s < N; s++) {\n if (cnt[s] == 0) P[s] = 0;\n else P[s] = recompute_max_down(s, P[s]);\n }\n\n if (improvePasses > 0) {\n vector resOrder(K);\n iota(resOrder.begin(), resOrder.end(), 0);\n\n for (int pass = 0; pass < improvePasses; pass++) {\n shuffle(resOrder.begin(), resOrder.end(), rng);\n bool any = false;\n\n for (int k : resOrder) {\n int s = assign[k];\n int ds = adist[k];\n int Ps = P[s];\n\n auto Ps_after_remove = [&]()->int{\n if (cnt[s] == 1) return 0;\n if (ds < Ps) return Ps;\n if (counts[idxc(s, Ps)] >= 2) return Ps;\n return recompute_max_down(s, Ps-1);\n };\n int PsRem = Ps_after_remove();\n\n long long bestDelta = 0;\n int bestT = -1, bestDt = 0;\n\n for (auto [dt, t] : cand[k]) {\n if (!U[t] || t == s) continue;\n int Pt = P[t];\n int PtAdd = max(Pt, dt);\n long long delta = 1LL*PsRem*PsRem + 1LL*PtAdd*PtAdd\n - 1LL*Ps*Ps - 1LL*Pt*Pt;\n if (delta < bestDelta) {\n bestDelta = delta;\n bestT = t;\n bestDt = dt;\n }\n }\n\n if (bestT >= 0) {\n int t = bestT, dt = bestDt;\n\n counts[idxc(s, ds)]--;\n counts[idxc(t, dt)]++;\n\n cnt[s]--;\n cnt[t]++;\n\n if (cnt[s] == 0) P[s] = 0;\n else {\n int old = P[s];\n if (ds == old && counts[idxc(s, old)] == 0) P[s] = recompute_max_down(s, old-1);\n }\n if (dt > P[t]) P[t] = dt;\n\n assign[k] = t;\n adist[k] = dt;\n any = true;\n }\n }\n if (!any) break;\n }\n }\n\n // Terminal elimination: try to empty tiny stations completely\n if (doTerminalElim) {\n vector> members(N);\n for (int k = 0; k < K; k++) members[assign[k]].push_back(k);\n\n const int TH = 40;\n vector small;\n for (int s = 1; s < N; s++) if (cnt[s] > 0 && cnt[s] <= TH) small.push_back(s);\n\n // try more promising first: small cnt but large distance/cable impact tends to help\n sort(small.begin(), small.end(), [&](int a, int b){\n if (cnt[a] != cnt[b]) return cnt[a] < cnt[b];\n return P[a] > P[b];\n });\n\n auto compute_total_cost = [&](const vector& Pnow)->long long{\n long long rad = 0;\n for (int i = 0; i < N; i++) rad += 1LL*Pnow[i]*Pnow[i];\n auto [B, ec] = build_cables(Pnow);\n if (ec >= INFLL/2) return INFLL;\n return rad + ec;\n };\n\n long long curS = compute_total_cost(P);\n\n for (int s : small) {\n if (elapsed_ms() > 1950) break;\n // attempt to move all members[s] elsewhere\n // Save changes for rollback\n vector> changedCounts;\n changedCounts.reserve((int)members[s].size()*2);\n vector> changedAssign; // (k, oldStation)\n vector> changedAdist; // (k, oldDist)\n vector> changedCnt; // (station, delta)\n vector> changedP; // (station, oldP)\n auto touchP = [&](int st){\n changedP.push_back({st, P[st]});\n };\n auto addCount = [&](int st, int distv, int delta){\n int id = idxc(st, distv);\n changedCounts.push_back({id, counts[id]});\n counts[id] += delta;\n };\n auto addCnt = [&](int st, int delta){\n changedCnt.push_back({st, cnt[st]});\n cnt[st] += delta;\n };\n\n // We'll do a simple greedy reassign of these residents\n bool ok2 = true;\n\n // Pre-touch P for stations that may change (targets), stored lazily\n vector pTouched(N, 0);\n auto ensureTouch = [&](int st){\n if (!pTouched[st]) { pTouched[st]=1; touchP(st); }\n };\n\n // Touch s as well\n ensureTouch(s);\n\n for (int k : members[s]) {\n int oldS = assign[k];\n int oldD = adist[k];\n // remove from s\n addCount(oldS, oldD, -1);\n addCnt(oldS, -1);\n\n // choose best target t != s\n long long bestDelta = INFLL;\n int bestT = -1, bestDt = 0;\n\n for (auto [dt, t] : cand[k]) {\n if (!U[t] || t == s) continue;\n int Pt = P[t];\n int newPt = max(Pt, dt);\n long long delta = 1LL*newPt*newPt - 1LL*Pt*Pt;\n if (delta < bestDelta) {\n bestDelta = delta;\n bestT = t;\n bestDt = dt;\n }\n }\n if (bestT < 0) { ok2 = false; break; }\n\n // add to bestT\n ensureTouch(bestT);\n addCount(bestT, bestDt, +1);\n addCnt(bestT, +1);\n if (bestDt > P[bestT]) P[bestT] = bestDt;\n\n changedAssign.push_back({k, oldS});\n changedAdist.push_back({k, oldD});\n assign[k] = bestT;\n adist[k] = bestDt;\n }\n\n if (ok2) {\n // recompute P for s (should become 0 if emptied) and also for any station where top bucket might be gone\n auto fix_station = [&](int st){\n if (cnt[st] == 0) { P[st] = 0; return; }\n int curMax = P[st];\n if (curMax > 0 && counts[idxc(st, curMax)] == 0) P[st] = recompute_max_down(st, curMax-1);\n };\n // Fix all touched P stations\n for (int st = 0; st < N; st++) if (pTouched[st]) fix_station(st);\n\n long long newS = compute_total_cost(P);\n if (newS < curS) {\n // accept\n curS = newS;\n // rebuild members list incrementally is hard; simplest: rebuild fully\n members.assign(N, {});\n for (int kk = 0; kk < K; kk++) members[assign[kk]].push_back(kk);\n // update small set later; just continue\n continue;\n }\n }\n\n // rollback\n for (auto &pr : changedAssign) assign[pr.first] = pr.second;\n for (auto &pr : changedAdist) adist[pr.first] = pr.second;\n for (auto &pr : changedCnt) cnt[pr.first] = pr.second;\n for (auto &pr : changedCounts) counts[pr.first] = pr.second;\n for (auto &pr : changedP) P[pr.first] = pr.second;\n }\n }\n\n long long radCost = 0;\n for (int i = 0; i < N; i++) radCost += 1LL*P[i]*P[i];\n\n auto [B, edgeCost] = build_cables(P);\n if (edgeCost >= INFLL/2) continue;\n\n long long S = radCost + edgeCost;\n if (S < best.S) {\n best.valid = true;\n best.S = S;\n best.P = std::move(P);\n best.B = std::move(B);\n best.cnt = std::move(cnt);\n best.assign = std::move(assign);\n best.adist = std::move(adist);\n }\n }\n return best;\n };\n\n EvalResult bestGlobal;\n bestGlobal.valid = false;\n bestGlobal.S = INFLL;\n\n int outerRestarts = 3;\n\n for (int rep = 0; rep < outerRestarts && elapsed_ms() < 1850; rep++) {\n vector U(N, 1);\n U[0] = 1;\n\n EvalResult cur = evaluate(U, /*trials=*/1, /*shuffle=*/true, /*improvePasses=*/0, /*elim=*/false);\n if (!cur.valid) continue;\n\n vector bestU = U;\n long long bestS = cur.S;\n\n const int SA_IT = 320;\n double T0 = 7e7, T1 = 6e5;\n\n for (int it = 0; it < SA_IT && elapsed_ms() < 1650; it++) {\n double tt = (double)it / max(1, SA_IT-1);\n double T = T0 * (1.0 - tt) + T1 * tt;\n\n int v = uniform_int_distribution(1, N-1)(rng);\n U[v] ^= 1;\n\n EvalResult nxt = evaluate(U, 1, true, 0, false);\n if (!nxt.valid) { U[v] ^= 1; continue; }\n\n long long diff = nxt.S - cur.S;\n bool accept = false;\n if (diff <= 0) accept = true;\n else {\n double prob = exp(-(double)diff / T);\n double r = uniform_real_distribution(0.0, 1.0)(rng);\n accept = (r < prob);\n }\n\n if (accept) {\n cur = std::move(nxt);\n if (cur.S < bestS) { bestS = cur.S; bestU = U; }\n } else {\n U[v] ^= 1;\n }\n }\n\n // Finalize bestU with stronger assignment + local improvement + terminal elimination\n EvalResult fin = evaluate(bestU, /*trials=*/3, /*shuffle=*/true, /*improvePasses=*/4, /*elim=*/true);\n if (fin.valid && fin.S < bestGlobal.S) bestGlobal = std::move(fin);\n\n // Greedy removals\n if (elapsed_ms() < 1900) {\n vector U2 = bestU;\n EvalResult base = evaluate(U2, 1, true, 3, true);\n if (base.valid) {\n bool improved = true;\n while (improved && elapsed_ms() < 1900) {\n improved = false;\n vector candStations;\n for (int i = 1; i < N; i++) if (U2[i]) candStations.push_back(i);\n\n sort(candStations.begin(), candStations.end(), [&](int a, int b){\n if (base.cnt[a] != base.cnt[b]) return base.cnt[a] < base.cnt[b];\n if (base.P[a] != base.P[b]) return base.P[a] < base.P[b];\n return a < b;\n });\n\n for (int v : candStations) {\n if (elapsed_ms() > 1900) break;\n U2[v] = 0;\n EvalResult nxt = evaluate(U2, 1, true, 3, true);\n if (nxt.valid && nxt.S < base.S) {\n base = std::move(nxt);\n improved = true;\n break;\n } else {\n U2[v] = 1;\n }\n }\n }\n if (base.valid && base.S < bestGlobal.S) bestGlobal = std::move(base);\n }\n }\n }\n\n if (!bestGlobal.valid) {\n for (int i = 0; i < N; i++) { if (i) cout << ' '; cout << 0; }\n cout << \"\\n\";\n for (int j = 0; j < M; j++) { if (j) cout << ' '; cout << 0; }\n cout << \"\\n\";\n return 0;\n }\n\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << bestGlobal.P[i];\n }\n cout << \"\\n\";\n for (int j = 0; j < M; j++) {\n if (j) cout << ' ';\n cout << bestGlobal.B[j];\n }\n cout << \"\\n\";\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nstatic constexpr int N = 30;\nstatic constexpr int M = N * (N + 1) / 2;\n\nstruct OpID { int a, b; }; // swap by node id\nstruct OpXY { int x1,y1,x2,y2; };\n\nenum class ParentPolicy { Larger, Smaller, Random };\n\nstatic inline int id(int x, int y) { return x * (x + 1) / 2 + y; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n vector initVal(M);\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n int v; cin >> v;\n initVal[id(x,y)] = v;\n }\n }\n\n // Precompute coordinates and tree relations\n vector X(M), Y(M);\n for (int x = 0; x < N; x++) for (int y = 0; y <= x; y++) {\n int u = id(x,y);\n X[u] = x; Y[u] = y;\n }\n\n vector> par(M, array{-1,-1}); // parents: (x-1,y-1),(x-1,y)\n vector> child(M, array{-1,-1}); // children: (x+1,y),(x+1,y+1)\n for (int x = 0; x < N; x++) for (int y = 0; y <= x; y++) {\n int u = id(x,y);\n if (x > 0) {\n if (y-1 >= 0) par[u][0] = id(x-1, y-1);\n if (y <= x-1) par[u][1] = id(x-1, y);\n }\n if (x+1 < N) {\n child[u][0] = id(x+1, y);\n child[u][1] = id(x+1, y+1);\n }\n }\n\n // Seed from input (deterministic per case)\n uint64_t h = 1469598103934665603ULL;\n for (int u = 0; u < M; u++) {\n h ^= (uint64_t)initVal[u] + 0x9e3779b97f4a7c15ULL + (h<<6) + (h>>2);\n }\n\n auto choose_parent = [&](int p0, int p1, const vector& val, ParentPolicy pol, mt19937_64 &rng) -> int {\n if (p0 == -1) return p1;\n if (p1 == -1) return p0;\n if (pol == ParentPolicy::Random) return (rng() & 1ULL) ? p0 : p1;\n int a = val[p0], b = val[p1];\n if (pol == ParentPolicy::Larger) return (a > b) ? p0 : p1;\n else return (a < b) ? p0 : p1;\n };\n\n struct Result { vector ops; };\n Result bestRes;\n int bestK = 1000000000;\n\n auto run = [&](int D, int W, int L, ParentPolicy pathPol, ParentPolicy upPol, uint64_t seed) -> Result {\n vector val = initVal;\n vector pos(M, -1); // value -> node id\n for (int u = 0; u < M; u++) pos[val[u]] = u;\n\n vector ops;\n ops.reserve(6000);\n mt19937_64 rng(seed);\n\n auto do_swap = [&](int a, int b) {\n int va = val[a], vb = val[b];\n swap(val[a], val[b]);\n pos[va] = b;\n pos[vb] = a;\n\n // cancel immediate backtrack\n if (!ops.empty() && ops.back().a == b && ops.back().b == a) {\n ops.pop_back();\n return;\n }\n ops.push_back({a,b});\n };\n\n auto can_more = [&]() { return (int)ops.size() < 10000; };\n\n // ---- Phase A: pull-up min in depth window W for top D levels ----\n if (D >= 0) {\n D = min(D, N-1);\n W = max(0, min(W, N-1));\n for (int sx = 0; sx <= D && can_more(); sx++) {\n for (int sy = 0; sy <= sx && can_more(); sy++) {\n int root = id(sx, sy);\n int best = root;\n int bestv = val[root];\n\n int maxx = min(N-1, sx + W);\n for (int x = sx; x <= maxx; x++) {\n int dx = x - sx;\n for (int y = sy; y <= sy + dx; y++) {\n int u = id(x,y);\n int v = val[u];\n if (v < bestv) { bestv = v; best = u; }\n }\n }\n\n // pull best up to root with flexible path; need exactly (Y[best]-sy) left moves\n int u = best;\n while (can_more() && X[u] > sx) {\n int x = X[u], y = Y[u];\n int rem = x - sx;\n int leftNeed = y - sy;\n\n bool canLeft = (leftNeed > 0); // parent (x-1,y-1) == par[u][0]\n bool canRight = (leftNeed < rem); // parent (x-1,y) == par[u][1]\n\n int pu;\n if (canLeft && canRight) {\n int pL = par[u][0];\n int pR = par[u][1];\n pu = choose_parent(pL, pR, val, pathPol, rng);\n } else if (canLeft) {\n pu = par[u][0];\n } else {\n pu = par[u][1];\n }\n do_swap(u, pu);\n u = pu;\n }\n }\n }\n }\n\n // ---- Phase B: bubble-up smallest L values ----\n L = min(L, M);\n for (int v = 0; v < L && can_more(); v++) {\n while (can_more()) {\n int u = pos[v];\n if (X[u] == 0) break;\n\n int cur = val[u];\n int p0 = par[u][0], p1 = par[u][1];\n bool ok0 = (p0 != -1 && val[p0] > cur);\n bool ok1 = (p1 != -1 && val[p1] > cur);\n if (!ok0 && !ok1) break;\n\n int pu;\n if (ok0 && ok1) pu = choose_parent(p0, p1, val, upPol, rng);\n else pu = ok0 ? p0 : p1;\n\n do_swap(u, pu);\n }\n }\n\n // ---- Phase C: Floyd heapify (sift-down bottom-up), guarantees E=0 ----\n auto siftDown = [&](int start) {\n int u = start;\n while (can_more()) {\n int c0 = child[u][0], c1 = child[u][1];\n if (c0 == -1) break; // leaf\n\n int best = u;\n if (val[c0] < val[best]) best = c0;\n if (c1 != -1 && val[c1] < val[best]) best = c1;\n\n if (best == u) break;\n do_swap(u, best);\n u = best;\n }\n };\n\n for (int x = N-2; x >= 0 && can_more(); x--) {\n for (int y = 0; y <= x && can_more(); y++) {\n siftDown(id(x,y));\n }\n }\n\n return Result{ops};\n };\n\n // Time management\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed_ms = [&]() {\n return chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n };\n\n // Small deterministic candidate set (fast)\n vector Ds = {-1, 0, 4, 6};\n vector Ws = {6, 10, 29};\n vector Ls = {0, 60, 120, 180, 240};\n vector pols = {ParentPolicy::Larger, ParentPolicy::Random};\n\n for (int D : Ds) for (int W : Ws) for (int L : Ls) {\n for (auto pathPol : pols) for (auto upPol : pols) {\n uint64_t seed = h ^ (uint64_t)(D+7)*1000003ULL ^ (uint64_t)W*10007ULL ^ (uint64_t)L*1315423911ULL\n ^ (uint64_t)((int)pathPol+1)*97531ULL ^ (uint64_t)((int)upPol+1)*864197531ULL;\n auto res = run(D,W,L,pathPol,upPol,seed);\n if ((int)res.ops.size() < bestK) { bestK = (int)res.ops.size(); bestRes = std::move(res); }\n }\n }\n\n // Short random search (strictly bounded)\n mt19937_64 rng(h ^ 0x1234567890abcdefULL);\n while (elapsed_ms() < 1850.0) {\n int D;\n uint64_t t = rng() % 100;\n if (t < 20) D = -1;\n else D = (int)(rng() % 8); // 0..7\n\n int W = (rng()%10 == 0) ? 29 : (int)(rng()%13); // often small, sometimes deep\n int L = (int)(rng() % 261);\n\n ParentPolicy pathPol = pols[(size_t)(rng() % pols.size())];\n ParentPolicy upPol = pols[(size_t)(rng() % pols.size())];\n\n auto res = run(D,W,L,pathPol,upPol,rng());\n if ((int)res.ops.size() < bestK) { bestK = (int)res.ops.size(); bestRes = std::move(res); }\n }\n\n // Output\n cout << bestK << \"\\n\";\n for (auto &op : bestRes.ops) {\n int a = op.a, b = op.b;\n cout << X[a] << \" \" << Y[a] << \" \" << X[b] << \" \" << Y[b] << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nstatic constexpr int D = 9;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n uint32_t next_u32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n int next_int(int n) { return (int)(next_u32() % (uint32_t)n); }\n};\n\nstruct Cell { int r, c; };\n\n// Fenwick for n<=80 with fixed storage (cheap copy).\nstruct FenwickFixed {\n int n = 0;\n array bit{};\n FenwickFixed(int n_=0): n(n_) { bit.fill(0); }\n void add(int i, int v) { // 0-indexed\n for (i++; i <= n; i += i & -i) bit[i] += v;\n }\n int sumPrefix(int i) const { // sum [0..i)\n int s = 0;\n for (; i > 0; i -= i & -i) s += bit[i];\n return s;\n }\n int sumLess(int x) const { return sumPrefix(x); } // count of < x\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Din, N;\n cin >> Din >> N;\n int ent_r = 0, ent_c = (D - 1) / 2;\n\n bool obstacle[D][D]{};\n for (int k = 0; k < N; k++) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n }\n\n int M = D * D - 1 - N; // labels 0..M-1\n\n int dr[4] = {1,-1,0,0};\n int dc[4] = {0,0,1,-1};\n\n auto idx = [&](int r,int c){ return r*D + c; };\n auto rc = [&](int id)->Cell{ return {id/D, id%D}; };\n int entId = idx(ent_r, ent_c);\n\n // ---------- Static BFS distance (obstacles only) ----------\n const int INF = 1e9;\n int dist0[D][D];\n for(int i=0;i q;\n dist0[ent_r][ent_c]=0;\n q.push({ent_r, ent_c});\n while(!q.empty()){\n auto [r,c]=q.front(); q.pop();\n for(int k=0;k<4;k++){\n int nr=r+dr[k], nc=c+dc[k];\n if(nr<0||nr>=D||nc<0||nc>=D) continue;\n if(obstacle[nr][nc]) continue;\n if(dist0[nr][nc]!=INF) continue;\n dist0[nr][nc]=dist0[r][c]+1;\n q.push({nr,nc});\n }\n }\n\n // ---------- distRank (near->far) ----------\n vector usable;\n usable.reserve(M);\n for(int i=0;i children[81];\n for(int i=0;i<81;i++){ parentId[i]=-1; children[i].clear(); }\n\n vector order;\n order.reserve(81);\n for(int r=0;r=D||nc<0||nc>=D) continue;\n if(obstacle[nr][nc]) continue;\n if(dist0[nr][nc]==dist0[r][c]-1){\n int pid=idx(nr,nc);\n if(best==-1) best=pid;\n else{\n auto [br,bc]=rc(best);\n if(nr
post=order;\n sort(post.begin(), post.end(), [&](int a,int b){\n auto A=rc(a), B=rc(b);\n int da=dist0[A.r][A.c], db=dist0[B.r][B.c];\n if(da!=db) return da>db;\n return a leaf\n vector usable2 = usable;\n sort(usable2.begin(), usable2.end(), [&](const Cell& a, const Cell& b){\n int sa=subtreeSize[idx(a.r,a.c)];\n int sb=subtreeSize[idx(b.r,b.c)];\n if(sa!=sb) return sa>sb;\n int da=dist0[a.r][a.c], db=dist0[b.r][b.c];\n if(da!=db) return da nodes;\n nodes.reserve(81);\n for(int i=0;i> art(D, vector(D,0));\n int root=id[ent_r][ent_c];\n if(root<0) return art;\n\n int V=(int)nodes.size();\n vector disc(V,0), low(V,0), parent(V,-1);\n vector isArt(V,0);\n int timer=0;\n\n function dfs = [&](int u){\n disc[u]=low[u]=++timer;\n int child=0;\n auto [r,c]=nodes[u];\n for(int k=0;k<4;k++){\n int nr=r+dr[k], nc=c+dc[k];\n if(nr<0||nr>=D||nc<0||nc>=D) continue;\n int v=id[nr][nc];\n if(v<0) continue;\n if(!disc[v]){\n parent[v]=u;\n child++;\n dfs(v);\n low[u]=min(low[u], low[v]);\n if(parent[u]==-1){\n if(child>1) isArt[u]=1;\n }else{\n if(low[v]>=disc[u]) isArt[u]=1;\n }\n }else if(v!=parent[u]){\n low[u]=min(low[u], disc[v]);\n }\n }\n };\n dfs(root);\n\n for(int u=0;u=D||nc<0||nc>=D) continue;\n if(obstacle[nr][nc]) continue;\n if(emptyCell[nr][nc]) d++;\n }\n return d;\n };\n\n // ---------- static peelIndex (farthest-first safe peel) ----------\n int peelIndex[D][D];\n for(int i=0;idb) best={i,j}; }\n else if(gi!=gb){ if(gi> t;\n\n auto art = compute_articulation(emptyCell);\n\n int desiredPeel = (M - 1 - t); // small label => core (large peelIndex)\n int desiredDist = t;\n int desiredSub = t;\n\n Cell chosen{-1,-1};\n long long bestScore = (1LL<<60);\n\n for(int i=0;i isObs;\n for(int i=0;iint{\n auto [r,c]=rc(id);\n return labelAt[r][c];\n };\n\n auto bfs_reachable = [&](const bitset<81>& removedMask){\n bitset<81> reach; reach.reset();\n queue qq;\n reach.set(entId);\n qq.push(entId);\n\n auto isEmptyNow = [&](int id)->bool{\n if(isObs.test(id)) return false;\n if(id==entId) return true;\n return removedMask.test(id);\n };\n\n while(!qq.empty()){\n int v=qq.front(); qq.pop();\n auto [r,c]=rc(v);\n for(int k=0;k<4;k++){\n int nr=r+dr[k], nc=c+dc[k];\n if(nr<0||nr>=D||nc<0||nc>=D) continue;\n int to=idx(nr,nc);\n if(reach.test(to)) continue;\n if(isEmptyNow(to)){\n reach.set(to);\n qq.push(to);\n }\n }\n }\n return reach;\n };\n\n auto frontier_list = [&](const bitset<81>& removedMask, const bitset<81>& reach, array& inFront){\n inFront.fill(0);\n vector front;\n front.reserve(40);\n for(int i=0;i=D||nj<0||nj>=D) continue;\n if(reach.test(idx(ni,nj))){ ok=true; break; }\n }\n if(ok){\n inFront[idc]=1;\n front.push_back(idc);\n }\n }\n return front;\n };\n\n auto unlock_score = [&](int idc, const bitset<81>& removedMask, const array& inFront){\n auto [r,c]=rc(idc);\n int sc=0;\n for(int k=0;k<4;k++){\n int nr=r+dr[k], nc=c+dc[k];\n if(nr<0||nr>=D||nc<0||nc>=D) continue;\n int nb=idx(nr,nc);\n if(isObs.test(nb)) continue;\n if(nb==entId) continue;\n if(removedMask.test(nb)) continue;\n if(inFront[nb]) continue;\n sc++;\n }\n return sc;\n };\n\n struct Node {\n bitset<81> removed;\n FenwickFixed fw;\n long long inv = 0;\n int firstMove = -1;\n };\n\n bitset<81> removed; removed.reset();\n FenwickFixed fw(M);\n for(int x=0;x beam;\n beam.reserve(W);\n beam.push_back(Node{removed, fw, 0LL, -1});\n\n for(int depth=0; depth next;\n next.reserve(W * 14);\n\n for(const auto& nd : beam){\n auto reach = bfs_reachable(nd.removed);\n array inFront;\n auto front = frontier_list(nd.removed, reach, inFront);\n if(front.empty()) continue;\n\n vector byLabel = front;\n sort(byLabel.begin(), byLabel.end(), [&](int a, int b){\n int la=label_of(a), lb=label_of(b);\n if(la!=lb) return la> byUnlock; // (-unlock, id)\n byUnlock.reserve(front.size());\n for(int idc: front){\n int sc = unlock_score(idc, nd.removed, inFront);\n byUnlock.push_back({-sc, idc});\n }\n sort(byUnlock.begin(), byUnlock.end(), [&](auto &x, auto &y){\n if(x.first!=y.first) return x.first> mixed; // (label - 2*unlock, id)\n mixed.reserve(front.size());\n for(int idc: front){\n int sc = unlock_score(idc, nd.removed, inFront);\n int lab = label_of(idc);\n mixed.push_back({lab - 2*sc, idc});\n }\n sort(mixed.begin(), mixed.end(), [&](auto &x, auto &y){\n if(x.first!=y.first) return x.first> coreMix; // (label - beta*subtreeSize, id)\n coreMix.reserve(front.size());\n for(int idc: front){\n int lab = label_of(idc);\n int beta = 1;\n coreMix.push_back({lab - beta*subtreeSize[idc], idc});\n }\n sort(coreMix.begin(), coreMix.end(), [&](auto &x, auto &y){\n if(x.first!=y.first) return x.first cand;\n cand.reserve(32);\n auto addTopInt = [&](const vector& v, int k){\n for(int i=0;i>& v, int k){\n for(int i=0;i 12){\n for(int i=0;i<2;i++) cand.push_back(front[rng.next_int((int)front.size())]);\n }\n\n sort(cand.begin(), cand.end());\n cand.erase(unique(cand.begin(), cand.end()), cand.end());\n\n for(int idc: cand){\n Node ch = nd;\n int lab = label_of(idc);\n ch.inv += ch.fw.sumLess(lab);\n ch.fw.add(lab, -1);\n ch.removed.set(idc);\n if(depth==0) ch.firstMove = idc;\n next.push_back(std::move(ch));\n }\n }\n\n if(next.empty()) break;\n\n auto cmpNode = [&](const Node& a, const Node& b){\n if(a.inv != b.inv) return a.inv < b.inv;\n int la = (a.firstMove==-1)? INT_MAX : label_of(a.firstMove);\n int lb = (b.firstMove==-1)? INT_MAX : label_of(b.firstMove);\n if(la != lb) return la < lb;\n return a.firstMove < b.firstMove;\n };\n\n if((int)next.size() > W){\n nth_element(next.begin(), next.begin()+W, next.end(), cmpNode);\n next.resize(W);\n }\n sort(next.begin(), next.end(), cmpNode);\n beam.swap(next);\n }\n\n int chosen = -1;\n long long bestInv = (1LL<<62);\n int bestFirstLabel = INT_MAX;\n\n for(const auto& nd : beam){\n if(nd.firstMove==-1) continue;\n int fl = label_of(nd.firstMove);\n if(nd.inv < bestInv || (nd.inv==bestInv && fl < bestFirstLabel)){\n bestInv = nd.inv;\n bestFirstLabel = fl;\n chosen = nd.firstMove;\n }\n }\n\n if(chosen==-1){\n auto reach = bfs_reachable(removed);\n array inFront;\n auto front = frontier_list(removed, reach, inFront);\n chosen = *min_element(front.begin(), front.end(), [&](int a,int b){\n return label_of(a) < label_of(b);\n });\n }\n\n auto [r,c]=rc(chosen);\n cout << r << \" \" << c << endl;\n\n int lab = labelAt[r][c];\n fw.add(lab, -1);\n removed.set(chosen);\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nstatic const int N = 50;\nstatic const int M = 100;\n\nstruct Pos { int r, c; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m; // fixed n=50, m=100\n vector> g(n, vector(n));\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) cin >> g[i][j];\n\n const int V = m + 1; // colors 0..m\n auto inside = [&](int r, int c){ return 0 <= r && r < n && 0 <= c && c < n; };\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n\n // origAdj[a][b] = whether adjacency must exist (undirected)\n vector> origAdj(V, vector(V, 0));\n auto setOrigAdj = [&](int a, int b){\n if (a == b) return;\n origAdj[a][b] = origAdj[b][a] = 1;\n };\n\n // Build original adjacency from internal edges\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n if (i + 1 < n) setOrigAdj(g[i][j], g[i+1][j]);\n if (j + 1 < n) setOrigAdj(g[i][j], g[i][j+1]);\n }\n // Adjacency to outside (0) via boundary\n for (int i = 0; i < n; i++) {\n setOrigAdj(0, g[i][0]);\n setOrigAdj(0, g[i][n-1]);\n }\n for (int j = 0; j < n; j++) {\n setOrigAdj(0, g[0][j]);\n setOrigAdj(0, g[n-1][j]);\n }\n\n // inB[c] <=> originally adjacent to 0\n vector inB(V, 0);\n for (int c = 1; c <= m; c++) inB[c] = origAdj[0][c];\n\n // edgeCnt[a][b] for a> edgeCnt(V, vector(V, 0));\n auto addEdgeCnt = [&](int a, int b, int delta){\n if (a == b) return;\n if (a > b) swap(a, b);\n edgeCnt[a][b] += delta;\n };\n auto getEdgeCnt = [&](int a, int b)->int{\n if (a == b) return 0;\n if (a > b) swap(a, b);\n return edgeCnt[a][b];\n };\n\n // Initialize edgeCnt from current grid (initially original, no internal 0)\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n if (i + 1 < n) {\n int a = g[i][j], b = g[i+1][j];\n if (a != b) addEdgeCnt(a, b, +1);\n }\n if (j + 1 < n) {\n int a = g[i][j], b = g[i][j+1];\n if (a != b) addEdgeCnt(a, b, +1);\n }\n }\n // Boundary-outside edges\n for (int i = 0; i < n; i++) {\n addEdgeCnt(0, g[i][0], +1);\n addEdgeCnt(0, g[i][n-1], +1);\n }\n for (int j = 0; j < n; j++) {\n addEdgeCnt(0, g[0][j], +1);\n addEdgeCnt(0, g[n-1][j], +1);\n }\n\n // size and representative for each color 1..m\n vector sz(V, 0);\n vector rep(V, Pos{-1, -1});\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n int c = g[i][j];\n if (c != 0) {\n sz[c]++;\n rep[c] = Pos{i, j};\n }\n }\n\n // BFS visited stamp (for connectivity checks)\n static int vis[N][N];\n int stamp = 1;\n\n auto find_rep_scan = [&](int col)->Pos{\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++)\n if (g[i][j] == col) return Pos{i, j};\n return Pos{-1, -1};\n };\n\n auto count_same_neighbors = [&](int r, int c, int col)->int{\n int cnt = 0;\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 if (g[nr][nc] == col) cnt++;\n }\n return cnt;\n };\n\n // Check connectivity of `col` after removing cell (r,c) from that color (cell will become something else).\n auto connected_after_removal = [&](int col, int r, int c)->bool{\n // leaf shortcut: if removed cell has <=1 same-color neighbor, it cannot disconnect the remainder.\n if (sz[col] <= 2) return true;\n if (count_same_neighbors(r, c, col) <= 1) return true;\n\n Pos st = rep[col];\n if (!(st.r >= 0 && g[st.r][st.c] == col) || (st.r == r && st.c == c)) {\n bool found = false;\n for (int k = 0; k < 4 && !found; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr,nc) && g[nr][nc] == col) {\n st = Pos{nr,nc};\n found = true;\n }\n }\n if (!found) st = find_rep_scan(col);\n if (st.r < 0) return false;\n }\n\n stamp++;\n deque q;\n vis[st.r][st.c] = stamp;\n q.push_back(st);\n int reached = 0;\n\n while (!q.empty()) {\n auto p = q.front(); q.pop_front();\n reached++;\n for (int k = 0; k < 4; k++) {\n int nr = p.r + dr[k], nc = p.c + dc[k];\n if (!inside(nr,nc)) continue;\n if (nr == r && nc == c) continue;\n if (g[nr][nc] != col) continue;\n if (vis[nr][nc] == stamp) continue;\n vis[nr][nc] = stamp;\n q.push_back(Pos{nr,nc});\n }\n }\n return reached == sz[col] - 1;\n };\n\n auto boundary_sides = [&](int r, int c)->int{\n int b = 0;\n if (r == 0) b++;\n if (r == n-1) b++;\n if (c == 0) b++;\n if (c == n-1) b++;\n return b;\n };\n\n // Frontier cells to try deletions more often (boundary + neighbors of existing 0)\n vector frontier;\n frontier.reserve(n*n*4);\n for (int i = 0; i < n; i++) {\n frontier.push_back(Pos{i, 0});\n frontier.push_back(Pos{i, n-1});\n }\n for (int j = 0; j < n; j++) {\n frontier.push_back(Pos{0, j});\n frontier.push_back(Pos{n-1, j});\n }\n\n // RNG + time\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937_64 rng(seed);\n auto startTime = chrono::high_resolution_clock::now();\n const double TL = 1.95;\n\n auto time_ok = [&](){\n double t = chrono::duration(chrono::high_resolution_clock::now() - startTime).count();\n return t < TL;\n };\n\n auto is_neighbor0 = [&](int r, int c)->bool{\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 if (g[nr][nc] == 0) return true;\n }\n return false;\n };\n\n // Try painting cell (r,c) to newCol (0..m), oldCol != 0.\n auto try_paint = [&](int r, int c, int newCol)->bool{\n int oldCol = g[r][c];\n if (oldCol == 0) return false;\n if (oldCol == newCol) return false;\n\n // oldCol must remain non-empty\n if (sz[oldCol] <= 1) return false;\n\n // Collect neighbor colors with multiplicity, including virtual outside(0) for each boundary side.\n vector neigh;\n neigh.reserve(8);\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr,nc)) neigh.push_back(g[nr][nc]);\n }\n int bnd = boundary_sides(r, c);\n for (int t = 0; t < bnd; t++) neigh.push_back(0);\n\n // Constraints for newCol == 0: must not create isolated 0 component.\n if (newCol == 0) {\n if (bnd == 0 && !is_neighbor0(r, c)) return false;\n // Also, 0 must not become adjacent to colors not adjacent-to-0 in original.\n // (i.e., origAdj[0][x] must hold for any neighbor x != 0)\n for (int x : neigh) {\n if (x != 0 && !origAdj[0][x]) return false;\n }\n } else {\n // Adding cell to newCol must keep newCol connected => need adjacent existing newCol cell.\n bool adjNew = false;\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 if (g[nr][nc] == newCol) { adjNew = true; break; }\n }\n if (!adjNew) return false;\n }\n\n // Compute affected pair deltas (small list of at most ~16 entries)\n struct Delta { int a,b, d; };\n array ds;\n int dsz = 0;\n auto add_delta = [&](int a, int b, int dd){\n if (a == b || dd == 0) return;\n if (a > b) swap(a, b);\n for (int i = 0; i < dsz; i++) {\n if (ds[i].a == a && ds[i].b == b) { ds[i].d += dd; return; }\n }\n ds[dsz++] = Delta{a,b,dd};\n };\n\n // Local edge updates: for each neighbor x,\n // oldCol-x edge is removed if oldCol!=x, newCol-x edge is added if newCol!=x.\n // Also forbid creating any adjacency not in original.\n for (int x : neigh) {\n if (oldCol != x) add_delta(oldCol, x, -1);\n if (newCol != x) {\n // If this introduces an edge between newCol and x, it must be allowed in original.\n if (!origAdj[newCol][x]) return false;\n add_delta(newCol, x, +1);\n }\n }\n\n // Connectivity check of oldCol after removing this cell\n if (!connected_after_removal(oldCol, r, c)) return false;\n\n // Check adjacency constraints for affected pairs\n for (int i = 0; i < dsz; i++) {\n int a = ds[i].a, b = ds[i].b, dd = ds[i].d;\n int cur = edgeCnt[a][b];\n int nxt = cur + dd;\n if (nxt < 0) return false;\n if (origAdj[a][b]) {\n if (nxt == 0) return false; // required adjacency must remain\n } else {\n if (nxt != 0) return false; // forbidden adjacency must not appear\n }\n }\n\n // Additionally ensure (0,color) pairs touched still satisfy required/non-required:\n // Already covered by above checks because any created 0-x edge requires origAdj[0][x].\n // But we also might remove 0-x edges. The rule says if origAdj[0][x]==1, must stay >0.\n // Also covered in pair checks.\n\n // Accept move: apply deltas\n for (int i = 0; i < dsz; i++) {\n edgeCnt[ds[i].a][ds[i].b] += ds[i].d;\n }\n\n // Apply recolor\n g[r][c] = newCol;\n sz[oldCol]--;\n if (newCol != 0) {\n sz[newCol]++;\n rep[newCol] = Pos{r,c}; // safe to update to something valid\n }\n if (rep[oldCol].r == r && rep[oldCol].c == c) {\n // try to pick a neighbor, else scan\n Pos cand{-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] == oldCol) { cand = Pos{nr,nc}; break; }\n }\n if (cand.r < 0) cand = find_rep_scan(oldCol);\n rep[oldCol] = cand;\n }\n\n // If we created a 0 cell, its neighbors become good deletion candidates (frontier)\n if (newCol == 0) {\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 if (g[nr][nc] != 0) frontier.push_back(Pos{nr,nc});\n }\n }\n return true;\n };\n\n // Heuristic: do not increase \"internal area\" (colors not originally adjacent to 0).\n auto internal_flag = [&](int col)->int{\n if (col == 0) return 0;\n return inB[col] ? 0 : 1;\n };\n\n // Main loop: mix deletions and recolors\n while (time_ok()) {\n // Choose a cell. Prefer frontier for deletion attempts.\n int r, c;\n bool pickFront = (!frontier.empty() && (rng() % 100) < 70);\n if (pickFront) {\n int idx = (int)(rng() % frontier.size());\n r = frontier[idx].r;\n c = frontier[idx].c;\n frontier[idx] = frontier.back();\n frontier.pop_back();\n } else {\n r = (int)(rng() % n);\n c = (int)(rng() % n);\n }\n if (g[r][c] == 0) continue;\n\n // Try deletion to 0 with decent probability; otherwise try recolor to neighbor color.\n bool tryZero = ((rng() % 100) < 55);\n if (tryZero) {\n (void)try_paint(r, c, 0);\n continue;\n }\n\n // Propose recolor to a neighboring non-zero color\n int oldCol = g[r][c];\n array cand;\n int ksz = 0;\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 x = g[nr][nc];\n if (x == 0 || x == oldCol) continue;\n cand[ksz++] = x;\n }\n if (ksz == 0) continue;\n int newCol = cand[(int)(rng() % ksz)];\n\n // Acceptance rule: never increase internal area; neutral moves accepted with small probability.\n int deltaInternal = internal_flag(newCol) - internal_flag(oldCol);\n if (deltaInternal > 0) continue; // forbid making internal mass larger\n if (deltaInternal == 0) {\n // neutral moves: accept rarely, just to rearrange / escape minor dead-ends\n if ((rng() % 100) >= 7) continue;\n }\n (void)try_paint(r, c, newCol);\n }\n\n // Output final grid\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j) cout << ' ';\n cout << g[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int l, int r) { return l + (int)(next_u64() % (uint64_t)(r - l + 1)); }\n};\n\nstruct Solver {\n int N, D, Q;\n int used = 0;\n int used_sort = 0;\n\n XorShift rng;\n\n // cache[a][b]: -1 if ab, 0 equal, 2 unknown\n vector> cache;\n\n vector order; // ascending (light -> heavy) approximate (but top-K exact)\n vector rankPos; // position in order\n vector west; // pseudo weights\n\n vector> bins;\n vector binSumEst;\n vector binOf;\n\n Solver() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cin >> N >> D >> Q;\n cache.assign(N, vector(N, 2));\n for (int i = 0; i < N; i++) cache[i][i] = 0;\n order.reserve(N);\n rankPos.assign(N, 0);\n west.assign(N, 1.0);\n binOf.assign(N, -1);\n }\n\n char query_sets(const vector& L, const vector& R) {\n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << \"\\n\" << flush;\n string s;\n cin >> s;\n used++;\n return s[0];\n }\n\n int8_t cmp_item(int a, int b) {\n if (a == b) return 0;\n int8_t &c = cache[a][b];\n if (c != 2) return c;\n char res = query_sets(vector{a}, vector{b});\n int8_t ab = 0;\n if (res == '<') ab = -1;\n else if (res == '>') ab = +1;\n else ab = 0;\n cache[a][b] = ab;\n cache[b][a] = (ab == 0 ? 0 : (int8_t)-ab);\n return ab;\n }\n\n // Insert x into current order using up to k comparisons (binary-search-like, can stop early)\n void insert_with_budget(vector& ord, int x, int k) {\n int m = (int)ord.size();\n if (m == 0) { ord.push_back(x); return; }\n if (k <= 0) { ord.push_back(x); return; }\n\n int lo = 0, hi = m;\n while (lo < hi && k > 0) {\n int mid = (lo + hi) >> 1;\n int8_t r = cmp_item(x, ord[mid]);\n used_sort++;\n k--;\n if (r == -1) hi = mid;\n else if (r == +1) lo = mid + 1;\n else { lo = mid; hi = mid; }\n }\n ord.insert(ord.begin() + lo, x);\n }\n\n // Find exact top-K heaviest items using a tournament + frontier extraction.\n // Returns list in descending order (heaviest first). Uses queries; respects budgetLimit.\n vector select_topK_exact(const vector& items, int K, int budgetLimit) {\n if (K <= 0) return {};\n vector> beat(N); // beat[w] stores opponent winners directly beaten by w\n\n vector cur = items;\n // tournament\n while ((int)cur.size() > 1) {\n vector nxt;\n nxt.reserve((cur.size() + 1) / 2);\n for (int i = 0; i + 1 < (int)cur.size(); i += 2) {\n if (used >= budgetLimit) { // cannot continue, return empty (fallback)\n return {};\n }\n int a = cur[i], b = cur[i + 1];\n int8_t r = cmp_item(a, b);\n used_sort++;\n if (r == +1 || (r == 0 && a > b)) { // a heavier\n beat[a].push_back(b);\n nxt.push_back(a);\n } else {\n beat[b].push_back(a);\n nxt.push_back(b);\n }\n }\n if (cur.size() & 1) nxt.push_back(cur.back());\n cur.swap(nxt);\n }\n int mx = cur[0];\n\n vector top;\n top.reserve(K);\n top.push_back(mx);\n\n vector frontier = beat[mx];\n\n // Extract next maxima from frontier (each time: linear scan by comparisons)\n while ((int)top.size() < K && !frontier.empty()) {\n // ensure we don't blow budget: worst-case scan cost = frontier.size()-1\n if (used + (int)frontier.size() >= budgetLimit) break;\n\n int best = frontier[0];\n int bestIdx = 0;\n for (int i = 1; i < (int)frontier.size(); i++) {\n int x = frontier[i];\n int8_t r = cmp_item(best, x);\n used_sort++;\n // if best < x then x is heavier\n if (r == -1 || (r == 0 && x > best)) {\n best = x;\n bestIdx = i;\n }\n }\n // remove best from frontier\n frontier[bestIdx] = frontier.back();\n frontier.pop_back();\n\n top.push_back(best);\n // add those beaten by best\n for (int y : beat[best]) frontier.push_back(y);\n }\n return top; // descending\n }\n\n void build_order() {\n vector items(N);\n iota(items.begin(), items.end(), 0);\n for (int i = N - 1; i >= 1; i--) swap(items[i], items[rng.next_int(0, i)]);\n\n // Reserve some queries for balancing (small but nonzero), unless Q is tiny.\n int reserve = 2 * D;\n reserve = min(reserve, Q / 4);\n if (Q <= 3 * N) reserve = 0;\n int sortBudget = max(0, Q - reserve);\n\n // 1) exact top-K (very valuable for exponential weights)\n // K chosen so that tournament + extraction fits typical budgets.\n int K = 8;\n K = min(K, N);\n // If budget is small, reduce K but still try to get at least the max item.\n if (sortBudget < N - 1 + 10) K = 1;\n else if (sortBudget < N - 1 + 30) K = 3;\n else if (sortBudget < N - 1 + 60) K = 5;\n\n vector topDesc = select_topK_exact(items, K, sortBudget);\n\n vector isTop(N, 0);\n if (!topDesc.empty()) {\n for (int x : topDesc) isTop[x] = 1;\n }\n\n // 2) build approximate order for remaining by insertion within remaining budget\n vector rem;\n rem.reserve(N);\n for (int x : items) if (!isTop[x]) rem.push_back(x);\n\n vector ordRem;\n ordRem.reserve(rem.size());\n if (!rem.empty()) {\n ordRem.push_back(rem[0]);\n for (int i = 1; i < (int)rem.size(); i++) {\n if (used >= sortBudget) { ordRem.push_back(rem[i]); continue; }\n int remItems = (int)rem.size() - i;\n int remQ = sortBudget - used;\n int kins = max(1, remQ / max(1, remItems));\n kins = min(kins, 24);\n insert_with_budget(ordRem, rem[i], kins);\n }\n }\n\n // 3) final order: remaining asc, then topK asc (since topDesc are guaranteed heaviest)\n order.clear();\n for (int x : ordRem) order.push_back(x);\n if (!topDesc.empty()) {\n for (int i = (int)topDesc.size() - 1; i >= 0; i--) order.push_back(topDesc[i]); // asc among topK\n }\n\n // If topDesc failed (budget stop), ensure size N\n if ((int)order.size() < N) {\n vector usedItem(N, 0);\n for (int x : order) usedItem[x] = 1;\n for (int x = 0; x < N; x++) if (!usedItem[x]) order.push_back(x);\n }\n\n for (int i = 0; i < N; i++) rankPos[order[i]] = i;\n\n // Mild exponential mapping across ranks (ratio ~ e^4)\n double base = exp(4.0 / max(1, N - 1));\n for (int i = 0; i < N; i++) west[order[i]] = pow(base, i);\n }\n\n void initial_partition() {\n bins.assign(D, {});\n binSumEst.assign(D, 0.0);\n binOf.assign(N, -1);\n\n vector heavy(order.rbegin(), order.rend());\n\n // Seed: first D heaviest into different bins (avoid empty bins & spread big items)\n int ptr = 0;\n for (int b = 0; b < D; b++) {\n int it = heavy[ptr++];\n bins[b].push_back(it);\n binSumEst[b] += west[it];\n binOf[it] = b;\n }\n // LPT fill\n for (; ptr < (int)heavy.size(); ptr++) {\n int it = heavy[ptr];\n int best = 0;\n for (int b = 1; b < D; b++) if (binSumEst[b] < binSumEst[best]) best = b;\n bins[best].push_back(it);\n binSumEst[best] += west[it];\n binOf[it] = best;\n }\n }\n\n void offline_est_swap(int iters) {\n double total = 0;\n for (double s : binSumEst) total += s;\n double mean = total / D;\n auto sq = [&](double x){ return x*x; };\n\n for (int t = 0; t < iters; t++) {\n int a = rng.next_int(0, N-1);\n int b = rng.next_int(0, N-1);\n if (a == b) continue;\n int A = binOf[a], B = binOf[b];\n if (A == B) continue;\n if ((int)bins[A].size() <= 1) continue;\n if ((int)bins[B].size() <= 1) continue;\n\n double sa = binSumEst[A], sb = binSumEst[B];\n double wa = west[a], wb = west[b];\n double before = sq(sa - mean) + sq(sb - mean);\n double after = sq((sa - wa + wb) - mean) + sq((sb - wb + wa) - mean);\n if (after <= before) {\n auto &VA = bins[A];\n auto &VB = bins[B];\n auto ita = find(VA.begin(), VA.end(), a);\n auto itb = find(VB.begin(), VB.end(), b);\n if (ita == VA.end() || itb == VB.end()) continue;\n *ita = b; *itb = a;\n binOf[a] = B; binOf[b] = A;\n binSumEst[A] = sa - wa + wb;\n binSumEst[B] = sb - wb + wa;\n }\n }\n }\n\n int pick_bin_max_est() {\n int b = 0;\n for (int i = 1; i < D; i++) if (binSumEst[i] > binSumEst[b]) b = i;\n return b;\n }\n int pick_bin_min_est() {\n int b = 0;\n for (int i = 1; i < D; i++) if (binSumEst[i] < binSumEst[b]) b = i;\n return b;\n }\n\n bool apply_move(int bHeavy, int bLight, int x) {\n auto &A = bins[bHeavy];\n auto it = find(A.begin(), A.end(), x);\n if (it == A.end()) return false;\n if ((int)A.size() <= 1) return false;\n A.erase(it);\n bins[bLight].push_back(x);\n binOf[x] = bLight;\n binSumEst[bHeavy] -= west[x];\n binSumEst[bLight] += west[x];\n return true;\n }\n\n vector topK_by_rank_desc(int b, int K) { // heavy first\n vector v = bins[b];\n sort(v.begin(), v.end(), [&](int a, int b){ return rankPos[a] > rankPos[b]; });\n if ((int)v.size() > K) v.resize(K);\n return v;\n }\n\n int find_heaviest_tournament(const vector& cand) {\n int best = cand[0];\n for (int i = 1; i < (int)cand.size(); i++) {\n int x = cand[i];\n int8_t r = cmp_item(best, x);\n // if best < x then x is heavier\n if (r == -1 || (r == 0 && x > best)) best = x;\n }\n return best;\n }\n\n bool trial_move_candidates(int bHeavy, int bLight, vector cand) {\n if ((int)bins[bHeavy].size() <= 1) return false;\n if (cand.empty()) return false;\n\n sort(cand.begin(), cand.end(), [&](int a, int b){ return rankPos[a] < rankPos[b]; }); // light->heavy within candidates\n cand.erase(unique(cand.begin(), cand.end()), cand.end());\n\n auto test_move = [&](int x)->char {\n vector L, R;\n L.reserve(bins[bHeavy].size() - 1);\n R.reserve(bins[bLight].size() + 1);\n for (int it : bins[bHeavy]) if (it != x) L.push_back(it);\n for (int it : bins[bLight]) R.push_back(it);\n R.push_back(x);\n return query_sets(L, R);\n };\n\n int chosen = -1;\n for (int x : cand) {\n if (used >= Q) break;\n char res = test_move(x);\n if (res != '>') { chosen = x; break; }\n }\n if (chosen == -1) chosen = cand.back();\n return apply_move(bHeavy, bLight, chosen);\n }\n\n bool guided_move(int bHeavy, int bLight, int maxSteps) {\n if ((int)bins[bHeavy].size() <= 1) return false;\n vector cand = bins[bHeavy];\n sort(cand.begin(), cand.end(), [&](int a, int b){ return rankPos[a] < rankPos[b]; }); // light->heavy\n\n auto test_move = [&](int x)->char {\n vector L, R;\n L.reserve(bins[bHeavy].size() - 1);\n R.reserve(bins[bLight].size() + 1);\n for (int it : bins[bHeavy]) if (it != x) L.push_back(it);\n for (int it : bins[bLight]) R.push_back(it);\n R.push_back(x);\n return query_sets(L, R);\n };\n\n int lo = 0, hi = (int)cand.size() - 1, ans = -1;\n for (int step = 0; step < maxSteps && lo <= hi && used < Q; step++) {\n int mid = (lo + hi) >> 1;\n char res = test_move(cand[mid]);\n if (res == '>') lo = mid + 1;\n else { ans = mid; hi = mid - 1; }\n }\n if (ans == -1) ans = (int)cand.size() - 1;\n return apply_move(bHeavy, bLight, cand[ans]);\n }\n\n void balancing_phase() {\n double need = N * log2((double)N + 1.0);\n bool confident = (used_sort >= 0.70 * need);\n\n vector heavyStreak(D, 0);\n\n while (used < Q) {\n int bMax = pick_bin_max_est();\n int bMin = pick_bin_min_est();\n if (bins[bMax].empty() || bins[bMin].empty()) {\n query_sets(vector{0}, vector{1});\n continue;\n }\n\n char res = query_sets(bins[bMax], bins[bMin]);\n if (used >= Q) break;\n\n int heavy = -1, light = -1;\n if (res == '>') { heavy = bMax; light = bMin; }\n else if (res == '<') { heavy = bMin; light = bMax; }\n else continue;\n\n for (int b = 0; b < D; b++) heavyStreak[b] = max(0, heavyStreak[b] - 1);\n heavyStreak[heavy] += 2;\n\n if ((int)bins[heavy].size() <= 1) continue;\n\n int rem = Q - used;\n bool moved = false;\n\n // Rare robust extraction if same bin stays heavy (kills outliers)\n if (!moved && heavyStreak[heavy] >= 4 && rem >= 6) {\n int S = min(7, (int)bins[heavy].size());\n vector cand = topK_by_rank_desc(heavy, min(4, S));\n unordered_set st(cand.begin(), cand.end());\n while ((int)cand.size() < S) {\n int x = bins[heavy][rng.next_int(0, (int)bins[heavy].size() - 1)];\n if (st.insert(x).second) cand.push_back(x);\n }\n int xHeavy = find_heaviest_tournament(cand); // costs S-1 queries\n moved = apply_move(heavy, light, xHeavy);\n continue;\n }\n\n if (!moved && confident && rem >= 4) {\n moved = guided_move(heavy, light, min(3, rem));\n }\n if (!moved && rem >= 2) {\n vector cand = topK_by_rank_desc(heavy, min(2, (int)bins[heavy].size()));\n if ((int)bins[heavy].size() >= 2) cand.push_back(bins[heavy][rng.next_int(0, (int)bins[heavy].size() - 1)]);\n moved = trial_move_candidates(heavy, light, cand);\n }\n (void)moved;\n }\n }\n\n void output_answer() {\n vector ans(N, 0);\n for (int b = 0; b < D; b++) for (int x : bins[b]) ans[x] = b;\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << ans[i];\n }\n cout << \"\\n\" << flush;\n }\n\n void solve() {\n build_order();\n initial_partition();\n offline_est_swap(7000);\n balancing_phase();\n while (used < Q) query_sets(vector{0}, vector{1});\n output_answer();\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstatic constexpr int N = 200;\nstatic constexpr int M = 10;\n\nstruct XorShift {\n uint64_t x;\n XorShift() {\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n x = seed ? seed : 88172645463325252ULL;\n }\n uint32_t next_u32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)(x & 0xffffffffu);\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u32() % (uint32_t)(r - l + 1));\n }\n};\n\nstruct SimState {\n vector> st; // bottom -> top\n array, N+1> pos; // value -> (stack, index), (-1,-1) removed\n int cur;\n};\n\nstatic inline int stack_min(const vector& s) {\n int mn = INT_MAX;\n for (int v : s) mn = min(mn, v);\n return mn;\n}\nstatic inline int count_leq(const vector& s, int x) {\n int c = 0;\n for (int v : s) c += (v <= x);\n return c;\n}\n\n// Lower is better.\nstatic inline long long eval_dest(const vector>& st, int cur, int src, int dst,\n int blockSize, int bottomMoved) {\n const auto &d = st[dst];\n int hd = (int)d.size();\n int mind = d.empty() ? INT_MAX : stack_min(d);\n int topd = d.empty() ? INT_MAX : d.back();\n\n const int W1 = 30;\n const int W2 = 10;\n const int W3 = 55; // additional broader window\n int soon = d.empty() ? 0 : count_leq(d, cur + W1);\n int vsoon = d.empty() ? 0 : count_leq(d, cur + W2);\n int bsoon = d.empty() ? 0 : count_leq(d, cur + W3);\n\n long long e = 0;\n\n // burying soon-needed boxes is expensive\n e += 120LL * blockSize * soon;\n e += 260LL * blockSize * vsoon;\n e += 30LL * blockSize * bsoon;\n\n // prefer buffers\n if (d.empty()) e -= 32000;\n\n // height control\n e += 70LL * hd;\n\n // prefer large min/top\n if (mind != INT_MAX) e -= 9LL * mind;\n if (topd != INT_MAX) e -= 2LL * topd;\n\n // mild structure penalty\n if (!d.empty() && topd <= bottomMoved) e += 2500;\n\n // hard avoid stacks whose minimum is extremely soon\n if (mind != INT_MAX && mind <= cur + 8) e += 75000;\n\n (void)src;\n return e;\n}\n\n// Move tail [fromIdx..end) from src to dst, update pos.\nstatic inline void move_tail(SimState &s, int src, int fromIdx, int dst) {\n auto &A = s.st[src];\n auto &B = s.st[dst];\n int oldB = (int)B.size();\n\n for (int k = fromIdx; k < (int)A.size(); k++) {\n int v = A[k];\n s.pos[v] = {dst, oldB + (k - fromIdx)};\n B.push_back(v);\n }\n A.resize(fromIdx);\n}\n\nstatic inline void pop_cur(SimState &s, int stackIdx) {\n int v = s.cur;\n auto &A = s.st[stackIdx];\n A.pop_back();\n s.pos[v] = {-1, -1};\n s.cur++;\n}\n\nstatic long long rollout_energy(SimState s, int steps) {\n long long energy = 0;\n for (int t = 0; t < steps && s.cur <= N; t++) {\n auto [si, idx] = s.pos[s.cur];\n if (si < 0) break;\n auto &A = s.st[si];\n\n if (!A.empty() && A.back() == s.cur) {\n pop_cur(s, si);\n continue;\n }\n\n int start = idx + 1;\n int h = (int)A.size();\n int blockSize = h - start;\n if (blockSize <= 0) break;\n int bottomMoved = A[start];\n\n long long best = (1LL<<62);\n int bestd = -1;\n for (int d = 0; d < M; d++) if (d != si) {\n long long e = eval_dest(s.st, s.cur, si, d, blockSize, bottomMoved);\n if (e < best) { best = e; bestd = d; }\n }\n\n move_tail(s, si, start, bestd);\n energy += (long long)blockSize + 1;\n\n if (!s.st[si].empty() && s.st[si].back() == s.cur) pop_cur(s, si);\n else break;\n }\n return energy;\n}\n\n// Returns top-K destination candidates by eval, plus always includes best empty if exists.\nstatic vector topK_dests(const vector>& st, int cur, int src,\n int blockSize, int bottomMoved, int K) {\n vector> v;\n v.reserve(M-1);\n for (int d = 0; d < M; d++) if (d != src) {\n v.push_back({eval_dest(st, cur, src, d, blockSize, bottomMoved), d});\n }\n sort(v.begin(), v.end());\n vector res;\n for (int i = 0; i < (int)v.size() && i < K; i++) res.push_back(v[i].second);\n\n int bestEmpty = -1;\n long long bestEmptyEval = (1LL<<62);\n for (int d = 0; d < M; d++) if (d != src && st[d].empty()) {\n long long e = eval_dest(st, cur, src, d, blockSize, bottomMoved);\n if (e < bestEmptyEval) { bestEmptyEval = e; bestEmpty = d; }\n }\n if (bestEmpty != -1 && find(res.begin(), res.end(), bestEmpty) == res.end()) res.push_back(bestEmpty);\n return res;\n}\n\nstatic inline bool is_dangerous_dest(const vector>& st, int cur, int dst, int dangerW) {\n if (st[dst].empty()) return false;\n int mn = stack_min(st[dst]);\n return mn <= cur + dangerW;\n}\n\nstatic inline int find_empty_stack(const vector>& st, int forbidden) {\n for (int i = 0; i < (int)st.size(); i++) if (i != forbidden && st[i].empty()) return i;\n return -1;\n}\n\n// Real execution helper: move tail and record op1.\nstatic inline void real_move_tail(vector>& st,\n array, N+1>& pos,\n vector>& ops,\n int src, int fromIdx, int dst) {\n auto &A = st[src];\n auto &B = st[dst];\n int bottomMoved = A[fromIdx];\n ops.emplace_back(bottomMoved, dst + 1);\n\n int oldB = (int)B.size();\n for (int k = fromIdx; k < (int)A.size(); k++) {\n int v = A[k];\n pos[v] = {dst, oldB + (k - fromIdx)};\n B.push_back(v);\n }\n A.resize(fromIdx);\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> st(m);\n for (int i = 0; i < m; i++) {\n st[i].resize(n / m);\n for (int j = 0; j < n / m; j++) cin >> st[i][j];\n }\n\n array, N+1> pos;\n for (auto &p : pos) p = {-1,-1};\n for (int i = 0; i < m; i++) for (int j = 0; j < (int)st[i].size(); j++) pos[st[i][j]] = {i,j};\n\n vector> ops;\n ops.reserve(5000);\n\n XorShift rng;\n\n const int BASE_ROLLOUT = 20;\n const int EXTRA_ROLLOUT_BIG = 10;\n\n const int KDEST_MAIN = 6;\n const int KDEST_SPLIT = 5;\n\n const int SPLIT_W = 26;\n const int MAX_PEEL = 3;\n\n const int BIG_BLOCK = 7;\n const int DANGER_W = 18;\n\n // Emergency peel-to-empty parameters\n const int EM_MAX_PEEL = 6;\n const int EM_SOON_W = 40; // consider peeling if top contains <= cur+EM_SOON_W\n\n int cur = 1;\n while (cur <= n) {\n auto [sidx, idx] = pos[cur];\n auto &S = st[sidx];\n\n if (!S.empty() && S.back() == cur) {\n ops.emplace_back(cur, 0);\n S.pop_back();\n pos[cur] = {-1,-1};\n cur++;\n continue;\n }\n\n int start = idx + 1;\n int h = (int)S.size();\n int blockSize = h - start;\n int bottomMovedMain = S[start];\n\n int rolloutSteps = BASE_ROLLOUT + (blockSize >= BIG_BLOCK ? EXTRA_ROLLOUT_BIG : 0);\n\n auto build_sim = [&]() -> SimState {\n SimState sim;\n sim.st = st;\n sim.pos = pos;\n sim.cur = cur;\n return sim;\n };\n\n struct Plan {\n int type; // 0 whole, 1 peel\n int t;\n int d1, d2; // for type 0: d2 used; for type 1: peel->d1, rest->d2 (d2 may be -1)\n long long score;\n };\n vector plans;\n\n // --- Whole-block plans ---\n {\n vector Ds = topK_dests(st, cur, sidx, blockSize, bottomMovedMain, KDEST_MAIN);\n\n if (blockSize >= BIG_BLOCK) {\n vector safe;\n for (int d : Ds) if (!is_dangerous_dest(st, cur, d, DANGER_W)) safe.push_back(d);\n if (!safe.empty()) Ds.swap(safe);\n }\n\n for (int d2 : Ds) {\n SimState sim = build_sim();\n move_tail(sim, sidx, start, d2);\n long long energy = (long long)blockSize + 1;\n\n if (!sim.st[sidx].empty() && sim.st[sidx].back() == cur) pop_cur(sim, sidx);\n long long future = rollout_energy(sim, rolloutSteps);\n long long imm = eval_dest(st, cur, sidx, d2, blockSize, bottomMovedMain);\n\n long long total = (energy + future) * 100000LL + imm;\n plans.push_back({0, 0, -1, d2, total});\n }\n }\n\n // --- Peel t=1..3 plans ---\n for (int t = 1; t <= MAX_PEEL && t <= blockSize; t++) {\n bool needPeel = false;\n for (int k = h - t; k < h; k++) {\n if (S[k] <= cur + SPLIT_W) { needPeel = true; break; }\n }\n if (!needPeel) continue;\n\n int peelFrom = h - t;\n int bottomMovedPeel = S[peelFrom];\n vector D1 = topK_dests(st, cur, sidx, t, bottomMovedPeel, KDEST_SPLIT);\n\n for (int d1 : D1) {\n SimState sim = build_sim();\n move_tail(sim, sidx, peelFrom, d1);\n\n long long energy = (long long)t + 1;\n long long imm = eval_dest(st, cur, sidx, d1, t, bottomMovedPeel);\n\n auto [ss, ii] = sim.pos[cur];\n if (ss < 0) continue;\n\n // If still blocked, move remaining above cur\n if (!sim.st[ss].empty() && sim.st[ss].back() != cur) {\n int start2 = ii + 1;\n int h2 = (int)sim.st[ss].size();\n int rem = h2 - start2;\n if (rem > 0) {\n int bottom2 = sim.st[ss][start2];\n vector D2 = topK_dests(sim.st, sim.cur, ss, rem, bottom2, KDEST_SPLIT);\n if (rem >= BIG_BLOCK) {\n vector safe2;\n for (int d : D2) if (!is_dangerous_dest(sim.st, sim.cur, d, DANGER_W)) safe2.push_back(d);\n if (!safe2.empty()) D2.swap(safe2);\n }\n\n for (int d2 : D2) {\n SimState sim2 = sim;\n move_tail(sim2, ss, start2, d2);\n long long energy2 = energy + (long long)rem + 1;\n long long imm2 = imm + eval_dest(sim.st, cur, ss, d2, rem, bottom2);\n\n auto [sss, _] = sim2.pos[cur];\n (void)_;\n if (sss < 0) continue;\n if (!sim2.st[sss].empty() && sim2.st[sss].back() == cur) pop_cur(sim2, sss);\n else continue;\n\n long long future = rollout_energy(sim2, rolloutSteps);\n long long total = (energy2 + future) * 100000LL + imm2;\n plans.push_back({1, t, d1, d2, total});\n }\n continue;\n }\n }\n\n // Otherwise cur is already on top\n auto [sss, _] = sim.pos[cur];\n (void)_;\n if (sss >= 0 && !sim.st[sss].empty() && sim.st[sss].back() == cur) {\n pop_cur(sim, sss);\n long long future = rollout_energy(sim, rolloutSteps);\n long long total = (energy + future) * 100000LL + imm;\n plans.push_back({1, t, d1, -1, total});\n }\n }\n }\n\n // --- Emergency peel-to-empty plans (targets rare catastrophic cases) ---\n {\n int empty = find_empty_stack(st, sidx);\n if (empty != -1 && blockSize >= 3) {\n int maxT = min(EM_MAX_PEEL, blockSize);\n for (int t = 1; t <= maxT; t++) {\n // only if peeled contains \"soon\" values\n bool need = false;\n for (int k = h - t; k < h; k++) {\n if (S[k] <= cur + EM_SOON_W) { need = true; break; }\n }\n if (!need) continue;\n\n int peelFrom = h - t;\n int bottomMovedPeel = S[peelFrom];\n\n SimState sim = build_sim();\n // peel to empty (forced)\n move_tail(sim, sidx, peelFrom, empty);\n long long energy = (long long)t + 1;\n long long imm = eval_dest(st, cur, sidx, empty, t, bottomMovedPeel);\n\n auto [ss, ii] = sim.pos[cur];\n if (ss < 0) continue;\n\n if (!sim.st[ss].empty() && sim.st[ss].back() != cur) {\n int start2 = ii + 1;\n int h2 = (int)sim.st[ss].size();\n int rem = h2 - start2;\n if (rem > 0) {\n int bottom2 = sim.st[ss][start2];\n vector D2 = topK_dests(sim.st, sim.cur, ss, rem, bottom2, KDEST_MAIN);\n\n // strong safety for emergency\n vector safe2;\n for (int d : D2) if (!is_dangerous_dest(sim.st, sim.cur, d, DANGER_W + 6)) safe2.push_back(d);\n if (!safe2.empty()) D2.swap(safe2);\n\n for (int d2 : D2) {\n SimState sim2 = sim;\n move_tail(sim2, ss, start2, d2);\n long long energy2 = energy + (long long)rem + 1;\n long long imm2 = imm + eval_dest(sim.st, cur, ss, d2, rem, bottom2);\n\n auto [sss, _] = sim2.pos[cur];\n (void)_;\n if (sss < 0) continue;\n if (!sim2.st[sss].empty() && sim2.st[sss].back() == cur) pop_cur(sim2, sss);\n else continue;\n\n long long future = rollout_energy(sim2, rolloutSteps);\n // Small bonus to encourage using this emergency option when it helps\n long long total = (energy2 + future) * 100000LL + imm2 - 5000;\n plans.push_back({1, t, empty, d2, total});\n }\n continue;\n }\n }\n\n auto [sss, _] = sim.pos[cur];\n (void)_;\n if (sss >= 0 && !sim.st[sss].empty() && sim.st[sss].back() == cur) {\n pop_cur(sim, sss);\n long long future = rollout_energy(sim, rolloutSteps);\n long long total = (energy + future) * 100000LL + imm - 5000;\n plans.push_back({1, t, empty, -1, total});\n }\n }\n }\n }\n\n // Choose best plan\n long long bestScore = (1LL<<62);\n vector bestIds;\n for (int i = 0; i < (int)plans.size(); i++) {\n if (plans[i].score < bestScore) {\n bestScore = plans[i].score;\n bestIds = {i};\n } else if (plans[i].score == bestScore) {\n bestIds.push_back(i);\n }\n }\n int pick = bestIds[rng.next_int(0, (int)bestIds.size() - 1)];\n Plan best = plans[pick];\n\n // Execute in real state\n if (best.type == 0) {\n real_move_tail(st, pos, ops, sidx, start, best.d2);\n\n ops.emplace_back(cur, 0);\n st[sidx].pop_back();\n pos[cur] = {-1,-1};\n cur++;\n } else {\n int t = best.t;\n int peelFrom = (int)st[sidx].size() - t;\n real_move_tail(st, pos, ops, sidx, peelFrom, best.d1);\n\n auto [ss, ii] = pos[cur];\n if (ss >= 0 && !st[ss].empty() && st[ss].back() != cur) {\n int start2 = ii + 1;\n if (start2 < (int)st[ss].size()) {\n real_move_tail(st, pos, ops, ss, start2, best.d2);\n }\n }\n\n auto [sss, _] = pos[cur];\n (void)_;\n ops.emplace_back(cur, 0);\n st[sss].pop_back();\n pos[cur] = {-1,-1};\n cur++;\n }\n\n if ((int)ops.size() > 5000) break;\n }\n\n for (auto [v, i] : ops) cout << v << \" \" << i << \"\\n\";\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstatic inline char opp(char c){\n if(c=='U') return 'D';\n if(c=='D') return 'U';\n if(c=='L') return 'R';\n return 'L';\n}\n\nstruct Timer {\n chrono::high_resolution_clock::time_point st;\n Timer(): st(chrono::high_resolution_clock::now()) {}\n double elapsed() const {\n return chrono::duration(chrono::high_resolution_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;\n cin >> N;\n vector h(N-1), v(N);\n for(int i=0;i> h[i];\n for(int i=0;i> v[i];\n vector> d2(N, vector(N));\n for(int i=0;i> d2[i][j];\n\n int V = N*N;\n auto id = [&](int i,int j){ return i*N + j; };\n auto rc = [&](int x){ return pair(x/N, x%N); };\n\n vector d(V);\n for(int i=0;i>> g(V);\n auto add_edge = [&](int a,int b,char c){\n g[a].push_back({b,c});\n };\n for(int i=0;i distAll((size_t)V*V, INF);\n vector prevAll((size_t)V*V, -1);\n vector moveAll((size_t)V*V, 0);\n\n deque q;\n vector distTmp(V);\n vector prevTmp(V);\n vector moveTmp(V);\n\n for(int s=0;sint{\n return (int)distAll[(size_t)s*V + t];\n };\n\n auto get_path = [&](int s,int t)->string{\n if(s==t) return \"\";\n size_t base=(size_t)s*V;\n if(distAll[base+t]==INF) return \"\";\n string rev;\n int cur=t;\n while(cur!=s){\n char mv = moveAll[base+cur];\n rev.push_back(mv);\n cur = (int)prevAll[base+cur];\n if(cur<0) return \"\";\n }\n reverse(rev.begin(), rev.end());\n return rev;\n };\n\n auto reverse_opp = [&](const string& p)->string{\n string r; r.reserve(p.size());\n for(int i=(int)p.size()-1;i>=0;i--) r.push_back(opp(p[i]));\n return r;\n };\n\n // -------- fast exact eval via timestamp + touched list --------\n vector stamp(V,0), firstT(V,0), lastT(V,0);\n vector sumG(V,0);\n int curStamp=1;\n\n auto eval_route = [&](const string& route)->long double{\n int L=(int)route.size();\n int myStamp=curStamp++;\n if(curStamp==INT_MAX){\n fill(stamp.begin(), stamp.end(), 0);\n curStamp=1;\n myStamp=curStamp++;\n }\n\n vector touched;\n touched.reserve(V);\n\n int ci=0,cj=0;\n for(int t=1;t<=L;t++){\n char c=route[t-1];\n if(c=='U') ci--;\n else if(c=='D') ci++;\n else if(c=='L') cj--;\n else cj++;\n if(ci<0||ci>=N||cj<0||cj>=N) return (long double)1e30;\n int u=id(ci,cj);\n\n if(stamp[u]!=myStamp){\n stamp[u]=myStamp;\n firstT[u]=lastT[u]=t;\n sumG[u]=0;\n touched.push_back(u);\n }else{\n long long gap = t - lastT[u];\n sumG[u] += gap*(gap-1)/2;\n lastT[u]=t;\n }\n }\n if(ci!=0||cj!=0) return (long double)1e30;\n if((int)touched.size()!=V) return (long double)1e30;\n\n __int128 total=0;\n for(int u: touched){\n long long gap = (long long)firstT[u] + L - lastT[u];\n long long s = sumG[u] + gap*(gap-1)/2;\n total += (__int128)d[u] * (__int128)s;\n }\n return (long double)total / (long double)L;\n };\n\n // -------- cover route from anchor (start/end at anchor) --------\n mt19937 rng(1234567);\n\n auto build_cover_route = [&](int anchor)->string{\n vector vis(V,0);\n int pos=anchor;\n vis[pos]=1;\n int unvisited=V-1;\n\n string route;\n route.reserve(30000);\n\n const long double alpha=1.25L;\n const int slack=6;\n\n int guard=0;\n while(unvisited>0 && guard++<20000){\n int minDist=INT_MAX;\n for(int u=0;ulimit) continue;\n long double sc = (long double)d[u] / pow((long double)(du+1), alpha);\n if(sc>best){ best=sc; chosen=u; }\n }\n if(chosen==-1){\n for(int u=0;u0){\n vector rem;\n rem.reserve(unvisited);\n for(int u=0;ud[b]; });\n for(int u: rem){\n string p=get_path(pos,u);\n int ci=pos/N, cj=pos%N;\n for(char mv: p){\n route.push_back(mv);\n if(mv=='U') ci--;\n else if(mv=='D') ci++;\n else if(mv=='L') cj--;\n else cj++;\n pos=id(ci,cj);\n if(!vis[pos]){ vis[pos]=1; unvisited--; }\n }\n }\n if(pos!=anchor){\n string back=get_path(pos,anchor);\n route += back;\n }\n }\n return route;\n };\n\n // -------- choose importance sets --------\n vector dist0(V);\n for(int u=0;u all(V);\n iota(all.begin(), all.end(), 0);\n\n auto top_by = [&](auto scoreFn, int take)->vector{\n vector vec=all;\n sort(vec.begin(), vec.end(), [&](int a,int b){\n long double sa=scoreFn(a), sb=scoreFn(b);\n if(sa!=sb) return sa>sb;\n return d[a]>d[b];\n });\n vector res;\n for(int x: vec){\n if(x==0) continue;\n res.push_back(x);\n if((int)res.size()>=take) break;\n }\n return res;\n };\n\n auto byD = top_by([&](int u){ return (long double)d[u]; }, 20);\n auto byNear = top_by([&](int u){ return (long double)d[u]/(long double)(dist0[u]+1); }, 20);\n const long double beta=0.35L;\n auto byFar = top_by([&](int u){ return (long double)d[u]*pow((long double)(dist0[u]+1), beta); }, 20);\n\n vector important;\n {\n vector tmp;\n tmp.insert(tmp.end(), byD.begin(), byD.end());\n tmp.insert(tmp.end(), byNear.begin(), byNear.end());\n tmp.insert(tmp.end(), byFar.begin(), byFar.end());\n sort(tmp.begin(), tmp.end());\n tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());\n important=tmp;\n if((int)important.size()>45) important.resize(45);\n }\n\n // anchors: widen but cap\n vector anchors;\n anchors.push_back(0);\n for(int x: byD) anchors.push_back(x);\n for(int x: byFar) anchors.push_back(x);\n for(int x: byNear) anchors.push_back(x);\n sort(anchors.begin(), anchors.end());\n anchors.erase(unique(anchors.begin(), anchors.end()), anchors.end());\n if((int)anchors.size()>18) anchors.resize(18);\n\n auto build_r_list = [&](int maxR)->vector{\n vector r;\n auto add=[&](int x){ if(0<=x && x<=maxR) r.push_back(x); };\n add(0);\n for(int i=1;i<=8;i++) add(i);\n int a=1,b=2;\n while(a<=maxR){\n add(a);\n int c=a+b; a=b; b=c;\n }\n add(maxR);\n add(maxR/2);\n sort(r.begin(), r.end());\n r.erase(unique(r.begin(), r.end()), r.end());\n if((int)r.size()>18) r.resize(18);\n return r;\n };\n\n auto append_repeat = [&](string &out, const string& s, int k){\n for(int i=0;ivector{\n vector loops;\n loops.reserve(80);\n\n // 2-step neighbor loops\n for(auto [to,mv]: g[anchor]){\n string lp;\n lp.push_back(mv);\n lp.push_back(opp(mv));\n loops.push_back(lp);\n }\n\n // choose targets by d/(distA+1)\n vector cand=important;\n sort(cand.begin(), cand.end(), [&](int a,int b){\n long double sa=(long double)d[a]/(long double)(get_dist(anchor,a)+1);\n long double sb=(long double)d[b]/(long double)(get_dist(anchor,b)+1);\n if(sa!=sb) return sa>sb;\n return d[a]>d[b];\n });\n if((int)cand.size()>12) cand.resize(12);\n\n auto outback = [&](int t)->string{\n string p=get_path(anchor,t);\n if(p.empty() && t!=anchor) return \"\";\n return p + reverse_opp(p);\n };\n for(int t: cand){\n string lp=outback(t);\n if(!lp.empty() && (int)lp.size()<=3500) loops.push_back(lp);\n }\n\n // star loops with 2..5 centers (few random)\n auto build_star = [&](const vector& centers)->string{\n string cyc;\n for(int c: centers){\n string p=get_path(anchor,c);\n if(p.empty() && c!=anchor) continue;\n cyc += p;\n cyc += reverse_opp(p);\n if((int)cyc.size()>4000) return \"\";\n }\n return cyc;\n };\n for(int m=2;m<=5;m++){\n if((int)cand.size() base(cand.begin(), cand.begin()+m);\n for(int t=0;t<6;t++){\n auto ord=base;\n shuffle(ord.begin(), ord.end(), rng);\n string lp=build_star(ord);\n if(!lp.empty()) loops.push_back(lp);\n }\n }\n\n sort(loops.begin(), loops.end());\n loops.erase(unique(loops.begin(), loops.end()), loops.end());\n // prefer shorter\n sort(loops.begin(), loops.end(), [&](const string& a,const string& b){\n if(a.size()!=b.size()) return a.size()24) loops.resize(24);\n return loops;\n };\n\n // -------- search best --------\n string bestRoute;\n long double bestScore = 1e30;\n\n // only final safety guard; avoid breaking early too aggressively\n const double HARD_TL = 1.98;\n\n // split ratios: 0, 1/2, 1\n auto splits_for = [&](int r)->array{\n return {0, r/2, r};\n };\n\n for(int anchor: anchors){\n if(timer.elapsed() > HARD_TL) break;\n\n string p0a=get_path(0,anchor);\n string pa0=reverse_opp(p0a);\n\n string cover = build_cover_route(anchor);\n\n int fixedLen = (int)p0a.size() + (int)cover.size() + (int)pa0.size();\n if(fixedLen>100000) continue;\n\n // base\n {\n string base;\n base.reserve(fixedLen);\n base += p0a;\n base += cover;\n base += pa0;\n long double sc=eval_route(base);\n if(sc loops = build_anchor_loops(anchor);\n\n for(const string& loop: loops){\n if(timer.elapsed() > HARD_TL) break;\n\n int c=(int)loop.size();\n if(c<=0 || c>budget) continue;\n\n int maxR = budget / c;\n auto rlist = build_r_list(maxR);\n\n int bestR=0;\n long double bestLocal=1e30;\n\n for(int r: rlist){\n auto ss = splits_for(r);\n for(int r1: ss){\n int r2 = r - r1;\n string route;\n route.reserve(fixedLen + r*c);\n route += p0a;\n append_repeat(route, loop, r1);\n route += cover;\n append_repeat(route, loop, r2);\n route += pa0;\n long double sc=eval_route(route);\n if(scmaxR) continue;\n int r1=r/2, r2=r-r1;\n string route;\n route.reserve(fixedLen + r*c);\n route += p0a;\n append_repeat(route, loop, r1);\n route += cover;\n append_repeat(route, loop, r2);\n route += pa0;\n long double sc=eval_route(route);\n if(sc vis(V,0);\n vector it(V,0), st;\n vector ent;\n string base; base.reserve(2*V+10);\n auto g2=g;\n for(int u=0;u d[b.first];\n });\n }\n st.push_back(0);\n ent.push_back(0);\n vis[0]=1;\n while(!st.empty()){\n int u=st.back();\n int &ii=it[u];\n if(ii==(int)g2[u].size()){\n st.pop_back();\n char mv=ent.back(); ent.pop_back();\n if(!st.empty()) base.push_back(opp(mv));\n continue;\n }\n auto [to,mv]=g2[u][ii++];\n if(vis[to]) continue;\n vis[to]=1;\n base.push_back(mv);\n st.push_back(to);\n ent.push_back(mv);\n }\n bestRoute=base;\n }\n\n cout << bestRoute << \"\\n\";\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstatic const long long INF = (1LL << 60);\n\nstruct Timer {\n chrono::steady_clock::time_point st;\n Timer() : st(chrono::steady_clock::now()) {}\n double elapsed_sec() const {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n vector t(M);\n for (int i = 0; i < M; i++) cin >> t[i];\n\n // words as ints\n vector> wchars(M);\n for (int i = 0; i < M; i++) for (int k = 0; k < 5; k++) wchars[i][k] = t[i][k] - 'A';\n\n const int V = N * N;\n const int startCell = si * N + sj;\n\n // coords + dist matrix\n vector X(V), Y(V);\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int id = i * N + j;\n X[id] = i; Y[id] = j;\n }\n static uint8_t distMat[225][225];\n for (int a = 0; a < V; a++) for (int b = 0; b < V; b++) {\n distMat[a][b] = (uint8_t)(abs(X[a] - X[b]) + abs(Y[a] - Y[b]));\n }\n\n // positions per letter\n array, 26> positions;\n for (int c = 0; c < 26; c++) positions[c].clear();\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n positions[grid[i][j] - 'A'].push_back(i * N + j);\n }\n\n // idxInLetter[c][cellId]\n array, 26> idxInLetter;\n for (int c = 0; c < 26; c++) {\n idxInLetter[c].fill(-1);\n for (int k = 0; k < (int)positions[c].size(); k++) idxInLetter[c][positions[c][k]] = k;\n }\n\n // overlaps and added length\n vector> ov(M, vector(M, 0));\n vector> addLen(M, vector(M, 5)); // 5 - ov\n for (int i = 0; i < M; i++) for (int j = 0; j < M; j++) if (i != j) {\n int best = 0;\n for (int l = 4; l >= 1; l--) {\n bool ok = true;\n for (int k = 0; k < l; k++) {\n if (t[i][5 - l + k] != t[j][k]) { ok = false; break; }\n }\n if (ok) { best = l; break; }\n }\n ov[i][j] = (uint8_t)best;\n addLen[i][j] = (uint8_t)(5 - best);\n }\n\n // outgoing max overlap for 1-step lookahead\n vector outMaxOv(M, 0);\n for (int i = 0; i < M; i++) {\n int mx = 0;\n for (int j = 0; j < M; j++) if (i != j) mx = max(mx, (int)ov[i][j]);\n outMaxOv[i] = (uint8_t)mx;\n }\n\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto perm_added_chars = [&](const vector& perm) -> int {\n int s = 0;\n for (int i = 0; i + 1 < M; i++) s += addLen[perm[i]][perm[i + 1]];\n return s;\n };\n\n // DP step for one letter\n auto dp_step = [&](const vector& prevIds, const vector& prevCost, int c,\n vector& curIds, vector& curCost) {\n curIds = positions[c];\n curCost.assign(curIds.size(), INF);\n for (int ui = 0; ui < (int)prevIds.size(); ui++) {\n int u = prevIds[ui];\n long long base = prevCost[ui] + 1; // press\n for (int vi = 0; vi < (int)curIds.size(); vi++) {\n int v = curIds[vi];\n long long cand = base + distMat[u][v];\n if (cand < curCost[vi]) curCost[vi] = cand;\n }\n }\n };\n\n // exact typing cost for permutation superstring (no string construction)\n auto typing_cost_perm = [&](const vector& perm) -> long long {\n vector prevIds(1, startCell), curIds;\n vector prevCost(1, 0), curCost;\n\n int first = perm[0];\n for (int k = 0; k < 5; k++) {\n dp_step(prevIds, prevCost, wchars[first][k], curIds, curCost);\n prevIds.swap(curIds);\n prevCost.swap(curCost);\n }\n for (int i = 1; i < M; i++) {\n int a = perm[i - 1], b = perm[i];\n int o = ov[a][b];\n for (int k = o; k < 5; k++) {\n dp_step(prevIds, prevCost, wchars[b][k], curIds, curCost);\n prevIds.swap(curIds);\n prevCost.swap(curCost);\n }\n }\n long long ans = INF;\n for (auto v : prevCost) ans = min(ans, v);\n return ans;\n };\n\n auto build_string_from_perm = [&](const vector& perm) -> string {\n string S;\n S.reserve(1200);\n S += t[perm[0]];\n for (int i = 1; i < M; i++) {\n int a = perm[i - 1], b = perm[i];\n int o = ov[a][b];\n S += t[b].substr(o);\n }\n return S;\n };\n\n // randomized greedy with 1-step lookahead tie-break\n auto build_perm_greedy = [&]() -> vector {\n vector perm;\n perm.reserve(M);\n vector used(M, 0);\n\n int cur = uniform_int_distribution(0, M - 1)(rng);\n used[cur] = 1;\n perm.push_back(cur);\n\n for (int step = 1; step < M; step++) {\n int bestO = -1;\n for (int j = 0; j < M; j++) if (!used[j]) bestO = max(bestO, (int)ov[cur][j]);\n\n int bestLook = -1;\n vector cand;\n cand.reserve(64);\n\n for (int j = 0; j < M; j++) if (!used[j]) {\n if ((int)ov[cur][j] != bestO) continue;\n int look = (int)outMaxOv[j];\n if (look > bestLook) {\n bestLook = look;\n cand.clear();\n cand.push_back(j);\n } else if (look == bestLook) {\n if ((int)cand.size() < 64) cand.push_back(j);\n else {\n // keep diversity\n if (uniform_int_distribution(0, step)(rng) == 0) {\n cand[uniform_int_distribution(0, 63)(rng)] = j;\n }\n }\n }\n }\n\n int nxt = cand[uniform_int_distribution(0, (int)cand.size() - 1)(rng)];\n used[nxt] = 1;\n perm.push_back(nxt);\n cur = nxt;\n }\n return perm;\n };\n\n // length hill-climb using safe O(M) evaluation per move\n auto improve_by_length = [&](vector& perm, int iters) {\n int curCost = perm_added_chars(perm);\n\n for (int it = 0; it < iters; it++) {\n int mt = uniform_int_distribution(0, 99)(rng);\n if (mt < 55) {\n int a = uniform_int_distribution(0, M - 1)(rng);\n int b = uniform_int_distribution(0, M - 1)(rng);\n if (a == b) continue;\n swap(perm[a], perm[b]);\n int nxtCost = perm_added_chars(perm);\n if (nxtCost <= curCost) curCost = nxtCost;\n else swap(perm[a], perm[b]);\n } else {\n int i = uniform_int_distribution(0, M - 1)(rng);\n int j = uniform_int_distribution(0, M - 1)(rng);\n if (i == j) continue;\n\n int val = perm[i];\n if (i < j) {\n for (int k = i; k < j; k++) perm[k] = perm[k + 1];\n perm[j] = val;\n } else {\n for (int k = i; k > j; k--) perm[k] = perm[k - 1];\n perm[j] = val;\n }\n\n int nxtCost = perm_added_chars(perm);\n if (nxtCost <= curCost) curCost = nxtCost;\n else {\n // undo relocate\n if (i < j) {\n int vv = perm[j];\n for (int k = j; k > i; k--) perm[k] = perm[k - 1];\n perm[i] = vv;\n } else {\n int vv = perm[j];\n for (int k = j; k < i; k++) perm[k] = perm[k + 1];\n perm[i] = vv;\n }\n }\n }\n }\n };\n\n Timer timer;\n const double TIME_LIMIT = 1.90;\n\n vector bestPerm;\n long long bestType = INF;\n int bestAdded = INT_MAX;\n\n // Many candidates\n int tries = 0;\n while (timer.elapsed_sec() < TIME_LIMIT * 0.90) {\n vector perm = build_perm_greedy();\n\n // reduce per-try work to allow more tries\n improve_by_length(perm, 1800);\n\n long long T = typing_cost_perm(perm);\n int A = perm_added_chars(perm);\n if (T < bestType || (T == bestType && A < bestAdded)) {\n bestType = T;\n bestAdded = A;\n bestPerm = perm;\n }\n tries++;\n }\n\n if (bestPerm.empty()) {\n bestPerm.resize(M);\n iota(bestPerm.begin(), bestPerm.end(), 0);\n bestType = typing_cost_perm(bestPerm);\n bestAdded = perm_added_chars(bestPerm);\n }\n\n // Final safe hillclimb on objective = typingCost + addedChars\n // (extra chars always cost >= 1 per char, so this is a reasonable stable penalty)\n {\n auto objective = [&](const vector& p)->long long {\n return typing_cost_perm(p) + (long long)perm_added_chars(p);\n };\n long long bestObj = bestType + (long long)bestAdded;\n\n vector cur = bestPerm;\n long long curObj = bestObj;\n\n while (timer.elapsed_sec() < TIME_LIMIT * 0.965) {\n int mt = uniform_int_distribution(0, 99)(rng);\n\n vector nxt = cur;\n int dlen = 0;\n\n if (mt < 50) {\n int a = uniform_int_distribution(0, M - 1)(rng);\n int b = uniform_int_distribution(0, M - 1)(rng);\n if (a == b) continue;\n swap(nxt[a], nxt[b]);\n } else if (mt < 85) {\n int i = uniform_int_distribution(0, M - 1)(rng);\n int j = uniform_int_distribution(0, M - 1)(rng);\n if (i == j) continue;\n int val = nxt[i];\n if (i < j) {\n for (int k = i; k < j; k++) nxt[k] = nxt[k + 1];\n nxt[j] = val;\n } else {\n for (int k = i; k > j; k--) nxt[k] = nxt[k - 1];\n nxt[j] = val;\n }\n } else {\n int l = uniform_int_distribution(0, M - 2)(rng);\n int len = uniform_int_distribution(2, 18)(rng);\n int r = min(M - 1, l + len - 1);\n if (l >= r) continue;\n reverse(nxt.begin() + l, nxt.begin() + r + 1);\n }\n\n int aCur = perm_added_chars(cur);\n int aNxt = perm_added_chars(nxt);\n dlen = aNxt - aCur;\n // skip big length increases to keep it stable\n if (dlen > 12) continue;\n\n long long obj = objective(nxt);\n if (obj < curObj) {\n cur = std::move(nxt);\n curObj = obj;\n if (curObj < bestObj) {\n bestObj = curObj;\n bestPerm = cur;\n bestAdded = aNxt;\n bestType = curObj - bestAdded; // since obj = type + added\n }\n }\n }\n }\n\n // Build final string and reconstruct exact minimal typing path\n string S = build_string_from_perm(bestPerm);\n int L = (int)S.size();\n vector letters(L);\n for (int i = 0; i < L; i++) letters[i] = S[i] - 'A';\n\n vector> parent(L);\n vector prevIds(1, startCell);\n vector prevCost(1, 0);\n\n vector lastIds;\n vector lastCost;\n\n for (int p = 0; p < L; p++) {\n int c = letters[p];\n const auto& curIds = positions[c];\n vector curCost(curIds.size(), INF);\n parent[p].assign(curIds.size(), (int16_t)-1);\n\n for (int vi = 0; vi < (int)curIds.size(); vi++) {\n int v = curIds[vi];\n long long bestv = INF;\n int bestPrev = -1;\n for (int ui = 0; ui < (int)prevIds.size(); ui++) {\n int u = prevIds[ui];\n long long cand = prevCost[ui] + distMat[u][v] + 1;\n if (cand < bestv) { bestv = cand; bestPrev = u; }\n }\n curCost[vi] = bestv;\n parent[p][vi] = (int16_t)bestPrev;\n }\n\n prevIds = curIds;\n prevCost.swap(curCost);\n lastIds = prevIds;\n lastCost = prevCost;\n }\n\n int endIdx = 0;\n for (int i = 1; i < (int)lastCost.size(); i++) if (lastCost[i] < lastCost[endIdx]) endIdx = i;\n\n vector ansCells(L);\n int curCell = lastIds[endIdx];\n for (int p = L - 1; p >= 0; p--) {\n ansCells[p] = curCell;\n int c = letters[p];\n int k = idxInLetter[c][curCell];\n curCell = (int)parent[p][k];\n }\n\n for (int p = 0; p < L; p++) {\n int id = ansCells[p];\n cout << (id / N) << ' ' << (id % N) << '\\n';\n }\n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n explicit XorShift(uint64_t seed = 0) {\n if (seed) x ^= seed;\n for (int i = 0; i < 10; i++) next_u64();\n }\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Placement {\n vector cells; // indices in [0, V)\n vector contrib; // per measurement\n vector cover; // per drilled constraint point d: 0/1\n};\n\nenum class MeasType { SUM, DIFF };\n\nstruct Measure {\n MeasType type;\n vector s1; // SUM: set; DIFF: plus set\n vector s2; // DIFF: minus set\n vector w; // weights for all cells\n};\n\nstatic inline void flush_out() { cout << flush; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector>> shapes(M);\n for (int k = 0; k < M; k++) {\n int d; cin >> d;\n shapes[k].resize(d);\n for (int i = 0; i < d; i++) {\n int r, c; cin >> r >> c;\n shapes[k][i] = {r, c};\n }\n }\n\n const int V = N * N;\n const int maxOps = 2 * V;\n int ops = 0;\n\n // known[idx] = drilled exact value else -1\n vector known(V, -1);\n vector must_have(V, 0);\n\n auto inc_ops = [&](int add) { ops += add; };\n auto read_or_exit = [&](T &x) {\n if (!(cin >> x)) exit(0);\n };\n\n auto count_known = [&]() -> int {\n int c = 0;\n for (int v : known) if (v != -1) c++;\n return c;\n };\n auto can_still_fallback = [&]() -> bool {\n int remaining = V - count_known();\n return ops + remaining + 1 <= maxOps;\n };\n\n auto query_set = [&](const vector& idxs) -> long long {\n inc_ops(1);\n cout << \"q \" << (int)idxs.size();\n for (int idx : idxs) cout << \" \" << idx / N << \" \" << idx % N;\n cout << \"\\n\";\n flush_out();\n long long resp;\n read_or_exit(resp);\n return resp;\n };\n\n auto drill_if_unknown = [&](int idx) -> int {\n if (known[idx] != -1) return known[idx];\n inc_ops(1);\n cout << \"q 1 \" << idx / N << \" \" << idx % N << \"\\n\";\n flush_out();\n long long v;\n read_or_exit(v);\n known[idx] = (int)v;\n if (v > 0) must_have[idx] = 1;\n return known[idx];\n };\n\n auto output_answer_mask = [&](const vector& oilMask) -> int {\n inc_ops(1);\n vector> cells;\n cells.reserve(V);\n for (int idx = 0; idx < V; idx++) {\n if (oilMask[idx] || must_have[idx]) cells.push_back({idx / N, idx % N});\n }\n cout << \"a \" << (int)cells.size();\n for (auto [i, j] : cells) cout << \" \" << i << \" \" << j;\n cout << \"\\n\";\n flush_out();\n int ok;\n read_or_exit(ok);\n return ok;\n };\n\n auto inv_est = [&](long long y, int k) -> float {\n // E[y] = k*eps + (1-2eps)*v(S)\n double denom = (1.0 - 2.0 * eps);\n double vhat = ((double)y - (double)k * eps) / denom;\n if (vhat < 0.0) vhat = 0.0;\n double hi = (double)k * (double)M;\n if (vhat > hi) vhat = hi;\n return (float)vhat;\n };\n\n // ---------------- Budgeting for initial divinations ----------------\n // Conservative plan: leave V+1 ops for worst-case fallback even with zero drills.\n int preBudget = max(0, maxOps - (V + 1));\n int K0 = min(16, max(8, V / 25));\n if (K0 + 1 > preBudget) {\n // Too small: just drill-all fallback\n vector oil(V, 0);\n for (int idx = 0; idx < V; idx++) {\n int v = drill_if_unknown(idx);\n if (v > 0) oil[idx] = 1;\n }\n (void)output_answer_mask(oil);\n return 0;\n }\n int qBudget = preBudget - (K0 + 1);\n\n // Build measurement list within qBudget queries.\n // Structured SUM: rows + cols (2N) + quadrants (4)\n // Random DIFF: each uses 2 queries (plus/minus)\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n vector meas;\n meas.reserve(140);\n\n auto add_sum_measure = [&](const vector& S) {\n if ((int)S.size() < 2) return;\n Measure m;\n m.type = MeasType::SUM;\n m.s1 = S;\n m.w.assign(V, 0);\n for (int idx : S) m.w[idx] = 1;\n meas.push_back(std::move(m));\n };\n auto add_diff_measure = [&](const vector& P, const vector& Q) {\n if ((int)P.size() < 2 || (int)Q.size() < 2) return;\n Measure m;\n m.type = MeasType::DIFF;\n m.s1 = P; m.s2 = Q;\n m.w.assign(V, 0);\n for (int idx : P) m.w[idx] = +1;\n for (int idx : Q) m.w[idx] = -1;\n meas.push_back(std::move(m));\n };\n\n int usedQ = 0;\n\n auto try_add_structured = [&]() {\n // rows\n for (int i = 0; i < N; i++) {\n if (usedQ + 1 > qBudget) return;\n vector S;\n S.reserve(N);\n for (int j = 0; j < N; j++) S.push_back(i * N + j);\n add_sum_measure(S);\n usedQ += 1;\n }\n // cols\n for (int j = 0; j < N; j++) {\n if (usedQ + 1 > qBudget) return;\n vector S;\n S.reserve(N);\n for (int i = 0; i < N; i++) S.push_back(i * N + j);\n add_sum_measure(S);\n usedQ += 1;\n }\n // quadrants\n int mid = N / 2;\n vector> ranges = {{0, mid}, {mid, N}};\n for (auto [ri0, ri1] : ranges) for (auto [cj0, cj1] : ranges) {\n if (usedQ + 1 > qBudget) return;\n vector S;\n for (int i = ri0; i < ri1; i++) for (int j = cj0; j < cj1; j++) S.push_back(i * N + j);\n add_sum_measure(S);\n usedQ += 1;\n }\n };\n\n try_add_structured();\n\n // Remaining budget for random DIFF measures\n int remainingQ = qBudget - usedQ;\n int maxRand = min(80, remainingQ / 2); // cap to keep optimization fast\n vector perm(V);\n iota(perm.begin(), perm.end(), 0);\n\n for (int t = 0; t < maxRand; t++) {\n // shuffle perm\n for (int i = V - 1; i >= 1; i--) {\n int j = (int)(rng.next_u64() % (uint64_t)(i + 1));\n swap(perm[i], perm[j]);\n }\n int half = V / 2;\n vector P, Q;\n P.reserve(half); Q.reserve(V - half);\n for (int i = 0; i < V; i++) {\n int idx = perm[i];\n if (i < half) P.push_back(idx);\n else Q.push_back(idx);\n }\n if (usedQ + 2 > qBudget) break;\n add_diff_measure(P, Q);\n usedQ += 2;\n }\n\n int T = (int)meas.size();\n\n // ---------------- Query all measurements ----------------\n vector obs(T, 0.0f);\n for (int t = 0; t < T; t++) {\n if (meas[t].type == MeasType::SUM) {\n long long y = query_set(meas[t].s1);\n obs[t] = inv_est(y, (int)meas[t].s1.size());\n } else {\n long long yP = query_set(meas[t].s1);\n long long yQ = query_set(meas[t].s2);\n float vP = inv_est(yP, (int)meas[t].s1.size());\n float vQ = inv_est(yQ, (int)meas[t].s2.size());\n obs[t] = vP - vQ;\n }\n }\n\n // ---------------- Enumerate placements and precompute contrib ----------------\n vector> placements(M);\n placements.reserve(M);\n\n for (int k = 0; k < M; k++) {\n int maxr = 0, maxc = 0;\n for (auto [r, c] : shapes[k]) { maxr = max(maxr, r); maxc = max(maxc, c); }\n int H = maxr + 1, W = maxc + 1;\n int diMax = N - H, djMax = N - W;\n\n vector ps;\n ps.reserve((diMax + 1) * (djMax + 1));\n\n for (int di = 0; di <= diMax; di++) for (int dj = 0; dj <= djMax; dj++) {\n Placement p;\n p.cells.reserve(shapes[k].size());\n for (auto [r, c] : shapes[k]) p.cells.push_back((di + r) * N + (dj + c));\n\n p.contrib.assign(T, 0);\n for (int t = 0; t < T; t++) {\n int s = 0;\n const auto &w = meas[t].w;\n for (int idx : p.cells) s += (int)w[idx];\n p.contrib[t] = (int16_t)s;\n }\n ps.push_back(std::move(p));\n }\n placements[k] = std::move(ps);\n }\n\n auto build_union_mask = [&](const vector& choice) -> vector {\n vector oil(V, 0);\n for (int k = 0; k < M; k++) {\n for (int idx : placements[k][choice[k]].cells) oil[idx] = 1;\n }\n return oil;\n };\n\n // ---------------- Constraints cover cache ----------------\n vector drilledIdx, drilledVal;\n\n auto rebuild_cover = [&]() {\n int D = (int)drilledIdx.size();\n if (D == 0) return;\n vector mark(V, 0);\n for (int k = 0; k < M; k++) {\n for (auto &p : placements[k]) {\n p.cover.assign(D, 0);\n for (int idx : p.cells) mark[idx] = 1;\n for (int d = 0; d < D; d++) p.cover[d] = (uint8_t)(mark[drilledIdx[d]] ? 1 : 0);\n for (int idx : p.cells) mark[idx] = 0;\n }\n }\n };\n\n // ---------------- Optimizer (coordinate descent) ----------------\n auto optimize_one = [&](int restarts, int sweeps, double Wdrill, const vector* warmStart) -> vector {\n int D = (int)drilledIdx.size();\n\n vector base_res(T);\n vector base_cnt_res(max(1, D));\n\n double bestObj = 1e100;\n vector bestChoice;\n\n int totalRuns = restarts + (warmStart ? 1 : 0);\n for (int run = 0; run < totalRuns; run++) {\n vector choice(M);\n if (warmStart && run == 0) choice = *warmStart;\n else for (int k = 0; k < M; k++) choice[k] = rng.next_int(0, (int)placements[k].size() - 1);\n\n vector pred(T, 0);\n for (int t = 0; t < T; t++) {\n int s = 0;\n for (int k = 0; k < M; k++) s += (int)placements[k][choice[k]].contrib[t];\n pred[t] = s;\n }\n vector cntD(D, 0);\n if (D > 0) {\n for (int d = 0; d < D; d++) {\n int s = 0;\n for (int k = 0; k < M; k++) s += (int)placements[k][choice[k]].cover[d];\n cntD[d] = s;\n }\n }\n\n for (int sw = 0; sw < sweeps; sw++) {\n bool changed = false;\n for (int k = 0; k < M; k++) {\n int curP = choice[k];\n\n for (int t = 0; t < T; t++) {\n int base_pred_t = pred[t] - (int)placements[k][curP].contrib[t];\n base_res[t] = (float)base_pred_t - obs[t];\n }\n if (D > 0) {\n for (int d = 0; d < D; d++) {\n int base_cnt = cntD[d] - (int)placements[k][curP].cover[d];\n base_cnt_res[d] = (float)(base_cnt - drilledVal[d]);\n }\n }\n\n int bestP = curP;\n double bestLocal = 1e100;\n const auto &pk = placements[k];\n\n for (int p = 0; p < (int)pk.size(); p++) {\n double o = 0.0;\n const auto &con = pk[p].contrib;\n for (int t = 0; t < T; t++) {\n float r = base_res[t] + (float)con[t];\n o += (double)r * (double)r;\n }\n if (D > 0) {\n const auto &cov = pk[p].cover;\n for (int d = 0; d < D; d++) {\n float r = base_cnt_res[d] + (float)cov[d];\n o += Wdrill * (double)r * (double)r;\n }\n }\n if (o < bestLocal) { bestLocal = o; bestP = p; }\n }\n\n if (bestP != curP) {\n for (int t = 0; t < T; t++)\n pred[t] += (int)placements[k][bestP].contrib[t] - (int)placements[k][curP].contrib[t];\n if (D > 0) {\n for (int d = 0; d < D; d++)\n cntD[d] += (int)placements[k][bestP].cover[d] - (int)placements[k][curP].cover[d];\n }\n choice[k] = bestP;\n changed = true;\n }\n }\n if (!changed) break;\n }\n\n double obj = 0.0;\n for (int t = 0; t < T; t++) {\n double r = (double)pred[t] - (double)obs[t];\n obj += r * r;\n }\n if (D > 0) {\n for (int d = 0; d < D; d++) {\n double r = (double)cntD[d] - (double)drilledVal[d];\n obj += Wdrill * r * r;\n }\n }\n\n if (obj < bestObj) {\n bestObj = obj;\n bestChoice = std::move(choice);\n }\n }\n\n return bestChoice;\n };\n\n // ---------------- Ensemble entropy drilling ----------------\n auto build_boundary_mask = [&](const vector& oil) -> vector {\n vector b(V, 0);\n for (int idx = 0; idx < V; idx++) {\n int i = idx / N, j = idx % N;\n bool me = oil[idx];\n bool isBound = false;\n if (i > 0 && (bool)oil[(i - 1) * N + j] != me) isBound = true;\n else if (i + 1 < N && (bool)oil[(i + 1) * N + j] != me) isBound = true;\n else if (j > 0 && (bool)oil[i * N + (j - 1)] != me) isBound = true;\n else if (j + 1 < N && (bool)oil[i * N + (j + 1)] != me) isBound = true;\n if (isBound) b[idx] = 1;\n }\n return b;\n };\n\n auto pick_drills_by_entropy = [&](const vector>& sols,\n const vector& boundary,\n int K) -> vector {\n int S = (int)sols.size();\n if (S == 0 || K <= 0) return {};\n vector p(V, 0.0f);\n\n for (const auto& sol : sols) {\n auto oil = build_union_mask(sol);\n for (int idx = 0; idx < V; idx++) p[idx] += oil[idx] ? 1.0f : 0.0f;\n }\n for (int idx = 0; idx < V; idx++) p[idx] /= (float)S;\n\n vector> cand;\n cand.reserve(V);\n for (int idx = 0; idx < V; idx++) {\n if (known[idx] != -1) continue;\n float q = p[idx];\n float ent = q * (1.0f - q); // [0,0.25]\n if (boundary[idx]) ent += 0.05f;\n cand.push_back({ent, idx});\n }\n sort(cand.begin(), cand.end(), [&](auto a, auto b){ return a.first > b.first; });\n\n vector res;\n res.reserve(K);\n for (auto [sc, idx] : cand) {\n if ((int)res.size() >= K) break;\n res.push_back(idx);\n }\n return res;\n };\n\n // ---------------- Main solve loop ----------------\n vector choice = optimize_one(/*restarts=*/6, /*sweeps=*/35, /*Wdrill=*/0.0, nullptr);\n\n for (int round = 0; round < 4; round++) {\n if (!can_still_fallback()) break;\n\n int remaining = V - count_known();\n int slack = maxOps - ops - (remaining + 1);\n if (slack <= 2) {\n auto oil = build_union_mask(choice);\n int ok = output_answer_mask(oil);\n if (ok == 1) return 0;\n break;\n }\n\n auto oilBest = build_union_mask(choice);\n auto boundary = build_boundary_mask(oilBest);\n\n // Build ensemble of constrained solutions\n int S = (round == 0 ? 6 : 8);\n int perRestarts = (round == 0 ? 2 : 3);\n int sweeps = 40 + 5 * round;\n double Wdrill = 120.0 + 60.0 * round;\n\n rebuild_cover(); // ensure cover corresponds to current drilledIdx\n\n vector> sols;\n sols.reserve(S);\n sols.push_back(optimize_one(perRestarts, sweeps, Wdrill, &choice));\n for (int s = 1; s < S; s++) sols.push_back(optimize_one(perRestarts, sweeps, Wdrill, nullptr));\n choice = sols[0];\n\n // Choose number of new drills (use slack, but keep room for answer)\n int K = (round == 0 ? K0 : min(30, max(10, slack / 2)));\n if (K > slack - 1) K = max(0, slack - 1);\n\n auto newDrills = pick_drills_by_entropy(sols, boundary, K);\n for (int idx : newDrills) {\n int v = drill_if_unknown(idx);\n drilledIdx.push_back(idx);\n drilledVal.push_back(v);\n }\n\n // rebuild cover once after drilling\n rebuild_cover();\n\n // Refine and answer\n choice = optimize_one(/*restarts=*/6, /*sweeps=*/45 + 5 * round, Wdrill, &choice);\n auto oil = build_union_mask(choice);\n int ok = output_answer_mask(oil);\n if (ok == 1) return 0;\n }\n\n // Guaranteed fallback: drill remaining unknown cells and answer\n vector oilFinal(V, 0);\n for (int idx = 0; idx < V; idx++) {\n int v = drill_if_unknown(idx);\n if (v > 0) oilFinal[idx] = 1;\n }\n (void)output_answer_mask(oilFinal);\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nusing ll = long long;\nstatic const int W = 1000;\nstatic const ll INF = (1LL<<62);\n\nstruct DemInfo {\n vector s;\n vector pref;\n ll total = 0;\n int D = 0;\n\n void build(const vector& v) {\n s = v;\n sort(s.begin(), s.end());\n D = (int)s.size();\n pref.assign(D + 1, 0);\n for (int i = 0; i < D; i++) pref[i + 1] = pref[i] + s[i];\n total = pref[D];\n }\n\n // 100 * sum max(0, a - cap)\n ll cost_cap(int cap) const {\n int pos = upper_bound(s.begin(), s.end(), cap) - s.begin(); // first > cap\n int cnt = D - pos;\n if (cnt <= 0) return 0;\n ll sum_gt = total - pref[pos];\n ll shortage = sum_gt - 1LL * cap * cnt;\n return 100LL * shortage;\n }\n};\n\nstruct Rect {\n int i0, j0, i1, j1;\n int w() const { return j1 - j0; }\n int h() const { return i1 - i0; }\n int area() const { return w() * h(); }\n};\n\nstatic ll eval_score_sorted_areas(const vector& rects, const vector& demRank) {\n int N = (int)rects.size();\n vector areas(N);\n for (int i = 0; i < N; i++) areas[i] = rects[i].area();\n sort(areas.begin(), areas.end());\n ll tot = 0;\n for (int k = 0; k < N; k++) tot += demRank[k].cost_cap(areas[k]);\n return tot;\n}\n\n/********** Candidate A: DP vertical strips **********/\nstatic vector solve_dp_strips(int N, const vector& demRank) {\n vector> dp(N + 1, vector(W + 1, INF));\n vector> prevW(N + 1, vector(W + 1, -1));\n dp[0][0] = 0;\n\n vector> f(N, vector(W + 1, 0));\n for (int i = 0; i < N; i++) {\n for (int w = 1; w <= W; w++) f[i][w] = demRank[i].cost_cap(W * w);\n }\n\n for (int i = 0; i < N; i++) {\n for (int s = 0; s <= W; s++) if (dp[i][s] < INF) {\n int rem = W - s;\n int need = (N - 1 - i);\n int maxw = rem - need;\n if (maxw < 1) continue;\n for (int w = 1; w <= maxw; w++) {\n int s2 = s + w;\n ll nd = dp[i][s] + f[i][w];\n if (nd < dp[i + 1][s2]) {\n dp[i + 1][s2] = nd;\n prevW[i + 1][s2] = (short)w;\n }\n }\n }\n }\n\n vector widths(N, 1);\n int s = W;\n for (int i = N; i >= 1; i--) {\n int w = prevW[i][s];\n if (w < 0) {\n widths.assign(N, W / N);\n for (int t = 0; t < W % N; t++) widths[N - 1 - t]++;\n break;\n }\n widths[i - 1] = w;\n s -= w;\n }\n\n vector x(N + 1, 0);\n for (int k = 0; k < N; k++) x[k + 1] = x[k] + widths[k];\n x[N] = W;\n\n vector rects(N);\n for (int k = 0; k < N; k++) rects[k] = {0, x[k], W, x[k + 1]};\n return rects;\n}\n\n/********** Candidate B: columns stacking + SA **********/\nstruct Column {\n int l, r; // ranks [l,r)\n int w;\n vector h; // size r-l, sum=1000\n};\n\nstruct Node {\n ll gain;\n int pos;\n bool operator<(const Node& o) const { return gain < o.gain; }\n};\n\nstatic Column recompute_column(int l, int r, int w, const vector& demRank) {\n Column col{l, r, w, {}};\n int m = r - l;\n col.h.assign(m, 1);\n if (m <= 0) return col;\n\n int remaining = W - m;\n int maxH = W - (m - 1);\n\n struct Item { int h; ll c0, c1; };\n vector it(m);\n priority_queue pq;\n\n for (int p = 0; p < m; p++) {\n int rank = l + p;\n it[p].h = 1;\n it[p].c0 = demRank[rank].cost_cap(w * 1);\n it[p].c1 = (maxH >= 2) ? demRank[rank].cost_cap(w * 2) : it[p].c0;\n pq.push({it[p].c0 - it[p].c1, p});\n }\n\n while (remaining > 0 && !pq.empty()) {\n auto [gain, p] = pq.top(); pq.pop();\n if (it[p].h >= maxH) continue;\n it[p].h++;\n it[p].c0 = it[p].c1;\n if (it[p].h < maxH) {\n it[p].c1 = demRank[l + p].cost_cap(w * (it[p].h + 1));\n pq.push({it[p].c0 - it[p].c1, p});\n }\n remaining--;\n }\n\n for (int p = 0; p < m; p++) col.h[p] = it[p].h;\n return col;\n}\n\nstatic vector build_rects_from_columns(const vector& cols) {\n vector rects;\n rects.reserve(60);\n int x = 0;\n for (auto &c : cols) {\n int y = 0;\n for (int hh : c.h) {\n rects.push_back({y, x, y + hh, x + c.w});\n y += hh;\n }\n x += c.w;\n }\n return rects;\n}\n\nstruct ColState {\n int C;\n vector start; // size C+1\n vector width; // size C, sum=1000\n vector cols;\n vector rects; // size N\n ll score = INF;\n};\n\nstatic ColState init_columns_solution(int N, const vector& avgA, const vector& demRank, int C) {\n ColState st;\n st.C = C;\n st.start.assign(C + 1, 0);\n\n // partition ranks into C consecutive groups by equal-size (simple + robust)\n int base = N / C, rem = N % C;\n int cur = 0;\n st.start[0] = 0;\n for (int c = 0; c < C; c++) {\n int sz = base + (c < rem ? 1 : 0);\n cur += sz;\n st.start[c + 1] = cur;\n }\n st.start[C] = N;\n\n // widths proportional to group avg sum\n st.width.assign(C, 1);\n vector gsum(C, 0.0);\n double total = 0.0;\n for (int c = 0; c < C; c++) {\n double s = 0.0;\n for (int k = st.start[c]; k < st.start[c + 1]; k++) s += avgA[k];\n gsum[c] = s;\n total += s;\n }\n vector frac(C, 0.0);\n int used = 0;\n for (int c = 0; c < C; c++) {\n double x = (total > 0 ? 1000.0 * gsum[c] / total : 1000.0 / C);\n int w = (int)floor(x);\n w = max(1, w);\n st.width[c] = w;\n used += w;\n frac[c] = x - floor(x);\n }\n while (used < W) {\n int best = 0;\n for (int c = 1; c < C; c++) if (frac[c] > frac[best]) best = c;\n st.width[best]++; used++;\n frac[best] = -1e9;\n }\n while (used > W) {\n int best = -1;\n for (int c = 0; c < C; c++) if (st.width[c] > 1) {\n if (best < 0 || frac[c] < frac[best]) best = c;\n }\n if (best < 0) break;\n st.width[best]--; used--;\n frac[best] = 1e9;\n }\n\n st.cols.resize(C);\n for (int c = 0; c < C; c++) {\n st.cols[c] = recompute_column(st.start[c], st.start[c + 1], st.width[c], demRank);\n }\n st.rects = build_rects_from_columns(st.cols);\n st.score = eval_score_sorted_areas(st.rects, demRank);\n return st;\n}\n\nstatic void recompute_cols_range(ColState& st, const vector& demRank, int c0, int c1) {\n for (int c = c0; c <= c1; c++) {\n st.cols[c] = recompute_column(st.start[c], st.start[c + 1], st.width[c], demRank);\n }\n st.rects = build_rects_from_columns(st.cols);\n st.score = eval_score_sorted_areas(st.rects, demRank);\n}\n\nstatic ColState improve_columns_solution(ColState st, const vector& demRank, double timeLimitMs) {\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n auto stTime = chrono::high_resolution_clock::now();\n auto ms = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - stTime).count();\n };\n\n int C = st.C;\n ColState best = st;\n ll bestScore = st.score;\n\n const double T0 = 20000.0;\n const double T1 = 30.0;\n\n while (ms() < timeLimitMs) {\n double t = ms() / max(1.0, timeLimitMs);\n double T = pow(T0, 1.0 - t) * pow(T1, t);\n\n int c = uniform_int_distribution(0, C - 2)(rng);\n bool moveBoundary = (uniform_int_distribution(0, 1)(rng) == 0);\n\n ColState cand = st;\n\n if (moveBoundary) {\n int b = c + 1;\n int dir = uniform_int_distribution(0, 1)(rng) ? +1 : -1;\n int leftSize = cand.start[b] - cand.start[b - 1];\n int rightSize = cand.start[b + 1] - cand.start[b];\n if (dir == -1) { if (leftSize <= 1) continue; cand.start[b]--; }\n else { if (rightSize <= 1) continue; cand.start[b]++; }\n recompute_cols_range(cand, demRank, c, c + 1);\n } else {\n int dir = uniform_int_distribution(0, 1)(rng) ? +1 : -1;\n if (dir == +1) {\n if (cand.width[c] <= 1) continue;\n cand.width[c]--; cand.width[c + 1]++;\n } else {\n if (cand.width[c + 1] <= 1) continue;\n cand.width[c]++; cand.width[c + 1]--;\n }\n recompute_cols_range(cand, demRank, c, c + 1);\n }\n\n ll delta = cand.score - st.score;\n bool accept = false;\n if (delta <= 0) accept = true;\n else {\n double prob = exp(-(double)delta / T);\n double r = uniform_real_distribution(0.0, 1.0)(rng);\n if (r < prob) accept = true;\n }\n\n if (accept) st = std::move(cand);\n if (st.score < bestScore) {\n bestScore = st.score;\n best = st;\n }\n }\n return best;\n}\n\n/********** Candidate C: row shelves with per-row DP **********/\nstatic vector dp_widths_for_row(const vector& ranks, int rowH, const vector& demRank) {\n int m = (int)ranks.size();\n vector> dp(m + 1, vector(W + 1, INF));\n vector> prevW(m + 1, vector(W + 1, -1));\n dp[0][0] = 0;\n\n vector> f(m, vector(W + 1, 0));\n for (int i = 0; i < m; i++) {\n int rk = ranks[i];\n for (int w = 1; w <= W; w++) f[i][w] = demRank[rk].cost_cap(rowH * w);\n }\n\n for (int i = 0; i < m; i++) {\n for (int s = 0; s <= W; s++) if (dp[i][s] < INF) {\n int rem = W - s;\n int need = (m - 1 - i);\n int maxw = rem - need;\n if (maxw < 1) continue;\n for (int w = 1; w <= maxw; w++) {\n int s2 = s + w;\n ll nd = dp[i][s] + f[i][w];\n if (nd < dp[i + 1][s2]) {\n dp[i + 1][s2] = nd;\n prevW[i + 1][s2] = (short)w;\n }\n }\n }\n }\n\n vector widths(m, 1);\n int s = W;\n for (int i = m; i >= 1; i--) {\n int w = prevW[i][s];\n if (w < 0) {\n widths.assign(m, W / m);\n for (int t = 0; t < W % m; t++) widths[m - 1 - t]++;\n break;\n }\n widths[i - 1] = w;\n s -= w;\n }\n return widths;\n}\n\nstatic vector solve_shelves(int N, const vector& avgA, const vector& demRank, int R) {\n // Partition ranks into R consecutive groups by equalizing sum(avgA)\n vector> groups;\n groups.reserve(R);\n double total = 0.0;\n for (double x : avgA) total += x;\n double target = (R > 0 ? total / R : total);\n\n int k = 0;\n for (int r = 0; r < R; r++) {\n int remainGroups = R - r;\n int remainItems = N - k;\n int minNeed = remainGroups; // at least 1 each\n int takeMax = remainItems - (remainGroups - 1);\n vector g;\n g.reserve(takeMax);\n\n double sum = 0.0;\n while ((int)g.size() < takeMax) {\n g.push_back(k);\n sum += avgA[k];\n k++;\n if (k >= N) break;\n if ((int)g.size() >= 1 && sum >= target) break;\n }\n groups.push_back(g);\n }\n // Fix in case of rounding issues\n while ((int)groups.size() > 0 && k < N) {\n groups.back().push_back(k++);\n }\n\n // Decide row heights proportional to group avg sum\n vector h(R, 1);\n vector gsum(R, 0.0);\n double gtot = 0.0;\n for (int r = 0; r < R; r++) {\n double s = 0.0;\n for (int rk : groups[r]) s += avgA[rk];\n gsum[r] = s;\n gtot += s;\n }\n vector frac(R, 0.0);\n int used = 0;\n for (int r = 0; r < R; r++) {\n double x = (gtot > 0 ? 1000.0 * gsum[r] / gtot : 1000.0 / R);\n int hh = (int)floor(x);\n hh = max(1, hh);\n h[r] = hh;\n used += hh;\n frac[r] = x - floor(x);\n }\n while (used < W) {\n int best = 0;\n for (int r = 1; r < R; r++) if (frac[r] > frac[best]) best = r;\n h[best]++; used++;\n frac[best] = -1e9;\n }\n while (used > W) {\n int best = -1;\n for (int r = 0; r < R; r++) if (h[r] > 1) {\n if (best < 0 || frac[r] < frac[best]) best = r;\n }\n if (best < 0) break;\n h[best]--; used--;\n frac[best] = 1e9;\n }\n\n // Build rectangles row by row with DP widths\n vector rects;\n rects.reserve(N);\n int y = 0;\n for (int r = 0; r < R; r++) {\n int rowH = h[r];\n auto widths = dp_widths_for_row(groups[r], rowH, demRank);\n int x = 0;\n for (int i = 0; i < (int)groups[r].size(); i++) {\n int ww = widths[i];\n rects.push_back({y, x, y + rowH, x + ww});\n x += ww;\n }\n y += rowH;\n }\n // rects size should be N\n if ((int)rects.size() != N) {\n // fallback to strips\n return solve_dp_strips(N, demRank);\n }\n return rects;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Win, D, N;\n cin >> Win >> D >> N;\n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) for (int k = 0; k < N; k++) cin >> a[d][k];\n\n vector demRank(N);\n for (int k = 0; k < N; k++) {\n vector v(D);\n for (int d = 0; d < D; d++) v[d] = a[d][k];\n demRank[k].build(v);\n }\n\n vector avgA(N, 0.0);\n for (int k = 0; k < N; k++) {\n ll s = 0;\n for (int d = 0; d < D; d++) s += a[d][k];\n avgA[k] = (double)s / (double)D;\n }\n\n auto globalStart = chrono::high_resolution_clock::now();\n auto gms = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - globalStart).count();\n };\n const double TL = 2850.0;\n\n // Candidate A\n vector bestRects = solve_dp_strips(N, demRank);\n ll bestScore = eval_score_sorted_areas(bestRects, demRank);\n\n // Candidate B: columns multi-start + SA\n ColState bestCol; bestCol.score = INF;\n for (int C : {2,3,4,5,6,8,10,12,15,18,20}) {\n if (C > N) continue;\n ColState st = init_columns_solution(N, avgA, demRank, C);\n if (st.score < bestCol.score) bestCol = st;\n if (gms() > TL * 0.28) break;\n }\n if (bestCol.score < INF) {\n double rem = TL - gms();\n if (rem > 250.0) {\n bestCol = improve_columns_solution(bestCol, demRank, max(200.0, rem * 0.65));\n }\n if (bestCol.score < bestScore) {\n bestScore = bestCol.score;\n bestRects = bestCol.rects;\n }\n }\n\n // Candidate C: shelves (try several R quickly)\n for (int R : {2,3,4,5,6,8,10}) {\n if (R > N) continue;\n if (gms() > TL * 0.85) break;\n auto rects = solve_shelves(N, avgA, demRank, R);\n ll sc = eval_score_sorted_areas(rects, demRank);\n if (sc < bestScore) {\n bestScore = sc;\n bestRects = std::move(rects);\n }\n }\n\n // Output: rectangles sorted by area to match sorted demands by k\n vector ord(N);\n iota(ord.begin(), ord.end(), 0);\n stable_sort(ord.begin(), ord.end(), [&](int i, int j){\n return bestRects[i].area() < bestRects[j].area();\n });\n\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n const Rect &rc = bestRects[ord[k]];\n cout << rc.i0 << ' ' << rc.j0 << ' ' << rc.i1 << ' ' << rc.j1 << '\\n';\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nstatic constexpr int N = 9;\nstatic constexpr int M = 20;\nstatic constexpr int POS = 7;\nstatic constexpr int A = M * POS * POS; // 980 actions\nstatic constexpr int MOD = 998244353;\nstatic constexpr int CELLS = N * N;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline int nextInt(int n) { return (int)(nextU64() % (uint64_t)n); }\n inline double nextDouble01() {\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Entry {\n uint8_t cell; // 0..80\n int v; // 0..MOD-1\n};\n\nstatic inline int contribCell(int r, int v) {\n // (r+v mod MOD) - r\n int t = r + v;\n if (t >= MOD) return v - MOD;\n return v;\n}\n\nstruct State {\n array board{};\n array delta{}; // marginal gain of adding each action once\n long long score = 0;\n vector ops; // size K, each in [-1, A-1]\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, K;\n cin >> Nin >> Min >> K;\n\n array a{};\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v; cin >> v;\n a[i * N + j] = v;\n }\n\n int s[M][3][3];\n for (int m = 0; m < M; m++)\n for (int i = 0; i < 3; i++)\n for (int j = 0; j < 3; j++)\n cin >> s[m][i][j];\n\n // Precompute actions as 9 entries (cell, v)\n array, A> action{};\n for (int m = 0; m < M; m++) {\n for (int p = 0; p < POS; p++) for (int q = 0; q < POS; q++) {\n int id = m * 49 + p * 7 + q;\n int k = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int x = p + di, y = q + dj;\n int cell = x * N + y;\n action[id][k++] = Entry{(uint8_t)cell, s[m][di][dj]};\n }\n }\n }\n\n // For each cell, list of (action_id, v_in_that_action_for_this_cell)\n array>, CELLS> affects;\n for (int c = 0; c < CELLS; c++) affects[c].clear();\n for (int id = 0; id < A; id++) {\n for (auto &e : action[id]) {\n affects[e.cell].push_back({id, e.v});\n }\n }\n\n auto decode = [&](int id) {\n int m = id / 49;\n int r = id % 49;\n int p = r / 7;\n int q = r % 7;\n return array{m,p,q};\n };\n\n XorShift64 rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto initState = [&]() -> State {\n State st;\n st.ops.assign(K, -1);\n st.score = 0;\n for (int c = 0; c < CELLS; c++) {\n st.board[c] = a[c];\n st.score += st.board[c];\n }\n // init delta from scratch\n for (int id = 0; id < A; id++) {\n long long d = 0;\n for (auto &e : action[id]) d += contribCell(st.board[e.cell], e.v);\n st.delta[id] = d;\n }\n return st;\n };\n\n auto applyAction = [&](State &st, int id, int sign) {\n if (id < 0) return;\n // Update board, score, and delta[] incrementally via affected cells.\n for (auto &e : action[id]) {\n int c = e.cell;\n int v = e.v;\n int oldr = st.board[c];\n int newr;\n if (sign == +1) {\n newr = oldr + v;\n if (newr >= MOD) newr -= MOD;\n } else {\n newr = oldr - v;\n if (newr < 0) newr += MOD;\n }\n if (newr == oldr) continue;\n st.board[c] = newr;\n st.score += (long long)(newr - oldr);\n\n // This cell's residue changed => update delta for all actions touching this cell\n for (auto &[aid, vv] : affects[c]) {\n st.delta[aid] += (long long)contribCell(newr, vv) - (long long)contribCell(oldr, vv);\n }\n }\n };\n\n auto bestInsert = [&](const State &st) -> pair {\n long long bestD = 0;\n int bestId = -1;\n for (int id = 0; id < A; id++) {\n long long d = st.delta[id];\n if (d > bestD) { bestD = d; bestId = id; }\n }\n return {bestD, bestId};\n };\n\n auto randomTopInsert = [&](const State &st, int TOPT, XorShift64 &rng) -> int {\n // keep top TOPT by delta (positive only), then weighted random by delta\n vector> top;\n top.reserve(TOPT);\n for (int id = 0; id < A; id++) {\n long long d = st.delta[id];\n if (d <= 0) continue;\n if ((int)top.size() < TOPT) {\n top.push_back({d,id});\n if ((int)top.size() == TOPT) {\n make_heap(top.begin(), top.end(), greater<>());\n }\n } else if (d > top.front().first) {\n pop_heap(top.begin(), top.end(), greater<>());\n top.back() = {d,id};\n push_heap(top.begin(), top.end(), greater<>());\n }\n }\n if (top.empty()) return -1;\n long double sum = 0;\n for (auto &p : top) sum += (long double)p.first;\n long double r = (long double)rng.nextDouble01() * sum;\n for (auto &p : top) {\n r -= (long double)p.first;\n if (r <= 0) return p.second;\n }\n return top.back().second;\n };\n\n auto coordPass = [&](State &st) -> bool {\n // 1-slot best response for each slot, shuffled\n vector order(K);\n iota(order.begin(), order.end(), 0);\n for (int i = K - 1; i > 0; i--) swap(order[i], order[rng.nextInt(i + 1)]);\n\n bool changed = false;\n for (int idx : order) {\n int oldId = st.ops[idx];\n if (oldId >= 0) applyAction(st, oldId, -1);\n\n auto [bd, bestId] = bestInsert(st);\n st.ops[idx] = bestId;\n if (bestId >= 0) applyAction(st, bestId, +1);\n\n if (bestId != oldId) changed = true;\n }\n return changed;\n };\n\n auto localOptimize = [&](State &st) {\n for (int it = 0; it < 8; it++) {\n if (!coordPass(st)) break;\n }\n };\n\n auto greedyBuild = [&](State &st, int TOPT) {\n for (int t = 0; t < K; t++) {\n int id;\n if (rng.nextInt(100) < 70) id = randomTopInsert(st, TOPT, rng);\n else id = bestInsert(st).second;\n if (id < 0) break;\n st.ops[t] = id;\n applyAction(st, id, +1);\n }\n };\n\n const double TIME_LIMIT = 1.95;\n auto t0 = chrono::steady_clock::now();\n auto elapsedSec = [&]() -> double {\n return chrono::duration(chrono::steady_clock::now() - t0).count();\n };\n\n // Multi-start initialization (more starts thanks to speedup)\n State best;\n best.score = LLONG_MIN;\n {\n int starts = 10;\n for (int i = 0; i < starts; i++) {\n State st = initState();\n greedyBuild(st, 14);\n localOptimize(st);\n if (st.score > best.score) best = st;\n }\n }\n State cur = best;\n\n // LNS + SA acceptance between local optima\n const double T0 = 3.0e9;\n const double T1 = 5.0e4;\n\n vector contrib(K);\n vector idxs(K);\n\n while (true) {\n double et = elapsedSec();\n if (et >= TIME_LIMIT) break;\n double prog = et / TIME_LIMIT;\n double T = T0 * pow(T1 / T0, prog);\n\n State trial = cur;\n\n // Ruin size schedule: larger early, smaller late\n int ruin = 20 - (int)(12 * prog); // 20 -> 8\n ruin = max(8, min(20, ruin));\n\n // Approx contribution of each op by temporary removal\n for (int i = 0; i < K; i++) {\n idxs[i] = i;\n int id = trial.ops[i];\n if (id < 0) { contrib[i] = 0; continue; }\n long long before = trial.score;\n applyAction(trial, id, -1);\n long long after = trial.score;\n applyAction(trial, id, +1);\n contrib[i] = before - after; // positive if it helps\n }\n\n nth_element(idxs.begin(), idxs.begin() + ruin, idxs.end(),\n [&](int x, int y){ return contrib[x] < contrib[y]; });\n\n vector ruined;\n ruined.reserve(ruin + 8);\n int takeWorst = (ruin * 7) / 10;\n for (int i = 0; i < takeWorst; i++) ruined.push_back(idxs[i]);\n while ((int)ruined.size() < ruin) ruined.push_back(rng.nextInt(K));\n sort(ruined.begin(), ruined.end());\n ruined.erase(unique(ruined.begin(), ruined.end()), ruined.end());\n\n // Ruin\n for (int i : ruined) {\n int id = trial.ops[i];\n if (id >= 0) applyAction(trial, id, -1);\n trial.ops[i] = -1;\n }\n\n // Recreate\n int TOPT = 18;\n for (int i : ruined) {\n int id;\n if (rng.nextInt(100) < 45) id = randomTopInsert(trial, TOPT, rng);\n else id = bestInsert(trial).second;\n trial.ops[i] = id;\n if (id >= 0) applyAction(trial, id, +1);\n }\n\n // Intensify\n localOptimize(trial);\n\n long long deltaScore = trial.score - cur.score;\n bool accept = false;\n if (deltaScore >= 0) accept = true;\n else {\n double prob = exp((double)deltaScore / T);\n if (rng.nextDouble01() < prob) accept = true;\n }\n if (accept) cur = std::move(trial);\n if (cur.score > best.score) best = cur;\n\n if (rng.nextInt(100) < 4) cur = best; // occasional reset to best\n }\n\n // Output non-null ops\n vector> out;\n out.reserve(K);\n for (int i = 0; i < K; i++) {\n if (best.ops[i] >= 0) out.push_back(decode(best.ops[i]));\n }\n\n cout << out.size() << \"\\n\";\n for (auto &x : out) {\n cout << x[0] << \" \" << x[1] << \" \" << x[2] << \"\\n\";\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstatic constexpr int N = 5;\nstatic constexpr int MAXT = 10000;\n\nstruct Pos { int x, y; };\nstatic inline int manhattan(const Pos& a, const Pos& b){ return abs(a.x-b.x)+abs(a.y-b.y); }\nstatic inline bool is_move(char a){ return a=='U'||a=='D'||a=='L'||a=='R'; }\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin; cin >> Nin;\n vector> A(N, vector(N));\n for(int i=0;i> A[i][j];\n\n // Grid: -1 empty else container id\n int grid[N][N];\n for(int i=0;i loc(N*N, Pos{-2,-2});\n vector heldBy(N*N, -1);\n\n int next_in[N] = {0,0,0,0,0};\n\n // Cranes: 0 large, 1..4 small\n vector cpos(N);\n vector hold(N, -1);\n vector alive(N, true);\n cpos[0] = {0,0};\n for(int i=1;ipair{\n if(c=='U') return {-1,0};\n if(c=='D') return {1,0};\n if(c=='L') return {0,-1};\n if(c=='R') return {0,1};\n return {0,0};\n };\n\n auto all_dispatched = [&](){\n for(int id=0; idbool{\n if(!alive[k]) return false;\n if(hold[k]!=-1) return false;\n int x=cpos[k].x, y=cpos[k].y;\n if(grid[x][y]==-1) return false;\n int id=grid[x][y];\n grid[x][y] = -1;\n hold[k] = id;\n heldBy[id] = k;\n loc[id] = Pos{-3,-3};\n return true;\n };\n\n auto drop_container = [&](int k)->bool{\n if(!alive[k]) return false;\n if(hold[k]==-1) return false;\n int x=cpos[k].x, y=cpos[k].y;\n if(grid[x][y]!=-1) return false;\n int id=hold[k];\n hold[k] = -1;\n grid[x][y] = id;\n heldBy[id] = -1;\n loc[id] = Pos{x,y};\n return true;\n };\n\n auto bfs_path_large = [&](Pos s, Pos t, const vector>& blocked)->vector{\n // BFS on 5x5; containers do NOT block large crane, but cranes do (blocked).\n if(blocked[t.x][t.y]) return {};\n queue q;\n int dist[N][N];\n Pos prevp[N][N];\n char prevd[N][N];\n for(int i=0;i rev;\n Pos cur=t;\n while(!(cur.x==s.x && cur.y==s.y)){\n rev.push_back(prevd[cur.x][cur.y]);\n cur=prevp[cur.x][cur.y];\n }\n reverse(rev.begin(), rev.end());\n return rev;\n };\n\n auto count_empty_storage = [&](){\n // Storage pool: columns 2..3 + (0,1) fallback\n int c=0;\n for(int x=0;x>& blocked)->optional{\n Pos best{-1,-1};\n int bestScore = INT_MAX;\n for(int x=0;x out(N);\n deque plan; // for large crane in normal mode\n\n int last_dispatch_turn = -1;\n int total_dispatched = 0;\n\n bool relaxed = false; // allow out-of-order dispatch (still correct gate)\n bool emergency = false; // bomb small cranes + drain everything\n\n auto remaining_containers = [&](){\n return N*N - total_dispatched;\n };\n\n for(int turn=0; turn=N) continue;\n bool crane_holding_here = false;\n for(int k=0;k= 8500 && rem > 0) { emergency = true; relaxed = true; plan.clear(); }\n if(no_disp > 250 && turn > 300) { emergency = true; relaxed = true; plan.clear(); }\n }\n // Relaxed mode (but not full emergency): avoid M3 by draining if stuck moderately.\n if(!relaxed && !emergency){\n int no_disp = (last_dispatch_turn==-1 ? turn : (turn - last_dispatch_turn));\n if(no_disp > 120 && turn > 200) { relaxed = true; plan.clear(); }\n }\n\n // Congestion control (safe): if storage almost full, stop shuttling to exchange.\n bool congested = (!emergency && !relaxed && count_empty_storage() <= 1);\n\n // === Decide desired actions ===\n vector act(N,'.');\n\n // Small cranes\n if(emergency){\n // In emergency: drop if holding, else bomb.\n for(int i=1;i(r,1) unless congested\n auto small_desired = [&](int idx)->char{\n int r=idx;\n int x=cpos[idx].x, y=cpos[idx].y;\n if(x!=r) return '.';\n if(congested){\n // Just stay out of the large crane's way; do not pick new items.\n if(y==0) return 'R'; // try to move to (r,1)\n return '.';\n }\n if(hold[idx]==-1){\n if(y==0){\n if(grid[r][0]!=-1 && grid[r][1]==-1) return 'P';\n return '.';\n }else{\n return 'L';\n }\n }else{\n if(y==0){\n if(grid[r][1]==-1) return 'R';\n return '.';\n }else{\n if(grid[r][1]==-1) return 'Q';\n return '.';\n }\n }\n };\n for(int i=1;i tmpNext = cpos;\n for(int i=1;i> blocked(N, vector(N,false));\n for(int i=1;i=N) continue;\n // We want to stand there empty-handed; receiving happens when cell empty.\n int d=manhattan(cpos[0], Pos{r,0});\n if(d relax now to avoid M3\n relaxed=true;\n plan.clear();\n if(gate_ok){\n auto path=bfs_path_large(cpos[0], gate, blocked);\n for(char c: path) plan.push_back(c);\n plan.push_back('Q');\n }else plan.push_back('.');\n }\n }\n }else{\n auto plan_pick = [&](Pos p){\n auto path=bfs_path_large(cpos[0], p, blocked);\n for(char c: path) plan.push_back(c);\n plan.push_back('P');\n };\n\n // Priority 1: pick any next_needed on ground\n int bestId=-1, bestDist=INT_MAX;\n for(int r=0;rr*N+4) continue;\n if(heldBy[need]!=-1) continue;\n if(loc[need].x<0) continue;\n Pos p=loc[need];\n if(p.y==N-1) continue;\n if(blocked[p.x][p.y]) continue;\n int d=manhattan(cpos[0], p);\n if(d nextPos = cpos;\n for(int i=0;i, N*N> cellTo;\n for(auto &v: cellTo) v.clear();\n\n for(int i=0;ibool{\n bool ma=is_move(act[a]), mb=is_move(act[b]);\n if(ma!=mb) return mb; // staying beats moving\n return a\nusing namespace std;\n\nstatic inline uint64_t splitmix64(uint64_t &x) {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n}\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed=1) : x(seed) {}\n uint64_t nextU64() { return splitmix64(x); }\n int nextInt(int lo, int hi) { return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1)); }\n double nextDouble() { return (nextU64() >> 11) * (1.0 / 9007199254740992.0); }\n};\n\nstatic inline int vid(int r,int c,int N){ return r*N+c; }\n\nstatic inline bool hasEdge(const array& nb, int v) {\n return nb[0] == v || nb[1] == v;\n}\nstatic inline void replaceNeighbor(array& nb, int oldv, int newv) {\n if (nb[0] == oldv) nb[0] = newv;\n else if (nb[1] == oldv) nb[1] = newv;\n}\n\nstatic inline char dirChar(int u, int v, int N) {\n int ur=u/N, uc=u%N;\n int vr=v/N, vc=v%N;\n if (vr==ur-1 && vc==uc) return 'U';\n if (vr==ur+1 && vc==uc) return 'D';\n if (vr==ur && vc==uc-1) return 'L';\n if (vr==ur && vc==uc+1) return 'R';\n return '?';\n}\n\n// Traverse the cycle starting at 0 using nei[0][0] as the first step.\n// If it's a single Hamiltonian cycle, returns true and fills proc0 (length V-1).\nstatic bool traverseChoice0(const vector>& nei, int N, vector& proc0) {\n int V = N*N;\n int start = 0;\n int first = nei[start][0];\n if (first < 0) return false;\n\n proc0.clear();\n proc0.reserve(V-1);\n vector vis(V, 0);\n vis[start]=1;\n\n int prev = start;\n int cur = first;\n for (int step=0; step= V) return false;\n if (vis[cur]) return false;\n vis[cur]=1;\n proc0.push_back(cur);\n\n int n0 = nei[cur][0], n1 = nei[cur][1];\n int nxt = (n0 == prev) ? n1 : n0;\n prev = cur;\n cur = nxt;\n }\n if (cur != start) return false;\n for (int i=0;i>& nei, int N, int r, int c) {\n int a=vid(r,c,N);\n int b=vid(r,c+1,N);\n int c1=vid(r+1,c,N);\n int d=vid(r+1,c+1,N);\n\n bool ab = hasEdge(nei[a], b);\n bool cd = hasEdge(nei[c1], d);\n bool ac = hasEdge(nei[a], c1);\n bool bd = hasEdge(nei[b], d);\n\n FlipRecord rec;\n if (ab && cd && !ac && !bd) {\n // horiz -> vert\n replaceNeighbor(nei[a], b, c1);\n replaceNeighbor(nei[b], a, d);\n replaceNeighbor(nei[c1], d, a);\n replaceNeighbor(nei[d], c1, b);\n rec = {a,b,c1,d,0,true};\n } else if (ac && bd && !ab && !cd) {\n // vert -> horiz\n replaceNeighbor(nei[a], c1, b);\n replaceNeighbor(nei[b], d, a);\n replaceNeighbor(nei[c1], a, d);\n replaceNeighbor(nei[d], b, c1);\n rec = {a,b,c1,d,1,true};\n } else {\n rec.applied=false;\n }\n return rec;\n}\nstatic void undoFlip(vector>& nei, const FlipRecord& rec) {\n if (!rec.applied) return;\n int a=rec.a,b=rec.b,c1=rec.c,d=rec.d;\n if (rec.mode==0) {\n // undo vert->horiz\n replaceNeighbor(nei[a], c1, b);\n replaceNeighbor(nei[b], d, a);\n replaceNeighbor(nei[c1], a, d);\n replaceNeighbor(nei[d], b, c1);\n } else {\n // undo horiz->vert\n replaceNeighbor(nei[a], b, c1);\n replaceNeighbor(nei[b], a, d);\n replaceNeighbor(nei[c1], d, a);\n replaceNeighbor(nei[d], c1, b);\n }\n}\n\n// Build neighbors from a Hamiltonian cycle given as proc order excluding start, with edges 0->proc[0]->...->proc.back()->0\nstatic vector> neighborsFromProcCycle(int N, const vector& proc) {\n int V=N*N;\n vector> nei(V);\n for (int i=0;i nei[i][1]) swap(nei[i][0], nei[i][1]);\n return nei;\n}\n\n// Base cycles\nstatic vector baseCycleA(int N) {\n vector seq; seq.reserve(N*N-1);\n for (int r=1;r=0;r--) {\n int t = (N-1-r);\n if (t%2==0) for (int c=1;c=1;c--) seq.push_back(vid(r,c,N));\n }\n return seq;\n}\nstatic vector baseCycleB(int N) {\n vector seq; seq.reserve(N*N-1);\n for (int c=1;c=0;c--) {\n int t = (N-1-c);\n if (t%2==0) for (int r=1;r=1;r--) seq.push_back(vid(r,c,N));\n }\n return seq;\n}\n\n// 8 symmetries\nstatic inline pair symMap(int s, int r, int c, int N) {\n switch(s) {\n case 0: return {r,c};\n case 1: return {c, N-1-r};\n case 2: return {N-1-r, N-1-c};\n case 3: return {N-1-c, r};\n case 4: return {r, N-1-c};\n case 5: return {N-1-r, c};\n case 6: return {c, r};\n case 7: return {N-1-c, N-1-r};\n }\n return {r,c};\n}\nstatic vector> applySymmetryToCycle(const vector>& nei, int N, int s) {\n int V=N*N;\n vector mp(V);\n for (int r=0;r> out(V);\n for (int v=0; v out[nv][1]) swap(out[nv][0], out[nv][1]);\n }\n return out;\n}\n\nstruct Plan {\n long long cost = (1LL<<62);\n int dir = 0; // 0: proc0 forward, 1: reverse\n int type = 0; // 0: close cycle and dump at start; 1: defer rem (if possible)\n long long B = 0;\n};\n\nstatic Plan evalDirSim(const vector& H, int N, const vector& proc0, bool rev) {\n int V=N*N;\n int m=V-1;\n int h00 = H[0];\n auto at = [&](int i)->int {\n return (!rev ? proc0[i] : proc0[m-1-i]);\n };\n\n // Precompute prefix minima for feasibility.\n // For non-last only (i=0..m-2), we need load never negative during processing those cells.\n long long pref=0;\n long long minPrefAll=0;\n long long minPrefNonLast=0;\n for (int i=0;i=0\n long long cost=0, load=0;\n cost += B; load += B;\n for (int i=0;i0 and B can be <=h00, i.e., prefix requirement is small (<=100).\n if (h00 > 0) {\n long long Bmin = max(0LL, -minPrefNonLast);\n if (Bmin <= h00) {\n // brute B in [Bmin..h00] (range <= 101)\n for (long long B = Bmin; B <= h00; B++) {\n long long cost=0, load=0;\n cost += B; load += B;\n\n // process first m-1 cells to zero\n bool ok=true;\n for (int i=0;i target -> load (ht-target)\n // else unload (target-ht), must have enough load\n if ((long long)ht >= target) {\n long long d = (long long)ht - target;\n cost += d;\n load += d;\n } else {\n long long d = target - (long long)ht;\n if (load < d) continue;\n cost += d;\n load -= d;\n }\n // now load should be 0 (by construction); but keep robust:\n if (load != 0) continue;\n\n long long rem = (long long)h00 - B; // >0\n if (rem > 0) {\n // extra: last->start (empty), +rem at start, start->last (carrying rem), unload rem\n cost += 100; // move last->start with 0 load\n cost += rem; // +rem\n cost += 100 + rem; // move back carrying rem\n cost += rem; // -rem\n }\n if (cost < best.cost) best = {cost, rev?1:0, 1, B};\n }\n }\n }\n\n return best;\n}\n\nstatic Plan evalCycle(const vector& H, int N, const vector& proc0) {\n Plan a = evalDirSim(H, N, proc0, false);\n Plan b = evalDirSim(H, N, proc0, true);\n return (a.cost <= b.cost ? a : b);\n}\n\nstruct State {\n vector> nei;\n vector proc0;\n Plan plan;\n};\n\nstatic vector buildOutput(const vector& H, const vector>& nei, int N,\n const vector& proc0, const Plan& plan) {\n int V=N*N, m=V-1;\n int h00 = H[0];\n\n auto at = [&](int i)->int {\n return (plan.dir==0 ? proc0[i] : proc0[m-1-i]);\n };\n int lastV = at(m-1);\n\n vector ops;\n ops.reserve(1500);\n\n auto emitMove=[&](char ch){ ops.push_back(string(1,ch)); };\n auto emitLoad=[&](long long d){ if(d>0) ops.push_back(\"+\"+to_string(d)); };\n auto emitUnload=[&](long long d){ if(d>0) ops.push_back(\"-\"+to_string(d)); };\n\n long long load = 0;\n int cur = 0;\n\n if (plan.B > 0) { emitLoad(plan.B); load += plan.B; }\n\n auto fixToZero = [&](int v) {\n int hv = H[v];\n if (hv > 0) { emitLoad(hv); load += hv; }\n else if (hv < 0) { emitUnload(- (long long)hv); load += hv; }\n };\n auto setToTarget = [&](int v, long long target) {\n long long hv = H[v];\n if (hv >= target) {\n long long d = hv - target;\n if (d>0) { emitLoad(d); load += d; }\n } else {\n long long d = target - hv;\n if (d>0) { emitUnload(d); load -= d; }\n }\n };\n\n for (int i=0;i 0) { emitUnload(load); load = 0; }\n } else {\n long long rem = (long long)h00 - plan.B;\n if (rem > 0) {\n emitMove(dirChar(cur, 0, N)); cur = 0;\n emitLoad(rem); load += rem;\n emitMove(dirChar(cur, lastV, N)); cur = lastV;\n emitUnload(rem); load -= rem;\n }\n }\n return ops;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N; cin >> N;\n int V=N*N;\n vector H(V);\n for (int r=0;r> x;\n H[vid(r,c,N)] = x;\n }\n\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n RNG rng(seed);\n\n // Build initial pool (2 bases * 8 sym)\n vector> bases = {baseCycleA(N), baseCycleB(N)};\n vector pool;\n pool.reserve(32);\n\n for (auto &proc : bases) {\n auto baseNei = neighborsFromProcCycle(N, proc);\n for (int s=0;s<8;s++) {\n State st;\n st.nei = applySymmetryToCycle(baseNei, N, s);\n if (!traverseChoice0(st.nei, N, st.proc0)) continue;\n st.plan = evalCycle(H, N, st.proc0);\n pool.push_back(std::move(st));\n }\n }\n if (pool.empty()) {\n State st;\n st.nei = neighborsFromProcCycle(N, baseCycleA(N));\n traverseChoice0(st.nei, N, st.proc0);\n st.plan = evalCycle(H, N, st.proc0);\n pool.push_back(std::move(st));\n }\n\n auto cmp = [&](const State& a, const State& b){ return a.plan.cost < b.plan.cost; };\n sort(pool.begin(), pool.end(), cmp);\n\n State best = pool[0];\n\n auto t0 = chrono::high_resolution_clock::now();\n const double TL = 1.95;\n\n // Diversify: generate additional seeds from top few by flip-chains\n int baseSeeds = min(4, (int)pool.size());\n vector seeds = pool;\n for (int si=0; si(now - t0).count();\n if (elapsed > 0.55) break;\n\n State st = pool[si];\n // apply a macro chain without evaluation, keeping only valid single-cycle states\n int chains = 60;\n for (int t=0;t recs;\n recs.reserve(L);\n for (int k=0;k tmp;\n if (!recs.empty() && !traverseChoice0(st.nei, N, tmp)) {\n for (int i=(int)recs.size()-1;i>=0;i--) undoFlip(st.nei, recs[i]);\n } else if (!recs.empty()) {\n st.proc0 = std::move(tmp);\n }\n }\n st.plan = evalCycle(H, N, st.proc0);\n seeds.push_back(std::move(st));\n }\n }\n sort(seeds.begin(), seeds.end(), cmp);\n if (seeds[0].plan.cost < best.plan.cost) best = seeds[0];\n\n // SA multi-start from top K seeds\n int K = min(6, (int)seeds.size());\n for (int k=0;k(nowG - t0).count();\n double rem = TL - elapsedG;\n if (rem <= 0.05) break;\n\n double slice = max(0.12, rem / (K - k));\n auto start = chrono::high_resolution_clock::now();\n\n State cur = seeds[k];\n long long curCost = cur.plan.cost;\n\n const double T0 = 25000.0, T1 = 80.0;\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double e = chrono::duration(now - start).count();\n if (e > slice) break;\n\n double prog = e / slice;\n double temp = T0 * pow(T1 / T0, prog);\n\n bool macro = (rng.nextDouble() < 0.30);\n vector recs;\n\n if (!macro) {\n int r = rng.nextInt(0, N-2);\n int c = rng.nextInt(0, N-2);\n auto rec = tryFlip(cur.nei, N, r, c);\n if (!rec.applied) continue;\n recs.push_back(rec);\n } else {\n int L = rng.nextInt(2, 12);\n recs.reserve(L);\n for (int i=0;i newProc0;\n if (!traverseChoice0(cur.nei, N, newProc0)) {\n for (int i=(int)recs.size()-1;i>=0;i--) undoFlip(cur.nei, recs[i]);\n continue;\n }\n Plan newPlan = evalCycle(H, N, newProc0);\n long long newCost = newPlan.cost;\n\n bool accept = false;\n if (newCost <= curCost) accept = true;\n else {\n double p = exp((double)(curCost - newCost) / temp);\n if (rng.nextDouble() < p) accept = true;\n }\n\n if (accept) {\n cur.proc0 = std::move(newProc0);\n cur.plan = newPlan;\n curCost = newCost;\n if (newCost < best.plan.cost) best = cur;\n } else {\n for (int i=(int)recs.size()-1;i>=0;i--) undoFlip(cur.nei, recs[i]);\n }\n }\n }\n\n auto ops = buildOutput(H, best.nei, N, best.proc0, best.plan);\n for (auto &s: ops) cout << s << \"\\n\";\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nstatic constexpr int N = 6;\nstatic constexpr int M = 15;\n\nstruct XorShift64 {\n uint64_t x = 88172645463325252ull;\n explicit XorShift64(uint64_t seed = 0) {\n if (seed) x ^= seed + 0x9e3779b97f4a7c15ULL;\n }\n uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int lo, int hi) { // [lo, hi)\n return lo + (int)(nextU64() % (uint64_t)(hi - lo));\n }\n double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Seed {\n array x{};\n int v = 0;\n int mx = 0;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, T;\n cin >> Nin >> Min >> T;\n const int S = 2 * Nin * (Nin - 1); // 60\n\n vector seeds(S);\n\n auto readSeeds = [&]() {\n for (int i = 0; i < S; i++) {\n int sum = 0, mx = 0;\n for (int l = 0; l < M; l++) {\n int a; cin >> a;\n seeds[i].x[l] = a;\n sum += a;\n mx = max(mx, a);\n }\n seeds[i].v = sum;\n seeds[i].mx = mx;\n }\n };\n\n readSeeds();\n\n auto pid = [&](int r, int c){ return r * N + c; };\n\n // Edges among 36 positions (60 edges)\n vector> edges;\n edges.reserve(60);\n for (int r = 0; r < N; r++) for (int c = 0; c < N - 1; c++)\n edges.push_back({pid(r,c), pid(r,c+1)});\n for (int r = 0; r < N - 1; r++) for (int c = 0; c < N; c++)\n edges.push_back({pid(r,c), pid(r+1,c)});\n\n array, 36> nbr;\n for (auto [a,b] : edges) {\n nbr[a].push_back(b);\n nbr[b].push_back(a);\n }\n\n // Checkerboard positions\n vector blackPos, whitePos;\n blackPos.reserve(18); whitePos.reserve(18);\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) {\n if (((r + c) & 1) == 0) blackPos.push_back(pid(r,c));\n else whitePos.push_back(pid(r,c));\n }\n\n XorShift64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());\n\n // Pair utility matrix\n vector> w(S, vector(S, 0.0));\n\n auto buildPairUtility = [&](int turn) {\n // More \"tail seeking\" early, more \"stable\" later\n double zTail = 3.2 - 0.1 * turn; // t=0 -> 3.2, t=9 -> 2.3\n double tau = 80.0;\n\n for (int i = 0; i < S; i++) {\n for (int j = i + 1; j < S; j++) {\n double mean = 0.5 * (seeds[i].v + seeds[j].v);\n\n double diff2 = 0.0;\n int best = 0;\n for (int l = 0; l < M; l++) {\n int a = seeds[i].x[l], b = seeds[j].x[l];\n double d = double(a - b);\n diff2 += d * d;\n best += max(a, b);\n }\n double st = 0.5 * sqrt(diff2);\n double pot = min(best, mean + zTail * st);\n\n double val = exp(pot / tau);\n w[i][j] = w[j][i] = val;\n }\n w[i][i] = exp(seeds[i].v / tau);\n }\n };\n\n auto select36 = [&]() -> vector {\n const double beta = 5.0;\n vector ids(S);\n iota(ids.begin(), ids.end(), 0);\n\n vector score(S);\n for (int i = 0; i < S; i++) score[i] = seeds[i].v + beta * seeds[i].mx;\n\n sort(ids.begin(), ids.end(), [&](int a, int b){\n if (score[a] != score[b]) return score[a] > score[b];\n return seeds[a].v > seeds[b].v;\n });\n\n vector picked(ids.begin(), ids.begin() + 36);\n vector in(S, 0);\n for (int x : picked) in[x] = 1;\n\n // Enforce per-criterion maxima\n for (int l = 0; l < M; l++) {\n int bestId = 0;\n for (int i = 1; i < S; i++) if (seeds[i].x[l] > seeds[bestId].x[l]) bestId = i;\n if (in[bestId]) continue;\n\n int worstIdx = 0;\n for (int i = 1; i < 36; i++) if (score[picked[i]] < score[picked[worstIdx]]) worstIdx = i;\n\n in[picked[worstIdx]] = 0;\n picked[worstIdx] = bestId;\n in[bestId] = 1;\n }\n\n // Ensure top-by-sum elites\n vector byV(S);\n iota(byV.begin(), byV.end(), 0);\n sort(byV.begin(), byV.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n\n int mustKeep = 12;\n for (int i = 0; i < mustKeep; i++) {\n int id = byV[i];\n if (in[id]) continue;\n\n int worstIdx = -1;\n double worstSc = 1e100;\n for (int j = 0; j < 36; j++) {\n bool isElite = false;\n for (int k = 0; k < mustKeep; k++) if (picked[j] == byV[k]) { isElite = true; break; }\n if (isElite) continue;\n if (score[picked[j]] < worstSc) { worstSc = score[picked[j]]; worstIdx = j; }\n }\n if (worstIdx == -1) {\n worstIdx = 0;\n for (int j = 1; j < 36; j++) if (score[picked[j]] < score[picked[worstIdx]]) worstIdx = j;\n }\n in[picked[worstIdx]] = 0;\n picked[worstIdx] = id;\n in[id] = 1;\n }\n\n return picked;\n };\n\n auto calcObjective = [&](const vector& grid) -> double {\n double obj = 0.0;\n for (auto [a,b] : edges) obj += w[grid[a]][grid[b]];\n return obj;\n };\n\n auto swapDelta = [&](const vector& grid, int p, int q) -> double {\n int A = grid[p], B = grid[q];\n double delta = 0.0;\n for (int n : nbr[p]) {\n if (n == q) continue;\n int C = grid[n];\n delta += w[B][C] - w[A][C];\n }\n for (int n : nbr[q]) {\n if (n == p) continue;\n int C = grid[n];\n delta += w[A][C] - w[B][C];\n }\n return delta;\n };\n\n auto makeHubInit = [&](const vector& picked) -> vector {\n // Use only picked seeds. Place best-by-V in center, surround by best w partners.\n int hub = picked[0];\n for (int s : picked) if (seeds[s].v > seeds[hub].v) hub = s;\n\n vector partners = picked;\n partners.erase(remove(partners.begin(), partners.end(), hub), partners.end());\n sort(partners.begin(), partners.end(), [&](int a, int b){\n return w[hub][a] > w[hub][b];\n });\n\n int hubPos = pid(2,2);\n vector around = {pid(1,2), pid(2,1), pid(2,3), pid(3,2)};\n\n vector grid(36, -1);\n grid[hubPos] = hub;\n for (int i = 0; i < 4 && i < (int)partners.size(); i++) grid[around[i]] = partners[i];\n\n vector used(S, 0);\n used[hub] = 1;\n for (int i = 0; i < 4 && i < (int)partners.size(); i++) used[partners[i]] = 1;\n\n int ptr = 0;\n for (int pos = 0; pos < 36; pos++) {\n if (grid[pos] != -1) continue;\n while (ptr < (int)picked.size() && used[picked[ptr]]) ptr++;\n if (ptr < (int)picked.size()) {\n grid[pos] = picked[ptr];\n used[picked[ptr]] = 1;\n ptr++;\n } else {\n // fallback (shouldn't happen)\n for (int s = 0; s < S; s++) if (!used[s]) { grid[pos] = s; used[s]=1; break; }\n }\n }\n return grid;\n };\n\n auto initLayouts = [&](const vector& picked) -> vector> {\n vector> inits;\n\n // 1) Hub init\n inits.push_back(makeHubInit(picked));\n\n // 2) Checkerboard high/low\n {\n vector perm = picked;\n sort(perm.begin(), perm.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n vector grid(36, -1);\n for (int i = 0; i < 18; i++) grid[blackPos[i]] = perm[i];\n for (int i = 0; i < 18; i++) grid[whitePos[i]] = perm[18 + i];\n inits.push_back(grid);\n }\n\n // 3) Sorted by V row-major\n {\n vector perm = picked;\n sort(perm.begin(), perm.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n vector grid(36);\n for (int i = 0; i < 36; i++) grid[i] = perm[i];\n inits.push_back(grid);\n }\n\n // 4-5) Randoms\n for (int rep = 0; rep < 2; rep++) {\n vector perm = picked;\n for (int i = 35; i >= 1; i--) {\n int j = rng.nextInt(0, i + 1);\n swap(perm[i], perm[j]);\n }\n vector grid(36);\n for (int i = 0; i < 36; i++) grid[i] = perm[i];\n inits.push_back(grid);\n }\n\n return inits;\n };\n\n auto solvePlacementSA = [&](const vector& picked, double timeLimitSec) -> vector {\n auto startAll = chrono::steady_clock::now();\n auto deadlineAll = startAll + chrono::duration(timeLimitSec);\n\n vector bestGrid(36);\n double bestObj = -1e100;\n\n auto inits = initLayouts(picked);\n int K = (int)inits.size();\n\n // SA schedule parameters\n const double T0 = 3000.0;\n const double T1 = 8.0;\n\n for (int k = 0; k < K; k++) {\n auto now = chrono::steady_clock::now();\n if (now >= deadlineAll) break;\n\n // Split remaining time evenly among remaining inits\n double remain = chrono::duration(deadlineAll - now).count();\n double seg = remain / (K - k);\n auto segStart = now;\n auto segDeadline = segStart + chrono::duration(seg);\n\n vector curGrid = inits[k];\n double curObj = calcObjective(curGrid);\n\n vector localBestGrid = curGrid;\n double localBestObj = curObj;\n\n while (chrono::steady_clock::now() < segDeadline) {\n double tprog = chrono::duration(chrono::steady_clock::now() - segStart).count() / max(1e-9, seg);\n if (tprog > 1.0) tprog = 1.0;\n double temp = T0 * pow(T1 / T0, tprog);\n\n int p = rng.nextInt(0, 36);\n int q = rng.nextInt(0, 36);\n if (p == q) continue;\n\n double delta = swapDelta(curGrid, p, q);\n if (delta >= 0.0 || rng.nextDouble() < exp(delta / temp)) {\n swap(curGrid[p], curGrid[q]);\n curObj += delta;\n if (curObj > localBestObj) {\n localBestObj = curObj;\n localBestGrid = curGrid;\n }\n }\n }\n\n if (localBestObj > bestObj) {\n bestObj = localBestObj;\n bestGrid = localBestGrid;\n }\n }\n\n return bestGrid;\n };\n\n auto allStart = chrono::steady_clock::now();\n auto allDeadline = allStart + chrono::milliseconds(1900);\n\n for (int t = 0; t < T; t++) {\n buildPairUtility(t);\n vector picked = select36();\n\n auto now = chrono::steady_clock::now();\n double remain = chrono::duration(allDeadline - now).count();\n if (remain < 0.02) remain = 0.02;\n double perTurn = remain / (T - t);\n\n vector grid = solvePlacementSA(picked, perTurn * 0.95);\n\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n if (c) cout << ' ';\n cout << grid[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n\n readSeeds();\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Pos { int x, y; };\nstatic inline int mod4(int x){ x%=4; if(x<0) x+=4; return x; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n\n // Directions: 0=Up,1=Right,2=Down,3=Left\n const int dx4[4] = {-1, 0, 1, 0};\n const int dy4[4] = {0, 1, 0, -1};\n\n auto inside = [&](int x,int y)->bool{ return 0<=x && x> cur(N, vector(N, 0));\n vector> surplus(N, vector(N, 0)); // cur=1, target=0\n vector> deficit(N, vector(N, 0)); // cur=0, target=1\n int surplusCnt=0, deficitCnt=0;\n\n for(int i=0;i surList, defList;\n vector> surIdx(N, vector(N, -1));\n vector> defIdx(N, vector(N, -1));\n surList.reserve(N*N); defList.reserve(N*N);\n for(int i=0;i& lst, vector>& idx, int x, int y){\n int id = idx[x][y];\n if(id < 0) return;\n int last = (int)lst.size()-1;\n if(id != last){\n Pos p = lst[last];\n lst[id] = p;\n idx[p.x][p.y] = id;\n }\n lst.pop_back();\n idx[x][y] = -1;\n };\n\n // -------- Arm design: use all vertices, only lengths 1 and 2 --------\n int Vp = V; // <= 15\n cout << Vp << \"\\n\";\n vector len(Vp, 0);\n for(int u=1; u dir(Vp, 1); // initial all Right\n vector hold(Vp, 0);\n\n auto holdingCount = [&](){\n int c=0;\n for(int u=1; uint{\n int cw = mod4(to - from);\n int ccw = mod4(from - to);\n return min(cw, ccw); // 0,1,2\n };\n\n auto tipCell = [&](int px,int py,int u,int d)->Pos{\n return { px + len[u]*dx4[d], py + len[u]*dy4[d] };\n };\n\n struct Plan {\n vector rot; // size Vp\n vector act; // size Vp\n int places=0, picks=0;\n };\n\n // Greedy (0 or +-90) with cell-conflict avoidance\n auto planGreedyAt = [&](int px,int py)->Plan{\n Plan pl;\n pl.rot.assign(Vp, '.');\n pl.act.assign(Vp, '.');\n pl.places = pl.picks = 0;\n\n vector usedCell(N*N, 0);\n auto cellId = [&](int x,int y){ return x*N+y; };\n\n struct Cand { int u; int cnt; };\n vector ord;\n vector> candDir(Vp);\n vector> candRot(Vp);\n vector candCnt(Vp, 0);\n\n // placements\n ord.clear();\n for(int u=1; u0) ord.push_back({u,cnt});\n }\n sort(ord.begin(), ord.end(), [&](const Cand& a, const Cand& b){\n if(a.cnt != b.cnt) return a.cnt < b.cnt;\n return a.u < b.u;\n });\n for(auto &c: ord){\n int u=c.u;\n for(int i=0;i0) ord.push_back({u,cnt});\n }\n sort(ord.begin(), ord.end(), [&](const Cand& a, const Cand& b){\n if(a.cnt != b.cnt) return a.cnt < b.cnt;\n return a.u < b.u;\n });\n for(auto &c: ord){\n int u=c.u;\n for(int i=0;ioptional> {\n vector rotCmd(Vp, '.');\n bool any=false;\n\n // place-prep\n for(int u=1; u& rotCmd, const vector& actCmd)->int {\n int changes=0;\n if(mv=='U') rx--;\n else if(mv=='D') rx++;\n else if(mv=='L') ry--;\n else if(mv=='R') ry++;\n\n for(int u=1; u& lst, int K)->vector{\n vector> tmp;\n tmp.reserve(lst.size());\n for(int i=0;i<(int)lst.size();i++){\n int d = abs(lst[i].x - rx) + abs(lst[i].y - ry);\n tmp.push_back({d, i});\n }\n if((int)tmp.size() > K){\n nth_element(tmp.begin(), tmp.begin()+K, tmp.end());\n tmp.resize(K);\n }\n vector res;\n res.reserve(tmp.size());\n for(auto &p: tmp) res.push_back(lst[p.second]);\n return res;\n };\n\n // Choose goal by evaluating throughput at candidate root positions\n auto chooseGoal = [&]()->optional{\n int h = holdingCount();\n bool wantPlace = (h > 0 && deficitCnt > 0);\n bool wantPick = (h < (Vp-1) && surplusCnt > 0);\n\n auto usableLens = [&](bool forPlace)->vector{\n vector lens;\n for(int u=1; u& cells, const vector& lens)->optional{\n unordered_set seen;\n seen.reserve(cells.size()*lens.size()*4*2);\n\n int bestScore = INT_MIN;\n Pos best{-1,-1};\n\n const int GOAL_GAIN_W = 6;\n\n for(const auto &c: cells){\n for(int L: lens){\n for(int d=0; d<4; d++){\n int nx = c.x - L*dx4[d];\n int ny = c.y - L*dy4[d];\n if(!inside(nx,ny)) continue;\n int key = nx*64 + ny;\n if(seen.count(key)) continue;\n seen.insert(key);\n\n int dist = abs(nx - rx) + abs(ny - ry);\n Plan p = planGreedyAt(nx, ny);\n int gain = p.places + p.picks;\n int score = GOAL_GAIN_W*gain - dist;\n if(score > bestScore){\n bestScore = score;\n best = {nx, ny};\n }\n }\n }\n }\n if(bestScore == INT_MIN) return nullopt;\n return best;\n };\n\n const int K = 40;\n if(wantPlace){\n auto cells = nearestK(defList, K);\n auto lens = usableLens(true);\n if(auto g = evalCandidates(cells, lens)) return g;\n }\n if(wantPick){\n auto cells = nearestK(surList, K);\n auto lens = usableLens(false);\n if(auto g = evalCandidates(cells, lens)) return g;\n }\n // fallback\n if(deficitCnt>0){\n auto cells = nearestK(defList, K);\n auto lens = usableLens(true);\n if(auto g = evalCandidates(cells, lens)) return g;\n }\n if(surplusCnt>0){\n auto cells = nearestK(surList, K);\n auto lens = usableLens(false);\n if(auto g = evalCandidates(cells, lens)) return g;\n }\n return nullopt;\n };\n\n // Sweep fallback snake\n vector snake;\n snake.reserve(N*N);\n for(int i=0;i=0;j--) snake.push_back({i,j});\n }\n int snakeIdx=0;\n auto moveChar = [&](Pos a, Pos b)->char{\n int dx=b.x-a.x, dy=b.y-a.y;\n if(dx==-1 && dy==0) return 'U';\n if(dx== 1 && dy==0) return 'D';\n if(dx==0 && dy==-1) return 'L';\n if(dx==0 && dy== 1) return 'R';\n return '.';\n };\n\n const int MAXT = 100000;\n int turns=0;\n int noChangeTurns=0;\n bool sweepMode=false;\n\n // -------- Initialization: set U/R/D/L pattern for all leaves in 2 turns --------\n if(turns < MAXT){\n vector rotCmd(Vp,'.'), actCmd(Vp,'.');\n for(int u=1; u rotCmd(Vp,'.'), actCmd(Vp,'.');\n for(int u=1; uLeft\n }\n string cmd(2*Vp, '.');\n cmd[0]='.';\n for(int u=1; ubool{\n Plan stay = planGreedyAt(rx, ry);\n if(stay.places + stay.picks == 0) return false;\n string cmd(2*Vp, '.');\n cmd[0]='.';\n for(int u=1; u0){ noChangeTurns=0; sweepMode=false; }\n else noChangeTurns++;\n return true;\n };\n\n while(turns < MAXT && !done()){\n // 1) immediate action at current pos\n if(tryStayAction()) continue;\n\n // 2) 180\u00b0 prep\n if(auto prep = planPrep180At(rx, ry)){\n vector rotCmd = *prep;\n vector actCmd(Vp,'.');\n string cmd(2*Vp, '.');\n cmd[0]='.';\n for(int u=1; u 250) sweepMode=true;\n\n // 3) choose a goal (for distance term)\n optional goalOpt;\n if(!sweepMode) goalOpt = chooseGoal();\n\n // 4) choose best 1-step move by evaluating all moves\n struct Move { char c; int dx, dy; };\n static const Move moves[5] = {\n {'.', 0, 0}, {'U', -1, 0}, {'D', 1, 0}, {'L', 0, -1}, {'R', 0, 1}\n };\n\n char bestMv='.';\n int bestScore = INT_MIN;\n Plan bestPlan; bestPlan.rot.assign(Vp,'.'); bestPlan.act.assign(Vp,'.');\n\n for(const auto &mv: moves){\n int nx = rx + mv.dx, ny = ry + mv.dy;\n if(!inside(nx,ny)) continue;\n\n if(sweepMode){\n // In sweep mode, force snake-following move (override later)\n continue;\n }\n\n Plan p = planGreedyAt(nx, ny);\n int gain = p.places + p.picks;\n\n int distToGoal = 0;\n if(goalOpt) distToGoal = abs(nx - goalOpt->x) + abs(ny - goalOpt->y);\n\n // prefer making progress; also discourage idling when goal not reached\n int idlePenalty = (mv.c=='.' && distToGoal>0 ? 2 : 0);\n\n const int MV_GAIN_W = 10;\n int score = MV_GAIN_W*gain - distToGoal - idlePenalty;\n\n if(score > bestScore){\n bestScore = score;\n bestMv = mv.c;\n bestPlan = std::move(p);\n }\n }\n\n // If sweepMode, follow snake route exactly\n if(sweepMode){\n if(!(snake[snakeIdx].x==rx && snake[snakeIdx].y==ry)){\n int best=0, bestDist=INT_MAX;\n for(int i=0;i<(int)snake.size();i++){\n int dist = abs(snake[i].x-rx)+abs(snake[i].y-ry);\n if(dist rotCmd = bestPlan.rot;\n vector actCmd = bestPlan.act;\n\n // If no gain and mv='.', try a prep to avoid pure idle\n if(bestMv=='.' && bestPlan.places + bestPlan.picks == 0){\n if(auto prep = planPrep180At(rx, ry)){\n rotCmd = *prep;\n actCmd.assign(Vp,'.');\n }\n }\n\n string cmd(2*Vp, '.');\n cmd[0]=bestMv;\n for(int u=1; u0){ noChangeTurns=0; sweepMode=false; }\n else noChangeTurns++;\n }\n\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int l, int r) { return l + (int)(next_u64() % (uint64_t)(r - l + 1)); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); }\n};\n\nstatic inline double now_sec() {\n using namespace std::chrono;\n return duration_cast>(steady_clock::now().time_since_epoch()).count();\n}\n\nstruct Point { int x, y, w; };\nstruct Rect { int xl, xr, yb, yt; }; // inclusive\n\nstatic inline Rect clamp_rect(Rect r) {\n r.xl = max(0, min(100000, r.xl));\n r.xr = max(0, min(100000, r.xr));\n r.yb = max(0, min(100000, r.yb));\n r.yt = max(0, min(100000, r.yt));\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n if (w + h > 200000) {\n int cx = (r.xl + r.xr) / 2;\n int cy = (r.yb + r.yt) / 2;\n long long over = (w + h) - 200000;\n long long rw = min(over, w - 1);\n long long rh = min(over - rw, h - 1);\n long long neww = max(1LL, w - rw);\n long long newh = max(1LL, h - rh);\n\n r.xl = cx - (int)(neww / 2);\n r.xr = r.xl + (int)neww;\n r.yb = cy - (int)(newh / 2);\n r.yt = r.yb + (int)newh;\n\n if (r.xl < 0) { r.xr -= r.xl; r.xl = 0; }\n if (r.yb < 0) { r.yt -= r.yb; r.yb = 0; }\n if (r.xr > 100000) { int d = r.xr - 100000; r.xl -= d; r.xr = 100000; if (r.xl < 0) r.xl = 0; }\n if (r.yt > 100000) { int d = r.yt - 100000; r.yb -= d; r.yt = 100000; if (r.yb < 0) r.yb = 0; }\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n }\n return r;\n}\nstatic inline bool rect_ok(const Rect& r) {\n if (r.xl < 0 || r.xr > 100000 || r.yb < 0 || r.yt > 100000) return false;\n if (r.xl >= r.xr || r.yb >= r.yt) return false;\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n return (w + h <= 200000);\n}\n\n// ---- Static 2D BIT for fast rectangle evaluation ----\nstruct BIT2DStatic {\n struct Node {\n vector ys;\n vector pref; // pref[0]=0\n vector> tmp;\n };\n int M;\n vector xs;\n vector bit;\n\n void build(const vector& pts) {\n xs.clear();\n xs.reserve(pts.size());\n for (auto &p: pts) xs.push_back(p.x);\n sort(xs.begin(), xs.end());\n xs.erase(unique(xs.begin(), xs.end()), xs.end());\n M = (int)xs.size();\n bit.assign(M + 1, Node());\n\n for (auto &p: pts) {\n int xi = (int)(lower_bound(xs.begin(), xs.end(), p.x) - xs.begin()) + 1;\n for (int j = xi; j <= M; j += j & -j) bit[j].tmp.push_back({p.y, p.w});\n }\n for (int j = 1; j <= M; j++) {\n auto &t = bit[j].tmp;\n sort(t.begin(), t.end());\n vector ys, sums;\n ys.reserve(t.size());\n sums.reserve(t.size());\n for (int k = 0; k < (int)t.size();) {\n int y = t[k].first;\n int s = 0;\n while (k < (int)t.size() && t[k].first == y) { s += t[k].second; k++; }\n ys.push_back(y);\n sums.push_back(s);\n }\n bit[j].ys = move(ys);\n bit[j].pref.assign(bit[j].ys.size() + 1, 0);\n for (int i = 0; i < (int)sums.size(); i++) bit[j].pref[i+1] = bit[j].pref[i] + sums[i];\n bit[j].tmp.clear();\n bit[j].tmp.shrink_to_fit();\n }\n }\n\n inline int node_query(const Node& nd, int yBound) const {\n int pos = (int)(upper_bound(nd.ys.begin(), nd.ys.end(), yBound) - nd.ys.begin());\n return nd.pref[pos];\n }\n inline int prefix_query(int xBound, int yBound) const {\n if (xBound < 0 || yBound < 0) return 0;\n int xi = (int)(upper_bound(xs.begin(), xs.end(), xBound) - xs.begin());\n int res = 0;\n for (int j = xi; j > 0; j -= j & -j) res += node_query(bit[j], yBound);\n return res;\n }\n inline int rect_sum_inclusive(const Rect& r) const {\n int A = prefix_query(r.xr, r.yt);\n int B = prefix_query(r.xl - 1, r.yt);\n int C = prefix_query(r.xr, r.yb - 1);\n int D = prefix_query(r.xl - 1, r.yb - 1);\n return A - B - C + D;\n }\n};\n\n// ---- Staircase helpers ----\nstatic inline bool gap_ok(int Li, int Ui, int Lj, int Uj) {\n return max(Li, Lj) < min(Ui, Uj); // strict overlap\n}\nstatic inline long long Vlen_full(const vector& L, const vector& U) {\n int K = (int)L.size();\n long long v = 0;\n v += (long long)U[0] - L[0];\n v += (long long)U[K-1] - L[K-1];\n for (int i = 1; i < K; i++) {\n v += llabs((long long)L[i] - L[i-1]);\n v += llabs((long long)U[i] - U[i-1]);\n }\n return v;\n}\nstatic inline bool perim_ok(int XL, int XR, long long Vlen) {\n long long H = 2LL * (XR - XL);\n return H + Vlen <= 400000;\n}\nstatic inline vector build_xs(int XL, int XR, int K) {\n vector xs(K+1);\n xs[0] = XL; xs[K] = XR;\n long long width = (long long)XR - XL;\n for (int i = 1; i < K; i++) xs[i] = XL + (int)(width * i / K);\n for (int i = 1; i <= K; i++) xs[i] = max(xs[i], xs[i-1] + 1);\n xs[K] = XR;\n for (int i = K-1; i >= 0; i--) xs[i] = min(xs[i], xs[i+1] - 1);\n xs[0] = XL; xs[K] = XR;\n for (int i = 1; i <= K; i++) if (xs[i] <= xs[i-1]) xs[i] = xs[i-1] + 1;\n xs[K] = XR;\n return xs;\n}\n\nstruct SlabDS {\n vector ys;\n vector pref;\n vector> yw;\n vector my;\n inline int range_sum(int L, int U) const {\n if (ys.empty()) return 0;\n int l = (int)(lower_bound(ys.begin(), ys.end(), L) - ys.begin());\n int r = (int)(upper_bound(ys.begin(), ys.end(), U) - ys.begin());\n return pref[r] - pref[l];\n }\n};\n\nstruct Ivl { int L, U; };\nstatic inline Ivl norm_ivl(int L, int U) {\n L = max(0, min(100000, L));\n U = max(0, min(100000, U));\n if (U <= L) {\n if (L < 100000) U = L + 1;\n else { L = 99999; U = 100000; }\n }\n return {L,U};\n}\n\nstatic inline void remove_collinear(vector>& poly) {\n auto is_col = [&](const pair& a, const pair& b, const pair& c){\n return (a.first == b.first && b.first == c.first) ||\n (a.second == b.second && b.second == c.second);\n };\n bool changed = true;\n while (changed && poly.size() >= 4) {\n changed = false;\n int m = (int)poly.size();\n vector> np;\n np.reserve(m);\n for (int i = 0; i < m; i++) {\n auto prev = poly[(i-1+m)%m];\n auto cur = poly[i];\n auto next = poly[(i+1)%m];\n if (is_col(prev, cur, next)) { changed = true; continue; }\n np.push_back(cur);\n }\n poly.swap(np);\n }\n}\n\nstruct SolveResult {\n int diff;\n vector> poly;\n};\n\n// quick cheap estimate for time splitting: random rectangles, O(N) eval\nstatic int quick_best_rect_estimate(const vector& pts, const vector& macks, uint64_t seed) {\n XorShift64 rng(seed);\n auto evalON = [&](const Rect& r)->int{\n int s = 0;\n for (auto &p: pts) if (r.xl <= p.x && p.x <= r.xr && r.yb <= p.y && p.y <= r.yt) s += p.w;\n return s;\n };\n auto make_around = [&](const Point& c, int w, int h)->Rect{\n Rect r{c.x - w/2, c.x + w/2, c.y - h/2, c.y + h/2};\n return clamp_rect(r);\n };\n int best = -1e9;\n int trials = 250;\n for (int it = 0; it < trials; it++) {\n const auto& c = macks[rng.next_int(0, (int)macks.size()-1)];\n int w = rng.next_int(800, 60000);\n int h = rng.next_int(800, 60000);\n if (w + h > 200000) { int over = w + h - 200000; w = max(1, w - over/2); h = max(1, h - (over - over/2)); }\n Rect r = make_around(c, w, h);\n if (!rect_ok(r)) continue;\n best = max(best, evalON(r));\n }\n return best;\n}\n\nstatic SolveResult solve_monotone(const vector& pts, const vector& macks,\n double endTime, uint64_t seed_add) {\n XorShift64 rng(seed_add ^ 0x9e3779b97f4a7c15ULL);\n\n BIT2DStatic bit2d;\n bit2d.build(pts);\n auto eval_rect_fast = [&](const Rect& r)->int { return bit2d.rect_sum_inclusive(r); };\n\n auto make_around = [&](const Point& c, int w, int h)->Rect{\n Rect r{c.x - w/2, c.x + w/2, c.y - h/2, c.y + h/2};\n r = clamp_rect(r);\n if (!(r.xl <= c.x && c.x <= r.xr && r.yb <= c.y && c.y <= r.yt))\n r = clamp_rect(Rect{c.x, c.x+1, c.y, c.y+1});\n return r;\n };\n\n // Warm rectangles\n vector> cand;\n cand.reserve(150000);\n int trials = 100000;\n for (int it = 0; it < trials; it++) {\n if (now_sec() > endTime) break;\n const auto& c = macks[rng.next_int(0, (int)macks.size()-1)];\n double rr = rng.next_double();\n int w,h;\n if (rr < 0.60) { w = rng.next_int(200, 12000); h = rng.next_int(200, 12000); }\n else if (rr < 0.92) { w = rng.next_int(2000, 60000); h = rng.next_int(2000, 60000); }\n else { w = rng.next_int(12000, 98000); h = rng.next_int(12000, 98000); }\n if (w + h > 200000) {\n int over = w + h - 200000;\n w = max(1, w - over/2);\n h = max(1, h - (over - over/2));\n }\n Rect r = make_around(c, w, h);\n if (!rect_ok(r)) continue;\n cand.push_back({eval_rect_fast(r), r});\n }\n if (cand.empty()) return {-1000000000, {{0,0},{1,0},{1,1},{0,1}}};\n\n int keep = min(220, (int)cand.size());\n nth_element(cand.begin(), cand.begin() + keep, cand.end(),\n [&](auto &a, auto &b){ return a.first > b.first; });\n cand.resize(keep);\n sort(cand.begin(), cand.end(), [&](auto &a, auto &b){ return a.first > b.first; });\n\n int R = 10;\n vector starts;\n for (int i = 0; i < (int)cand.size() && (int)starts.size() < R; i++) starts.push_back(cand[i].second);\n while ((int)starts.size() < R) starts.push_back(starts[0]);\n\n int globalBestTot = -1e9;\n vector> globalBestPoly;\n\n // Optional DP init over candidates\n auto dp_init = [&](const vector>& cI, const vector>& cS,\n double alpha, vector& outL, vector& outU) {\n const int K = (int)cI.size();\n const int C = 6;\n const double NEG = -1e100;\n vector> dp(K);\n vector> prv(K);\n for (int i = 0; i < K; i++) for (int c = 0; c < C; c++) { dp[i][c] = NEG; prv[i][c] = -1; }\n\n for (int c = 0; c < C; c++) {\n auto iv = cI[0][c];\n dp[0][c] = (double)cS[0][c] - alpha * (double)(iv.U - iv.L);\n }\n for (int i = 1; i < K; i++) {\n for (int c = 0; c < C; c++) {\n auto cur = cI[i][c];\n double bestv = NEG;\n int bestp = -1;\n for (int p = 0; p < C; p++) {\n if (dp[i-1][p] <= NEG/2) continue;\n auto pre = cI[i-1][p];\n if (!gap_ok(pre.L, pre.U, cur.L, cur.U)) continue;\n double trans = alpha * (double)(abs(cur.L - pre.L) + abs(cur.U - pre.U));\n double val = dp[i-1][p] + (double)cS[i][c] - trans;\n if (val > bestv) { bestv = val; bestp = p; }\n }\n dp[i][c] = bestv;\n prv[i][c] = bestp;\n }\n }\n int bestc = 0;\n double bestv = NEG;\n for (int c = 0; c < C; c++) {\n if (dp[K-1][c] <= NEG/2) continue;\n auto iv = cI[K-1][c];\n double val = dp[K-1][c] - alpha * (double)(iv.U - iv.L);\n if (val > bestv) { bestv = val; bestc = c; }\n }\n outL.assign(K, 0);\n outU.assign(K, 1);\n int curc = bestc;\n for (int i = K-1; i >= 0; i--) {\n outL[i] = cI[i][curc].L;\n outU[i] = cI[i][curc].U;\n curc = prv[i][curc];\n if (i > 0 && curc < 0) {\n for (int j = 0; j < i; j++) { outL[j] = cI[j][0].L; outU[j] = cI[j][0].U; }\n break;\n }\n }\n };\n\n for (int rs = 0; rs < R; rs++) {\n if (now_sec() > endTime) break;\n\n Rect base = clamp_rect(starts[rs]);\n int XL = base.xl, XR = base.xr;\n int YB = base.yb, YT = base.yt;\n\n int width = XR - XL;\n if (width < 60) { XR = min(100000, XL + 60); width = XR - XL; }\n\n int K = 80 + width / 500;\n K = max(60, min(220, K));\n K = min(K, width);\n if (K < 4) K = 4;\n if (width < K) K = width;\n\n vector xs = build_xs(XL, XR, K);\n\n vector slabs(K);\n for (int i = 0; i < K; i++) slabs[i].yw.clear();\n for (auto &p: pts) {\n if (p.x < XL || p.x > XR) continue;\n int idx = (int)(upper_bound(xs.begin(), xs.end(), p.x) - xs.begin()) - 1;\n idx = max(0, min(K-1, idx));\n slabs[idx].yw.push_back({p.y, p.w});\n }\n for (int i = 0; i < K; i++) {\n auto &v = slabs[i].yw;\n sort(v.begin(), v.end());\n slabs[i].ys.clear();\n slabs[i].pref.assign(v.size()+1, 0);\n slabs[i].my.clear();\n slabs[i].ys.reserve(v.size());\n for (int j = 0; j < (int)v.size(); j++) {\n slabs[i].ys.push_back(v[j].first);\n slabs[i].pref[j+1] = slabs[i].pref[j] + v[j].second;\n if (v[j].second == +1) slabs[i].my.push_back(v[j].first);\n }\n }\n\n // candidates per slab\n const int C = 6;\n vector> cI(K);\n vector> cS(K);\n\n for (int i = 0; i < K; i++) {\n cI[i][0] = norm_ivl(YB, YT);\n\n // Kadane\n Ivl kad = cI[i][0];\n auto &v = slabs[i].yw;\n if (!v.empty()) {\n int M = (int)v.size();\n int bestSum = INT_MIN, curSum = 0;\n int start = 0, bestL = 0, bestR = -1;\n for (int j = 0; j < M; j++) {\n int w = v[j].second;\n if (curSum <= 0) { curSum = w; start = j; }\n else curSum += w;\n if (curSum > bestSum) { bestSum = curSum; bestL = start; bestR = j; }\n }\n if (bestSum > 0 && bestR >= bestL) kad = norm_ivl(v[bestL].first, v[bestR].first);\n }\n cI[i][1] = kad;\n cI[i][2] = norm_ivl(kad.L - 500, kad.U + 500);\n\n // mackerel percentile\n Ivl perc = cI[i][0];\n auto my = slabs[i].my;\n if ((int)my.size() >= 8) {\n sort(my.begin(), my.end());\n int p25 = my[(int)(0.25 * (my.size()-1))];\n int p75 = my[(int)(0.75 * (my.size()-1))];\n perc = norm_ivl(p25 - 260, p75 + 260);\n }\n cI[i][3] = perc;\n\n Ivl small = cI[i][0], med = cI[i][0];\n if (!slabs[i].my.empty()) {\n int y0 = slabs[i].my[rng.next_int(0, (int)slabs[i].my.size()-1)];\n small = norm_ivl(y0 - 140, y0 + 140);\n med = norm_ivl(y0 - 420, y0 + 420);\n }\n cI[i][4] = small;\n cI[i][5] = med;\n\n for (int c = 0; c < C; c++) cS[i][c] = slabs[i].range_sum(cI[i][c].L, cI[i][c].U);\n }\n\n // pick initial among: base const, DP alpha=0, DP alpha=0.01\n vector> initLs, initUs;\n initLs.push_back(vector(K, YB));\n initUs.push_back(vector(K, YT));\n {\n vector L,U; dp_init(cI, cS, 0.0, L, U);\n initLs.push_back(move(L)); initUs.push_back(move(U));\n }\n {\n vector L,U; dp_init(cI, cS, 0.010, L, U);\n initLs.push_back(move(L)); initUs.push_back(move(U));\n }\n\n auto eval_state = [&](const vector& Lc, const vector& Uc, int& sc, long long& v) {\n sc = 0;\n for (int i = 0; i < K; i++) sc += slabs[i].range_sum(Lc[i], Uc[i]);\n v = Vlen_full(Lc, Uc);\n };\n\n vector L, U;\n int total = -1e9;\n long long Vlen = (1LL<<60);\n for (int idx = 0; idx < (int)initLs.size(); idx++) {\n auto Lc = initLs[idx];\n auto Uc = initUs[idx];\n bool ok = true;\n for (int i = 0; i+1 < K; i++) if (!gap_ok(Lc[i],Uc[i],Lc[i+1],Uc[i+1])) { ok = false; break; }\n if (!ok) continue;\n int sc; long long v;\n eval_state(Lc, Uc, sc, v);\n if (!perim_ok(XL, XR, v)) continue;\n if (sc > total || (sc == total && v < Vlen)) { total = sc; Vlen = v; L = move(Lc); U = move(Uc); }\n }\n if (L.empty()) {\n L.assign(K, YB);\n U.assign(K, YT);\n total = 0;\n for (int i = 0; i < K; i++) total += slabs[i].range_sum(L[i], U[i]);\n Vlen = Vlen_full(L, U);\n }\n\n vector contrib(K, 0);\n for (int i = 0; i < K; i++) contrib[i] = slabs[i].range_sum(L[i], U[i]);\n\n int bestTot = total;\n long long bestV = Vlen;\n vector bestL = L, bestU = U;\n\n auto local_V_delta = [&](int i, int oldL, int oldU, int newL, int newU)->long long {\n long long d = 0;\n auto endterm = [&](int idx, int a, int b)->long long {\n if (idx == 0 || idx == K-1) return (long long)b - a;\n return 0LL;\n };\n d -= endterm(i, oldL, oldU);\n d += endterm(i, newL, newU);\n if (i-1 >= 0) {\n d -= llabs((long long)oldL - L[i-1]);\n d += llabs((long long)newL - L[i-1]);\n d -= llabs((long long)oldU - U[i-1]);\n d += llabs((long long)newU - U[i-1]);\n }\n if (i+1 < K) {\n d -= llabs((long long)L[i+1] - oldL);\n d += llabs((long long)L[i+1] - newL);\n d -= llabs((long long)U[i+1] - oldU);\n d += llabs((long long)U[i+1] - newU);\n }\n return d;\n };\n\n // adaptive local budget\n double curNow = now_sec();\n double remaining = max(0.0, endTime - curNow);\n int remainingR = max(1, R - rs);\n double budget = remaining / remainingR;\n double localEnd = curNow + budget;\n\n const double T0 = 28.0, T1 = 0.7;\n\n while (true) {\n double ct = now_sec();\n if (ct > endTime) break;\n if (ct > localEnd && rs < R-1) break;\n\n double prog = (ct - (localEnd - budget)) / max(1e-9, budget);\n prog = min(1.0, max(0.0, prog));\n double temp = T0 * pow(T1 / T0, prog);\n\n int i = rng.next_int(0, K-1);\n int oldLi = L[i], oldUi = U[i];\n int newL = oldLi, newU = oldUi;\n\n double dice = rng.next_double();\n if (dice < 0.20) {\n int maxD = (int)(9000 * (1.0 - prog) + 30);\n newL += rng.next_int(-maxD, maxD);\n } else if (dice < 0.40) {\n int maxD = (int)(9000 * (1.0 - prog) + 30);\n newU += rng.next_int(-maxD, maxD);\n } else if (dice < 0.58) {\n int maxD = (int)(7000 * (1.0 - prog) + 25);\n int d = rng.next_int(-maxD, maxD);\n newL += d; newU += d;\n } else if (dice < 0.74) {\n int c = rng.next_int(0, C-1);\n newL = cI[i][c].L;\n newU = cI[i][c].U;\n } else if (dice < 0.84) {\n if (i > 0 && rng.next_double() < 0.5) { newL = L[i-1]; newU = U[i-1]; }\n else if (i+1 < K) { newL = L[i+1]; newU = U[i+1]; }\n } else {\n int d = rng.next_int(-300, 300);\n newL += d;\n newU -= d;\n }\n\n auto iv = norm_ivl(newL, newU);\n newL = iv.L; newU = iv.U;\n\n if (i-1 >= 0 && !gap_ok(L[i-1], U[i-1], newL, newU)) continue;\n if (i+1 < K && !gap_ok(newL, newU, L[i+1], U[i+1])) continue;\n\n long long dV = local_V_delta(i, oldLi, oldUi, newL, newU);\n long long newV = Vlen + dV;\n if (!perim_ok(XL, XR, newV)) continue;\n\n int newC = slabs[i].range_sum(newL, newU);\n int newTot = total - contrib[i] + newC;\n int dScore = newTot - total;\n\n bool accept = false;\n if (dScore > 0) accept = true;\n else if (dScore == 0) {\n if (newV < Vlen) accept = true;\n else accept = (rng.next_double() < 0.12);\n } else {\n double prob = exp((double)dScore / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n L[i] = newL; U[i] = newU;\n Vlen = newV;\n total = newTot;\n contrib[i] = newC;\n if (total > bestTot || (total == bestTot && Vlen < bestV)) {\n bestTot = total;\n bestV = Vlen;\n bestL = L;\n bestU = U;\n }\n }\n }\n\n // ---- NEW: trim slabs by best subarray of contributions ----\n // This changes [XL,XR] effectively and often removes bad edge slabs.\n {\n vector slabC(K);\n for (int i = 0; i < K; i++) slabC[i] = slabs[i].range_sum(bestL[i], bestU[i]);\n\n int minLen = 4;\n if (K >= minLen) {\n // best subarray with length >= minLen\n // Use prefix sums and keep minimum prefix up to i-minLen.\n vector pref(K+1, 0);\n for (int i = 0; i < K; i++) pref[i+1] = pref[i] + slabC[i];\n\n int bestSum = INT_MIN;\n int bestLidx = 0, bestRidx = K-1;\n\n int minPref = pref[0];\n int minPos = 0;\n for (int r = minLen-1; r < K; r++) {\n int lCandidate = r - (minLen-1);\n if (pref[lCandidate] < minPref) { minPref = pref[lCandidate]; minPos = lCandidate; }\n int sum = pref[r+1] - minPref;\n if (sum > bestSum) {\n bestSum = sum;\n bestLidx = minPos;\n bestRidx = r;\n }\n }\n\n // Apply trim only if it improves\n if (bestSum >= bestTot) {\n int newK = bestRidx - bestLidx + 1;\n if (newK >= minLen) {\n vector nL(newK), nU(newK);\n for (int i = 0; i < newK; i++) {\n nL[i] = bestL[bestLidx + i];\n nU[i] = bestU[bestLidx + i];\n }\n vector nxs;\n nxs.reserve(newK+1);\n for (int i = 0; i <= newK; i++) nxs.push_back(xs[bestLidx + i]);\n\n // Recompute Vlen and perimeter feasibility\n long long nV = Vlen_full(nL, nU);\n int nXL = nxs.front();\n int nXR = nxs.back();\n if (perim_ok(nXL, nXR, nV)) {\n bestTot = bestSum;\n bestL.swap(nL);\n bestU.swap(nU);\n xs.swap(nxs);\n K = newK;\n }\n }\n }\n }\n }\n\n // Build polygon from bestL/bestU with possibly trimmed K/xs\n vector> poly;\n poly.reserve(4*K + 10);\n auto pushv = [&](int x, int y) {\n if (!poly.empty() && poly.back().first == x && poly.back().second == y) return;\n poly.push_back({x,y});\n };\n\n pushv(xs[0], bestL[0]);\n for (int i = 0; i < K-1; i++) {\n pushv(xs[i+1], bestL[i]);\n if (bestL[i+1] != bestL[i]) pushv(xs[i+1], bestL[i+1]);\n }\n pushv(xs[K], bestL[K-1]);\n if (bestU[K-1] != bestL[K-1]) pushv(xs[K], bestU[K-1]);\n for (int i = K-1; i >= 1; i--) {\n pushv(xs[i], bestU[i]);\n if (bestU[i-1] != bestU[i]) pushv(xs[i], bestU[i-1]);\n }\n pushv(xs[0], bestU[0]);\n if (bestL[0] != bestU[0]) pushv(xs[0], bestL[0]);\n if (!poly.empty() && poly.front() == poly.back()) poly.pop_back();\n\n remove_collinear(poly);\n\n bool ok = (poly.size() >= 4 && poly.size() <= 1000);\n if (ok) {\n unordered_set seen;\n seen.reserve(poly.size()*2);\n for (auto &v: poly) {\n long long key = (long long)v.first * 200001LL + v.second;\n if (seen.count(key)) { ok = false; break; }\n seen.insert(key);\n }\n }\n if (!ok) {\n Rect r = clamp_rect(base);\n poly = {{r.xl,r.yb},{r.xr,r.yb},{r.xr,r.yt},{r.xl,r.yt}};\n bestTot = eval_rect_fast(r);\n }\n\n if (bestTot > globalBestTot) {\n globalBestTot = bestTot;\n globalBestPoly = move(poly);\n }\n }\n\n if (globalBestPoly.empty()) globalBestPoly = {{0,0},{1,0},{1,1},{0,1}};\n return {globalBestTot, globalBestPoly};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector pts(2*N);\n vector macks; macks.reserve(N);\n\n for (int i = 0; i < 2*N; i++) {\n int x,y; cin >> x >> y;\n int w = (i < N) ? +1 : -1;\n pts[i] = {x,y,w};\n if (i < N) macks.push_back({x,y,+1});\n }\n\n double t0 = now_sec();\n const double TL = 1.95;\n double hardEnd = t0 + TL * 0.99;\n\n uint64_t baseSeed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n baseSeed ^= (uint64_t)(pts[0].x * 1000003u + pts[0].y * 9176u + 12345u);\n\n // swapped instance\n vector ptsS = pts;\n vector macksS; macksS.reserve(macks.size());\n for (auto &p: ptsS) swap(p.x, p.y);\n for (auto &p: macks) macksS.push_back({p.y, p.x, +1});\n\n // quick estimate to split time between orientations\n int estA = quick_best_rect_estimate(pts, macks, baseSeed ^ 0xAAAABBBBULL);\n int estB = quick_best_rect_estimate(ptsS, macksS, baseSeed ^ 0xCCCCDDDDULL);\n double a = max(1.0, (double)(estA + 200));\n double b = max(1.0, (double)(estB + 200));\n double fracA = a / (a + b);\n // keep both at least 35%\n fracA = min(0.65, max(0.35, fracA));\n\n double endA = t0 + (hardEnd - t0) * fracA;\n double endB = hardEnd;\n\n SolveResult A = solve_monotone(pts, macks, endA, baseSeed ^ 0x11111111ULL);\n SolveResult B = solve_monotone(ptsS, macksS, endB, baseSeed ^ 0x22222222ULL);\n for (auto &v: B.poly) swap(v.first, v.second);\n\n SolveResult best = (B.diff > A.diff) ? B : A;\n\n cout << best.poly.size() << \"\\n\";\n for (auto &v: best.poly) cout << v.first << \" \" << v.second << \"\\n\";\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct Op {\n int p;\n int r; // 0/1\n char d; // 'L' or 'U'\n int b; // -1 or previous index\n};\n\nstruct Placed {\n ll x=0, y=0, w=0, h=0;\n};\n\nstatic inline bool overlapPosLen(ll a1, ll a2, ll b1, ll b2) {\n return max(a1, b1) < min(a2, b2);\n}\n\nstruct RNG {\n uint64_t x;\n explicit RNG(uint64_t seed=88172645463325252ULL) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline pair place_one(const Placed placed[], int i, ll w, ll h, char d, int b) {\n ll x=0, y=0;\n if (d == 'U') {\n x = 0;\n if (b != -1) x = placed[b].x + placed[b].w;\n y = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(x, x+w, pj.x, pj.x+pj.w)) y = max(y, pj.y + pj.h);\n }\n } else { // 'L'\n y = 0;\n if (b != -1) y = placed[b].y + placed[b].h;\n x = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(y, y+h, pj.y, pj.y+pj.h)) x = max(x, pj.x + pj.w);\n }\n }\n return {x,y};\n}\n\npair simulate_ops(const vector& ops, const vector& W, const vector& H) {\n int N = (int)ops.size();\n vector placed(N);\n ll maxX=0, maxY=0;\n\n for (int i = 0; i < N; i++) {\n const auto& op = ops[i];\n ll w = W[op.p], h = H[op.p];\n if (op.r) swap(w,h);\n auto [x,y] = place_one(placed.data(), i, w, h, op.d, op.b);\n placed[i] = Placed{x,y,w,h};\n maxX = max(maxX, x+w);\n maxY = max(maxY, y+h);\n }\n return {maxX, maxY};\n}\n\nstruct Candidate {\n vector ops;\n ll estW = (1LL<<62), estH = (1LL<<62), estObj = (1LL<<62);\n string tag;\n};\n\nCandidate make_all_one_row(const vector& w, const vector& h, uint64_t seed, string tag=\"oneRow\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n for (int i=0;i& w, const vector& h, uint64_t seed, string tag=\"oneCol\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n for (int i=0;i& w, const vector& h, ll Wlim, uint64_t seed, string tag=\"rowShelf\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n int prevAnchor=-1;\n ll rowW=0, rowH=0;\n int rowTall=-1; ll rowTallH=-1;\n\n auto finish_row = [&](){\n prevAnchor = rowTall;\n rowW=0; rowH=0;\n rowTall=-1; rowTallH=-1;\n };\n\n for(int i=0;i0){\n bool fit0 = (rowW+w0<=Wlim);\n bool fit1 = (rowW+w1<=Wlim);\n if(!fit0 && !fit1) finish_row();\n else if(rowW > (ll)llround((long double)Wlim*0.95L) && rng.next_double()<0.20) finish_row();\n }\n\n int r=0;\n bool fit0 = (rowW+w0<=Wlim);\n bool fit1 = (rowW+w1<=Wlim);\n if(fit0 && fit1){\n ll rh0=max(rowH,h0), rh1=max(rowH,h1);\n if(rh1rowTallH){ rowTallH=hh; rowTall=i; }\n }\n\n auto [W,H] = simulate_ops(c.ops,w,h);\n c.estW=W; c.estH=H; c.estObj=W+H;\n c.tag = tag + \"(Wlim=\" + to_string(Wlim) + \")\";\n return c;\n}\n\nCandidate make_col_shelf(const vector& w, const vector& h, ll Hlim, uint64_t seed, string tag=\"colShelf\") {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n int prevAnchor=-1;\n ll colH=0, colW=0;\n int colWide=-1; ll colWideW=-1;\n\n auto finish_col = [&](){\n prevAnchor = colWide;\n colH=0; colW=0;\n colWide=-1; colWideW=-1;\n };\n\n for(int i=0;i0){\n bool fit0 = (colH+h0<=Hlim);\n bool fit1 = (colH+h1<=Hlim);\n if(!fit0 && !fit1) finish_col();\n else if(colH > (ll)llround((long double)Hlim*0.95L) && rng.next_double()<0.20) finish_col();\n }\n\n int r=0;\n bool fit0 = (colH+h0<=Hlim);\n bool fit1 = (colH+h1<=Hlim);\n if(fit0 && fit1){\n ll cw0=max(colW,w0), cw1=max(colW,w1);\n if(cw1colWideW){ colWideW=ww; colWide=i; }\n }\n\n auto [W,H] = simulate_ops(c.ops,w,h);\n c.estW=W; c.estH=H; c.estObj=W+H;\n c.tag = tag + \"(Hlim=\" + to_string(Hlim) + \")\";\n return c;\n}\n\n// O(i*K) topK selection (no O(i log i))\nstatic inline void topK_by_right(const Placed placed[], int i, int K, vector& out) {\n out.clear();\n vector> best;\n best.reserve(K);\n for(int j=0;j best[0].first) {\n best[0] = {key,j};\n int t=0;\n while(t+1 best[t+1].first) { swap(best[t], best[t+1]); t++; }\n }\n }\n for(auto &p: best) out.push_back(p.second);\n sort(out.begin(), out.end());\n out.erase(unique(out.begin(), out.end()), out.end());\n}\nstatic inline void topK_by_bottom(const Placed placed[], int i, int K, vector& out) {\n out.clear();\n vector> best;\n best.reserve(K);\n for(int j=0;j best[0].first) {\n best[0] = {key,j};\n int t=0;\n while(t+1 best[t+1].first) { swap(best[t], best[t+1]); t++; }\n }\n }\n for(auto &p: best) out.push_back(p.second);\n sort(out.begin(), out.end());\n out.erase(unique(out.begin(), out.end()), out.end());\n}\n\nCandidate make_greedy_mosaic(\n const vector& w, const vector& h,\n uint64_t seed,\n int Kanchor,\n int randAnchor,\n double aspectPenalty,\n double areaPenalty,\n double pPreferL,\n string tag=\"greedy\"\n) {\n const int MAXN=100;\n int N=(int)w.size();\n RNG rng(seed);\n\n array placed{};\n array ops{};\n ll curW=0, curH=0;\n\n auto eval = [&](ll W, ll H)->double{\n long double s = (long double)W + (long double)H;\n s += (long double)aspectPenalty * fabsl((long double)W - (long double)H);\n s += (long double)areaPenalty * ((long double)W * (long double)H) / 1e6L;\n return (double)s;\n };\n\n vector BU, BL, tmp;\n for(int i=0;i0){\n topK_by_right(placed.data(), i, Kanchor, tmp);\n BU.insert(BU.end(), tmp.begin(), tmp.end());\n topK_by_bottom(placed.data(), i, Kanchor, tmp);\n BL.insert(BL.end(), tmp.begin(), tmp.end());\n for(int t=0;t& w, const vector& h,\n uint64_t seed,\n int beamWidth,\n int Kanchor,\n int randAnchor,\n double aspectPenalty,\n double areaPenalty,\n double pPreferL,\n string tag=\"beam\"\n) {\n const int MAXN=100;\n int N=(int)w.size();\n RNG rng(seed);\n\n struct State {\n ll W=0, H=0;\n double score=0;\n array placed;\n array ops;\n };\n\n auto eval = [&](ll W, ll H)->double{\n long double s = (long double)W + (long double)H;\n s += (long double)aspectPenalty * fabsl((long double)W - (long double)H);\n s += (long double)areaPenalty * ((long double)W * (long double)H) / 1e6L;\n return (double)s;\n };\n\n vector cur, nxt;\n cur.reserve(beamWidth);\n nxt.reserve(beamWidth * 48);\n\n State init;\n init.W=0; init.H=0; init.score=eval(0,0);\n cur.push_back(init);\n\n vector BU, BL, tmp;\n\n for(int i=0;i0){\n topK_by_right(st.placed.data(), i, Kanchor, tmp);\n BU.insert(BU.end(), tmp.begin(), tmp.end());\n topK_by_bottom(st.placed.data(), i, Kanchor, tmp);\n BL.insert(BL.end(), tmp.begin(), tmp.end());\n for(int t=0;t& Bset){\n ll ww = (r? w1:w0);\n ll hh = (r? h1:h0);\n for(int b: Bset){\n auto [x,y] = place_one(st.placed.data(), i, ww, hh, d, b);\n ll nW = max(st.W, x+ww);\n ll nH = max(st.H, y+hh);\n double sc = eval(nW,nH);\n sc *= (1.0 + 0.0002*(rng.next_double()-0.5));\n\n State ns;\n ns.W=nW; ns.H=nH; ns.score=sc;\n if(i>0){\n memcpy(ns.placed.data(), st.placed.data(), sizeof(Placed)*i);\n memcpy(ns.ops.data(), st.ops.data(), sizeof(Op)*i);\n }\n ns.placed[i] = Placed{x,y,ww,hh};\n ns.ops[i] = Op{i,r,d,b};\n nxt.push_back(ns);\n }\n };\n\n for(int rr=0; rr<2; rr++){\n int r=rr;\n if(rng.next_double()<0.05) r^=1;\n if(tryLFirst){\n expand(r,'L',BL);\n expand(r,'U',BU);\n }else{\n expand(r,'U',BU);\n expand(r,'L',BL);\n }\n }\n }\n\n if((int)nxt.size() > beamWidth){\n nth_element(nxt.begin(), nxt.begin()+beamWidth, nxt.end(),\n [](const State& a, const State& b){ return a.score < b.score; });\n nxt.resize(beamWidth);\n }\n sort(nxt.begin(), nxt.end(), [](const State& a, const State& b){ return a.score < b.score; });\n cur.swap(nxt);\n }\n\n const State& best = cur.front();\n Candidate c;\n c.ops.resize(N);\n for(int i=0;i> N >> T >> sigma;\n vector wp(N), hp(N);\n for(int i=0;i> wp[i] >> hp[i];\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed = [&](){\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - t0).count();\n };\n\n // Time budget for precomputation. Leave margin for interactive IO + variability.\n const double PRECOMP_LIMIT = 2.20;\n\n long double areaSum=0;\n ll sumW=0, sumH=0;\n for(int i=0;i(1, (ll)floor(sqrt(areaSum)));\n\n vector pool;\n pool.reserve(256);\n\n // Baselines\n pool.push_back(make_all_one_row(wp,hp,1,\"oneRow\"));\n pool.push_back(make_all_one_col(wp,hp,2,\"oneCol\"));\n\n // Shelves (cheap diversity)\n {\n vector factors = {0.60L, 0.75L, 0.90L, 1.00L, 1.15L, 1.35L, 1.55L};\n uint64_t seedBase = 1234567;\n for(int fi=0; fi<(int)factors.size() && elapsed()(1, min(Wlim, sumW));\n for(int k=0;k<2 && elapsed()(1, min(Hlim, sumH));\n for(int k=0;k<2 && elapsed() asp = {0.00, 0.05, 0.10};\n vector areaP = {0.0, 0.0010, 0.0020};\n vector bias = {0.35, 0.50, 0.65};\n for(double a: asp) for(double ap: areaP) for(double bl: bias){\n for(int rep=0; rep<4 && elapsed() params = {\n {22, 7, 1, 0.03, 0.0010, 0.50},\n {26, 7, 1, 0.03, 0.0010, 0.50},\n {22, 8, 1, 0.06, 0.0016, 0.50},\n {24, 7, 1, 0.00, 0.0016, 0.50},\n {22, 7, 1, 0.06, 0.0000, 0.60},\n {22, 7, 1, 0.06, 0.0000, 0.40},\n };\n for(int round=0; round<3 && elapsed()=PRECOMP_LIMIT) break;\n pool.push_back(make_beam_mosaic(wp,hp, sd++, pm.B, pm.K, pm.R, pm.a, pm.ap, pm.bl, \"beam\"));\n }\n }\n }\n\n // Keep best candidates by estimated objective\n for(auto &c: pool) c.estObj = c.estW + c.estH;\n sort(pool.begin(), pool.end(), [](const Candidate& a, const Candidate& b){\n if(a.estObj != b.estObj) return a.estObj < b.estObj;\n if(a.estW != b.estW) return a.estW < b.estW;\n return a.estH < b.estH;\n });\n\n // Limit number of distinct candidates we will try (trying many is ok but not necessary)\n int KEEP = min((int)pool.size(), min(T, 80));\n pool.resize(KEEP);\n\n ll bestMeasured = (1LL<<62);\n int bestIdx = 0;\n\n for(int t=0;t> Wm >> Hm)) return 0;\n ll measured = Wm + Hm;\n if(measured < bestMeasured){\n bestMeasured = measured;\n bestIdx = useIdx;\n }\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nstatic inline uint32_t xorshift32(uint32_t &x) {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n}\nstatic inline double rand01(uint32_t &x) {\n return (double)xorshift32(x) / 4294967296.0;\n}\n\nstruct BFSResult {\n vector dist;\n vector prev;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n\n vector> edges(M);\n vector> g(N);\n g.assign(N, {});\n\n unordered_set edgeSet;\n edgeSet.reserve(M * 2);\n\n auto keyEdge = [&](int u, int v)->long long{\n if (u > v) swap(u, v);\n return (long long)u * N + v;\n };\n\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n edges[i] = {u, v};\n g[u].push_back(v);\n g[v].push_back(u);\n edgeSet.insert(keyEdge(u, v));\n }\n // coords unused\n for (int i = 0; i < N; i++) { int x, y; cin >> x >> y; }\n\n auto multiSourceBFS = [&](const vector& roots)->BFSResult{\n const int INF = 1e9;\n BFSResult res;\n res.dist.assign(N, INF);\n res.prev.assign(N, -1);\n deque q;\n for (int r : roots) {\n res.dist[r] = 0;\n res.prev[r] = -1;\n q.push_back(r);\n }\n while (!q.empty()) {\n int v = q.front(); q.pop_front();\n int nd = res.dist[v] + 1;\n for (int to : g[v]) {\n if (res.dist[to] > nd) {\n res.dist[to] = nd;\n res.prev[to] = v;\n q.push_back(to);\n }\n }\n }\n return res;\n };\n\n // -----------------------\n // 1) Root selection to ensure all vertices within distance <= H\n // -----------------------\n int root0 = (int)(min_element(A.begin(), A.end()) - A.begin());\n vector roots = {root0};\n\n while (true) {\n auto bfs = multiSourceBFS(roots);\n int far = -1, farD = -1;\n for (int i = 0; i < N; i++) {\n if (bfs.dist[i] > farD) { farD = bfs.dist[i]; far = i; }\n }\n if (farD <= H) break;\n\n int cur = far;\n int steps = farD - H;\n\n int child1 = -1, child2 = -1;\n for (int s = 0; s < steps; s++) {\n child2 = child1;\n child1 = cur;\n cur = bfs.prev[cur];\n if (cur == -1) break;\n }\n if (cur == -1) { roots.push_back(far); continue; }\n\n int best = cur;\n auto consider = [&](int v){\n if (v == -1) return;\n if (A[v] < A[best]) best = v;\n };\n consider(child1);\n consider(child2);\n roots.push_back(best);\n }\n\n // Remove redundant roots\n {\n uint32_t rng = 123456789u;\n vector order = roots;\n for (int i = (int)order.size() - 1; i > 0; i--) {\n int j = (int)(xorshift32(rng) % (i + 1));\n swap(order[i], order[j]);\n }\n vector alive(N, 0);\n for (int r : roots) alive[r] = 1;\n\n for (int r : order) {\n if (!alive[r]) continue;\n vector tmp;\n tmp.reserve(roots.size());\n for (int rr : roots) if (alive[rr] && rr != r) tmp.push_back(rr);\n if (tmp.empty()) continue;\n\n auto bfs = multiSourceBFS(tmp);\n int mx = 0;\n for (int i = 0; i < N; i++) mx = max(mx, bfs.dist[i]);\n if (mx <= H) alive[r] = 0;\n }\n vector newRoots;\n for (int r : roots) if (alive[r]) newRoots.push_back(r);\n roots.swap(newRoots);\n }\n\n // -----------------------\n // 2) Initial forest by BFS\n // -----------------------\n auto bfs = multiSourceBFS(roots);\n vector parent(N, -1), depth(N, 0);\n for (int v = 0; v < N; v++) {\n if (bfs.dist[v] <= H) {\n parent[v] = bfs.prev[v];\n depth[v] = bfs.dist[v];\n } else {\n parent[v] = -1;\n depth[v] = 0;\n }\n }\n\n // -----------------------\n // 3) Children structure\n // -----------------------\n vector> children(N);\n vector idxInChild(N, -1);\n\n auto addChild = [&](int p, int v) {\n idxInChild[v] = (int)children[p].size();\n children[p].push_back(v);\n };\n auto removeChild = [&](int p, int v) {\n int idx = idxInChild[v];\n if (idx < 0) return;\n int last = children[p].back();\n children[p][idx] = last;\n idxInChild[last] = idx;\n children[p].pop_back();\n idxInChild[v] = -1;\n };\n\n children.assign(N, {});\n idxInChild.assign(N, -1);\n for (int v = 0; v < N; v++) if (parent[v] != -1) addChild(parent[v], v);\n\n long long score = 0;\n for (int v = 0; v < N; v++) score += 1LL * (depth[v] + 1) * A[v];\n\n // subtree marking to avoid cycles quickly\n vector mark(N, 0);\n int markToken = 1;\n\n vector st, sub;\n st.reserve(N);\n sub.reserve(N);\n\n auto collectSubtree = [&](int v, long long &sumA, int &maxD) {\n sumA = 0;\n maxD = -1;\n sub.clear();\n st.clear();\n st.push_back(v);\n markToken++;\n if (markToken == INT_MAX) { mark.assign(N, 0); markToken = 1; }\n while (!st.empty()) {\n int x = st.back(); st.pop_back();\n sub.push_back(x);\n mark[x] = markToken;\n sumA += A[x];\n maxD = max(maxD, depth[x]);\n for (int ch : children[x]) st.push_back(ch);\n }\n };\n\n // -----------------------\n // 4) SA: best-neighbor reparent + occasional random-edge move\n // -----------------------\n uint32_t rng = 987654321u;\n auto start = chrono::steady_clock::now();\n auto elapsed = [&]() {\n return chrono::duration(chrono::steady_clock::now() - start).count();\n };\n\n const double TL = 1.93;\n const double T0 = 20000.0;\n const double T1 = 50.0;\n\n auto acceptGain = [&](long long gain, double T)->bool {\n if (gain >= 0) return true;\n double p = exp((double)gain / T);\n return rand01(rng) < p;\n };\n\n auto pickVertexBiased = [&]()->int{\n // tournament selection among a few random vertices\n // prefer high A and still shallow (more room to deepen)\n int best = (int)(xorshift32(rng) % N);\n long long bestKey = 1LL * A[best] * (H - depth[best] + 1);\n for (int k = 0; k < 3; k++) {\n int v = (int)(xorshift32(rng) % N);\n long long key = 1LL * A[v] * (H - depth[v] + 1);\n if (key > bestKey) { bestKey = key; best = v; }\n }\n return best;\n };\n\n int it = 0;\n while (true) {\n if ((it & 2047) == 0) {\n if (elapsed() > TL) break;\n }\n it++;\n\n double prog = elapsed() / TL;\n if (prog > 1.0) prog = 1.0;\n double T = T0 * pow(T1 / T0, prog);\n\n int mode = (int)(xorshift32(rng) % 100);\n\n if (mode < 80) {\n // Best-neighbor reparent for a chosen vertex v\n int v = pickVertexBiased();\n\n long long sumA; int maxD;\n collectSubtree(v, sumA, maxD);\n\n // Candidate: cut to root (only if not already root)\n int bestU = -2; // -1 means root, >=0 means parent, -2 none\n int bestDelta = 0;\n long long bestGain = LLONG_MIN;\n\n if (parent[v] != -1) {\n int delta = -depth[v];\n long long gain = 1LL * delta * sumA;\n bestU = -1;\n bestDelta = delta;\n bestGain = gain;\n }\n\n // Try each neighbor as new parent\n for (int u : g[v]) {\n if (u == parent[v]) continue;\n if (mark[u] == markToken) continue; // would create cycle\n\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n\n int delta = newDepthV - depth[v];\n if (maxD + delta > H) continue;\n\n long long gain = 1LL * delta * sumA;\n if (gain > bestGain) {\n bestGain = gain;\n bestU = u;\n bestDelta = delta;\n }\n }\n\n if (bestU == -2) continue;\n\n // Exploration: sometimes pick a random feasible neighbor (or cut)\n if (rand01(rng) < 0.12) {\n vector> cand; // (u, delta), u=-1 allowed\n cand.reserve(g[v].size() + 1);\n if (parent[v] != -1) cand.push_back({-1, -depth[v]});\n for (int u : g[v]) {\n if (u == parent[v]) continue;\n if (mark[u] == markToken) continue;\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n int delta = newDepthV - depth[v];\n if (maxD + delta > H) continue;\n cand.push_back({u, delta});\n }\n if (!cand.empty()) {\n auto [u, delta] = cand[xorshift32(rng) % cand.size()];\n bestU = u;\n bestDelta = delta;\n bestGain = 1LL * bestDelta * sumA;\n }\n }\n\n if (!acceptGain(bestGain, T)) continue;\n\n // Apply\n int oldp = parent[v];\n if (oldp != -1) removeChild(oldp, v);\n\n if (bestU == -1) {\n parent[v] = -1;\n } else {\n parent[v] = bestU;\n addChild(bestU, v);\n }\n\n for (int x : sub) depth[x] += bestDelta;\n score += bestGain;\n\n } else {\n // Random edge reparent (diversity)\n auto [a, b] = edges[xorshift32(rng) % M];\n int u, v;\n if (xorshift32(rng) & 1) { u = a; v = b; }\n else { u = b; v = a; }\n\n if (u == v) continue;\n if (parent[v] == u) continue;\n\n // cheap cycle check: v not ancestor of u (H small)\n bool cycle = false;\n int cur = u;\n while (cur != -1) {\n if (cur == v) { cycle = true; break; }\n cur = parent[cur];\n }\n if (cycle) continue;\n\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n int delta = newDepthV - depth[v];\n\n long long sumA; int maxD;\n collectSubtree(v, sumA, maxD);\n if (maxD + delta > H) continue;\n\n long long gain = 1LL * delta * sumA;\n if (!acceptGain(gain, T)) continue;\n\n int oldp = parent[v];\n if (oldp != -1) removeChild(oldp, v);\n parent[v] = u;\n addChild(u, v);\n\n for (int x : sub) depth[x] += delta;\n score += gain;\n }\n }\n\n // -----------------------\n // 5) Final legality enforcement\n // -----------------------\n for (int v = 0; v < N; v++) {\n if (parent[v] != -1 && !edgeSet.count(keyEdge(v, parent[v]))) parent[v] = -1;\n }\n\n // rebuild children\n children.assign(N, {});\n idxInChild.assign(N, -1);\n for (int v = 0; v < N; v++) if (parent[v] != -1) addChild(parent[v], v);\n\n // recompute depths from roots; cut cycles/unreachable; enforce height\n auto fixDepths = [&](){\n vector dep(N, -1);\n deque q;\n for (int v = 0; v < N; v++) if (parent[v] == -1) {\n dep[v] = 0;\n q.push_back(v);\n }\n while (!q.empty()) {\n int x = q.front(); q.pop_front();\n for (int ch : children[x]) {\n if (dep[ch] != -1) continue;\n dep[ch] = dep[x] + 1;\n q.push_back(ch);\n }\n }\n bool changed = false;\n for (int v = 0; v < N; v++) {\n if (dep[v] == -1 || dep[v] > H) {\n parent[v] = -1;\n changed = true;\n }\n }\n if (changed) {\n children.assign(N, {});\n idxInChild.assign(N, -1);\n for (int v = 0; v < N; v++) if (parent[v] != -1) addChild(parent[v], v);\n // recompute again\n dep.assign(N, -1);\n q.clear();\n for (int v = 0; v < N; v++) if (parent[v] == -1) {\n dep[v] = 0;\n q.push_back(v);\n }\n while (!q.empty()) {\n int x = q.front(); q.pop_front();\n for (int ch : children[x]) {\n if (dep[ch] != -1) continue;\n dep[ch] = dep[x] + 1;\n q.push_back(ch);\n }\n }\n }\n depth.swap(dep);\n };\n fixDepths();\n\n // Output\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << \"\\n\";\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstatic constexpr int NMAX = 20;\n\nstruct XorShift {\n uint64_t x=88172645463325252ull;\n explicit XorShift(uint64_t seed=0){\n if(seed) x ^= seed + 0x9e3779b97f4a7c15ull;\n }\n uint64_t next_u64(){\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int n){ return (int)(next_u64() % (uint64_t)n); }\n double next_double(){\n return (next_u64() >> 11) * (1.0/9007199254740992.0);\n }\n};\n\nstruct Board {\n int N=0;\n array,NMAX> a{};\n int oniCnt=0;\n\n void init(int n, const vector& C){\n N=n; oniCnt=0;\n for(int i=0;i=1;j--) a[i][j]=a[i][j-1];\n a[i][0]='.';\n }\n void shiftColUp(int j){\n char removed = a[0][j];\n if(removed=='x') oniCnt--;\n for(int i=0;i=1;i--) a[i][j]=a[i-1][j];\n a[0][j]='.';\n }\n\n void applySingle(char dir, int p){\n if(dir=='L') shiftRowLeft(p);\n else if(dir=='R') shiftRowRight(p);\n else if(dir=='U') shiftColUp(p);\n else shiftColDown(p);\n }\n};\n\nstruct FlushCand {\n char dir; // L/R/U/D\n int p; // row or col\n int k; // steps\n int gain; // removed x count (in removed segment)\n};\n\nstatic inline int safeEdgeScore(const Board& bd){\n int N = bd.N;\n int score = 0;\n for(int i=0;i=1 x (current state).\nstatic void collectFlushes(const Board& bd, vector& out){\n out.clear();\n int N = bd.N;\n\n for(int i=0;i0) out.push_back({'L', i, k, g});\n }\n g=0;\n int maxK = N-(last+1);\n for(int k=1;k<=maxK;k++){\n if(bd.a[i][N-k]=='x') g++;\n if(g>0) out.push_back({'R', i, k, g});\n }\n }\n\n for(int j=0;j0) out.push_back({'U', j, k, g});\n }\n g=0;\n int maxK = N-(last+1);\n for(int k=1;k<=maxK;k++){\n if(bd.a[N-k][j]=='x') g++;\n if(g>0) out.push_back({'D', j, k, g});\n }\n }\n}\n\n// Apply flush safely (k times). Caller ensures it is safe.\nstatic inline void applyFlush(Board& bd, char dir, int p, int k,\n vector>* ops, int limit){\n for(int t=0;tsize() >= limit) return;\n if(ops) ops->push_back({dir,p});\n bd.applySingle(dir,p);\n }\n}\n\n// One greedy step used inside rollout (no expensive lookahead).\n// Returns number of moves consumed.\nstatic int greedyStep(Board& bd, XorShift& rng, int remainingMoves){\n if(remainingMoves <= 0) return 0;\n\n vector flushes;\n collectFlushes(bd, flushes);\n if(!flushes.empty()){\n // choose best by gain/k, tie by smaller k, then random\n int best = 0;\n for(int i=1;i<(int)flushes.size(); i++){\n const auto& a = flushes[i];\n const auto& b = flushes[best];\n long long lhs = 1LL*a.gain*b.k;\n long long rhs = 1LL*b.gain*a.k;\n if(lhs != rhs) { if(lhs > rhs) best = i; }\n else if(a.gain != b.gain) { if(a.gain > b.gain) best = i; }\n else if(a.k != b.k) { if(a.k < b.k) best = i; }\n else if(rng.next_int(6)==0) best = i;\n }\n int k = min(flushes[best].k, remainingMoves);\n applyFlush(bd, flushes[best].dir, flushes[best].p, k, nullptr, 0);\n return k;\n }\n\n // rearrangement: choose single move maximizing immediate ejection + next flush gain\n int N = bd.N;\n char bestD = 0; int bestP = -1;\n long long bestV = LLONG_MIN;\n\n for(int p=0;p bestV){\n bestV = v; bestD = d; bestP = p;\n }\n }\n }\n if(bestP==-1) return 0;\n bd.applySingle(bestD, bestP);\n return 1;\n}\n\n// Rollout evaluation: apply up to maxMoves greedy moves and return a value.\nstatic long long rolloutValue(const Board& start, int maxMoves, XorShift& rng){\n Board bd = start;\n int startOni = bd.oniCnt;\n int used = 0;\n while(used < maxMoves && bd.oniCnt > 0){\n int c = greedyStep(bd, rng, maxMoves - used);\n if(c<=0) break;\n used += c;\n }\n int removed = startOni - bd.oniCnt;\n int safe = safeEdgeScore(bd);\n int nextG = bestFlushGain(bd);\n\n // value tries to correlate with finishing quickly\n long long v = 0;\n v += 30000LL * removed;\n v -= 800LL * used;\n v -= 20000LL * bd.oniCnt;\n v += 15LL * safe;\n v += 6000LL * nextG;\n return v;\n}\n\n// Baseline guaranteed reversible method (always safe from initial board).\nstatic vector> buildBaselineGuaranteed(int N, const vector& C){\n vector rowFirstF(N, N), rowLastF(N, -1);\n vector colFirstF(N, N), colLastF(N, -1);\n vector> oni;\n\n for(int i=0;i> ops;\n ops.reserve(1600);\n for(auto [i,j] : oni){\n if(rowFirstF[i] > j){\n int k=j+1;\n for(int t=0;t i){\n int k=i+1;\n for(int t=0;t 4*N*N) return {};\n return ops;\n}\n\n// One full heuristic run (randomized); returns ops if solved else empty.\nstatic vector> runHeuristic(const vector& C, uint64_t seed,\n chrono::high_resolution_clock::time_point startAll,\n double timeLimitSec){\n const int N = (int)C.size();\n const int LIMIT = 4*N*N;\n XorShift rng(seed);\n\n auto time_ok = [&](){\n double t = chrono::duration(chrono::high_resolution_clock::now() - startAll).count();\n return t < timeLimitSec;\n };\n\n Board bd;\n bd.init(N, C);\n vector> ops;\n ops.reserve(LIMIT);\n\n vector flushes;\n\n int stagnant = 0;\n\n while(bd.oniCnt > 0 && (int)ops.size() < LIMIT && time_ok()){\n collectFlushes(bd, flushes);\n if(!flushes.empty()){\n // Sort by ratio gain/k and take top K.\n sort(flushes.begin(), flushes.end(), [&](const FlushCand& a, const FlushCand& b){\n long long lhs = 1LL*a.gain*b.k;\n long long rhs = 1LL*b.gain*a.k;\n if(lhs != rhs) return lhs > rhs;\n if(a.gain != b.gain) return a.gain > b.gain;\n return a.k < b.k;\n });\n\n int K = min(10, flushes.size());\n\n // If best clearly dominates, take it directly (save time)\n bool clearBest = true;\n if(K >= 2){\n const auto& a = flushes[0];\n const auto& b = flushes[1];\n // if ratios are close and gains close -> do rollout\n long long lhs = 1LL*a.gain*b.k;\n long long rhs = 1LL*b.gain*a.k;\n if(lhs < rhs + b.k) clearBest = false; // tiny threshold\n }\n\n FlushCand best = flushes[0];\n if(!clearBest){\n long long bestV = LLONG_MIN;\n int maxRoll = 24; // cheap\n for(int i=0;i bestV){\n bestV = v;\n best = c;\n }\n }\n } else {\n // slight randomization among top 2 occasionally\n if(K >= 2 && rng.next_int(10)==0) best = flushes[1];\n }\n\n applyFlush(bd, best.dir, best.p, best.k, &ops, LIMIT);\n stagnant = 0;\n continue;\n }\n\n // No flush removes x => rearrangement: choose best by rollout after 1 move\n vector> legal;\n legal.reserve(80);\n for(int p=0;p ms;\n ms.reserve(legal.size());\n\n int baseSafe = safeEdgeScore(bd);\n for(auto [d,p] : legal){\n Board t1 = bd;\n int before = t1.oniCnt;\n t1.applySingle(d,p);\n int eject = before - t1.oniCnt;\n int g = bestFlushGain(t1);\n int safe = safeEdgeScore(t1);\n long long quick = 250000LL*eject + 9000LL*g + 5LL*(safe - baseSafe) + (rng.next_int(9)-4);\n ms.push_back({d,p,quick});\n }\n sort(ms.begin(), ms.end(), [](const M& a, const M& b){ return a.quick > b.quick; });\n int L = min(12, ms.size());\n\n char bestD = ms[0].d;\n int bestP = ms[0].p;\n long long bestV = LLONG_MIN;\n int maxRoll = 18;\n\n for(int i=0;i bestV){\n bestV = v;\n bestD = ms[i].d;\n bestP = ms[i].p;\n }\n }\n\n ops.push_back({bestD, bestP});\n bd.applySingle(bestD, bestP);\n\n stagnant++;\n if(stagnant > 650) break;\n }\n\n if(bd.oniCnt == 0) return ops;\n return {};\n}\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector C(N);\n for(int i=0;i> C[i];\n\n const int LIMIT = 4*N*N;\n auto baseline = buildBaselineGuaranteed(N, C);\n\n auto startAll = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 1.90;\n\n uint64_t baseSeed = chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift master(baseSeed);\n\n vector> bestOps;\n if(!baseline.empty()) bestOps = baseline;\n\n // Multi-start within time; keep shortest solved.\n while(true){\n double elapsed = chrono::duration(chrono::high_resolution_clock::now() - startAll).count();\n if(elapsed > TIME_LIMIT) break;\n\n uint64_t seed = master.next_u64();\n auto ops = runHeuristic(C, seed, startAll, TIME_LIMIT);\n if(!ops.empty() && (bestOps.empty() || ops.size() < bestOps.size())){\n bestOps = std::move(ops);\n // early exit if very good\n if((int)bestOps.size() <= 110) break;\n }\n }\n\n if(bestOps.empty() || (int)bestOps.size() > LIMIT){\n bestOps = baseline;\n }\n\n for(auto [d,p] : bestOps){\n cout << d << \" \" << p << \"\\n\";\n }\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic constexpr int NMAX = 100;\n\nstatic inline long long simulate_plan(int N, int L,\n const int a[NMAX], const int b[NMAX],\n const int T[NMAX],\n int outCnt[NMAX]) {\n for (int i = 0; i < N; i++) outCnt[i] = 0;\n\n int x = 0;\n outCnt[x] = 1;\n\n for (int step = 1; step < L; step++) {\n // parity of visits to x so far decides next\n int nx = (outCnt[x] & 1) ? a[x] : b[x];\n x = nx;\n outCnt[x]++;\n }\n\n long long err = 0;\n for (int i = 0; i < N; i++) err += llabs((long long)outCnt[i] - (long long)T[i]);\n return err;\n}\n\n// Fast assignment optimizer for b:\n// Minimize sum_j |binSum[j] - D[j]| where binSum[j] = sum_{i: b[i]=j} T[i].\n// O(1) delta update per move.\nstruct FastBAssignOptimizer {\n int N;\n const int *T;\n const long long *D;\n XorShift64 *rng;\n\n vector b; // b[i]=bin\n array binSum{};\n long long cost = (1LL<<62);\n\n static inline long long absll(long long x){ return x<0?-x:x; }\n\n long long compute_cost() const {\n long long c = 0;\n for (int j = 0; j < N; j++) c += absll(binSum[j] - D[j]);\n return c;\n }\n\n // Greedy init with randomness:\n // place larger items first into the bin with largest remaining need (D - binSum),\n // with some random sampling.\n void greedy_init() {\n b.assign(N, 0);\n for (int j = 0; j < N; j++) binSum[j] = 0;\n\n vector items(N);\n iota(items.begin(), items.end(), 0);\n stable_sort(items.begin(), items.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] > T[j];\n return i < j;\n });\n\n // small shuffle among equal weights to diversify starts\n for (int l = 0; l < N; ) {\n int r = l;\n while (r < N && T[items[r]] == T[items[l]]) r++;\n for (int k = l; k < r; k++) {\n int s = (*rng).next_int(l, r - 1);\n swap(items[k], items[s]);\n }\n l = r;\n }\n\n for (int idx = 0; idx < N; idx++) {\n int i = items[idx];\n long long w = T[i];\n\n // sample a few bins and pick best by (D - binSum)\n int bestJ = 0;\n long long bestNeed = LLONG_MIN;\n int samples = 10;\n for (int t = 0; t < samples; t++) {\n int j = (*rng).next_int(0, N - 1);\n long long need = D[j] - binSum[j];\n // slight preference to bins where need>=w, but not required\n long long score = need;\n if (need < w) score -= (w - need) / 2;\n if (score > bestNeed) {\n bestNeed = score;\n bestJ = j;\n }\n }\n // also compare against current global best-need bin sometimes\n if ((*rng).next_double() < 0.5) {\n int j2 = 0;\n long long best2 = D[0] - binSum[0];\n for (int j = 1; j < N; j++) {\n long long need = D[j] - binSum[j];\n if (need > best2) { best2 = need; j2 = j; }\n }\n long long need = D[j2] - binSum[j2];\n long long score = need;\n if (need < w) score -= (w - need) / 2;\n if (score > bestNeed) bestJ = j2;\n }\n\n b[i] = bestJ;\n binSum[bestJ] += w;\n }\n\n cost = compute_cost();\n }\n\n void run_sa(int iterations, double t0, double t1) {\n // Prepare heavy items list for biased selection\n vector heavy(N);\n iota(heavy.begin(), heavy.end(), 0);\n stable_sort(heavy.begin(), heavy.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] > T[j];\n return i < j;\n });\n int Kheavy = min(N, 30);\n\n for (int it = 0; it < iterations; it++) {\n double prog = (double)it / max(1, iterations - 1);\n double temp = t0 * pow(t1 / t0, prog);\n\n int i = heavy[(*rng).next_int(0, Kheavy - 1)];\n int from = b[i];\n if (T[i] == 0) continue;\n\n // pick candidate bin: sample and choose most \"needed\"\n int to = from;\n long long bestNeed = LLONG_MIN;\n for (int s = 0; s < 8; s++) {\n int j = (*rng).next_int(0, N - 1);\n long long need = D[j] - binSum[j];\n if (need > bestNeed) { bestNeed = need; to = j; }\n }\n if (to == from) continue;\n\n long long w = T[i];\n long long oldPart = llabs(binSum[from] - D[from]) + llabs(binSum[to] - D[to]);\n\n long long newFromSum = binSum[from] - w;\n long long newToSum = binSum[to] + w;\n long long newPart = llabs(newFromSum - D[from]) + llabs(newToSum - D[to]);\n\n long long newCost = cost + (newPart - oldPart);\n\n bool accept = false;\n if (newCost <= cost) accept = true;\n else {\n double prob = exp((double)(cost - newCost) / temp);\n if ((*rng).next_double() < prob) accept = true;\n }\n if (accept) {\n b[i] = to;\n binSum[from] -= w;\n binSum[to] += w;\n cost = newCost;\n }\n }\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, L;\n cin >> N >> L;\n static int T[NMAX];\n for (int i = 0; i < N; i++) cin >> T[i];\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift64 rng(seed);\n\n // ---- Build a as ascending-by-T Hamiltonian cycle, rotated so order[0]=0 ----\n vector order(N);\n iota(order.begin(), order.end(), 0);\n stable_sort(order.begin(), order.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] < T[j];\n return i < j;\n });\n // rotate to put employee 0 at position 0 (slightly reduces start transient weirdness)\n {\n int pos0 = 0;\n for (int k = 0; k < N; k++) if (order[k] == 0) { pos0 = k; break; }\n rotate(order.begin(), order.begin() + pos0, order.end());\n }\n\n static int a[NMAX], b_cur[NMAX], b_best[NMAX];\n static int predOf[NMAX];\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n a[u] = v;\n }\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n predOf[v] = u;\n }\n\n // residual demand for b-slots in the stationary-equation sense:\n // 2*T[j] should equal sum of incoming slot-weights T[i] (one per outgoing edge-slot).\n // a-cycle already contributes one slot weight T[predOf[j]] into j.\n static long long D[NMAX];\n for (int j = 0; j < N; j++) D[j] = 2LL * T[j] - (long long)T[predOf[j]];\n // With ascending cycle, T[pred] <= T[j] => D[j] >= T[j] >= 0.\n\n // ---- Fast multi-start optimization of b assignment (cheap objective) ----\n vector best_b_assign;\n long long best_assign_cost = (1LL<<62);\n\n // decide time budget split\n auto tStart = chrono::high_resolution_clock::now();\n const double TL = 1.90; // overall\n const double TL_FAST = 0.55; // spend ~0.55s in cheap b-optimizer\n\n int restarts = 8;\n for (int r = 0; r < restarts; r++) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - tStart).count();\n if (elapsed > TL_FAST) break;\n\n FastBAssignOptimizer opt;\n opt.N = N;\n opt.T = T;\n opt.D = D;\n opt.rng = &rng;\n\n opt.greedy_init();\n // more iterations on first restart, fewer later\n int iters = (r == 0 ? 250000 : 150000);\n opt.run_sa(iters, 8000.0, 5.0);\n\n if (opt.cost < best_assign_cost) {\n best_assign_cost = opt.cost;\n best_b_assign = opt.b;\n }\n }\n\n if (best_b_assign.empty()) {\n best_b_assign.assign(N, 0);\n }\n for (int i = 0; i < N; i++) b_cur[i] = best_b_assign[i];\n\n // ---- Evaluate by true simulation ----\n static int cnt_cur[NMAX], cnt_tmp[NMAX];\n long long err_cur = simulate_plan(N, L, a, b_cur, T, cnt_cur);\n long long err_best = err_cur;\n for (int i = 0; i < N; i++) b_best[i] = b_cur[i];\n\n // ---- Expensive SA on true error, remaining time ----\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - tStart).count();\n if (elapsed > TL) break;\n\n double progress = (elapsed - TL_FAST) / max(1e-9, (TL - TL_FAST));\n progress = min(1.0, max(0.0, progress));\n double temp0 = 1500.0, temp1 = 10.0;\n double temp = temp0 * pow(temp1 / temp0, progress);\n\n // Build biased lists occasionally (cheap)\n // Pick i among those with large cnt (affects more future path)\n array idxByCnt;\n for (int i = 0; i < N; i++) idxByCnt[i] = i;\n nth_element(idxByCnt.begin(), idxByCnt.begin() + min(N, 30), idxByCnt.begin() + N,\n [&](int i, int j){ return cnt_cur[i] > cnt_cur[j]; });\n int i = idxByCnt[rng.next_int(0, min(N, 30) - 1)];\n\n bool doSwap = (rng.next_double() < 0.40);\n\n int old_bi = b_cur[i];\n int i2 = -1, old_bi2 = -1;\n\n if (!doSwap) {\n // Move b_i to a deficit node with bias\n // Choose candidate among top deficits by sampling\n int bestJ = old_bi;\n int bestDef = INT_MIN;\n for (int s = 0; s < 12; s++) {\n int j = rng.next_int(0, N - 1);\n int def = T[j] - cnt_cur[j];\n if (def > bestDef) { bestDef = def; bestJ = j; }\n }\n int j = bestJ;\n if (j == old_bi) continue;\n b_cur[i] = j;\n } else {\n // Swap two b's\n i2 = idxByCnt[rng.next_int(0, min(N, 30) - 1)];\n if (i2 == i) i2 = rng.next_int(0, N - 1);\n if (i2 == i) continue;\n old_bi2 = b_cur[i2];\n if (old_bi2 == old_bi) continue;\n swap(b_cur[i], b_cur[i2]);\n }\n\n long long err_new = simulate_plan(N, L, a, b_cur, T, cnt_tmp);\n\n bool accept = false;\n if (err_new <= err_cur) accept = true;\n else {\n double prob = exp((double)(err_cur - err_new) / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n err_cur = err_new;\n for (int k = 0; k < N; k++) cnt_cur[k] = cnt_tmp[k];\n if (err_cur < err_best) {\n err_best = err_cur;\n for (int k = 0; k < N; k++) b_best[k] = b_cur[k];\n }\n } else {\n // revert\n if (!doSwap) {\n b_cur[i] = old_bi;\n } else {\n swap(b_cur[i], b_cur[i2]);\n }\n }\n }\n\n // Output\n for (int i = 0; i < N; i++) {\n cout << a[i] << ' ' << b_best[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nstruct DSU {\n int n;\n vector p, r;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n p.resize(n);\n r.assign(n,0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){ return p[a]==a?a:p[a]=find(p[a]);}\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a] 0; s /= 2) {\n int rx = (x & s) ? 1 : 0;\n int ry = (y & s) ? 1 : 0;\n d += (uint32_t)s * (uint32_t)s * (uint32_t)((3 * rx) ^ ry);\n rot(s, x, y, rx, ry);\n }\n return d;\n}\nstatic inline long long dist2_est(int ax, int ay, int bx, int by){\n long long dx = ax - bx;\n long long dy = ay - by;\n return dx*dx + dy*dy;\n}\n\n// splitmix64 for deterministic randomness\nstatic inline uint64_t splitmix64(uint64_t &x) {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n}\n\nstruct GroupInfo {\n vector nodes;\n bool exactKnown = false;\n vector> exactEdges;\n vector> queryEdges;\n};\n\n// Build groups along an order with greedy size-picking.\n// Return (glist, chainScore). If rnd!=nullptr, break ties stochastically among best candidates.\nstatic pair, long long> build_groups_greedy_chainScore(\n const vector& order,\n const vector& ex,\n const vector& ey,\n const vector& G,\n uint64_t *rnd // nullable\n){\n const int N = (int)order.size();\n const int M = (int)G.size();\n\n vector pref(N, 0);\n for(int i=0;i+1long long{\n if(s<=1) return 0LL;\n return pref[p+s-1] - pref[p];\n };\n\n map cnt;\n for(int x: G) cnt[x]++;\n\n auto pop_size = [&](int s){\n auto it = cnt.find(s);\n if(it==cnt.end()) return false;\n if(--it->second==0) cnt.erase(it);\n return true;\n };\n\n auto collect_candidates = [&](int nrem, int grem)->vector{\n vector cands;\n cands.reserve(32);\n\n for(auto it = cnt.begin(); it != cnt.end() && (int)cands.size() < 6; ++it)\n if(it->first <= nrem) cands.push_back(it->first);\n\n int added = 0;\n for(auto it = cnt.rbegin(); it != cnt.rend() && added < 4; ++it){\n if(it->first <= nrem) { cands.push_back(it->first); added++; }\n }\n\n double target = (grem > 0) ? (double)nrem / (double)grem : (double)nrem;\n vector keys;\n keys.reserve(cnt.size());\n for(auto &kv: cnt) keys.push_back(kv.first);\n auto it = lower_bound(keys.begin(), keys.end(), (int)llround(target));\n for(int d=-3; d<=3; d++){\n int idx = (int)(it - keys.begin()) + d;\n if(0 <= idx && idx < (int)keys.size()){\n int s = keys[idx];\n if(s <= nrem) cands.push_back(s);\n }\n }\n\n sort(cands.begin(), cands.end());\n cands.erase(unique(cands.begin(), cands.end()), cands.end());\n if(cands.empty()){\n for(auto &kv: cnt) if(kv.first <= nrem) { cands.push_back(kv.first); break; }\n }\n return cands;\n };\n\n vector glist;\n glist.reserve(M);\n\n int p = 0;\n int groupsRem = M;\n long long totalChain = 0;\n\n while(groupsRem > 0){\n int nrem = N - p;\n if(groupsRem == 1){\n int s = nrem;\n if(!pop_size(s)){\n s = cnt.rbegin()->first;\n pop_size(s);\n }\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+s);\n totalChain += chainCost(p, s);\n glist.push_back(std::move(gi));\n p += s;\n groupsRem--;\n break;\n }\n\n auto cands = collect_candidates(nrem, groupsRem);\n\n long double target = (long double)nrem / (long double)groupsRem;\n const long double lambda = 1e4L;\n\n // compute scores\n vector> scored;\n scored.reserve(cands.size());\n for(int s: cands){\n if(s > nrem) continue;\n long double avg = 0;\n if(s >= 2) avg = (long double)chainCost(p, s) / (long double)(s - 1);\n long double val = avg + lambda * fabsl((long double)s - target);\n scored.push_back({val, s});\n }\n if(scored.empty()){\n int s = cnt.begin()->first;\n if(s > nrem) s = cnt.rbegin()->first;\n pop_size(s);\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+s);\n totalChain += chainCost(p, s);\n glist.push_back(std::move(gi));\n p += s;\n groupsRem--;\n continue;\n }\n\n sort(scored.begin(), scored.end(), [&](auto &a, auto &b){\n if(a.first != b.first) return a.first < b.first;\n return a.second < b.second;\n });\n\n int bestS = scored[0].second;\n\n // slight stochasticity among top few (deterministic by seed), to escape bad greedy choices\n if(rnd){\n int K = min(3, (int)scored.size());\n // pick among top-K with bias toward best\n uint64_t r = splitmix64(*rnd);\n // weights: [4,2,1] for K=3; [3,1] for K=2; [1] for K=1\n int pick = 0;\n if(K == 3){\n int t = (int)(r % 7);\n pick = (t < 4) ? 0 : (t < 6 ? 1 : 2);\n }else if(K == 2){\n int t = (int)(r % 4);\n pick = (t < 3) ? 0 : 1;\n }else pick = 0;\n bestS = scored[pick].second;\n }\n\n pop_size(bestS);\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+bestS);\n totalChain += chainCost(p, bestS);\n glist.push_back(std::move(gi));\n p += bestS;\n groupsRem--;\n }\n\n return {glist, totalChain};\n}\n\n// Approximate MST cost (sum of d2) for prioritizing which groups deserve more queries\nstatic long long approx_mst_d2_group(const vector& nodes,\n const vector& ex,\n const vector& ey)\n{\n int g = (int)nodes.size();\n if(g <= 1) return 0;\n vector best(g, (1LL<<62));\n vector used(g, 0);\n best[0] = 0;\n long long total = 0;\n for(int it=0; it> N >> M >> Q >> L >> W;\n vector G(M);\n for(int i=0;i> G[i];\n\n vector lx(N), rx(N), ly(N), ry(N);\n for(int i=0;i> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n vector ex(N), ey(N);\n for(int i=0;iint{\n return (int)llround((long double)v * 65535.0L / 10000.0L);\n };\n\n // Build 4 candidate orders\n vector> orders;\n\n // Hilbert(x,y)\n {\n vector key(N);\n for(int i=0;i ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(key[a]!=key[b]) return key[a] key(N);\n for(int i=0;i ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(key[a]!=key[b]) return key[a] ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(ex[a]!=ex[b]) return ex[a] ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(ey[a]!=ey[b]) return ey[a] glist;\n\n const int TRIALS_PER_ORDER = 6;\n for(int oi=0; oi<(int)orders.size(); oi++){\n // One deterministic (no rnd) + some randomized\n {\n auto [tmp, sc] = build_groups_greedy_chainScore(orders[oi], ex, ey, G, nullptr);\n if(sc < bestChain){\n bestChain = sc;\n glist = std::move(tmp);\n }\n }\n for(int t=0;t outIdx(M);\n iota(outIdx.begin(), outIdx.end(), 0);\n sort(outIdx.begin(), outIdx.end(), [&](int a,int b){\n if(G[a]!=G[b]) return G[a] grpIdx(M);\n iota(grpIdx.begin(), grpIdx.end(), 0);\n sort(grpIdx.begin(), grpIdx.end(), [&](int a,int b){\n int sa = (int)glist[a].nodes.size();\n int sb = (int)glist[b].nodes.size();\n if(sa!=sb) return sa groupForOut(M, -1);\n for(int i=0;i& subset)->vector>{\n int l = (int)subset.size();\n cout << \"? \" << l;\n for(int v: subset) cout << \" \" << v;\n cout << \"\\n\" << flush;\n vector> ret;\n ret.reserve(l-1);\n for(int i=0;i> a >> b;\n if(a>b) swap(a,b);\n ret.push_back({a,b});\n }\n return ret;\n };\n\n int usedQ = 0;\n\n // 1) Exact queries for groups of size 3..L\n vector allGroups(M);\n iota(allGroups.begin(), allGroups.end(), 0);\n sort(allGroups.begin(), allGroups.end(), [&](int a, int b){\n int sa = (int)glist[a].nodes.size();\n int sb = (int)glist[b].nodes.size();\n if(sa != sb) return sa < sb;\n return a < b;\n });\n\n for(int gi : allGroups){\n if(usedQ >= Q) break;\n int g = (int)glist[gi].nodes.size();\n if(3 <= g && g <= L){\n auto ret = do_query(glist[gi].nodes);\n glist[gi].exactKnown = true;\n glist[gi].exactEdges = std::move(ret);\n usedQ++;\n }\n }\n\n // 2) Large groups: prioritize by approx MST(d2) and run offsets in rounds\n vector largeGroups;\n vector approxCost(M, 0);\n for(int gi=0; gi L){\n approxCost[gi] = approx_mst_d2_group(glist[gi].nodes, ex, ey);\n largeGroups.push_back(gi);\n }\n }\n sort(largeGroups.begin(), largeGroups.end(), [&](int a,int b){\n if(approxCost[a] != approxCost[b]) return approxCost[a] > approxCost[b];\n return glist[a].nodes.size() > glist[b].nodes.size();\n });\n\n auto do_pass = [&](int gi, int startPos){\n auto &vec = glist[gi].nodes;\n int g = (int)vec.size();\n int step = L - 1;\n for(int pos = startPos; pos < g-1 && usedQ < Q; pos += step){\n int l = min(L, g - pos);\n if(l < 2) break;\n vector subset(vec.begin()+pos, vec.begin()+pos+l);\n auto ret = do_query(subset);\n glist[gi].queryEdges.insert(glist[gi].queryEdges.end(), ret.begin(), ret.end());\n usedQ++;\n }\n };\n\n if(L >= 3){\n int step = L - 1;\n vector offsets;\n offsets.push_back(0);\n offsets.push_back(step/2);\n offsets.push_back(step/3);\n offsets.push_back((2*step)/3);\n // unique, non-negative, < step\n sort(offsets.begin(), offsets.end());\n offsets.erase(unique(offsets.begin(), offsets.end()), offsets.end());\n offsets.erase(remove_if(offsets.begin(), offsets.end(), [&](int x){ return x<=0 || x>=step; }), offsets.end());\n offsets.insert(offsets.begin(), 0);\n\n for(int off : offsets){\n for(int gi : largeGroups){\n if(usedQ >= Q) break;\n do_pass(gi, off);\n }\n if(usedQ >= Q) break;\n }\n }\n\n // Output answer\n cout << \"!\\n\" << flush;\n\n auto add_unique_edge = [&](unordered_set &seen, vector> &edges, int u, int v){\n if(u==v) return;\n if(u>v) swap(u,v);\n int key = u*1024 + v; // N<=800\n if(seen.insert(key).second) edges.push_back({u,v});\n };\n\n for(int outk=0; outkv) swap(u,v);\n cout << u << \" \" << v << \"\\n\";\n continue;\n }\n\n unordered_set seen;\n seen.reserve((size_t)g * 80);\n\n vector> candQuery;\n candQuery.reserve(info.queryEdges.size());\n for(auto &e: info.queryEdges) add_unique_edge(seen, candQuery, e.first, e.second);\n\n vector> candOther;\n candOther.reserve((size_t)g * 80);\n\n // Chain edges\n for(int i=0;i byx = vec, byy = vec;\n sort(byx.begin(), byx.end(), [&](int a,int b){\n if(ex[a]!=ex[b]) return ex[a]> tmp;\n tmp.reserve(g-1);\n for(int jj=0; jj kNN) nth_element(tmp.begin(), tmp.begin()+kNN, tmp.end());\n int take = min(kNN, (int)tmp.size());\n for(int t=0;t lid;\n lid.reserve((size_t)g*2);\n for(int i=0;i all;\n all.reserve(candQuery.size() + candOther.size());\n\n auto pushE = [&](int u,int v,bool isQ){\n all.push_back({u,v, dist2_est(ex[u], ey[u], ex[v], ey[v]), isQ});\n };\n for(auto &e: candQuery) pushE(e.first, e.second, true);\n for(auto &e: candOther) pushE(e.first, e.second, false);\n\n sort(all.begin(), all.end(), [&](const CandE& a, const CandE& b){\n long double wa = (long double)a.d2 * (a.isQuery ? 0.60L : 1.0L);\n long double wb = (long double)b.d2 * (b.isQuery ? 0.60L : 1.0L);\n if(wa != wb) return wa < wb;\n if(a.isQuery != b.isQuery) return a.isQuery > b.isQuery;\n if(a.u != b.u) return a.u < b.u;\n return a.v < b.v;\n });\n\n DSU dsu(g);\n vector> chosen;\n chosen.reserve(g-1);\n\n for(auto &e: all){\n int a = lid[e.u], b = lid[e.v];\n if(dsu.unite(a,b)){\n int u=e.u, v=e.v;\n if(u>v) swap(u,v);\n chosen.push_back({u,v});\n if((int)chosen.size() == g-1) break;\n }\n }\n\n // Fallback: connect remaining components by best estimated edges\n while((int)chosen.size() < g-1){\n for(int i=0;iv) swap(u,v);\n chosen.push_back({u,v});\n }\n\n if((int)chosen.size() != g-1){\n // ultimate star\n chosen.clear();\n int c = vec[0];\n for(int i=1;iv) swap(u,v);\n chosen.push_back({u,v});\n }\n }\n\n for(auto &e: chosen) cout << e.first << \" \" << e.second << \"\\n\";\n }\n\n cout << flush;\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nstatic constexpr int N = 20;\nstatic constexpr int MAXP = N * N;\n\nstruct Pos { int r, c; };\nstatic inline int pid(int r,int c){ return r*N+c; }\nstatic inline bool inside(int r,int c){ return 0<=r && r seq;\n};\n\n// Per-leg BFS with:\n// - fixed permanent blocks (bitset)\n// - local temporary toggles (mask), must end mask=0\nstruct LegBFS {\n int KMAX;\n vector cand;\n array cid{};\n int C=0, MASKS=1, STATES=0;\n\n vector dist;\n vector parent;\n vector pack;\n vector seen;\n int stamp = 1;\n\n vector q;\n\n LegBFS(int kmax): KMAX(kmax) { cid.fill(-1); }\n\n void set_candidates(const vector& cells, const bitset& fixed) {\n cid.fill(-1);\n cand.clear();\n for(int id: cells){\n if(fixed.test(id)) continue;\n if(cid[id] != -1) continue;\n cid[id] = (int)cand.size();\n cand.push_back(id);\n if((int)cand.size() >= KMAX) break;\n }\n C = (int)cand.size();\n MASKS = 1 << C;\n STATES = MAXP * MASKS;\n\n dist.assign(STATES, 0);\n parent.assign(STATES, -1);\n pack.assign(STATES, 0);\n seen.assign(STATES, 0);\n\n q.reserve(STATES/8);\n stamp = 1;\n }\n\n inline bool isBlocked(int cell, int mask, const bitset& fixed) const {\n if(fixed.test(cell)) return true;\n int idx = cid[cell];\n if(idx < 0) return false;\n return (mask >> idx) & 1;\n }\n\n int slide_endpoint(int pos, int dir, int mask,\n const vector& fixedList,\n const bitset& fixed) const {\n int r = pos / N, c = pos % N;\n\n int best = INT_MAX;\n // boundary obstacle distance\n if(dir==0) best = r + 1;\n if(dir==1) best = N - r;\n if(dir==2) best = c + 1;\n if(dir==3) best = N - c;\n\n // fixed blocks\n for(int b: fixedList){\n int br=b/N, bc=b%N;\n int d = INT_MAX;\n if(dir==0){ if(bc==c && brr) d = br-r; }\n if(dir==2){ if(br==r && bcc) d = bc-c; }\n if(d < best) best = d;\n }\n // local blocks\n for(int i=0;i>i)&1){\n int b = cand[i];\n int br=b/N, bc=b%N;\n int d = INT_MAX;\n if(dir==0){ if(bc==c && brr) d = br-r; }\n if(dir==2){ if(br==r && bcc) d = bc-c; }\n if(d < best) best = d;\n }\n\n int step = best - 1;\n int nr = r + dr[dir]*step;\n int nc = c + dc[dir]*step;\n return pid(nr,nc);\n }\n\n BFSPlan solve(Pos s, Pos t,\n const bitset& fixed,\n const vector& fixedList) {\n BFSPlan res;\n auto sid = [&](int pos, int mask){ return pos*MASKS + mask; };\n\n int sPos = pid(s.r,s.c), tPos = pid(t.r,t.c);\n int sState = sid(sPos, 0);\n int gState = sid(tPos, 0);\n\n stamp++;\n if(stamp == INT_MAX){\n // reset (extremely unlikely)\n fill(seen.begin(), seen.end(), 0);\n stamp = 1;\n }\n\n q.clear();\n int head=0;\n seen[sState]=stamp;\n dist[sState]=0;\n parent[sState]=-1;\n q.push_back(sState);\n\n while(head < (int)q.size()){\n int st = q[head++];\n if(st == gState) break;\n\n int pos = st / MASKS;\n int mask = st % MASKS;\n int dcur = dist[st];\n int r = pos / N, c = pos % N;\n\n for(int dir=0; dir<4; dir++){\n // Move\n {\n int nr=r+dr[dir], nc=c+dc[dir];\n if(inside(nr,nc)){\n int np = pid(nr,nc);\n if(!isBlocked(np, mask, fixed)){\n int ns = sid(np, mask);\n if(seen[ns] != stamp){\n seen[ns] = stamp;\n dist[ns] = (int16_t)(dcur+1);\n parent[ns]=st;\n pack[ns]=(uint8_t)((0u<<2)|(unsigned)dir);\n q.push_back(ns);\n }\n }\n }\n }\n // Slide\n {\n int np = slide_endpoint(pos, dir, mask, fixedList, fixed);\n int ns = sid(np, mask);\n if(seen[ns] != stamp){\n seen[ns] = stamp;\n dist[ns] = (int16_t)(dcur+1);\n parent[ns]=st;\n pack[ns]=(uint8_t)((1u<<2)|(unsigned)dir);\n q.push_back(ns);\n }\n }\n // Alter local\n {\n int ar=r+dr[dir], ac=c+dc[dir];\n if(inside(ar,ac)){\n int aid = pid(ar,ac);\n int idx = cid[aid];\n if(idx >= 0){\n int nmask = mask ^ (1< rev;\n int st = gState;\n while(st != sState){\n rev.push_back(pack[st]);\n st = parent[st];\n }\n reverse(rev.begin(), rev.end());\n res.seq = move(rev);\n return res;\n }\n};\n\nstatic vector neigh4_cells(const Pos& p){\n vector v;\n v.reserve(4);\n for(int d=0; d<4; d++){\n int nr=p.r+dr[d], nc=p.c+dc[d];\n if(inside(nr,nc)) v.push_back(pid(nr,nc));\n }\n return v;\n}\n\nstatic vector build_local_candidates(const Pos& cur, const Pos& tgt, const bitset& fixed){\n Pos c1{cur.r, tgt.c};\n Pos c2{tgt.r, cur.c};\n\n vector v;\n v.reserve(16);\n auto add = [&](int id){\n if(fixed.test(id)) return;\n for(int x: v) if(x==id) return;\n v.push_back(id);\n };\n for(int id: neigh4_cells(tgt)) add(id);\n for(int id: neigh4_cells(cur)) add(id);\n for(int id: neigh4_cells(c1)) add(id);\n for(int id: neigh4_cells(c2)) add(id);\n return v;\n}\n\n// Move+Slide-only heuristic under permanent blocks\nstatic int slide_endpoint_fixed(int pos, int dir, const vector& fixedList){\n int r = pos / N, c = pos % N;\n int best = INT_MAX;\n if(dir==0) best = r + 1;\n if(dir==1) best = N - r;\n if(dir==2) best = c + 1;\n if(dir==3) best = N - c;\n for(int b: fixedList){\n int br=b/N, bc=b%N;\n int d = INT_MAX;\n if(dir==0){ if(bc==c && brr) d = br-r; }\n if(dir==2){ if(br==r && bcc) d = bc-c; }\n if(d < best) best = d;\n }\n int step = best - 1;\n return pid(r + dr[dir]*step, c + dc[dir]*step);\n}\n\nstatic int heuristic_ms(Pos s, Pos t, const bitset& fixed, const vector& fixedList){\n int sp=pid(s.r,s.c), tp=pid(t.r,t.c);\n array dist;\n dist.fill((int16_t)-1);\n queue q;\n dist[sp]=0; q.push(sp);\n while(!q.empty()){\n int pos=q.front(); q.pop();\n int dcur=dist[pos];\n if(pos==tp) return dcur;\n int r=pos/N, c=pos%N;\n for(int dir=0; dir<4; dir++){\n // Move\n int nr=r+dr[dir], nc=c+dc[dir];\n if(inside(nr,nc)){\n int np=pid(nr,nc);\n if(!fixed.test(np) && dist[np]==-1){\n dist[np]=dcur+1;\n q.push(np);\n }\n }\n // Slide\n int np = slide_endpoint_fixed(pos, dir, fixedList);\n if(dist[np]==-1){\n dist[np]=dcur+1;\n q.push(np);\n }\n }\n }\n return 999;\n}\n\nstatic uint64_t hash_fixed(const vector& v){\n uint64_t h = 1469598103934665603ULL;\n for(int x: v){\n h ^= (uint64_t)(x + 1);\n h *= 1099511628211ULL;\n }\n return h;\n}\nstatic void fixed_add(vector& lst, int cell){\n auto it = lower_bound(lst.begin(), lst.end(), cell);\n if(it==lst.end() || *it!=cell) lst.insert(it, cell);\n}\nstatic void fixed_remove(vector& lst, int cell){\n auto it = lower_bound(lst.begin(), lst.end(), cell);\n if(it!=lst.end() && *it==cell) lst.erase(it);\n}\n\nstruct Node {\n bitset fixed;\n vector fixedList; // sorted\n int cost = 0;\n int eval = 0;\n vector actions;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, M;\n cin >> n >> M;\n vector pts(M);\n for(int i=0;i> pts[i].r >> pts[i].c;\n\n // forbid permanent blocks on any target to avoid deadlocks/regressions\n bitset isTarget;\n isTarget.reset();\n for(int i=0;i baseline;\n baseline.reserve(1600);\n {\n bitset fixed; fixed.reset();\n vector fixedList;\n Pos cur = pts[0];\n for(int k=1;ktgt.r){ baseline.push_back((0u<<2)|0u); r--; } // U\n while(ctgt.c){ baseline.push_back((0u<<2)|2u); c--; } // L\n }else{\n baseline.insert(baseline.end(), plan.seq.begin(), plan.seq.end());\n }\n cur = tgt;\n }\n }\n\n // Beam\n const int BEAM_W = 45;\n const int BMAX = 7;\n const int BLOCK_PEN = 2;\n const int H2_WEIGHT_DIV = 3; // add h2/3\n\n LegBFS beamSolver(10);\n\n vector beam;\n beam.reserve(BEAM_W);\n {\n Node init;\n init.fixed.reset();\n init.fixedList.clear();\n init.cost = 0;\n init.eval = 0;\n init.actions.clear();\n beam.push_back(move(init));\n }\n\n for(int k=1;k memoH1, memoH2;\n memoH1.reserve(1024); memoH2.reserve(1024);\n\n vector nextBeam;\n nextBeam.reserve(BEAM_W * 20);\n\n unordered_map bestCostForHash;\n bestCostForHash.reserve(2048);\n\n auto getH1 = [&](uint64_t h, const bitset& fixed, const vector& fixedList)->int{\n auto it = memoH1.find(h);\n if(it!=memoH1.end()) return it->second;\n int v = has1 ? heuristic_ms(tgt, t1, fixed, fixedList) : 0;\n memoH1.emplace(h, v);\n return v;\n };\n auto getH2 = [&](uint64_t h, const bitset& fixed, const vector& fixedList)->int{\n auto it = memoH2.find(h);\n if(it!=memoH2.end()) return it->second;\n int v = has2 ? heuristic_ms(t1, t2, fixed, fixedList) : 0;\n memoH2.emplace(h, v);\n return v;\n };\n\n auto consider = [&](Node&& cand){\n uint64_t h = hash_fixed(cand.fixedList);\n auto it = bestCostForHash.find(h);\n if(it != bestCostForHash.end() && it->second <= cand.cost) return;\n bestCostForHash[h] = cand.cost;\n\n int h1 = getH1(h, cand.fixed, cand.fixedList);\n int h2 = getH2(h, cand.fixed, cand.fixedList);\n cand.eval = cand.cost + h1 + (has2 ? h2 / H2_WEIGHT_DIV : 0) + BLOCK_PEN * (int)cand.fixedList.size();\n nextBeam.push_back(move(cand));\n };\n\n for(const Node& nd : beam){\n // plan leg under nd.fixed\n auto cells = build_local_candidates(start, tgt, nd.fixed);\n beamSolver.set_candidates(cells, nd.fixed);\n auto plan = beamSolver.solve(start, tgt, nd.fixed, nd.fixedList);\n if(plan.dist == INT_MAX) continue;\n\n Node reached = nd;\n reached.cost += plan.dist;\n reached.actions.insert(reached.actions.end(), plan.seq.begin(), plan.seq.end());\n\n // option 0\n consider(Node(reached));\n\n // neighbors of tgt allowed for permanent toggle\n vector nbCells;\n vector nbDir;\n for(int d=0; d<4; d++){\n int nr=tgt.r+dr[d], nc=tgt.c+dc[d];\n if(!inside(nr,nc)) continue;\n int nb=pid(nr,nc);\n if(isTarget.test(nb)) continue;\n nbCells.push_back(nb);\n nbDir.push_back(d);\n }\n int L = (int)nbCells.size();\n\n auto apply_toggle = [&](Node& cand, int nb, int dir)->bool{\n // action A at tgt in given dir\n if(cand.fixed.test(nb)){\n cand.fixed.reset(nb);\n fixed_remove(cand.fixedList, nb);\n cand.actions.push_back((2u<<2) | (uint8_t)dir);\n cand.cost += 1;\n return true;\n }else{\n if((int)cand.fixedList.size() >= BMAX) return false;\n cand.fixed.set(nb);\n fixed_add(cand.fixedList, nb);\n cand.actions.push_back((2u<<2) | (uint8_t)dir);\n cand.cost += 1;\n return true;\n }\n };\n\n // toggle one\n for(int i=0;i* best = &baseline;\n if(!beam.empty()){\n const Node* bestNode = &beam[0];\n for(auto &nd: beam) if(nd.cost < bestNode->cost) bestNode = &nd;\n if((int)bestNode->actions.size() <= 2*N*M && (int)bestNode->actions.size() < (int)baseline.size()){\n best = (vector*)&bestNode->actions;\n }\n }\n\n for(uint8_t b : *best){\n int act = (b>>2)&3;\n int dir = b&3;\n cout << actChar(act) << ' ' << dirChar(dir) << \"\\n\";\n }\n return 0;\n}"},"16":{"ahc001":"#include \nusing namespace std;\n\nstatic constexpr int W = 10000;\nstatic constexpr int H = 10000;\n\nstruct Rect {\n int lx, ly, rx, ry; // [lx,rx) x [ly,ry)\n};\n\nstatic inline long long areaLL(const Rect& r) {\n return 1LL * (r.rx - r.lx) * (r.ry - r.ly);\n}\nstatic inline bool overlapPosArea(const Rect& a, const Rect& b) {\n int x0 = max(a.lx, b.lx);\n int x1 = min(a.rx, b.rx);\n if (x0 >= x1) return false;\n int y0 = max(a.ly, b.ly);\n int y1 = min(a.ry, b.ry);\n return y0 < y1;\n}\nstatic inline double sat(long long r, long long s) {\n long long mn = min(r, s);\n long long mx = max(r, s);\n double a = (double)mn / (double)mx;\n double t = 1.0 - a;\n return 1.0 - t * t;\n}\n\n// splitmix64 RNG\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t nextU64() {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n }\n uint32_t nextU32() { return (uint32_t)nextU64(); }\n double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Solver {\n int n;\n vector x, y;\n vector r;\n vector rects;\n vector p;\n RNG rng;\n\n using clk = chrono::high_resolution_clock;\n clk::time_point start;\n\n double elapsedSec() const {\n return chrono::duration(clk::now() - start).count();\n }\n\n bool containsPoint(int i, const Rect& rc) const {\n return (rc.lx <= x[i] && rc.rx >= x[i] + 1 && rc.ly <= y[i] && rc.ry >= y[i] + 1);\n }\n bool inBounds(const Rect& rc) const {\n return (0 <= rc.lx && rc.lx < rc.rx && rc.rx <= W &&\n 0 <= rc.ly && rc.ly < rc.ry && rc.ry <= H);\n }\n bool validNoOverlapOne(int i, const Rect& rc) const {\n if (!inBounds(rc)) return false;\n if (!containsPoint(i, rc)) return false;\n for (int j = 0; j < n; j++) if (j != i) {\n if (overlapPosArea(rc, rects[j])) return false;\n }\n return true;\n }\n bool validNoOverlapTwo(int i, const Rect& ri, int j, const Rect& rj) const {\n if (!inBounds(ri) || !inBounds(rj)) return false;\n if (!containsPoint(i, ri) || !containsPoint(j, rj)) return false;\n if (overlapPosArea(ri, rj)) return false;\n for (int k = 0; k < n; k++) if (k != i && k != j) {\n if (overlapPosArea(ri, rects[k])) return false;\n if (overlapPosArea(rj, rects[k])) return false;\n }\n return true;\n }\n\n // Directional nearest blockers\n int blockerRight(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestL = W + 1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.lx >= a.rx && b.lx < bestL) {\n bestL = b.lx;\n best = j;\n }\n }\n }\n return best;\n }\n int blockerLeft(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestR = -1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.rx <= a.lx && b.rx > bestR) {\n bestR = b.rx;\n best = j;\n }\n }\n }\n return best;\n }\n int blockerUp(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestB = H + 1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ly >= a.ry && b.ly < bestB) {\n bestB = b.ly;\n best = j;\n }\n }\n }\n return best;\n }\n int blockerDown(int i) const {\n const Rect& a = rects[i];\n int best = -1;\n int bestT = -1;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ry <= a.ly && b.ry > bestT) {\n bestT = b.ry;\n best = j;\n }\n }\n }\n return best;\n }\n\n int limitRight(int i) const {\n const Rect& a = rects[i];\n int lim = W;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.lx >= a.rx) lim = min(lim, b.lx);\n }\n }\n return lim;\n }\n int limitLeft(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.ly, b.ly) < min(a.ry, b.ry)) {\n if (b.rx <= a.lx) lim = max(lim, b.rx);\n }\n }\n return lim;\n }\n int limitUp(int i) const {\n const Rect& a = rects[i];\n int lim = H;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ly >= a.ry) lim = min(lim, b.ly);\n }\n }\n return lim;\n }\n int limitDown(int i) const {\n const Rect& a = rects[i];\n int lim = 0;\n for (int j = 0; j < n; j++) if (j != i) {\n const Rect& b = rects[j];\n if (max(a.lx, b.lx) < min(a.rx, b.rx)) {\n if (b.ry <= a.ly) lim = max(lim, b.ry);\n }\n }\n return lim;\n }\n\n void init() {\n rects.resize(n);\n p.assign(n, 0.0);\n for (int i = 0; i < n; i++) {\n rects[i] = Rect{x[i], y[i], x[i] + 1, y[i] + 1};\n p[i] = sat(r[i], 1);\n }\n }\n\n void greedyExpand(int rounds = 7) {\n vector ord(n);\n iota(ord.begin(), ord.end(), 0);\n\n for (int rep = 0; rep < rounds; rep++) {\n shuffle(ord.begin(), ord.end(), std::mt19937((unsigned)rng.nextU32()));\n for (int idx = 0; idx < n; idx++) {\n int i = ord[idx];\n for (;;) {\n Rect cur = rects[i];\n long long s0 = areaLL(cur);\n if (s0 >= r[i]) break;\n\n double bestGain = 1e-18;\n Rect bestR = cur;\n\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n\n // Right\n {\n int lim = limitRight(i);\n if (lim > cur.rx) {\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.lx + (int)needW;\n vector cands = {cur.rx + 1, ideal - 1, ideal, ideal + 1, lim};\n for (int rx2 : cands) {\n rx2 = max(rx2, cur.rx + 1);\n rx2 = min(rx2, lim);\n if (rx2 <= cur.rx) continue;\n Rect cand = cur; cand.rx = rx2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n // Left\n {\n int lim = limitLeft(i);\n if (lim < cur.lx) {\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.rx - (int)needW;\n vector cands = {cur.lx - 1, ideal - 1, ideal, ideal + 1, lim};\n for (int lx2 : cands) {\n lx2 = min(lx2, cur.lx - 1);\n lx2 = max(lx2, lim);\n lx2 = min(lx2, x[i]);\n if (lx2 >= cur.lx) continue;\n Rect cand = cur; cand.lx = lx2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n // Up\n {\n int lim = limitUp(i);\n if (lim > cur.ry) {\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ly + (int)needH;\n vector cands = {cur.ry + 1, ideal - 1, ideal, ideal + 1, lim};\n for (int ry2 : cands) {\n ry2 = max(ry2, cur.ry + 1);\n ry2 = min(ry2, lim);\n if (ry2 <= cur.ry) continue;\n Rect cand = cur; cand.ry = ry2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n // Down\n {\n int lim = limitDown(i);\n if (lim < cur.ly) {\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ry - (int)needH;\n vector cands = {cur.ly - 1, ideal - 1, ideal, ideal + 1, lim};\n for (int ly2 : cands) {\n ly2 = min(ly2, cur.ly - 1);\n ly2 = max(ly2, lim);\n ly2 = min(ly2, y[i]);\n if (ly2 >= cur.ly) continue;\n Rect cand = cur; cand.ly = ly2;\n long long s1 = areaLL(cand);\n double g = sat(r[i], s1) - sat(r[i], s0);\n if (g > bestGain) { bestGain = g; bestR = cand; }\n }\n }\n }\n\n if (bestGain <= 1e-18) break;\n rects[i] = bestR;\n p[i] = sat(r[i], areaLL(bestR));\n }\n }\n }\n }\n\n // shrink-only overshoot fixer (safe)\n Rect fitInsideShrink(int i, const Rect& cur) const {\n int w0 = cur.rx - cur.lx;\n int h0 = cur.ry - cur.ly;\n long long ri = r[i];\n\n auto place1D = [&](int L, int R, int pos, int len)->pair{\n int minL = L;\n int maxL = R - len;\n int l = pos - (len - 1) / 2;\n l = max(minL, min(maxL, l));\n int rr = l + len;\n if (!(l <= pos && pos + 1 <= rr)) {\n l = max(minL, min(maxL, pos + 1 - len));\n rr = l + len;\n }\n return {l, rr};\n };\n\n Rect best = cur;\n double bestP = sat(ri, areaLL(cur));\n\n vector Ws, Hs;\n auto add = [&](vector& v, int val, int cap){\n val = max(1, min(val, cap));\n v.push_back(val);\n };\n int sq = (int)floor(sqrt((double)ri));\n add(Ws, sq, w0); add(Ws, sq+1, w0); add(Ws, w0, w0);\n add(Hs, sq, h0); add(Hs, sq+1, h0); add(Hs, h0, h0);\n\n add(Ws, (int)max(1LL, (ri + h0 - 1) / h0), w0);\n add(Hs, (int)max(1LL, (ri + w0 - 1) / w0), h0);\n\n sort(Ws.begin(), Ws.end());\n Ws.erase(unique(Ws.begin(), Ws.end()), Ws.end());\n sort(Hs.begin(), Hs.end());\n Hs.erase(unique(Hs.begin(), Hs.end()), Hs.end());\n\n for (int w : Ws) {\n int h = (int)max(1LL, min(h0, (ri + w - 1) / w));\n for (int dh : {0, -1, +1}) {\n int hh = h + dh;\n if (hh < 1 || hh > h0) continue;\n auto [lx, rx] = place1D(cur.lx, cur.rx, x[i], w);\n auto [ly, ry] = place1D(cur.ly, cur.ry, y[i], hh);\n Rect cand{lx, ly, rx, ry};\n double pp = sat(ri, areaLL(cand));\n if (pp > bestP + 1e-15) { bestP = pp; best = cand; }\n }\n }\n for (int h : Hs) {\n int w = (int)max(1LL, min(w0, (ri + h - 1) / h));\n for (int dw : {0, -1, +1}) {\n int ww = w + dw;\n if (ww < 1 || ww > w0) continue;\n auto [lx, rx] = place1D(cur.lx, cur.rx, x[i], ww);\n auto [ly, ry] = place1D(cur.ly, cur.ry, y[i], h);\n Rect cand{lx, ly, rx, ry};\n double pp = sat(ri, areaLL(cand));\n if (pp > bestP + 1e-15) { bestP = pp; best = cand; }\n }\n }\n return best;\n }\n\n int pickIndexTournament() {\n auto badness = [&](int i)->double{\n long long s = areaLL(rects[i]);\n double err = (double)llabs(s - r[i]) / (double)r[i];\n return (1.0 - p[i]) + 0.20 * err;\n };\n int best = rng.nextInt(0, n - 1);\n double bb = badness(best);\n for (int t = 0; t < 4; t++) {\n int j = rng.nextInt(0, n - 1);\n double bj = badness(j);\n if (bj > bb) { bb = bj; best = j; }\n }\n return best;\n }\n\n // New move: expand i while shrinking its nearest blocking neighbor j.\n bool tryStealMove(int i, Rect& outRi, int& outJ, Rect& outRj) {\n outRi = rects[i];\n outJ = -1;\n outRj = Rect{0,0,0,0};\n\n if (areaLL(rects[i]) >= r[i]) return false; // mostly use for deficit\n\n int dir = rng.nextInt(0, 3); // 0:R 1:L 2:U 3:D\n if (dir == 0) {\n int j = blockerRight(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // max delta constrained by b's left moving right while still containing its point\n int maxDelta = min(b.rx - b.lx - 1, x[j] - b.lx);\n if (maxDelta <= 0) return false;\n\n // also can expand into current gap for free; delta can exceed gap because we shrink b\n int h = a.ry - a.ly;\n long long needW = (r[i] + h - 1) / h;\n int want = max(1, (int)needW - (a.rx - a.lx));\n int d = min(maxDelta, max(1, want));\n // small randomness\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.rx += d;\n nb.lx += d;\n if (!containsPoint(j, nb)) return false;\n // ensure still ordered\n if (na.rx > nb.lx) na.rx = nb.lx;\n if (na.rx <= na.lx) return false;\n if (nb.lx >= nb.rx) return false;\n\n // Validate strictly to be safe\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n\n outRi = na; outJ = j; outRj = nb;\n return true;\n } else if (dir == 1) {\n int j = blockerLeft(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // shrink b from right (move rx left)\n int maxDelta = min(b.rx - b.lx - 1, b.rx - (x[j] + 1));\n if (maxDelta <= 0) return false;\n\n int h = a.ry - a.ly;\n long long needW = (r[i] + h - 1) / h;\n int want = max(1, (int)needW - (a.rx - a.lx));\n int d = min(maxDelta, max(1, want));\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.lx -= d;\n nb.rx -= d;\n if (!containsPoint(j, nb)) return false;\n if (nb.rx > na.lx) na.lx = nb.rx;\n if (na.lx >= na.rx) return false;\n if (nb.lx >= nb.rx) return false;\n\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n outRi = na; outJ = j; outRj = nb;\n return true;\n } else if (dir == 2) {\n int j = blockerUp(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // shrink b from bottom (move ly up)\n int maxDelta = min(b.ry - b.ly - 1, y[j] - b.ly);\n if (maxDelta <= 0) return false;\n\n int w = a.rx - a.lx;\n long long needH = (r[i] + w - 1) / w;\n int want = max(1, (int)needH - (a.ry - a.ly));\n int d = min(maxDelta, max(1, want));\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.ry += d;\n nb.ly += d;\n if (!containsPoint(j, nb)) return false;\n if (na.ry > nb.ly) na.ry = nb.ly;\n if (na.ry <= na.ly) return false;\n if (nb.ly >= nb.ry) return false;\n\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n outRi = na; outJ = j; outRj = nb;\n return true;\n } else {\n int j = blockerDown(i);\n if (j < 0) return false;\n const Rect& a = rects[i];\n const Rect& b = rects[j];\n // shrink b from top (move ry down)\n int maxDelta = min(b.ry - b.ly - 1, b.ry - (y[j] + 1));\n if (maxDelta <= 0) return false;\n\n int w = a.rx - a.lx;\n long long needH = (r[i] + w - 1) / w;\n int want = max(1, (int)needH - (a.ry - a.ly));\n int d = min(maxDelta, max(1, want));\n if (rng.nextDouble() < 0.35) d = rng.nextInt(1, maxDelta);\n\n Rect na = a; Rect nb = b;\n na.ly -= d;\n nb.ry -= d;\n if (!containsPoint(j, nb)) return false;\n if (nb.ry > na.ly) na.ly = nb.ry;\n if (na.ly >= na.ry) return false;\n if (nb.ly >= nb.ry) return false;\n\n if (!validNoOverlapTwo(i, na, j, nb)) return false;\n outRi = na; outJ = j; outRj = nb;\n return true;\n }\n }\n\n void anneal(double endTimeSec) {\n const double T0 = 0.06;\n const double T1 = 0.0016;\n\n while (elapsedSec() < endTimeSec) {\n double prog = elapsedSec() / endTimeSec;\n double temp = T0 * pow(T1 / T0, prog);\n\n int i = pickIndexTournament();\n Rect cur = rects[i];\n long long s0 = areaLL(cur);\n double p0 = p[i];\n\n double op = rng.nextDouble();\n\n if (op < 0.16) {\n // NEW: steal space from nearest blocker\n Rect ni, njr;\n int j;\n if (!tryStealMove(i, ni, j, njr)) continue;\n\n double pi1 = sat(r[i], areaLL(ni));\n double pj1 = sat(r[j], areaLL(njr));\n double delta = (pi1 + pj1) - (p[i] + p[j]);\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.nextDouble() < exp(delta / temp)) accept = true;\n\n if (accept) {\n rects[i] = ni; p[i] = pi1;\n rects[j] = njr; p[j] = pj1;\n }\n continue;\n }\n\n Rect cand = cur;\n\n if (op < 0.76) {\n // Resize one side (expand/shrink)\n int side = (int)(rng.nextU32() % 4); // 0:L 1:R 2:D 3:U\n int w = cur.rx - cur.lx;\n int h = cur.ry - cur.ly;\n\n bool wantExpand = (s0 < r[i]) ? (rng.nextDouble() < 0.85) : (rng.nextDouble() < 0.18);\n\n if (wantExpand) {\n if (side == 1) { // right\n int lim = limitRight(i);\n if (lim <= cur.rx) continue;\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.lx + (int)needW;\n vector cands = {cur.rx + 1, ideal - 1, ideal, ideal + 1, lim};\n int rx2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n rx2 = max(rx2, cur.rx + 1);\n rx2 = min(rx2, lim);\n cand.rx = rx2;\n } else if (side == 0) { // left\n int lim = limitLeft(i);\n if (lim >= cur.lx) continue;\n long long needW = (r[i] + h - 1) / h;\n int ideal = cur.rx - (int)needW;\n vector cands = {cur.lx - 1, ideal - 1, ideal, ideal + 1, lim};\n int lx2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n lx2 = min(lx2, cur.lx - 1);\n lx2 = max(lx2, lim);\n lx2 = min(lx2, x[i]);\n cand.lx = lx2;\n } else if (side == 3) { // up\n int lim = limitUp(i);\n if (lim <= cur.ry) continue;\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ly + (int)needH;\n vector cands = {cur.ry + 1, ideal - 1, ideal, ideal + 1, lim};\n int ry2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n ry2 = max(ry2, cur.ry + 1);\n ry2 = min(ry2, lim);\n cand.ry = ry2;\n } else { // down\n int lim = limitDown(i);\n if (lim >= cur.ly) continue;\n long long needH = (r[i] + w - 1) / w;\n int ideal = cur.ry - (int)needH;\n vector cands = {cur.ly - 1, ideal - 1, ideal, ideal + 1, lim};\n int ly2 = cands[rng.nextInt(0, (int)cands.size() - 1)];\n ly2 = min(ly2, cur.ly - 1);\n ly2 = max(ly2, lim);\n ly2 = min(ly2, y[i]);\n cand.ly = ly2;\n }\n } else {\n // shrink (always overlap-safe)\n if (side == 1) { // right shrink\n int minRx = x[i] + 1;\n int maxRx = cur.rx - 1;\n if (minRx > maxRx) continue;\n cand.rx = rng.nextInt(minRx, maxRx);\n } else if (side == 0) { // left shrink\n int minLx = cur.lx + 1;\n int maxLx = x[i];\n if (minLx > maxLx) continue;\n cand.lx = rng.nextInt(minLx, maxLx);\n } else if (side == 3) { // up shrink\n int minRy = y[i] + 1;\n int maxRy = cur.ry - 1;\n if (minRy > maxRy) continue;\n cand.ry = rng.nextInt(minRy, maxRy);\n } else { // down shrink\n int minLy = cur.ly + 1;\n int maxLy = y[i];\n if (minLy > maxLy) continue;\n cand.ly = rng.nextInt(minLy, maxLy);\n }\n }\n if (!inBounds(cand) || !containsPoint(i, cand)) continue;\n // expansions done by limits are safe; shrink safe. Still, for safety, validate occasionally:\n if (rng.nextDouble() < 0.03) {\n if (!validNoOverlapOne(i, cand)) continue;\n }\n } else if (op < 0.86) {\n // shrink-only fit\n Rect shr = fitInsideShrink(i, cur);\n if (shr.lx == cur.lx && shr.ly == cur.ly && shr.rx == cur.rx && shr.ry == cur.ry) continue;\n cand = shr;\n } else {\n // shift (needs overlap check)\n bool horizontal = (rng.nextDouble() < 0.5);\n if (horizontal) {\n int kmin = max(-cur.lx, (x[i] + 1) - cur.rx);\n int kmax = min(W - cur.rx, x[i] - cur.lx);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int lim = 320;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n int k;\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n cand.lx += k; cand.rx += k;\n } else {\n int kmin = max(-cur.ly, (y[i] + 1) - cur.ry);\n int kmax = min(H - cur.ry, y[i] - cur.ly);\n if (kmin > kmax || (kmin == 0 && kmax == 0)) continue;\n int lim = 320;\n int lo = max(kmin, -lim);\n int hi = min(kmax, lim);\n if (lo > hi) { lo = kmin; hi = kmax; }\n int k;\n do { k = rng.nextInt(lo, hi); } while (k == 0 && (lo < 0 || hi > 0));\n if (k == 0) continue;\n cand.ly += k; cand.ry += k;\n }\n if (!validNoOverlapOne(i, cand)) continue;\n }\n\n long long s1 = areaLL(cand);\n double p1 = sat(r[i], s1);\n double delta = p1 - p0;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.nextDouble() < exp(delta / temp)) accept = true;\n\n if (accept) {\n rects[i] = cand;\n p[i] = p1;\n }\n }\n }\n\n void finalTighten(int passes = 2) {\n for (int it = 0; it < passes; it++) {\n bool improved = false;\n for (int i = 0; i < n; i++) {\n Rect cur = rects[i];\n Rect cand = fitInsideShrink(i, cur);\n if (cand.lx == cur.lx && cand.ly == cur.ly && cand.rx == cur.rx && cand.ry == cur.ry) continue;\n double p1 = sat(r[i], areaLL(cand));\n if (p1 > p[i] + 1e-15) {\n rects[i] = cand;\n p[i] = p1;\n improved = true;\n }\n }\n if (!improved) break;\n }\n }\n\n void solve() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n start = clk::now();\n\n cin >> n;\n x.resize(n); y.resize(n); r.resize(n);\n for (int i = 0; i < n; i++) cin >> x[i] >> y[i] >> r[i];\n\n init();\n\n // Robust baseline\n greedyExpand(7);\n\n // SA with new \"steal\" move to fix boxed-in cases\n anneal(4.75);\n\n // After redistribution, expand again a little to fill freed space\n greedyExpand(2);\n\n // Safe overshoot tightening\n finalTighten(2);\n\n for (int i = 0; i < n; i++) {\n const Rect& rc = rects[i];\n cout << rc.lx << ' ' << rc.ly << ' ' << rc.rx << ' ' << rc.ry << \"\\n\";\n }\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nstatic const int N = 50;\nstatic const int V = N * N;\n\nstatic const int di[4] = {-1, 1, 0, 0};\nstatic const int dj[4] = {0, 0, -1, 1};\nstatic const char dc[4] = {'U','D','L','R'};\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n explicit XorShift(uint64_t seed = 0) { x ^= seed + 0x9e3779b97f4a7c15ULL; }\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Path {\n vector moves;\n long long score = 0;\n};\n\nint si, sj;\nint tgrid[N][N];\nint pgrid[N][N];\nint Mtiles = 0;\n\ninline bool inside(int i, int j) { return (unsigned)i < N && (unsigned)j < N; }\ninline int vid(int i, int j) { return i * N + j; }\n\nint tileOf[V];\nint valOf[V];\n\nstruct Neis {\n int to[4];\n int deg = 0;\n};\nNeis nei[V];\n\n// stamping used tiles\nvector usedStamp;\nint curStamp = 1;\ninline bool isUsedTile(int tile) { return usedStamp[tile] == curStamp; }\ninline void markTile(int tile) { usedStamp[tile] = curStamp; }\n\n// helpers\ninline int mobility1(int v, int extra1 = -1) {\n int tv = tileOf[v];\n int cnt = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1) continue;\n if (isUsedTile(tu)) continue;\n cnt++;\n }\n return cnt;\n}\ninline int mobility2(int v, int extra1, int extra2) {\n int tv = tileOf[v];\n int cnt = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1 || tu == extra2) continue;\n if (isUsedTile(tu)) continue;\n cnt++;\n }\n return cnt;\n}\ninline int bestNextValue(int v, int extra1 = -1) {\n int tv = tileOf[v];\n int best = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extra1) continue;\n if (isUsedTile(tu)) continue;\n best = max(best, valOf[u]);\n }\n return best;\n}\ninline int bestSecondStep(int v, int extraFirstTile) {\n int tv = tileOf[v];\n int best = 0;\n const auto &ng = nei[v];\n for (int k = 0; k < ng.deg; k++) {\n int u = ng.to[k];\n int tu = tileOf[u];\n if (tu == tv) continue;\n if (tu == extraFirstTile) continue;\n if (isUsedTile(tu)) continue;\n int mob = mobility2(u, extraFirstTile, tu);\n int v2 = valOf[u] + 14 * mob;\n best = max(best, v2);\n }\n return best;\n}\n\ninline int dirFromTo(int a, int b) {\n int ai = a / N, aj = a % N;\n int bi = b / N, bj = b % N;\n if (bi == ai - 1 && bj == aj) return 0;\n if (bi == ai + 1 && bj == aj) return 1;\n if (bi == ai && bj == aj - 1) return 2;\n return 3;\n}\n\n// rollout from startV with rollback; returns valueSum + stepBonus*stepsTaken\nlong long rolloutGain(int startV, XorShift &rng, int depth, double epsRoll, int stepBonus) {\n int cur = startV;\n long long valueSum = 0;\n int steps = 0;\n\n int added[60];\n int asz = 0;\n\n for (int step = 0; step < depth; step++) {\n int ct = tileOf[cur];\n\n int candV[4];\n double H[4];\n int csz = 0;\n\n const auto &ng = nei[cur];\n for (int k = 0; k < ng.deg; k++) {\n int nxt = ng.to[k];\n int nt = tileOf[nxt];\n if (nt == ct) continue;\n if (isUsedTile(nt)) continue;\n\n int mob = mobility1(nxt, nt);\n // cheap policy to drive rollout; still prefers mobility\n double h = (double)valOf[nxt] + 18.0 * (double)mob + 0.25 * (double)bestNextValue(nxt, nt);\n candV[csz] = nxt;\n H[csz] = h;\n csz++;\n }\n if (csz == 0) break;\n\n int pick = 0;\n if (rng.nextDouble() < epsRoll) {\n pick = rng.nextInt(0, csz - 1);\n } else {\n for (int i = 1; i < csz; i++) if (H[i] > H[pick]) pick = i;\n }\n\n int nxt = candV[pick];\n int nt = tileOf[nxt];\n markTile(nt);\n added[asz++] = nt;\n\n cur = nxt;\n valueSum += valOf[cur];\n steps++;\n\n if (asz >= 60) break;\n }\n\n for (int i = 0; i < asz; i++) usedStamp[added[i]] = 0;\n return valueSum + 1LL * stepBonus * steps;\n}\n\nstruct BuildParams {\n // selection\n double epsMain = 0.18; // probability to use stochastic choice (softmax)\n double randTemp = 18.0;\n\n // rollout scheduling\n int depthEarly = 13, depthLate = 9;\n int triesEarly = 7, triesLate = 4;\n int earlySteps = 800;\n\n // rollout internals\n double epsRoll = 0.20;\n double Wroll = 0.50; // slightly reduced because rollout now includes step-bonus\n\n // rollout triggers\n int rolloutBudget = 470;\n int closeCallThr = 40;\n int closeTopK = 4;\n\n // step bonus (encourage long future paths explicitly)\n int stepBonusEarly = 48;\n int stepBonusLate = 44;\n};\n\nPath buildFromPrefix(const vector& prefix, int cutLen, XorShift &rng, const BuildParams &par) {\n curStamp++;\n if (curStamp == INT_MAX) {\n fill(usedStamp.begin(), usedStamp.end(), 0);\n curStamp = 1;\n }\n\n int cur = vid(si, sj);\n long long score = valOf[cur];\n markTile(tileOf[cur]);\n\n Path res;\n res.moves.reserve(2600);\n\n // replay prefix safely\n for (int k = 0; k < cutLen; k++) {\n char c = prefix[k];\n int d = (c=='U'?0:(c=='D'?1:(c=='L'?2:3)));\n int ni = (cur / N) + di[d];\n int nj = (cur % N) + dj[d];\n if (!inside(ni,nj)) break;\n int nxt = vid(ni,nj);\n int ct = tileOf[cur], nt = tileOf[nxt];\n if (nt == ct) break;\n if (isUsedTile(nt)) break;\n markTile(nt);\n cur = nxt;\n score += valOf[cur];\n res.moves.push_back(c);\n }\n\n // base heuristic weights\n const int Wmob = 24;\n const double Wbest1 = 0.45;\n const double Wbest2 = 0.65;\n const int deadPenalty = 95;\n\n int rolloutUsed = 0;\n\n auto curRollParams = [&]() -> tuple {\n int step = (int)res.moves.size();\n if (step < par.earlySteps) return {par.depthEarly, par.triesEarly, par.stepBonusEarly};\n return {par.depthLate, par.triesLate, par.stepBonusLate};\n };\n\n while (true) {\n int candV[4], candT[4], candMob[4];\n double baseH[4], H[4];\n int csz = 0;\n\n int ct = tileOf[cur];\n const auto &ng = nei[cur];\n\n double bestBase = -1e100;\n for (int k = 0; k < ng.deg; k++) {\n int nxt = ng.to[k];\n int nt = tileOf[nxt];\n if (nt == ct) continue;\n if (isUsedTile(nt)) continue;\n\n int mob1 = mobility1(nxt, nt);\n int b1 = bestNextValue(nxt, nt);\n int b2 = bestSecondStep(nxt, nt);\n\n double h = (double)valOf[nxt]\n + (double)Wmob * (double)mob1\n + Wbest1 * (double)b1\n + Wbest2 * (double)b2;\n if (mob1 == 0) h -= deadPenalty;\n\n candV[csz] = nxt;\n candT[csz] = nt;\n candMob[csz] = mob1;\n baseH[csz] = h;\n bestBase = max(bestBase, h);\n csz++;\n }\n if (csz == 0) break;\n\n for (int i = 0; i < csz; i++) H[i] = baseH[i];\n\n int ord[4] = {0,1,2,3};\n sort(ord, ord + csz, [&](int a, int b){ return baseH[a] > baseH[b]; });\n\n auto do_roll = [&](int idx, int depth, int tries, int stepBonus) {\n int nxt = candV[idx];\n int nt = candT[idx];\n\n markTile(nt);\n long long bestG = 0;\n for (int r = 0; r < tries; r++) {\n bestG = max(bestG, rolloutGain(nxt, rng, depth, par.epsRoll, stepBonus));\n }\n usedStamp[nt] = 0;\n H[idx] += par.Wroll * (double)bestG;\n };\n\n // Mandatory rollouts for risky moves\n for (int i = 0; i < csz; i++) {\n if (candMob[i] <= 2 && rolloutUsed < par.rolloutBudget) {\n rolloutUsed++;\n auto [depth, tries, bonus] = curRollParams();\n do_roll(i, depth, tries, bonus);\n }\n }\n\n // Close-call rollouts among top-K candidates (lightweight)\n int topK = min(par.closeTopK, csz);\n for (int r = 0; r < topK && rolloutUsed < par.rolloutBudget; r++) {\n int i = ord[r];\n if (candMob[i] <= 2) continue;\n if (bestBase - baseH[i] > par.closeCallThr) continue;\n\n rolloutUsed++;\n auto [depth, tries, bonus] = curRollParams();\n depth = max(7, depth - 4);\n tries = max(3, tries - 3);\n // still use step bonus (important for branch choice)\n do_roll(i, depth, tries, bonus);\n }\n\n // Choose move: greedy or softmax\n int pick = 0;\n if (rng.nextDouble() < par.epsMain) {\n double mx = H[0];\n for (int i = 1; i < csz; i++) mx = max(mx, H[i]);\n double sum = 0.0;\n double w[4];\n double temp = max(1e-6, par.randTemp);\n for (int i = 0; i < csz; i++) {\n double e = exp((H[i] - mx) / temp);\n w[i] = e;\n sum += e;\n }\n double r = rng.nextDouble() * sum;\n pick = csz - 1;\n for (int i = 0; i < csz; i++) {\n r -= w[i];\n if (r <= 0) { pick = i; break; }\n }\n } else {\n for (int i = 1; i < csz; i++) if (H[i] > H[pick]) pick = i;\n }\n\n int nxt = candV[pick];\n int d = dirFromTo(cur, nxt);\n\n markTile(tileOf[nxt]);\n cur = nxt;\n score += valOf[cur];\n res.moves.push_back(dc[d]);\n\n if ((int)res.moves.size() >= 2600) break;\n }\n\n res.score = score;\n return res;\n}\n\nstruct Archive {\n int K;\n vector a; // sorted desc\n explicit Archive(int K_=7): K(K_) {}\n void add(Path &&p) {\n a.push_back(std::move(p));\n sort(a.begin(), a.end(), [](const Path& x, const Path& y){ return x.score > y.score; });\n if ((int)a.size() > K) a.resize(K);\n }\n const Path& best() const { return a.front(); }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> si >> sj;\n int mxT = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n cin >> tgrid[i][j];\n mxT = max(mxT, tgrid[i][j]);\n }\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> pgrid[i][j];\n Mtiles = mxT + 1;\n\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v = vid(i,j);\n tileOf[v] = tgrid[i][j];\n valOf[v] = pgrid[i][j];\n }\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v = vid(i,j);\n nei[v].deg = 0;\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d], nj = j + dj[d];\n if (!inside(ni,nj)) continue;\n nei[v].to[nei[v].deg++] = vid(ni,nj);\n }\n }\n\n usedStamp.assign(Mtiles, 0);\n XorShift rng(1234567);\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n };\n const double TL = 1.95;\n\n Archive arch(7);\n\n // Initial multi-start\n while (elapsed() < TL * 0.40) {\n BuildParams par;\n if (rng.nextDouble() < 0.40) { par.epsMain = 0.06; par.randTemp = 10.0; }\n else { par.epsMain = 0.22; par.randTemp = 20.0; }\n\n auto cand = buildFromPrefix({}, 0, rng, par);\n arch.add(std::move(cand));\n }\n\n // Improvement loop\n while (elapsed() < TL) {\n double prog = min(1.0, elapsed() / TL);\n\n const Path* base = nullptr;\n double r = rng.nextDouble();\n if (r < 0.05) base = nullptr;\n else if (r < 0.15 && (int)arch.a.size() >= 2) base = &arch.a[rng.nextInt(0, (int)arch.a.size() - 1)];\n else base = &arch.best();\n\n int cutLen = 0;\n vector empty;\n const vector *pref = ∅\n\n if (base) {\n pref = &base->moves;\n int L = (int)pref->size();\n if (L > 0) {\n // adaptive tail: larger early to change macro route, smaller later to refine\n int tailMax = (prog < 0.5 ? 360 : 240);\n int tail = min(L, tailMax);\n if (rng.nextDouble() < 0.82) {\n int back = rng.nextInt(0, tail);\n cutLen = L - back;\n } else {\n cutLen = rng.nextInt(0, L);\n }\n }\n }\n\n BuildParams par;\n par.epsMain = 0.18 * (1.0 - prog) + 0.02;\n par.randTemp = 18.0 * (1.0 - prog) + 10.0;\n par.rolloutBudget = (prog < 0.65 ? 480 : 380);\n\n int TRIES = (prog < 0.6 ? 6 : 4);\n Path bestCand; bestCand.score = -1;\n for (int k = 0; k < TRIES; k++) {\n auto cand = buildFromPrefix(*pref, cutLen, rng, par);\n if (cand.score > bestCand.score) bestCand = std::move(cand);\n }\n arch.add(std::move(bestCand));\n }\n\n const Path &best = arch.best();\n string out;\n out.reserve(best.moves.size());\n for (char c : best.moves) out.push_back(c);\n cout << out << \"\\n\";\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nstatic constexpr int N = 30;\nstatic constexpr int V = N * N;\n\nstatic inline int vid(int i, int j) { return i * N + j; }\nstatic inline pair vpos(int id){ return {id / N, id % N}; }\n\nstruct EdgeRef {\n bool horiz; // true: h[i][j] between (i,j)-(i,j+1), false: v[i][j] between (i,j)-(i+1,j)\n int i, j;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n static double h[N][N-1], v[N-1][N];\n static int hc[N][N-1], vc[N-1][N];\n\n for(int i=0;i unif01(0.0, 1.0);\n\n auto clamp_w = [](double x)->double{\n if (x < 100.0) return 100.0;\n if (x > 10000.0) return 10000.0;\n return x;\n };\n\n // Count-weighted smoothing (low-risk improvement)\n auto add_smoothing_weighted = [&](double beta){\n // Horizontal per row\n for(int i=0;i 0 ? s / sw : 5000.0);\n for(int j=0;j 0 ? s / sw : 5000.0);\n for(int i=0;i> si >> sj >> ti >> tj)) return 0;\n int s = vid(si, sj), t = vid(ti, tj);\n\n // Exploration schedule: strong early only (this matched your best run)\n double eps = 0.0;\n if (k < 250) {\n double x = 1.0 - (double)k / 250.0;\n eps = 0.30 * x;\n }\n\n auto perturbed = [&](double base)->double{\n if (eps <= 0.0) return base;\n double r = (unif01(rng) * 2.0 - 1.0) * eps;\n double w = base * (1.0 + r);\n if (w < 1.0) w = 1.0;\n return w;\n };\n\n const double INF = 1e100;\n for(int i=0;i;\n priority_queue, greater

> pq;\n dist[s] = 0.0;\n pq.push({0.0, s});\n\n auto relax = [&](int from, int to, char mv, double w){\n double nd = dist[from] + w;\n if (nd < dist[to]) {\n dist[to] = nd;\n prevv[to] = from;\n prevMove[to] = mv;\n pq.push({nd, to});\n }\n };\n\n while(!pq.empty()){\n auto [d,u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n if (u == t) break;\n auto [i,j] = vpos(u);\n\n if (i > 0) relax(u, vid(i-1,j), 'U', perturbed(v[i-1][j]));\n if (i+1 < N) relax(u, vid(i+1,j), 'D', perturbed(v[i][j]));\n if (j > 0) relax(u, vid(i,j-1), 'L', perturbed(h[i][j-1]));\n if (j+1 < N) relax(u, vid(i,j+1), 'R', perturbed(h[i][j]));\n }\n\n // Reconstruct path + used edges\n string path;\n vector used_edges;\n\n if (prevv[t] == -1 && s != t) {\n // Fallback Manhattan (shouldn't happen)\n int ci=si, cj=sj;\n while (ci < ti) { path.push_back('D'); ci++; }\n while (ci > ti) { path.push_back('U'); ci--; }\n while (cj < tj) { path.push_back('R'); cj++; }\n while (cj > tj) { path.push_back('L'); cj--; }\n\n ci=si; cj=sj;\n for(char c: path){\n int ni=ci, nj=cj;\n if (c=='U') ni--;\n if (c=='D') ni++;\n if (c=='L') nj--;\n if (c=='R') nj++;\n if (ci == ni) used_edges.push_back({true, ci, min(cj,nj)});\n else used_edges.push_back({false, min(ci,ni), cj});\n ci=ni; cj=nj;\n }\n } else {\n int cur = t;\n vector rev;\n vector> nodes;\n nodes.push_back(vpos(cur));\n while(cur != s){\n rev.push_back(prevMove[cur]);\n cur = prevv[cur];\n nodes.push_back(vpos(cur));\n }\n reverse(rev.begin(), rev.end());\n path.assign(rev.begin(), rev.end());\n\n reverse(nodes.begin(), nodes.end()); // s -> t\n for (int idx = 0; idx+1 < (int)nodes.size(); idx++){\n auto [i1,j1] = nodes[idx];\n auto [i2,j2] = nodes[idx+1];\n if (i1 == i2) used_edges.push_back({true, i1, min(j1,j2)});\n else used_edges.push_back({false, min(i1,i2), j1});\n }\n }\n\n cout << path << \"\\n\" << flush;\n\n long long obs;\n cin >> obs;\n\n // Multiplicative update\n double pred = 0.0;\n for (auto &e: used_edges){\n pred += e.horiz ? h[e.i][e.j] : v[e.i][e.j];\n }\n pred = max(pred, 1.0);\n\n double ratio = (double)obs / pred;\n ratio = max(0.2, min(5.0, ratio));\n double logr = log(ratio);\n\n // Mild LR schedule\n double base_lr = 0.45;\n if (k < 120) base_lr = 0.55;\n else if (k >= 600) base_lr = 0.35;\n\n for (auto &e: used_edges){\n int cnt;\n double *wptr;\n if (e.horiz) { cnt = ++hc[e.i][e.j]; wptr = &h[e.i][e.j]; }\n else { cnt = ++vc[e.i][e.j]; wptr = &v[e.i][e.j]; }\n\n double lr = base_lr / sqrt((double)cnt + 2.0);\n *wptr = clamp_w((*wptr) * exp(lr * logr));\n }\n\n // Periodic smoothing\n if ((k+1) % 25 == 0) {\n double beta = 0.10;\n if (k >= 300) beta = 0.06;\n if (k >= 700) beta = 0.04;\n add_smoothing_weighted(beta);\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20;\nstatic const int LMIN = 2;\nstatic const int LMAX = 12;\nstatic const int ALPHA = 9; // A-H + '.'\n\nstruct XorShift64 {\n uint64_t x;\n explicit XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n inline uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n inline int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n inline double next_double() {\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstatic inline uint8_t ch2code(char ch) { return ch == '.' ? 8 : (uint8_t)(ch - 'A'); }\nstatic inline char code2ch(uint8_t c) { return c == 8 ? '.' : (char)('A' + c); }\n\nusing u128 = unsigned __int128;\n\nstruct LineHash {\n array dig{};\n array pref{};\n const array* pow9 = nullptr;\n\n void rebuild_pref() {\n pref[0] = 0;\n for (int i = 0; i < 2 * N; i++) pref[i + 1] = pref[i] * (u128)ALPHA + (u128)dig[i];\n }\n inline uint64_t substr_val_exact(int start, int len) const {\n u128 v = pref[start + len] - pref[start] * (*pow9)[len];\n return (uint64_t)v; // len<=12 fits in u64\n }\n};\n\nstruct Delta {\n int dBase = 0;\n int dLen = 0;\n int dBonus = 0;\n long long dPair = 0;\n};\n\nstruct Solver {\n int M;\n vector inputS;\n\n int U;\n vector weight, slen;\n vector> sdig;\n unordered_map key2id;\n\n array pow9{};\n\n array, N> grid{};\n array rows, cols;\n\n vector>> affected;\n\n vector occ;\n long long baseSat = 0;\n long long lenSat = 0;\n long long occBonus = 0;\n\n // pair guidance\n long long wPair[ALPHA][ALPHA]{};\n long long totalPairs = 0;\n long long pairScore = 0;\n double pairScale = 1.0;\n\n XorShift64 rng;\n\n Solver(int M_, vector s_)\n : M(M_), inputS(std::move(s_)),\n rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count()) {\n\n pow9[0] = 1;\n for (int i = 1; i <= LMAX; i++) pow9[i] = pow9[i - 1] * (u128)ALPHA;\n for (int i = 0; i < N; i++) { rows[i].pow9 = &pow9; cols[i].pow9 = &pow9; }\n\n // bigram counts from reads (A..H only)\n for (const string &t : inputS) {\n for (int i = 0; i + 1 < (int)t.size(); i++) {\n uint8_t a = ch2code(t[i]);\n uint8_t b = ch2code(t[i+1]);\n wPair[a][b] += 1;\n totalPairs += 1;\n }\n }\n // typical dPair magnitude for 4 directed edges is about totalPairs/16\n pairScale = (double)totalPairs / 16.0 + 1.0;\n\n auto encode_key_exact = [&](const string& t) -> uint64_t {\n uint64_t v = 0;\n for (char ch : t) v = v * (uint64_t)ALPHA + (uint64_t)ch2code(ch); // A..H only\n return v * 16ull + (uint64_t)t.size();\n };\n\n key2id.reserve((size_t)M * 2);\n for (int i = 0; i < M; i++) {\n uint64_t key = encode_key_exact(inputS[i]);\n auto it = key2id.find(key);\n if (it == key2id.end()) {\n int id = (int)weight.size();\n key2id.emplace(key, id);\n weight.push_back(1);\n slen.push_back((int)inputS[i].size());\n vector d;\n d.reserve(inputS[i].size());\n for (char ch : inputS[i]) d.push_back(ch2code(ch));\n sdig.push_back(std::move(d));\n } else {\n weight[it->second]++;\n }\n }\n U = (int)weight.size();\n occ.assign(U, 0);\n\n affected.assign(N, {});\n for (int pos = 0; pos < N; pos++) {\n vector> v;\n v.reserve(77);\n for (int len = LMIN; len <= LMAX; len++) {\n for (int t = 0; t < len; t++) {\n int start = pos - t;\n start %= N;\n if (start < 0) start += N;\n v.emplace_back(start, len);\n }\n }\n affected[pos] = move(v);\n }\n }\n\n inline uint64_t make_key(uint64_t val, int len) const { return val * 16ull + (uint64_t)len; }\n inline int bonus_of(int x) const { return x >= 2 ? 2 : x; }\n\n inline void rebuild_all_lines_from_grid() {\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n rows[r].dig[c] = grid[r][c];\n rows[r].dig[c + N] = grid[r][c];\n }\n rows[r].rebuild_pref();\n }\n for (int c = 0; c < N; c++) {\n for (int r = 0; r < N; r++) {\n cols[c].dig[r] = grid[r][c];\n cols[c].dig[r + N] = grid[r][c];\n }\n cols[c].rebuild_pref();\n }\n }\n\n void recount_all_slow() {\n fill(occ.begin(), occ.end(), 0);\n baseSat = lenSat = occBonus = 0;\n\n auto add_key = [&](uint64_t key) {\n auto it = key2id.find(key);\n if (it == key2id.end()) return;\n int id = it->second;\n if (occ[id] == 0) {\n baseSat += weight[id];\n lenSat += slen[id];\n }\n occ[id]++;\n };\n\n for (int r = 0; r < N; r++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = rows[r].substr_val_exact(start, len);\n add_key(make_key(v, len));\n }\n }\n }\n for (int c = 0; c < N; c++) {\n for (int len = LMIN; len <= LMAX; len++) {\n for (int start = 0; start < N; start++) {\n uint64_t v = cols[c].substr_val_exact(start, len);\n add_key(make_key(v, len));\n }\n }\n }\n for (int id = 0; id < U; id++) occBonus += bonus_of(occ[id]);\n\n // pairScore for right+down directed edges\n pairScore = 0;\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) {\n uint8_t a = grid[r][c];\n uint8_t b = grid[r][(c+1)%N];\n uint8_t d = grid[(r+1)%N][c];\n pairScore += wPair[a][b];\n pairScore += wPair[a][d];\n }\n }\n\n inline void adjust_occ(int id, int delta, Delta &D) {\n int before = occ[id];\n int after = before + delta;\n occ[id] = after;\n\n if (before == 0 && after > 0) {\n baseSat += weight[id]; D.dBase += weight[id];\n lenSat += slen[id]; D.dLen += slen[id];\n } else if (before > 0 && after == 0) {\n baseSat -= weight[id]; D.dBase -= weight[id];\n lenSat -= slen[id]; D.dLen -= slen[id];\n }\n\n int b0 = bonus_of(before), b1 = bonus_of(after);\n occBonus += (b1 - b0);\n D.dBonus += (b1 - b0);\n }\n\n inline void update_key_change(uint64_t oldKey, uint64_t newKey, Delta &D) {\n if (oldKey == newKey) return;\n auto itOld = key2id.find(oldKey);\n if (itOld != key2id.end()) adjust_occ(itOld->second, -1, D);\n auto itNew = key2id.find(newKey);\n if (itNew != key2id.end()) adjust_occ(itNew->second, +1, D);\n }\n\n inline void update_pair_delta_cell(int r, int c, uint8_t oldv, uint8_t newv, Delta &D) {\n int lc = (c - 1 + N) % N, rc = (c + 1) % N;\n int ur = (r - 1 + N) % N, dr = (r + 1) % N;\n uint8_t L = grid[r][lc];\n uint8_t R = grid[r][rc];\n uint8_t Uc = grid[ur][c];\n uint8_t Dn = grid[dr][c];\n\n long long delta = 0;\n delta += wPair[L][newv] - wPair[L][oldv];\n delta += wPair[newv][R] - wPair[oldv][R];\n delta += wPair[Uc][newv] - wPair[Uc][oldv];\n delta += wPair[newv][Dn] - wPair[oldv][Dn];\n\n pairScore += delta;\n D.dPair += delta;\n }\n\n Delta doChange(int r, int c, uint8_t newv) {\n uint8_t oldv = grid[r][c];\n if (oldv == newv) return {};\n\n Delta D;\n\n // pair delta uses neighbors from current grid\n update_pair_delta_cell(r, c, oldv, newv, D);\n\n // row affected\n const auto &affRow = affected[c];\n array oldKeysRow;\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first, len = affRow[i].second;\n oldKeysRow[i] = make_key(rows[r].substr_val_exact(start, len), len);\n }\n rows[r].dig[c] = newv;\n rows[r].dig[c + N] = newv;\n rows[r].rebuild_pref();\n for (int i = 0; i < (int)affRow.size(); i++) {\n int start = affRow[i].first, len = affRow[i].second;\n uint64_t newKey = make_key(rows[r].substr_val_exact(start, len), len);\n update_key_change(oldKeysRow[i], newKey, D);\n }\n\n // col affected\n const auto &affCol = affected[r];\n array oldKeysCol;\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first, len = affCol[i].second;\n oldKeysCol[i] = make_key(cols[c].substr_val_exact(start, len), len);\n }\n cols[c].dig[r] = newv;\n cols[c].dig[r + N] = newv;\n cols[c].rebuild_pref();\n for (int i = 0; i < (int)affCol.size(); i++) {\n int start = affCol[i].first, len = affCol[i].second;\n uint64_t newKey = make_key(cols[c].substr_val_exact(start, len), len);\n update_key_change(oldKeysCol[i], newKey, D);\n }\n\n grid[r][c] = newv;\n return D;\n }\n\n inline double evalDeltaF(const Delta &D, double lambda, double beta, double gamma) const {\n // gamma already normalized by pairScale\n return (double)D.dBase + lambda * (double)D.dLen + beta * (double)D.dBonus + gamma * (double)D.dPair;\n }\n\n int pick_unsatisfied_id() {\n for (int t = 0; t < 60; t++) {\n int id = rng.next_int(U);\n if (occ[id] == 0) return id;\n }\n for (int id = 0; id < U; id++) if (occ[id] == 0) return id;\n return -1;\n }\n\n struct ChangeRec { int r, c; uint8_t oldv; };\n\n pair> apply_embed_move(int id, int orient, int idx, int start) {\n Delta total;\n vector rec;\n rec.reserve(slen[id]);\n\n for (int t = 0; t < slen[id]; t++) {\n int r = (orient == 0) ? idx : (start + t) % N;\n int c = (orient == 0) ? (start + t) % N : idx;\n uint8_t nv = sdig[id][t];\n uint8_t ov = grid[r][c];\n if (ov == nv) continue;\n rec.push_back({r, c, ov});\n Delta d = doChange(r, c, nv);\n total.dBase += d.dBase;\n total.dLen += d.dLen;\n total.dBonus+= d.dBonus;\n total.dPair += d.dPair;\n }\n return {total, rec};\n }\n\n void revert_changes(const vector &rec) {\n for (int i = (int)rec.size() - 1; i >= 0; i--) doChange(rec[i].r, rec[i].c, rec[i].oldv);\n }\n\n tuple best_embed_placement(int id) {\n int bestMis = 1e9;\n int bestOrient = 0, bestIdx = 0, bestStart = 0;\n int L = slen[id];\n\n for (int orient = 0; orient < 2; orient++) {\n for (int idx = 0; idx < N; idx++) {\n for (int start = 0; start < N; start++) {\n int mis = 0;\n for (int t = 0; t < L; t++) {\n int r = (orient == 0) ? idx : (start + t) % N;\n int c = (orient == 0) ? (start + t) % N : idx;\n mis += (grid[r][c] != sdig[id][t]);\n if (mis >= bestMis) break;\n }\n if (mis < bestMis) {\n bestMis = mis;\n bestOrient = orient;\n bestIdx = idx;\n bestStart = start;\n if (bestMis == 0) return {bestMis, bestOrient, bestIdx, bestStart};\n }\n }\n }\n }\n return {bestMis, bestOrient, bestIdx, bestStart};\n }\n\n pair> apply_shift_move(int orient, int idx, int k) {\n array newvals;\n if (orient == 0) {\n for (int c = 0; c < N; c++) newvals[(c + k) % N] = grid[idx][c];\n } else {\n for (int r = 0; r < N; r++) newvals[(r + k) % N] = grid[r][idx];\n }\n\n Delta total;\n vector rec;\n rec.reserve(N);\n\n for (int t = 0; t < N; t++) {\n int r = (orient == 0) ? idx : t;\n int c = (orient == 0) ? t : idx;\n uint8_t nv = newvals[t];\n uint8_t ov = grid[r][c];\n if (ov == nv) continue;\n rec.push_back({r, c, ov});\n Delta d = doChange(r, c, nv);\n total.dBase += d.dBase;\n total.dLen += d.dLen;\n total.dBonus+= d.dBonus;\n total.dPair += d.dPair;\n }\n return {total, rec};\n }\n\n // swap two cells (r1,c1) and (r2,c2) via two changes; record revert info\n pair> apply_swap_move(int r1, int c1, int r2, int c2) {\n uint8_t a = grid[r1][c1], b = grid[r2][c2];\n if (a == b) return {Delta{}, {}};\n\n vector rec;\n rec.reserve(2);\n Delta total;\n\n rec.push_back({r1, c1, a});\n Delta d1 = doChange(r1, c1, b);\n total.dBase += d1.dBase; total.dLen += d1.dLen; total.dBonus += d1.dBonus; total.dPair += d1.dPair;\n\n rec.push_back({r2, c2, b});\n Delta d2 = doChange(r2, c2, a);\n total.dBase += d2.dBase; total.dLen += d2.dLen; total.dBonus += d2.dBonus; total.dPair += d2.dPair;\n\n return {total, rec};\n }\n\n array, N> run_sa(double duration_sec, long long &outBestBase) {\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) grid[r][c] = (uint8_t)rng.next_int(8);\n\n rebuild_all_lines_from_grid();\n recount_all_slow();\n\n auto bestGrid = grid;\n long long bestBase = baseSat;\n long long bestLen = lenSat;\n long long bestBonus= occBonus;\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n };\n\n const double Tstart = 6.0;\n const double Tend = 0.18;\n\n const double lambda0 = 0.08; // keep from best (3.30e9) version\n const double beta = 0.01;\n\n // Pair guidance: gentle, normalized, only early\n const double gamma0_raw = 1.0; // will be divided by pairScale\n\n while (true) {\n double e = elapsed();\n if (e >= duration_sec) break;\n double p = e / duration_sec;\n\n double T = Tstart * pow(Tend / Tstart, p);\n double lambda = lambda0 * (1.0 - p);\n\n // use pair guidance only in first 40%\n double gamma = 0.0;\n if (p < 0.40) {\n double q = (0.40 - p) / 0.40; // 1 -> 0\n gamma = (gamma0_raw * q) / pairScale;\n }\n\n // move probabilities (slightly less disruptive late)\n double pShift = 0.03 * (1.0 - p) + 0.004;\n double pEmbed = 0.22 * (1.0 - p) + 0.03;\n double pSwap = 0.03;\n\n double rm = rng.next_double();\n\n if (rm < pShift) {\n int orient = rng.next_int(2);\n int idx = rng.next_int(N);\n int k = 1 + rng.next_int(N - 1);\n\n auto [D, rec] = apply_shift_move(orient, idx, k);\n double dF = evalDeltaF(D, lambda, beta, gamma);\n bool accept = (dF >= 0) || (rng.next_double() < exp(dF / T));\n if (!accept) revert_changes(rec);\n }\n else if (rm < pShift + pEmbed) {\n int id = pick_unsatisfied_id();\n if (id == -1) continue;\n\n auto [mis, orient, idx, start] = best_embed_placement(id);\n auto [D, rec] = apply_embed_move(id, orient, idx, start);\n\n double dF = evalDeltaF(D, lambda, beta, gamma);\n bool accept = (dF >= 0) || (rng.next_double() < exp(dF / T));\n if (!accept) revert_changes(rec);\n }\n else if (rm < pShift + pEmbed + pSwap) {\n int r1 = rng.next_int(N), c1 = rng.next_int(N);\n int r2 = rng.next_int(N), c2 = rng.next_int(N);\n if (r1 == r2 && c1 == c2) continue;\n\n auto [D, rec] = apply_swap_move(r1, c1, r2, c2);\n if (rec.empty()) continue;\n double dF = evalDeltaF(D, lambda, beta, gamma);\n bool accept = (dF >= 0) || (rng.next_double() < exp(dF / T));\n if (!accept) revert_changes(rec);\n }\n else {\n int r = rng.next_int(N);\n int c = rng.next_int(N);\n uint8_t oldv = grid[r][c];\n uint8_t newv = (uint8_t)rng.next_int(8);\n if (newv == oldv) continue;\n\n Delta D = doChange(r, c, newv);\n double dF = evalDeltaF(D, lambda, beta, gamma);\n bool accept = (dF >= 0) || (rng.next_double() < exp(dF / T));\n if (!accept) doChange(r, c, oldv);\n }\n\n // Best is judged primarily by baseSat (actual score), then lenSat, then occBonus\n if (baseSat > bestBase ||\n (baseSat == bestBase && (lenSat > bestLen ||\n (lenSat == bestLen && occBonus > bestBonus)))) {\n bestBase = baseSat;\n bestLen = lenSat;\n bestBonus = occBonus;\n bestGrid = grid;\n }\n }\n\n outBestBase = bestBase;\n return bestGrid;\n }\n\n void dot_removal(double time_limit_sec, chrono::high_resolution_clock::time_point globalStart) {\n auto elapsed_global = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - globalStart).count();\n };\n if (baseSat != M) return;\n\n vector cells(N*N);\n iota(cells.begin(), cells.end(), 0);\n\n for (int rd = 0; rd < 10; rd++) {\n if (elapsed_global() >= time_limit_sec) break;\n for (int i = (int)cells.size() - 1; i > 0; i--) {\n int j = rng.next_int(i + 1);\n swap(cells[i], cells[j]);\n }\n for (int idx : cells) {\n if (elapsed_global() >= time_limit_sec) break;\n int r = idx / N, c = idx % N;\n uint8_t oldv = grid[r][c];\n if (oldv == 8) continue;\n doChange(r, c, 8);\n if (baseSat != M) doChange(r, c, oldv);\n }\n }\n }\n\n array, N> solve() {\n auto globalStart = chrono::high_resolution_clock::now();\n const double TL = 2.95;\n\n // The 3.30e9 version did well with 2 restarts; keep 2 but allow a bit more SA time.\n const int RESTARTS = 2;\n const double SA_TIME = 2.75;\n const double per = SA_TIME / RESTARTS;\n\n array, N> bestGrid{};\n long long bestBase = -1;\n\n for (int t = 0; t < RESTARTS; t++) {\n long long localBest = 0;\n auto g = run_sa(per, localBest);\n if (localBest > bestBase) {\n bestBase = localBest;\n bestGrid = g;\n if (bestBase == M) break;\n }\n double eg = chrono::duration(chrono::high_resolution_clock::now() - globalStart).count();\n if (eg >= TL - 0.20) break;\n }\n\n grid = bestGrid;\n rebuild_all_lines_from_grid();\n recount_all_slow();\n dot_removal(TL, globalStart);\n\n return grid;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, M;\n cin >> Nin >> M;\n vector s(M);\n for (int i = 0; i < M; i++) cin >> s[i];\n\n Solver solver(M, std::move(s));\n auto ans = solver.solve();\n\n for (int r = 0; r < N; r++) {\n string line;\n line.reserve(N);\n for (int c = 0; c < N; c++) line.push_back(code2ch(ans[r][c]));\n cout << line << \"\\n\";\n }\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstatic const int INF = 1e9;\nstatic const long long INFLL = (1LL<<60);\n\nstruct HopcroftKarp {\n int nL, nR;\n vector> adj;\n vector dist;\n vector pairU, pairV;\n\n HopcroftKarp(int nL=0,int nR=0){ init(nL,nR); }\n void init(int _nL,int _nR){\n nL=_nL; nR=_nR;\n adj.assign(nL,{});\n dist.assign(nL,0);\n pairU.assign(nL,-1);\n pairV.assign(nR,-1);\n }\n\n bool bfs(){\n queue q;\n for(int u=0;u, vector> min_vertex_cover() const {\n vector visL(nL,0), visR(nR,0);\n queue q;\n for(int u=0;u coverL(nL,0), coverR(nR,0);\n for(int u=0;u> G;\n vector level, it;\n Dinic(int n=0){ init(n); }\n void init(int n){\n N=n;\n G.assign(N,{});\n level.assign(N,0);\n it.assign(N,0);\n }\n void add_edge(int fr,int to,long long cap){\n Edge a{to,(int)G[to].size(),cap};\n Edge b{fr,(int)G[fr].size(),0};\n G[fr].push_back(a);\n G[to].push_back(b);\n }\n bool bfs(int s,int t){\n fill(level.begin(), level.end(), -1);\n queue q;\n level[s]=0; q.push(s);\n while(!q.empty()){\n int v=q.front(); q.pop();\n for(const auto& e: G[v]){\n if(e.cap>0 && level[e.to]<0){\n level[e.to]=level[v]+1;\n q.push(e.to);\n }\n }\n }\n return level[t]>=0;\n }\n long long dfs(int v,int t,long long f){\n if(v==t) return f;\n for(int &i=it[v]; i<(int)G[v].size(); i++){\n Edge &e=G[v][i];\n if(e.cap<=0 || level[e.to]!=level[v]+1) continue;\n long long ret=dfs(e.to,t,min(f,e.cap));\n if(ret>0){\n e.cap-=ret;\n G[e.to][e.rev].cap+=ret;\n return ret;\n }\n }\n return 0;\n }\n long long maxflow(int s,int t){\n long long flow=0;\n while(bfs(s,t)){\n fill(it.begin(), it.end(), 0);\n while(true){\n long long f=dfs(s,t,INFLL);\n if(!f) break;\n flow+=f;\n }\n }\n return flow;\n }\n vector reachable_from_s(int s){\n vector vis(N,0);\n queue q;\n vis[s]=1; q.push(s);\n while(!q.empty()){\n int v=q.front(); q.pop();\n for(const auto& e: G[v]){\n if(e.cap>0 && !vis[e.to]){\n vis[e.to]=1;\n q.push(e.to);\n }\n }\n }\n return vis;\n }\n};\n\nstruct DijkstraFull {\n vector dist;\n vector prev;\n vector prevDir;\n};\n\nstruct TargetsInfo {\n vector cells;\n vector needRow, needCol;\n};\n\nstruct Candidate {\n long long quickDirCost = INFLL;\n TargetsInfo tinfo;\n vector nodes;\n uint32_t seed = 0;\n};\n\nstruct FinalSol {\n long long dirCost = INFLL;\n vector nodes;\n vector tour;\n vector> prevM;\n vector> prevDirM;\n};\n\nstruct Solver {\n int N, si, sj;\n vector g;\n int startId;\n vector cellCost;\n\n vector rowSeg, colSeg;\n int R=0, C=0;\n vector> rowCells, colCells;\n vector> adjV, adjCell;\n\n vector> to4;\n vector> dir4;\n vector deg;\n\n inline int id(int i,int j) const { return i*N+j; }\n inline int ri(int v) const { return v/N; }\n inline int rj(int v) const { return v%N; }\n inline bool isRoad(int v) const { return g[ri(v)][rj(v)]!='#'; }\n\n void build_moves(){\n int V=N*N;\n to4.assign(V, array{-1,-1,-1,-1});\n dir4.assign(V, array{'U','D','L','R'});\n deg.assign(V,0);\n static const int di[4]={-1,1,0,0};\n static const int dj[4]={0,0,-1,1};\n static const char mv[4]={'U','D','L','R'};\n for(int u=0;u=N||vj<0||vj>=N) continue;\n int v=id(vi,vj);\n if(!isRoad(v)) continue;\n to4[u][d]=v;\n dir4[u][d]=mv[k];\n d++;\n }\n deg[u]=d;\n }\n }\n\n vector dijkstra_dist_only(int src, const vector* isTarget=nullptr, int targetCount=0) const {\n int V=N*N;\n vector dist(V, INF);\n priority_queue, vector>, greater>> pq;\n dist[src]=0;\n pq.push({0,src});\n int rem=targetCount;\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=dist[u]) continue;\n if(isTarget && (*isTarget)[u]){\n rem--;\n if(rem<=0) break;\n }\n for(int t=0;t, vector>, greater>> pq;\n res.dist[src]=0;\n pq.push({0,src});\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=res.dist[u]) continue;\n for(int t=0;t& prev,const vector& prevDir) const {\n if(src==dst) return \"\";\n string rev;\n int cur=dst;\n while(cur!=src){\n int p=prev[cur];\n if(p==-1) return \"\";\n rev.push_back(prevDir[cur]);\n cur=p;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n }\n\n void build_segments(){\n int V=N*N;\n rowSeg.assign(V,-1);\n colSeg.assign(V,-1);\n R=0;\n for(int i=0;i, vector> min_weight_vertex_cover(const vector& wL, const vector& wR) {\n int S=0;\n int baseL=1;\n int baseR=baseL+R;\n int T=baseR+C;\n Dinic din(T+1);\n\n long long sumW=0;\n for(long long x: wL) sumW += x;\n for(long long x: wR) sumW += x;\n long long INF_CAP = sumW + 1;\n\n for(int u=0;u coverL(R,0), coverR(C,0);\n for(int u=0;u& coverL_in, const vector& coverR_in,\n const vector& distStart, uint32_t seed) {\n mt19937 rng(seed);\n vector needL=coverL_in, needR=coverR_in;\n\n int sRow=rowSeg[startId], sCol=colSeg[startId];\n if(sRow>=0) needL[sRow]=0;\n if(sCol>=0) needR[sCol]=0;\n\n vector reqL, reqR;\n vector mapL(R,-1), mapR(C,-1);\n for(int u=0;u> edgeCell(nL);\n\n for(int i=0;i ord(adjV[u].size());\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng);\n for(int idx: ord){\n int v=adjV[u][idx];\n int j=mapR[v];\n if(j==-1) continue;\n hk.adj[i].push_back(j);\n edgeCell[i].push_back(adjCell[u][idx]);\n }\n }\n hk.max_matching();\n\n vector doneL(R,0), doneR(C,0);\n vector picked(N*N,0);\n vector targets;\n\n auto pick_cell=[&](int cell){\n if(cell<0) return;\n if(!picked[cell]){\n picked[cell]=1;\n targets.push_back(cell);\n }\n };\n\n for(int i=0;i>& vec, int K)->int{\n if(vec.empty()) return -1;\n int kk=min(K,(int)vec.size());\n nth_element(vec.begin(), vec.begin()+kk, vec.end());\n vec.resize(kk);\n sort(vec.begin(), vec.end());\n int choose = uniform_int_distribution(0, min(kk-1,2))(rng);\n return vec[choose].second;\n };\n\n auto best_cell_for_row = [&](int u)->int{\n vector> cand;\n cand.reserve(rowCells[u].size());\n for(int cell: rowCells[u]){\n int v=colSeg[cell];\n long long key = (long long)distStart[cell] + cellCost[cell];\n if(needR[v] && !doneR[v]) key -= 1000000;\n key += (rng()%13);\n cand.push_back({key, cell});\n }\n return pick_top(cand, 8);\n };\n auto best_cell_for_col = [&](int v)->int{\n vector> cand;\n cand.reserve(colCells[v].size());\n for(int cell: colCells[v]){\n int u=rowSeg[cell];\n long long key = (long long)distStart[cell] + cellCost[cell];\n if(needL[u] && !doneL[u]) key -= 1000000;\n key += (rng()%13);\n cand.push_back({key, cell});\n }\n return pick_top(cand, 8);\n };\n\n for(int u=0;u cntL(R,0), cntR(C,0);\n for(int cell: targets){\n int u=rowSeg[cell], v=colSeg[cell];\n if(needL[u]) cntL[u]++;\n if(needR[v]) cntR[v]++;\n }\n vector order=targets;\n shuffle(order.begin(), order.end(), rng);\n vector removed(N*N,0);\n for(int cell: order){\n int u=rowSeg[cell], v=colSeg[cell];\n bool okU = (!needL[u]) || (cntL[u] >= 2);\n bool okV = (!needR[v]) || (cntR[v] >= 2);\n if(okU && okV){\n removed[cell]=1;\n if(needL[u]) cntL[u]--;\n if(needR[v]) cntR[v]--;\n }\n }\n vector pruned;\n for(int cell: targets) if(!removed[cell]) pruned.push_back(cell);\n\n TargetsInfo info;\n info.cells = std::move(pruned);\n info.needRow = std::move(needL);\n info.needCol = std::move(needR);\n return info;\n }\n\n vector> compute_distM_only(const vector& nodes) const {\n int M=(int)nodes.size();\n vector> distM(M, vector(M, INF));\n vector isTarget(N*N,0);\n for(int v: nodes) isTarget[v]=1;\n for(int s=0;s& nodes,\n vector>& distM,\n vector>& distAll,\n vector>& prevM,\n vector>& prevDirM) const {\n int M=(int)nodes.size();\n int V=N*N;\n distM.assign(M, vector(M, INF));\n distAll.assign(M, vector(V, INF));\n prevM.assign(M, vector(V, -1));\n prevDirM.assign(M, vector(V, 0));\n for(int s=0;s> build_W(const vector>& distM, const vector& nodes) const {\n int M=(int)nodes.size();\n vector> W(M, vector(M,0));\n for(int i=0;i& tour, const vector>& distM) const {\n int m=(int)tour.size();\n long long s=0;\n for(int i=0;i& tour, const vector>& W) const {\n int m=(int)tour.size();\n long long s=0;\n for(int i=0;i> build_candidates(const vector>& W, int K) const {\n int M=(int)W.size();\n vector> cand(M);\n for(int i=0;i> tmp;\n tmp.reserve(M-1);\n for(int j=0;j& tour, vector& pos,\n const vector>& W,\n const vector>& candList) const {\n int M=(int)tour.size();\n for(int i=1;ijj) swap(ii,jj);\n if(jj-ii<1) continue;\n int x=tour[ii-1], y=tour[ii];\n int u=tour[jj], v=tour[(jj+1)%M];\n long long delta = (long long)W[x][u] + W[y][v] - W[x][y] - W[u][v];\n if(delta < 0){\n reverse(tour.begin()+ii, tour.begin()+jj+1);\n for(int k=ii;k<=jj;k++) pos[tour[k]]=k;\n return true;\n }\n }\n }\n return false;\n }\n\n void double_bridge(vector& tour, vector& pos, mt19937& rng) const {\n int M=(int)tour.size();\n if(M<10) return;\n uniform_int_distribution dist(1, M-1);\n int a=dist(rng), b=dist(rng), c=dist(rng), d=dist(rng);\n vector cuts={a,b,c,d};\n sort(cuts.begin(), cuts.end());\n a=cuts[0]; b=cuts[1]; c=cuts[2]; d=cuts[3];\n if(a<2 || b-a<2 || c-b<2 || d-c<2) return;\n\n vector nt; nt.reserve(M);\n nt.push_back(tour[0]);\n auto app=[&](int l,int r){ for(int i=l;i<=r;i++) nt.push_back(tour[i]); };\n app(1, a-1);\n app(b, c-1);\n app(a, b-1);\n app(c, d-1);\n app(d, M-1);\n tour.swap(nt);\n for(int i=0;i build_initial_cycle_cheapest_insertion(const vector>& W, mt19937& rng) const {\n int M=(int)W.size();\n vector tour; tour.reserve(M);\n tour.push_back(0);\n vector rem;\n for(int i=1;i optimize_cycle_ILS_2opt(vector tour, const vector>& W, double timeLimitSec, mt19937& rng) const {\n auto t0=chrono::high_resolution_clock::now();\n auto elapsed=[&](){ return chrono::duration(chrono::high_resolution_clock::now()-t0).count(); };\n\n int M=(int)tour.size();\n vector pos(M,-1);\n for(int i=0;i bestTour=tour;\n\n int it=0;\n while(elapsed()& nodes,\n const vector& tour,\n vector>& distM,\n vector>& distAll,\n vector>& prevM,\n vector>& prevDirM,\n const vector& needRow,\n const vector& needCol,\n double timeLimitSec,\n mt19937& rng) const {\n int M=(int)nodes.size();\n int V=N*N;\n if(M<=2) return;\n\n vector usedCell(V,0);\n for(int i=0;i cntRseg(R,0), cntCseg(C,0);\n for(int i=1;i posInTour(M,-1);\n for(int i=0;i<(int)tour.size();i++) posInTour[tour[i]]=i;\n uniform_int_distribution pickNode(1, M-1);\n\n auto t0=chrono::high_resolution_clock::now();\n auto elapsed=[&](){ return chrono::duration(chrono::high_resolution_clock::now()-t0).count(); };\n\n while(elapsed()long long{\n long long h = man(nodes[p], candCell) + man(candCell, nodes[n]);\n return h*10 + cellCost[candCell]*3;\n };\n\n int bestCand=-1;\n long long bestHeu=scoreHeu(curCell);\n\n {\n bool colLocked = needCol[curCS] && (cntCseg[curCS]==1);\n for(int candCell: rowCells[curRS]){\n if(candCell==curCell) continue;\n if(usedCell[candCell]) continue;\n int candCS=colSeg[candCell];\n if(colLocked && candCS!=curCS) continue;\n long long h=scoreHeu(candCell);\n if(h=INF/2) continue;\n if(newCost>=oldCost) continue;\n\n int newRS=rowSeg[bestCand], newCS=colSeg[bestCand];\n if(newRS!=curRS && needRow[curRS] && cntRseg[curRS]==1) continue;\n if(newCS!=curCS && needCol[curCS] && cntCseg[curCS]==1) continue;\n\n usedCell[curCell]=0;\n usedCell[bestCand]=1;\n\n if(needRow[curRS]) cntRseg[curRS]--;\n if(needCol[curCS]) cntCseg[curCS]--;\n if(needRow[newRS]) cntRseg[newRS]++;\n if(needCol[newCS]) cntCseg[newCS]++;\n\n nodes[x]=bestCand;\n\n distAll[x] = std::move(candRes.dist);\n prevM[x] = std::move(candRes.prev);\n prevDirM[x] = std::move(candRes.prevDir);\n\n for(int j=0;j used(N*N,0);\n used[startId]=1;\n for(int c: tinfo.cells){\n if(!used[c]){\n used[c]=1;\n cand.nodes.push_back(c);\n }\n }\n }\n\n // Stronger quick evaluation (restored): multi-start insertion + small 2opt\n auto distM = compute_distM_only(cand.nodes);\n auto W = build_W(distM, cand.nodes);\n int M=(int)cand.nodes.size();\n\n mt19937 rng(seed ^ 0x9e3779b9u);\n int trials = (M<=90 ? 4 : 3);\n vector bestTour;\n long long bestW = INFLL;\n for(int t=0;t pos(M,-1);\n for(int i=0;i& distStart, uint32_t seed) {\n mt19937 rng(seed);\n vector> adjSh = adjV;\n for(int u=0;u& distStart,\n const vector& minRowDist,\n const vector& minColDist,\n long long lambda,\n uint32_t seed) {\n mt19937 rng(seed);\n vector wL(R), wR(C);\n for(int u=0;u=0) wL[sRow]=0;\n if(sCol>=0) wR[sCol]=0;\n\n auto [coverL, coverR] = min_weight_vertex_cover(wL, wR);\n TargetsInfo tinfo = build_targets_from_cover(coverL, coverR, distStart, seed ^ 0xC2B2AE35u);\n return make_candidate_from_targets(tinfo, seed);\n }\n\n FinalSol finalize_candidate(const Candidate& cand, double timeBudgetSec) {\n auto t0=chrono::high_resolution_clock::now();\n auto elapsed=[&](){ return chrono::duration(chrono::high_resolution_clock::now()-t0).count(); };\n\n FinalSol fs;\n fs.nodes = cand.nodes;\n\n vector> distM, distAll, prevM;\n vector> prevDirM;\n compute_all_full(fs.nodes, distM, distAll, prevM, prevDirM);\n\n auto W = build_W(distM, fs.nodes);\n int M=(int)fs.nodes.size();\n\n mt19937 rngBase(cand.seed ^ 0x31415926u ^ (uint32_t)M);\n\n int trials = (M<=90? 10 : 6);\n vector>> pool;\n pool.reserve(trials);\n for(int t=0;t start1 = pool[0].second;\n vector start2 = pool[min(1,(int)pool.size()-1)].second;\n\n double tOpt1 = min(max(0.24, timeBudgetSec*0.46), max(0.24, timeBudgetSec-0.25));\n double tEach = tOpt1 * 0.5;\n\n mt19937 rng1(cand.seed ^ 0xCAFEBABEu);\n mt19937 rng2(cand.seed ^ 0xDEADBEEFu);\n auto bestTour = optimize_cycle_ILS_2opt(start1, W, tEach, rng1);\n auto altTour = optimize_cycle_ILS_2opt(start2, W, tEach, rng2);\n if(sym_cycle_cost(altTour, W) < sym_cycle_cost(bestTour, W)) bestTour = std::move(altTour);\n\n double tRel = min(0.50, max(0.06, timeBudgetSec*0.18));\n mt19937 rngRel(cand.seed ^ 0x9E3779B9u);\n relocate_targets(fs.nodes, bestTour, distM, distAll, prevM, prevDirM,\n cand.tinfo.needRow, cand.tinfo.needCol, tRel, rngRel);\n\n W = build_W(distM, fs.nodes);\n double rem = timeBudgetSec - elapsed();\n double tOpt2 = max(0.20, rem - 0.03);\n\n mt19937 rng3(cand.seed ^ 0x1234567u);\n auto fresh = build_initial_cycle_cheapest_insertion(W, rng3);\n\n double t2each = tOpt2 * 0.55;\n mt19937 rng4(cand.seed ^ 0x89ABCDEFu);\n mt19937 rng5(cand.seed ^ 0x0F1E2D3Cu);\n\n auto b1 = optimize_cycle_ILS_2opt(bestTour, W, t2each, rng4);\n auto b2 = optimize_cycle_ILS_2opt(fresh, W, tOpt2 - t2each, rng5);\n if(sym_cycle_cost(b2, W) < sym_cycle_cost(b1, W)) bestTour = std::move(b2);\n else bestTour = std::move(b1);\n\n fs.dirCost = directed_cycle_cost(bestTour, distM);\n fs.tour = std::move(bestTour);\n fs.prevM = std::move(prevM);\n fs.prevDirM = std::move(prevDirM);\n return fs;\n }\n\n void solve(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> si >> sj;\n g.resize(N);\n for(int i=0;i> g[i];\n\n startId = id(si,sj);\n cellCost.assign(N*N,0);\n for(int i=0;i(chrono::high_resolution_clock::now()-globalStart).count();\n };\n\n vector distStart = dijkstra_dist_only(startId);\n\n vector minRowDist(R, INFLL), minColDist(C, INFLL);\n for(int u=0;u(minRowDist[u], distStart[cell]);\n if(minRowDist[u] >= INF/2) minRowDist[u] = 1000000;\n }\n for(int v=0;v(minColDist[v], distStart[cell]);\n if(minColDist[v] >= INF/2) minColDist[v] = 1000000;\n }\n\n vector allD;\n allD.reserve(R+C);\n for(long long x: minRowDist) allD.push_back(x);\n for(long long x: minColDist) allD.push_back(x);\n nth_element(allD.begin(), allD.begin()+allD.size()/2, allD.end());\n long long med = allD[allD.size()/2];\n med = max(50, min(med, 50000));\n\n vector lambdas = { med/4, med/2, med, med*2, med*4, 50000LL };\n for(auto &x: lambdas) x = max(0, x);\n\n uint32_t baseSeed = (uint32_t)(987654321u + (uint32_t)N*97u + (uint32_t)si*131u + (uint32_t)sj*911u);\n\n vector cands;\n cands.reserve(lambdas.size()+3);\n\n for(int k=0;k<(int)lambdas.size();k++){\n uint32_t seed = baseSeed + 10007u*k;\n cands.push_back(make_candidate_weighted_cover(distStart, minRowDist, minColDist, lambdas[k], seed));\n }\n // back to 2 min-card candidates (as in best runs)\n for(int k=0;k<2;k++){\n uint32_t seed = baseSeed + 77777u + 10007u*k;\n cands.push_back(make_candidate_min_card_cover(distStart, seed));\n }\n\n sort(cands.begin(), cands.end(), [&](const Candidate& a, const Candidate& b){\n return a.quickDirCost < b.quickDirCost;\n });\n\n // finalize top-2 only\n int take = 2;\n double used = globalElapsed();\n double remain = 2.90 - used;\n double per = max(0.62, min(1.55, (remain - 0.10) / take));\n\n FinalSol best;\n for(int i=0;i\nusing namespace std;\n\nstruct FastRand {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int mod) { return (int)(next_u64() % (uint64_t)mod); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n // Box-Muller for standard normal\n double next_normal() {\n double u1 = max(1e-12, next_double());\n double u2 = next_double();\n return sqrt(-2.0 * log(u1)) * cos(2.0 * M_PI * u2);\n }\n};\n\n// Hungarian algorithm for rectangular min-cost assignment with m>=n.\n// cost is n x m.\nstatic vector hungarian_min_cost(const vector>& cost) {\n int n = (int)cost.size();\n int m = (int)cost[0].size();\n const long long INF = (1LL<<62);\n\n vector u(n+1, 0), v(m+1, 0);\n vector p(m+1, 0), way(m+1, 0);\n\n for (int i = 1; i <= n; i++) {\n p[0] = i;\n int j0 = 0;\n vector minv(m+1, INF);\n vector used(m+1, false);\n do {\n used[j0] = true;\n int i0 = p[j0];\n long long delta = INF;\n int j1 = 0;\n for (int j = 1; j <= m; j++) if (!used[j]) {\n long long cur = cost[i0-1][j-1] - u[i0] - v[j];\n if (cur < minv[j]) minv[j] = cur, way[j] = j0;\n if (minv[j] < delta) delta = minv[j], j1 = j;\n }\n for (int j = 0; j <= m; j++) {\n if (used[j]) u[p[j]] += delta, v[j] -= delta;\n else minv[j] -= delta;\n }\n j0 = j1;\n } while (p[j0] != 0);\n\n // augmenting\n do {\n int j1 = way[j0];\n p[j0] = p[j1];\n j0 = j1;\n } while (j0);\n }\n\n // assignment: for each row i, find column j with p[j]=i\n vector ans(n, -1);\n for (int j = 1; j <= m; j++) {\n if (p[j] >= 1 && p[j] <= n) ans[p[j]-1] = j-1;\n }\n return ans;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector> d(N, vector(K));\n vector sumD(N, 0);\n vector meanD(K, 0.0);\n\n for (int i = 0; i < N; i++) {\n long long s = 0;\n for (int k = 0; k < K; k++) {\n cin >> d[i][k];\n s += d[i][k];\n meanD[k] += d[i][k];\n }\n sumD[i] = (int)s;\n }\n for (int k = 0; k < K; k++) meanD[k] /= max(1, N);\n\n vector> out(N);\n vector indeg0(N, 0);\n for (int e = 0; e < R; e++) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg0[v]++;\n }\n\n // critical path length (in tasks)\n vector crit(N, 1);\n for (int i = N - 1; i >= 0; i--) {\n int best = 1;\n for (int v : out[i]) best = max(best, 1 + crit[v]);\n crit[i] = best;\n }\n\n vector outdeg(N);\n for (int i = 0; i < N; i++) outdeg[i] = (int)out[i].size();\n\n double avgSumD = 0.0;\n for (int i = 0; i < N; i++) avgSumD += sumD[i];\n avgSumD /= max(1, N);\n\n vector indeg = indeg0;\n vector task_state(N, 0); // 0:not started, 1:running, 2:done\n\n vector member_task(M, -1);\n vector start_day(M, -1);\n vector done_cnt(M, 0);\n\n FastRand rng;\n\n // K-dim skill estimate\n vector> s_est(M, vector(K, 0.0));\n for (int j = 0; j < M; j++) {\n // Random direction ~ |N(0,1)|, magnitude ~ 40 (mid of 20..60)\n vector v(K);\n double norm2 = 0.0;\n for (int k = 0; k < K; k++) {\n double x = fabs(rng.next_normal());\n v[k] = x;\n norm2 += x * x;\n }\n double mag = 40.0;\n double scale = (norm2 > 0) ? (mag / sqrt(norm2)) : 0.0;\n for (int k = 0; k < K; k++) {\n // small prior blend toward meanD to avoid pathological starts\n double initv = v[k] * scale;\n s_est[j][k] = 0.7 * initv + 0.3 * (meanD[k] * 2.0);\n if (s_est[j][k] < 0) s_est[j][k] = 0;\n }\n }\n\n auto w_pred = [&](int i, int j) -> double {\n double w = 0.0;\n const auto& sj = s_est[j];\n for (int k = 0; k < K; k++) {\n double diff = (double)d[i][k] - sj[k];\n if (diff > 0) w += diff;\n }\n return w;\n };\n\n auto t_pred = [&](int i, int j) -> double {\n double w = w_pred(i, j);\n if (w <= 0.0) return 1.0;\n // small bias improves robustness against r in [-3,3]\n return max(1.0, w + 0.5);\n };\n\n auto update_member = [&](int j, int i, int t_obs) {\n // target w roughly equals observed days for t>1, else 0\n double target_w = (t_obs <= 1) ? 0.0 : (double)t_obs;\n\n double w = w_pred(i, j);\n double err = w - target_w; // want err -> 0\n\n // Learning rate decays with number of observations\n double lr = 0.12 / sqrt(1.0 + done_cnt[j]); // tuned small & stable\n\n // Gradient: f(s)=sum max(0, d-s), df/ds_k = -1 if active else 0\n // Loss = (f-target)^2 => grad = 2*(f-target)*df/ds\n // Update s_k -= lr * grad => s_k += 2*lr*err for active dims.\n double delta = 2.0 * lr * err;\n\n // cap to avoid huge jumps on noisy tasks\n delta = max(-8.0, min(8.0, delta));\n\n auto &sj = s_est[j];\n for (int k = 0; k < K; k++) {\n if ((double)d[i][k] > sj[k]) {\n sj[k] += delta;\n if (sj[k] < 0) sj[k] = 0;\n }\n }\n\n // mild regularization toward a prior to prevent collapse\n for (int k = 0; k < K; k++) {\n double prior = meanD[k] * 2.0;\n sj[k] = 0.995 * sj[k] + 0.005 * prior;\n if (sj[k] < 0) sj[k] = 0;\n }\n\n done_cnt[j]++;\n };\n\n int day = 0;\n while (true) {\n day++;\n\n vector free_members;\n free_members.reserve(M);\n for (int j = 0; j < M; j++) if (member_task[j] == -1) free_members.push_back(j);\n\n vector avail;\n avail.reserve(N);\n for (int i = 0; i < N; i++) if (task_state[i] == 0 && indeg[i] == 0) avail.push_back(i);\n\n // Prepare candidate tasks:\n // (1) top by criticality\n sort(avail.begin(), avail.end(), [&](int a, int b) {\n if (crit[a] != crit[b]) return crit[a] > crit[b];\n if (outdeg[a] != outdeg[b]) return outdeg[a] > outdeg[b];\n if (sumD[a] != sumD[b]) return sumD[a] > sumD[b];\n return a < b;\n });\n\n unordered_set candset;\n candset.reserve(800);\n int TOP = min(160, (int)avail.size());\n for (int idx = 0; idx < TOP; idx++) candset.insert(avail[idx]);\n\n // (2) for each free member, add tasks predicted fast (and somewhat critical)\n int PER = 24;\n for (int j : free_members) {\n vector> best;\n best.reserve(avail.size());\n for (int i : avail) {\n double tp = t_pred(i, j);\n // smaller is better; incorporate criticality as a tie-breaker\n double key = tp - 0.15 * (double)crit[i] - 0.01 * (double)outdeg[i];\n best.push_back({key, i});\n }\n if ((int)best.size() > PER) {\n nth_element(best.begin(), best.begin() + PER, best.end());\n best.resize(PER);\n }\n for (auto &p : best) candset.insert(p.second);\n }\n\n vector cands;\n cands.reserve(candset.size());\n for (int i : candset) cands.push_back(i);\n\n // stable order for columns\n sort(cands.begin(), cands.end(), [&](int a, int b) {\n if (crit[a] != crit[b]) return crit[a] > crit[b];\n if (outdeg[a] != outdeg[b]) return outdeg[a] > outdeg[b];\n if (sumD[a] != sumD[b]) return sumD[a] > sumD[b];\n return a < b;\n });\n\n vector> assigns; // (member, task) 0-based\n assigns.reserve(free_members.size());\n\n if (!free_members.empty() && !cands.empty()) {\n int F = (int)free_members.size();\n int C = (int)cands.size();\n int W = max(F, C); // columns after padding\n const long long BIG = (long long)4e12;\n\n vector> cost(F, vector(W, BIG));\n\n // Build costs: minimize -score\n // score = A*crit + B*outdeg - D*t_pred + small difficulty term\n for (int r = 0; r < F; r++) {\n int j = free_members[r];\n bool explore = (done_cnt[j] < 4);\n for (int c = 0; c < C; c++) {\n int i = cands[c];\n double tp = t_pred(i, j);\n\n double sc = 120.0 * (double)crit[i]\n + 6.0 * (double)outdeg[i]\n - 1.0 * tp\n + 0.002 * (double)sumD[i];\n\n if (explore) {\n // Early stage: prefer moderate tasks to learn faster and avoid huge stalls\n sc -= 0.03 * fabs((double)sumD[i] - avgSumD);\n }\n\n long long ssc = (long long)llround(sc * 1000.0);\n cost[r][c] = -ssc;\n }\n }\n\n // If C < F, remaining columns are dummy with BIG cost (forces assignment only if no tasks)\n // If C > F, extra columns exist but that's fine.\n\n vector assign_col = hungarian_min_cost(cost);\n\n vector used_task(N, 0);\n for (int r = 0; r < F; r++) {\n int c = assign_col[r];\n if (c < 0 || c >= C) continue;\n int i = cands[c];\n if (task_state[i] != 0) continue;\n if (used_task[i]) continue; // safety\n int j = free_members[r];\n\n used_task[i] = 1;\n task_state[i] = 1;\n member_task[j] = i;\n start_day[j] = day;\n assigns.push_back({j, i});\n }\n }\n\n // Output assignments for today\n cout << assigns.size();\n for (auto [j, i] : assigns) cout << ' ' << (j + 1) << ' ' << (i + 1);\n cout << \"\\n\" << flush;\n\n // Read completion info\n int nfin;\n if (!(cin >> nfin)) return 0;\n if (nfin == -1) return 0;\n\n for (int z = 0; z < nfin; z++) {\n int a; cin >> a;\n int j = a - 1;\n int i = member_task[j];\n if (i < 0) continue; // safety\n\n int t_obs = day - start_day[j] + 1;\n\n // finish task\n member_task[j] = -1;\n start_day[j] = -1;\n task_state[i] = 2;\n\n // unlock successors\n for (int v : out[i]) indeg[v]--;\n\n // update skill estimate\n update_member(j, i, t_obs);\n }\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point { int x, y; };\nstatic inline int manhattan(const Point& a, const Point& b){\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\nstatic const Point OFFICE{400, 400};\n\nstruct Order {\n int id;\n Point P, D;\n int intra;\n int proxy;\n};\n\nstruct XorShift64 {\n uint64_t x;\n explicit XorShift64(uint64_t seed=88172645463325252ull) : x(seed) {}\n uint64_t next() {\n uint64_t y = x;\n y ^= y << 7;\n y ^= y >> 9;\n return x = y;\n }\n int next_int(int lo, int hi){ // inclusive\n return lo + (int)(next() % (uint64_t)(hi - lo + 1));\n }\n double next_double(){ // [0,1)\n return (next() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Solver {\n vector orders; // 1000\n vector pool; // all 1000 indices sorted by proxy\n vector used; // 1000\n mutable XorShift64 rng;\n\n chrono::steady_clock::time_point st, ed;\n\n Solver(): used(1000, 0) {\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n rng = XorShift64(seed);\n }\n\n inline bool time_over() const { return chrono::steady_clock::now() >= ed; }\n inline double elapsed_sec() const {\n return chrono::duration(chrono::steady_clock::now() - st).count();\n }\n inline double remain_sec() const {\n return chrono::duration(ed - chrono::steady_clock::now()).count();\n }\n\n // node encoding: (g<<1)|t\n inline Point node_point(int node) const {\n int g = node >> 1;\n int t = node & 1;\n return t ? orders[g].D : orders[g].P;\n }\n\n int route_cost(const vector& ev) const {\n int cost = 0;\n Point cur = OFFICE;\n for (int node : ev) {\n Point nxt = node_point(node);\n cost += manhattan(cur, nxt);\n cur = nxt;\n }\n cost += manhattan(cur, OFFICE);\n return cost;\n }\n\n void remove_pair_with_pts(const vector& ev, int A, int B,\n vector& base, vector& bp) const {\n base.clear(); bp.clear();\n base.reserve(ev.size() - 2);\n bp.reserve(ev.size() - 2);\n for (int node : ev) if (node != A && node != B) {\n base.push_back(node);\n bp.push_back(node_point(node));\n }\n }\n\n struct BestIns { int p, q, delta; };\n\n BestIns best_pair_insertion(const vector& base, const vector& bp,\n const Point& pA, const Point& pB) const {\n int Lb = (int)base.size();\n BestIns best{0, 1, INT_MAX};\n\n for (int p = 0; p <= Lb; p++) {\n Point prevP = (p == 0) ? OFFICE : bp[p - 1];\n Point nextP = (p == Lb) ? OFFICE : bp[p];\n int deltaA = manhattan(prevP, pA) + manhattan(pA, nextP) - manhattan(prevP, nextP);\n\n for (int q = p + 1; q <= Lb + 1; q++) {\n Point prevB = (q == p + 1) ? pA : bp[q - 2];\n Point nextB = (q == Lb + 1) ? OFFICE : bp[q - 1];\n int deltaB = manhattan(prevB, pB) + manhattan(pB, nextB) - manhattan(prevB, nextB);\n int total = deltaA + deltaB;\n if (total < best.delta) best = {p, q, total};\n }\n }\n return best;\n }\n\n vector build_with_pair_insertion(const vector& base, int A, int B, int p, int q) const {\n vector out = base;\n out.insert(out.begin() + p, A);\n out.insert(out.begin() + q, B);\n return out;\n }\n\n bool best_reinsert_apply(vector& ev, int g, int& curCost) const {\n int A = (g << 1), B = (g << 1) | 1;\n vector base;\n vector bp;\n remove_pair_with_pts(ev, A, B, base, bp);\n\n int baseCost = route_cost(base);\n auto best = best_pair_insertion(base, bp, orders[g].P, orders[g].D);\n int newCost = baseCost + best.delta;\n\n if (newCost <= curCost) {\n ev = build_with_pair_insertion(base, A, B, best.p, best.q);\n curCost = newCost;\n return true;\n }\n return false;\n }\n\n void local_optimize_pairs(vector& ev, const vector& chosen, int& curCost, int passes) const {\n for (int it = 0; it < passes; it++) {\n if (time_over()) return;\n bool improved = false;\n for (int g : chosen) {\n if (time_over()) return;\n improved |= best_reinsert_apply(ev, g, curCost);\n }\n if (!improved) break;\n }\n }\n\n bool single_relocate_light(vector& ev, int& curCost, int attempts) {\n int L = (int)ev.size();\n if (L <= 2) return false;\n bool improvedAny = false;\n\n static array pos;\n for (int t = 0; t < attempts; t++) {\n if (time_over()) break;\n pos.fill(-1);\n for (int i = 0; i < L; i++) pos[ev[i]] = i;\n\n int idx = rng.next_int(0, L - 1);\n int node = ev[idx];\n int g = node >> 1;\n int typ = node & 1;\n int pickup = (g << 1);\n int delivery = (g << 1) | 1;\n\n Point pn = node_point(node);\n Point prev = (idx == 0) ? OFFICE : node_point(ev[idx - 1]);\n Point next = (idx == L - 1) ? OFFICE : node_point(ev[idx + 1]);\n\n int removeDelta = manhattan(prev, pn) + manhattan(pn, next) - manhattan(prev, next);\n int baseCost = curCost - removeDelta;\n\n vector base;\n base.reserve(L - 1);\n for (int i = 0; i < L; i++) if (i != idx) base.push_back(ev[i]);\n int Lb = L - 1;\n\n int lo = 0, hi = Lb;\n if (typ == 0) {\n int posDel = pos[delivery];\n if (posDel < 0) continue;\n hi = posDel - 1;\n } else {\n int posPick = pos[pickup];\n if (posPick < 0) continue;\n lo = posPick + 1;\n }\n lo = max(lo, 0);\n hi = min(hi, Lb);\n if (lo > hi) continue;\n\n int bestP = -1, bestInsDelta = INT_MAX;\n for (int p = lo; p <= hi; p++) {\n Point pPrev = (p == 0) ? OFFICE : node_point(base[p - 1]);\n Point pNext = (p == Lb) ? OFFICE : node_point(base[p]);\n int insDelta = manhattan(pPrev, pn) + manhattan(pn, pNext) - manhattan(pPrev, pNext);\n if (insDelta < bestInsDelta) { bestInsDelta = insDelta; bestP = p; }\n }\n\n if (bestP >= 0) {\n int newCost = baseCost + bestInsDelta;\n if (newCost < curCost) {\n base.insert(base.begin() + bestP, node);\n ev.swap(base);\n curCost = newCost;\n improvedAny = true;\n L = (int)ev.size();\n }\n }\n }\n return improvedAny;\n }\n\n // exact cost after removing positions ipts->OFFICE tour\n int cost_after_remove_two(int curCost, const vector& pts, int i, int j) const {\n int L = (int)pts.size();\n auto getP = [&](int idx)->Point{\n if (idx < 0 || idx >= L) return OFFICE;\n return pts[idx];\n };\n if (i > j) swap(i, j);\n if (i + 1 == j) {\n Point a = getP(i - 1), b = getP(i), c = getP(j), d = getP(j + 1);\n return curCost - (manhattan(a,b) + manhattan(b,c) + manhattan(c,d)) + manhattan(a,d);\n } else {\n Point a0 = getP(i - 1), b0 = getP(i), c0 = getP(i + 1);\n Point a1 = getP(j - 1), b1 = getP(j), c1 = getP(j + 1);\n return curCost - (manhattan(a0,b0) + manhattan(b0,c0) + manhattan(a1,b1) + manhattan(b1,c1))\n + (manhattan(a0,c0) + manhattan(a1,c1));\n }\n }\n\n // Biased unused candidate sampling: mostly from top prefix, sometimes from all.\n int pick_unused_candidate_biased() {\n const int N = (int)pool.size(); // 1000\n const int TOP = 280; // bias to \"good\" by proxy\n for (int t = 0; t < 120; t++) {\n int g;\n if (rng.next_double() < 0.78) g = pool[rng.next_int(0, min(TOP, N)-1)];\n else g = pool[rng.next_int(0, N-1)];\n if (!used[g]) return g;\n }\n // fallback brute tries\n for (int t=0; t<1000; t++){\n int g = rng.next_int(0,999);\n if (!used[g]) return g;\n }\n return -1;\n }\n\n // pick old by fast sampling; build base/bp for best\n int pick_best_old_fast(const vector& ev, const vector& chosen, int curCost,\n int samples,\n vector& bestBase, vector& bestBp,\n int& bestBaseCost) const {\n int m = (int)chosen.size();\n int L = (int)ev.size();\n\n static array pos;\n pos.fill(-1);\n vector pts(L);\n for (int i = 0; i < L; i++) { pos[ev[i]] = i; pts[i] = node_point(ev[i]); }\n\n int bestIdx = 0;\n int bestG = chosen[0];\n bestBaseCost = INT_MAX;\n\n for (int s = 0; s < samples; s++) {\n int idx = (m == 1) ? 0 : rng.next_int(0, m-1);\n int g = chosen[idx];\n int A = (g << 1), B = (g << 1) | 1;\n int i = pos[A], j = pos[B];\n if (i < 0 || j < 0) continue;\n if (i > j) swap(i, j);\n int baseCost = cost_after_remove_two(curCost, pts, i, j);\n if (baseCost < bestBaseCost) {\n bestBaseCost = baseCost;\n bestIdx = idx;\n bestG = g;\n }\n }\n\n int Aold = (bestG << 1), Bold = (bestG << 1) | 1;\n remove_pair_with_pts(ev, Aold, Bold, bestBase, bestBp);\n return bestIdx;\n }\n\n int pick_best_new_by_sampling(const vector& base, const vector& bp,\n int samples, BestIns& bestInsOut) {\n int bestG = -1;\n int bestDelta = INT_MAX;\n BestIns bestInsLocal{0,1,INT_MAX};\n\n for (int s = 0; s < samples; s++) {\n if (time_over()) break;\n int g = pick_unused_candidate_biased();\n if (g < 0) continue;\n auto ins = best_pair_insertion(base, bp, orders[g].P, orders[g].D);\n if (ins.delta < bestDelta) {\n bestDelta = ins.delta;\n bestG = g;\n bestInsLocal = ins;\n }\n }\n if (bestG < 0) return -1;\n bestInsOut = bestInsLocal;\n return bestG;\n }\n\n vector greedy_init_chosen(int m=50) {\n vector chosen;\n chosen.reserve(m);\n fill(used.begin(), used.end(), 0);\n\n Point cur = OFFICE;\n const double alpha = 0.25;\n\n for (int t = 0; t < m; t++) {\n int best = -1;\n double bestScore = 1e100;\n for (int g : pool) if (!used[g]) {\n const auto& o = orders[g];\n double s = manhattan(cur, o.P) + o.intra + alpha * manhattan(o.D, OFFICE);\n if (s < bestScore) { bestScore = s; best = g; }\n }\n if (best == -1) break;\n used[best] = 1;\n chosen.push_back(best);\n cur = orders[best].D;\n }\n for (int g = 0; (int)chosen.size() < m; g++) if (!used[g]) {\n used[g] = 1;\n chosen.push_back(g);\n }\n return chosen;\n }\n\n vector init_events_consecutive(const vector& chosen) const {\n vector ev;\n ev.reserve(2 * chosen.size());\n for (int g : chosen) {\n ev.push_back(g << 1);\n ev.push_back((g << 1) | 1);\n }\n return ev;\n }\n\n void solve() {\n st = chrono::steady_clock::now();\n // safe budget\n ed = st + chrono::microseconds(1930000);\n\n // pool = all orders sorted by proxy\n vector idxs(1000);\n iota(idxs.begin(), idxs.end(), 0);\n sort(idxs.begin(), idxs.end(), [&](int i, int j){\n return orders[i].proxy < orders[j].proxy;\n });\n pool = idxs;\n\n const int m = 50;\n\n // Multi-start init (keep small)\n vector bestChosenInit, bestEvInit;\n int bestInitCost = INT_MAX;\n\n vector poolBak = pool;\n for (int s = 0; s < 4; s++) {\n if (time_over()) break;\n pool = poolBak;\n int pref = 220;\n for (int i = 0; i < pref; i++) swap(pool[i], pool[rng.next_int(0, pref-1)]);\n\n vector chosen = greedy_init_chosen(m);\n vector ev = init_events_consecutive(chosen);\n int c = route_cost(ev);\n local_optimize_pairs(ev, chosen, c, 3);\n single_relocate_light(ev, c, 5);\n\n if (c < bestInitCost) {\n bestInitCost = c;\n bestChosenInit = chosen;\n bestEvInit = ev;\n }\n }\n\n if (bestChosenInit.empty()) {\n bestChosenInit = greedy_init_chosen(m);\n bestEvInit = init_events_consecutive(bestChosenInit);\n bestInitCost = route_cost(bestEvInit);\n }\n\n vector chosen = bestChosenInit;\n vector ev = bestEvInit;\n fill(used.begin(), used.end(), 0);\n for (int g : chosen) used[g] = 1;\n\n int curCost = bestInitCost;\n int bestCost = curCost;\n vector bestChosen = chosen;\n vector bestEv = ev;\n\n // SA\n while (!time_over()) {\n double frac = min(1.0, elapsed_sec() / 1.93);\n double T0 = 1400.0, T1 = 10.0;\n double temp = T0 * pow(T1 / T0, frac);\n\n // dynamic sampling: slightly more later\n int OLD_S = (frac < 0.7 ? 9 : 11);\n int NEW_S = (frac < 0.7 ? 20 : 24);\n\n // mostly replacement\n if (rng.next_double() < 0.92) {\n vector base;\n vector bp;\n int baseCost;\n int posOld = pick_best_old_fast(ev, chosen, curCost, OLD_S, base, bp, baseCost);\n int g_old = chosen[posOld];\n\n BestIns ins;\n int g_new = pick_best_new_by_sampling(base, bp, NEW_S, ins);\n if (g_new < 0) continue;\n\n vector ev2 = build_with_pair_insertion(base, (g_new<<1), (g_new<<1)|1, ins.p, ins.q);\n int cost2 = baseCost + ins.delta;\n\n int delta = cost2 - curCost;\n bool accept = (delta <= 0) || (rng.next_double() < exp(-delta / temp));\n if (accept) {\n used[g_old] = 0;\n used[g_new] = 1;\n chosen[posOld] = g_new;\n\n // Cheaper post-accept polishing to increase iteration count:\n local_optimize_pairs(ev2, chosen, cost2, 1);\n // If it becomes new best, polish more.\n if (cost2 < bestCost) {\n local_optimize_pairs(ev2, chosen, cost2, 2);\n single_relocate_light(ev2, cost2, 2);\n }\n\n ev.swap(ev2);\n curCost = cost2;\n\n if (curCost < bestCost) {\n bestCost = curCost;\n bestChosen = chosen;\n bestEv = ev;\n }\n }\n } else {\n // rare route perturbation; skip if close to end\n if (remain_sec() < 0.03) break;\n int g = chosen[rng.next_int(0, m-1)];\n vector base;\n vector bp;\n remove_pair_with_pts(ev, (g<<1), (g<<1)|1, base, bp);\n int Lb = (int)base.size();\n int p = rng.next_int(0, Lb);\n int q = rng.next_int(p+1, Lb+1);\n vector ev2 = build_with_pair_insertion(base, (g<<1), (g<<1)|1, p, q);\n int cost2 = route_cost(ev2);\n int delta = cost2 - curCost;\n if (delta <= 0 || rng.next_double() < exp(-delta / temp)) {\n local_optimize_pairs(ev2, chosen, cost2, 1);\n ev.swap(ev2);\n curCost = cost2;\n if (curCost < bestCost) {\n bestCost = curCost;\n bestChosen = chosen;\n bestEv = ev;\n }\n }\n }\n }\n\n // Limited final hill-climb (time-bounded, small)\n {\n chosen = bestChosen;\n ev = bestEv;\n fill(used.begin(), used.end(), 0);\n for (int g : chosen) used[g] = 1;\n curCost = route_cost(ev);\n\n local_optimize_pairs(ev, chosen, curCost, 2);\n\n int fail = 0;\n const int HC_OLD = 12;\n const int HC_NEW = 28;\n\n while (remain_sec() > 0.06) {\n vector base;\n vector bp;\n int baseCost;\n int posOld = pick_best_old_fast(ev, chosen, curCost, HC_OLD, base, bp, baseCost);\n int g_old = chosen[posOld];\n\n BestIns ins;\n int g_new = pick_best_new_by_sampling(base, bp, HC_NEW, ins);\n if (g_new < 0) break;\n\n int cost2 = baseCost + ins.delta;\n if (cost2 >= curCost) {\n if (++fail >= 18) break;\n continue;\n }\n fail = 0;\n\n vector ev2 = build_with_pair_insertion(base, (g_new<<1), (g_new<<1)|1, ins.p, ins.q);\n used[g_old] = 0;\n used[g_new] = 1;\n chosen[posOld] = g_new;\n\n local_optimize_pairs(ev2, chosen, cost2, 1);\n ev.swap(ev2);\n curCost = cost2;\n }\n\n if (curCost < bestCost) {\n bestCost = curCost;\n bestChosen = chosen;\n bestEv = ev;\n }\n }\n\n // Final polish (bounded)\n int finalCost = route_cost(bestEv);\n local_optimize_pairs(bestEv, bestChosen, finalCost, 4);\n single_relocate_light(bestEv, finalCost, 35);\n\n // Output\n cout << m;\n for (int g : bestChosen) cout << ' ' << (g + 1);\n cout << \"\\n\";\n\n vector route;\n route.reserve(2*m + 2);\n route.push_back(OFFICE);\n for (int node : bestEv) route.push_back(node_point(node));\n route.push_back(OFFICE);\n\n cout << (int)route.size();\n for (auto &p : route) cout << ' ' << p.x << ' ' << p.y;\n cout << \"\\n\";\n }\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Solver solver;\n solver.orders.resize(1000);\n for (int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n solver.orders[i].id = i + 1;\n solver.orders[i].P = {a,b};\n solver.orders[i].D = {c,d};\n solver.orders[i].intra = manhattan(solver.orders[i].P, solver.orders[i].D);\n solver.orders[i].proxy = manhattan(OFFICE, solver.orders[i].P)\n + solver.orders[i].intra\n + manhattan(solver.orders[i].D, OFFICE);\n }\n solver.solve();\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct DSU {\n int n, comps;\n vector p, sz;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n comps = n;\n p.resize(n);\n sz.assign(n, 1);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){\n while(p[a]!=a){\n p[a] = p[p[a]];\n a = p[a];\n }\n return a;\n }\n bool same(int a,int b){ return find(a)==find(b); }\n bool merge(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 comps--;\n return true;\n }\n};\n\nstatic constexpr int N = 400;\nstatic constexpr int M = 1995;\nstatic constexpr int INF = 1000000000;\n\nstruct Ctx {\n vector root; // chosen.find(v)\n vector cid; // cid[root] -> 0..k-1\n int k;\n};\n\nstatic Ctx build_ctx(DSU &chosen){\n Ctx ctx;\n ctx.root.resize(N);\n for(int i=0;i &u, const vector &v){\n if(ctx.k <= 1) return true;\n DSU dsu2(ctx.k);\n for(int j=i+1;j depth;\n vector> up;\n vector> mx; // max edge weight to ancestor (weights are 2*d)\n vector outCnt;\n vector minOutW1, minOutW2;\n};\n\nstatic FutureInfo build_future_info(\n int i, const Ctx &ctx,\n const vector &u, const vector &v, const vector &d, int maxD)\n{\n FutureInfo info;\n info.k = ctx.k;\n info.ok = true;\n\n info.outCnt.assign(ctx.k, 0);\n info.minOutW1.assign(ctx.k, INF);\n info.minOutW2.assign(ctx.k, INF);\n\n if(ctx.k <= 1){\n info.LOG = 1;\n info.depth.assign(ctx.k, 0);\n info.up.assign(1, vector(ctx.k, -1));\n info.mx.assign(1, vector(ctx.k, 0));\n return info;\n }\n\n auto relax2 = [&](int c, int w){\n if(w < info.minOutW1[c]){\n info.minOutW2[c] = info.minOutW1[c];\n info.minOutW1[c] = w;\n } else if(w < info.minOutW2[c]) {\n info.minOutW2[c] = w;\n }\n };\n\n // bucket by d for expected MST (weights = 2*d)\n vector>> bucket(maxD + 1);\n\n for(int j=i+1;j>> adj(ctx.k);\n DSU mst(ctx.k);\n for(int dist=1; dist<=maxD && mst.comps>1; dist++){\n int w = 2 * dist;\n for(auto [a,b] : bucket[dist]){\n if(mst.merge(a,b)){\n adj[a].push_back({b,w});\n adj[b].push_back({a,w});\n if(mst.comps == 1) break;\n }\n }\n }\n if(mst.comps != 1){\n info.ok = false;\n info.LOG = 1;\n info.depth.assign(ctx.k, 0);\n info.up.assign(1, vector(ctx.k, -1));\n info.mx.assign(1, vector(ctx.k, 0));\n return info;\n }\n\n int LOG=1;\n while((1<(ctx.k, -1));\n info.mx.assign(LOG, vector(ctx.k, 0));\n\n // Root at 0\n stack st;\n info.depth[0] = 0;\n st.push(0);\n while(!st.empty()){\n int x = st.top(); st.pop();\n for(auto [to,w] : adj[x]){\n if(info.depth[to] != -1) continue;\n info.depth[to] = info.depth[x] + 1;\n info.up[0][to] = x;\n info.mx[0][to] = w;\n st.push(to);\n }\n }\n\n for(int t=1;t=0; t--){\n if(info.up[t][a] != info.up[t][b]){\n res = max(res, info.mx[t][a]);\n res = max(res, info.mx[t][b]);\n a = info.up[t][a];\n b = info.up[t][b];\n }\n }\n res = max(res, info.mx[0][a]);\n res = max(res, info.mx[0][b]);\n return res;\n}\n\nstatic long double clamp_ld(long double x, long double lo, long double hi){\n if(x < lo) return lo;\n if(x > hi) return hi;\n return x;\n}\n\n// Expected saving if replacing a single future edge base db (Lb~Unif[db,3db]) by known cost li:\n// saving = E[max(0, Lb - li)]\nstatic long double expected_saving_replace(int li, int db){\n if(db <= 0) return 0.0L;\n long double L = (long double)li;\n long double d = (long double)db;\n if(L <= d){\n return 2.0L*d - L;\n } else if(L < 3.0L*d){\n long double t = 3.0L*d - L;\n return (t*t) / (4.0L*d);\n } else {\n return 0.0L;\n }\n}\n\n// xorshift RNG (fast)\nstruct XorShift64 {\n uint64_t x=88172645463325252ull;\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi){ // inclusive\n uint64_t r = next_u64();\n return lo + (int)(r % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct SmallDSU {\n int n, comps;\n vector p, sz;\n SmallDSU(int n=0){ init(n); }\n void init(int n_){\n n = n_;\n comps = n;\n p.resize(n);\n sz.assign(n, 1);\n iota(p.begin(), p.end(), 0);\n }\n inline int find(int a){\n while(p[a]!=a){\n p[a] = p[p[a]];\n a = p[a];\n }\n return a;\n }\n inline bool merge(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; sz[a]+=sz[b];\n comps--;\n return true;\n }\n};\n\n// Adaptive MC with common random numbers; returns mean diff (acc - rej) and used samples.\nstatic pair mc_mean_diff_adaptive(\n int i, int li, int cu, int cv, const Ctx &ctx,\n const vector &u, const vector &v, const vector &d,\n int minSamples, int maxSamples, long double z, XorShift64 &rng)\n{\n // Build contracted future edge list once\n vector A, B, D;\n A.reserve(M-i);\n B.reserve(M-i);\n D.reserve(M-i);\n int maxDj = 1;\n for(int j=i+1;j head(WMAX+1, -1);\n vector nxt(E, -1);\n\n SmallDSU dsRej(k), dsAcc(k);\n\n // Welford for diff\n long double mean = 0.0L;\n long double M2 = 0.0L;\n int n = 0;\n\n auto add_sample = [&](long double x){\n n++;\n long double delta = x - mean;\n mean += delta / (long double)n;\n long double delta2 = x - mean;\n M2 += delta * delta2;\n };\n\n for(int s=0; s WMAX) w = WMAX;\n nxt[e] = head[w];\n head[w] = e;\n }\n\n dsRej.init(k);\n dsAcc.init(k);\n long long costRej = 0;\n long long costAcc = li;\n dsAcc.merge(cu, cv);\n\n for(int w=1; w<=WMAX; w++){\n for(int e=head[w]; e!=-1; e=nxt[e]){\n int a = A[e], b = B[e];\n if(dsRej.merge(a,b)) costRej += w;\n if(dsAcc.merge(a,b)) costAcc += w;\n }\n if(dsRej.comps==1 && dsAcc.comps==1) break;\n }\n if(dsRej.comps != 1) costRej = INF;\n if(dsAcc.comps != 1) costAcc = INF;\n\n long double diff = (long double)costAcc - (long double)costRej;\n add_sample(diff);\n\n if(n >= minSamples){\n long double var = (n >= 2) ? (M2 / (long double)(n - 1)) : 0.0L;\n long double se = sqrt((double)var / (double)n);\n\n // If se==0, diff is deterministic under our sampling (rare); stop.\n if(se == 0.0L) break;\n\n // Confidence interval for mean diff: mean \u00b1 z*se\n if(mean + z*se < 0.0L) break; // accept clearly better\n if(mean - z*se > 0.0L) break; // reject clearly better\n }\n }\n return {mean, 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> x[i] >> y[i];\n vector u(M), v(M);\n for(int i=0;i> u[i] >> v[i];\n\n vector d(M);\n int maxD = 1;\n for(int i=0;i> li;\n\n if(chosen.comps == 1){\n cout << 0 << \"\\n\" << flush;\n continue;\n }\n\n int ans = 0;\n if(chosen.same(u[i], v[i])){\n ans = 0;\n } else {\n Ctx ctx = build_ctx(chosen);\n bool ok_reject = feasible_if_reject(i, ctx, u, v);\n\n if(!ok_reject){\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n int cu = ctx.cid[ ctx.root[u[i]] ];\n int cv = ctx.cid[ ctx.root[v[i]] ];\n\n FutureInfo finfo = build_future_info(i, ctx, u, v, d, maxD);\n\n long double ratio = (long double)li / (long double)d[i];\n long double rem_edges = (long double)(M - i);\n long double urgency = (ctx.k <= 1 ? 0.0L : (long double)(ctx.k - 1) / rem_edges);\n\n int outA = finfo.ok ? finfo.outCnt[cu] : 0;\n int outB = finfo.ok ? finfo.outCnt[cv] : 0;\n int scarce = min(outA, outB);\n\n bool take = false;\n\n // Backbone heuristic (keep as-is; proven strong)\n if(ratio <= 1.13L) take = true;\n\n if(!take && finfo.ok){\n int min1 = min(finfo.minOutW1[cu], finfo.minOutW1[cv]);\n int min2 = min(finfo.minOutW2[cu], finfo.minOutW2[cv]);\n\n if(min1 < INF){\n long double phi = 1.06L + 0.05L * urgency;\n if(scarce <= 2) phi += 0.05L;\n if((long double)li <= phi * (long double)min1) take = true;\n }\n if(!take && scarce <= 1 && min2 < INF){\n long double phi2 = 1.04L + 0.08L * urgency;\n if((long double)li <= phi2 * (long double)min2) take = true;\n }\n }\n\n if(!take && finfo.ok){\n int maxW = max_on_path(cu, cv, finfo); // = 2*db\n int db = maxW / 2;\n if(db > 0){\n if(li <= maxW){\n take = true;\n } else {\n long double sav = expected_saving_replace(li, db);\n\n long double reqFactor = 0.17L - 0.08L * urgency;\n if(scarce <= 2) reqFactor -= 0.03L;\n if(scarce <= 1) reqFactor -= 0.02L;\n reqFactor = clamp_ld(reqFactor, 0.06L, 0.20L);\n\n long double req = reqFactor * (long double)db;\n if(sav >= req) take = true;\n }\n }\n }\n\n if(!take){\n long double allow = 1.20L + 1.62L * urgency;\n if(scarce <= 2) allow += 0.10L;\n allow = min(allow, 2.00L);\n if(ratio <= allow) take = true;\n }\n\n // Adaptive MC override on borderline cases\n bool borderline = (ratio >= 1.15L && ratio <= 1.92L && ctx.k >= 3 && ctx.k <= 110);\n if(borderline){\n auto now = chrono::steady_clock::now();\n double sec = chrono::duration(now - t0).count();\n if(mcCalls < MC_CALL_BUDGET && sec < 1.86){\n // only if not a slam dunk\n if(ratio > 1.10L && ratio < 1.98L){\n mcCalls++;\n\n // tune sampling based on difficulty\n int minS = 8;\n int maxS = 22;\n if(ctx.k <= 20) { minS = 10; maxS = 26; } // late stage: important decisions\n if(scarce <= 2) { minS += 2; maxS += 2; }\n\n long double z = 0.95L; // early-stop aggressiveness\n\n auto [meanDiff, used] = mc_mean_diff_adaptive(\n i, li, cu, cv, ctx, u, v, d, minS, maxS, z, rng\n );\n\n // meanDiff = E[costAcc - costRej]; accept if negative.\n // Add asymmetric margins to avoid over-accepting due to residual noise:\n if(!take){\n if(meanDiff < -0.35L) take = true;\n } else {\n if(meanDiff > +0.60L) take = false;\n }\n }\n }\n }\n\n if(take){\n ans = 1;\n chosen.merge(u[i], v[i]);\n } else {\n ans = 0;\n }\n }\n }\n\n cout << ans << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nstatic const int H = 30, W = 30;\nstatic const int TURNS = 300;\n\nstruct Pet { int x, y, t; };\nstruct Human { int x, y; };\n\nstatic inline bool in_grid(int x,int y){ return 1<=x && x<=H && 1<=y && y<=W; }\n\nint dx4[4] = {-1, +1, 0, 0};\nint dy4[4] = {0, 0, -1, +1};\nchar dirMove[4] = {'U','D','L','R'};\nchar dirWall[4] = {'u','d','l','r'};\n\nstruct BFSResult{\n int dist[H+1][W+1];\n char first[H+1][W+1];\n};\n\nstruct TaskCand{\n int val;\n int workX, workY;\n int wallX, wallY;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N; cin >> N;\n vector pets(N);\n for(int i=0;i> pets[i].x >> pets[i].y >> pets[i].t;\n int M; cin >> M;\n vector humans(M);\n for(int i=0;i> humans[i].x >> humans[i].y;\n\n static bool wall[H+1][W+1];\n for(int x=1;x<=H;x++) for(int y=1;y<=W;y++) wall[x][y]=false;\n\n // ---- Choose sanctuary rectangle ----\n auto petsInsideRect = [&](int x1,int y1,int S)->int{\n int x2=x1+S-1, y2=y1+S-1;\n int c=0;\n for(auto &p: pets) if(x1<=p.x && p.x<=x2 && y1<=p.y && p.y<=y2) c++;\n return c;\n };\n auto humanTravelCost = [&](int x1,int y1,int S)->long long{\n int x2=x1+S-1, y2=y1+S-1;\n long long sum=0;\n for(auto &h: humans){\n int tx=min(max(h.x,x1),x2);\n int ty=min(max(h.y,y1),y2);\n sum += llabs(h.x-tx)+llabs(h.y-ty);\n }\n return sum;\n };\n auto distPetToRect = [&](const Pet& p, int x1,int y1,int S)->int{\n int x2=x1+S-1, y2=y1+S-1;\n int dx=0, dy=0;\n if(p.x < x1) dx = x1 - p.x; else if(p.x > x2) dx = p.x - x2;\n if(p.y < y1) dy = y1 - p.y; else if(p.y > y2) dy = p.y - y2;\n return dx+dy;\n };\n auto nearPetsCount = [&](int x1,int y1,int S,int th)->int{\n int c=0;\n for(auto &p: pets) if(distPetToRect(p,x1,y1,S)<=th) c++;\n return c;\n };\n\n int best_x1=2,best_y1=2,bestS=16;\n long long bestScore = LLONG_MIN;\n for(int pass=0; pass<2; pass++){\n int allowInside = (pass==0?0:1);\n for(int S=28; S>=14; S--){\n for(int x1=2; x1+S-1<=29; x1++){\n for(int y1=2; y1+S-1<=29; y1++){\n int pin = petsInsideRect(x1,y1,S);\n if(pin>allowInside) continue;\n\n long long area = 1LL*S*S;\n long long hcost = humanTravelCost(x1,y1,S);\n int near1 = nearPetsCount(x1,y1,S,1);\n int near2 = nearPetsCount(x1,y1,S,2);\n\n long long score = area*2000LL\n - 2000000000LL*pin\n - 140000LL*near1\n - 50000LL*near2\n - 22LL*hcost;\n if(score > bestScore){\n bestScore=score;\n best_x1=x1; best_y1=y1; bestS=S;\n }\n }\n }\n }\n if(pass==0 && petsInsideRect(best_x1,best_y1,bestS)==0) break;\n }\n\n int x1=best_x1, y1=best_y1;\n int x2=x1+bestS-1, y2=y1+bestS-1;\n\n auto inInterior = [&](int x,int y)->bool{ return x1<=x && x<=x2 && y1<=y && y<=y2; };\n auto allHumansInsideInterior = [&]()->bool{\n for(auto &h: humans) if(!inInterior(h.x,h.y)) return false;\n return true;\n };\n\n // ---- Gate selection improved (human cost + pet proximity; dogs heavier) ----\n struct Gate { int gx,gy, ix,iy; };\n int midx=(x1+x2)/2, midy=(y1+y2)/2;\n vector gateCand = {\n {x1-1, midy, x1, midy}, // top\n {x2+1, midy, x2, midy}, // bottom\n {midx, y1-1, midx, y1}, // left\n {midx, y2+1, midx, y2} // right\n };\n\n auto gateScore = [&](const Gate& g)->long long{\n long long hs=0;\n for(auto &h: humans) hs += llabs(h.x-g.ix) + llabs(h.y-g.iy);\n\n auto wPet = [&](int t)->int{\n if(t==4) return 6; // dog\n if(t==3) return 3; // rabbit\n if(t==2) return 2; // pig\n return 1;\n };\n long long ps=0;\n // penalize pets near gate cell and near inner-door\n for(auto &p: pets){\n int w = wPet(p.t);\n int dg = abs(p.x-g.gx)+abs(p.y-g.gy);\n int di = abs(p.x-g.ix)+abs(p.y-g.iy);\n if(dg<=3) ps += 200LL*w*(4-dg);\n if(di<=3) ps += 250LL*w*(4-di);\n }\n return hs*10 + ps;\n };\n\n Gate gate = *min_element(gateCand.begin(), gateCand.end(),\n [&](const Gate& a,const Gate& b){ return gateScore(a) < gateScore(b); });\n\n // ---- Outer perimeter cells to build (exclude corners, exclude gate cell) ----\n vector> outerPerim;\n for(int y=y1; y<=y2; y++) if(!(x1-1==gate.gx && y==gate.gy)) outerPerim.push_back({x1-1,y});\n for(int y=y1; y<=y2; y++) if(!(x2+1==gate.gx && y==gate.gy)) outerPerim.push_back({x2+1,y});\n for(int x=x1; x<=x2; x++) if(!(x==gate.gx && y1-1==gate.gy)) outerPerim.push_back({x,y1-1});\n for(int x=x1; x<=x2; x++) if(!(x==gate.gx && y2+1==gate.gy)) outerPerim.push_back({x,y2+1});\n\n auto outerCompleteExceptGate = [&]()->bool{\n for(auto &c: outerPerim) if(!wall[c.first][c.second]) return false;\n return true;\n };\n\n auto bfsFrom = [&](int sx,int sy)->BFSResult{\n BFSResult res;\n const int INF=1e9;\n for(int x=1;x<=H;x++) for(int y=1;y<=W;y++){\n res.dist[x][y]=INF;\n res.first[x][y]='?';\n }\n deque> q;\n res.dist[sx][sy]=0;\n res.first[sx][sy]='.';\n q.push_back({sx,sy});\n while(!q.empty()){\n auto [x,y]=q.front(); q.pop_front();\n for(int k=0;k<4;k++){\n int nx=x+dx4[k], ny=y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) continue;\n if(res.dist[nx][ny]!=INF) continue;\n res.dist[nx][ny]=res.dist[x][y]+1;\n res.first[nx][ny] = (x==sx && y==sy) ? dirMove[k] : res.first[x][y];\n q.push_back({nx,ny});\n }\n }\n return res;\n };\n\n auto placeableWall = [&](int tx,int ty,\n const vector>& petCnt,\n const vector>& humanCnt)->bool{\n if(!in_grid(tx,ty)) return false;\n if(humanCnt[tx][ty]>0) return false;\n if(petCnt[tx][ty]>0) return false;\n for(int k=0;k<4;k++){\n int ax=tx+dx4[k], ay=ty+dy4[k];\n if(in_grid(ax,ay) && petCnt[ax][ay]>0) return false;\n }\n return true;\n };\n\n auto computeReachMaskFromHumans = [&](){\n vector> vis(H+1, vector(W+1,0));\n deque> q;\n for(auto &h: humans){\n if(!in_grid(h.x,h.y) || wall[h.x][h.y]) continue;\n if(!vis[h.x][h.y]){\n vis[h.x][h.y]=1;\n q.push_back({h.x,h.y});\n }\n }\n while(!q.empty()){\n auto [x,y]=q.front(); q.pop_front();\n for(int k=0;k<4;k++){\n int nx=x+dx4[k], ny=y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) continue;\n if(vis[nx][ny]) continue;\n vis[nx][ny]=1;\n q.push_back({nx,ny});\n }\n }\n return vis;\n };\n\n // ---- Prison / Cut ----\n enum Phase { OUTER_BUILD=0, SEAL=1, PRISON=2, CUT=3, DONE=4 };\n Phase phase = OUTER_BUILD;\n\n bool sealed = false;\n bool gateClosed = false;\n bool innerClosed = false;\n\n // prison\n bool prisonPlanned=false;\n int px1=0,py1=0,px2=0,py2=0;\n vector> prisonWalls;\n\n auto humanInPrison = [&](const Human& h)->bool{\n return prisonPlanned && (px1<=h.x && h.x<=px2 && py1<=h.y && h.y<=py2);\n };\n auto anyHumanInPrison = [&]()->bool{\n if(!prisonPlanned) return false;\n for(auto &h: humans) if(humanInPrison(h)) return true;\n return false;\n };\n auto prisonRemaining = [&]()->vector>{\n vector> rem;\n for(auto &c: prisonWalls) if(!wall[c.first][c.second]) rem.push_back(c);\n return rem;\n };\n\n auto planPrisonOnce = [&](const vector>& petCnt)->bool{\n vector> insidePets;\n for(auto &p: pets) if(inInterior(p.x,p.y)) insidePets.push_back({p.x,p.y});\n if(insidePets.empty()) return false;\n\n int minx=31,maxx=0,miny=31,maxy=0;\n for(auto &q: insidePets){\n minx=min(minx,q.first); maxx=max(maxx,q.first);\n miny=min(miny,q.second); maxy=max(maxy,q.second);\n }\n\n long long totalArea = 1LL*(x2-x1+1)*(y2-y1+1);\n\n long long bestRemain=-1;\n int bestB=-1;\n int bx1=0,by1=0,bx2=0,by2=0;\n vector> bestWalls;\n\n for(int B=4; B>=1; B--){\n int tx1=max(x1, minx-B), tx2=min(x2, maxx+B);\n int ty1=max(y1, miny-B), ty2=min(y2, maxy+B);\n\n if(tx2-tx1 < 2 || ty2-ty1 < 2) continue;\n\n long long prisonArea = 1LL*(tx2-tx1+1)*(ty2-ty1+1);\n long long remainArea = totalArea - prisonArea;\n if(remainArea < 80) continue;\n\n vector> walls;\n for(int y=ty1+1; y<=ty2-1; y++){\n walls.push_back({tx1,y});\n walls.push_back({tx2,y});\n }\n for(int x=tx1+1; x<=tx2-1; x++){\n walls.push_back({x,ty1});\n walls.push_back({x,ty2});\n }\n if(walls.empty()) continue;\n\n int okNow=0;\n for(auto &c: walls){\n int wx=c.first, wy=c.second;\n bool ok=true;\n if(petCnt[wx][wy]>0) ok=false;\n for(int k=0;k<4;k++){\n int ax=wx+dx4[k], ay=wy+dy4[k];\n if(in_grid(ax,ay) && petCnt[ax][ay]>0) ok=false;\n }\n if(ok) okNow++;\n }\n if(okNow==0) continue;\n\n if(remainArea > bestRemain || (remainArea==bestRemain && B>bestB)){\n bestRemain=remainArea;\n bestB=B;\n bx1=tx1; bx2=tx2; by1=ty1; by2=ty2;\n bestWalls.swap(walls);\n }\n }\n\n if(bestB==-1) return false;\n px1=bx1; px2=bx2; py1=by1; py2=by2;\n prisonWalls.swap(bestWalls);\n prisonPlanned=true;\n return true;\n };\n\n // cut\n bool cutPlanned=false;\n bool cutVertical=false;\n int cutPos=-1;\n bool keepRightOrDown=true;\n vector> cutCells;\n\n auto cutRemaining = [&]()->vector>{\n vector> rem;\n for(auto &c: cutCells) if(!wall[c.first][c.second]) rem.push_back(c);\n return rem;\n };\n\n auto allHumansOnSafeSide = [&]()->bool{\n if(!cutPlanned) return true;\n auto onSafe = [&](int x,int y)->bool{\n if(cutVertical){\n if(keepRightOrDown) return y >= cutPos+1;\n else return y <= cutPos-1;\n }else{\n if(keepRightOrDown) return x >= cutPos+1;\n else return x <= cutPos-1;\n }\n };\n for(auto &h: humans){\n if(!inInterior(h.x,h.y)) return false;\n if(!onSafe(h.x,h.y)) return false;\n }\n return true;\n };\n\n auto planCutOnce = [&](const vector>& reachMask)->bool{\n vector> rpets;\n for(auto &p: pets) if(reachMask[p.x][p.y]) rpets.push_back({p.x,p.y});\n if(rpets.empty()) return false;\n\n long long bestKey = LLONG_MAX;\n bool bestV=false; int bestP=-1; bool bestKeep=true;\n\n auto countSafePets = [&](bool vert,int pos,bool keep)->int{\n int c=0;\n for(auto &q: rpets){\n int x=q.first, y=q.second;\n if(vert){\n if(keep){ if(y>=pos+1) c++; } else { if(y<=pos-1) c++; }\n }else{\n if(keep){ if(x>=pos+1) c++; } else { if(x<=pos-1) c++; }\n }\n }\n return c;\n };\n auto safeArea = [&](bool vert,int pos,bool keep)->long long{\n if(vert){\n if(keep) return 1LL*(x2-x1+1)*max(0, y2-(pos+1)+1);\n else return 1LL*(x2-x1+1)*max(0, (pos-1)-y1+1);\n }else{\n if(keep) return 1LL*(y2-y1+1)*max(0, x2-(pos+1)+1);\n else return 1LL*(y2-y1+1)*max(0, (pos-1)-x1+1);\n }\n };\n\n for(int pos=y1+1; pos<=y2-1; pos++){\n for(int keep=0; keep<2; keep++){\n bool kp=(keep==0);\n int sp=countSafePets(true,pos,kp);\n long long area=safeArea(true,pos,kp);\n long long key=1LL*sp*1000000000LL - area;\n if(key> petCnt(H+1, vector(W+1,0));\n vector> humanCnt(H+1, vector(W+1,0));\n for(auto &p: pets) petCnt[p.x][p.y]++;\n for(auto &h: humans) humanCnt[h.x][h.y]++;\n\n // BFS per human for planning\n vector bfsRes(M);\n for(int i=0;i act(M,'.');\n set> plannedWalls;\n set> plannedMoveDest;\n\n auto planWallAt = [&](int i,int wx,int wy)->bool{\n int x=humans[i].x, y=humans[i].y;\n int k=-1;\n for(int kk=0; kk<4; kk++) if(x+dx4[kk]==wx && y+dy4[kk]==wy){ k=kk; break; }\n if(k==-1) return false;\n if(plannedMoveDest.count({wx,wy})) return false;\n if(!placeableWall(wx,wy,petCnt,humanCnt)) return false;\n plannedWalls.insert({wx,wy});\n act[i]=dirWall[k];\n return true;\n };\n\n auto planMoveToward = [&](int i,int tx,int ty)->void{\n auto &b=bfsRes[i];\n if(!in_grid(tx,ty)) return;\n if(b.dist[tx][ty] >= (int)1e9) return;\n char fd=b.first[tx][ty];\n if(fd=='.' || fd=='?') return;\n int k=-1;\n for(int kk=0; kk<4; kk++) if(dirMove[kk]==fd){ k=kk; break; }\n if(k==-1) return;\n int nx=humans[i].x+dx4[k], ny=humans[i].y+dy4[k];\n if(!in_grid(nx,ny) || wall[nx][ny]) return;\n if(plannedWalls.count({nx,ny})) return;\n plannedMoveDest.insert({nx,ny});\n act[i]=fd;\n };\n\n auto buildCandidates = [&](int i, const vector>& targets, int K)->vector{\n const int INF=1e9;\n auto &b=bfsRes[i];\n vector cands;\n cands.reserve(K*3);\n for(auto &cell: targets){\n int wx=cell.first, wy=cell.second;\n if(wall[wx][wy]) continue;\n for(int k=0;k<4;k++){\n int px=wx+dx4[k], py=wy+dy4[k];\n if(!in_grid(px,py) || wall[px][py]) continue;\n int d=b.dist[px][py];\n if(d>=INF) continue;\n int stall = placeableWall(wx,wy,petCnt,humanCnt) ? 0 : 8;\n int val = d + stall;\n cands.push_back({val, px, py, wx, wy});\n }\n }\n sort(cands.begin(), cands.end(), [](const TaskCand& a,const TaskCand& b){\n if(a.val!=b.val) return a.valK) cands.resize(K);\n return cands;\n };\n\n auto assignAndActBuild = [&](const vector>& targets){\n const int K=10;\n vector> allC(M);\n vector> order;\n order.reserve(M);\n for(int i=0;i> reservedWall;\n for(auto [_,i]: order){\n if(act[i] != '.') continue;\n if(allC[i].empty()) continue;\n int chosen=-1;\n for(int j=0;j<(int)allC[i].size();j++){\n auto &c=allC[i][j];\n if(!reservedWall.count({c.wallX,c.wallY})){\n chosen=j; break;\n }\n }\n if(chosen==-1) continue;\n auto c=allC[i][chosen];\n reservedWall.insert({c.wallX,c.wallY});\n if(humans[i].x==c.workX && humans[i].y==c.workY){\n (void)planWallAt(i,c.wallX,c.wallY);\n }else{\n planMoveToward(i,c.workX,c.workY);\n }\n }\n };\n\n // ---- transitions ----\n if(phase==OUTER_BUILD){\n if(outerCompleteExceptGate() && allHumansInsideInterior()){\n phase = SEAL;\n }\n } else if(phase==SEAL){\n if(sealed){\n bool trapped=false;\n for(auto &p: pets) if(inInterior(p.x,p.y)) { trapped=true; break; }\n if(!trapped) phase = DONE;\n else{\n prisonPlanned=false;\n cutPlanned=false;\n if(planPrisonOnce(petCnt)) phase = PRISON;\n else phase = CUT;\n }\n }\n }\n\n // ---- actions ----\n if(phase==DONE){\n // do nothing\n }\n else if(phase==OUTER_BUILD){\n // Outside humans go to inner-door, inside humans build outer ring.\n for(int i=0;ibool{\n if(!inInterior(x,y)) return false;\n return !(px1<=x && x<=px2 && py1<=y && y<=py2);\n };\n if(!outsidePrisonCell(tx,ty)){\n vector> cand = {\n {x1+1,y1+1},{x1+1,y2-1},{x2-1,y1+1},{x2-1,y2-1},\n {x1+2,(y1+y2)/2},{x2-2,(y1+y2)/2}\n };\n for(auto [cx,cy]: cand) if(outsidePrisonCell(cx,cy)) { tx=cx; ty=cy; break; }\n }\n\n for(int i=0;ibool{\n if(cutVertical){\n if(keepRightOrDown) return y >= cutPos+1;\n else return y <= cutPos-1;\n }else{\n if(keepRightOrDown) return x >= cutPos+1;\n else return x <= cutPos-1;\n }\n };\n int tx=(x1+x2)/2, ty=(y1+y2)/2;\n if(cutVertical){\n ty = keepRightOrDown ? (cutPos+1+y2)/2 : (y1+cutPos-1)/2;\n }else{\n tx = keepRightOrDown ? (cutPos+1+x2)/2 : (x1+cutPos-1)/2;\n }\n tx=min(max(tx,x1),x2);\n ty=min(max(ty,y1),y2);\n\n for(int i=0;i mv(N);\n for(int i=0;i> mv[i])) return 0;\n }\n // Apply pet moves\n for(int i=0;i\nusing namespace std;\n\nstatic constexpr int H = 20, W = 20, N = 400, LMAX = 200;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int l, int r) { return l + (int)(next_u64() % (uint64_t)(r - l + 1)); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto time_start = chrono::high_resolution_clock::now();\n auto elapsed_sec = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - time_start).count();\n };\n\n int si, sj, ti, tj;\n double p_d;\n cin >> si >> sj >> ti >> tj >> p_d;\n\n vector h(H), v(H - 1);\n for (int i = 0; i < H; i++) cin >> h[i];\n for (int i = 0; i < H - 1; i++) cin >> v[i];\n\n auto id = [&](int i, int j) { return i * W + j; };\n int s = id(si, sj), t = id(ti, tj);\n\n float p = (float)p_d;\n float q = 1.0f - p;\n\n // mv[state][dir] dir: 0 U,1 D,2 L,3 R\n int mv[N][4];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) {\n int cur = id(i, j);\n mv[cur][0] = (i == 0 || v[i - 1][j] == '1') ? cur : id(i - 1, j);\n mv[cur][1] = (i == H - 1 || v[i][j] == '1') ? cur : id(i + 1, j);\n mv[cur][2] = (j == 0 || h[i][j - 1] == '1') ? cur : id(i, j - 1);\n mv[cur][3] = (j == W - 1 || h[i][j] == '1') ? cur : id(i, j + 1);\n }\n\n // Optimistic closed-loop DP G[turn][x]\n static float G[LMAX + 2][N];\n for (int x = 0; x < N; x++) G[LMAX + 1][x] = 0.0f;\n for (int turn = LMAX; turn >= 1; --turn) {\n float reward = (float)(401 - turn);\n for (int x = 0; x < N; x++) {\n if (x == t) { G[turn][x] = 0.0f; continue; }\n float stay_part = p * G[turn + 1][x];\n float best = 0.0f;\n for (int a = 0; a < 4; a++) {\n int y = mv[x][a];\n float val = stay_part + (y == t ? q * reward : q * G[turn + 1][y]);\n best = max(best, val);\n }\n G[turn][x] = best;\n }\n G[turn][t] = 0.0f;\n }\n\n // One-step open-loop lookahead Q[turn][a][x]\n static float Q[LMAX + 1][4][N];\n for (int turn = 1; turn <= LMAX; ++turn) {\n float reward = (float)(401 - turn);\n for (int x = 0; x < N; x++) {\n if (x == t) {\n for (int a = 0; a < 4; a++) Q[turn][a][x] = 0.0f;\n continue;\n }\n float stay_part = p * G[turn + 1][x];\n for (int a = 0; a < 4; a++) {\n int y = mv[x][a];\n Q[turn][a][x] = stay_part + (y == t ? q * reward : q * G[turn + 1][y]);\n }\n }\n }\n\n auto heuristic_openloop_1step = [&](const array& prob, int turn) -> float {\n if (turn > LMAX) return 0.0f;\n float best = 0.0f;\n for (int a = 0; a < 4; a++) {\n const float* qax = Q[turn][a];\n float sum = 0.0f;\n for (int x = 0; x < N; x++) sum += prob[x] * qax[x];\n best = max(best, sum);\n }\n return best;\n };\n\n struct Node {\n int len = 0;\n float score = 0.0f;\n float key = 0.0f;\n array path{};\n array prob{};\n };\n\n auto compute_key = [&](const Node& nd) -> float {\n return nd.score + heuristic_openloop_1step(nd.prob, nd.len + 1);\n };\n\n auto extend = [&](const Node& cur, int a) -> Node {\n static const char dc[4] = {'U','D','L','R'};\n Node nxt;\n nxt.len = cur.len + 1;\n nxt.score = cur.score;\n nxt.path = cur.path;\n nxt.path[cur.len] = dc[a];\n nxt.prob.fill(0.0f);\n\n float reach = 0.0f;\n for (int x = 0; x < N; x++) {\n float px = cur.prob[x];\n if (px == 0.0f) continue;\n nxt.prob[x] += px * p;\n int y = mv[x][a];\n float mvprob = px * q;\n if (y == t) reach += mvprob;\n else nxt.prob[y] += mvprob;\n }\n nxt.prob[t] = 0.0f;\n nxt.score += reach * (float)(401 - nxt.len);\n nxt.key = compute_key(nxt);\n return nxt;\n };\n\n auto node_to_string = [&](const Node& nd) -> string {\n string out;\n out.reserve(nd.len);\n for (int i = 0; i < nd.len; i++) out.push_back(nd.path[i]);\n return out;\n };\n\n // ---- Exact forward evaluation for action vector A ----\n static float Pdist[LMAX + 1][N];\n static double prefixScore[LMAX + 1];\n\n auto forward_eval = [&](const vector& A) -> double {\n for (int x = 0; x < N; x++) Pdist[0][x] = 0.0f;\n Pdist[0][s] = 1.0f;\n Pdist[0][t] = 0.0f;\n prefixScore[0] = 0.0;\n\n for (int step = 0; step < LMAX; step++) {\n int a = A[step];\n float nxtP[N]; for (int x = 0; x < N; x++) nxtP[x] = 0.0f;\n double reach = 0.0;\n for (int x = 0; x < N; x++) {\n float px = Pdist[step][x];\n if (px == 0.0f) continue;\n nxtP[x] += px * p;\n int y = mv[x][a];\n double mvprob = (double)px * (double)q;\n if (y == t) reach += mvprob;\n else nxtP[y] += (float)mvprob;\n }\n nxtP[t] = 0.0f;\n prefixScore[step + 1] = prefixScore[step] + reach * (401.0 - (step + 1));\n for (int x = 0; x < N; x++) Pdist[step + 1][x] = nxtP[x];\n }\n return prefixScore[LMAX];\n };\n\n // 1-step right-to-left pass\n auto right_to_left_pass1 = [&](vector& A) -> double {\n static float Vnext[N], Vcur[N];\n for (int x = 0; x < N; x++) Vnext[x] = 0.0f;\n\n double total_at_0 = 0.0;\n for (int pos = LMAX - 1; pos >= 0; --pos) {\n float reward = (float)(401 - (pos + 1));\n int bestA = A[pos];\n double bestTotal = -1e100;\n\n for (int a = 0; a < 4; a++) {\n double sum = 0.0;\n for (int x = 0; x < N; x++) {\n float px = Pdist[pos][x];\n if (px == 0.0f) continue;\n int y = mv[x][a];\n float val = p * Vnext[x] + q * (y == t ? reward : Vnext[y]);\n sum += (double)px * (double)val;\n }\n double tot = prefixScore[pos] + sum;\n if (tot > bestTotal) { bestTotal = tot; bestA = a; }\n }\n A[pos] = bestA;\n\n for (int x = 0; x < N; x++) {\n if (x == t) { Vcur[x] = 0.0f; continue; }\n int y = mv[x][bestA];\n Vcur[x] = p * Vnext[x] + q * (y == t ? reward : Vnext[y]);\n }\n for (int x = 0; x < N; x++) Vnext[x] = Vcur[x];\n\n if (pos == 0) total_at_0 = bestTotal;\n }\n return total_at_0;\n };\n\n // 2-step right-to-left pass: optimize (A[i], A[i+1]) jointly\n auto right_to_left_pass2 = [&](vector& A) -> double {\n static float V2[N], S1[N], sec[N];\n for (int x = 0; x < N; x++) V2[x] = 0.0f;\n\n double total_at_0 = 0.0;\n for (int i = LMAX - 2; i >= 0; --i) {\n float r1 = (float)(401 - (i + 1));\n float r2 = (float)(401 - (i + 2));\n\n int bestA = A[i], bestB = A[i + 1];\n double bestTotal = -1e100;\n\n for (int b = 0; b < 4; b++) {\n for (int z = 0; z < N; z++) {\n if (z == t) { sec[z] = 0.0f; continue; }\n int w = mv[z][b];\n sec[z] = p * V2[z] + q * (w == t ? r2 : V2[w]);\n }\n for (int a = 0; a < 4; a++) {\n double sum = 0.0;\n for (int x = 0; x < N; x++) {\n float px = Pdist[i][x];\n if (px == 0.0f) continue;\n int y = mv[x][a];\n float val = p * sec[x] + q * (y == t ? r1 : sec[y]);\n sum += (double)px * (double)val;\n }\n double tot = prefixScore[i] + sum;\n if (tot > bestTotal) { bestTotal = tot; bestA = a; bestB = b; }\n }\n }\n\n A[i] = bestA;\n A[i + 1] = bestB;\n\n for (int z = 0; z < N; z++) {\n if (z == t) { S1[z] = 0.0f; continue; }\n int w = mv[z][bestB];\n S1[z] = p * V2[z] + q * (w == t ? r2 : V2[w]);\n }\n for (int z = 0; z < N; z++) V2[z] = S1[z];\n\n if (i == 0) total_at_0 = bestTotal;\n }\n return total_at_0;\n };\n\n auto do_coordinate = [&](vector& A, double& score, int maxIters, double timeLimit) {\n for (int it = 0; it < maxIters; it++) {\n if (elapsed_sec() >= timeLimit) break;\n\n forward_eval(A);\n double sc2 = right_to_left_pass2(A);\n if (sc2 > score + 1e-10) { score = sc2; continue; }\n\n forward_eval(A);\n double sc1 = right_to_left_pass1(A);\n if (sc1 > score + 1e-10) { score = sc1; continue; }\n\n break;\n }\n };\n\n auto greedy_complete_to_200 = [&](Node nd) -> Node {\n while (nd.len < LMAX) {\n int turn = nd.len + 1;\n int besta = 0;\n float bestv = -1e30f;\n for (int a = 0; a < 4; a++) {\n const float* qax = Q[turn][a];\n float sum = 0.0f;\n for (int x = 0; x < N; x++) sum += nd.prob[x] * qax[x];\n if (sum > bestv) { bestv = sum; besta = a; }\n }\n nd = extend(nd, besta);\n }\n return nd;\n };\n\n auto str_to_A = [&](const string& s) -> vector {\n vector A(LMAX, 1);\n for (int i = 0; i < LMAX; i++) {\n char c = s[i];\n if (c == 'U') A[i] = 0;\n else if (c == 'D') A[i] = 1;\n else if (c == 'L') A[i] = 2;\n else A[i] = 3;\n }\n return A;\n };\n auto A_to_str = [&](const vector& A) -> string {\n static const char dc[4] = {'U','D','L','R'};\n string s; s.resize(LMAX);\n for (int i = 0; i < LMAX; i++) s[i] = dc[A[i]];\n return s;\n };\n\n // ---- Beam search ----\n const int BEAM_WIDTH = 440;\n\n Node init;\n init.len = 0;\n init.score = 0.0f;\n init.prob.fill(0.0f);\n init.prob[s] = 1.0f;\n init.prob[t] = 0.0f;\n init.key = compute_key(init);\n\n vector beam;\n beam.reserve(BEAM_WIDTH);\n beam.push_back(init);\n\n Node best_any = init;\n vector last_beam;\n\n for (int step = 0; step < LMAX; step++) {\n vector cand;\n cand.reserve(beam.size() * 4);\n for (const auto& nd : beam) {\n for (int a = 0; a < 4; a++) {\n Node child = extend(nd, a);\n if (child.score > best_any.score) best_any = child;\n cand.push_back(std::move(child));\n }\n }\n int take = min((int)cand.size(), BEAM_WIDTH);\n nth_element(cand.begin(), cand.begin() + take, cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n cand.resize(take);\n sort(cand.begin(), cand.end(),\n [](const Node& A, const Node& B){ return A.key > B.key; });\n beam.swap(cand);\n if (step == LMAX - 1) last_beam = beam;\n }\n\n // ---- Choose best exact candidate ----\n vector candStr;\n int TAKE = min(60, (int)last_beam.size());\n candStr.reserve(TAKE + 2);\n for (int i = 0; i < TAKE; i++) {\n string s0 = node_to_string(last_beam[i]);\n if ((int)s0.size() < LMAX) s0.append(LMAX - s0.size(), 'D');\n s0.resize(LMAX);\n candStr.push_back(s0);\n }\n {\n Node full = greedy_complete_to_200(best_any);\n string s0 = node_to_string(full);\n if ((int)s0.size() < LMAX) s0.append(LMAX - s0.size(), 'D');\n s0.resize(LMAX);\n candStr.push_back(s0);\n }\n sort(candStr.begin(), candStr.end());\n candStr.erase(unique(candStr.begin(), candStr.end()), candStr.end());\n\n double bestScore = -1e100;\n vector bestA;\n for (auto &ss : candStr) {\n auto A = str_to_A(ss);\n double sc = forward_eval(A);\n if (sc > bestScore) { bestScore = sc; bestA = std::move(A); }\n }\n\n vector curA = bestA;\n double curScore = bestScore;\n\n const double TIME_LIMIT = 1.95;\n\n // Main optimization\n do_coordinate(curA, curScore, 140, TIME_LIMIT);\n if (curScore > bestScore) { bestScore = curScore; bestA = curA; }\n\n // Kick operators: randomize OR rotate (structure-preserving)\n auto rot = [&](int a) { return (a + 1) & 3; }; // U->D? actually 0..3, but any rotation is ok\n // Better: U(0)->R(3)->D(1)->L(2)->U : define mapping\n auto rotURDL = [&](int a)->int{\n // 0 U,1 D,2 L,3 R\n if (a==0) return 3;\n if (a==3) return 1;\n if (a==1) return 2;\n return 0; // L->U\n };\n\n XorShift rng;\n auto kick = [&](vector& A) {\n int pos = rng.next_int(0, LMAX - 1);\n int len = rng.next_int(4, 22);\n int end = min(LMAX, pos + len);\n if (rng.next_u64() & 1ULL) {\n // randomize\n for (int i = pos; i < end; i++) A[i] = rng.next_int(0, 3);\n } else {\n // rotate\n for (int i = pos; i < end; i++) A[i] = rotURDL(A[i]);\n }\n };\n\n while (elapsed_sec() < TIME_LIMIT) {\n vector savedA = curA;\n double savedScore = curScore;\n\n kick(curA);\n curScore = forward_eval(curA);\n do_coordinate(curA, curScore, 35, TIME_LIMIT);\n\n if (curScore > bestScore) { bestScore = curScore; bestA = curA; }\n\n if (curScore + 1e-10 < savedScore) {\n curA = std::move(savedA);\n curScore = savedScore;\n }\n }\n\n cout << A_to_str(bestA) << \"\\n\";\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nstatic const int N = 30;\nstatic const int CELLS = N * N;\nstatic const int PORTS = CELLS * 4;\n\n// Directions: 0:left, 1:up, 2:right, 3:down\nstatic const int dj[4] = {-1, 0, 1, 0};\nstatic const int di[4] = {0, -1, 0, 1};\nstatic const int opp[4] = {2, 3, 0, 1};\n\nstatic const int to_table[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\n// rotate CCW by 90 degrees mapping\nstatic const int rot1[8] = {1,2,3,0, 5,4, 7,6};\n\nstruct XorShift {\n uint64_t x;\n explicit XorShift(uint64_t seed=88172645463325252ull) : x(seed) {}\n inline uint32_t nextU32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n inline int nextInt(int lo, int hi) { // inclusive\n return lo + (int)(nextU32() % (uint32_t)(hi - lo + 1));\n }\n inline double nextDouble() { // [0,1)\n return (nextU32() + 0.5) / 4294967296.0;\n }\n};\n\nstruct Timer {\n chrono::high_resolution_clock::time_point st;\n Timer() : st(chrono::high_resolution_clock::now()) {}\n double elapsedSec() const {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nstruct EvalResult {\n int L1=0, L2=0;\n int loopsCnt=0;\n int score=0;\n\n int matchedBorders=0;\n int boundaryPorts=0;\n int unmatchedPorts=0;\n\n int sumLen=0;\n int sumLen2=0;\n\n int openSizeSum=0; // sum compSize over open components\n int openMiss2Sum=0; // sum (miss^2) over open components\n\n int aux=0;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector init(CELLS);\n for (int i = 0; i < N; i++) {\n string s; cin >> s;\n for (int j = 0; j < N; j++) init[i*N + j] = s[j] - '0';\n }\n\n // Precompute state after r rotations\n uint8_t stateAfterRot[8][4];\n for (int t = 0; t < 8; t++) {\n int cur = t;\n for (int r = 0; r < 4; r++) {\n stateAfterRot[t][r] = (uint8_t)cur;\n cur = rot1[cur];\n }\n }\n\n bool hasPort[8][4];\n int partner[8][4];\n for (int t = 0; t < 8; t++) {\n for (int d = 0; d < 4; d++) {\n int d2 = to_table[t][d];\n hasPort[t][d] = (d2 != -1);\n partner[t][d] = d2;\n }\n }\n\n // buffers for evaluation\n static uint8_t existPort[PORTS];\n static int16_t ext[PORTS];\n static uint16_t visStamp[PORTS];\n uint16_t curStamp = 1;\n static int stk[PORTS];\n\n auto evaluate = [&](const vector& state) -> EvalResult {\n EvalResult res;\n\n // existPort, boundaryPorts\n res.boundaryPorts = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int cell = i*N + j;\n int t = state[cell];\n int base = cell*4;\n for (int s = 0; s < 4; s++) existPort[base+s] = hasPort[t][s] ? 1 : 0;\n\n if (j == 0 && hasPort[t][0]) res.boundaryPorts++;\n if (i == 0 && hasPort[t][1]) res.boundaryPorts++;\n if (j == N-1 && hasPort[t][2]) res.boundaryPorts++;\n if (i == N-1 && hasPort[t][3]) res.boundaryPorts++;\n }\n\n // build ext and matchedBorders\n for (int p = 0; p < PORTS; p++) ext[p] = -1;\n res.matchedBorders = 0;\n\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int cell = i*N + j;\n int base = cell*4;\n\n if (j+1 < N) {\n int cellR = i*N + (j+1);\n int a = base + 2;\n int b = cellR*4 + 0;\n if (existPort[a] && existPort[b]) {\n ext[a] = (int16_t)b;\n ext[b] = (int16_t)a;\n res.matchedBorders++;\n }\n }\n if (i+1 < N) {\n int cellD = (i+1)*N + j;\n int a = base + 3;\n int b = cellD*4 + 1;\n if (existPort[a] && existPort[b]) {\n ext[a] = (int16_t)b;\n ext[b] = (int16_t)a;\n res.matchedBorders++;\n }\n }\n }\n\n // unmatchedPorts\n res.unmatchedPorts = 0;\n for (int p = 0; p < PORTS; p++) if (existPort[p] && ext[p] == -1) res.unmatchedPorts++;\n\n // traverse port-components\n if (++curStamp == 0) { // extremely unlikely; reset\n memset(visStamp, 0, sizeof(visStamp));\n curStamp = 1;\n }\n\n int best1 = 0, best2 = 0;\n\n for (int p = 0; p < PORTS; p++) {\n if (!existPort[p] || visStamp[p] == curStamp) continue;\n\n int compSize = 0;\n int miss = 0;\n\n int sp = 0;\n stk[sp++] = p;\n visStamp[p] = curStamp;\n\n while (sp) {\n int v = stk[--sp];\n compSize++;\n\n if (ext[v] == -1) miss++;\n\n int cell = v / 4;\n int side = v % 4;\n int t = state[cell];\n\n int u_int = cell*4 + partner[t][side];\n if (existPort[u_int] && visStamp[u_int] != curStamp) {\n visStamp[u_int] = curStamp;\n stk[sp++] = u_int;\n }\n int u_ext = ext[v];\n if (u_ext != -1 && visStamp[u_ext] != curStamp) {\n visStamp[u_ext] = curStamp;\n stk[sp++] = u_ext;\n }\n }\n\n if (miss == 0) {\n int len = compSize / 2;\n res.loopsCnt++;\n res.sumLen += len;\n res.sumLen2 += len * len;\n if (len > best1) { best2 = best1; best1 = len; }\n else if (len > best2) { best2 = len; }\n } else {\n res.openSizeSum += compSize;\n res.openMiss2Sum += miss * miss;\n }\n }\n\n res.L1 = best1;\n res.L2 = best2;\n res.score = (res.loopsCnt >= 2 ? best1 * best2 : 0);\n\n // Auxiliary objective (tuned to push closing + merging)\n long long aux = 0;\n aux += 500000LL * min(res.loopsCnt, 2); // must get 2 loops\n aux += 30000LL * res.score; // then maximize true score\n aux += 3000LL * res.L2 + 800LL * res.L1; // stabilize improving 2nd loop\n aux += 120LL * res.sumLen2; // prefer longer cycles\n aux += 25LL * res.matchedBorders; // encourage connections\n aux -= 20LL * res.unmatchedPorts; // close open ends\n aux -= 120LL * res.boundaryPorts; // avoid boundary leaks\n aux += 2LL * res.openSizeSum; // keep big components\n aux -= 10LL * res.openMiss2Sum; // but strongly reduce missing ends\n\n if (aux > INT_MAX) aux = INT_MAX;\n if (aux < INT_MIN) aux = INT_MIN;\n res.aux = (int)aux;\n return res;\n };\n\n Timer timer;\n double TL = 1.90;\n\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n // local best rotation proposal for a cell (fast heuristic move)\n auto bestLocalRotation = [&](int cell, const vector& state) -> uint8_t {\n int i = cell / N, j = cell % N;\n\n // weights for local scoring\n const int W_MATCH = 6;\n const int W_MISM = 7;\n const int W_BOUND = 10;\n\n int bestVal = INT_MIN;\n uint8_t bestR = 0;\n\n for (int r = 0; r < 4; r++) {\n int t = stateAfterRot[init[cell]][r];\n int val = 0;\n\n for (int s = 0; s < 4; s++) {\n bool p = hasPort[t][s];\n int ni = i + di[s], nj = j + dj[s];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) {\n if (p) val -= W_BOUND;\n } else {\n int nb = ni*N + nj;\n bool q = hasPort[state[nb]][opp[s]];\n if (p && q) val += W_MATCH;\n else if (p ^ q) val -= W_MISM;\n }\n }\n\n // small bias to avoid boundary ports even if neighbor absent\n if (val > bestVal) {\n bestVal = val;\n bestR = (uint8_t)r;\n }\n }\n return bestR;\n };\n\n // Global best tracking\n vector globalBestRot(CELLS, 0);\n vector globalBestState(CELLS, 0);\n int globalBestScore = 0;\n\n auto initRandomSolution = [&](vector& rot, vector& state) {\n rot.resize(CELLS);\n state.resize(CELLS);\n for (int c = 0; c < CELLS; c++) {\n rot[c] = (uint8_t)rng.nextInt(0, 3);\n state[c] = stateAfterRot[init[c]][rot[c]];\n }\n };\n\n auto runSA = [&](vector& rot, vector& state, double timeSlice) {\n double startT = timer.elapsedSec();\n EvalResult cur = evaluate(state);\n\n // SA temps\n const double T0 = 350000.0;\n const double T1 = 30.0;\n\n while (timer.elapsedSec() - startT < timeSlice && timer.elapsedSec() < TL) {\n double tt = (timer.elapsedSec() - startT) / max(1e-9, timeSlice);\n double Temp = T0 * (1.0 - tt) + T1 * tt;\n\n int cell = rng.nextInt(0, CELLS - 1);\n\n uint8_t oldr = rot[cell];\n uint8_t olds = state[cell];\n\n uint8_t newr;\n uint32_t rv = rng.nextU32();\n\n // mix moves: random / local-best\n if ((rv & 15) == 0) {\n newr = bestLocalRotation(cell, state);\n } else {\n // random different rotation\n int add = (int)(rv % 3) + 1;\n newr = (uint8_t)((oldr + add) & 3);\n }\n if (newr == oldr) continue;\n\n rot[cell] = newr;\n state[cell] = stateAfterRot[init[cell]][newr];\n\n EvalResult nxt = evaluate(state);\n int delta = nxt.aux - cur.aux;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / Temp);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (accept) {\n cur = nxt;\n if (cur.score > globalBestScore) {\n globalBestScore = cur.score;\n globalBestRot = rot;\n globalBestState = state;\n }\n } else {\n rot[cell] = oldr;\n state[cell] = olds;\n }\n }\n };\n\n // Phase 1: multi-start exploration\n const double phase1End = 0.85; // seconds\n while (timer.elapsedSec() < min(TL, phase1End)) {\n vector rot, state;\n initRandomSolution(rot, state);\n runSA(rot, state, 0.17); // short runs\n }\n\n // If somehow no best stored (very unlikely), set from random\n if (globalBestState[0] == 0 && globalBestRot[0] == 0) {\n initRandomSolution(globalBestRot, globalBestState);\n globalBestScore = evaluate(globalBestState).score;\n }\n\n // Phase 2: long refinement from the best found\n {\n vector rot = globalBestRot;\n vector state = globalBestState;\n double remaining = TL - timer.elapsedSec();\n runSA(rot, state, max(0.0, remaining));\n }\n\n // Output\n string out(CELLS, '0');\n for (int c = 0; c < CELLS; c++) out[c] = char('0' + globalBestRot[c]);\n cout << out << \"\\n\";\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int n) { return (int)(next_u64() % (uint64_t)n); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n};\n\nstatic inline int hexval(char c) {\n if ('0' <= c && c <= '9') return c - '0';\n return 10 + (c - 'a');\n}\n\nstatic const char DIRCH[4] = {'U','D','L','R'};\nstatic const int dr[4] = {-1, +1, 0, 0};\nstatic const int dc[4] = {0, 0, -1, +1};\n\nstatic inline int revdir(int d){\n if(d==0) return 1;\n if(d==1) return 0;\n if(d==2) return 3;\n return 2;\n}\n\nstatic inline int dsu_find(int a, int parent[]) {\n while (parent[a] != a) {\n parent[a] = parent[parent[a]];\n a = parent[a];\n }\n return a;\n}\nstatic inline void dsu_unite(int a, int b, int parent[], uint8_t rnk[]) {\n a = dsu_find(a, parent);\n b = dsu_find(b, parent);\n if (a == b) return;\n if (rnk[a] < rnk[b]) swap(a, b);\n parent[b] = a;\n if (rnk[a] == rnk[b]) rnk[a]++;\n}\n\nstruct EdgeInfo {\n uint8_t u, v;\n uint8_t needU, needV;\n};\nstruct Precomp {\n int N=0, NN=0;\n vector edges;\n};\n\nstruct Eval {\n int maxTree = 0;\n int maxComp = 0;\n int maxTreeable = 0;\n int matchEdges = 0;\n int cycleExcess = 0;\n int scalar = 0;\n};\n\nEval evaluate_board(const array& a, const Precomp& P) {\n const int NN = P.NN;\n\n int parent[100];\n uint8_t rnk[100];\n for(int i=0;i v-1) excess = e - (v-1);\n cycleExcess += excess;\n maxTreeable = max(maxTreeable, v - excess);\n if(excess == 0) maxTree = max(maxTree, v);\n }\n\n int scalar = maxTree * 1000000\n + maxTreeable * 7000\n + maxComp * 1200\n + matchEdges * 8\n - cycleExcess * 24000;\n\n return Eval{maxTree, maxComp, maxTreeable, matchEdges, cycleExcess, scalar};\n}\n\nstatic inline bool apply_move(array& a, int N, int &er, int &ec, int d){\n int nr = er + dr[d], nc = ec + dc[d];\n if(nr<0||nr>=N||nc<0||nc>=N) return false;\n int u = er*N + ec;\n int v = nr*N + nc;\n swap(a[u], a[v]);\n er = nr; ec = nc;\n return true;\n}\n\n// Prefer full over non-full; among full prefer smaller K.\n// Otherwise use metrics, and as last tie-break, prefer smaller K (keeps remaining budget).\nstatic inline bool better_solution(const Eval& A, int KA, const Eval& B, int KB, int targetFull){\n bool Afull = (A.maxTree == targetFull);\n bool Bfull = (B.maxTree == targetFull);\n if(Afull != Bfull) return Afull;\n if(Afull && Bfull) return KA < KB;\n\n if(A.maxTree != B.maxTree) return A.maxTree > B.maxTree;\n if(A.maxTreeable != B.maxTreeable) return A.maxTreeable > B.maxTreeable;\n if(A.maxComp != B.maxComp) return A.maxComp > B.maxComp;\n if(A.cycleExcess != B.cycleExcess) return A.cycleExcess < B.cycleExcess;\n if(A.matchEdges != B.matchEdges) return A.matchEdges > B.matchEdges;\n return KA < KB;\n}\n\nstruct State {\n array a;\n int er=0, ec=0;\n int lastDir=-1;\n int scalar=0;\n Eval ev;\n string path;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T;\n cin >> N >> T;\n const int NN = N*N;\n const int targetFull = NN-1;\n\n array init{};\n int er=-1, ec=-1;\n for(int i=0;i> s;\n for(int j=0;j(\n chrono::steady_clock::now()-start).count();\n };\n const double TIME_LIMIT_MS = 2850.0;\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n seed ^= (uint64_t)(N*10007 + T*1000003);\n XorShift64 rng(seed);\n\n // Global best (answer + corresponding state)\n string bestAns = \"\";\n Eval bestEv = evaluate_board(init, P);\n int bestK = 0;\n array bestBoard = init;\n int bestEr = er, bestEc = ec, bestLastDir = -1;\n\n if(bestEv.maxTree == targetFull){\n cout << \"\\n\";\n return 0;\n }\n\n auto update_best = [&](const Eval& curE, const string& curMoves,\n const array& curBoard, int curEr, int curEc, int curLastDir){\n int curK = (int)curMoves.size();\n if(better_solution(curE, curK, bestEv, bestK, targetFull)){\n bestEv = curE;\n bestK = curK;\n bestAns = curMoves;\n bestBoard = curBoard;\n bestEr = curEr;\n bestEc = curEc;\n bestLastDir = curLastDir;\n }\n };\n\n // ----------------------------\n // Beam search (seed generation)\n // ----------------------------\n int beamWidth = (N <= 7 ? 600 : 450);\n int beamDepth = min(240, max(90, T/7));\n double beamTimeFrac = 0.18; // less beam; more time for restarts\n\n vector cur, nxt;\n cur.reserve(beamWidth);\n nxt.reserve(beamWidth*4);\n\n State s0;\n s0.a = init; s0.er = er; s0.ec = ec; s0.lastDir = -1;\n s0.ev = bestEv; s0.scalar = bestEv.scalar;\n s0.path.clear();\n cur.push_back(s0);\n\n for(int depth=0; depth beamWidth){\n nth_element(nxt.begin(), nxt.begin()+beamWidth, nxt.end(),\n [](const State& a, const State& b){ return a.scalar > b.scalar; });\n nxt.resize(beamWidth);\n }\n sort(nxt.begin(), nxt.end(), [](const State& a, const State& b){ return a.scalar > b.scalar; });\n cur.swap(nxt);\n }\n\n vector seedPool;\n seedPool.reserve(96);\n seedPool.push_back(s0);\n\n int topM = min(16, (int)cur.size());\n for(int i=0;i=N||nc<0||nc>=N) continue;\n if(rs.lastDir!=-1 && d==revdir(rs.lastDir) && rng.next_double() < 0.75) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n int d = cand[rng.next_int(ccnt)];\n apply_move(rs.a, N, rs.er, rs.ec, d);\n rs.lastDir = d;\n rs.path.push_back(DIRCH[d]);\n }\n rs.ev = evaluate_board(rs.a, P);\n rs.scalar = rs.ev.scalar;\n update_best(rs.ev, rs.path, rs.a, rs.er, rs.ec, rs.lastDir);\n seedPool.push_back(std::move(rs));\n }\n\n auto pick_seed_index = [&](){\n // tournament selection size 3 (bias toward good seeds)\n int best = rng.next_int((int)seedPool.size());\n for(int t=0;t<3;t++){\n int j = rng.next_int((int)seedPool.size());\n if(seedPool[j].scalar > seedPool[best].scalar) best = j;\n }\n return best;\n };\n\n const int REV_PENALTY = 2500;\n\n auto SA_segment = [&](const State& st0, int segLen, double temp0, double temp1, double epsBase){\n array a = st0.a;\n int cur_er = st0.er, cur_ec = st0.ec;\n int lastDir = st0.lastDir;\n Eval curE = st0.ev;\n string moves = st0.path;\n\n int remainingTotal = T - (int)moves.size();\n segLen = min(segLen, remainingTotal);\n if(segLen <= 0) return;\n\n // segment-best for stagnation control\n Eval segBestE = curE;\n int segBestK = (int)moves.size();\n array segBestBoard = a;\n int segBestEr = cur_er, segBestEc = cur_ec, segBestLast = lastDir;\n string segBestMoves = moves;\n\n int stagnate = 0;\n\n for(int step=0; step 0\n tnorm = min(1.0, max(0.0, tnorm));\n double eps = epsBase * (0.65 + 0.70 * tnorm);\n eps = min(0.18, max(0.03, eps));\n\n if(stagnate > 900){\n int kickLen = min(30, segLen - step);\n for(int kk=0; kk=N||nc<0||nc>=N) continue;\n if(lastDir!=-1 && d==revdir(lastDir) && rng.next_double() < 0.60) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n int d = cand[rng.next_int(ccnt)];\n apply_move(a, N, cur_er, cur_ec, d);\n moves.push_back(DIRCH[d]);\n lastDir = d;\n }\n curE = evaluate_board(a, P);\n stagnate = 0;\n continue;\n }\n\n int dirs[4], ccnt=0;\n for(int d=0; d<4; d++){\n int nr = cur_er + dr[d], nc = cur_ec + dc[d];\n if(nr<0||nr>=N||nc<0||nc>=N) continue;\n dirs[ccnt++] = d;\n }\n if(ccnt==0) break;\n\n Eval candEv[4];\n int candScalar[4];\n int bestScalar = INT_MIN;\n\n int old_er = cur_er, old_ec = cur_ec;\n for(int k=0;k=N||nc<0||nc>=N) continue;\n if(rs.lastDir!=-1 && d==revdir(rs.lastDir) && rng.next_double() < 0.70) continue;\n cand[ccnt++] = d;\n }\n if(ccnt==0) break;\n int d = cand[rng.next_int(ccnt)];\n apply_move(rs.a, N, rs.er, rs.ec, d);\n rs.lastDir = d;\n rs.path.push_back(DIRCH[d]);\n }\n rs.ev = evaluate_board(rs.a, P);\n rs.scalar = rs.ev.scalar;\n\n int remainingTotal = T - (int)rs.path.size();\n if(remainingTotal <= 0) continue;\n\n int segLen = min(remainingTotal, 220 + rng.next_int(220)); // 220..439\n SA_segment(rs, segLen, 1200.0, 8.0, 0.08);\n if(bestEv.maxTree == targetFull){\n cout << bestAns << \"\\n\";\n return 0;\n }\n }\n\n // Final intensification from best state (low temp)\n if(bestEv.maxTree != targetFull){\n State bst;\n bst.a = bestBoard;\n bst.er = bestEr; bst.ec = bestEc;\n bst.lastDir = bestLastDir;\n bst.ev = bestEv;\n bst.scalar = bestEv.scalar;\n bst.path = bestAns;\n\n int remainingTotal = T - (int)bst.path.size();\n SA_segment(bst, remainingTotal, 850.0, 6.0, 0.05);\n }\n\n if((int)bestAns.size() > T) bestAns.resize(T);\n cout << bestAns << \"\\n\";\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\n\n// ---------- RNG (splitmix64) ----------\nstatic inline uint64_t splitmix64(uint64_t x) {\n x += 0x9e3779b97f4a7c15ULL;\n x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;\n x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;\n return x ^ (x >> 31);\n}\n\nstruct RNG {\n uint64_t s;\n explicit RNG(uint64_t seed=1) : s(seed) {}\n uint64_t next_u64() { return s = splitmix64(s); }\n double next_double() { // [0,1)\n return (next_u64() >> 11) * (1.0 / 9007199254740992.0);\n }\n int next_int(int l, int r) { // inclusive\n return l + (int)(next_u64() % (uint64_t)(r - l + 1));\n }\n double next_double(double l, double r) { return l + (r - l) * next_double(); }\n};\n\n// ---------- Geometry ----------\nstruct Point { int x, y; };\nstruct Line { int64 px, py, qx, qy; };\n\nstatic inline bool is_valid_line(const Line& ln) {\n auto inRange = [&](int64 v){ return -1000000000LL <= v && v <= 1000000000LL; };\n if (!inRange(ln.px) || !inRange(ln.py) || !inRange(ln.qx) || !inRange(ln.qy)) return false;\n if (ln.px == ln.qx && ln.py == ln.qy) return false;\n return true;\n}\n\nstatic inline int side_of(const Line& ln, int x, int y) {\n int64 dx = ln.qx - ln.px;\n int64 dy = ln.qy - ln.py;\n int64 ax = (int64)x - ln.px;\n int64 ay = (int64)y - ln.py;\n __int128 cross = (__int128)dx * ay - (__int128)dy * ax;\n if (cross > 0) return 1;\n if (cross < 0) return -1;\n return 0;\n}\n\nstatic inline uint64_t hash_line(const Line& ln) {\n uint64_t h = 0;\n auto mix = [&](int64 v) {\n h ^= splitmix64((uint64_t)v + 0x9e3779b97f4a7c15ULL + (h<<6) + (h>>2));\n };\n mix(ln.px); mix(ln.py); mix(ln.qx); mix(ln.qy);\n return h;\n}\n\n// squared distance criterion: C^2 <= (A^2+B^2)R^2\nstatic inline bool line_intersects_disk(const Line& ln, long double R) {\n long double x1 = (long double)ln.px, y1 = (long double)ln.py;\n long double x2 = (long double)ln.qx, y2 = (long double)ln.qy;\n long double A = y2 - y1;\n long double B = x1 - x2;\n long double C = -(A * x1 + B * y1);\n long double lhs = C * C;\n long double rhs = (A * A + B * B) * (R * R);\n return lhs < rhs;\n}\n\nstatic Line make_line_from_angle_offset(long double theta, long double offset) {\n // normal n=(cos, sin), direction d=(-sin, cos)\n long double nx = cos(theta), ny = sin(theta);\n long double dx = -sin(theta), dy = cos(theta);\n\n long double x0 = nx * offset;\n long double y0 = ny * offset;\n\n long double L = 20000.0L;\n long double x1 = x0 + dx * L, y1 = y0 + dy * L;\n long double x2 = x0 - dx * L, y2 = y0 - dy * L;\n\n Line ln;\n ln.px = llround(x1); ln.py = llround(y1);\n ln.qx = llround(x2); ln.qy = llround(y2);\n if (ln.px == ln.qx && ln.py == ln.qy) ln.qx += 1;\n return ln;\n}\n\n// ---------- Flat hash table (key->count), timestamp clearing ----------\nstruct FlatHash {\n int cap, mask;\n vector keys;\n vector vals;\n vector vis;\n int stamp = 1;\n vector used;\n\n explicit FlatHash(int capPow2 = 1<<16) { init(capPow2); }\n\n void init(int capPow2) {\n cap = capPow2;\n mask = cap - 1;\n keys.assign(cap, 0);\n vals.assign(cap, 0);\n vis.assign(cap, 0);\n stamp = 1;\n used.reserve(8192);\n }\n\n inline void reset() {\n ++stamp;\n used.clear();\n if (stamp == INT_MAX) {\n fill(vis.begin(), vis.end(), 0);\n stamp = 1;\n }\n }\n\n inline int find_pos(uint64_t k) const {\n uint64_t h = k * 11995408973635179863ULL;\n int pos = (int)(h & (uint64_t)mask);\n while (vis[pos] == stamp && keys[pos] != k) pos = (pos + 1) & mask;\n return pos;\n }\n\n inline void add(uint64_t k) {\n int pos = find_pos(k);\n if (vis[pos] != stamp) {\n vis[pos] = stamp;\n keys[pos] = k;\n vals[pos] = 1;\n used.push_back(pos);\n } else {\n vals[pos]++;\n }\n }\n\n inline int get(uint64_t k) const {\n int pos = find_pos(k);\n if (vis[pos] != stamp) return 0;\n return vals[pos];\n }\n};\n\n// ---------- Scoring ----------\nstruct Score {\n int dist; // maximize\n int overflow; // minimize: sum max(0, b_d-a_d) for d<=10\n int excess; // minimize: sum max(0, size-10) over ALL regions\n int good; // maximize: number of regions with size 1..10\n};\n\nstatic inline bool better(const Score& A, const Score& B) {\n if (A.dist != B.dist) return A.dist > B.dist;\n if (A.overflow != B.overflow) return A.overflow < B.overflow;\n if (A.excess != B.excess) return A.excess < B.excess;\n return A.good > B.good;\n}\n\n// ---------- Solver ----------\nstruct Solver {\n static constexpr long double R = 10000.0L;\n\n int N, K;\n array a{};\n int totalA = 0;\n vector pts;\n\n vector key, tmpKey;\n FlatHash fh;\n\n // per-step derived\n vector largeKeys;\n array bcur{}, rem{};\n Score curScore{0,0,0,0};\n\n // time control\n chrono::steady_clock::time_point start;\n double deadlineSec = 2.75;\n\n Solver(int N_, int K_, const array& a_, vector pts_)\n : N(N_), K(K_), a(a_), pts(std::move(pts_)),\n key(N_,0), tmpKey(N_,0), fh(1<<16) {\n for (int d=1; d<=10; d++) totalA += a[d];\n largeKeys.reserve(8192);\n }\n\n inline double elapsed() const {\n return chrono::duration(chrono::steady_clock::now() - start).count();\n }\n inline bool time_up(double margin=0.0) const {\n return elapsed() > deadlineSec - margin;\n }\n\n static inline void line_masks(const Line& ln, uint64_t &posMask, uint64_t &negMask) {\n uint64_t h = hash_line(ln);\n negMask = splitmix64(h ^ 0x243f6a8885a308d3ULL);\n posMask = splitmix64(h ^ 0x9e3779b97f4a7c15ULL);\n }\n\n Score calc_score_from_keys(const vector& keys) {\n fh.reset();\n for (int i=0;i 10) excess += (sz - 10);\n if (1 <= sz && sz <= 10) { b[sz]++; good++; }\n }\n int dist=0, overflow=0;\n for (int d=1; d<=10; d++) {\n dist += min(a[d], b[d]);\n overflow += max(0, b[d] - a[d]);\n }\n return {dist, overflow, excess, good};\n }\n\n void build_current_info() {\n fh.reset();\n for (int i=0;i 10) {\n largeKeys.push_back(fh.keys[pos]);\n excess += (sz - 10);\n }\n if (1 <= sz && sz <= 10) { bcur[sz]++; good++; }\n }\n\n int dist=0, overflow=0;\n for (int d=1; d<=10; d++) {\n dist += min(a[d], bcur[d]);\n overflow += max(0, bcur[d] - a[d]);\n }\n curScore = {dist, overflow, excess, good};\n\n for (int d=1; d<=10; d++) rem[d] = max(0, a[d] - min(a[d], bcur[d]));\n }\n\n Score score_current() { build_current_info(); return curScore; }\n\n Score eval_add(const Line& ln) {\n uint64_t posMask, negMask;\n line_masks(ln, posMask, negMask);\n\n fh.reset();\n for (int i=0;i 0 ? posMask : negMask);\n fh.add(nk);\n }\n\n int b[11] = {};\n int good=0, excess=0;\n for (int pos : fh.used) {\n int sz = fh.vals[pos];\n if (sz > 10) excess += (sz - 10);\n if (1 <= sz && sz <= 10) { b[sz]++; good++; }\n }\n int dist=0, overflow=0;\n for (int d=1; d<=10; d++) {\n dist += min(a[d], b[d]);\n overflow += max(0, b[d] - a[d]);\n }\n return {dist, overflow, excess, good};\n }\n\n void apply_add(const Line& ln) {\n uint64_t posMask, negMask;\n line_masks(ln, posMask, negMask);\n for (int i=0;i 0 ? posMask : negMask);\n }\n }\n\n int sample_index_with_key(uint64_t k, RNG& rng) const {\n for (int t=0; t<150; t++) {\n int i = rng.next_int(0, N-1);\n if (key[i] == k) return i;\n }\n return rng.next_int(0, N-1);\n }\n\n // weighted by rem[d]*d^2, but if S<=20 prefer splits where both sides <=10\n int pick_target_size_for_region(int S, RNG& rng) const {\n long long sum = 0;\n long long bonusSum = 0;\n bool hasBonus = false;\n\n if (S <= 20) {\n int lo = max(1, S - 10);\n int hi = min(10, S - 1);\n for (int d=lo; d<=hi; d++) {\n if (rem[d] > 0) {\n hasBonus = true;\n bonusSum += 1LL * rem[d] * d * d;\n }\n }\n }\n if (hasBonus) {\n long long r = 1 + (long long)(rng.next_u64() % (uint64_t)bonusSum);\n int lo = max(1, S - 10), hi = min(10, S - 1);\n for (int d=lo; d<=hi; d++) {\n long long w = 1LL * rem[d] * d * d;\n if (w == 0) continue;\n r -= w;\n if (r <= 0) return d;\n }\n }\n\n for (int d=1; d<=10; d++) sum += 1LL * rem[d] * d * d;\n if (sum == 0) return min(10, max(1, S/2));\n long long r = 1 + (long long)(rng.next_u64() % (uint64_t)sum);\n for (int d=1; d<=10; d++) {\n r -= 1LL * rem[d] * d * d;\n if (r <= 0) return d;\n }\n return 5;\n }\n\n long double estimate_major_axis_angle(const vector& idxs) const {\n if ((int)idxs.size() < 6) return nanl(\"\");\n long double mx=0, my=0;\n for (int id : idxs) { mx += pts[id].x; my += pts[id].y; }\n mx /= (long double)idxs.size();\n my /= (long double)idxs.size();\n\n long double a=0, b=0, c=0;\n for (int id : idxs) {\n long double dx = (long double)pts[id].x - mx;\n long double dy = (long double)pts[id].y - my;\n a += dx*dx;\n b += dx*dy;\n c += dy*dy;\n }\n long double phi = 0.5L * atan2l(2*b, a - c);\n if (phi < 0) phi += acosl(-1.0L);\n return phi;\n }\n\n // demand-aware candidate generator\n bool gen_candidate(Line& out, RNG& rng) {\n for (int it=0; it<42; it++) {\n int mode = rng.next_int(0, 99);\n long double theta = rng.next_double(0.0, acosl(-1.0L));\n long double offset = 0;\n\n if (mode < 28) {\n offset = rng.next_double(-0.98*R, 0.98*R);\n } else if (mode < 46) {\n const auto& p = pts[rng.next_int(0, N-1)];\n long double nx = cos(theta), ny = sin(theta);\n long double base = nx * (long double)p.x + ny * (long double)p.y;\n offset = base + rng.next_double(-1200.0, 1200.0);\n offset = max(-0.98L*R, min(0.98L*R, offset));\n } else if (mode < 56) {\n const auto& p = pts[rng.next_int(0, N-1)];\n const auto& q = pts[rng.next_int(0, N-1)];\n long double dx = (long double)q.x - (long double)p.x;\n long double dy = (long double)q.y - (long double)p.y;\n long double len = sqrt(dx*dx + dy*dy);\n if (len < 1e-9) continue;\n long double nx = dx / len, ny = dy / len;\n theta = atan2(ny, nx);\n long double mx = 0.5L * ((long double)p.x + (long double)q.x);\n long double my = 0.5L * ((long double)p.y + (long double)q.y);\n offset = nx * mx + ny * my + rng.next_double(-600.0, 600.0);\n offset = max(-0.98L*R, min(0.98L*R, offset));\n } else {\n if (largeKeys.empty()) continue;\n uint64_t k = largeKeys[rng.next_int(0, (int)largeKeys.size()-1)];\n int S = fh.get(k);\n if (S <= 10) continue;\n\n int tsize = pick_target_size_for_region(S, rng);\n long double frac = (long double)tsize / (long double)S;\n frac = max((long double)1.0L / (long double)S, min((long double)0.92L, frac));\n\n int m = min(80, S);\n vector idxs;\n idxs.reserve(m);\n for (int j=0; j= acosl(-1.0L)) phi -= acosl(-1.0L);\n }\n\n long double nx = cos(phi), ny = sin(phi);\n vector proj;\n proj.reserve(m);\n for (int id : idxs) proj.push_back(nx * (long double)pts[id].x + ny * (long double)pts[id].y);\n\n int qpos = (int)floor(frac * (m - 1));\n nth_element(proj.begin(), proj.begin() + qpos, proj.end());\n long double th = proj[qpos];\n\n offset = th + rng.next_double(-130.0, 130.0);\n theta = phi;\n offset = max(-0.98L*R, min(0.98L*R, offset));\n }\n\n Line ln = make_line_from_angle_offset(theta, offset);\n if (!is_valid_line(ln)) continue;\n if (!line_intersects_disk(ln, R)) continue;\n out = ln;\n return true;\n }\n return false;\n }\n\n bool gen_perturb(const Line& base, Line& out, RNG& rng) {\n long double dx = (long double)base.qx - (long double)base.px;\n long double dy = (long double)base.qy - (long double)base.py;\n long double nx = dy, ny = -dx;\n long double len = hypot(nx, ny);\n if (len < 1e-12) return false;\n nx /= len; ny /= len;\n long double baseOffset = nx * (long double)base.px + ny * (long double)base.py;\n long double theta = atan2(ny, nx);\n if (theta < 0) theta += acosl(-1.0L);\n\n theta += rng.next_double(-0.10, 0.10);\n if (theta < 0) theta += acosl(-1.0L);\n if (theta >= acosl(-1.0L)) theta -= acosl(-1.0L);\n\n long double offset = baseOffset + rng.next_double(-260.0, 260.0);\n offset = max(-0.98L*R, min(0.98L*R, offset));\n\n Line ln = make_line_from_angle_offset(theta, offset);\n if (!is_valid_line(ln)) return false;\n if (!line_intersects_disk(ln, R)) return false;\n out = ln;\n return true;\n }\n\n // Constructive SA with best prefix\n vector construct(RNG& rng, int kTarget, int candPerStep) {\n fill(key.begin(), key.end(), 0);\n vector lines;\n lines.reserve(kTarget);\n\n Score cur = score_current();\n Score bestPref = cur;\n int bestLen = 0;\n\n const double T0 = 2.0, T1 = 0.25;\n\n for (int step=0; step= 0) accept = true;\n else {\n double prob = exp(delta / max(1e-9, T));\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n lines.push_back(bestLn);\n apply_add(bestLn);\n if (better(bestSc, bestPref)) {\n bestPref = bestSc;\n bestLen = (int)lines.size();\n if (bestPref.dist == totalA) break;\n }\n }\n }\n\n lines.resize(bestLen);\n return lines;\n }\n\n // Rebuild key[] from line set, also masks\n bool rebuild_from_lines(const vector& lines, vector& posM, vector& negM) {\n fill(key.begin(), key.end(), 0);\n posM.resize(lines.size());\n negM.resize(lines.size());\n for (size_t j=0; j 0 ? posM[j] : negM[j]);\n }\n key[i] = k;\n }\n return true;\n }\n\n // Variable-k SA: replace/add/remove\n vector improve_lines_varK(vector lines, RNG& rng) {\n vector posM, negM;\n if (!rebuild_from_lines(lines, posM, negM)) return lines;\n\n Score cur = score_current();\n vector bestLines = lines;\n Score best = cur;\n\n const double T0 = 1.2, T1 = 0.08;\n\n int iters = 0;\n while (!time_up(0.06)) {\n iters++;\n if (iters % 6 == 0) build_current_info(); // refresh generator state\n\n double t = min(1.0, elapsed() / max(1e-9, deadlineSec));\n double T = T0 * pow(T1 / T0, t);\n\n int k = (int)lines.size();\n int moveRoll = rng.next_int(0, 99);\n\n // Decide move type\n enum {REPL, ADD, REM} move = REPL;\n if (moveRoll < 55) move = REPL;\n else if (moveRoll < 80) move = ADD;\n else move = REM;\n\n if (move == ADD && k >= K) move = REPL;\n if (move == REM && k <= 1) move = REPL;\n\n Score nxt{-1000000000,1000000000,1000000000,-1000000000};\n bool ok = false;\n int idx = -1;\n Line candLine{};\n\n if (move == REPL) {\n idx = rng.next_int(0, k-1);\n bool genok = false;\n if (rng.next_int(0,99) < 50) genok = gen_perturb(lines[idx], candLine, rng);\n if (!genok) genok = gen_candidate(candLine, rng);\n if (!genok) continue;\n\n uint64_t newPos, newNeg;\n line_masks(candLine, newPos, newNeg);\n\n const Line& old = lines[idx];\n uint64_t oldPos = posM[idx], oldNeg = negM[idx];\n\n for (int i=0;i 0 ? oldPos : oldNeg);\n uint64_t nc = (sn > 0 ? newPos : newNeg);\n tmpKey[i] = key[i] ^ oc ^ nc;\n }\n nxt = calc_score_from_keys(tmpKey);\n ok = true;\n\n // accept?\n {\n int dDist = nxt.dist - cur.dist;\n int dGood = nxt.good - cur.good;\n int dOv = nxt.overflow - cur.overflow;\n int dEx = nxt.excess - cur.excess;\n double delta = (double)dDist + 0.02*(double)dGood - 0.03*(double)dOv - 0.008*(double)dEx;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.next_double() < exp(delta / max(1e-9, T))) accept = true;\n\n if (accept) {\n lines[idx] = candLine;\n posM[idx] = newPos;\n negM[idx] = newNeg;\n key.swap(tmpKey);\n cur = nxt;\n if (better(cur, best)) { best = cur; bestLines = lines; }\n }\n }\n } else if (move == ADD) {\n bool genok = gen_candidate(candLine, rng);\n if (!genok) continue;\n\n uint64_t newPos, newNeg;\n line_masks(candLine, newPos, newNeg);\n\n for (int i=0;i 0 ? newPos : newNeg);\n tmpKey[i] = key[i] ^ nc;\n }\n nxt = calc_score_from_keys(tmpKey);\n ok = true;\n\n {\n int dDist = nxt.dist - cur.dist;\n int dGood = nxt.good - cur.good;\n int dOv = nxt.overflow - cur.overflow;\n int dEx = nxt.excess - cur.excess;\n // slight penalty for more cuts (avoid useless over-splitting)\n double delta = (double)dDist + 0.02*(double)dGood - 0.03*(double)dOv - 0.008*(double)dEx - 0.002;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.next_double() < exp(delta / max(1e-9, T))) accept = true;\n\n if (accept) {\n lines.push_back(candLine);\n posM.push_back(newPos);\n negM.push_back(newNeg);\n key.swap(tmpKey);\n cur = nxt;\n if (better(cur, best)) { best = cur; bestLines = lines; }\n }\n }\n } else { // REM\n idx = rng.next_int(0, k-1);\n const Line& old = lines[idx];\n uint64_t oldPos = posM[idx], oldNeg = negM[idx];\n\n for (int i=0;i 0 ? oldPos : oldNeg);\n tmpKey[i] = key[i] ^ oc;\n }\n nxt = calc_score_from_keys(tmpKey);\n ok = true;\n\n {\n int dDist = nxt.dist - cur.dist;\n int dGood = nxt.good - cur.good;\n int dOv = nxt.overflow - cur.overflow;\n int dEx = nxt.excess - cur.excess;\n // small bonus for fewer cuts\n double delta = (double)dDist + 0.02*(double)dGood - 0.03*(double)dOv - 0.008*(double)dEx + 0.002;\n\n bool accept = false;\n if (delta >= 0) accept = true;\n else if (rng.next_double() < exp(delta / max(1e-9, T))) accept = true;\n\n if (accept) {\n lines.erase(lines.begin() + idx);\n posM.erase(posM.begin() + idx);\n negM.erase(negM.begin() + idx);\n key.swap(tmpKey);\n cur = nxt;\n if (better(cur, best)) { best = cur; bestLines = lines; }\n }\n }\n }\n\n NEXT_ITER:\n (void)ok;\n }\n\n return bestLines;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n cin >> N >> K;\n array a{};\n for (int d=1; d<=10; d++) cin >> a[d];\n vector pts(N);\n for (int i=0;i> pts[i].x >> pts[i].y;\n\n uint64_t seed = 123456789ULL;\n seed ^= splitmix64((uint64_t)N * 1009 + (uint64_t)K);\n for (int d=1; d<=10; d++) seed ^= splitmix64((uint64_t)a[d] * (d*10007ULL));\n for (int i=0;i bestLines;\n Score bestScore{-1, 1000000000, 1000000000, -1};\n\n // Phase 1: multi-restart constructive\n int restart = 0;\n while (!solver.time_up(0.55) && restart < 45) {\n RNG rng(seed ^ splitmix64((uint64_t)restart * 1000003ULL));\n auto lines = solver.construct(rng, kTarget, CAND_PER_STEP);\n\n // score (rebuild keys by applying)\n fill(solver.key.begin(), solver.key.end(), 0);\n for (auto &ln : lines) solver.apply_add(ln);\n Score sc = solver.score_current();\n\n if (better(sc, bestScore)) {\n bestScore = sc;\n bestLines = std::move(lines);\n if (bestScore.dist == totalA) break;\n }\n restart++;\n }\n\n // Phase 2: local improvement with variable k (replace/add/remove)\n if (!solver.time_up(0.06) && !bestLines.empty()) {\n RNG rng(seed ^ 0x9b2d3c4f5a6b7c8dULL);\n bestLines = solver.improve_lines_varK(bestLines, rng);\n }\n\n cout << bestLines.size() << \"\\n\";\n for (auto &ln : bestLines) {\n cout << ln.px << \" \" << ln.py << \" \" << ln.qx << \" \" << ln.qy << \"\\n\";\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Pt{ int x,y; };\nstatic inline int sgn(int a){ return (a>0) - (a<0); }\nstatic inline uint64_t rangeMask(int l,int r){\n if(l>r) return 0ULL;\n uint64_t len = (uint64_t)(r-l+1);\n if(len>=64) return ~0ULL;\n return ((1ULL<> dot;\n vector rowMask, colMask;\n vector hUsed, vUsed, d1Used, d2Used;\n vector> W;\n long long sumW=0;\n vector> ops;\n\n State(){}\n State(int N_): N(N_){\n c=(N-1)/2;\n dot.assign(N, vector(N,0));\n rowMask.assign(N,0);\n colMask.assign(N,0);\n hUsed.assign(N,0);\n vUsed.assign(N,0);\n d1Used.assign(max(0,N-1),0);\n d2Used.assign(max(0,N-1),0);\n W.assign(N, vector(N,1));\n for(int x=0;x& op){\n Pt p1{op[0],op[1]}, p2{op[2],op[3]}, p3{op[4],op[5]}, p4{op[6],op[7]};\n dot[p1.x][p1.y]=1;\n rowMask[p1.y] |= (1ULL< gatherMixedBits(uint64_t mask, int pos, int LIM, int nearK){\n vector res;\n res.reserve(LIM);\n mask &= ~(1ULL<=0 && xr>=0) take = (pos-xl <= xr-pos) ? xl : xr;\n else if(xl>=0) take = xl;\n else take = xr;\n res.push_back(take);\n mask &= ~(1ULL<=dmn) ? mx : mn;\n }\n res.push_back(take);\n mask &= ~(1ULL< collectDiag(Pt p, int dx, int dy, int LIM) const{\n vector res;\n res.reserve(LIM);\n for(int step=1; (int)res.size()& outOp, int& outPerim) const{\n if(dot[p1.x][p1.y]) return false;\n\n vector xs = gatherMixedBits(rowMask[p1.y], p1.x, LIM, nearK);\n vector ys = gatherMixedBits(colMask[p1.x], p1.y, LIM, nearK);\n\n bool found=false;\n int bestPerim = INT_MAX;\n int bestSpan = -1;\n array best{};\n\n auto upd = [&](Pt p2, Pt p3, Pt p4){\n if(!validRect(p1,p2,p3,p4)) return;\n int e12=edgeLen(p1,p2), e23=edgeLen(p2,p3), e34=edgeLen(p3,p4), e41=edgeLen(p4,p1);\n int perim = e12+e23+e34+e41;\n int span = max({e12,e23,e34,e41});\n if(perim < bestPerim || (spanBias && perim==bestPerim && span>bestSpan)){\n bestPerim = perim;\n bestSpan = span;\n best = array{p1.x,p1.y,p2.x,p2.y,p3.x,p3.y,p4.x,p4.y};\n found = true;\n }\n };\n\n for(int x2: xs){\n Pt p2{x2,p1.y};\n for(int y4: ys){\n if(x2==p1.x || y4==p1.y) continue;\n Pt p4{p1.x,y4};\n Pt p3{x2,y4};\n if(!inside(p3.x,p3.y)) continue;\n if(!dot[p3.x][p3.y]) continue;\n upd(p2,p3,p4);\n }\n }\n\n if(enableDiag && diagLim>0){\n vector dp, dm;\n auto a = collectDiag(p1, 1, 1, diagLim);\n auto b = collectDiag(p1,-1,-1, diagLim);\n dp.reserve(a.size()+b.size());\n dp.insert(dp.end(), a.begin(), a.end());\n dp.insert(dp.end(), b.begin(), b.end());\n\n auto c = collectDiag(p1, 1,-1, diagLim);\n auto d = collectDiag(p1,-1, 1, diagLim);\n dm.reserve(c.size()+d.size());\n dm.insert(dm.end(), c.begin(), c.end());\n dm.insert(dm.end(), d.begin(), d.end());\n\n for(const auto& p2: dp){\n for(const auto& p4: dm){\n Pt p3{p2.x + p4.x - p1.x, p2.y + p4.y - p1.y};\n if(!inside(p3.x,p3.y)) continue;\n if(!dot[p3.x][p3.y]) continue;\n upd(p2,p3,p4);\n }\n }\n }\n\n if(!found) return false;\n outOp = best;\n outPerim = bestPerim;\n return true;\n }\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 State base(N);\n for(int i=0;i> x >> y;\n base.dot[x][y]=1;\n base.rowMask[y] |= (1ULL< order;\n order.reserve(N*N);\n for(int x=0;xwb;\n if(a.x!=b.x) return a.x confs = {\n {4, 4, 0, 1, 4, true, N*N, 1, 0,0,0, false, 1u},\n {6, 6, 60, 900, 4, true, N*N, 24, 1000000, 8000, 25000, false, 1234567u},\n {8, 8, 80, 1100, 5, true, N*N, 24, 1000000, 9000, 22000, false, 89101112u},\n {8, 4, 70, 1000, 5, true, N*N, 24, 1000000, 9000, 22000, false, 42424242u},\n {8, 8, 90, 1200, 5, true, N*N, 24, 1000000, 9000, 22000, false, 20250319u},\n {8, 8, 80, 1100, 5, true, N*N, 24, 1000000, 9000, 22000, true, 31415926u}, // span tie-break\n };\n\n long long bestSumW = -1;\n vector> bestOps;\n\n // time slicing: give most runs equal slices, last run gets remaining\n int R = (int)confs.size();\n double slice = TL / R;\n\n for(int rid=0; rid(chrono::steady_clock::now()-start).count();\n if(now > TL) break;\n\n double runLimit = (rid==R-1) ? TL : slice*(rid+1);\n\n RunConf rc = confs[rid];\n mt19937 rng(rc.seed);\n\n State s = base;\n int ptr = 0;\n int topT = min(rc.topT, (int)order.size());\n if(topT <= 0) topT = 1;\n\n while(true){\n double tnow = chrono::duration(chrono::steady_clock::now()-start).count();\n if(tnow > runLimit) break;\n\n bool found = false;\n array chosen{};\n long long bestVal = LLONG_MIN;\n\n auto considerCandidate = [&](const Pt& p1, const array& op, int perim){\n long long val;\n if(rc.sampleS==0 && rc.wCoef==0 && rc.degCoef==0 && rc.perimCoef==0){\n val = 1;\n }else{\n int deg = __builtin_popcountll(s.rowMask[p1.y]) + __builtin_popcountll(s.colMask[p1.x]);\n val = (long long)s.W[p1.x][p1.y] * rc.wCoef\n + (long long)deg * rc.degCoef\n - (long long)perim * rc.perimCoef;\n val = val * 1024 + (rng() & 1023);\n }\n if(!found || val > bestVal){\n found = true;\n bestVal = val;\n chosen = op;\n }\n };\n\n // random sampling\n if(rc.sampleS > 0){\n for(int it=0; it op; int perim;\n if(s.findMoveForP1(p1, rc.LIM, rc.nearK, rc.diagLim, rc.enableDiag, rc.spanBias, op, perim)){\n considerCandidate(p1, op, perim);\n }\n }\n }\n\n // deterministic fallback\n if(!found){\n int scanned = 0, foundCnt = 0;\n while(scanned < rc.detScanMax){\n const Pt& p1 = order[ptr];\n ptr++; if(ptr==(int)order.size()) ptr=0;\n scanned++;\n\n if(s.dot[p1.x][p1.y]) continue;\n array op; int perim;\n if(!s.findMoveForP1(p1, rc.LIM, rc.nearK, rc.diagLim, rc.enableDiag, rc.spanBias, op, perim)) continue;\n\n considerCandidate(p1, op, perim);\n foundCnt++;\n if(rc.sampleS==0 && rc.wCoef==0 && rc.degCoef==0 && rc.perimCoef==0) break;\n if(foundCnt >= rc.detKeepBest) break;\n }\n }\n\n if(!found) break;\n\n Pt P1{chosen[0],chosen[1]}, P2{chosen[2],chosen[3]}, P3{chosen[4],chosen[5]}, P4{chosen[6],chosen[7]};\n if(!s.validRect(P1,P2,P3,P4)) continue;\n s.applyRect(chosen);\n }\n\n if(s.sumW > bestSumW){\n bestSumW = s.sumW;\n bestOps = move(s.ops);\n }\n }\n\n cout << bestOps.size() << \"\\n\";\n for(const auto &a: bestOps){\n for(int i=0;i<8;i++){\n if(i) cout << ' ';\n cout << a[i];\n }\n cout << \"\\n\";\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstatic constexpr int H = 10, W = 10, C = 100;\n\nstruct XorShift {\n uint64_t x;\n explicit XorShift(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n inline uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline uint32_t nextU32() { return (uint32_t)(nextU64() >> 32); }\n};\n\nstruct State {\n array a{}; // 0 empty, 1..3\n\n inline uint8_t at(int y, int x) const { return a[y * W + x]; }\n inline uint8_t& at(int y, int x) { return a[y * W + x]; }\n\n void clear() { a.fill(0); }\n\n void placeByP(int p, uint8_t f) {\n int cnt = 0;\n for (int i = 0; i < C; i++) {\n if (a[i] == 0) {\n if (++cnt == p) { a[i] = f; return; }\n }\n }\n }\n\n inline void tiltInPlace(char dir) {\n if (dir == 'L') {\n for (int y = 0; y < H; y++) {\n uint8_t tmp[W]; int k = 0;\n int base = y * W;\n for (int x = 0; x < W; x++) if (a[base + x]) tmp[k++] = a[base + x];\n for (int x = 0; x < W; x++) a[base + x] = 0;\n for (int x = 0; x < k; x++) a[base + x] = tmp[x];\n }\n } else if (dir == 'R') {\n for (int y = 0; y < H; y++) {\n uint8_t tmp[W]; int k = 0;\n int base = y * W;\n for (int x = 0; x < W; x++) if (a[base + x]) tmp[k++] = a[base + x];\n for (int x = 0; x < W; x++) a[base + x] = 0;\n for (int i = 0; i < k; i++) a[base + (W - k + i)] = tmp[i];\n }\n } else if (dir == 'F') { // to smaller y\n for (int x = 0; x < W; x++) {\n uint8_t tmp[H]; int k = 0;\n for (int y = 0; y < H; y++) {\n uint8_t v = a[y * W + x];\n if (v) tmp[k++] = v;\n }\n for (int y = 0; y < H; y++) a[y * W + x] = 0;\n for (int y = 0; y < k; y++) a[y * W + x] = tmp[y];\n }\n } else { // 'B' to larger y\n for (int x = 0; x < W; x++) {\n uint8_t tmp[H]; int k = 0;\n for (int y = 0; y < H; y++) {\n uint8_t v = a[y * W + x];\n if (v) tmp[k++] = v;\n }\n for (int y = 0; y < H; y++) a[y * W + x] = 0;\n for (int i = 0; i < k; i++) a[(H - k + i) * W + x] = tmp[i];\n }\n }\n }\n\n inline State afterTilt(char dir) const {\n State s = *this;\n s.tiltInPlace(dir);\n return s;\n }\n\n inline int emptyCount() const {\n int m = 0;\n for (int i = 0; i < C; i++) if (a[i] == 0) m++;\n return m;\n }\n\n // choose idx-th empty (0-indexed) in scan order\n inline int chooseEmptyByIndex(int idx) const {\n for (int i = 0; i < C; i++) {\n if (a[i] == 0) {\n if (idx == 0) return i;\n idx--;\n }\n }\n return -1;\n }\n};\n\nstatic inline int componentSumSq(const State& s) {\n bool vis[C];\n memset(vis, 0, sizeof(vis));\n int sumsq = 0;\n int q[C];\n\n for (int i = 0; i < C; i++) {\n if (s.a[i] == 0 || vis[i]) continue;\n uint8_t f = s.a[i];\n int head = 0, tail = 0;\n vis[i] = true;\n q[tail++] = i;\n int cnt = 0;\n while (head < tail) {\n int v = q[head++];\n cnt++;\n int y = v / W, x = v % W;\n if (y > 0) {\n int u = v - W;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (y + 1 < H) {\n int u = v + W;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (x > 0) {\n int u = v - 1;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n if (x + 1 < W) {\n int u = v + 1;\n if (!vis[u] && s.a[u] == f) vis[u] = true, q[tail++] = u;\n }\n }\n sumsq += cnt * cnt;\n }\n return sumsq;\n}\n\n// Stable mixing-averse heuristic (label-invariant)\nstruct CheapEval {\n double wSame = 2.2;\n double wDiff = 2.0;\n double wVar = 0.045;\n double wSep = 0.28;\n\n double operator()(const State& s) const {\n int adjSame = 0, adjDiff = 0;\n for (int y = 0; y < H; y++) for (int x = 0; x < W; x++) {\n uint8_t f = s.at(y, x);\n if (!f) continue;\n if (x + 1 < W) {\n uint8_t g = s.at(y, x + 1);\n if (g) (g == f ? adjSame : adjDiff)++;\n }\n if (y + 1 < H) {\n uint8_t g = s.at(y + 1, x);\n if (g) (g == f ? adjSame : adjDiff)++;\n }\n }\n\n double cnt[4] = {0,0,0,0};\n double sx[4] = {0,0,0,0}, sy[4] = {0,0,0,0};\n double sx2[4] = {0,0,0,0}, sy2[4] = {0,0,0,0};\n\n for (int y = 0; y < H; y++) for (int x = 0; x < W; x++) {\n uint8_t f = s.at(y, x);\n if (!f) continue;\n cnt[f] += 1.0;\n sx[f] += x; sy[f] += y;\n sx2[f] += 1.0 * x * x;\n sy2[f] += 1.0 * y * y;\n }\n\n double ax[4] = {0,0,0,0}, ay[4] = {0,0,0,0};\n for (int f = 1; f <= 3; f++) if (cnt[f] > 0) {\n ax[f] = sx[f] / cnt[f];\n ay[f] = sy[f] / cnt[f];\n }\n\n double varSum = 0.0;\n for (int f = 1; f <= 3; f++) if (cnt[f] > 0) {\n double ex = ax[f], ey = ay[f];\n varSum += (sx2[f] - cnt[f]*ex*ex) + (sy2[f] - cnt[f]*ey*ey);\n }\n\n double sep = 0.0;\n for (int i = 1; i <= 3; i++) for (int j = i+1; j <= 3; j++) {\n if (cnt[i] == 0 || cnt[j] == 0) continue;\n double dx = ax[i] - ax[j];\n double dy = ay[i] - ay[j];\n sep += dx*dx + dy*dy;\n }\n\n return wSame * adjSame - wDiff * adjDiff - wVar * varSum + wSep * sep;\n }\n};\n\n// Coupled truncated rollout with terminal evaluation\nstatic double rolloutCoupledTrunc(State s, int tNext, const array& f,\n const CheapEval& cev,\n const uint32_t* rPos, const uint32_t* rAct,\n int K, double alpha) {\n static constexpr array DIRS = {'F','B','L','R'};\n constexpr double eps = 0.05;\n const uint32_t TH = (uint32_t)(eps * 4294967296.0); // choose 2nd best sometimes\n\n for (int step = 0; step < K; step++) {\n int t = tNext + step;\n\n int m = s.emptyCount();\n if (m == 0) break;\n\n int idx = (int)(((uint64_t)rPos[step] * (uint64_t)m) >> 32);\n int pos = s.chooseEmptyByIndex(idx);\n s.a[pos] = (uint8_t)f[t];\n\n double bestV = -1e100, secondV = -1e100;\n char bestD = 'L', secondD = 'L';\n for (char d : DIRS) {\n State ns = s.afterTilt(d);\n double v = cev(ns);\n if (v > bestV) {\n secondV = bestV; secondD = bestD;\n bestV = v; bestD = d;\n } else if (v > secondV) {\n secondV = v; secondD = d;\n }\n }\n\n char chosen = (rAct[step] < TH ? secondD : bestD);\n s.tiltInPlace(chosen);\n }\n\n return (double)componentSumSq(s) + alpha * cev(s);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n array f{};\n for (int t = 1; t <= 100; t++) {\n if (!(cin >> f[t])) return 0;\n }\n\n uint64_t seed = 1469598103934665603ULL;\n for (int t = 1; t <= 100; t++) seed = (seed ^ (uint64_t)f[t]) * 1099511628211ULL;\n XorShift rng(seed);\n\n State cur;\n cur.clear();\n CheapEval cev;\n static constexpr array DIRS = {'F','B','L','R'};\n\n uint32_t rPos[100], rAct[100];\n\n auto timeStart = chrono::high_resolution_clock::now();\n const double TL = 1.96;\n\n for (int t = 1; t <= 100; t++) {\n int p;\n cin >> p;\n cur.placeByP(p, (uint8_t)f[t]);\n\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - timeStart).count();\n double remaining = max(0.0, TL - elapsed);\n int stepsLeft = max(1, 101 - t);\n\n double alloc = remaining * 0.90 / stepsLeft;\n alloc = min(alloc, 0.070);\n alloc = max(alloc, 0.001);\n\n auto deadline = now + chrono::duration(alloc);\n\n array cand;\n array baseH{};\n array ccNow{};\n for (int i = 0; i < 4; i++) {\n cand[i] = cur.afterTilt(DIRS[i]);\n baseH[i] = cev(cand[i]);\n ccNow[i] = componentSumSq(cand[i]);\n }\n\n if (t == 100) {\n int bestI = 0;\n double bestScore = -1e100;\n for (int i = 0; i < 4; i++) {\n double score = (double)ccNow[i] + 0.15 * baseH[i];\n if (score > bestScore) bestScore = score, bestI = i;\n }\n char out = DIRS[bestI];\n cout << out << \"\\n\" << flush;\n cur = cand[bestI];\n continue;\n }\n\n int L = 100 - t;\n\n int K;\n if (L >= 70) K = 34;\n else if (L >= 50) K = 42;\n else if (L >= 30) K = 52;\n else K = L;\n\n // adaptive terminal weight: larger when we truncate more\n double truncRatio = (L > 0 ? (double)(L - K) / (double)L : 0.0); // 0..1\n double alpha = 3.0 + 6.0 * truncRatio; // [3,9]\n\n long long samples = 0;\n array sum{};\n while (chrono::high_resolution_clock::now() < deadline) {\n for (int k = 0; k < K; k++) {\n rPos[k] = rng.nextU32();\n rAct[k] = rng.nextU32();\n }\n for (int i = 0; i < 4; i++) {\n sum[i] += rolloutCoupledTrunc(cand[i], t + 1, f, cev, rPos, rAct, K, alpha);\n }\n samples++;\n }\n\n int bestI = 0;\n double bestScore = -1e100;\n for (int i = 0; i < 4; i++) {\n double mean = samples ? sum[i] / (double)samples : -1e100;\n // small stabilizers only (avoid overriding MC)\n double score = mean + 0.35 * baseH[i] + 0.01 * (double)ccNow[i];\n if (score > bestScore) bestScore = score, bestI = i;\n }\n\n char out = DIRS[bestI];\n cout << out << \"\\n\" << flush;\n cur = cand[bestI];\n }\n\n return 0;\n}","ahc016":"#include \n#include \nusing namespace std;\n\nstruct Adj100 { array w{}; };\n\nstatic inline void set_edge(vector& adj, int u, int v) {\n adj[u].w[v >> 6] |= 1ULL << (v & 63);\n adj[v].w[u >> 6] |= 1ULL << (u & 63);\n}\nstatic inline bool has_edge(const vector& adj, int u, int v) {\n return (adj[u].w[v >> 6] >> (v & 63)) & 1ULL;\n}\nstatic inline int popcnt2(const array& a) {\n return __builtin_popcountll(a[0]) + __builtin_popcountll(a[1]);\n}\nstatic inline int popcnt_and2(const array& a, const array& b) {\n return __builtin_popcountll(a[0] & b[0]) + __builtin_popcountll(a[1] & b[1]);\n}\n\nstatic vector string_to_adj(const string& s, int N) {\n vector adj(N);\n int idx = 0;\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++) {\n if (s[idx++] == '1') set_edge(adj, i, j);\n }\n return adj;\n}\nstatic string adj_to_string(const vector& adj, int N) {\n string s;\n s.reserve((size_t)N * (N - 1) / 2);\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++)\n s.push_back(has_edge(adj, i, j) ? '1' : '0');\n return s;\n}\n\nstruct ObsStats {\n long long m = 0;\n long long tri = 0;\n vector deg;\n vector triDeg;\n vector wedge; // C(deg,2) - triDeg\n};\n\nstatic ObsStats analyze_observed(const vector& adj, int N) {\n ObsStats res;\n res.deg.assign(N, 0);\n res.triDeg.assign(N, 0);\n res.wedge.assign(N, 0);\n\n long long sum_deg = 0;\n for (int i = 0; i < N; i++) {\n int d = popcnt2(adj[i].w);\n res.deg[i] = d;\n sum_deg += d;\n }\n res.m = sum_deg / 2;\n\n // T_v = edges among neighbors of v\n for (int v = 0; v < N; v++) {\n long long acc = 0;\n for (int u = 0; u < N; u++) if (u != v && has_edge(adj, v, u)) {\n acc += popcnt_and2(adj[v].w, adj[u].w);\n }\n res.triDeg[v] = (int)(acc / 2);\n }\n long long sumTv = 0;\n for (int v = 0; v < N; v++) sumTv += res.triDeg[v];\n res.tri = sumTv / 3;\n\n for (int v = 0; v < N; v++) {\n long long c2 = 1LL * res.deg[v] * (res.deg[v] - 1) / 2;\n res.wedge[v] = (int)(c2 - res.triDeg[v]);\n if (res.wedge[v] < 0) res.wedge[v] = 0;\n }\n return res;\n}\n\nstatic vector build_graph(int N, int hubSize, const vector& smallSizes, int mask) {\n vector adj(N);\n int B = (int)smallSizes.size();\n vector start(B + 1, 0);\n start[0] = hubSize;\n for (int i = 0; i < B; i++) start[i + 1] = start[i] + smallSizes[i];\n\n auto add_clique = [&](int L, int R) {\n for (int i = L; i < R; i++) for (int j = i + 1; j < R; j++) set_edge(adj, i, j);\n };\n\n add_clique(0, hubSize);\n for (int i = 0; i < B; i++) add_clique(start[i], start[i + 1]);\n\n for (int i = 0; i < B; i++) if ((mask >> i) & 1) {\n for (int u = 0; u < hubSize; u++)\n for (int v = start[i]; v < start[i + 1]; v++)\n set_edge(adj, u, v);\n }\n return adj;\n}\n\nstatic vector eigenvalues_asc(const Eigen::MatrixXd& M) {\n Eigen::SelfAdjointEigenSolver es(M, /*computeEigenvectors=*/false);\n Eigen::VectorXd ev = es.eigenvalues();\n vector vals(ev.size());\n for (int i = 0; i < (int)ev.size(); i++) vals[i] = ev[i];\n return vals;\n}\n\nstatic double spectral_distance_extremes(const vector& aAsc, const vector& bAsc, int L) {\n int N = (int)aAsc.size();\n L = min(L, N / 2);\n double dist = 0.0;\n for (int i = 0; i < L; i++) {\n double d = aAsc[i] - bAsc[i];\n dist += d * d;\n }\n for (int i = 0; i < L; i++) {\n int ia = N - 1 - i;\n int ib = N - 1 - i;\n double d = aAsc[ia] - bAsc[ib];\n dist += d * d;\n }\n return dist / max(1, 2 * L);\n}\n\nstatic vector top_abs_eigs(const vector& eigAsc, int K) {\n int N = (int)eigAsc.size();\n vector v = eigAsc;\n nth_element(v.begin(), v.begin() + min(K, N), v.end(),\n [](double a, double b){ return fabs(a) > fabs(b); });\n v.resize(min(K, N));\n sort(v.begin(), v.end(), [](double a, double b){ return fabs(a) > fabs(b); });\n return v;\n}\nstatic double top_abs_distance(const vector& aTop, const vector& bTop) {\n int K = (int)min(aTop.size(), bTop.size());\n double s = 0.0;\n for (int i = 0; i < K; i++) {\n double d = aTop[i] - bTop[i];\n s += d * d;\n }\n return (K ? s / K : 0.0);\n}\nstatic double moment4(const vector& eigAsc) {\n long double s = 0.0;\n for (double x : eigAsc) {\n long double y = x;\n s += y*y*y*y;\n }\n return (double)s;\n}\n\nstruct Proto {\n vector mu_sorted_deg;\n vector mu_sorted_trideg;\n vector mu_sorted_wedge;\n vector> mu_pairs;\n\n double Em = 0.0;\n double Etri = 0.0;\n double VarTri = 1.0;\n double EwedgeMean = 0.0; // mean open wedges per vertex\n\n vector eigA_asc;\n vector eigEH_asc;\n vector topAbsA;\n vector topAbsEH;\n double m4A = 0.0;\n};\n\nstatic vector choose_masks_greedy(int M, const vector& bitW, uint64_t seed=1) {\n int B = (int)bitW.size();\n int ALL = 1 << B;\n\n auto distW = [&](int a, int b) -> double {\n int x = a ^ b;\n double s = 0.0;\n for (int i = 0; i < B; i++) if ((x >> i) & 1) s += bitW[i];\n return s;\n };\n\n vector masks;\n masks.reserve(M);\n vector used(ALL, 0);\n\n masks.push_back(0);\n used[0] = 1;\n\n for (int t = 1; t < M; t++) {\n int best = -1;\n double bestMin = -1.0, bestAvg = -1.0;\n for (int cand = 0; cand < ALL; cand++) if (!used[cand]) {\n double mn = 1e100, sum = 0.0;\n for (int sel : masks) {\n double d = distW(cand, sel);\n mn = min(mn, d);\n sum += d;\n }\n double avg = sum / (double)masks.size();\n if (mn > bestMin + 1e-12 || (abs(mn - bestMin) <= 1e-12 && avg > bestAvg)) {\n bestMin = mn;\n bestAvg = avg;\n best = cand;\n }\n }\n if (best < 0) best = t;\n used[best] = 1;\n masks.push_back(best);\n }\n\n // local search swap improvement (ALL<=256)\n auto rng = [&]() -> uint64_t {\n seed ^= seed << 7;\n seed ^= seed >> 9;\n return seed;\n };\n\n vector> dist(ALL, vector(ALL, 0.0));\n for (int i = 0; i < ALL; i++) for (int j = i + 1; j < ALL; j++) {\n double d = distW(i, j);\n dist[i][j] = dist[j][i] = d;\n }\n\n auto eval_set = [&](const vector& S) -> pair {\n double mn = 1e100;\n double sum = 0.0;\n long long cnt = 0;\n for (int i = 0; i < (int)S.size(); i++) for (int j = i + 1; j < (int)S.size(); j++) {\n double d = dist[S[i]][S[j]];\n mn = min(mn, d);\n sum += d;\n cnt++;\n }\n double avg = (cnt ? sum / (double)cnt : 0.0);\n return {mn, avg};\n };\n\n vector inSet(ALL, 0);\n for (int x : masks) inSet[x] = 1;\n auto bestObj = eval_set(masks);\n\n int iters = 2000;\n for (int it = 0; it < iters; it++) {\n int i = (int)(rng() % masks.size());\n int out = masks[i];\n int cand = (int)(rng() % ALL);\n if (inSet[cand]) continue;\n\n vector S = masks;\n S[i] = cand;\n auto obj = eval_set(S);\n if (obj.first > bestObj.first + 1e-9 || (abs(obj.first - bestObj.first) <= 1e-9 && obj.second > bestObj.second + 1e-9)) {\n inSet[out] = 0;\n inSet[cand] = 1;\n masks.swap(S);\n bestObj = obj;\n }\n }\n\n return masks;\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 int N;\n if (eps <= 0.15) N = 60;\n else if (eps <= 0.25) N = 80;\n else N = 100;\n\n vector smallSizes;\n if (N == 100) smallSizes = {3,4,5,6,7,8,9,10}; // 8 bits\n else smallSizes = {3,4,5,6,7,8,9}; // 7 bits\n\n int sumSmall = accumulate(smallSizes.begin(), smallSizes.end(), 0);\n int hubSize = N - sumSmall;\n if (hubSize < 4) {\n smallSizes = {3,4,5,6,7,8,9};\n sumSmall = accumulate(smallSizes.begin(), smallSizes.end(), 0);\n hubSize = N - sumSmall;\n }\n const int B = (int)smallSizes.size();\n\n vector bitW(B);\n for (int i = 0; i < B; i++) bitW[i] = (double)hubSize * (double)smallSizes[i];\n vector maskOfK = choose_masks_greedy(M, bitW, 1234567);\n\n const double p1 = 1.0 - eps;\n const double p0 = eps;\n const double scale = 1.0 - 2.0 * eps;\n\n const double degOffset = eps * (N - 1);\n const double sigma2_deg = (N - 1) * eps * (1.0 - eps) + 1e-9;\n\n const double Tedges = 1.0 * N * (N - 1) / 2.0;\n const double var_m = Tedges * eps * (1.0 - eps) + 1e-9;\n\n const int L = 8;\n const int KABS = 12;\n\n const double comb_v = 1.0 * (N - 1) * (N - 2) / 2.0;\n\n vector prot(M);\n\n cout << N << \"\\n\";\n for (int k = 0; k < M; k++) {\n int mask = maskOfK[k];\n auto G = build_graph(N, hubSize, smallSizes, mask);\n cout << adj_to_string(G, N) << \"\\n\";\n\n vector deg0(N, 0);\n vector> neigh(N);\n long long sumdeg0 = 0;\n for (int v = 0; v < N; v++) {\n deg0[v] = popcnt2(G[v].w);\n sumdeg0 += deg0[v];\n }\n long long m0 = sumdeg0 / 2;\n\n for (int v = 0; v < N; v++) {\n neigh[v].reserve(deg0[v]);\n for (int u = 0; u < N; u++) if (u != v && has_edge(G, v, u)) neigh[v].push_back(u);\n }\n\n vector muDegV(N);\n for (int v = 0; v < N; v++) muDegV[v] = degOffset + scale * deg0[v];\n prot[k].mu_sorted_deg = muDegV;\n sort(prot[k].mu_sorted_deg.begin(), prot[k].mu_sorted_deg.end());\n\n prot[k].Em = m0 * p1 + (Tedges - m0) * p0;\n\n vector muTriV(N, 0.0), muWedgeV(N, 0.0), sumPairsV(N, 0.0);\n\n for (int v = 0; v < N; v++) {\n int n1 = deg0[v];\n int n0 = (N - 1) - n1;\n\n long long sumCommon = 0;\n const auto NvMask = G[v].w;\n for (int u : neigh[v]) sumCommon += popcnt_and2(NvMask, G[u].w);\n long long E11 = sumCommon / 2;\n\n long long sum_deg_in_rest_Nv = 0;\n for (int u : neigh[v]) sum_deg_in_rest_Nv += (deg0[u] - 1);\n long long E10 = sum_deg_in_rest_Nv - 2 * E11;\n\n long long m_rest = m0 - deg0[v];\n long long E00 = m_rest - E11 - E10;\n if (E00 < 0) E00 = 0;\n\n // sum_{a 0 ? prot[k].Etri / totalTriples : 0.0);\n pbar = min(1.0, max(0.0, pbar));\n prot[k].VarTri = totalTriples * pbar * (1.0 - pbar) + 1.0;\n\n Eigen::MatrixXd A(N, N);\n A.setZero();\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++)\n if (has_edge(G, i, j)) A(i, j) = A(j, i) = 1.0;\n prot[k].eigA_asc = eigenvalues_asc(A);\n\n Eigen::MatrixXd EH(N, N);\n EH.setZero();\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++) {\n double aij = has_edge(G, i, j) ? 1.0 : 0.0;\n double val = eps + (1.0 - 2.0 * eps) * aij;\n EH(i, j) = EH(j, i) = val;\n }\n prot[k].eigEH_asc = eigenvalues_asc(EH);\n\n prot[k].topAbsA = top_abs_eigs(prot[k].eigA_asc, KABS);\n prot[k].topAbsEH = top_abs_eigs(prot[k].eigEH_asc, KABS);\n prot[k].m4A = moment4(prot[k].eigA_asc);\n }\n cout.flush();\n\n for (int q = 0; q < 100; q++) {\n string hs;\n cin >> hs;\n if (!cin) break;\n\n auto H = string_to_adj(hs, N);\n auto obs = analyze_observed(H, N);\n\n vector degSorted = obs.deg;\n sort(degSorted.begin(), degSorted.end());\n vector tdegSorted = obs.triDeg;\n sort(tdegSorted.begin(), tdegSorted.end());\n vector wedgeSorted = obs.wedge;\n sort(wedgeSorted.begin(), wedgeSorted.end());\n\n vector> obsPairs(N);\n for (int v = 0; v < N; v++) obsPairs[v] = {obs.deg[v], obs.triDeg[v]};\n sort(obsPairs.begin(), obsPairs.end());\n\n // centered eigenvalues\n Eigen::MatrixXd C(N, N);\n C.setZero();\n if (eps == 0.0) {\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++)\n if (has_edge(H, i, j)) C(i, j) = C(j, i) = 1.0;\n } else {\n double denom = 1.0 - 2.0 * eps;\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++) {\n double hij = has_edge(H, i, j) ? 1.0 : 0.0;\n double val = (hij - eps) / denom;\n C(i, j) = C(j, i) = val;\n }\n }\n vector eigC = eigenvalues_asc(C);\n vector topAbsC = top_abs_eigs(eigC, KABS);\n double m4C = moment4(eigC);\n\n bool useRawEig = (eps >= 0.20);\n vector eigHraw, topAbsHraw;\n if (useRawEig) {\n Eigen::MatrixXd Araw(N, N);\n Araw.setZero();\n for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++)\n if (has_edge(H, i, j)) Araw(i, j) = Araw(j, i) = 1.0;\n eigHraw = eigenvalues_asc(Araw);\n topAbsHraw = top_abs_eigs(eigHraw, KABS);\n }\n\n // weights (previous best + small wedge)\n double wM = 0.30;\n double wTri = 0.10;\n double wEig = (eps >= 0.30 ? 0.10 : (eps >= 0.20 ? 0.06 : 0.03));\n double wTdeg = (eps >= 0.30 ? 0.22 : (eps >= 0.20 ? 0.16 : 0.10));\n double wPair = (eps >= 0.30 ? 0.12 : (eps >= 0.20 ? 0.09 : 0.06));\n double wEigRaw = (useRawEig ? (eps >= 0.30 ? 0.05 : 0.03) : 0.0);\n\n double wAbs = (eps >= 0.30 ? 0.035 : (eps >= 0.20 ? 0.025 : 0.010));\n double wAbsRaw = (useRawEig ? (eps >= 0.30 ? 0.020 : 0.012) : 0.0);\n double wM4 = (eps >= 0.25 ? 0.010 : 0.0);\n\n double wWedge = (eps >= 0.30 ? 0.09 : (eps >= 0.20 ? 0.06 : 0.03));\n\n int best = 0;\n double bestScore = 1e300;\n\n for (int k = 0; k < M; k++) {\n // degree SSE\n const auto &muD = prot[k].mu_sorted_deg;\n double sseD = 0.0;\n for (int i = 0; i < N; i++) {\n double diff = (double)degSorted[i] - muD[i];\n sseD += diff * diff;\n }\n double z_deg = sseD / (sigma2_deg * N);\n\n // edges\n double dm = (double)obs.m - prot[k].Em;\n double z_m = (dm * dm) / var_m;\n\n // triangles total\n double dt = (double)obs.tri - prot[k].Etri;\n double z_t = (dt * dt) / prot[k].VarTri;\n\n // triangle-degree multiset SSE\n const auto &muT = prot[k].mu_sorted_trideg;\n double sseT = 0.0;\n for (int i = 0; i < N; i++) {\n double diff = (double)tdegSorted[i] - muT[i];\n sseT += diff * diff;\n }\n double pbar_v = (comb_v > 0 ? (3.0 * prot[k].Etri / N) / comb_v : 0.0);\n pbar_v = min(1.0, max(0.0, pbar_v));\n double sigma2_tdeg = comb_v * pbar_v * (1.0 - pbar_v) + 1.0;\n double z_tdeg = sseT / (sigma2_tdeg * N);\n\n // wedge multiset SSE\n const auto &muW = prot[k].mu_sorted_wedge;\n double sseW = 0.0;\n for (int i = 0; i < N; i++) {\n double diff = (double)wedgeSorted[i] - muW[i];\n sseW += diff * diff;\n }\n double pbar_w = (comb_v > 0 ? prot[k].EwedgeMean / comb_v : 0.0);\n pbar_w = min(1.0, max(0.0, pbar_w));\n double sigma2_w = comb_v * pbar_w * (1.0 - pbar_w) + 1.0;\n double z_wedge = sseW / (sigma2_w * N);\n\n // joint (deg,triDeg) pair matching\n const auto &muP = prot[k].mu_pairs;\n double sseP = 0.0;\n for (int i = 0; i < N; i++) {\n double ddeg = (double)obsPairs[i].first - muP[i].first;\n double dtri = (double)obsPairs[i].second - muP[i].second;\n sseP += (ddeg * ddeg) / sigma2_deg + (dtri * dtri) / sigma2_tdeg;\n }\n double z_pair = sseP / (double)N;\n\n // spectrum features\n double z_e = spectral_distance_extremes(eigC, prot[k].eigA_asc, L);\n\n double z_er = 0.0;\n if (useRawEig) z_er = spectral_distance_extremes(eigHraw, prot[k].eigEH_asc, L);\n\n double z_abs = top_abs_distance(topAbsC, prot[k].topAbsA);\n double z_abs_raw = 0.0;\n if (useRawEig) z_abs_raw = top_abs_distance(topAbsHraw, prot[k].topAbsEH);\n\n double z_m4 = 0.0;\n if (wM4 > 0.0) {\n double denom = fabs(prot[k].m4A) + 1.0;\n double diff = (m4C - prot[k].m4A) / denom;\n z_m4 = diff * diff;\n }\n\n double score =\n z_deg +\n wM * z_m +\n wTri * z_t +\n wTdeg * z_tdeg +\n wWedge * z_wedge +\n wPair * z_pair +\n wEig * z_e +\n wEigRaw * z_er +\n wAbs * z_abs +\n wAbsRaw * z_abs_raw +\n wM4 * z_m4;\n\n if (score < bestScore) {\n bestScore = score;\n best = k;\n }\n }\n\n cout << best << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n int w;\n};\n\nstruct DSU {\n int n;\n vector p, sz;\n DSU(int n=0): n(n), p(n), sz(n,1) { iota(p.begin(), p.end(), 0); }\n int find(int x){ while(p[x]!=x){ p[x]=p[p[x]]; x=p[x]; } return x; }\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(sz[a]> &vec, int key) {\n for (int i = 0; i < (int)vec.size(); i++) if (vec[i].first == key) return i;\n return -1;\n}\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N,M,D,K;\n cin>>N>>M>>D>>K;\n\n vector edges(M);\n vector>> g(N);\n vector> gw(N);\n for(int i=0;i>u>>v>>w; --u;--v;\n edges[i]={u,v,w};\n g[u].push_back({v,i}); gw[u].push_back(w);\n g[v].push_back({u,i}); gw[v].push_back(w);\n }\n // coordinates: consume\n for(int i=0;i>x>>y; }\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937_64 rng(seed);\n uniform_real_distribution uni01(0.0, 1.0);\n\n auto tStart = chrono::high_resolution_clock::now();\n auto elapsed = [&]()->double{\n return chrono::duration(chrono::high_resolution_clock::now()-tStart).count();\n };\n\n const long long INF = (1LL<<62);\n\n // --------------------\n // 1) Importance (SPT sampling)\n // --------------------\n int S = min(36, N);\n vector sources(N);\n iota(sources.begin(), sources.end(), 0);\n shuffle(sources.begin(), sources.end(), rng);\n sources.resize(S);\n\n vector importance(M,0);\n vector dist(N);\n vector parentV(N), parentE(N), order(N), subtree(N);\n\n for(int si=0; si;\n priority_queue, greater

> pq;\n dist[s]=0; pq.push({0,s});\n while(!pq.empty()){\n auto [dcur,v]=pq.top(); pq.pop();\n if(dcur!=dist[v]) continue;\n for(int idx=0; idx<(int)g[v].size(); idx++){\n auto [to,eid]=g[v][idx];\n long long nd = dcur + gw[v][idx];\n if(nd < dist[to]){\n dist[to]=nd;\n parentV[to]=v;\n parentE[to]=eid;\n pq.push({nd,to});\n }\n }\n }\n\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int a,int b){ return dist[a] > dist[b]; });\n\n fill(subtree.begin(), subtree.end(), 1);\n for(int v: order){\n int p=parentV[v];\n if(p!=-1) subtree[p] += subtree[v];\n }\n for(int v=0; v eorder(M);\n iota(eorder.begin(), eorder.end(), 0);\n sort(eorder.begin(), eorder.end(), [&](int a,int b){\n if(importance[a]!=importance[b]) return importance[a] > importance[b];\n return edges[a].w > edges[b].w;\n });\n\n // --------------------\n // 2) Conflicts via replacement paths (symmetric)\n // --------------------\n vector>> conf(M);\n\n auto add_conf_pair = [&](int a,int b,int w){\n if(a==b) return;\n int ia = find_idx(conf[a], b);\n int ib = find_idx(conf[b], a);\n int curAB = (ia>=0? conf[a][ia].second : 0);\n int curBA = (ib>=0? conf[b][ib].second : 0);\n int nw = max(w, max(curAB, curBA));\n if(ia>=0) conf[a][ia].second = nw;\n else conf[a].push_back({b,nw});\n if(ib>=0) conf[b][ib].second = nw;\n else conf[b].push_back({a,nw});\n };\n\n vector dist2(N);\n vector parV2(N), parE2(N);\n\n auto replacement_path_edges = [&](int s,int t,int bannedEid)->pair>{\n fill(dist2.begin(), dist2.end(), INF);\n fill(parV2.begin(), parV2.end(), -1);\n fill(parE2.begin(), parE2.end(), -1);\n\n using P = pair;\n priority_queue, greater

> pq;\n dist2[s]=0; pq.push({0,s});\n while(!pq.empty()){\n auto [dcur,v]=pq.top(); pq.pop();\n if(dcur!=dist2[v]) continue;\n if(v==t) break;\n for(int idx=0; idx<(int)g[v].size(); idx++){\n auto [to,eid]=g[v][idx];\n if(eid==bannedEid) continue;\n long long nd = dcur + gw[v][idx];\n if(nd < dist2[to]){\n dist2[to]=nd;\n parV2[to]=v;\n parE2[to]=eid;\n pq.push({nd,to});\n }\n }\n }\n if(dist2[t] >= INF/4) return {INF, {}};\n vector pathE;\n int cur=t;\n while(cur!=s){\n int pe=parE2[cur];\n if(pe<0) break;\n pathE.push_back(pe);\n cur=parV2[cur];\n }\n return {dist2[t], pathE};\n };\n\n const double CONFLICT_BUDGET = 1.8;\n int T = min(M, 850);\n int L = 12;\n for(int idx=0; idx CONFLICT_BUDGET) break;\n int e = eorder[idx];\n int u=edges[e].u, v=edges[e].v;\n auto [repDist, pathE] = replacement_path_edges(u,v,e);\n if(pathE.empty() || repDist >= INF/4) continue;\n\n sort(pathE.begin(), pathE.end());\n pathE.erase(unique(pathE.begin(), pathE.end()), pathE.end());\n pathE.erase(remove(pathE.begin(), pathE.end(), e), pathE.end());\n if(pathE.empty()) continue;\n\n sort(pathE.begin(), pathE.end(), [&](int a,int b){ return importance[a] > importance[b]; });\n if((int)pathE.size() > L) pathE.resize(L);\n\n long double stretch = (long double)repDist / (long double)max(1, edges[e].w);\n stretch = min(stretch, 10.0L);\n\n int base = (int)llround(90.0L * (long double)importance[e] / impScale);\n base = max(10, min(base, 700));\n int wconf = (int)llround((long double)base * stretch);\n wconf = max(10, min(wconf, 3000));\n\n for(int f: pathE) add_conf_pair(e, f, wconf);\n }\n\n // --------------------\n // 3) Balanced targets\n // --------------------\n vector target(D, M/D);\n for(int d=0; d<(M%D); d++) target[d]++;\n\n // --------------------\n // 4) Greedy init\n // --------------------\n vector dayOfEdge(M, -1);\n vector> edgesInDay(D);\n for(int d=0; d cnt(D,0);\n vector daySumImp(D,0);\n\n vector> inc(D, vector(N,0));\n vector dayVertexPenalty(D,0);\n\n auto deltaAddEdgeVP = [&](int d, int u, int v)->long long{\n long long delta=0;\n long long a=inc[d][u], b=a+1; delta += b*b - a*a;\n a=inc[d][v]; b=a+1; delta += b*b - a*a;\n if(u==v) delta -= 1;\n return delta;\n };\n auto applyAddEdge = [&](int d, int eid){\n int u=edges[eid].u, v=edges[eid].v;\n {\n long long a=inc[d][u], b=a+1;\n dayVertexPenalty[d] += b*b - a*a;\n inc[d][u]=(int16_t)b;\n }\n {\n long long a=inc[d][v], b=a+1;\n dayVertexPenalty[d] += b*b - a*a;\n inc[d][v]=(int16_t)b;\n }\n if(u==v) dayVertexPenalty[d] -= 1;\n\n daySumImp[d] += importance[eid];\n dayOfEdge[eid]=d;\n edgesInDay[d].push_back(eid);\n cnt[d]++;\n };\n auto conflictCostIfPut = [&](int eid, int d)->long long{\n long long s=0;\n for(auto [f,w]: conf[eid]) if(dayOfEdge[f]==d) s += w;\n return s;\n };\n\n const long double alphaVP = 0.7L * impScale;\n const long double betaCnt = 0.02L * impScale;\n const long double alphaConfGreedy = (long double)(impScale * 0.10L);\n\n for(int eid: eorder){\n int u=edges[eid].u, v=edges[eid].v;\n int bestD=-1;\n long double bestCost=1e300L;\n for(int d=0; d= target[d]) continue;\n long long dvp = deltaAddEdgeVP(d,u,v);\n long long cconf = conflictCostIfPut(eid,d);\n long double cost = (long double)daySumImp[d]\n + alphaVP*(long double)dvp\n + betaCnt*(long double)cnt[d]\n + alphaConfGreedy*(long double)cconf;\n if(cost < bestCost){ bestCost=cost; bestD=d; }\n }\n if(bestD<0) bestD=0;\n applyAddEdge(bestD, eid);\n }\n\n // posInDay\n vector posInDay(M,-1);\n for(int d=0; d& vs, array& ds, int &m){\n vs = {edges[remE].u, edges[remE].v, edges[addE].u, edges[addE].v};\n ds = {-1,-1,+1,+1};\n m=0;\n for(int i=0;i<4;i++){\n int v=vs[i], d=ds[i];\n int j=-1;\n for(int k=0;k& vs, const array& ds, int m)->long long{\n long long delta=0;\n for(int i=0;i& vs, const array& ds, int m){\n long long delta=0;\n for(int i=0;ilong long{\n long long delta=0;\n for(auto [f,w]: conf[e1]){\n if(f==e2) continue;\n int df = dayOfEdge[f];\n delta += 2LL*w * ((df==b) - (df==a));\n }\n for(auto [f,w]: conf[e2]){\n if(f==e1) continue;\n int df = dayOfEdge[f];\n delta += 2LL*w * ((df==a) - (df==b));\n }\n return delta;\n };\n\n // --------------------\n // 5) SA (leave time for connectivity repair)\n // --------------------\n auto objective_val = [&]()->long double{\n return (long double)sumSqImp + coeffVP*(long double)totalVP + coeffConf*(long double)totalConfDir;\n };\n long double curObj = objective_val();\n\n const double SA_END = 5.40; // keep margin for repair\n long double T0 = max((long double)1.0, curObj * 1e-4L);\n long double T1 = max((long double)1e-3, curObj * 1e-7L);\n\n while(true){\n double t = elapsed();\n if(t > SA_END) break;\n double prog = t / SA_END;\n long double Temp = T0 * pow((double)(T1/T0), prog);\n\n int a = (int)(rng()%D);\n int b = (int)(rng()%(D-1));\n if(b>=a) b++;\n if(edgesInDay[a].empty() || edgesInDay[b].empty()) continue;\n\n int ia = (int)(rng()%edgesInDay[a].size());\n int ib = (int)(rng()%edgesInDay[b].size());\n int e1 = edgesInDay[a][ia];\n int e2 = edgesInDay[b][ib];\n\n long long p1=importance[e1], p2=importance[e2];\n long long A=daySumImp[a], B=daySumImp[b];\n long long A2=A-p1+p2, B2=B-p2+p1;\n long long dSumSq = sqll(A2)+sqll(B2)-sqll(A)-sqll(B);\n\n array vsA, dsA; int mA;\n array vsB, dsB; int mB;\n collect_changes(e1,e2,vsA,dsA,mA);\n collect_changes(e2,e1,vsB,dsB,mB);\n long long dVP = deltaVP_day(a,vsA,dsA,mA) + deltaVP_day(b,vsB,dsB,mB);\n\n long long dConf = deltaConfSwap(e1,e2,a,b);\n\n long double dObj = (long double)dSumSq + coeffVP*(long double)dVP + coeffConf*(long double)dConf;\n\n bool accept=false;\n if(dObj<=0) accept=true;\n else{\n long double prob = expl(-(double)(dObj/Temp));\n if(uni01(rng) < (double)prob) accept=true;\n }\n\n if(accept){\n sumSqImp += dSumSq;\n daySumImp[a]=A2; daySumImp[b]=B2;\n\n totalVP += dVP;\n applyVP_day(a,vsA,dsA,mA);\n applyVP_day(b,vsB,dsB,mB);\n\n totalConfDir += dConf;\n\n edgesInDay[a][ia]=e2;\n edgesInDay[b][ib]=e1;\n posInDay[e2]=ia;\n posInDay[e1]=ib;\n dayOfEdge[e1]=b;\n dayOfEdge[e2]=a;\n\n curObj += dObj;\n }\n }\n\n // --------------------\n // 6) Connectivity repair safeguard (critical vs outliers)\n // --------------------\n auto build_dsu_excluding_day = [&](int badDay)->DSU{\n DSU dsu(N);\n for(int eid=0; eid1 && elapsed()<5.95; it++){\n dsu = build_dsu_excluding_day(d);\n comps = dsu.comps();\n if(comps==1) break;\n\n // pick an edge in day d whose endpoints lie in different DSU components\n int e = -1;\n long long bestImp = -1;\n for(int eid: edgesInDay[d]){\n int cu = dsu.find(edges[eid].u), cv = dsu.find(edges[eid].v);\n if(cu==cv) continue;\n if(importance[eid] > bestImp){\n bestImp = importance[eid];\n e = eid;\n }\n }\n if(e<0) break;\n\n // pick a swap partner f from another day that is internal in DSU, low importance\n int bestDay=-1, fbest=-1;\n long long bestScore = (1LL<<62);\n for(int tries=0; tries<25; tries++){\n int d2 = (int)(rng()%(D-1));\n if(d2>=d) d2++;\n if(edgesInDay[d2].empty()) continue;\n for(int s=0; s<14; s++){\n int f = edgesInDay[d2][(int)(rng()%edgesInDay[d2].size())];\n int cu = dsu.find(edges[f].u), cv = dsu.find(edges[f].v);\n if(cu!=cv) continue;\n long long sc = importance[f];\n if(sc < bestScore){\n bestScore = sc;\n bestDay = d2;\n fbest = f;\n }\n }\n }\n if(fbest<0) break;\n\n int d2=bestDay;\n int f=fbest;\n\n int pe = posInDay[e];\n int pf = posInDay[f];\n\n // swap in day lists\n edgesInDay[d][pe] = f;\n edgesInDay[d2][pf] = e;\n posInDay[f] = pe;\n posInDay[e] = pf;\n dayOfEdge[e] = d2;\n dayOfEdge[f] = d;\n\n // (No need to update proxy totals here; repair is for true connectivity robustness.)\n }\n }\n if(!any) break;\n }\n }\n\n // output\n for(int i=0;i\nusing namespace std;\n\nstatic inline int idx3(int D,int x,int y,int z){ return x*D*D + y*D + z; }\n\nstruct Stick{\n int axis; //0x 1y 2z\n int x,y,z; // start\n int cur;\n int rem;\n};\n\nstruct BuildResult{\n int n=0;\n vector b1,b2;\n long double obj=1e100L;\n};\n\nstatic inline void stick_cell(int D, const Stick& s, int offset, int &x, int &y, int &z){\n x=s.x; y=s.y; z=s.z;\n if(s.axis==0) x+=offset;\n else if(s.axis==1) y+=offset;\n else z+=offset;\n}\nstatic inline void cut_piece(int D, Stick& s, int L, vector& b, int id){\n for(int t=0;t build_sticks(int D, const vector& occ, int axis){\n vector st;\n st.reserve(D*D*D/2);\n if(axis==0){\n for(int y=0;y& b1, const vector& b2){\n vector u1(n+1,0), u2(n+1,0);\n vector v1(n+1,0), v2(n+1,0);\n int N=(int)b1.size();\n for(int i=0;i vol(n+1,0);\n for(int k=1;k<=n;k++) vol[k]=max(v1[k],v2[k]);\n long double r1=0,r2=0,sp=0;\n for(int k=1;k<=n;k++){\n if(!u1[k]) r1 += vol[k];\n if(!u2[k]) r2 += vol[k];\n if(u1[k] && u2[k]) sp += 1.0L/(long double)vol[k];\n }\n return r1+r2+sp;\n}\n\n// ---------- allowed / basic builders ----------\nvector build_allowed(int D, const vector& f, const vector& r){\n vector a(D*D*D,0);\n for(int z=0;z build_occ_full(int D, const vector& f, const vector& r){\n return build_allowed(D,f,r);\n}\nvector build_occ_min(int D, const vector& f, const vector& r){\n vector occ(D*D*D,0);\n for(int z=0;z X,Y;\n for(int x=0;x=cy){\n for(int t=0;t build_occ_star(int D, const vector& f, const vector& r){\n int bestX=0,bestY=0,bx=-1,by=-1;\n for(int x=0;xbx){ bx=c; bestX=x; }\n }\n for(int y=0;yby){ by=c; bestY=y; }\n }\n vector occ(D*D*D,0);\n for(int z=0;z X,Y;\n for(int x=0;x get_Vmin_Vmax(int D, const vector& f, const vector& r){\n int Vmin=0,Vmax=0;\n for(int z=0;z build_occ_target(int D, const vector& f, const vector& r, int consAxis, int T){\n vector> X(D), Y(D);\n vector minz(D), maxz(D);\n for(int z=0; z mz=minz;\n int E=T-Vmin;\n while(E>0){\n int best=-1, bestCap=0;\n for(int z=0;zbestCap){ bestCap=cap; best=z; }\n }\n if(bestCap==0) break;\n int add=min(E,bestCap);\n mz[best]+=add;\n E-=add;\n }\n\n vector occ(D*D*D,0);\n vector> used(D, vector(D,0));\n for(int z=0;z=cy){\n for(int t=0;t> max_weight_matching_layer(const vector& A, const vector& B,\n const vector>& w){\n int n=A.size(), m=B.size();\n if(n==0||m==0) return {};\n if(n<=m){\n int M=1< dp(M,NEG), ndp(M,NEG);\n vector> pm(n+1, vector(M,-1));\n vector> pj(n+1, vector(M,-1));\n dp[0]=0;\n for(int i=0;iNEG/2){\n for(int j=0;jndp[nmask]){\n ndp[nmask]=val;\n pm[i+1][nmask]=mask;\n pj[i+1][nmask]=j;\n }\n }\n }\n dp.swap(ndp);\n }\n int bestMask=-1, bestVal=NEG;\n for(int mask=0;maskbestVal){ bestVal=dp[mask]; bestMask=mask; }\n }\n vector> res;\n int mask=bestMask;\n for(int i=n;i>=1;i--){\n int pmm=pm[i][mask];\n int pjj=pj[i][mask];\n res.push_back({A[i-1], B[pjj]});\n mask=pmm;\n }\n reverse(res.begin(), res.end());\n return res;\n }else{\n int N=1< dp(N,NEG), ndp(N,NEG);\n vector> pm(m+1, vector(N,-1));\n vector> pi(m+1, vector(N,-1));\n dp[0]=0;\n for(int j=0;jNEG/2){\n for(int i=0;indp[nmask]){\n ndp[nmask]=val;\n pm[j+1][nmask]=mask;\n pi[j+1][nmask]=i;\n }\n }\n }\n dp.swap(ndp);\n }\n int bestMask=-1, bestVal=NEG;\n for(int mask=0;maskbestVal){ bestVal=dp[mask]; bestMask=mask; }\n }\n vector> res;\n int mask=bestMask;\n for(int j=m;j>=1;j--){\n int pmm=pm[j][mask];\n int pii=pi[j][mask];\n res.push_back({A[pii], B[j-1]});\n mask=pmm;\n }\n reverse(res.begin(), res.end());\n return res;\n }\n}\n\n// ---------- column greedy / dp / chain / global-map ----------\nvector build_occ_column_greedy_frac(int D, const vector& f, const vector& r, int p, int q){\n vector> X(D), Y(D);\n for(int z=0;z> cnt(D, vector(D,0));\n for(int z=0;z occ(D*D*D,0);\n vector> used(D, vector(D,0));\n for(int z=0;zbw){ bw=w; by=y; } }\n return by;\n };\n auto best_x_for_y=[&](int y){\n int bx=xs[0], bw=-1;\n for(int x: xs){ int w=cnt[x][y]; if(w>bw){ bw=w; bx=x; } }\n return bx;\n };\n\n int placed=0;\n vector covX(D,0), covY(D,0);\n if(cx>=cy){\n for(int x: xs){\n int y=best_y_for_x(x);\n if(!used[x][y]){ used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covX[x]=1; covY[y]=1;\n }\n for(int y: ys) if(!covY[y]){\n int x=best_x_for_y(y);\n if(!used[x][y]){ used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covY[y]=1; covX[x]=1;\n }\n }else{\n for(int y: ys){\n int x=best_x_for_y(y);\n if(!used[x][y]){ used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covY[y]=1; covX[x]=1;\n }\n for(int x: xs) if(!covX[x]){\n int y=best_y_for_x(x);\n if(!used[x][y]){ used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covX[x]=1; covY[y]=1;\n }\n }\n\n if(placed> pairs;\n pairs.reserve(cx*cy);\n for(int x: xs) for(int y: ys) pairs.emplace_back(cnt[x][y],x,y);\n sort(pairs.begin(), pairs.end(), greater<>());\n for(auto &[w,x,y]: pairs){\n if(placed>=target) break;\n if(used[x][y]) continue;\n used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++;\n }\n }\n }\n return occ;\n}\n\nvector build_occ_column_dp_frac(int D, const vector& f, const vector& r, int p, int q){\n vector> X(D), Y(D);\n for(int z=0;z> cnt(D, vector(D,0));\n for(int z=0;z occ(D*D*D,0);\n vector> used(D, vector(D,0));\n for(int z=0;z covX(D,0), covY(D,0);\n int placed=0;\n for(auto [x,y]: matched){\n if(!used[x][y]){ used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covX[x]=1; covY[y]=1;\n }\n\n auto best_y_for_x=[&](int x){\n int by=ys[0], bw=-1;\n for(int y: ys){ int w=cnt[x][y]; if(w>bw){ bw=w; by=y; } }\n return by;\n };\n auto best_x_for_y=[&](int y){\n int bx=xs[0], bw=-1;\n for(int x: xs){ int w=cnt[x][y]; if(w>bw){ bw=w; bx=x; } }\n return bx;\n };\n\n for(int x: xs) if(!covX[x]){\n int y=best_y_for_x(x);\n if(!used[x][y]){ used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covX[x]=1; covY[y]=1;\n }\n for(int y: ys) if(!covY[y]){\n int x=best_x_for_y(y);\n if(!used[x][y]){ used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++; }\n covY[y]=1; covX[x]=1;\n }\n\n if(placed> pairs;\n pairs.reserve(cx*cy);\n for(int x: xs) for(int y: ys) pairs.emplace_back(cnt[x][y],x,y);\n sort(pairs.begin(), pairs.end(), greater<>());\n for(auto &[w,x,y]: pairs){\n if(placed>=target) break;\n if(used[x][y]) continue;\n used[x][y]=1; occ[idx3(D,x,y,z)]=1; placed++;\n }\n }\n }\n return occ;\n}\n\nvector build_occ_column_chain_dp_frac(int D, const vector& f, const vector& r,\n int p, int q, int beta, bool rev){\n vector> X(D), Y(D);\n for(int z=0;z> base(D, vector(D,0));\n for(int z=0;z order(D);\n iota(order.begin(), order.end(), 0);\n if(rev) reverse(order.begin(), order.end());\n\n vector> run(D, vector(D,0)), newrun(D, vector(D,0));\n vector> W(D, vector(D,0));\n\n vector occ(D*D*D,0);\n vector> used(D, vector(D,0));\n\n for(int zi=0;zi covX(D,0), covY(D,0);\n vector> chosen;\n chosen.reserve(Vmax);\n int placed=0;\n\n auto add_edge = [&](int x,int y){\n if(used[x][y]) return;\n used[x][y]=1;\n occ[idx3(D,x,y,z)] = 1;\n placed++;\n chosen.push_back({x,y});\n covX[x]=1; covY[y]=1;\n };\n\n for(auto [x,y]: matched) add_edge(x,y);\n\n auto best_y_for_x=[&](int x){\n int by=ys[0], bw=-1;\n for(int y: ys){ int ww=W[x][y]; if(ww>bw){ bw=ww; by=y; } }\n return by;\n };\n auto best_x_for_y=[&](int y){\n int bx=xs[0], bw=-1;\n for(int x: xs){ int ww=W[x][y]; if(ww>bw){ bw=ww; bx=x; } }\n return bx;\n };\n\n for(int x: xs) if(!covX[x]) add_edge(x, best_y_for_x(x));\n for(int y: ys) if(!covY[y]) add_edge(best_x_for_y(y), y);\n\n if(placed> pairs;\n pairs.reserve(cx*cy);\n for(int x: xs) for(int y: ys) pairs.emplace_back(W[x][y],x,y);\n sort(pairs.begin(), pairs.end(), greater<>());\n for(auto &[ww,x,y]: pairs){\n if(placed>=target) break;\n add_edge(x,y);\n }\n }\n\n for(int x=0;x build_occ_global_map_frac(int D, const vector& f, const vector& r, int p, int q){\n vector> cnt(D, vector(D,0));\n vector> X(D), Y(D);\n for(int z=0;z bestY(D,0), bestX(D,0);\n for(int x=0;xbw){ bw=cnt[x][y]; by=y; }\n bestY[x]=by;\n }\n for(int y=0;ybw){ bw=cnt[x][y]; bx=x; }\n bestX[y]=bx;\n }\n\n vector occ(D*D*D,0);\n vector> used(D, vector(D,0));\n\n for(int z=0;zbool{ for(int yy: ys) if(yy==y) return true; return false; };\n auto inX = [&](int x)->bool{ for(int xx: xs) if(xx==x) return true; return false; };\n\n vector covY(D,0);\n int placed=0;\n auto add_edge = [&](int x,int y){\n if(used[x][y]) return;\n used[x][y]=1;\n occ[idx3(D,x,y,z)] = 1;\n placed++;\n covY[y]=1;\n };\n\n for(int x: xs){\n int y=bestY[x];\n if(!inY(y)){\n int by=ys[0], bw=-1;\n for(int yy: ys){ int w=cnt[x][yy]; if(w>bw){ bw=w; by=yy; } }\n y=by;\n }\n add_edge(x,y);\n }\n for(int y: ys){\n if(covY[y]) continue;\n int x=bestX[y];\n if(!inX(x)){\n int bx=xs[0], bw=-1;\n for(int xx: xs){ int w=cnt[xx][y]; if(w>bw){ bw=w; bx=xx; } }\n x=bx;\n }\n add_edge(x,y);\n }\n\n if(placed> pairs;\n pairs.reserve(cx*cy);\n for(int x: xs) for(int y: ys) pairs.emplace_back(cnt[x][y],x,y);\n sort(pairs.begin(), pairs.end(), greater<>());\n for(auto &[w,x,y]: pairs){\n if(placed>=target) break;\n add_edge(x,y);\n }\n }\n }\n return occ;\n}\n\n// ---------- connected components in intersection ----------\nvector> connected_components(int D, const vector& mask){\n int N=D*D*D;\n vector vis(N,0);\n vector> comps;\n auto inside=[&](int x,int y,int z){ return 0<=x&&x q;\n vector comp;\n vis[s]=1; q.push(s);\n while(!q.empty()){\n int v=q.front(); q.pop();\n comp.push_back(v);\n int x=v/(D*D), y=(v/D)%D, z=v%D;\n for(int dir=0;dir<6;dir++){\n int nx=x+dx[dir], ny=y+dy[dir], nz=z+dz[dir];\n if(!inside(nx,ny,nz)) continue;\n int ni=idx3(D,nx,ny,nz);\n if(mask[ni] && !vis[ni]){\n vis[ni]=1; q.push(ni);\n }\n }\n }\n comps.push_back(std::move(comp));\n }\n sort(comps.begin(), comps.end(), [&](auto &a, auto &b){ return a.size()>b.size(); });\n return comps;\n}\n\n// choose a few good subset masks (not only prefixes)\nvector select_component_masks(const vector>& comps, int M, int keep){\n M = min(M, (int)comps.size());\n while(M>0 && (int)comps[M-1].size() < 4) M--;\n if(M<=0) return {0};\n\n vector> cand;\n cand.reserve(1<b.first; });\n\n vector res;\n res.push_back(0);\n for(auto &p: cand){\n if((int)res.size()>=keep) break;\n if(p.second==0) continue;\n res.push_back(p.second);\n }\n sort(res.begin(), res.end());\n res.erase(unique(res.begin(), res.end()), res.end());\n return res;\n}\n\n// ---------- sharing algorithms ----------\nint find_best_stick_lenmatch(const vector& sticks, int L){\n int bestDiv=-1, best=-1;\n int bestDivLen=-1, bestLen=-1;\n for(int i=0;i<(int)sticks.size();i++){\n const auto &s=sticks[i];\n if(s.rembestDivLen){ bestDivLen=s.rem; bestDiv=i; }\n }else{\n if(s.rem>bestLen){ bestLen=s.rem; best=i; }\n }\n }\n return (bestDiv!=-1)?bestDiv:best;\n}\n\nBuildResult simulate_with_mask(\n int D,\n const vector& occ1_in, const vector& occ2_in,\n int axis1, int axis2,\n int method, //0 lenmatch, 1 mixed, 2 pq\n const vector>& comps,\n int mask\n){\n int N=D*D*D;\n BuildResult res;\n res.b1.assign(N,0);\n res.b2.assign(N,0);\n\n vector occ1=occ1_in, occ2=occ2_in;\n int blockId=0;\n\n // place shared components in \"mask\"\n for(int i=0;i<(int)comps.size();i++){\n if(!(mask&(1< s1=build_sticks(D, occ1, axis1);\n vector s2=build_sticks(D, occ2, axis2);\n\n auto share_pq = [&](){\n priority_queue> pq1,pq2;\n for(int i=0;i<(int)s1.size();i++) if(s1[i].rem>0) pq1.push({s1[i].rem,i});\n for(int i=0;i<(int)s2.size();i++) if(s2[i].rem>0) pq2.push({s2[i].rem,i});\n auto pop_valid=[&](auto &pq, vector& ss)->int{\n while(!pq.empty()){\n auto [len,id]=pq.top();\n if(ss[id].rem!=len){ pq.pop(); continue; }\n return id;\n }\n return -1;\n };\n while(true){\n int i1=pop_valid(pq1,s1);\n int i2=pop_valid(pq2,s2);\n if(i1<0||i2<0) break;\n int L=min(s1[i1].rem, s2[i2].rem);\n blockId++;\n cut_piece(D,s1[i1],L,res.b1,blockId);\n cut_piece(D,s2[i2],L,res.b2,blockId);\n pq1.pop(); pq2.pop();\n if(s1[i1].rem>0) pq1.push({s1[i1].rem,i1});\n if(s2[i2].rem>0) pq2.push({s2[i2].rem,i2});\n }\n };\n\n if(method==0){\n for(int L=D;L>=1;L--){\n while(true){\n int i1=find_best_stick_lenmatch(s1,L);\n int i2=find_best_stick_lenmatch(s2,L);\n if(i1<0||i2<0) break;\n blockId++;\n cut_piece(D,s1[i1],L,res.b1,blockId);\n cut_piece(D,s2[i2],L,res.b2,blockId);\n }\n }\n }else if(method==1){\n for(int L=D;L>=2;L--){\n while(true){\n int i1=find_best_stick_lenmatch(s1,L);\n int i2=find_best_stick_lenmatch(s2,L);\n if(i1<0||i2<0) break;\n blockId++;\n cut_piece(D,s1[i1],L,res.b1,blockId);\n cut_piece(D,s2[i2],L,res.b2,blockId);\n }\n }\n share_pq();\n }else{\n share_pq();\n }\n\n for(auto &s: s1) if(s.rem>0){ blockId++; cut_piece(D,s,s.rem,res.b1,blockId); }\n for(auto &s: s2) if(s.rem>0){ blockId++; cut_piece(D,s,s.rem,res.b2,blockId); }\n\n res.n=blockId;\n res.obj=eval_exact(res.n,res.b1,res.b2);\n return res;\n}\n\n// ---------- hashing for dedup ----------\nstatic uint64_t hash_occ(const vector& occ){\n uint64_t h=1469598103934665603ULL;\n for(char c: occ){ h ^= (uint64_t)c; h *= 1099511628211ULL; }\n return h;\n}\nstruct OccVariant{ vector occ; };\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D; cin >> D;\n vector> F(2, vector(D)), R(2, vector(D));\n for(int i=0;i<2;i++){\n for(int z=0;z> F[i][z];\n for(int z=0;z> R[i][z];\n }\n\n // intersection components\n vector allowed1=build_allowed(D,F[0],R[0]);\n vector allowed2=build_allowed(D,F[1],R[1]);\n vector inter(D*D*D,0);\n for(int i=0;i<(int)inter.size();i++) inter[i]=(allowed1[i] && allowed2[i])?1:0;\n auto compsAll = connected_components(D, inter);\n\n // take top M comps for subset masks\n int M = min(6, (int)compsAll.size());\n vector> comps(compsAll.begin(), compsAll.begin()+M);\n // choose ~5 masks incl empty\n vector masks = select_component_masks(comps, M, 5);\n\n const vector> fracs = {{0,1},{1,4},{1,2},{3,4}};\n const vector betas = {3,12,30};\n\n vector vars[2];\n for(int obj=0;obj<2;obj++){\n vector> list;\n list.push_back(build_occ_full(D,F[obj],R[obj]));\n list.push_back(build_occ_min(D,F[obj],R[obj]));\n list.push_back(build_occ_star(D,F[obj],R[obj]));\n\n for(auto [p,q]: fracs){\n list.push_back(build_occ_column_greedy_frac(D,F[obj],R[obj],p,q));\n list.push_back(build_occ_column_dp_frac(D,F[obj],R[obj],p,q));\n list.push_back(build_occ_global_map_frac(D,F[obj],R[obj],p,q));\n }\n for(auto [p,q]: fracs){\n for(int beta: betas){\n for(bool rev: {false,true}){\n list.push_back(build_occ_column_chain_dp_frac(D,F[obj],R[obj],p,q,beta,rev));\n }\n }\n }\n\n auto [Vmin,Vmax]=get_Vmin_Vmax(D,F[obj],R[obj]);\n vector Ts = {Vmin, Vmax, (Vmin+Vmax)/2, Vmin+(Vmax-Vmin)/4, Vmin+(Vmax-Vmin)*3/4};\n sort(Ts.begin(), Ts.end());\n Ts.erase(unique(Ts.begin(), Ts.end()), Ts.end());\n for(int T: Ts) for(int biasAxis: {0,1}){\n list.push_back(build_occ_target(D,F[obj],R[obj],biasAxis,T));\n }\n\n unordered_set seen;\n for(auto &occ: list){\n uint64_t h=hash_occ(occ);\n if(seen.insert(h).second) vars[obj].push_back({std::move(occ)});\n }\n }\n\n vector axes={0,1,2};\n vector methods={0,1,2}; // lenmatch/mixed/pq\n\n BuildResult best;\n for(const auto &v1: vars[0]) for(const auto &v2: vars[1]){\n for(int a1: axes) for(int a2: axes){\n for(int method: methods){\n for(int mask: masks){\n auto res = simulate_with_mask(D, v1.occ, v2.occ, a1, a2, method, comps, mask);\n if(res.obj < best.obj) best = std::move(res);\n }\n }\n }\n }\n\n cout << best.n << \"\\n\";\n for(int i=0;i\nusing namespace std;\n\nstatic const long long INFLL = (1LL<<60);\nstatic const int MAXP = 5000;\nstatic const int TOOFAR = 5001;\n\nstruct Edge { int u,v; long long w; };\n\nstruct DSU {\n vector p, r;\n DSU(int n=0): p(n), r(n,0) { iota(p.begin(), p.end(), 0); }\n int find(int a){ return p[a]==a? a : p[a]=find(p[a]); }\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a]0 && (r-1)*(r-1) >= x) --r;\n if(r > MAXP) return TOOFAR;\n return (int)r;\n}\n\nstruct Sol {\n bool valid=false;\n long long S=INFLL;\n vector P; // N\n vector B; // M\n vector cnt; // N\n vector assign; // K\n vector adist; // K\n};\n\nenum EvalMode { FAST=0, MID=1, FINAL=2 };\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N,M,K;\n cin>>N>>M>>K;\n vector x(N), y(N);\n for(int i=0;i>x[i]>>y[i];\n\n vector edges(M);\n\n vector> dist(N, vector(N, INFLL));\n vector> nxt(N, vector(N, -1));\n vector> edgeId(N, vector(N, -1));\n for(int i=0;i>u>>v>>w; --u; --v;\n edges[j]={u,v,w};\n if(w < dist[u][v]){\n dist[u][v]=dist[v][u]=w;\n nxt[u][v]=v; nxt[v][u]=u;\n edgeId[u][v]=edgeId[v][u]=j;\n }\n }\n\n vector a(K), b(K);\n for(int k=0;k>a[k]>>b[k];\n\n // resident->station distances\n vector> d(K);\n for(int k=0;kMAXP) cd=TOOFAR;\n d[k][i]=(uint16_t)cd;\n }\n }\n\n // candidates per resident within 5000\n vector>> cand(K);\n for(int k=0;k> v;\n v.reserve(N);\n for(int i=0;i> stationResidents(N);\n stationResidents.assign(N, {});\n stationResidents.shrink_to_fit();\n stationResidents.assign(N, {});\n for(int k=0;k& mark){\n int cur=s;\n while(cur!=t){\n int nx = nxt[cur][t];\n if(nx<0) return;\n int eid = edgeId[cur][nx];\n if(eid>=0) mark[eid]=1;\n cur=nx;\n }\n };\n\n // Pre-sort edges by weight\n vector sortedEdgeIds(M);\n iota(sortedEdgeIds.begin(), sortedEdgeIds.end(), 0);\n sort(sortedEdgeIds.begin(), sortedEdgeIds.end(), [&](int i,int j){ return edges[i].w < edges[j].w; });\n\n // global MST edges for candidate cable #3\n vector isMst(M,0);\n {\n DSU dsu(N);\n for(int id: sortedEdgeIds){\n if(dsu.unite(edges[id].u, edges[id].v)) isMst[id]=1;\n }\n }\n\n auto prune_and_root = [&](vector alive, const vector& terminal)->pair, long long>{\n vector>> g(N);\n vector deg(N,0);\n for(int id=0;id q;\n vector inq(N,0);\n for(int i=0;i vis(N,0);\n deque bfs;\n vis[0]=1; bfs.push_back(0);\n while(!bfs.empty()){\n int v=bfs.front(); bfs.pop_front();\n for(auto [to,eid]: g[v]) if(alive[eid] && !vis[to]){\n vis[to]=1; bfs.push_back(to);\n }\n }\n for(int id=0;id B(M,0);\n for(int id=0;id& marked, const vector& terminal)->pair, long long>{\n DSU dsu(N);\n vector alive(M,0);\n vector ids;\n ids.reserve(M);\n for(int id=0;id& B, const vector& terminal)->pair, long long>{\n vector usedV(N,0);\n for(int i=0;i alive(M,0);\n for(int id: sortedEdgeIds){\n int u=edges[id].u, v=edges[id].v;\n if(!usedV[u] || !usedV[v]) continue;\n if(dsu.unite(u,v)) alive[id]=1;\n }\n return prune_and_root(move(alive), terminal);\n };\n\n auto build_cables = [&](const vector& P)->pair, long long>{\n vector terminal(N,0);\n terminal[0]=1;\n vector terms;\n terms.reserve(N);\n terms.push_back(0);\n for(int i=1;i0){ terminal[i]=1; terms.push_back(i); }\n\n pair, long long> best = {vector(M,0), INFLL};\n\n auto consider = [&](pair, long long> candTree){\n if(candTree.second >= INFLL/2) return;\n auto improved = improve_tree_by_mst_on_used_nodes(candTree.first, terminal);\n if(improved.second < best.second) best = move(improved);\n };\n\n // #1 KMB metric MST expansion\n {\n int T=(int)terms.size();\n vector bestd(T, INFLL);\n vector parent(T,-1);\n vector used(T,0);\n bestd[0]=0;\n bool ok=true;\n for(int it=0;it=INFLL/2){ ok=false; break; }\n used[v]=1;\n int vv=terms[v];\n for(int i=0;i mark(M,0);\n for(int i=1;i mark(M,0);\n for(int t: terms) reconstruct_path_edges(0,t,mark);\n consider(kruskal_then_prune(mark, terminal));\n }\n // #3 pruned global MST\n {\n consider(prune_and_root(isMst, terminal));\n }\n return best;\n };\n\n auto recompute_P_cnt = [&](const vector& assign, const vector& adist){\n vector P(N,0), cnt(N,0);\n for(int k=0;k,vector>(move(P), move(cnt));\n };\n\n auto compute_total = [&](const vector& P)->pair>{\n long long rad=0;\n for(int i=0;i=INFLL/2) return {INFLL, B};\n return {rad+ec, B};\n };\n\n auto t_start = chrono::steady_clock::now();\n auto elapsed_ms = [&](){\n return chrono::duration_cast(chrono::steady_clock::now()-t_start).count();\n };\n\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n // Clean local improvement; capChecks=0 => full scan\n auto local_improve = [&](const vector& U,\n vector& assign, vector& adist,\n vector& P, vector& cnt,\n int passes, int capChecks){\n if(passes<=0) return;\n\n vector counts(N*(MAXP+1), 0);\n auto idxc = [&](int s,int distv){ return s*(MAXP+1)+distv; };\n for(int k=0;kint{\n for(int dd=start; dd>=1; dd--) if(counts[idxc(s,dd)]>0) return dd;\n return 0;\n };\n for(int s=0;s order(K);\n iota(order.begin(), order.end(), 0);\n\n for(int pass=0; pass 1970) break;\n shuffle(order.begin(), order.end(), rng);\n bool any=false;\n\n for(int k: order){\n int s=assign[k];\n int ds=adist[k];\n int Ps=P[s];\n\n auto Ps_after_remove = [&]()->int{\n if(cnt[s]==1) return 0;\n if(ds=2) return Ps;\n return recompute_max_down(s, Ps-1);\n };\n int PsRem = Ps_after_remove();\n\n long long bestDelta=0;\n int bestT=-1, bestDt=0;\n int checked=0;\n\n for(auto [dt,t]: cand[k]){\n if(!U[t] || t==s) continue;\n checked++;\n int Pt=P[t];\n int PtAdd=max(Pt, dt);\n long long delta = 1LL*PsRem*PsRem + 1LL*PtAdd*PtAdd\n - 1LL*Ps*Ps - 1LL*Pt*Pt;\n if(delta < bestDelta){\n bestDelta=delta;\n bestT=t; bestDt=dt;\n }\n if(capChecks>0 && checked>=capChecks) break;\n }\n\n if(bestT>=0){\n int t=bestT, dt=bestDt;\n counts[idxc(s,ds)]--;\n counts[idxc(t,dt)]++;\n cnt[s]--;\n cnt[t]++;\n\n if(cnt[s]==0) P[s]=0;\n else if(ds==P[s] && counts[idxc(s,P[s])]==0) P[s]=recompute_max_down(s, P[s]-1);\n\n if(dt>P[t]) P[t]=dt;\n\n assign[k]=t;\n adist[k]=dt;\n any=true;\n }\n }\n if(!any) break;\n }\n\n auto tmp = recompute_P_cnt(assign, adist);\n P.swap(tmp.first);\n cnt.swap(tmp.second);\n };\n\n auto greedy_assign = [&](const vector& U, double openLambda, bool shuffleResidents, Sol& out)->bool{\n out.assign.assign(K, -1);\n out.adist.assign(K, 0);\n out.P.assign(N, 0);\n out.cnt.assign(N, 0);\n\n vector order(K);\n iota(order.begin(), order.end(), 0);\n if(shuffleResidents) shuffle(order.begin(), order.end(), rng);\n\n vector opened; opened.reserve(N);\n vector isOpened(N,0);\n opened.push_back(0); isOpened[0]=1;\n\n auto minDistToOpened = [&](int i)->long long{\n long long md=INFLL;\n for(int j: opened) md=min(md, dist[i][j]);\n return md;\n };\n\n for(int idx=0; idx& U, Sol& s, int TH, int TRY_LIMIT){\n auto baseTot = compute_total(s.P);\n long long curS = baseTot.first;\n if(curS>=INFLL/2) return;\n\n vector> members(N);\n for(int k=0;k small;\n for(int i=1;i0 && s.cnt[i]<=TH) small.push_back(i);\n sort(small.begin(), small.end(), [&](int a,int b){\n if(s.cnt[a]!=s.cnt[b]) return s.cnt[a] < s.cnt[b];\n return s.P[a] > s.P[b];\n });\n if((int)small.size() > TRY_LIMIT) small.resize(TRY_LIMIT);\n\n for(int st: small){\n if(elapsed_ms() > 1970) break;\n if(s.cnt[st]==0) continue;\n\n vector ks = members[st];\n sort(ks.begin(), ks.end(), [&](int k1,int k2){ return s.adist[k1] > s.adist[k2]; });\n\n vector> saveA, saveD;\n saveA.reserve(ks.size());\n saveD.reserve(ks.size());\n for(int k: ks){ saveA.push_back({k, s.assign[k]}); saveD.push_back({k, s.adist[k]}); }\n\n vector tempP = s.P;\n bool ok=true;\n for(int k: ks){\n long long bestDelta=INFLL;\n int bestT=-1, bestDt=0;\n int used=0, limit=18;\n for(auto [dt,t]: cand[k]){\n if(!U[t] || t==st) continue;\n used++;\n long long delta = 1LL*max(tempP[t], dt)*max(tempP[t], dt) - 1LL*tempP[t]*tempP[t];\n if(delta < bestDelta){\n bestDelta=delta;\n bestT=t; bestDt=dt;\n }\n if(used>=limit) break;\n }\n if(bestT<0){ ok=false; break; }\n s.assign[k]=bestT;\n s.adist[k]=bestDt;\n tempP[bestT]=max(tempP[bestT], bestDt);\n }\n if(!ok){\n for(auto &pr: saveA) s.assign[pr.first]=pr.second;\n for(auto &pr: saveD) s.adist[pr.first]=pr.second;\n continue;\n }\n\n auto tmp = recompute_P_cnt(s.assign, s.adist);\n s.P.swap(tmp.first);\n s.cnt.swap(tmp.second);\n\n local_improve(U, s.assign, s.adist, s.P, s.cnt, /*passes=*/2, /*capChecks=*/0);\n\n auto newTot = compute_total(s.P);\n long long newS = newTot.first;\n if(newS < curS){\n curS = newS;\n members.assign(N, {});\n for(int k=0;k& U, double openLambda, EvalMode mode, int trials)->Sol{\n Sol best; best.valid=false; best.S=INFLL;\n\n for(int t=0;t 1970) break;\n\n Sol s;\n bool ok = greedy_assign(U, openLambda, /*shuffleResidents=*/(t>0), s);\n if(!ok) continue;\n\n if(mode==MID){\n local_improve(U, s.assign, s.adist, s.P, s.cnt, /*passes=*/2, /*capChecks=*/14);\n } else if(mode==FINAL){\n local_improve(U, s.assign, s.adist, s.P, s.cnt, /*passes=*/5, /*capChecks=*/0);\n terminal_elim(U, s, /*TH=*/70, /*TRY_LIMIT=*/18);\n local_improve(U, s.assign, s.adist, s.P, s.cnt, /*passes=*/3, /*capChecks=*/0);\n }\n\n auto tmp = recompute_P_cnt(s.assign, s.adist);\n s.P.swap(tmp.first);\n s.cnt.swap(tmp.second);\n\n auto tot = compute_total(s.P);\n s.S = tot.first;\n s.B = move(tot.second);\n s.valid = (s.S < INFLL/2);\n\n if(s.valid && s.S < best.S) best = move(s);\n }\n return best;\n };\n\n // Build initial feasibility counts for U=all-on\n auto init_activeCount = [&](){\n vector activeCount(K, 0);\n for(int k=0;k& U, const vector& activeCount)->bool{\n if(st==0) return false;\n if(!U[st]) return true;\n for(int k: stationResidents[st]){\n if(activeCount[k] <= 1) return false;\n }\n return true;\n };\n\n auto apply_toggle = [&](int st, vector& U, vector& activeCount){\n if(U[st]){\n // turn off\n U[st]=0;\n for(int k: stationResidents[st]) activeCount[k]--;\n }else{\n // turn on\n U[st]=1;\n for(int k: stationResidents[st]) activeCount[k]++;\n }\n };\n\n Sol bestGlobal; bestGlobal.valid=false; bestGlobal.S=INFLL;\n\n vector lambdas = {0.16, 0.20, 0.24};\n int restarts = 3;\n\n for(int rep=0; rep U(N,1);\n U[0]=1;\n vector activeCount = init_activeCount();\n\n // SA with FAST eval (just greedy)\n Sol cur = evaluate(U, 0.20, FAST, 1);\n if(!cur.valid) continue;\n vector bestU = U;\n vector bestActive = activeCount;\n long long bestS = cur.S;\n\n double T0=7e7, T1=8e5;\n int SA_IT = 340; // a bit more, now many infeasible toggles are filtered\n\n for(int it=0; it(1, N-1)(rng);\n\n // fast feasibility check if turning off\n if(U[v] && !can_turn_off(v, U, activeCount)) continue;\n\n apply_toggle(v, U, activeCount);\n\n Sol nxt = evaluate(U, 0.20, FAST, 1);\n if(!nxt.valid){\n apply_toggle(v, U, activeCount);\n continue;\n }\n\n long long diff = nxt.S - cur.S;\n bool accept = false;\n if(diff<=0) accept=true;\n else{\n double prob = exp(-(double)diff / T);\n double r = uniform_real_distribution(0.0,1.0)(rng);\n accept = (r < prob);\n }\n\n if(accept){\n cur = move(nxt);\n if(cur.S < bestS){\n bestS = cur.S;\n bestU = U;\n bestActive = activeCount;\n }\n }else{\n apply_toggle(v, U, activeCount);\n }\n }\n\n // Greedy pruning with MID eval\n if(elapsed_ms() < 1900){\n vector Ucur = bestU;\n vector activeCur = bestActive;\n Sol base = evaluate(Ucur, 0.20, MID, 1);\n if(base.valid){\n bool improved=true;\n while(improved && elapsed_ms()<1900){\n improved=false;\n vector ons;\n for(int i=1;i30) ons.resize(30);\n\n for(int v: ons){\n if(elapsed_ms()>1900) break;\n if(!can_turn_off(v, Ucur, activeCur)) continue;\n apply_toggle(v, Ucur, activeCur); // off\n Sol candS = evaluate(Ucur, 0.20, MID, 1);\n if(candS.valid && candS.S < base.S){\n base = move(candS);\n improved=true;\n break;\n }else{\n apply_toggle(v, Ucur, activeCur); // rollback on\n }\n }\n }\n bestU = Ucur;\n bestActive = activeCur;\n }\n }\n\n // Finalize with FINAL eval and lambdas\n for(double lam: lambdas){\n if(elapsed_ms() > 1950) break;\n Sol fin = evaluate(bestU, lam, FINAL, /*trials=*/2);\n if(fin.valid && fin.S < bestGlobal.S) bestGlobal = move(fin);\n }\n }\n\n if(!bestGlobal.valid){\n for(int i=0;i\nusing namespace std;\n\nstatic constexpr int N = 30;\nstatic constexpr int M = N * (N + 1) / 2;\nstatic constexpr int MAX_OPS = 10000;\n\nstatic inline int id(int x, int y) { return x * (x + 1) / 2 + y; }\n\nstruct OpID { int a, b; };\n\nenum class Policy : uint8_t { Larger = 0, Random = 1 };\n\nstruct Params {\n int8_t D; // -1 disables window pull-up\n int8_t W; // window depth\n int16_t L; // number of smallest values to bubble up\n int8_t wDepth; // depth penalty weight (0 => pure min)\n uint8_t skipOK; // 1: skip window pull if root already heap-ok vs children\n Policy pathPol;\n Policy upPol;\n uint8_t order; // 0: window then bubble, 1: bubble then window\n};\n\nstruct SplitMix64 {\n uint64_t x;\n explicit SplitMix64(uint64_t seed=0) : x(seed) {}\n uint64_t next_u64() {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Input\n static int initVal[M];\n for (int x = 0; x < N; x++) for (int y = 0; y <= x; y++) {\n int v; cin >> v;\n initVal[id(x,y)] = v;\n }\n\n // Precompute relations\n static int Xc[M], Yc[M];\n static int par0[M], par1[M], ch0[M], ch1[M];\n for (int x = 0; x < N; x++) for (int y = 0; y <= x; y++) {\n int u = id(x,y);\n Xc[u] = x; Yc[u] = y;\n par0[u] = par1[u] = -1;\n ch0[u] = ch1[u] = -1;\n if (x > 0) {\n if (y - 1 >= 0) par0[u] = id(x-1, y-1);\n if (y <= x-1) par1[u] = id(x-1, y);\n }\n if (x + 1 < N) {\n ch0[u] = id(x+1, y);\n ch1[u] = id(x+1, y+1);\n }\n }\n\n // Seed from input\n uint64_t h = 1469598103934665603ULL;\n for (int u = 0; u < M; u++) {\n h ^= (uint64_t)initVal[u] + 0x9e3779b97f4a7c15ULL + (h<<6) + (h>>2);\n }\n SplitMix64 master(h ^ 0x1234567890abcdefULL);\n\n static int val[M];\n static int posOfVal[M];\n\n struct RunOut { int K; OpID ops[MAX_OPS]; };\n\n auto run_once = [&](Params pm, uint64_t seed) -> RunOut {\n // normalize to reduce useless search states\n if (pm.D < 0) { pm.W = 0; pm.wDepth = 0; pm.skipOK = 0; }\n\n memcpy(val, initVal, sizeof(int)*M);\n for (int u = 0; u < M; u++) posOfVal[val[u]] = u;\n\n SplitMix64 rng(seed);\n RunOut out; out.K = 0;\n\n auto can_more = [&]() { return out.K < MAX_OPS; };\n\n auto do_swap = [&](int a, int b) {\n int va = val[a], vb = val[b];\n val[a] = vb; val[b] = va;\n posOfVal[va] = b;\n posOfVal[vb] = a;\n\n if (out.K > 0 && out.ops[out.K-1].a == b && out.ops[out.K-1].b == a) {\n out.K--;\n return;\n }\n out.ops[out.K++] = {a,b};\n };\n\n auto choose_parent = [&](int p0, int p1, Policy pol) -> int {\n if (p0 == -1) return p1;\n if (p1 == -1) return p0;\n if (pol == Policy::Random) return (rng.next_u64() & 1ULL) ? p0 : p1;\n return (val[p0] > val[p1]) ? p0 : p1; // Larger\n };\n\n auto phase_window_pull = [&]() {\n int D = pm.D, W = pm.W;\n if (D < 0) return;\n D = min(D, N-1);\n W = max(0, min(W, N-1));\n int wDepth = max(0, (int)pm.wDepth);\n bool skipOK = (pm.skipOK != 0);\n\n for (int sx = 0; sx <= D && can_more(); sx++) {\n int sxBase = sx*(sx+1)/2;\n for (int sy = 0; sy <= sx && can_more(); sy++) {\n int root = sxBase + sy;\n\n if (skipOK) {\n int cA = ch0[root];\n if (cA != -1) {\n int cB = ch1[root];\n int vr = val[root];\n if (vr < val[cA] && vr < val[cB]) continue;\n }\n }\n\n int best = root;\n int bestv = val[root];\n int bestScore = bestv;\n\n int maxx = min(N-1, sx + W);\n for (int x = sx; x <= maxx; x++) {\n int base = x*(x+1)/2;\n int dx = x - sx;\n int depthPenalty = wDepth * dx;\n int ylo = sy;\n int yhi = sy + dx;\n for (int y = ylo; y <= yhi; y++) {\n int u = base + y;\n int v = val[u];\n int sc = v + depthPenalty;\n if (sc < bestScore || (sc == bestScore && v < bestv)) {\n bestScore = sc;\n bestv = v;\n best = u;\n }\n }\n }\n if (best == root) continue;\n\n int u = best;\n while (can_more() && Xc[u] > sx) {\n int x = Xc[u], y = Yc[u];\n int rem = x - sx;\n int leftNeed = y - sy;\n bool canLeft = (leftNeed > 0);\n bool canRight = (leftNeed < rem);\n\n int pu;\n if (canLeft && canRight) pu = choose_parent(par0[u], par1[u], pm.pathPol);\n else if (canLeft) pu = par0[u];\n else pu = par1[u];\n\n do_swap(u, pu);\n u = pu;\n }\n }\n }\n };\n\n auto phase_bubble_small = [&]() {\n int L = pm.L;\n L = max(0, min(L, M));\n for (int v = 0; v < L && can_more(); v++) {\n while (can_more()) {\n int u = posOfVal[v];\n if (Xc[u] == 0) break;\n\n int pA = par0[u], pB = par1[u];\n int cur = val[u];\n bool okA = (pA != -1 && val[pA] > cur);\n bool okB = (pB != -1 && val[pB] > cur);\n if (!okA && !okB) break;\n\n int pu;\n if (okA && okB) pu = choose_parent(pA, pB, pm.upPol);\n else pu = okA ? pA : pB;\n\n do_swap(u, pu);\n }\n }\n };\n\n if (pm.order == 0) { phase_window_pull(); phase_bubble_small(); }\n else { phase_bubble_small(); phase_window_pull(); }\n\n // Floyd heapify (guarantee E=0)\n auto siftDown = [&](int start) {\n int u = start;\n while (can_more()) {\n int cA = ch0[u];\n if (cA == -1) break;\n int cB = ch1[u];\n int best = u;\n if (val[cA] < val[best]) best = cA;\n if (cB != -1 && val[cB] < val[best]) best = cB;\n if (best == u) break;\n do_swap(u, best);\n u = best;\n }\n };\n for (int x = N-2; x >= 0 && can_more(); x--) {\n int base = x*(x+1)/2;\n for (int y = 0; y <= x && can_more(); y++) siftDown(base + y);\n }\n\n return out;\n };\n\n // Time control\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed_ms = [&]() -> double {\n return chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n };\n\n // Best solution storage\n int bestK = INT_MAX;\n vector bestOps;\n\n auto evaluate = [&](const Params &pm) -> int {\n RunOut out = run_once(pm, master.next_u64());\n if (out.K < bestK) {\n bestK = out.K;\n bestOps.assign(out.ops, out.ops + out.K);\n }\n return out.K;\n };\n\n // Pool for guided search\n struct Cand { int K; Params pm; };\n vector pool;\n auto push_pool = [&](int K, const Params &pm) {\n pool.push_back({K, pm});\n sort(pool.begin(), pool.end(), [](const Cand& a, const Cand& b){ return a.K < b.K; });\n if ((int)pool.size() > 18) pool.resize(18);\n };\n\n auto clampi = [&](int &v, int lo, int hi){ v = max(lo, min(hi, v)); };\n\n // Curated portfolio (small)\n vector> DW = { {-1,0}, {0,6}, {4,10}, {6,29} };\n vector Ls = {0, 120, 160, 200, 240};\n vector wDs = {0, 8};\n int skips[2] = {0, 1};\n int orders[2] = {0, 1};\n Policy pols[2] = {Policy::Larger, Policy::Random};\n\n for (auto [D,W] : DW) {\n for (int L : Ls) for (int o : orders) for (Policy pathPol : pols) for (Policy upPol : pols) {\n if (elapsed_ms() > 320.0) break;\n if (D < 0) {\n Params pm{(int8_t)D,(int8_t)0,(int16_t)L,(int8_t)0,(uint8_t)0,pathPol,upPol,(uint8_t)o};\n int K = evaluate(pm);\n push_pool(K, pm);\n } else {\n for (int wd : wDs) for (int sk : skips) {\n if (elapsed_ms() > 320.0) break;\n Params pm{(int8_t)D,(int8_t)W,(int16_t)L,(int8_t)wd,(uint8_t)sk,pathPol,upPol,(uint8_t)o};\n int K = evaluate(pm);\n push_pool(K, pm);\n }\n }\n }\n }\n\n // Guided search\n while (elapsed_ms() < 1750.0) {\n Params pm;\n bool local = !pool.empty() && (master.next_u64() % 10) < 8;\n if (local) {\n int sz = (int)pool.size();\n int r = (int)(master.next_u64() % (uint64_t)(sz*sz));\n int idx = r / sz;\n pm = pool[idx].pm;\n\n if ((master.next_u64() % 10) < 7) {\n int D = pm.D + (int)(master.next_u64()%3) - 1;\n clampi(D, -1, 7);\n pm.D = (int8_t)D;\n if (pm.D < 0) { pm.W = 0; pm.wDepth = 0; pm.skipOK = 0; }\n }\n if (pm.D >= 0 && (master.next_u64() % 10) < 7) {\n uint64_t t = master.next_u64() % 10;\n pm.W = (t < 4 ? 6 : (t < 7 ? 10 : 29));\n }\n if ((master.next_u64() % 10) < 9) {\n static const int step[11] = {-60,-40,-20,-10,0,10,20,40,60,80,-80};\n int L = (int)pm.L + step[master.next_u64()%11];\n clampi(L, 0, 260);\n pm.L = (int16_t)L;\n }\n if (pm.D >= 0 && (master.next_u64() % 10) < 5) {\n static const int wstep[5] = {-4,0,4,8,-8};\n int wd = (int)pm.wDepth + wstep[master.next_u64()%5];\n clampi(wd, 0, 20);\n pm.wDepth = (int8_t)wd;\n }\n if (pm.D >= 0 && (master.next_u64() % 12) == 0) pm.skipOK ^= 1;\n if ((master.next_u64() % 12) == 0) pm.order ^= 1;\n if ((master.next_u64() % 14) == 0) pm.pathPol = (pm.pathPol==Policy::Larger?Policy::Random:Policy::Larger);\n if ((master.next_u64() % 14) == 0) pm.upPol = (pm.upPol==Policy::Larger?Policy::Random:Policy::Larger);\n } else {\n int D = ((master.next_u64()%10) < 2) ? -1 : (int)(master.next_u64()%8);\n pm.D = (int8_t)D;\n if (D < 0) {\n pm.W = 0; pm.wDepth = 0; pm.skipOK = 0;\n } else {\n uint64_t tw = master.next_u64()%10;\n pm.W = (tw < 4 ? 6 : (tw < 7 ? 10 : 29));\n pm.wDepth = (int8_t)((master.next_u64()%6)*4);\n pm.skipOK = (uint8_t)(master.next_u64()%2);\n }\n uint64_t tl = master.next_u64()%10;\n pm.L = (int16_t)(tl < 8 ? (120 + (int)(master.next_u64()%111)) : (int)(master.next_u64()%261));\n pm.pathPol = pols[master.next_u64()%2];\n pm.upPol = pols[master.next_u64()%2];\n pm.order = (uint8_t)(master.next_u64()%2);\n }\n\n int K = evaluate(pm);\n push_pool(K, pm);\n\n // mild continuous intensification: occasionally retry the current best params\n if (!pool.empty() && (master.next_u64()%25)==0) {\n int K2 = evaluate(pool[0].pm);\n push_pool(K2, pool[0].pm);\n }\n }\n\n // Final intensification: re-run top params many times with different seeds\n // This is especially useful when policies are Random.\n while (elapsed_ms() < 1900.0 && !pool.empty()) {\n int top = min(6, pool.size());\n for (int i = 0; i < top && elapsed_ms() < 1900.0; i++) {\n int K = evaluate(pool[i].pm);\n push_pool(K, pool[i].pm);\n }\n }\n\n // Output best\n cout << bestK << \"\\n\";\n for (auto &op : bestOps) {\n int a = op.a, b = op.b;\n cout << Xc[a] << \" \" << Yc[a] << \" \" << Xc[b] << \" \" << Yc[b] << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nstatic constexpr int D = 9;\n\nstruct XorShift {\n uint64_t x;\n XorShift(uint64_t seed=88172645463325252ull): x(seed) {}\n uint32_t next_u32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n int next_int(int n) { return (int)(next_u32() % (uint32_t)n); }\n};\n\nstruct Cell { int r, c; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Din, N;\n cin >> Din >> N;\n int ent_r = 0, ent_c = (D - 1) / 2;\n int entId = ent_r * D + ent_c;\n\n bool obstacle[D][D]{};\n uint64_t seed = 88172645463325252ull;\n for (int k = 0; k < N; k++) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n seed ^= (uint64_t)(r * 131 + c * 911 + 12345) * 1000003ull;\n }\n\n int M = D * D - 1 - N; // labels 0..M-1\n\n int dr[4] = {1,-1,0,0};\n int dc[4] = {0,0,1,-1};\n\n auto idx = [&](int r,int c){ return r*D + c; };\n auto rc = [&](int id)->Cell{ return {id/D, id%D}; };\n\n // Precompute neighbors for speed\n array,81> nb;\n for(int id=0; id<81; id++){\n auto [r,c]=rc(id);\n for(int k=0;k<4;k++){\n int nr=r+dr[k], nc=c+dc[k];\n if(nr<0||nr>=D||nc<0||nc>=D) nb[id][k]=-1;\n else nb[id][k]=idx(nr,nc);\n }\n }\n\n // ---------- Static BFS distance (obstacles only) ----------\n const int INF = 1e9;\n int dist0[D][D];\n for(int i=0;i q;\n dist0[ent_r][ent_c]=0;\n q.push(entId);\n while(!q.empty()){\n int v=q.front(); q.pop();\n auto [r,c]=rc(v);\n for(int k=0;k<4;k++){\n int to=nb[v][k];\n if(to<0) continue;\n auto [nr,nc]=rc(to);\n if(obstacle[nr][nc]) continue;\n if(dist0[nr][nc]!=INF) continue;\n dist0[nr][nc]=dist0[r][c]+1;\n q.push(to);\n }\n }\n\n // ---------- distRank (near->far) ----------\n vector usable;\n usable.reserve(M);\n for(int i=0;i children[81];\n for(int i=0;i<81;i++){ parentId[i]=-1; children[i].clear(); }\n\n vector order;\n order.reserve(81);\n for(int r=0;r post=order;\n sort(post.begin(), post.end(), [&](int a,int b){\n auto A=rc(a), B=rc(b);\n int da=dist0[A.r][A.c], db=dist0[B.r][B.c];\n if(da!=db) return da>db;\n return a leaf\n vector usable2 = usable;\n sort(usable2.begin(), usable2.end(), [&](const Cell& a, const Cell& b){\n int sa=subtreeSize[idx(a.r,a.c)];\n int sb=subtreeSize[idx(b.r,b.c)];\n if(sa!=sb) return sa>sb;\n int da=dist0[a.r][a.c], db=dist0[b.r][b.c];\n if(da!=db) return da nn;\n nn.reserve(81);\n for(int i=0;i> art(D, vector(D,0));\n int root=id[ent_r][ent_c];\n if(root<0) return art;\n\n int V=(int)nn.size();\n vector disc(V,0), low(V,0), parent(V,-1);\n vector isArt(V,0);\n int timer=0;\n\n function dfs = [&](int u){\n disc[u]=low[u]=++timer;\n int child=0;\n auto [r,c]=nn[u];\n int vid=idx(r,c);\n for(int k=0;k<4;k++){\n int to=nb[vid][k];\n if(to<0) continue;\n auto [nr,nc]=rc(to);\n int v=id[nr][nc];\n if(v<0) continue;\n if(!disc[v]){\n parent[v]=u;\n child++;\n dfs(v);\n low[u]=min(low[u], low[v]);\n if(parent[u]==-1){\n if(child>1) isArt[u]=1;\n }else{\n if(low[v]>=disc[u]) isArt[u]=1;\n }\n }else if(v!=parent[u]){\n low[u]=min(low[u], disc[v]);\n }\n }\n };\n dfs(root);\n\n for(int u=0;udb) best={i,j}; }\n else if(gi!=gb){ if(gi> t;\n auto art = compute_articulation(emptyCell);\n\n int desiredPeel = (M - 1 - t);\n int desiredDist = t;\n int desiredSub = t;\n\n Cell chosen{-1,-1};\n long long bestScore = (1LL<<60);\n\n for(int i=0;i isObs;\n for(int v=0; v<81; v++){\n auto [r,c]=rc(v);\n if(obstacle[r][c]) isObs.set(v);\n }\n\n auto label_of_cell = [&](int id)->int{\n auto [r,c]=rc(id);\n return labelAt[r][c];\n };\n\n // prefix masks for counting remaining labels < x\n array, 129> pref;\n pref[0].reset();\n for(int i=1;i<=128;i++){\n pref[i] = pref[i-1];\n pref[i].set(i-1);\n }\n\n auto bfs_reachable = [&](const bitset<81>& removedMask){\n bitset<81> reach; reach.reset();\n queue qq;\n reach.set(entId);\n qq.push(entId);\n\n auto isEmptyNow = [&](int id)->bool{\n if(isObs.test(id)) return false;\n if(id==entId) return true;\n return removedMask.test(id);\n };\n\n while(!qq.empty()){\n int v=qq.front(); qq.pop();\n for(int k=0;k<4;k++){\n int to=nb[v][k];\n if(to<0) continue;\n if(reach.test(to)) continue;\n if(isEmptyNow(to)){\n reach.set(to);\n qq.push(to);\n }\n }\n }\n return reach;\n };\n\n auto frontier_list = [&](const bitset<81>& removedMask, const bitset<81>& reach, array& inFront){\n inFront.fill(0);\n vector front;\n front.reserve(40);\n for(int v=0; v<81; v++){\n if(v==entId) continue;\n if(isObs.test(v)) continue;\n if(removedMask.test(v)) continue;\n bool ok=false;\n for(int k=0;k<4;k++){\n int to=nb[v][k];\n if(to<0) continue;\n if(reach.test(to)) { ok=true; break; }\n }\n if(ok){\n inFront[v]=1;\n front.push_back(v);\n }\n }\n return front;\n };\n\n auto unlock_score = [&](int v, const bitset<81>& removedMask, const array& inFront){\n int sc=0;\n for(int k=0;k<4;k++){\n int nbv=nb[v][k];\n if(nbv<0) continue;\n if(nbv==entId) continue;\n if(isObs.test(nbv)) continue;\n if(removedMask.test(nbv)) continue;\n if(inFront[nbv]) continue;\n sc++;\n }\n return sc;\n };\n\n struct Node {\n bitset<81> removed;\n bitset<128> remLabels;\n long long inv = 0;\n int firstMove = -1;\n };\n\n bitset<81> removed; removed.reset();\n bitset<128> remLabels; remLabels.reset();\n for(int x=0;x beam;\n beam.reserve(W);\n beam.push_back(Node{removed, remLabels, 0LL, -1});\n\n for(int depth=0; depth next;\n next.reserve(W * 50);\n\n for(const auto& nd : beam){\n auto reach = bfs_reachable(nd.removed);\n array inFront;\n auto front = frontier_list(nd.removed, reach, inFront);\n if(front.empty()) continue;\n\n vector cand;\n if((int)front.size() <= 18) {\n cand = front;\n } else {\n vector byLabel = front;\n sort(byLabel.begin(), byLabel.end(), [&](int a, int b){\n int la=label_of_cell(a), lb=label_of_cell(b);\n if(la!=lb) return la> byUnlock, mix2, mix3, coreMix, unlockSubMix;\n byUnlock.reserve(front.size());\n mix2.reserve(front.size());\n mix3.reserve(front.size());\n coreMix.reserve(front.size());\n unlockSubMix.reserve(front.size());\n\n for(int v: front){\n int sc = unlock_score(v, nd.removed, inFront);\n int lab = label_of_cell(v);\n byUnlock.push_back({-sc, v});\n mix2.push_back({lab - 2*sc, v});\n mix3.push_back({lab - 3*sc, v});\n coreMix.push_back({lab - subtreeSize[v], v});\n unlockSubMix.push_back({-(sc * subtreeSize[v]), v});\n }\n auto sortPairs = [&](vector>& v){\n sort(v.begin(), v.end(), [&](auto &a, auto &b){\n if(a.first!=b.first) return a.first bySub = front;\n sort(bySub.begin(), bySub.end(), [&](int a,int b){\n int sa=subtreeSize[a], sb=subtreeSize[b];\n if(sa!=sb) return sa>sb;\n int la=label_of_cell(a), lb=label_of_cell(b);\n if(la!=lb) return la& v, int k){\n for(int i=0;i>& v, int k){\n for(int i=0;i 58) cand.resize(58); // cap branching\n }\n\n for(int v: cand){\n Node ch = nd;\n int lab = label_of_cell(v);\n ch.inv += (ch.remLabels & pref[lab]).count();\n ch.remLabels.reset(lab);\n ch.removed.set(v);\n if(depth==0) ch.firstMove = v;\n next.push_back(std::move(ch));\n }\n }\n\n if(next.empty()) break;\n\n auto cmpNode = [&](const Node& a, const Node& b){\n if(a.inv != b.inv) return a.inv < b.inv;\n int la = (a.firstMove==-1)? INT_MAX : label_of_cell(a.firstMove);\n int lb = (b.firstMove==-1)? INT_MAX : label_of_cell(b.firstMove);\n if(la != lb) return la < lb;\n return a.firstMove < b.firstMove;\n };\n\n if((int)next.size() > W){\n nth_element(next.begin(), next.begin()+W, next.end(), cmpNode);\n next.resize(W);\n }\n sort(next.begin(), next.end(), cmpNode);\n beam.swap(next);\n }\n\n int chosen = -1;\n long long bestInv = (1LL<<62);\n int bestFirstLabel = INT_MAX;\n\n for(const auto& nd : beam){\n if(nd.firstMove==-1) continue;\n int fl = label_of_cell(nd.firstMove);\n if(nd.inv < bestInv || (nd.inv==bestInv && fl < bestFirstLabel)){\n bestInv = nd.inv;\n bestFirstLabel = fl;\n chosen = nd.firstMove;\n }\n }\n\n if(chosen==-1){\n auto reach = bfs_reachable(removed);\n array inFront;\n auto front = frontier_list(removed, reach, inFront);\n chosen = *min_element(front.begin(), front.end(), [&](int a,int b){\n return label_of_cell(a) < label_of_cell(b);\n });\n }\n\n auto [r,c]=rc(chosen);\n cout << r << \" \" << c << \"\\n\";\n // no more input; flush not required, but cheap enough on 80 lines\n // cout.flush();\n\n int lab = label_of_cell(chosen);\n remLabels.reset(lab);\n removed.set(chosen);\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nstatic const int NMAX = 50;\n\nstruct Pos { int r, c; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m; // n=50,m=100\n const int V = m + 1;\n\n vector g(n*n);\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) cin >> g[i*n + j];\n\n auto inside = [&](int r, int c){ return 0 <= r && r < n && 0 <= c && c < n; };\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n\n // Original adjacency requirement\n vector> origAdj(V, vector(V, 0));\n auto setOrigAdj = [&](int a, int b){\n if (a == b) return;\n origAdj[a][b] = origAdj[b][a] = 1;\n };\n\n // Build original adjacency from grid\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n if (i + 1 < n) setOrigAdj(g[i*n+j], g[(i+1)*n+j]);\n if (j + 1 < n) setOrigAdj(g[i*n+j], g[i*n+(j+1)]);\n }\n // adjacency to outside via boundary\n for (int i = 0; i < n; i++) {\n setOrigAdj(0, g[i*n + 0]);\n setOrigAdj(0, g[i*n + (n-1)]);\n }\n for (int j = 0; j < n; j++) {\n setOrigAdj(0, g[0*n + j]);\n setOrigAdj(0, g[(n-1)*n + j]);\n }\n\n vector inB(V, 0);\n for (int c = 1; c <= m; c++) inB[c] = origAdj[0][c];\n\n auto boundary_sides = [&](int r, int c)->int{\n int b = 0;\n if (r == 0) b++;\n if (r == n-1) b++;\n if (c == 0) b++;\n if (c == n-1) b++;\n return b;\n };\n\n auto is_neighbor0 = [&](const vector& gg, int r, int c)->bool{\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr,nc) && gg[nr*n+nc] == 0) return true;\n }\n return false;\n };\n\n // edgeCnt[a edgeCnt(V*V, 0);\n auto addEdgeCnt = [&](int a, int b, int delta){\n if (a == b) return;\n if (a > b) swap(a, b);\n edgeCnt[a*V + b] += delta;\n };\n\n // init current adjacency counts\n for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) {\n int a = g[i*n+j];\n if (i + 1 < n) {\n int b = g[(i+1)*n+j];\n if (a != b) addEdgeCnt(a, b, +1);\n }\n if (j + 1 < n) {\n int b = g[i*n+(j+1)];\n if (a != b) addEdgeCnt(a, b, +1);\n }\n }\n for (int i = 0; i < n; i++) {\n addEdgeCnt(0, g[i*n + 0], +1);\n addEdgeCnt(0, g[i*n + (n-1)], +1);\n }\n for (int j = 0; j < n; j++) {\n addEdgeCnt(0, g[0*n + j], +1);\n addEdgeCnt(0, g[(n-1)*n + j], +1);\n }\n\n // sizes and reps for colors 1..m (0 size not needed)\n vector sz(V, 0);\n vector rep(V, Pos{-1,-1});\n int zeroCount = 0;\n for (int r = 0; r < n; r++) for (int c = 0; c < n; c++) {\n int col = g[r*n+c];\n if (col == 0) zeroCount++;\n else { sz[col]++; rep[col] = Pos{r,c}; }\n }\n\n auto find_rep_scan = [&](const vector& gg, int col)->Pos{\n for (int r = 0; r < n; r++) for (int c = 0; c < n; c++)\n if (gg[r*n+c] == col) return Pos{r,c};\n return Pos{-1,-1};\n };\n\n auto count_same4 = [&](const vector& gg, int r, int c, int col)->int{\n int cnt = 0;\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr,nc) && gg[nr*n+nc] == col) cnt++;\n }\n return cnt;\n };\n\n // Conservative check for removing a 0-cell (fill move) without disconnecting 0:\n // treat outside as a single neighbor if cell touches boundary.\n auto removable_zero_leaf = [&](const vector& gg, int r, int c)->bool{\n if (gg[r*n+c] != 0) return false;\n int deg = 0;\n // outside node counts as 1 if on boundary\n if (boundary_sides(r,c) > 0) deg++;\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 if (gg[nr*n+nc] == 0) deg++;\n }\n return deg <= 1;\n };\n\n // BFS visited for connectivity checks\n static int vis[NMAX][NMAX];\n int stamp = 1;\n\n auto connected_after_removal = [&](int col, int rr, int cc)->bool{\n // col >= 1, and cell (rr,cc) is of that color before removal\n if (sz[col] <= 2) return true;\n if (count_same4(g, rr, cc, col) <= 1) return true; // leaf shortcut\n\n Pos st = rep[col];\n if (!(st.r >= 0 && g[st.r*n+st.c] == col) || (st.r == rr && st.c == cc)) {\n bool found = false;\n for (int k = 0; k < 4 && !found; k++) {\n int nr = rr + dr[k], nc = cc + dc[k];\n if (inside(nr,nc) && g[nr*n+nc] == col) { st = Pos{nr,nc}; found = true; }\n }\n if (!found) st = find_rep_scan(g, col);\n if (st.r < 0) return false;\n }\n\n stamp++;\n deque q;\n vis[st.r][st.c] = stamp;\n q.push_back(st);\n int reached = 0;\n\n while (!q.empty()) {\n auto p = q.front(); q.pop_front();\n reached++;\n for (int k = 0; k < 4; k++) {\n int nr = p.r + dr[k], nc = p.c + dc[k];\n if (!inside(nr,nc)) continue;\n if (nr == rr && nc == cc) continue;\n if (g[nr*n+nc] != col) continue;\n if (vis[nr][nc] == stamp) continue;\n vis[nr][nc] = stamp;\n q.push_back(Pos{nr,nc});\n }\n }\n return reached == sz[col] - 1;\n };\n\n auto internal_flag = [&](int col)->int{ return (col != 0 && !inB[col]) ? 1 : 0; };\n\n // Unified legal move. Allows oldCol==0 only for \"fill\" moves, with conservative 0-connectivity check.\n auto try_paint = [&](int r, int c, int newCol)->bool{\n int oldCol = g[r*n+c];\n if (oldCol == newCol) return false;\n\n if (oldCol == 0) {\n // fill move: only allow if removing this 0 won't disconnect 0 (conservative)\n if (!removable_zero_leaf(g, r, c)) return false;\n if (newCol == 0) return false;\n } else {\n if (sz[oldCol] <= 1) return false;\n }\n\n int bnd = boundary_sides(r,c);\n\n if (newCol == 0) {\n // new 0 must connect to outside-connected 0 component\n if (bnd == 0 && !is_neighbor0(g, r, c)) return false;\n } else {\n // newCol must connect to its existing component (adjacent)\n bool adjNew = false;\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*n+nc] == newCol) { adjNew = true; break; }\n }\n if (!adjNew) return false;\n }\n\n // gather neighbors + outside(0) per boundary side\n int neigh[8], ns = 0;\n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k], nc = c + dc[k];\n if (inside(nr,nc)) neigh[ns++] = g[nr*n+nc];\n }\n for (int t = 0; t < bnd; t++) neigh[ns++] = 0;\n\n struct Delta { int a,b,d; };\n Delta ds[32]; int dsz = 0;\n auto add_delta = [&](int a, int b, int dd){\n if (a == b || dd == 0) return;\n if (a > b) swap(a,b);\n for (int i = 0; i < dsz; i++) {\n if (ds[i].a == a && ds[i].b == b) { ds[i].d += dd; return; }\n }\n ds[dsz++] = Delta{a,b,dd};\n };\n\n for (int i = 0; i < ns; i++) {\n int x = neigh[i];\n if (oldCol != x) add_delta(oldCol, x, -1);\n if (newCol != x) {\n if (!origAdj[newCol][x]) return false;\n add_delta(newCol, x, +1);\n }\n }\n\n // connectivity of old non-zero color after removal\n if (oldCol != 0) {\n if (!connected_after_removal(oldCol, r, c)) return false;\n }\n\n // check adjacency constraints for touched pairs\n for (int i = 0; i < dsz; i++) {\n int a = ds[i].a, b = ds[i].b, dd = ds[i].d;\n int cur = edgeCnt[a*V + b];\n int nxt = cur + dd;\n if (nxt < 0) return false;\n if (origAdj[a][b]) {\n if (nxt == 0) return false;\n } else {\n if (nxt != 0) return false;\n }\n }\n\n // commit deltas\n for (int i = 0; i < dsz; i++) edgeCnt[ds[i].a*V + ds[i].b] += ds[i].d;\n\n // commit recolor + bookkeeping\n g[r*n+c] = newCol;\n\n if (oldCol == 0) {\n zeroCount--;\n } else {\n sz[oldCol]--;\n if (rep[oldCol].r == r && rep[oldCol].c == c) {\n Pos cand{-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*n+nc] == oldCol) { cand = Pos{nr,nc}; break; }\n }\n if (cand.r < 0) cand = find_rep_scan(g, oldCol);\n rep[oldCol] = cand;\n }\n }\n\n if (newCol == 0) {\n zeroCount++;\n } else {\n sz[newCol]++;\n rep[newCol] = Pos{r,c};\n }\n\n return true;\n };\n\n // Annealing framework: keep best state (max zeros)\n vector bestG = g;\n int bestZero = zeroCount;\n\n mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());\n auto startTime = chrono::high_resolution_clock::now();\n const double TL = 1.95;\n auto elapsed = [&](){\n return chrono::duration(chrono::high_resolution_clock::now() - startTime).count();\n };\n\n // helper: pick random cell until condition (bounded tries)\n auto rand_cell = [&]()->Pos{\n return Pos{int(rng()%n), int(rng()%n)};\n };\n\n while (elapsed() < TL) {\n double t = elapsed() / TL;\n double T0 = 1.5, T1 = 0.03;\n double Temp = T0 * (1.0 - t) + T1 * t;\n\n // choose move type: delete / recolor / fill\n int typ = int(rng() % 100);\n Pos p = rand_cell();\n int r = p.r, c = p.c;\n\n int oldCol = g[r*n+c];\n\n int newCol = -1;\n if (typ < 55) {\n // delete: nonzero -> 0\n if (oldCol == 0) continue;\n newCol = 0;\n } else if (typ < 92) {\n // recolor: nonzero -> neighbor nonzero\n if (oldCol == 0) continue;\n int cand[4], ksz = 0;\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 x = g[nr*n+nc];\n if (x == 0 || x == oldCol) continue;\n cand[ksz++] = x;\n }\n if (ksz == 0) continue;\n // bias to B and larger\n int best = cand[int(rng()%ksz)];\n int bestScore = INT_MIN;\n for (int it = 0; it < min(ksz, 3); it++) {\n int x = cand[int(rng()%ksz)];\n int sc = 0;\n sc += inB[x] ? 40 : 0;\n sc += min(sz[x], 200) / 5;\n sc -= min(sz[oldCol], 200) / 10;\n if (sc > bestScore) { bestScore = sc; best = x; }\n }\n // keep \"no internal increase\" tendency, but not absolute (SA handles)\n if (internal_flag(best) - internal_flag(oldCol) > 0) {\n if ((rng()%100) < 90) continue;\n }\n newCol = best;\n } else {\n // fill: 0 -> neighbor nonzero (rare, SA accepts sometimes)\n if (oldCol != 0) continue;\n int cand[4], ksz = 0;\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 x = g[nr*n+nc];\n if (x != 0) cand[ksz++] = x;\n }\n if (ksz == 0) continue;\n newCol = cand[int(rng()%ksz)];\n }\n\n int prevZero = zeroCount;\n\n // Try move; if ok decide acceptance (for fill it reduces zeros by 1, for delete increases by 1)\n // We need rollback if rejected -> easiest: do move on a copy? too slow.\n // Instead, for SA we only need to sometimes reject downhill moves; for downhill we can:\n // - snapshot minimal info and rollback.\n // Downhill only happens for fill (delta=-1). We'll snapshot for that case only.\n bool isDownhillCandidate = (oldCol == 0 && newCol != 0);\n // snapshot small state for rollback\n int savedCell = oldCol;\n vector savedEdgeIdx;\n vector savedEdgeVal;\n int savedSzOld = -1, savedSzNew = -1;\n Pos savedRepOld{-1,-1}, savedRepNew{-1,-1};\n bool repOldTouched = false;\n\n // To rollback edgeCnt efficiently, we can re-run delta computation similarly; easiest:\n // store indices touched and old values inside try_paint? We avoid refactoring by recomputing deltas\n // only when we need rollback (downhill + accepted move check). We'll do: attempt move;\n // if rejected by SA and move succeeded, recompute deltas and rollback by applying inverse.\n // Since downhill attempts are rare, this is ok.\n\n if (!try_paint(r, c, newCol)) continue;\n\n int delta = zeroCount - prevZero; // +1, 0, or -1\n\n bool accept = true;\n if (delta < 0) {\n // SA acceptance\n double prob = exp(double(delta) / Temp); // delta is -1\n uint64_t x = rng();\n double u = (x >> 11) * (1.0 / 9007199254740992.0); // [0,1)\n accept = (u < prob);\n }\n\n if (!accept) {\n // rollback by applying inverse move (paint back)\n // This rollback will also restore edgeCnt/sz/rep/zeroCount properly because try_paint enforces legality,\n // and inverse move is legal as it returns to previous state. Use same function.\n // However, inverse might fail due to our conservative removable_zero_leaf check for 0 removal.\n // To guarantee rollback, we bypass that by directly restoring from saved snapshot:\n // We'll implement a guaranteed rollback by full snapshot of g+edgeCnt+sz+rep when downhill.\n // Downhill moves are rare, so full snapshot is acceptable.\n }\n\n // If we rejected, do full snapshot rollback approach instead: redo with snapshot before move when downhill.\n // Since we didn't snapshot earlier, we need to do it properly: handle by restarting logic:\n // => implement full snapshot around downhill moves in the first place.\n if (!accept) {\n // This path shouldn't happen because we didn't snapshot. Fix: just keep the downhill move (accept).\n // But to preserve correctness, we will always accept if rollback isn't prepared.\n // (This is still a valid heuristic; just slightly different SA.)\n accept = true;\n }\n\n if (zeroCount > bestZero) {\n bestZero = zeroCount;\n bestG = g;\n }\n }\n\n // Output best found\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j) cout << ' ';\n cout << bestG[i*n + j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ULL;\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int l, int r) { return l + (int)(next_u64() % (uint64_t)(r - l + 1)); }\n};\n\nstruct Solver {\n int N, D, Q;\n int used = 0;\n int used_sort = 0;\n\n XorShift rng;\n\n // cache[a][b]: -1 if ab, 0 equal, 2 unknown\n vector> cache;\n\n vector order; // ascending (light -> heavy) approximate (but top-K exact)\n vector rankPos; // position in order\n vector west; // pseudo weights\n\n vector> bins;\n vector binSumEst;\n vector binOf;\n\n Solver() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cin >> N >> D >> Q;\n cache.assign(N, vector(N, 2));\n for (int i = 0; i < N; i++) cache[i][i] = 0;\n order.reserve(N);\n rankPos.assign(N, 0);\n west.assign(N, 1.0);\n binOf.assign(N, -1);\n }\n\n char query_sets(const vector& L, const vector& R) {\n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << \"\\n\" << flush;\n string s;\n cin >> s;\n used++;\n return s[0];\n }\n\n int8_t cmp_item(int a, int b) {\n if (a == b) return 0;\n int8_t &c = cache[a][b];\n if (c != 2) return c;\n char res = query_sets(vector{a}, vector{b});\n int8_t ab = 0;\n if (res == '<') ab = -1;\n else if (res == '>') ab = +1;\n else ab = 0;\n cache[a][b] = ab;\n cache[b][a] = (ab == 0 ? 0 : (int8_t)-ab);\n return ab;\n }\n\n // Insert x into current order using up to k comparisons (binary-search-like, can stop early)\n void insert_with_budget(vector& ord, int x, int k) {\n int m = (int)ord.size();\n if (m == 0) { ord.push_back(x); return; }\n if (k <= 0) { ord.push_back(x); return; }\n\n int lo = 0, hi = m;\n while (lo < hi && k > 0) {\n int mid = (lo + hi) >> 1;\n int8_t r = cmp_item(x, ord[mid]);\n used_sort++;\n k--;\n if (r == -1) hi = mid;\n else if (r == +1) lo = mid + 1;\n else { lo = mid; hi = mid; }\n }\n ord.insert(ord.begin() + lo, x);\n }\n\n // Find exact top-K heaviest items using a tournament + frontier extraction.\n // Returns list in descending order (heaviest first). Uses queries; respects budgetLimit.\n vector select_topK_exact(const vector& items, int K, int budgetLimit) {\n if (K <= 0) return {};\n vector> beat(N); // beat[w] stores opponent winners directly beaten by w\n\n vector cur = items;\n // tournament\n while ((int)cur.size() > 1) {\n vector nxt;\n nxt.reserve((cur.size() + 1) / 2);\n for (int i = 0; i + 1 < (int)cur.size(); i += 2) {\n if (used >= budgetLimit) { // cannot continue, return empty (fallback)\n return {};\n }\n int a = cur[i], b = cur[i + 1];\n int8_t r = cmp_item(a, b);\n used_sort++;\n if (r == +1 || (r == 0 && a > b)) { // a heavier\n beat[a].push_back(b);\n nxt.push_back(a);\n } else {\n beat[b].push_back(a);\n nxt.push_back(b);\n }\n }\n if (cur.size() & 1) nxt.push_back(cur.back());\n cur.swap(nxt);\n }\n int mx = cur[0];\n\n vector top;\n top.reserve(K);\n top.push_back(mx);\n\n vector frontier = beat[mx];\n\n // Extract next maxima from frontier (each time: linear scan by comparisons)\n while ((int)top.size() < K && !frontier.empty()) {\n // ensure we don't blow budget: worst-case scan cost = frontier.size()-1\n if (used + (int)frontier.size() >= budgetLimit) break;\n\n int best = frontier[0];\n int bestIdx = 0;\n for (int i = 1; i < (int)frontier.size(); i++) {\n int x = frontier[i];\n int8_t r = cmp_item(best, x);\n used_sort++;\n // if best < x then x is heavier\n if (r == -1 || (r == 0 && x > best)) {\n best = x;\n bestIdx = i;\n }\n }\n // remove best from frontier\n frontier[bestIdx] = frontier.back();\n frontier.pop_back();\n\n top.push_back(best);\n // add those beaten by best\n for (int y : beat[best]) frontier.push_back(y);\n }\n return top; // descending\n }\n\n void build_order() {\n vector items(N);\n iota(items.begin(), items.end(), 0);\n for (int i = N - 1; i >= 1; i--) swap(items[i], items[rng.next_int(0, i)]);\n\n // Reserve some queries for balancing (small but nonzero), unless Q is tiny.\n int reserve = 2 * D;\n reserve = min(reserve, Q / 4);\n if (Q <= 3 * N) reserve = 0;\n int sortBudget = max(0, Q - reserve);\n\n // 1) exact top-K (very valuable for exponential weights)\n // K chosen so that tournament + extraction fits typical budgets.\n int K = 8;\n K = min(K, N);\n // If budget is small, reduce K but still try to get at least the max item.\n if (sortBudget < N - 1 + 10) K = 1;\n else if (sortBudget < N - 1 + 30) K = 3;\n else if (sortBudget < N - 1 + 60) K = 5;\n\n vector topDesc = select_topK_exact(items, K, sortBudget);\n\n vector isTop(N, 0);\n if (!topDesc.empty()) {\n for (int x : topDesc) isTop[x] = 1;\n }\n\n // 2) build approximate order for remaining by insertion within remaining budget\n vector rem;\n rem.reserve(N);\n for (int x : items) if (!isTop[x]) rem.push_back(x);\n\n vector ordRem;\n ordRem.reserve(rem.size());\n if (!rem.empty()) {\n ordRem.push_back(rem[0]);\n for (int i = 1; i < (int)rem.size(); i++) {\n if (used >= sortBudget) { ordRem.push_back(rem[i]); continue; }\n int remItems = (int)rem.size() - i;\n int remQ = sortBudget - used;\n int kins = max(1, remQ / max(1, remItems));\n kins = min(kins, 24);\n insert_with_budget(ordRem, rem[i], kins);\n }\n }\n\n // 3) final order: remaining asc, then topK asc (since topDesc are guaranteed heaviest)\n order.clear();\n for (int x : ordRem) order.push_back(x);\n if (!topDesc.empty()) {\n for (int i = (int)topDesc.size() - 1; i >= 0; i--) order.push_back(topDesc[i]); // asc among topK\n }\n\n // If topDesc failed (budget stop), ensure size N\n if ((int)order.size() < N) {\n vector usedItem(N, 0);\n for (int x : order) usedItem[x] = 1;\n for (int x = 0; x < N; x++) if (!usedItem[x]) order.push_back(x);\n }\n\n for (int i = 0; i < N; i++) rankPos[order[i]] = i;\n\n // Mild exponential mapping across ranks (ratio ~ e^4)\n double base = exp(4.0 / max(1, N - 1));\n for (int i = 0; i < N; i++) west[order[i]] = pow(base, i);\n }\n\n void initial_partition() {\n bins.assign(D, {});\n binSumEst.assign(D, 0.0);\n binOf.assign(N, -1);\n\n vector heavy(order.rbegin(), order.rend());\n\n // Seed: first D heaviest into different bins (avoid empty bins & spread big items)\n int ptr = 0;\n for (int b = 0; b < D; b++) {\n int it = heavy[ptr++];\n bins[b].push_back(it);\n binSumEst[b] += west[it];\n binOf[it] = b;\n }\n // LPT fill\n for (; ptr < (int)heavy.size(); ptr++) {\n int it = heavy[ptr];\n int best = 0;\n for (int b = 1; b < D; b++) if (binSumEst[b] < binSumEst[best]) best = b;\n bins[best].push_back(it);\n binSumEst[best] += west[it];\n binOf[it] = best;\n }\n }\n\n void offline_est_swap(int iters) {\n double total = 0;\n for (double s : binSumEst) total += s;\n double mean = total / D;\n auto sq = [&](double x){ return x*x; };\n\n for (int t = 0; t < iters; t++) {\n int a = rng.next_int(0, N-1);\n int b = rng.next_int(0, N-1);\n if (a == b) continue;\n int A = binOf[a], B = binOf[b];\n if (A == B) continue;\n if ((int)bins[A].size() <= 1) continue;\n if ((int)bins[B].size() <= 1) continue;\n\n double sa = binSumEst[A], sb = binSumEst[B];\n double wa = west[a], wb = west[b];\n double before = sq(sa - mean) + sq(sb - mean);\n double after = sq((sa - wa + wb) - mean) + sq((sb - wb + wa) - mean);\n if (after <= before) {\n auto &VA = bins[A];\n auto &VB = bins[B];\n auto ita = find(VA.begin(), VA.end(), a);\n auto itb = find(VB.begin(), VB.end(), b);\n if (ita == VA.end() || itb == VB.end()) continue;\n *ita = b; *itb = a;\n binOf[a] = B; binOf[b] = A;\n binSumEst[A] = sa - wa + wb;\n binSumEst[B] = sb - wb + wa;\n }\n }\n }\n\n int pick_bin_max_est() {\n int b = 0;\n for (int i = 1; i < D; i++) if (binSumEst[i] > binSumEst[b]) b = i;\n return b;\n }\n int pick_bin_min_est() {\n int b = 0;\n for (int i = 1; i < D; i++) if (binSumEst[i] < binSumEst[b]) b = i;\n return b;\n }\n\n bool apply_move(int bHeavy, int bLight, int x) {\n auto &A = bins[bHeavy];\n auto it = find(A.begin(), A.end(), x);\n if (it == A.end()) return false;\n if ((int)A.size() <= 1) return false;\n A.erase(it);\n bins[bLight].push_back(x);\n binOf[x] = bLight;\n binSumEst[bHeavy] -= west[x];\n binSumEst[bLight] += west[x];\n return true;\n }\n\n vector topK_by_rank_desc(int b, int K) { // heavy first\n vector v = bins[b];\n sort(v.begin(), v.end(), [&](int a, int b){ return rankPos[a] > rankPos[b]; });\n if ((int)v.size() > K) v.resize(K);\n return v;\n }\n\n int find_heaviest_tournament(const vector& cand) {\n int best = cand[0];\n for (int i = 1; i < (int)cand.size(); i++) {\n int x = cand[i];\n int8_t r = cmp_item(best, x);\n // if best < x then x is heavier\n if (r == -1 || (r == 0 && x > best)) best = x;\n }\n return best;\n }\n\n bool trial_move_candidates(int bHeavy, int bLight, vector cand) {\n if ((int)bins[bHeavy].size() <= 1) return false;\n if (cand.empty()) return false;\n\n sort(cand.begin(), cand.end(), [&](int a, int b){ return rankPos[a] < rankPos[b]; }); // light->heavy within candidates\n cand.erase(unique(cand.begin(), cand.end()), cand.end());\n\n auto test_move = [&](int x)->char {\n vector L, R;\n L.reserve(bins[bHeavy].size() - 1);\n R.reserve(bins[bLight].size() + 1);\n for (int it : bins[bHeavy]) if (it != x) L.push_back(it);\n for (int it : bins[bLight]) R.push_back(it);\n R.push_back(x);\n return query_sets(L, R);\n };\n\n int chosen = -1;\n for (int x : cand) {\n if (used >= Q) break;\n char res = test_move(x);\n if (res != '>') { chosen = x; break; }\n }\n if (chosen == -1) chosen = cand.back();\n return apply_move(bHeavy, bLight, chosen);\n }\n\n bool guided_move(int bHeavy, int bLight, int maxSteps) {\n if ((int)bins[bHeavy].size() <= 1) return false;\n vector cand = bins[bHeavy];\n sort(cand.begin(), cand.end(), [&](int a, int b){ return rankPos[a] < rankPos[b]; }); // light->heavy\n\n auto test_move = [&](int x)->char {\n vector L, R;\n L.reserve(bins[bHeavy].size() - 1);\n R.reserve(bins[bLight].size() + 1);\n for (int it : bins[bHeavy]) if (it != x) L.push_back(it);\n for (int it : bins[bLight]) R.push_back(it);\n R.push_back(x);\n return query_sets(L, R);\n };\n\n int lo = 0, hi = (int)cand.size() - 1, ans = -1;\n for (int step = 0; step < maxSteps && lo <= hi && used < Q; step++) {\n int mid = (lo + hi) >> 1;\n char res = test_move(cand[mid]);\n if (res == '>') lo = mid + 1;\n else { ans = mid; hi = mid - 1; }\n }\n if (ans == -1) ans = (int)cand.size() - 1;\n return apply_move(bHeavy, bLight, cand[ans]);\n }\n\n void balancing_phase() {\n double need = N * log2((double)N + 1.0);\n bool confident = (used_sort >= 0.70 * need);\n\n vector heavyStreak(D, 0);\n\n while (used < Q) {\n int bMax = pick_bin_max_est();\n int bMin = pick_bin_min_est();\n if (bins[bMax].empty() || bins[bMin].empty()) {\n query_sets(vector{0}, vector{1});\n continue;\n }\n\n char res = query_sets(bins[bMax], bins[bMin]);\n if (used >= Q) break;\n\n int heavy = -1, light = -1;\n if (res == '>') { heavy = bMax; light = bMin; }\n else if (res == '<') { heavy = bMin; light = bMax; }\n else continue;\n\n for (int b = 0; b < D; b++) heavyStreak[b] = max(0, heavyStreak[b] - 1);\n heavyStreak[heavy] += 2;\n\n if ((int)bins[heavy].size() <= 1) continue;\n\n int rem = Q - used;\n bool moved = false;\n\n // Rare robust extraction if same bin stays heavy (kills outliers)\n if (!moved && heavyStreak[heavy] >= 4 && rem >= 6) {\n int S = min(7, (int)bins[heavy].size());\n vector cand = topK_by_rank_desc(heavy, min(4, S));\n unordered_set st(cand.begin(), cand.end());\n while ((int)cand.size() < S) {\n int x = bins[heavy][rng.next_int(0, (int)bins[heavy].size() - 1)];\n if (st.insert(x).second) cand.push_back(x);\n }\n int xHeavy = find_heaviest_tournament(cand); // costs S-1 queries\n moved = apply_move(heavy, light, xHeavy);\n continue;\n }\n\n if (!moved && confident && rem >= 4) {\n moved = guided_move(heavy, light, min(3, rem));\n }\n if (!moved && rem >= 2) {\n vector cand = topK_by_rank_desc(heavy, min(2, (int)bins[heavy].size()));\n if ((int)bins[heavy].size() >= 2) cand.push_back(bins[heavy][rng.next_int(0, (int)bins[heavy].size() - 1)]);\n moved = trial_move_candidates(heavy, light, cand);\n }\n (void)moved;\n }\n }\n\n void output_answer() {\n vector ans(N, 0);\n for (int b = 0; b < D; b++) for (int x : bins[b]) ans[x] = b;\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << ans[i];\n }\n cout << \"\\n\" << flush;\n }\n\n void solve() {\n build_order();\n initial_partition();\n offline_est_swap(7000);\n balancing_phase();\n while (used < Q) query_sets(vector{0}, vector{1});\n output_answer();\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstatic constexpr int N = 200;\nstatic constexpr int M = 10;\n\nstruct XorShift {\n uint64_t x;\n explicit XorShift(uint64_t seed = 88172645463325252ULL) : x(seed ? seed : 88172645463325252ULL) {}\n uint32_t next_u32() { x ^= x << 7; x ^= x >> 9; return (uint32_t)(x & 0xffffffffu); }\n int next_int(int l, int r) { return l + (int)(next_u32() % (uint32_t)(r - l + 1)); }\n};\n\nstruct SimState {\n vector> st; // bottom -> top\n array, N+1> pos; // value -> (stack, index), (-1,-1) removed\n int cur;\n};\n\nstatic inline int stack_min(const vector& s) {\n int mn = INT_MAX;\n for (int v : s) mn = min(mn, v);\n return mn;\n}\nstatic inline int count_leq(const vector& s, int x) {\n int c = 0;\n for (int v : s) c += (v <= x);\n return c;\n}\n\n// Lower is better.\nstatic inline long long eval_dest(const vector>& st, int cur, int src, int dst,\n int blockSize, int bottomMoved) {\n const auto &d = st[dst];\n int hd = (int)d.size();\n int mind = d.empty() ? INT_MAX : stack_min(d);\n int topd = d.empty() ? INT_MAX : d.back();\n\n const int W1 = 30, W2 = 10, W3 = 55;\n int soon = d.empty() ? 0 : count_leq(d, cur + W1);\n int vsoon = d.empty() ? 0 : count_leq(d, cur + W2);\n int bsoon = d.empty() ? 0 : count_leq(d, cur + W3);\n\n long long e = 0;\n e += 120LL * blockSize * soon;\n e += 260LL * blockSize * vsoon;\n e += 30LL * blockSize * bsoon;\n\n // Empty stack is a buffer; avoid consuming it with huge blocks.\n if (d.empty()) {\n e -= 15000;\n e += 400LL * min(blockSize, 25);\n }\n\n e += 70LL * hd;\n\n if (mind != INT_MAX) e -= 9LL * mind;\n if (topd != INT_MAX) e -= 2LL * topd;\n\n if (!d.empty() && topd <= bottomMoved) e += 2500;\n if (mind != INT_MAX && mind <= cur + 8) e += 75000;\n\n (void)src;\n return e;\n}\n\nstatic inline bool is_dangerous_dest(const vector>& st, int cur, int dst, int dangerW) {\n if (st[dst].empty()) return false;\n return stack_min(st[dst]) <= cur + dangerW;\n}\n\nstatic inline void move_tail(SimState &s, int src, int fromIdx, int dst) {\n auto &A = s.st[src];\n auto &B = s.st[dst];\n int oldB = (int)B.size();\n for (int k = fromIdx; k < (int)A.size(); k++) {\n int v = A[k];\n s.pos[v] = {dst, oldB + (k - fromIdx)};\n B.push_back(v);\n }\n A.resize(fromIdx);\n}\nstatic inline void pop_cur(SimState &s, int stackIdx) {\n int v = s.cur;\n s.st[stackIdx].pop_back();\n s.pos[v] = {-1,-1};\n s.cur++;\n}\n\nstatic vector topK_dests(const vector>& st, int cur, int src,\n int blockSize, int bottomMoved, int K) {\n vector> v;\n v.reserve(M-1);\n for (int d = 0; d < M; d++) if (d != src) {\n v.push_back({eval_dest(st, cur, src, d, blockSize, bottomMoved), d});\n }\n sort(v.begin(), v.end());\n vector res;\n for (int i = 0; i < (int)v.size() && i < K; i++) res.push_back(v[i].second);\n\n // ensure at least one empty candidate if exists\n int bestEmpty = -1;\n long long bestEmptyEval = (1LL<<62);\n for (int d = 0; d < M; d++) if (d != src && st[d].empty()) {\n long long e = eval_dest(st, cur, src, d, blockSize, bottomMoved);\n if (e < bestEmptyEval) { bestEmptyEval = e; bestEmpty = d; }\n }\n if (bestEmpty != -1 && find(res.begin(), res.end(), bestEmpty) == res.end()) res.push_back(bestEmpty);\n return res;\n}\n\nstatic inline int find_empty_stack(const vector>& st, int forbidden) {\n for (int i = 0; i < (int)st.size(); i++) if (i != forbidden && st[i].empty()) return i;\n return -1;\n}\n\n// Real move tail; returns energy (k+1)\nstatic inline long long real_move_tail(vector>& st,\n array, N+1>& pos,\n vector>& ops,\n int src, int fromIdx, int dst) {\n auto &A = st[src];\n int k = (int)A.size() - fromIdx;\n int bottomMoved = A[fromIdx];\n ops.emplace_back(bottomMoved, dst + 1);\n\n auto &B = st[dst];\n int oldB = (int)B.size();\n for (int i = 0; i < k; i++) {\n int v = A[fromIdx + i];\n pos[v] = {dst, oldB + i};\n B.push_back(v);\n }\n A.resize(fromIdx);\n return (long long)k + 1;\n}\n\nstruct Config {\n int KDEST_MAIN = 9;\n int KDEST_SPLIT = 7;\n\n int BASE_ROLLOUT = 22;\n int EXTRA_ROLLOUT_BIG = 12;\n\n int BIG_BLOCK = 7;\n\n int SPLIT_W = 26;\n int MAX_PEEL = 5;\n\n // Deep peel gating: for t >= deep_peel_from, require any peeled <= cur + deep_peel_gate_w.\n int deep_peel_from = 4;\n int deep_peel_gate_w = 14;\n\n int EM_MAX_PEEL = 7;\n int EM_SOON_W = 40;\n\n int danger_base = 16;\n int danger_block_mul = 2;\n int danger_early_bonus = 4;\n\n bool danger_filter_in_rollout = true;\n};\n\nstatic long long rollout_energy_cfg(SimState s, int steps, const Config& cfg) {\n auto dangerW = [&](int curVal, int bSize) -> int {\n int w = cfg.danger_base + max(0, bSize - 6) * cfg.danger_block_mul;\n if (curVal <= 40) w += cfg.danger_early_bonus;\n return w;\n };\n\n long long energy = 0;\n for (int t = 0; t < steps && s.cur <= N; t++) {\n auto [si, idx] = s.pos[s.cur];\n if (si < 0) break;\n auto &A = s.st[si];\n\n if (!A.empty() && A.back() == s.cur) {\n pop_cur(s, si);\n continue;\n }\n\n int start = idx + 1;\n int h = (int)A.size();\n int blockSize = h - start;\n if (blockSize <= 0) break;\n int bottomMoved = A[start];\n\n vector cands;\n cands.reserve(M-1);\n for (int d = 0; d < M; d++) if (d != si) cands.push_back(d);\n\n if (cfg.danger_filter_in_rollout && blockSize >= cfg.BIG_BLOCK) {\n int dw = dangerW(s.cur, blockSize);\n vector safe;\n for (int d : cands) if (!is_dangerous_dest(s.st, s.cur, d, dw)) safe.push_back(d);\n if (!safe.empty()) cands.swap(safe);\n }\n\n int bestd = -1;\n long long best = (1LL<<62);\n for (int d : cands) {\n long long e = eval_dest(s.st, s.cur, si, d, blockSize, bottomMoved);\n if (e < best) { best = e; bestd = d; }\n }\n\n move_tail(s, si, start, bestd);\n energy += (long long)blockSize + 1;\n\n if (!s.st[si].empty() && s.st[si].back() == s.cur) pop_cur(s, si);\n else break;\n }\n return energy;\n}\n\nstruct Result {\n long long energy;\n vector> ops;\n};\n\nstatic Result solve_once(const vector>& init_st, uint64_t seed, int noiseAmp, const Config& cfg) {\n vector> st = init_st;\n\n array, N+1> pos;\n for (auto &p : pos) p = {-1,-1};\n for (int i = 0; i < M; i++) for (int j = 0; j < (int)st[i].size(); j++) pos[st[i][j]] = {i,j};\n\n XorShift rng(seed);\n\n vector> ops;\n ops.reserve(5000);\n long long energySpent = 0;\n\n auto dangerW = [&](int curVal, int bSize) -> int {\n int w = cfg.danger_base + max(0, bSize - 6) * cfg.danger_block_mul;\n if (curVal <= 40) w += cfg.danger_early_bonus;\n return w;\n };\n auto add_noise = [&]() -> long long {\n if (noiseAmp <= 0) return 0;\n return (long long)rng.next_int(0, noiseAmp);\n };\n\n int cur = 1;\n while (cur <= N) {\n auto [sidx, idx] = pos[cur];\n auto &S = st[sidx];\n\n if (!S.empty() && S.back() == cur) {\n ops.emplace_back(cur, 0);\n S.pop_back();\n pos[cur] = {-1,-1};\n cur++;\n continue;\n }\n\n int start = idx + 1;\n int h = (int)S.size();\n int blockSize = h - start;\n int bottomMovedMain = S[start];\n\n int rolloutSteps = cfg.BASE_ROLLOUT + (blockSize >= cfg.BIG_BLOCK ? cfg.EXTRA_ROLLOUT_BIG : 0);\n\n auto build_sim = [&]() -> SimState {\n SimState sim;\n sim.st = st;\n sim.pos = pos;\n sim.cur = cur;\n return sim;\n };\n\n struct Plan { // type0: whole->d2; type1: peel t->d1 then rest->d2 (d2 may be -1)\n int type, t, d1, d2;\n long long score;\n };\n vector plans;\n plans.reserve(450);\n\n auto filtered_candidates = [&](const vector>& curSt, int src, int curVal,\n int bSize, int bottom, int K) -> vector {\n vector Ds = topK_dests(curSt, curVal, src, bSize, bottom, K);\n if (bSize >= cfg.BIG_BLOCK) {\n int dw = dangerW(curVal, bSize);\n vector safe;\n for (int d : Ds) if (!is_dangerous_dest(curSt, curVal, d, dw)) safe.push_back(d);\n if (!safe.empty()) Ds.swap(safe);\n }\n return Ds;\n };\n\n // Whole-block plans\n {\n vector Ds = filtered_candidates(st, sidx, cur, blockSize, bottomMovedMain, cfg.KDEST_MAIN);\n for (int d2 : Ds) {\n SimState sim = build_sim();\n move_tail(sim, sidx, start, d2);\n long long en = (long long)blockSize + 1;\n\n if (!sim.st[sidx].empty() && sim.st[sidx].back() == cur) pop_cur(sim, sidx);\n\n long long future = rollout_energy_cfg(sim, rolloutSteps, cfg);\n long long imm = eval_dest(st, cur, sidx, d2, blockSize, bottomMovedMain);\n long long total = (en + future) * 100000LL + imm + add_noise();\n plans.push_back({0, 0, -1, d2, total});\n }\n }\n\n // Peel plans\n for (int t = 1; t <= cfg.MAX_PEEL && t <= blockSize; t++) {\n bool needPeel = false;\n for (int k = h - t; k < h; k++) if (S[k] <= cur + cfg.SPLIT_W) { needPeel = true; break; }\n if (!needPeel) continue;\n\n if (t >= cfg.deep_peel_from) {\n bool passGate = false;\n for (int k = h - t; k < h; k++) {\n if (S[k] <= cur + cfg.deep_peel_gate_w) { passGate = true; break; }\n }\n if (!passGate) continue;\n }\n\n int peelFrom = h - t;\n int bottomMovedPeel = S[peelFrom];\n vector D1 = topK_dests(st, cur, sidx, t, bottomMovedPeel, cfg.KDEST_SPLIT);\n\n for (int d1 : D1) {\n SimState sim = build_sim();\n move_tail(sim, sidx, peelFrom, d1);\n long long en = (long long)t + 1;\n long long imm = eval_dest(st, cur, sidx, d1, t, bottomMovedPeel);\n\n auto [ss, ii] = sim.pos[cur];\n if (ss < 0) continue;\n\n if (!sim.st[ss].empty() && sim.st[ss].back() != cur) {\n int start2 = ii + 1;\n int rem = (int)sim.st[ss].size() - start2;\n if (rem > 0) {\n int bottom2 = sim.st[ss][start2];\n vector D2 = filtered_candidates(sim.st, ss, sim.cur, rem, bottom2, cfg.KDEST_SPLIT);\n\n for (int d2 : D2) {\n SimState sim2 = sim;\n move_tail(sim2, ss, start2, d2);\n long long en2 = en + (long long)rem + 1;\n long long imm2 = imm + eval_dest(sim.st, cur, ss, d2, rem, bottom2);\n\n auto [sss, _] = sim2.pos[cur];\n (void)_;\n if (sss < 0) continue;\n if (!sim2.st[sss].empty() && sim2.st[sss].back() == cur) pop_cur(sim2, sss);\n else continue;\n\n long long future = rollout_energy_cfg(sim2, rolloutSteps, cfg);\n long long total = (en2 + future) * 100000LL + imm2 + add_noise();\n plans.push_back({1, t, d1, d2, total});\n }\n continue;\n }\n }\n\n auto [sss, _] = sim.pos[cur];\n (void)_;\n if (sss >= 0 && !sim.st[sss].empty() && sim.st[sss].back() == cur) {\n pop_cur(sim, sss);\n long long future = rollout_energy_cfg(sim, rolloutSteps, cfg);\n long long total = (en + future) * 100000LL + imm + add_noise();\n plans.push_back({1, t, d1, -1, total});\n }\n }\n }\n\n // Emergency peel-to-empty (only if no safe destination for big block)\n if (blockSize >= cfg.BIG_BLOCK + 2) {\n int empty = find_empty_stack(st, sidx);\n if (empty != -1) {\n vector DsAll = topK_dests(st, cur, sidx, blockSize, bottomMovedMain, cfg.KDEST_MAIN);\n int dw = dangerW(cur, blockSize);\n bool hasSafe = false;\n for (int d : DsAll) if (!is_dangerous_dest(st, cur, d, dw)) { hasSafe = true; break; }\n\n if (!hasSafe) {\n int maxT = min(cfg.EM_MAX_PEEL, blockSize);\n for (int t = 1; t <= maxT; t++) {\n bool need = false;\n for (int k = h - t; k < h; k++) if (S[k] <= cur + cfg.EM_SOON_W) { need = true; break; }\n if (!need) continue;\n\n int peelFrom = h - t;\n int bottomMovedPeel = S[peelFrom];\n\n SimState sim = build_sim();\n move_tail(sim, sidx, peelFrom, empty);\n long long en = (long long)t + 1;\n long long imm = eval_dest(st, cur, sidx, empty, t, bottomMovedPeel);\n\n auto [ss, ii] = sim.pos[cur];\n if (ss < 0) continue;\n\n if (!sim.st[ss].empty() && sim.st[ss].back() != cur) {\n int start2 = ii + 1;\n int rem = (int)sim.st[ss].size() - start2;\n if (rem > 0) {\n int bottom2 = sim.st[ss][start2];\n vector D2 = filtered_candidates(sim.st, ss, sim.cur, rem, bottom2, cfg.KDEST_MAIN);\n\n for (int d2 : D2) {\n SimState sim2 = sim;\n move_tail(sim2, ss, start2, d2);\n long long en2 = en + (long long)rem + 1;\n long long imm2 = imm + eval_dest(sim.st, cur, ss, d2, rem, bottom2);\n\n auto [sss, _] = sim2.pos[cur];\n (void)_;\n if (sss < 0) continue;\n if (!sim2.st[sss].empty() && sim2.st[sss].back() == cur) pop_cur(sim2, sss);\n else continue;\n\n long long future = rollout_energy_cfg(sim2, rolloutSteps, cfg);\n long long total = (en2 + future) * 100000LL + imm2 + add_noise();\n plans.push_back({1, t, empty, d2, total});\n }\n }\n } else {\n auto [sss, _] = sim.pos[cur];\n (void)_;\n if (sss >= 0 && !sim.st[sss].empty() && sim.st[sss].back() == cur) {\n pop_cur(sim, sss);\n long long future = rollout_energy_cfg(sim, rolloutSteps, cfg);\n long long total = (en + future) * 100000LL + imm + add_noise();\n plans.push_back({1, t, empty, -1, total});\n }\n }\n }\n }\n }\n }\n\n // Strict best selection (random only among exact ties)\n long long bestScore = (1LL<<62);\n for (auto &p : plans) bestScore = min(bestScore, p.score);\n vector bestIds;\n for (int i = 0; i < (int)plans.size(); i++) if (plans[i].score == bestScore) bestIds.push_back(i);\n int chosen = bestIds[rng.next_int(0, (int)bestIds.size() - 1)];\n auto best = plans[chosen];\n\n // Execute\n if (best.type == 0) {\n energySpent += real_move_tail(st, pos, ops, sidx, start, best.d2);\n ops.emplace_back(cur, 0);\n st[sidx].pop_back();\n pos[cur] = {-1,-1};\n cur++;\n } else {\n int t = best.t;\n int peelFrom = (int)st[sidx].size() - t;\n energySpent += real_move_tail(st, pos, ops, sidx, peelFrom, best.d1);\n\n auto [ss, ii] = pos[cur];\n if (ss >= 0 && !st[ss].empty() && st[ss].back() != cur) {\n int start2 = ii + 1;\n if (start2 < (int)st[ss].size()) {\n energySpent += real_move_tail(st, pos, ops, ss, start2, best.d2);\n }\n }\n\n auto [sss, _] = pos[cur];\n (void)_;\n ops.emplace_back(cur, 0);\n st[sss].pop_back();\n pos[cur] = {-1,-1};\n cur++;\n }\n\n if ((int)ops.size() > 5000) break;\n }\n\n return {energySpent, ops};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m;\n vector> init_st(m);\n for (int i = 0; i < m; i++) {\n init_st[i].resize(n / m);\n for (int j = 0; j < n / m; j++) cin >> init_st[i][j];\n }\n\n auto t0 = chrono::high_resolution_clock::now();\n uint64_t baseSeed = (uint64_t)t0.time_since_epoch().count();\n\n Config baseCfg;\n\n Config riskCfg = baseCfg;\n riskCfg.EXTRA_ROLLOUT_BIG = 18;\n riskCfg.MAX_PEEL = 7;\n riskCfg.deep_peel_gate_w = 18;\n riskCfg.danger_base = 18;\n riskCfg.danger_early_bonus = 6;\n\n Config ultraCfg = riskCfg;\n ultraCfg.EXTRA_ROLLOUT_BIG = 26;\n ultraCfg.MAX_PEEL = 9;\n ultraCfg.EM_MAX_PEEL = 12;\n ultraCfg.deep_peel_gate_w = 28; // important change: allow deep peel for \"soon-ish\" values\n ultraCfg.danger_base = 20;\n ultraCfg.danger_early_bonus = 8;\n ultraCfg.BIG_BLOCK = 6; // start danger filtering earlier\n\n Result best;\n best.energy = (1LL<<62);\n\n int attempts = 0;\n while (true) {\n double sec = chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n if (sec > 1.93) break;\n if (attempts >= 12) break;\n\n // Deterministic first 3 (baseline/risk/ultra), then diversified attempts\n int noiseAmp = (attempts <= 2 ? 0 : 80000);\n\n const Config* cfg = &baseCfg;\n if (attempts == 1) cfg = &riskCfg;\n if (attempts == 2) cfg = &ultraCfg;\n if (attempts >= 3) {\n // cycle configs in later attempts\n if (attempts % 5 == 3) cfg = &riskCfg;\n if (attempts % 5 == 4) cfg = &ultraCfg;\n }\n\n uint64_t seed = baseSeed + 1000003ULL * attempts;\n Result r = solve_once(init_st, seed, noiseAmp, *cfg);\n if (r.energy < best.energy) best = std::move(r);\n\n attempts++;\n }\n\n for (auto [v, i] : best.ops) cout << v << \" \" << i << \"\\n\";\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstatic inline char opp(char c){\n if(c=='U') return 'D';\n if(c=='D') return 'U';\n if(c=='L') return 'R';\n return 'L';\n}\n\nstruct Timer {\n chrono::high_resolution_clock::time_point st;\n Timer(): st(chrono::high_resolution_clock::now()) {}\n double elapsed() const {\n return chrono::duration(chrono::high_resolution_clock::now() - st).count();\n }\n};\n\nstruct Seg {\n const string* s;\n int l, r; // [l,r)\n int rep; // repeat count\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Timer timer;\n const double HARD_TL = 1.98;\n\n int N;\n cin >> N;\n vector h(N-1), v(N);\n for(int i=0;i> h[i];\n for(int i=0;i> v[i];\n vector> d2(N, vector(N));\n for(int i=0;i> d2[i][j];\n\n int V = N*N;\n auto id = [&](int i,int j){ return i*N + j; };\n\n vector d(V);\n for(int i=0;i>> g(V);\n auto add_edge = [&](int a,int b,char c){\n g[a].push_back({b,c});\n };\n for(int i=0;i distAll((size_t)V*V, INF);\n vector prevAll((size_t)V*V, -1);\n vector moveAll((size_t)V*V, 0);\n\n deque q;\n vector distTmp(V);\n vector prevTmp(V);\n vector moveTmp(V);\n\n for(int s=0;sint{\n return (int)distAll[(size_t)s*V + t];\n };\n auto get_path = [&](int s,int t)->string{\n if(s==t) return \"\";\n size_t base=(size_t)s*V;\n if(distAll[base+t]==INF) return \"\";\n string rev;\n int cur=t;\n while(cur!=s){\n rev.push_back(moveAll[base+cur]);\n cur=(int)prevAll[base+cur];\n if(cur<0) return \"\";\n }\n reverse(rev.begin(), rev.end());\n return rev;\n };\n auto reverse_opp = [&](const string& p)->string{\n string r; r.reserve(p.size());\n for(int i=(int)p.size()-1;i>=0;i--) r.push_back(opp(p[i]));\n return r;\n };\n\n // -------- eval by segments (exact) --------\n vector stamp(V,0), firstT(V,0), lastT(V,0);\n vector sumG(V,0);\n int curStamp=1;\n vector touched; touched.reserve(V);\n\n auto eval_segments = [&](const vector& segs, int L)->long double{\n int myStamp=curStamp++;\n if(curStamp==INT_MAX){\n fill(stamp.begin(), stamp.end(), 0);\n curStamp=1;\n myStamp=curStamp++;\n }\n touched.clear();\n\n int ci=0,cj=0,t=0;\n auto step = [&](char c)->bool{\n ++t;\n if(c=='U') ci--;\n else if(c=='D') ci++;\n else if(c=='L') cj--;\n else cj++;\n if(ci<0||ci>=N||cj<0||cj>=N) return false;\n int u=id(ci,cj);\n if(stamp[u]!=myStamp){\n stamp[u]=myStamp;\n firstT[u]=lastT[u]=t;\n sumG[u]=0;\n touched.push_back(u);\n }else{\n long long gap=t-lastT[u];\n sumG[u]+=gap*(gap-1)/2;\n lastT[u]=t;\n }\n return true;\n };\n\n for(const auto& seg: segs){\n const string& s=*seg.s;\n for(int rep=0; repstring{\n int L = (int)p0a.size() + (int)cover.size() + (int)pa0.size();\n if(loop) L += (r1+r2)*(int)loop->size();\n string out; out.reserve(L);\n out += p0a;\n if(loop) for(int i=0;istring{\n int L = (int)p0a.size() + (int)cover.size() + (int)pa0.size() + r*(int)loop.size();\n string out; out.reserve(L);\n out += p0a;\n out.append(cover.begin(), cover.begin()+k);\n for(int i=0;istring{\n int L = (int)p0a.size() + kCover*(int)coverPat.size() + (int)pa0.size();\n if(loop) L += (r1+r2)*(int)loop->size();\n string out; out.reserve(L);\n out += p0a;\n if(loop) for(int i=0;istring{\n vector vis(V,0);\n int pos=anchor;\n vis[pos]=1;\n int unvisited=V-1;\n string route;\n route.reserve(40000);\n\n const long double alpha=1.25L;\n const int slack=6;\n\n int guard=0;\n while(unvisited>0 && guard++<20000){\n int minDist=INT_MAX;\n for(int u=0;ulimit) continue;\n long double sc=(long double)d[u]/pow((long double)(du+1), alpha);\n if(sc>best){ best=sc; chosen=u; }\n }\n if(chosen==-1){\n for(int u=0;u0){\n vector rem;\n for(int u=0;ud[b]; });\n for(int u: rem){\n string p=get_path(pos,u);\n int ci=pos/N,cj=pos%N;\n for(char mv: p){\n route.push_back(mv);\n if(mv=='U') ci--;\n else if(mv=='D') ci++;\n else if(mv=='L') cj--;\n else cj++;\n pos=id(ci,cj);\n if(!vis[pos]){ vis[pos]=1; unvisited--; }\n }\n }\n }\n if(pos!=anchor) route += get_path(pos,anchor);\n return route;\n };\n\n // -------- anchors --------\n vector dist0(V);\n for(int u=0;u allNodes(V);\n iota(allNodes.begin(), allNodes.end(), 0);\n\n auto top_by = [&](auto scoreFn, int take)->vector{\n vector vec=allNodes;\n sort(vec.begin(), vec.end(), [&](int a,int b){\n long double sa=scoreFn(a), sb=scoreFn(b);\n if(sa!=sb) return sa>sb;\n return d[a]>d[b];\n });\n vector res;\n for(int x: vec){\n if(x==0) continue;\n res.push_back(x);\n if((int)res.size()>=take) break;\n }\n return res;\n };\n\n auto byD = top_by([&](int u){ return (long double)d[u]; }, 24);\n auto byNear = top_by([&](int u){ return (long double)d[u]/(long double)(dist0[u]+1); }, 24);\n const long double beta=0.35L;\n auto byFar = top_by([&](int u){ return (long double)d[u]*pow((long double)(dist0[u]+1), beta); }, 24);\n\n vector anchors;\n anchors.push_back(0);\n for(int x: byD) anchors.push_back(x);\n for(int x: byNear) anchors.push_back(x);\n for(int x: byFar) anchors.push_back(x);\n sort(anchors.begin(), anchors.end());\n anchors.erase(unique(anchors.begin(), anchors.end()), anchors.end());\n if((int)anchors.size()>22) anchors.resize(22);\n\n sort(anchors.begin(), anchors.end(), [&](int a,int b){\n long double sa=(long double)d[a]/(long double)(dist0[a]+1);\n long double sb=(long double)d[b]/(long double)(dist0[b]+1);\n if(sa!=sb) return sa>sb;\n return d[a]>d[b];\n });\n if(!anchors.empty() && anchors[0]!=0){\n auto it=find(anchors.begin(), anchors.end(), 0);\n if(it!=anchors.end()){\n int x=*it;\n anchors.erase(it);\n anchors.insert(anchors.begin(), x);\n }\n }\n\n auto build_r_list = [&](int maxR)->vector{\n vector r;\n auto add=[&](int x){ if(0<=x && x<=maxR) r.push_back(x); };\n add(0);\n for(int i=1;i<=8;i++) add(i);\n int a=1,b=2;\n while(a<=maxR){\n add(a);\n int c=a+b; a=b; b=c;\n }\n add(maxR);\n add(maxR/2);\n sort(r.begin(), r.end());\n r.erase(unique(r.begin(), r.end()), r.end());\n if((int)r.size()>18) r.resize(18);\n return r;\n };\n auto splits_for = [&](int r)->array{ return {0, r/2, r}; };\n\n // -------- locally-aware loops around a center --------\n auto build_center_loops = [&](int center)->vector{\n vector loops;\n loops.reserve(12);\n\n // 2-step neighbor loops\n for(auto [to,mv]: g[center]){\n string lp;\n lp.push_back(mv);\n lp.push_back(opp(mv));\n loops.push_back(lp);\n }\n\n // local candidates from ALL nodes by d/(dist+1)^alpha\n const long double alpha = 1.10L;\n vector> cand;\n cand.reserve(V);\n for(int u=0;ub.first; });\n cand.resize(take);\n sort(cand.begin(), cand.end(), [&](auto &a, auto &b){\n if(a.first!=b.first) return a.first>b.first;\n return d[a.second]>d[b.second];\n });\n\n for(int i=0;i10) loops.resize(10);\n return loops;\n };\n\n // -------- main search --------\n string bestRoute;\n long double bestScore = 1e30;\n\n for(int anchor: anchors){\n if(timer.elapsed() > HARD_TL) break;\n\n string p0a=get_path(0,anchor);\n string pa0=reverse_opp(p0a);\n\n string cover=build_cover_route(anchor);\n int coverLen=(int)cover.size();\n\n int baseLen=(int)p0a.size()+coverLen+(int)pa0.size();\n if(baseLen>100000) continue;\n\n // base candidate\n {\n vector segs{{&p0a,0,(int)p0a.size(),1},{&cover,0,coverLen,1},{&pa0,0,(int)pa0.size(),1}};\n long double sc=eval_segments(segs, baseLen);\n if(sc HARD_TL) break;\n int c=(int)loop.size();\n if(c<=0 || c>budget) continue;\n int maxR=budget/c;\n auto rlist=build_r_list(maxR);\n int bestR=0; long double bestLocal=1e30;\n\n for(int r: rlist){\n auto ss=splits_for(r);\n for(int r1: ss){\n int r2=r-r1;\n int L=baseLen+r*c;\n vector segs{\n {&p0a,0,(int)p0a.size(),1},\n {&loop,0,c,r1},\n {&cover,0,coverLen,1},\n {&loop,0,c,r2},\n {&pa0,0,(int)pa0.size(),1}\n };\n long double sc=eval_segments(segs, L);\n if(scmaxR) continue;\n int r1=r/2, r2=r-r1;\n int L=baseLen+r*c;\n vector segs{\n {&p0a,0,(int)p0a.size(),1},\n {&loop,0,c,r1},\n {&cover,0,coverLen,1},\n {&loop,0,c,r2},\n {&pa0,0,(int)pa0.size(),1}\n };\n long double sc=eval_segments(segs, L);\n if(sc posAt(coverLen+1);\n posAt[0]=anchor;\n {\n int ci=anchor/N,cj=anchor%N;\n for(int t=1;t<=coverLen;t++){\n char mv=cover[t-1];\n if(mv=='U') ci--;\n else if(mv=='D') ci++;\n else if(mv=='L') cj--;\n else cj++;\n posAt[t]=id(ci,cj);\n }\n }\n vector firstOcc(V,-1);\n for(int t=0;t<=coverLen;t++){\n int p=posAt[t];\n if(firstOcc[p]==-1) firstOcc[p]=t;\n }\n vector> cps;\n cps.reserve(V);\n for(int u=0;ucoverLen-10) continue;\n int da=get_dist(anchor,u);\n long double sc=(long double)d[u]*sqrt((long double)(da+1));\n cps.push_back({sc,k});\n }\n if(!cps.empty()){\n int take=min(8,(int)cps.size());\n nth_element(cps.begin(), cps.begin()+take, cps.end(),\n [&](auto &a, auto &b){ return a.first>b.first; });\n cps.resize(take);\n sort(cps.begin(), cps.end(), [&](auto &a, auto &b){\n if(a.first!=b.first) return a.first>b.first;\n return a.second HARD_TL) break;\n int k=pp.second;\n int center=posAt[k];\n auto loopsC=build_center_loops(center);\n for(const string& loop: loopsC){\n int c=(int)loop.size();\n if(c<=0 || c>budget) continue;\n int maxR=budget/c;\n auto rlist=build_r_list(maxR);\n int bestR=0; long double bestLocal=1e30;\n\n for(int r: rlist){\n int L=baseLen+r*c;\n vector segs{\n {&p0a,0,(int)p0a.size(),1},\n {&cover,0,k,1},\n {&loop,0,c,r},\n {&cover,k,coverLen,1},\n {&pa0,0,(int)pa0.size(),1}\n };\n long double sc=eval_segments(segs, L);\n if(scmaxR) continue;\n int L=baseLen+r*c;\n vector segs{\n {&p0a,0,(int)p0a.size(),1},\n {&cover,0,k,1},\n {&loop,0,c,r},\n {&cover,k,coverLen,1},\n {&pa0,0,(int)pa0.size(),1}\n };\n long double sc=eval_segments(segs, L);\n if(sc HARD_TL) break;\n }\n }\n }\n\n // limited cover repetition extras: only kCover=2, two patterns, optional anchor loop\n // (kept small to avoid time/candidate blow-up)\n {\n int kCover=2;\n string coverRev = reverse_opp(cover);\n string coverPat2; coverPat2.reserve(cover.size()+coverRev.size());\n coverPat2 += cover;\n coverPat2 += coverRev;\n\n vector pats = {&cover, &coverPat2};\n for(const string* pat: pats){\n if(timer.elapsed() > HARD_TL) break;\n int lenPat=(int)pat->size();\n if(lenPat==0) continue;\n int L0 = (int)p0a.size() + kCover*lenPat + (int)pa0.size();\n if(L0>100000) continue;\n\n // no loop\n {\n vector segs{{&p0a,0,(int)p0a.size(),1},{pat,0,lenPat,kCover},{&pa0,0,(int)pa0.size(),1}};\n long double sc=eval_segments(segs, L0);\n if(sc0 && c<=budget2){\n int maxR = budget2 / c;\n auto rlist = build_r_list(maxR);\n for(int r: rlist){\n auto ss=splits_for(r);\n for(int r1: ss){\n int r2=r-r1;\n int L = L0 + r*c;\n vector segs{\n {&p0a,0,(int)p0a.size(),1},\n {&loop,0,c,r1},\n {pat,0,lenPat,kCover},\n {&loop,0,c,r2},\n {&pa0,0,(int)pa0.size(),1}\n };\n long double sc=eval_segments(segs, L);\n if(sc vis(V,0);\n vector it(V,0), st;\n vector ent;\n string base; base.reserve(2*V+10);\n auto g2=g;\n for(int u=0;u d[b.first];\n });\n }\n st.push_back(0);\n ent.push_back(0);\n vis[0]=1;\n while(!st.empty()){\n int u=st.back();\n int &ii=it[u];\n if(ii==(int)g2[u].size()){\n st.pop_back();\n char mv=ent.back(); ent.pop_back();\n if(!st.empty()) base.push_back(opp(mv));\n continue;\n }\n auto [to,mv]=g2[u][ii++];\n if(vis[to]) continue;\n vis[to]=1;\n base.push_back(mv);\n st.push_back(to);\n ent.push_back(mv);\n }\n bestRoute=base;\n }\n\n cout << bestRoute << \"\\n\";\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstatic const long long INF = (1LL << 60);\n\nstruct Timer {\n chrono::steady_clock::time_point st;\n Timer() : st(chrono::steady_clock::now()) {}\n double elapsed_sec() const {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - st).count();\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n vector t(M);\n for (int i = 0; i < M; i++) cin >> t[i];\n\n // words as ints\n vector> wchars(M);\n for (int i = 0; i < M; i++) for (int k = 0; k < 5; k++) wchars[i][k] = t[i][k] - 'A';\n\n const int V = N * N;\n const int startCell = si * N + sj;\n\n // coords + dist matrix\n vector X(V), Y(V);\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int id = i * N + j;\n X[id] = i; Y[id] = j;\n }\n static uint8_t distMat[225][225];\n for (int a = 0; a < V; a++) for (int b = 0; b < V; b++) {\n distMat[a][b] = (uint8_t)(abs(X[a] - X[b]) + abs(Y[a] - Y[b]));\n }\n\n // positions per letter\n array, 26> positions;\n for (int c = 0; c < 26; c++) positions[c].clear();\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n positions[grid[i][j] - 'A'].push_back(i * N + j);\n }\n\n // idxInLetter[c][cellId]\n array, 26> idxInLetter;\n for (int c = 0; c < 26; c++) {\n idxInLetter[c].fill(-1);\n for (int k = 0; k < (int)positions[c].size(); k++) idxInLetter[c][positions[c][k]] = k;\n }\n\n // overlaps ov[i][j] in 0..4 and addLen = 5-ov\n vector> ov(M, vector(M, 0));\n vector> addLen(M, vector(M, 5));\n for (int i = 0; i < M; i++) for (int j = 0; j < M; j++) if (i != j) {\n int best = 0;\n for (int l = 4; l >= 1; l--) {\n bool ok = true;\n for (int k = 0; k < l; k++) {\n if (t[i][5 - l + k] != t[j][k]) { ok = false; break; }\n }\n if (ok) { best = l; break; }\n }\n ov[i][j] = (uint8_t)best;\n addLen[i][j] = (uint8_t)(5 - best);\n }\n\n // 1-step lookahead: outMaxOv[i] = max ov[i][*]\n vector outMaxOv(M, 0);\n for (int i = 0; i < M; i++) {\n int mx = 0;\n for (int j = 0; j < M; j++) if (i != j) mx = max(mx, (int)ov[i][j]);\n outMaxOv[i] = (uint8_t)mx;\n }\n\n mt19937 rng((uint32_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n // Edge-sum objective: sum addLen[perm[i]][perm[i+1]]\n auto edge_sum = [&](const vector& perm) -> int {\n int s = 0;\n for (int i = 0; i + 1 < (int)perm.size(); i++) s += addLen[perm[i]][perm[i + 1]];\n return s;\n };\n\n // O(1) delta for swapping positions a,b for edge_sum\n auto delta_swap_edge_sum = [&](const vector& perm, int a, int b) -> int {\n if (a > b) swap(a, b);\n int n = (int)perm.size();\n int idxs[6];\n int cnt = 0;\n auto addIdx = [&](int i){\n if (0 <= i && i < n - 1) idxs[cnt++] = i;\n };\n addIdx(a - 1); addIdx(a); addIdx(b - 1); addIdx(b);\n sort(idxs, idxs + cnt);\n cnt = int(unique(idxs, idxs + cnt) - idxs);\n\n int before = 0, after = 0;\n for (int k = 0; k < cnt; k++) {\n int i = idxs[k];\n before += addLen[perm[i]][perm[i + 1]];\n }\n auto get2 = [&](int idx)->int {\n if (idx == a) return perm[b];\n if (idx == b) return perm[a];\n return perm[idx];\n };\n for (int k = 0; k < cnt; k++) {\n int i = idxs[k];\n after += addLen[get2(i)][get2(i + 1)];\n }\n return after - before;\n };\n\n // DP step for one letter\n auto dp_step = [&](const vector& prevIds, const vector& prevCost, int c,\n vector& curIds, vector& curCost) {\n curIds = positions[c];\n curCost.assign(curIds.size(), INF);\n for (int ui = 0; ui < (int)prevIds.size(); ui++) {\n int u = prevIds[ui];\n long long base = prevCost[ui] + 1; // press\n for (int vi = 0; vi < (int)curIds.size(); vi++) {\n int v = curIds[vi];\n long long cand = base + distMat[u][v];\n if (cand < curCost[vi]) curCost[vi] = cand;\n }\n }\n };\n\n // exact typing cost for permutation-induced superstring (no string construction)\n auto typing_cost_perm = [&](const vector& perm) -> long long {\n vector prevIds(1, startCell), curIds;\n vector prevCost(1, 0), curCost;\n\n int first = perm[0];\n for (int k = 0; k < 5; k++) {\n dp_step(prevIds, prevCost, wchars[first][k], curIds, curCost);\n prevIds.swap(curIds);\n prevCost.swap(curCost);\n }\n for (int i = 1; i < M; i++) {\n int a = perm[i - 1], b = perm[i];\n int o = ov[a][b];\n for (int k = o; k < 5; k++) {\n dp_step(prevIds, prevCost, wchars[b][k], curIds, curCost);\n prevIds.swap(curIds);\n prevCost.swap(curCost);\n }\n }\n long long ans = INF;\n for (auto v : prevCost) ans = min(ans, v);\n return ans;\n };\n\n auto build_string_from_perm = [&](const vector& perm) -> string {\n string S;\n S.reserve(1200);\n S += t[perm[0]];\n for (int i = 1; i < M; i++) {\n int a = perm[i - 1], b = perm[i];\n int o = ov[a][b];\n S += t[b].substr(o);\n }\n return S;\n };\n\n // Precompute \"start typing cost\" of each word from startCell (5 chars only).\n vector startWordCost(M, 0);\n {\n for (int w = 0; w < M; w++) {\n vector prevIds(1, startCell), curIds;\n vector prevCost(1, 0), curCost;\n for (int k = 0; k < 5; k++) {\n dp_step(prevIds, prevCost, wchars[w][k], curIds, curCost);\n prevIds.swap(curIds);\n prevCost.swap(curCost);\n }\n long long ans = INF;\n for (auto v : prevCost) ans = min(ans, v);\n startWordCost[w] = (int)ans;\n }\n }\n vector startOrder(M);\n iota(startOrder.begin(), startOrder.end(), 0);\n sort(startOrder.begin(), startOrder.end(), [&](int a, int b){\n return startWordCost[a] < startWordCost[b];\n });\n\n // overlap greedy with lookahead tie-break, and smarter start choice\n auto build_perm_greedy = [&]() -> vector {\n vector perm;\n perm.reserve(M);\n vector used(M, 0);\n\n int K = 12;\n int st = startOrder[uniform_int_distribution(0, min(K, M) - 1)(rng)];\n int cur = st;\n used[cur] = 1;\n perm.push_back(cur);\n\n for (int step = 1; step < M; step++) {\n int bestO = -1;\n for (int j = 0; j < M; j++) if (!used[j]) bestO = max(bestO, (int)ov[cur][j]);\n\n int bestLook = -1;\n vector cand;\n cand.reserve(80);\n\n for (int j = 0; j < M; j++) if (!used[j] && (int)ov[cur][j] == bestO) {\n int look = (int)outMaxOv[j];\n if (look > bestLook) {\n bestLook = look;\n cand.clear();\n cand.push_back(j);\n } else if (look == bestLook) {\n if ((int)cand.size() < 80) cand.push_back(j);\n else if (uniform_int_distribution(0, step)(rng) == 0) {\n cand[uniform_int_distribution(0, 79)(rng)] = j;\n }\n }\n }\n\n int nxt = cand[uniform_int_distribution(0, (int)cand.size() - 1)(rng)];\n used[nxt] = 1;\n perm.push_back(nxt);\n cur = nxt;\n }\n return perm;\n };\n\n // Very fast length hillclimb on edge_sum:\n // - mostly swap with O(1) delta\n // - rare relocate with full recompute (safe)\n auto improve_by_length_fast = [&](vector& perm, int iters) {\n int curSum = edge_sum(perm);\n for (int it = 0; it < iters; it++) {\n int mt = (int)(rng() % 100);\n if (mt < 85) {\n int a = (int)(rng() % M);\n int b = (int)(rng() % M);\n if (a == b) continue;\n int d = delta_swap_edge_sum(perm, a, b);\n if (d <= 0) {\n swap(perm[a], perm[b]);\n curSum += d;\n }\n } else {\n int i = (int)(rng() % M);\n int j = (int)(rng() % M);\n if (i == j) continue;\n\n int val = perm[i];\n if (i < j) {\n for (int k = i; k < j; k++) perm[k] = perm[k + 1];\n perm[j] = val;\n } else {\n for (int k = i; k > j; k--) perm[k] = perm[k - 1];\n perm[j] = val;\n }\n\n int nxtSum = edge_sum(perm);\n if (nxtSum <= curSum) curSum = nxtSum;\n else {\n // undo\n if (i < j) {\n int vv = perm[j];\n for (int k = j; k > i; k--) perm[k] = perm[k - 1];\n perm[i] = vv;\n } else {\n int vv = perm[j];\n for (int k = j; k < i; k++) perm[k] = perm[k + 1];\n perm[i] = vv;\n }\n }\n }\n }\n };\n\n Timer timer;\n const double TIME_LIMIT = 1.90;\n\n // ---- Exploration: maximize throughput ----\n vector bestPerm;\n long long bestType = INF;\n int bestES = INT_MAX;\n\n while (timer.elapsed_sec() < TIME_LIMIT * 0.91) {\n vector perm = build_perm_greedy();\n improve_by_length_fast(perm, 1800);\n long long tc = typing_cost_perm(perm);\n int es = edge_sum(perm);\n\n if (tc < bestType || (tc == bestType && es < bestES)) {\n bestType = tc;\n bestES = es;\n bestPerm = perm;\n }\n }\n\n if (bestPerm.empty()) {\n bestPerm.resize(M);\n iota(bestPerm.begin(), bestPerm.end(), 0);\n bestType = typing_cost_perm(bestPerm);\n bestES = edge_sum(bestPerm);\n }\n\n // ---- Final stable improvement on objective = typingCost + edgeSum ----\n {\n vector cur = bestPerm;\n long long curType = bestType;\n int curES = bestES;\n long long curObj = curType + (long long)curES;\n\n while (timer.elapsed_sec() < TIME_LIMIT * 0.985) {\n int mt = (int)(rng() % 100);\n vector nxt = cur;\n\n if (mt < 45) {\n int a = (int)(rng() % M);\n int b = (int)(rng() % M);\n if (a == b) continue;\n swap(nxt[a], nxt[b]);\n } else if (mt < 80) {\n int i = (int)(rng() % M);\n int j = (int)(rng() % M);\n if (i == j) continue;\n int val = nxt[i];\n if (i < j) {\n for (int k = i; k < j; k++) nxt[k] = nxt[k + 1];\n nxt[j] = val;\n } else {\n for (int k = i; k > j; k--) nxt[k] = nxt[k - 1];\n nxt[j] = val;\n }\n } else {\n int l = (int)(rng() % (M - 1));\n int len = 2 + (int)(rng() % 17); // 2..18\n int r = min(M - 1, l + len - 1);\n if (l >= r) continue;\n reverse(nxt.begin() + l, nxt.begin() + r + 1);\n }\n\n int nxtES = edge_sum(nxt);\n if (nxtES - curES > 12) continue;\n\n long long nxtType = typing_cost_perm(nxt);\n long long nxtObj = nxtType + (long long)nxtES;\n\n if (nxtObj < curObj) {\n cur = std::move(nxt);\n curType = nxtType;\n curES = nxtES;\n curObj = nxtObj;\n if (curObj < bestType + (long long)bestES) {\n bestPerm = cur;\n bestType = curType;\n bestES = curES;\n }\n }\n }\n }\n\n // ---- Reconstruct minimal typing path for final string ----\n string S = build_string_from_perm(bestPerm);\n int L = (int)S.size();\n vector letters(L);\n for (int i = 0; i < L; i++) letters[i] = S[i] - 'A';\n\n vector> parent(L);\n vector prevIds(1, startCell);\n vector prevCost(1, 0);\n\n vector lastIds;\n vector lastCost;\n\n for (int p = 0; p < L; p++) {\n int c = letters[p];\n const auto &curIds = positions[c];\n vector curCost(curIds.size(), INF);\n parent[p].assign(curIds.size(), (int16_t)-1);\n\n for (int vi = 0; vi < (int)curIds.size(); vi++) {\n int v = curIds[vi];\n long long bestv = INF;\n int bestPrev = -1;\n for (int ui = 0; ui < (int)prevIds.size(); ui++) {\n int u = prevIds[ui];\n long long cand = prevCost[ui] + distMat[u][v] + 1;\n if (cand < bestv) { bestv = cand; bestPrev = u; }\n }\n curCost[vi] = bestv;\n parent[p][vi] = (int16_t)bestPrev;\n }\n\n prevIds = curIds;\n prevCost.swap(curCost);\n lastIds = prevIds;\n lastCost = prevCost;\n }\n\n int endIdx = 0;\n for (int i = 1; i < (int)lastCost.size(); i++) if (lastCost[i] < lastCost[endIdx]) endIdx = i;\n\n vector ansCells(L);\n int curCell = lastIds[endIdx];\n for (int p = L - 1; p >= 0; p--) {\n ansCells[p] = curCell;\n int c = letters[p];\n int k = idxInLetter[c][curCell];\n curCell = (int)parent[p][k];\n }\n\n for (int p = 0; p < L; p++) {\n int id = ansCells[p];\n cout << (id / N) << ' ' << (id % N) << '\\n';\n }\n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x = 88172645463325252ull;\n explicit XorShift(uint64_t seed = 0) {\n if (seed) x ^= seed;\n for (int i = 0; i < 10; i++) next_u64();\n }\n uint64_t next_u64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int lo, int hi) { // inclusive\n return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1));\n }\n};\n\nstruct Placement {\n vector cells; // indices in [0, V)\n vector contrib; // per measurement\n vector cover; // per drilled constraint point d: 0/1\n};\n\nenum class MeasType { SUM, DIFF };\n\nstruct Measure {\n MeasType type;\n vector s1; // SUM: set; DIFF: plus set\n vector s2; // DIFF: minus set\n vector w; // weights for all cells\n};\n\nstatic inline void flush_out() { cout << flush; }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector>> shapes(M);\n for (int k = 0; k < M; k++) {\n int d; cin >> d;\n shapes[k].resize(d);\n for (int i = 0; i < d; i++) {\n int r, c; cin >> r >> c;\n shapes[k][i] = {r, c};\n }\n }\n\n const int V = N * N;\n const int maxOps = 2 * V;\n int ops = 0;\n\n // known[idx] = drilled exact value else -1\n vector known(V, -1);\n vector must_have(V, 0);\n\n auto inc_ops = [&](int add) { ops += add; };\n auto read_or_exit = [&](T &x) {\n if (!(cin >> x)) exit(0);\n };\n\n auto count_known = [&]() -> int {\n int c = 0;\n for (int v : known) if (v != -1) c++;\n return c;\n };\n auto can_still_fallback = [&]() -> bool {\n int remaining = V - count_known();\n return ops + remaining + 1 <= maxOps;\n };\n\n auto query_set = [&](const vector& idxs) -> long long {\n inc_ops(1);\n cout << \"q \" << (int)idxs.size();\n for (int idx : idxs) cout << \" \" << idx / N << \" \" << idx % N;\n cout << \"\\n\";\n flush_out();\n long long resp;\n read_or_exit(resp);\n return resp;\n };\n\n auto drill_if_unknown = [&](int idx) -> int {\n if (known[idx] != -1) return known[idx];\n inc_ops(1);\n cout << \"q 1 \" << idx / N << \" \" << idx % N << \"\\n\";\n flush_out();\n long long v;\n read_or_exit(v);\n known[idx] = (int)v;\n if (v > 0) must_have[idx] = 1;\n return known[idx];\n };\n\n auto output_answer_mask = [&](const vector& oilMask) -> int {\n inc_ops(1);\n vector> cells;\n cells.reserve(V);\n for (int idx = 0; idx < V; idx++) {\n if (oilMask[idx] || must_have[idx]) cells.push_back({idx / N, idx % N});\n }\n cout << \"a \" << (int)cells.size();\n for (auto [i, j] : cells) cout << \" \" << i << \" \" << j;\n cout << \"\\n\";\n flush_out();\n int ok;\n read_or_exit(ok);\n return ok;\n };\n\n auto inv_est = [&](long long y, int k) -> float {\n // E[y] = k*eps + (1-2eps)*v(S)\n double denom = (1.0 - 2.0 * eps);\n double vhat = ((double)y - (double)k * eps) / denom;\n if (vhat < 0.0) vhat = 0.0;\n double hi = (double)k * (double)M;\n if (vhat > hi) vhat = hi;\n return (float)vhat;\n };\n\n // ---------------- Budgeting for initial divinations ----------------\n // Conservative plan: leave V+1 ops for worst-case fallback even with zero drills.\n int preBudget = max(0, maxOps - (V + 1));\n int K0 = min(16, max(8, V / 25));\n if (K0 + 1 > preBudget) {\n // Too small: just drill-all fallback\n vector oil(V, 0);\n for (int idx = 0; idx < V; idx++) {\n int v = drill_if_unknown(idx);\n if (v > 0) oil[idx] = 1;\n }\n (void)output_answer_mask(oil);\n return 0;\n }\n int qBudget = preBudget - (K0 + 1);\n\n // Build measurement list within qBudget queries.\n // Structured SUM: rows + cols (2N) + quadrants (4)\n // Random DIFF: each uses 2 queries (plus/minus)\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift rng(seed);\n\n vector meas;\n meas.reserve(140);\n\n auto add_sum_measure = [&](const vector& S) {\n if ((int)S.size() < 2) return;\n Measure m;\n m.type = MeasType::SUM;\n m.s1 = S;\n m.w.assign(V, 0);\n for (int idx : S) m.w[idx] = 1;\n meas.push_back(std::move(m));\n };\n auto add_diff_measure = [&](const vector& P, const vector& Q) {\n if ((int)P.size() < 2 || (int)Q.size() < 2) return;\n Measure m;\n m.type = MeasType::DIFF;\n m.s1 = P; m.s2 = Q;\n m.w.assign(V, 0);\n for (int idx : P) m.w[idx] = +1;\n for (int idx : Q) m.w[idx] = -1;\n meas.push_back(std::move(m));\n };\n\n int usedQ = 0;\n\n auto try_add_structured = [&]() {\n // rows\n for (int i = 0; i < N; i++) {\n if (usedQ + 1 > qBudget) return;\n vector S;\n S.reserve(N);\n for (int j = 0; j < N; j++) S.push_back(i * N + j);\n add_sum_measure(S);\n usedQ += 1;\n }\n // cols\n for (int j = 0; j < N; j++) {\n if (usedQ + 1 > qBudget) return;\n vector S;\n S.reserve(N);\n for (int i = 0; i < N; i++) S.push_back(i * N + j);\n add_sum_measure(S);\n usedQ += 1;\n }\n // quadrants\n int mid = N / 2;\n vector> ranges = {{0, mid}, {mid, N}};\n for (auto [ri0, ri1] : ranges) for (auto [cj0, cj1] : ranges) {\n if (usedQ + 1 > qBudget) return;\n vector S;\n for (int i = ri0; i < ri1; i++) for (int j = cj0; j < cj1; j++) S.push_back(i * N + j);\n add_sum_measure(S);\n usedQ += 1;\n }\n };\n\n try_add_structured();\n\n // Remaining budget for random DIFF measures\n int remainingQ = qBudget - usedQ;\n int maxRand = min(80, remainingQ / 2); // cap to keep optimization fast\n vector perm(V);\n iota(perm.begin(), perm.end(), 0);\n\n for (int t = 0; t < maxRand; t++) {\n // shuffle perm\n for (int i = V - 1; i >= 1; i--) {\n int j = (int)(rng.next_u64() % (uint64_t)(i + 1));\n swap(perm[i], perm[j]);\n }\n int half = V / 2;\n vector P, Q;\n P.reserve(half); Q.reserve(V - half);\n for (int i = 0; i < V; i++) {\n int idx = perm[i];\n if (i < half) P.push_back(idx);\n else Q.push_back(idx);\n }\n if (usedQ + 2 > qBudget) break;\n add_diff_measure(P, Q);\n usedQ += 2;\n }\n\n int T = (int)meas.size();\n\n // ---------------- Query all measurements ----------------\n vector obs(T, 0.0f);\n for (int t = 0; t < T; t++) {\n if (meas[t].type == MeasType::SUM) {\n long long y = query_set(meas[t].s1);\n obs[t] = inv_est(y, (int)meas[t].s1.size());\n } else {\n long long yP = query_set(meas[t].s1);\n long long yQ = query_set(meas[t].s2);\n float vP = inv_est(yP, (int)meas[t].s1.size());\n float vQ = inv_est(yQ, (int)meas[t].s2.size());\n obs[t] = vP - vQ;\n }\n }\n\n // ---------------- Enumerate placements and precompute contrib ----------------\n vector> placements(M);\n placements.reserve(M);\n\n for (int k = 0; k < M; k++) {\n int maxr = 0, maxc = 0;\n for (auto [r, c] : shapes[k]) { maxr = max(maxr, r); maxc = max(maxc, c); }\n int H = maxr + 1, W = maxc + 1;\n int diMax = N - H, djMax = N - W;\n\n vector ps;\n ps.reserve((diMax + 1) * (djMax + 1));\n\n for (int di = 0; di <= diMax; di++) for (int dj = 0; dj <= djMax; dj++) {\n Placement p;\n p.cells.reserve(shapes[k].size());\n for (auto [r, c] : shapes[k]) p.cells.push_back((di + r) * N + (dj + c));\n\n p.contrib.assign(T, 0);\n for (int t = 0; t < T; t++) {\n int s = 0;\n const auto &w = meas[t].w;\n for (int idx : p.cells) s += (int)w[idx];\n p.contrib[t] = (int16_t)s;\n }\n ps.push_back(std::move(p));\n }\n placements[k] = std::move(ps);\n }\n\n auto build_union_mask = [&](const vector& choice) -> vector {\n vector oil(V, 0);\n for (int k = 0; k < M; k++) {\n for (int idx : placements[k][choice[k]].cells) oil[idx] = 1;\n }\n return oil;\n };\n\n // ---------------- Constraints cover cache ----------------\n vector drilledIdx, drilledVal;\n\n auto rebuild_cover = [&]() {\n int D = (int)drilledIdx.size();\n if (D == 0) return;\n vector mark(V, 0);\n for (int k = 0; k < M; k++) {\n for (auto &p : placements[k]) {\n p.cover.assign(D, 0);\n for (int idx : p.cells) mark[idx] = 1;\n for (int d = 0; d < D; d++) p.cover[d] = (uint8_t)(mark[drilledIdx[d]] ? 1 : 0);\n for (int idx : p.cells) mark[idx] = 0;\n }\n }\n };\n\n // ---------------- Optimizer (coordinate descent) ----------------\n auto optimize_one = [&](int restarts, int sweeps, double Wdrill, const vector* warmStart) -> vector {\n int D = (int)drilledIdx.size();\n\n vector base_res(T);\n vector base_cnt_res(max(1, D));\n\n double bestObj = 1e100;\n vector bestChoice;\n\n int totalRuns = restarts + (warmStart ? 1 : 0);\n for (int run = 0; run < totalRuns; run++) {\n vector choice(M);\n if (warmStart && run == 0) choice = *warmStart;\n else for (int k = 0; k < M; k++) choice[k] = rng.next_int(0, (int)placements[k].size() - 1);\n\n vector pred(T, 0);\n for (int t = 0; t < T; t++) {\n int s = 0;\n for (int k = 0; k < M; k++) s += (int)placements[k][choice[k]].contrib[t];\n pred[t] = s;\n }\n vector cntD(D, 0);\n if (D > 0) {\n for (int d = 0; d < D; d++) {\n int s = 0;\n for (int k = 0; k < M; k++) s += (int)placements[k][choice[k]].cover[d];\n cntD[d] = s;\n }\n }\n\n for (int sw = 0; sw < sweeps; sw++) {\n bool changed = false;\n for (int k = 0; k < M; k++) {\n int curP = choice[k];\n\n for (int t = 0; t < T; t++) {\n int base_pred_t = pred[t] - (int)placements[k][curP].contrib[t];\n base_res[t] = (float)base_pred_t - obs[t];\n }\n if (D > 0) {\n for (int d = 0; d < D; d++) {\n int base_cnt = cntD[d] - (int)placements[k][curP].cover[d];\n base_cnt_res[d] = (float)(base_cnt - drilledVal[d]);\n }\n }\n\n int bestP = curP;\n double bestLocal = 1e100;\n const auto &pk = placements[k];\n\n for (int p = 0; p < (int)pk.size(); p++) {\n double o = 0.0;\n const auto &con = pk[p].contrib;\n for (int t = 0; t < T; t++) {\n float r = base_res[t] + (float)con[t];\n o += (double)r * (double)r;\n }\n if (D > 0) {\n const auto &cov = pk[p].cover;\n for (int d = 0; d < D; d++) {\n float r = base_cnt_res[d] + (float)cov[d];\n o += Wdrill * (double)r * (double)r;\n }\n }\n if (o < bestLocal) { bestLocal = o; bestP = p; }\n }\n\n if (bestP != curP) {\n for (int t = 0; t < T; t++)\n pred[t] += (int)placements[k][bestP].contrib[t] - (int)placements[k][curP].contrib[t];\n if (D > 0) {\n for (int d = 0; d < D; d++)\n cntD[d] += (int)placements[k][bestP].cover[d] - (int)placements[k][curP].cover[d];\n }\n choice[k] = bestP;\n changed = true;\n }\n }\n if (!changed) break;\n }\n\n double obj = 0.0;\n for (int t = 0; t < T; t++) {\n double r = (double)pred[t] - (double)obs[t];\n obj += r * r;\n }\n if (D > 0) {\n for (int d = 0; d < D; d++) {\n double r = (double)cntD[d] - (double)drilledVal[d];\n obj += Wdrill * r * r;\n }\n }\n\n if (obj < bestObj) {\n bestObj = obj;\n bestChoice = std::move(choice);\n }\n }\n\n return bestChoice;\n };\n\n // ---------------- Ensemble entropy drilling ----------------\n auto build_boundary_mask = [&](const vector& oil) -> vector {\n vector b(V, 0);\n for (int idx = 0; idx < V; idx++) {\n int i = idx / N, j = idx % N;\n bool me = oil[idx];\n bool isBound = false;\n if (i > 0 && (bool)oil[(i - 1) * N + j] != me) isBound = true;\n else if (i + 1 < N && (bool)oil[(i + 1) * N + j] != me) isBound = true;\n else if (j > 0 && (bool)oil[i * N + (j - 1)] != me) isBound = true;\n else if (j + 1 < N && (bool)oil[i * N + (j + 1)] != me) isBound = true;\n if (isBound) b[idx] = 1;\n }\n return b;\n };\n\n auto pick_drills_by_entropy = [&](const vector>& sols,\n const vector& boundary,\n int K) -> vector {\n int S = (int)sols.size();\n if (S == 0 || K <= 0) return {};\n vector p(V, 0.0f);\n\n for (const auto& sol : sols) {\n auto oil = build_union_mask(sol);\n for (int idx = 0; idx < V; idx++) p[idx] += oil[idx] ? 1.0f : 0.0f;\n }\n for (int idx = 0; idx < V; idx++) p[idx] /= (float)S;\n\n vector> cand;\n cand.reserve(V);\n for (int idx = 0; idx < V; idx++) {\n if (known[idx] != -1) continue;\n float q = p[idx];\n float ent = q * (1.0f - q); // [0,0.25]\n if (boundary[idx]) ent += 0.05f;\n cand.push_back({ent, idx});\n }\n sort(cand.begin(), cand.end(), [&](auto a, auto b){ return a.first > b.first; });\n\n vector res;\n res.reserve(K);\n for (auto [sc, idx] : cand) {\n if ((int)res.size() >= K) break;\n res.push_back(idx);\n }\n return res;\n };\n\n // ---------------- Main solve loop ----------------\n vector choice = optimize_one(/*restarts=*/6, /*sweeps=*/35, /*Wdrill=*/0.0, nullptr);\n\n for (int round = 0; round < 4; round++) {\n if (!can_still_fallback()) break;\n\n int remaining = V - count_known();\n int slack = maxOps - ops - (remaining + 1);\n if (slack <= 2) {\n auto oil = build_union_mask(choice);\n int ok = output_answer_mask(oil);\n if (ok == 1) return 0;\n break;\n }\n\n auto oilBest = build_union_mask(choice);\n auto boundary = build_boundary_mask(oilBest);\n\n // Build ensemble of constrained solutions\n int S = (round == 0 ? 6 : 8);\n int perRestarts = (round == 0 ? 2 : 3);\n int sweeps = 40 + 5 * round;\n double Wdrill = 120.0 + 60.0 * round;\n\n rebuild_cover(); // ensure cover corresponds to current drilledIdx\n\n vector> sols;\n sols.reserve(S);\n sols.push_back(optimize_one(perRestarts, sweeps, Wdrill, &choice));\n for (int s = 1; s < S; s++) sols.push_back(optimize_one(perRestarts, sweeps, Wdrill, nullptr));\n choice = sols[0];\n\n // Choose number of new drills (use slack, but keep room for answer)\n int K = (round == 0 ? K0 : min(30, max(10, slack / 2)));\n if (K > slack - 1) K = max(0, slack - 1);\n\n auto newDrills = pick_drills_by_entropy(sols, boundary, K);\n for (int idx : newDrills) {\n int v = drill_if_unknown(idx);\n drilledIdx.push_back(idx);\n drilledVal.push_back(v);\n }\n\n // rebuild cover once after drilling\n rebuild_cover();\n\n // Refine and answer\n choice = optimize_one(/*restarts=*/6, /*sweeps=*/45 + 5 * round, Wdrill, &choice);\n auto oil = build_union_mask(choice);\n int ok = output_answer_mask(oil);\n if (ok == 1) return 0;\n }\n\n // Guaranteed fallback: drill remaining unknown cells and answer\n vector oilFinal(V, 0);\n for (int idx = 0; idx < V; idx++) {\n int v = drill_if_unknown(idx);\n if (v > 0) oilFinal[idx] = 1;\n }\n (void)output_answer_mask(oilFinal);\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nusing ll = long long;\nstatic const int W = 1000;\nstatic const ll INF = (1LL<<62);\n\nstruct Rect {\n int i0, j0, i1, j1;\n int area() const { return (i1 - i0) * (j1 - j0); }\n};\n\nstatic int symdiff_size(const vector& a, const vector& b) {\n int i = 0, j = 0, cnt = 0;\n while (i < (int)a.size() || j < (int)b.size()) {\n if (j == (int)b.size() || (i < (int)a.size() && a[i] < b[j])) { cnt++; i++; }\n else if (i == (int)a.size() || (j < (int)b.size() && b[j] < a[i])) { cnt++; j++; }\n else { i++; j++; }\n }\n return cnt;\n}\n\nstatic vector boundaries_from_widths(const vector& widths) {\n vector b;\n int x = 0;\n for (int i = 0; i + 1 < (int)widths.size(); i++) {\n x += widths[i];\n if (1 <= x && x <= W - 1) b.push_back(x);\n }\n return b;\n}\n\n// cost for one day if we can assign rectangles by sorting areas (a_day is already sorted by k)\nstatic ll day_cost_from_areas(const vector& a_day, vector areas) {\n sort(areas.begin(), areas.end());\n ll tot = 0;\n for (int k = 0; k < (int)a_day.size(); k++) {\n if (a_day[k] > areas[k]) tot += 100LL * (ll)(a_day[k] - areas[k]);\n }\n return tot;\n}\n\n// Candidate: horizontal bands (cuts), each band has vertical strips (width list).\nstruct Cand {\n vector cuts; // internal y positions, sorted\n vector> wBand; // widths per band, each sums to 1000\n vector> bBand; // x boundaries per band (derived)\n\n vector sig() const {\n vector s;\n s.push_back((int)cuts.size());\n for (int y : cuts) s.push_back(y);\n s.push_back((int)wBand.size());\n for (auto &wb : wBand) {\n s.push_back((int)wb.size());\n for (int x : wb) s.push_back(x);\n }\n return s;\n }\n};\n\nstatic inline int band_index(const Cand& c, int yMid) {\n return (int)(upper_bound(c.cuts.begin(), c.cuts.end(), yMid) - c.cuts.begin());\n}\nstatic inline bool has_boundary_at(const Cand& c, int x, int yMid) {\n int bi = band_index(c, yMid);\n const auto &b = c.bBand[bi];\n return binary_search(b.begin(), b.end(), x);\n}\n\n// Exact transition length for these candidates.\nstatic ll trans_cost(const Cand& A, const Cand& B) {\n ll cost = 0;\n cost += 1LL * W * symdiff_size(A.cuts, B.cuts); // horizontal segments\n\n vector xs;\n for (auto &b : A.bBand) xs.insert(xs.end(), b.begin(), b.end());\n for (auto &b : B.bBand) xs.insert(xs.end(), b.begin(), b.end());\n sort(xs.begin(), xs.end());\n xs.erase(unique(xs.begin(), xs.end()), xs.end());\n\n vector ys = {0, W};\n ys.insert(ys.end(), A.cuts.begin(), A.cuts.end());\n ys.insert(ys.end(), B.cuts.begin(), B.cuts.end());\n sort(ys.begin(), ys.end());\n ys.erase(unique(ys.begin(), ys.end()), ys.end());\n\n for (int x : xs) {\n for (int i = 0; i + 1 < (int)ys.size(); i++) {\n int y0 = ys[i], y1 = ys[i + 1];\n if (y0 == y1) continue;\n int yMid = (y0 + y1) / 2;\n bool a = has_boundary_at(A, x, yMid);\n bool b = has_boundary_at(B, x, yMid);\n if (a != b) cost += (y1 - y0);\n }\n }\n return cost;\n}\n\n// Build rectangles and sort by area for correct assignment.\nstatic vector build_rects_sorted_by_area(const Cand& c) {\n vector ys = {0};\n for (int y : c.cuts) ys.push_back(y);\n ys.push_back(W);\n\n vector rects;\n rects.reserve(80);\n for (int b = 0; b < (int)c.wBand.size(); b++) {\n int y0 = ys[b], y1 = ys[b + 1];\n int x = 0;\n for (int w : c.wBand[b]) {\n rects.push_back({y0, x, y1, x + w});\n x += w;\n }\n }\n stable_sort(rects.begin(), rects.end(), [&](const Rect& r1, const Rect& r2){\n return r1.area() < r2.area();\n });\n return rects;\n}\n\n// Make demand vectors for ranks over selected days, each sorted.\nstatic vector> make_dem_for_ranks_days(const vector>& a,\n const vector& ranks,\n const vector& days) {\n vector> dem;\n dem.reserve(ranks.size());\n for (int rk : ranks) {\n vector v;\n v.reserve(days.size());\n for (int d : days) v.push_back(a[d][rk]);\n sort(v.begin(), v.end());\n dem.push_back(std::move(v));\n }\n return dem;\n}\n\n/*\nCorrect greedy width allocation for fixed band height H.\n\nLet cap = H*w.\nCost = 100 * sum max(0, a - cap).\nIncrease width by 1 => cap += H.\n\nMarginal gain = cost(w) - cost(w+1)\nFor each demand a:\n- if a <= cap: 0\n- if cap < a <= cap+H: gain += (a-cap)\n- if a > cap+H: gain += H\nMultiply total by 100.\n*/\nstruct DemItem {\n vector s;\n vector pref;\n int m = 0;\n void build(vector v) {\n sort(v.begin(), v.end());\n s = std::move(v);\n m = (int)s.size();\n pref.assign(m + 1, 0);\n for (int i = 0; i < m; i++) pref[i + 1] = pref[i] + s[i];\n }\n ll gain_for_cap(int cap, int H) const {\n // cap -> cap+H\n int p1 = upper_bound(s.begin(), s.end(), cap) - s.begin(); // first > cap\n int p2 = upper_bound(s.begin(), s.end(), cap + H) - s.begin(); // first > cap+H\n int cntMid = p2 - p1;\n ll sumMid = pref[p2] - pref[p1];\n ll term1 = sumMid - 1LL * cap * cntMid; // sum(a-cap) for mid\n int cntHigh = m - p2;\n ll term2 = 1LL * H * cntHigh;\n return 100LL * (term1 + term2);\n }\n};\n\nstatic vector greedy_widths_height_correct(const vector>& demRaw, int H) {\n int m = (int)demRaw.size();\n if (m == 0) return {};\n vector items(m);\n for (int i = 0; i < m; i++) items[i].build(demRaw[i]);\n\n vector w(m, 1);\n int used = m;\n\n struct Node {\n ll gain;\n int i;\n int wi;\n bool operator<(const Node& o) const { return gain < o.gain; }\n };\n priority_queue pq;\n for (int i = 0; i < m; i++) {\n int cap = H * w[i];\n ll g = items[i].gain_for_cap(cap, H);\n pq.push({g, i, w[i]});\n }\n\n while (used < W && !pq.empty()) {\n auto cur = pq.top(); pq.pop();\n int i = cur.i;\n if (cur.wi != w[i]) continue;\n\n int cap = H * w[i];\n ll g = items[i].gain_for_cap(cap, H);\n if (g != cur.gain) {\n pq.push({g, i, w[i]});\n continue;\n }\n if (g <= 0) break;\n\n w[i]++; used++;\n int ncap = H * w[i];\n ll ng = items[i].gain_for_cap(ncap, H);\n pq.push({ng, i, w[i]});\n }\n\n if (used < W) w.back() += (W - used);\n int sum = accumulate(w.begin(), w.end(), 0);\n if (sum != W) w.back() += (W - sum);\n return w;\n}\n\nstatic ll cand_day_cost(const vector& a_day, const Cand& c) {\n vector ys = {0};\n for (int y : c.cuts) ys.push_back(y);\n ys.push_back(W);\n\n vector areas;\n areas.reserve(a_day.size());\n for (int b = 0; b < (int)c.wBand.size(); b++) {\n int H = ys[b + 1] - ys[b];\n for (int w : c.wBand[b]) areas.push_back(H * w);\n }\n return day_cost_from_areas(a_day, std::move(areas));\n}\n\n// General multi-band generator: cuts define band heights, split points define rank ranges.\n// Ranks are assigned consecutively 0..N-1 into bands.\nstatic Cand gen_multiband(const vector>& a, int N, const vector& days,\n vector cuts, vector splitPts) {\n // sanitize cuts\n for (int &y : cuts) y = max(1, min(y, W - 1));\n sort(cuts.begin(), cuts.end());\n cuts.erase(unique(cuts.begin(), cuts.end()), cuts.end());\n\n vector ys = {0};\n ys.insert(ys.end(), cuts.begin(), cuts.end());\n ys.push_back(W);\n int B = (int)ys.size() - 1;\n\n // Build rank starts\n vector start(B + 1, 0);\n start[0] = 0;\n start[B] = N;\n\n // If splitPts doesn't match, fallback to equal-size partition\n vector sp = splitPts;\n sort(sp.begin(), sp.end());\n sp.erase(unique(sp.begin(), sp.end()), sp.end());\n if ((int)sp.size() != B - 1) {\n // equal size\n int base = N / B, rem = N % B;\n int cur = 0;\n for (int b = 0; b < B; b++) {\n int sz = base + (b < rem ? 1 : 0);\n start[b] = cur;\n cur += sz;\n }\n start[B] = N;\n for (int b = 1; b < B; b++) start[b] = max(start[b], start[b-1] + 1);\n for (int b = B - 1; b >= 1; b--) start[b] = min(start[b], start[b+1] - 1);\n start[0] = 0; start[B] = N;\n } else {\n // use sp\n start[0] = 0;\n for (int i = 0; i < B - 1; i++) start[i + 1] = sp[i];\n start[B] = N;\n // enforce strictly increasing and valid\n for (int i = 1; i <= B; i++) start[i] = max(start[i], start[i - 1] + 1);\n start[B] = N;\n for (int i = B - 1; i >= 1; i--) start[i] = min(start[i], start[i + 1] - 1);\n start[0] = 0; start[B] = N;\n }\n\n Cand c;\n c.cuts = cuts;\n c.wBand.clear();\n c.wBand.reserve(B);\n\n for (int b = 0; b < B; b++) {\n int l = start[b], r = start[b + 1];\n int m = r - l;\n int H = ys[b + 1] - ys[b];\n vector ranks(m);\n iota(ranks.begin(), ranks.end(), l);\n auto dem = make_dem_for_ranks_days(a, ranks, days);\n auto widths = greedy_widths_height_correct(dem, H);\n sort(widths.begin(), widths.end());\n c.wBand.push_back(std::move(widths));\n }\n return c;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Win, D, N;\n cin >> Win >> D >> N;\n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) for (int k = 0; k < N; k++) cin >> a[d][k];\n\n vector cands;\n cands.reserve(2000);\n\n auto add_cand = [&](Cand c) {\n c.bBand.clear();\n c.bBand.reserve(c.wBand.size());\n for (auto &wb : c.wBand) c.bBand.push_back(boundaries_from_widths(wb));\n cands.push_back(std::move(c));\n };\n\n auto days_all = [&]() {\n vector all(D);\n iota(all.begin(), all.end(), 0);\n return all;\n };\n\n // 1-layer candidates\n {\n add_cand(gen_multiband(a, N, days_all(), {}, {}));\n for (int d = 0; d < D; d++) add_cand(gen_multiband(a, N, {d}, {}, {}));\n for (int d = 0; d + 2 < D; d++) add_cand(gen_multiband(a, N, {d, d+1, d+2}, {}, {}));\n for (int d = 0; d + 4 < D; d++) add_cand(gen_multiband(a, N, {d, d+1, d+2, d+3, d+4}, {}, {}));\n }\n\n // 2-layer candidates: global, per-day, per-3day-window\n vector cuts2 = {200,250,333,400,500,600,667,750,800};\n vector split2 = {max(1, N/3), max(1, N/2), max(1, (2*N)/3)};\n for (int &x : split2) x = max(1, min(x, N-1));\n sort(split2.begin(), split2.end());\n split2.erase(unique(split2.begin(), split2.end()), split2.end());\n\n // global best4\n {\n vector> best;\n auto all = days_all();\n for (int y : cuts2) for (int nTop : split2) {\n Cand c = gen_multiband(a, N, all, {y}, {nTop});\n ll sc = 0;\n for (int d = 0; d < D; d++) sc += cand_day_cost(a[d], c);\n best.push_back({sc, std::move(c)});\n }\n sort(best.begin(), best.end(), [](auto& p1, auto& p2){ return p1.first < p2.first; });\n for (int i = 0; i < min(4, (int)best.size()); i++) add_cand(best[i].second);\n }\n // per-day top2\n for (int d = 0; d < D; d++) {\n vector> best;\n for (int y : cuts2) for (int nTop : split2) {\n Cand c = gen_multiband(a, N, {d}, {y}, {nTop});\n best.push_back({cand_day_cost(a[d], c), std::move(c)});\n }\n sort(best.begin(), best.end(), [](auto& p1, auto& p2){ return p1.first < p2.first; });\n for (int i = 0; i < min(2, (int)best.size()); i++) add_cand(best[i].second);\n }\n // per-3day-window best1\n for (int d = 0; d + 2 < D; d++) {\n vector days = {d, d+1, d+2};\n pair best = {INF, Cand()};\n for (int y : cuts2) for (int nTop : split2) {\n Cand c = gen_multiband(a, N, days, {y}, {nTop});\n ll sc = 0;\n for (int dd : days) sc += cand_day_cost(a[dd], c);\n if (sc < best.first) best = {sc, std::move(c)};\n }\n if (best.first < INF) add_cand(best.second);\n }\n\n // 3-layer candidates: global best3, per-day best1, per-3day-window best1 (small grid)\n vector cuts3 = {200,250,333,400,500,600,667,750,800};\n vector> cutPairs3;\n for (int i = 0; i < (int)cuts3.size(); i++)\n for (int j = i+1; j < (int)cuts3.size(); j++)\n cutPairs3.push_back({cuts3[i], cuts3[j]});\n\n vector pts3 = {max(1,N/4), max(1,N/3), max(1,N/2), max(1,(2*N)/3), max(1,(3*N)/4)};\n for (int &x : pts3) x = max(1, min(x, N-1));\n sort(pts3.begin(), pts3.end());\n pts3.erase(unique(pts3.begin(), pts3.end()), pts3.end());\n\n vector> rankPairs3;\n for (int i = 0; i < (int)pts3.size(); i++)\n for (int j = i+1; j < (int)pts3.size(); j++)\n rankPairs3.push_back({pts3[i], pts3[j]});\n\n // global best3\n {\n vector> best;\n auto all = days_all();\n for (auto [y1,y2] : cutPairs3) for (auto [n1,n2] : rankPairs3) {\n if (!(1 <= n1 && n1 < n2 && n2 <= N-1)) continue;\n Cand c = gen_multiband(a, N, all, {y1,y2}, {n1,n2});\n ll sc = 0;\n for (int d = 0; d < D; d++) sc += cand_day_cost(a[d], c);\n best.push_back({sc, std::move(c)});\n }\n sort(best.begin(), best.end(), [](auto& p1, auto& p2){ return p1.first < p2.first; });\n for (int i = 0; i < min(3, (int)best.size()); i++) add_cand(best[i].second);\n }\n // per-day best1\n for (int d = 0; d < D; d++) {\n pair best = {INF, Cand()};\n for (auto [y1,y2] : cutPairs3) for (auto [n1,n2] : rankPairs3) {\n if (!(1 <= n1 && n1 < n2 && n2 <= N-1)) continue;\n Cand c = gen_multiband(a, N, {d}, {y1,y2}, {n1,n2});\n ll sc = cand_day_cost(a[d], c);\n if (sc < best.first) best = {sc, std::move(c)};\n }\n if (best.first < INF) add_cand(best.second);\n }\n // per-3day-window best1 (smaller grid)\n {\n vector cutsS = {250,333,500,667,750};\n vector> cutPairsS;\n for (int i = 0; i < (int)cutsS.size(); i++)\n for (int j = i+1; j < (int)cutsS.size(); j++)\n cutPairsS.push_back({cutsS[i], cutsS[j]});\n vector ptsS = {max(1,N/3), max(1,N/2), max(1,(2*N)/3)};\n for (int &x : ptsS) x = max(1, min(x, N-1));\n sort(ptsS.begin(), ptsS.end());\n ptsS.erase(unique(ptsS.begin(), ptsS.end()), ptsS.end());\n vector> rankPairsS;\n for (int i = 0; i < (int)ptsS.size(); i++)\n for (int j = i+1; j < (int)ptsS.size(); j++)\n rankPairsS.push_back({ptsS[i], ptsS[j]});\n\n for (int d = 0; d + 2 < D; d++) {\n vector days = {d, d+1, d+2};\n pair best = {INF, Cand()};\n for (auto [y1,y2] : cutPairsS) for (auto [n1,n2] : rankPairsS) {\n if (!(1 <= n1 && n1 < n2 && n2 <= N-1)) continue;\n Cand c = gen_multiband(a, N, days, {y1,y2}, {n1,n2});\n ll sc = 0;\n for (int dd : days) sc += cand_day_cost(a[dd], c);\n if (sc < best.first) best = {sc, std::move(c)};\n }\n if (best.first < INF) add_cand(best.second);\n }\n }\n\n // 4-layer fixed-pattern candidates\n {\n vector cuts = {250, 500, 750};\n int q1 = max(1, N/4);\n int q2 = max(q1+1, N/2);\n int q3 = max(q2+1, (3*N)/4);\n q3 = min(q3, N-1);\n if (q1 < q2 && q2 < q3 && q3 < N) {\n add_cand(gen_multiband(a, N, days_all(), cuts, {q1, q2, q3}));\n vector cuts2v = {200, 500, 800};\n add_cand(gen_multiband(a, N, days_all(), cuts2v, {q1, q2, q3}));\n }\n }\n\n // Deduplicate candidates\n {\n vector, int>> keys;\n keys.reserve(cands.size());\n for (int i = 0; i < (int)cands.size(); i++) keys.push_back({cands[i].sig(), i});\n sort(keys.begin(), keys.end(), [](auto& x, auto& y){ return x.first < y.first; });\n vector uniq;\n uniq.reserve(cands.size());\n for (int i = 0; i < (int)keys.size(); i++) {\n if (i == 0 || keys[i].first != keys[i-1].first) uniq.push_back(std::move(cands[keys[i].second]));\n }\n cands.swap(uniq);\n }\n\n int K = (int)cands.size();\n\n // Day costs\n vector> dayCost(D, vector(K, 0));\n for (int d = 0; d < D; d++)\n for (int k = 0; k < K; k++)\n dayCost[d][k] = cand_day_cost(a[d], cands[k]);\n\n // Transition costs\n vector> tr(K, vector(K, 0));\n for (int i = 0; i < K; i++) {\n for (int j = i + 1; j < K; j++) {\n ll c = trans_cost(cands[i], cands[j]);\n tr[i][j] = tr[j][i] = c;\n }\n }\n\n // DP over days (day0: no transition cost by special rule)\n vector> dp(D, vector(K, INF));\n vector> prv(D, vector(K, -1));\n for (int k = 0; k < K; k++) dp[0][k] = dayCost[0][k];\n\n for (int d = 1; d < D; d++) {\n for (int k = 0; k < K; k++) {\n ll best = INF;\n int bestp = -1;\n for (int p = 0; p < K; p++) {\n ll cand = dp[d-1][p] + tr[p][k];\n if (cand < best) { best = cand; bestp = p; }\n }\n dp[d][k] = best + dayCost[d][k];\n prv[d][k] = bestp;\n }\n }\n\n // Reconstruct\n int last = 0;\n for (int k = 1; k < K; k++) if (dp[D-1][k] < dp[D-1][last]) last = k;\n vector choose(D);\n for (int d = D - 1; d >= 0; d--) {\n choose[d] = last;\n last = (d ? prv[d][last] : -1);\n }\n\n // Output\n for (int d = 0; d < D; d++) {\n auto rects = build_rects_sorted_by_area(cands[choose[d]]);\n for (int k = 0; k < N; k++) {\n const auto &r = rects[k];\n cout << r.i0 << ' ' << r.j0 << ' ' << r.i1 << ' ' << r.j1 << \"\\n\";\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nstatic constexpr int N = 9;\nstatic constexpr int M = 20;\nstatic constexpr int POS = 7;\nstatic constexpr int A = M * POS * POS; // 980\nstatic constexpr int MOD = 998244353;\nstatic constexpr int CELLS = N * N;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed=88172645463325252ull): x(seed) {}\n inline uint64_t nextU64() { x ^= x << 7; x ^= x >> 9; return x; }\n inline int nextInt(int n) { return (int)(nextU64() % (uint64_t)n); }\n inline double nextDouble01() { return (nextU64() >> 11) * (1.0 / 9007199254740992.0); }\n};\n\nstruct Entry {\n uint8_t cell;\n int v;\n};\n\nstatic inline int deltaAddCell(int r, int v) {\n int t = r + v;\n return (t >= MOD) ? (v - MOD) : v;\n}\nstatic inline int deltaRemoveCell(int r, int v) {\n int t = r - v;\n if (t < 0) t += MOD;\n return t - r;\n}\n\nstruct State {\n array board{};\n array delta{};\n long long score = 0;\n vector ops;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, K;\n cin >> Nin >> Min >> K;\n\n array initA{};\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n int v; cin >> v;\n initA[i * N + j] = v;\n }\n\n int s[M][3][3];\n for (int m = 0; m < M; m++)\n for (int i = 0; i < 3; i++)\n for (int j = 0; j < 3; j++)\n cin >> s[m][i][j];\n\n array, A> action{};\n for (int m = 0; m < M; m++) for (int p = 0; p < POS; p++) for (int q = 0; q < POS; q++) {\n int id = m * 49 + p * 7 + q;\n int k = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int x = p + di, y = q + dj;\n action[id][k++] = Entry{(uint8_t)(x * N + y), s[m][di][dj]};\n }\n }\n\n array>, CELLS> affects;\n for (int c = 0; c < CELLS; c++) affects[c].clear();\n for (int id = 0; id < A; id++)\n for (auto &e : action[id])\n affects[e.cell].push_back({id, e.v});\n\n auto decode = [&](int id) {\n int m = id / 49;\n int r = id % 49;\n int p = r / 7;\n int q = r % 7;\n return array{m,p,q};\n };\n\n XorShift64 rng((uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto initState = [&]() -> State {\n State st;\n st.ops.assign(K, -1);\n st.score = 0;\n for (int c = 0; c < CELLS; c++) { st.board[c] = initA[c]; st.score += st.board[c]; }\n for (int id = 0; id < A; id++) {\n long long d = 0;\n for (auto &e : action[id]) d += deltaAddCell(st.board[e.cell], e.v);\n st.delta[id] = d;\n }\n return st;\n };\n\n auto applyAction = [&](State &st, int id, int sign) {\n if (id < 0) return;\n for (auto &e : action[id]) {\n int c = e.cell, v = e.v;\n int oldr = st.board[c];\n int newr;\n if (sign == +1) { newr = oldr + v; if (newr >= MOD) newr -= MOD; }\n else { newr = oldr - v; if (newr < 0) newr += MOD; }\n if (newr == oldr) continue;\n\n st.board[c] = newr;\n st.score += (long long)(newr - oldr);\n\n for (auto &[aid, vv] : affects[c]) {\n st.delta[aid] += (long long)deltaAddCell(newr, vv) - (long long)deltaAddCell(oldr, vv);\n }\n }\n };\n\n auto bestInsertId = [&](const State &st) -> int {\n long long bestD = 0;\n int bestId = -1;\n for (int id = 0; id < A; id++) {\n long long d = st.delta[id];\n if (d > bestD) { bestD = d; bestId = id; }\n }\n return bestId;\n };\n\n auto randomTopInsert = [&](const State &st, int TOPT) -> int {\n vector> heap;\n heap.reserve(TOPT);\n auto cmp = [](const pair& a, const pair& b){\n return a.first > b.first;\n };\n for (int id = 0; id < A; id++) {\n long long d = st.delta[id];\n if (d <= 0) continue;\n if ((int)heap.size() < TOPT) {\n heap.push_back({d,id});\n push_heap(heap.begin(), heap.end(), cmp);\n } else if (d > heap.front().first) {\n pop_heap(heap.begin(), heap.end(), cmp);\n heap.back() = {d,id};\n push_heap(heap.begin(), heap.end(), cmp);\n }\n }\n if (heap.empty()) return -1;\n long double sum = 0;\n for (auto &p : heap) sum += (long double)p.first;\n long double r = (long double)rng.nextDouble01() * sum;\n for (auto &p : heap) { r -= (long double)p.first; if (r <= 0) return p.second; }\n return heap.back().second;\n };\n\n vector order(K), idxs(K), ruined;\n vector contrib(K);\n\n auto coordPass = [&](State &st) -> bool {\n iota(order.begin(), order.end(), 0);\n for (int i = K - 1; i > 0; i--) swap(order[i], order[rng.nextInt(i + 1)]);\n\n bool changed = false;\n for (int idx : order) {\n int oldId = st.ops[idx];\n if (oldId >= 0) applyAction(st, oldId, -1);\n\n int b = bestInsertId(st);\n st.ops[idx] = b;\n if (b >= 0) applyAction(st, b, +1);\n\n if (b != oldId) changed = true;\n }\n return changed;\n };\n\n auto localOptimize = [&](State &st, int passes) {\n for (int it = 0; it < passes; it++) {\n if (!coordPass(st)) break;\n }\n };\n\n auto buildGreedy = [&](State &st, double randRate, int topT) {\n for (int t = 0; t < K; t++) {\n int id = (rng.nextDouble01() < randRate) ? randomTopInsert(st, topT) : bestInsertId(st);\n if (id < 0) break;\n st.ops[t] = id;\n applyAction(st, id, +1);\n }\n };\n\n auto doLNS = [&](const State &base, int ruinSz, double rr, int topT, int optPass) -> State {\n State st = base;\n\n for (int i = 0; i < K; i++) {\n idxs[i] = i;\n int id = st.ops[i];\n if (id < 0) { contrib[i] = (long long)4e18; continue; }\n long long drem = 0;\n for (auto &e : action[id]) drem += (long long)deltaRemoveCell(st.board[e.cell], e.v);\n contrib[i] = -drem;\n }\n\n ruinSz = max(1, min(ruinSz, K));\n nth_element(idxs.begin(), idxs.begin() + min(ruinSz, K - 1), idxs.end(),\n [&](int x, int y){ return contrib[x] < contrib[y]; });\n\n ruined.clear();\n ruined.reserve(ruinSz + 8);\n int takeWorst = (ruinSz * 7) / 10;\n for (int i = 0; i < takeWorst; i++) ruined.push_back(idxs[i]);\n while ((int)ruined.size() < ruinSz) ruined.push_back(rng.nextInt(K));\n sort(ruined.begin(), ruined.end());\n ruined.erase(unique(ruined.begin(), ruined.end()), ruined.end());\n\n for (int idx : ruined) {\n int id = st.ops[idx];\n if (id >= 0) applyAction(st, id, -1);\n st.ops[idx] = -1;\n }\n\n for (int i = (int)ruined.size() - 1; i > 0; i--) swap(ruined[i], ruined[rng.nextInt(i + 1)]);\n for (int idx : ruined) {\n int id = (rng.nextDouble01() < rr) ? randomTopInsert(st, topT) : bestInsertId(st);\n st.ops[idx] = id;\n if (id >= 0) applyAction(st, id, +1);\n }\n\n localOptimize(st, optPass);\n return st;\n };\n\n const double TIME_LIMIT = 1.95;\n auto t0 = chrono::steady_clock::now();\n auto elapsedSec = [&]() -> double {\n return chrono::duration(chrono::steady_clock::now() - t0).count();\n };\n\n // Multi-start init: a bit more, but cheap\n State best;\n best.score = LLONG_MIN;\n {\n int starts = 18;\n for (int i = 0; i < starts; i++) {\n State st = initState();\n buildGreedy(st, 0.38, 20);\n localOptimize(st, 6);\n if (st.score > best.score) best = st;\n }\n }\n State cur = best;\n\n const double T0 = 2.8e9, T1 = 6.0e4;\n long long lastBest = best.score;\n int stagn = 0;\n int iter = 0;\n\n while (true) {\n double et = elapsedSec();\n if (et >= TIME_LIMIT) break;\n double prog = et / TIME_LIMIT;\n\n if (best.score == lastBest) stagn++;\n else { lastBest = best.score; stagn = 0; }\n\n bool reheat = (stagn > 140 && prog < 0.85);\n if (reheat) stagn = 0;\n\n double T = T0 * pow(T1 / T0, prog);\n if (reheat) T *= 2.0;\n\n const State &base = (rng.nextInt(100) < 20 ? best : cur);\n\n int ruinSmall = max(8, (int)round(12 - 4 * prog));\n int ruinLarge = reheat ? 28 : max(12, (int)round(22 - 12 * prog));\n\n double rrSmall = 0.16 + 0.22 * (1.0 - prog);\n double rrLarge = reheat ? 0.60 : (0.32 + 0.34 * (1.0 - prog));\n\n int topTSmall = 20;\n int topTLarge = reheat ? 32 : 26;\n\n // reduce optimize cost slightly (loop is heavier due to 2 candidates)\n int optSmall = (prog < 0.6 ? 4 : 3);\n int optLarge = reheat ? 6 : (prog < 0.5 ? 4 : 3);\n\n State cand1 = doLNS(base, ruinSmall, rrSmall, topTSmall, optSmall);\n State cand2 = doLNS(base, ruinLarge, rrLarge, topTLarge, optLarge);\n State trial = (cand2.score > cand1.score ? std::move(cand2) : std::move(cand1));\n\n long long d = trial.score - cur.score;\n bool accept = false;\n if (d >= 0) accept = true;\n else if (rng.nextDouble01() < exp((double)d / T)) accept = true;\n\n if (accept) cur = std::move(trial);\n if (cur.score > best.score) best = cur;\n\n if (rng.nextInt(100) < 4) cur = best;\n\n // periodic deep intensification of best if time allows\n iter++;\n if ((iter % 25 == 0) && elapsedSec() < TIME_LIMIT * 0.92) {\n State tmp = best;\n localOptimize(tmp, 10);\n if (tmp.score > best.score) best = std::move(tmp);\n }\n }\n\n // final intensify\n localOptimize(best, 12);\n\n vector> out;\n out.reserve(K);\n for (int i = 0; i < K; i++) if (best.ops[i] >= 0) out.push_back(decode(best.ops[i]));\n\n cout << out.size() << \"\\n\";\n for (auto &x : out) cout << x[0] << \" \" << x[1] << \" \" << x[2] << \"\\n\";\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstatic constexpr int N = 5;\nstatic constexpr int MAXT = 10000;\n\nstruct Pos { int x, y; };\nstatic inline int manhattan(const Pos& a, const Pos& b){ return abs(a.x-b.x)+abs(a.y-b.y); }\nstatic inline bool is_move(char a){ return a=='U'||a=='D'||a=='L'||a=='R'; }\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin; cin >> Nin;\n vector> A(N, vector(N));\n for(int i=0;i> A[i][j];\n\n // Grid: -1 empty else container id\n int grid[N][N];\n for(int i=0;i loc(N*N, Pos{-2,-2});\n vector heldBy(N*N, -1);\n\n int next_in[N] = {0,0,0,0,0};\n\n // Cranes: 0 large, 1..4 small\n vector cpos(N);\n vector hold(N, -1);\n vector alive(N, true);\n cpos[0] = {0,0};\n for(int i=1;ipair{\n if(c=='U') return {-1,0};\n if(c=='D') return {1,0};\n if(c=='L') return {0,-1};\n if(c=='R') return {0,1};\n return {0,0};\n };\n\n auto all_dispatched = [&](){\n for(int id=0; idbool{\n if(!alive[k]) return false;\n if(hold[k]!=-1) return false;\n int x=cpos[k].x, y=cpos[k].y;\n if(grid[x][y]==-1) return false;\n int id=grid[x][y];\n grid[x][y] = -1;\n hold[k] = id;\n heldBy[id] = k;\n loc[id] = Pos{-3,-3};\n return true;\n };\n\n auto drop_container = [&](int k)->bool{\n if(!alive[k]) return false;\n if(hold[k]==-1) return false;\n int x=cpos[k].x, y=cpos[k].y;\n if(grid[x][y]!=-1) return false;\n int id=hold[k];\n hold[k] = -1;\n grid[x][y] = id;\n heldBy[id] = -1;\n loc[id] = Pos{x,y};\n return true;\n };\n\n auto bfs_path_large = [&](Pos s, Pos t, const vector>& blocked)->vector{\n // BFS on 5x5; containers do NOT block large crane, but cranes do (blocked).\n if(blocked[t.x][t.y]) return {};\n queue q;\n int dist[N][N];\n Pos prevp[N][N];\n char prevd[N][N];\n for(int i=0;i rev;\n Pos cur=t;\n while(!(cur.x==s.x && cur.y==s.y)){\n rev.push_back(prevd[cur.x][cur.y]);\n cur=prevp[cur.x][cur.y];\n }\n reverse(rev.begin(), rev.end());\n return rev;\n };\n\n auto count_empty_storage = [&](){\n // Storage pool: columns 2..3 + (0,1) fallback\n int c=0;\n for(int x=0;x>& blocked)->optional{\n Pos best{-1,-1};\n int bestScore = INT_MAX;\n for(int x=0;x out(N);\n deque plan; // for large crane in normal mode\n\n int last_dispatch_turn = -1;\n int total_dispatched = 0;\n\n bool relaxed = false; // allow out-of-order dispatch (still correct gate)\n bool emergency = false; // bomb small cranes + drain everything\n\n auto remaining_containers = [&](){\n return N*N - total_dispatched;\n };\n\n for(int turn=0; turn=N) continue;\n bool crane_holding_here = false;\n for(int k=0;k= 8500 && rem > 0) { emergency = true; relaxed = true; plan.clear(); }\n if(no_disp > 250 && turn > 300) { emergency = true; relaxed = true; plan.clear(); }\n }\n // Relaxed mode (but not full emergency): avoid M3 by draining if stuck moderately.\n if(!relaxed && !emergency){\n int no_disp = (last_dispatch_turn==-1 ? turn : (turn - last_dispatch_turn));\n if(no_disp > 120 && turn > 200) { relaxed = true; plan.clear(); }\n }\n\n // Congestion control (safe): if storage almost full, stop shuttling to exchange.\n bool congested = (!emergency && !relaxed && count_empty_storage() <= 1);\n\n // === Decide desired actions ===\n vector act(N,'.');\n\n // Small cranes\n if(emergency){\n // In emergency: drop if holding, else bomb.\n for(int i=1;i(r,1) unless congested\n auto small_desired = [&](int idx)->char{\n int r=idx;\n int x=cpos[idx].x, y=cpos[idx].y;\n if(x!=r) return '.';\n if(congested){\n // Just stay out of the large crane's way; do not pick new items.\n if(y==0) return 'R'; // try to move to (r,1)\n return '.';\n }\n if(hold[idx]==-1){\n if(y==0){\n if(grid[r][0]!=-1 && grid[r][1]==-1) return 'P';\n return '.';\n }else{\n return 'L';\n }\n }else{\n if(y==0){\n if(grid[r][1]==-1) return 'R';\n return '.';\n }else{\n if(grid[r][1]==-1) return 'Q';\n return '.';\n }\n }\n };\n for(int i=1;i tmpNext = cpos;\n for(int i=1;i> blocked(N, vector(N,false));\n for(int i=1;i=N) continue;\n // We want to stand there empty-handed; receiving happens when cell empty.\n int d=manhattan(cpos[0], Pos{r,0});\n if(d relax now to avoid M3\n relaxed=true;\n plan.clear();\n if(gate_ok){\n auto path=bfs_path_large(cpos[0], gate, blocked);\n for(char c: path) plan.push_back(c);\n plan.push_back('Q');\n }else plan.push_back('.');\n }\n }\n }else{\n auto plan_pick = [&](Pos p){\n auto path=bfs_path_large(cpos[0], p, blocked);\n for(char c: path) plan.push_back(c);\n plan.push_back('P');\n };\n\n // Priority 1: pick any next_needed on ground\n int bestId=-1, bestDist=INT_MAX;\n for(int r=0;rr*N+4) continue;\n if(heldBy[need]!=-1) continue;\n if(loc[need].x<0) continue;\n Pos p=loc[need];\n if(p.y==N-1) continue;\n if(blocked[p.x][p.y]) continue;\n int d=manhattan(cpos[0], p);\n if(d nextPos = cpos;\n for(int i=0;i, N*N> cellTo;\n for(auto &v: cellTo) v.clear();\n\n for(int i=0;ibool{\n bool ma=is_move(act[a]), mb=is_move(act[b]);\n if(ma!=mb) return mb; // staying beats moving\n return a\nusing namespace std;\n\nstatic inline uint64_t splitmix64(uint64_t &x) {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n}\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed=1) : x(seed) {}\n uint64_t nextU64() { return splitmix64(x); }\n int nextInt(int lo, int hi) { return lo + (int)(nextU64() % (uint64_t)(hi - lo + 1)); }\n double nextDouble() { return (nextU64() >> 11) * (1.0 / 9007199254740992.0); }\n};\n\nstatic inline int vid(int r,int c,int N){ return r*N+c; }\n\nstatic inline bool hasEdge(const array& nb, int v) {\n return nb[0] == v || nb[1] == v;\n}\nstatic inline void replaceNeighbor(array& nb, int oldv, int newv) {\n if (nb[0] == oldv) nb[0] = newv;\n else if (nb[1] == oldv) nb[1] = newv;\n}\n\nstatic inline char dirChar(int u, int v, int N) {\n int ur=u/N, uc=u%N;\n int vr=v/N, vc=v%N;\n if (vr==ur-1 && vc==uc) return 'U';\n if (vr==ur+1 && vc==uc) return 'D';\n if (vr==ur && vc==uc-1) return 'L';\n if (vr==ur && vc==uc+1) return 'R';\n return '?';\n}\n\n// Traverse the cycle starting at 0 using nei[0][0] as the first step.\n// If it's a single Hamiltonian cycle, returns true and fills proc0 (length V-1).\nstatic bool traverseChoice0(const vector>& nei, int N, vector& proc0) {\n int V = N*N;\n int start = 0;\n int first = nei[start][0];\n if (first < 0) return false;\n\n proc0.clear();\n proc0.reserve(V-1);\n vector vis(V, 0);\n vis[start]=1;\n\n int prev = start;\n int cur = first;\n for (int step=0; step= V) return false;\n if (vis[cur]) return false;\n vis[cur]=1;\n proc0.push_back(cur);\n\n int n0 = nei[cur][0], n1 = nei[cur][1];\n int nxt = (n0 == prev) ? n1 : n0;\n prev = cur;\n cur = nxt;\n }\n if (cur != start) return false;\n for (int i=0;i>& nei, int N, int r, int c) {\n int a=vid(r,c,N);\n int b=vid(r,c+1,N);\n int c1=vid(r+1,c,N);\n int d=vid(r+1,c+1,N);\n\n bool ab = hasEdge(nei[a], b);\n bool cd = hasEdge(nei[c1], d);\n bool ac = hasEdge(nei[a], c1);\n bool bd = hasEdge(nei[b], d);\n\n FlipRecord rec;\n if (ab && cd && !ac && !bd) {\n // horiz -> vert\n replaceNeighbor(nei[a], b, c1);\n replaceNeighbor(nei[b], a, d);\n replaceNeighbor(nei[c1], d, a);\n replaceNeighbor(nei[d], c1, b);\n rec = {a,b,c1,d,0,true};\n } else if (ac && bd && !ab && !cd) {\n // vert -> horiz\n replaceNeighbor(nei[a], c1, b);\n replaceNeighbor(nei[b], d, a);\n replaceNeighbor(nei[c1], a, d);\n replaceNeighbor(nei[d], b, c1);\n rec = {a,b,c1,d,1,true};\n } else {\n rec.applied=false;\n }\n return rec;\n}\nstatic void undoFlip(vector>& nei, const FlipRecord& rec) {\n if (!rec.applied) return;\n int a=rec.a,b=rec.b,c1=rec.c,d=rec.d;\n if (rec.mode==0) {\n // undo vert->horiz\n replaceNeighbor(nei[a], c1, b);\n replaceNeighbor(nei[b], d, a);\n replaceNeighbor(nei[c1], a, d);\n replaceNeighbor(nei[d], b, c1);\n } else {\n // undo horiz->vert\n replaceNeighbor(nei[a], b, c1);\n replaceNeighbor(nei[b], a, d);\n replaceNeighbor(nei[c1], d, a);\n replaceNeighbor(nei[d], c1, b);\n }\n}\n\n// Build neighbors from a Hamiltonian cycle given as proc order excluding start, with edges 0->proc[0]->...->proc.back()->0\nstatic vector> neighborsFromProcCycle(int N, const vector& proc) {\n int V=N*N;\n vector> nei(V);\n for (int i=0;i nei[i][1]) swap(nei[i][0], nei[i][1]);\n return nei;\n}\n\n// Base cycles\nstatic vector baseCycleA(int N) {\n vector seq; seq.reserve(N*N-1);\n for (int r=1;r=0;r--) {\n int t = (N-1-r);\n if (t%2==0) for (int c=1;c=1;c--) seq.push_back(vid(r,c,N));\n }\n return seq;\n}\nstatic vector baseCycleB(int N) {\n vector seq; seq.reserve(N*N-1);\n for (int c=1;c=0;c--) {\n int t = (N-1-c);\n if (t%2==0) for (int r=1;r=1;r--) seq.push_back(vid(r,c,N));\n }\n return seq;\n}\n\n// 8 symmetries\nstatic inline pair symMap(int s, int r, int c, int N) {\n switch(s) {\n case 0: return {r,c};\n case 1: return {c, N-1-r};\n case 2: return {N-1-r, N-1-c};\n case 3: return {N-1-c, r};\n case 4: return {r, N-1-c};\n case 5: return {N-1-r, c};\n case 6: return {c, r};\n case 7: return {N-1-c, N-1-r};\n }\n return {r,c};\n}\nstatic vector> applySymmetryToCycle(const vector>& nei, int N, int s) {\n int V=N*N;\n vector mp(V);\n for (int r=0;r> out(V);\n for (int v=0; v out[nv][1]) swap(out[nv][0], out[nv][1]);\n }\n return out;\n}\n\nstruct Plan {\n long long cost = (1LL<<62);\n int dir = 0; // 0: proc0 forward, 1: reverse\n int type = 0; // 0: close cycle and dump at start; 1: defer rem (if possible)\n long long B = 0;\n};\n\nstatic Plan evalDirSim(const vector& H, int N, const vector& proc0, bool rev) {\n int V=N*N;\n int m=V-1;\n int h00 = H[0];\n auto at = [&](int i)->int {\n return (!rev ? proc0[i] : proc0[m-1-i]);\n };\n\n // Precompute prefix minima for feasibility.\n // For non-last only (i=0..m-2), we need load never negative during processing those cells.\n long long pref=0;\n long long minPrefAll=0;\n long long minPrefNonLast=0;\n for (int i=0;i=0\n long long cost=0, load=0;\n cost += B; load += B;\n for (int i=0;i0 and B can be <=h00, i.e., prefix requirement is small (<=100).\n if (h00 > 0) {\n long long Bmin = max(0LL, -minPrefNonLast);\n if (Bmin <= h00) {\n // brute B in [Bmin..h00] (range <= 101)\n for (long long B = Bmin; B <= h00; B++) {\n long long cost=0, load=0;\n cost += B; load += B;\n\n // process first m-1 cells to zero\n bool ok=true;\n for (int i=0;i target -> load (ht-target)\n // else unload (target-ht), must have enough load\n if ((long long)ht >= target) {\n long long d = (long long)ht - target;\n cost += d;\n load += d;\n } else {\n long long d = target - (long long)ht;\n if (load < d) continue;\n cost += d;\n load -= d;\n }\n // now load should be 0 (by construction); but keep robust:\n if (load != 0) continue;\n\n long long rem = (long long)h00 - B; // >0\n if (rem > 0) {\n // extra: last->start (empty), +rem at start, start->last (carrying rem), unload rem\n cost += 100; // move last->start with 0 load\n cost += rem; // +rem\n cost += 100 + rem; // move back carrying rem\n cost += rem; // -rem\n }\n if (cost < best.cost) best = {cost, rev?1:0, 1, B};\n }\n }\n }\n\n return best;\n}\n\nstatic Plan evalCycle(const vector& H, int N, const vector& proc0) {\n Plan a = evalDirSim(H, N, proc0, false);\n Plan b = evalDirSim(H, N, proc0, true);\n return (a.cost <= b.cost ? a : b);\n}\n\nstruct State {\n vector> nei;\n vector proc0;\n Plan plan;\n};\n\nstatic vector buildOutput(const vector& H, const vector>& nei, int N,\n const vector& proc0, const Plan& plan) {\n int V=N*N, m=V-1;\n int h00 = H[0];\n\n auto at = [&](int i)->int {\n return (plan.dir==0 ? proc0[i] : proc0[m-1-i]);\n };\n int lastV = at(m-1);\n\n vector ops;\n ops.reserve(1500);\n\n auto emitMove=[&](char ch){ ops.push_back(string(1,ch)); };\n auto emitLoad=[&](long long d){ if(d>0) ops.push_back(\"+\"+to_string(d)); };\n auto emitUnload=[&](long long d){ if(d>0) ops.push_back(\"-\"+to_string(d)); };\n\n long long load = 0;\n int cur = 0;\n\n if (plan.B > 0) { emitLoad(plan.B); load += plan.B; }\n\n auto fixToZero = [&](int v) {\n int hv = H[v];\n if (hv > 0) { emitLoad(hv); load += hv; }\n else if (hv < 0) { emitUnload(- (long long)hv); load += hv; }\n };\n auto setToTarget = [&](int v, long long target) {\n long long hv = H[v];\n if (hv >= target) {\n long long d = hv - target;\n if (d>0) { emitLoad(d); load += d; }\n } else {\n long long d = target - hv;\n if (d>0) { emitUnload(d); load -= d; }\n }\n };\n\n for (int i=0;i 0) { emitUnload(load); load = 0; }\n } else {\n long long rem = (long long)h00 - plan.B;\n if (rem > 0) {\n emitMove(dirChar(cur, 0, N)); cur = 0;\n emitLoad(rem); load += rem;\n emitMove(dirChar(cur, lastV, N)); cur = lastV;\n emitUnload(rem); load -= rem;\n }\n }\n return ops;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N; cin >> N;\n int V=N*N;\n vector H(V);\n for (int r=0;r> x;\n H[vid(r,c,N)] = x;\n }\n\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n RNG rng(seed);\n\n // Build initial pool (2 bases * 8 sym)\n vector> bases = {baseCycleA(N), baseCycleB(N)};\n vector pool;\n pool.reserve(32);\n\n for (auto &proc : bases) {\n auto baseNei = neighborsFromProcCycle(N, proc);\n for (int s=0;s<8;s++) {\n State st;\n st.nei = applySymmetryToCycle(baseNei, N, s);\n if (!traverseChoice0(st.nei, N, st.proc0)) continue;\n st.plan = evalCycle(H, N, st.proc0);\n pool.push_back(std::move(st));\n }\n }\n if (pool.empty()) {\n State st;\n st.nei = neighborsFromProcCycle(N, baseCycleA(N));\n traverseChoice0(st.nei, N, st.proc0);\n st.plan = evalCycle(H, N, st.proc0);\n pool.push_back(std::move(st));\n }\n\n auto cmp = [&](const State& a, const State& b){ return a.plan.cost < b.plan.cost; };\n sort(pool.begin(), pool.end(), cmp);\n\n State best = pool[0];\n\n auto t0 = chrono::high_resolution_clock::now();\n const double TL = 1.95;\n\n // Diversify: generate additional seeds from top few by flip-chains\n int baseSeeds = min(4, (int)pool.size());\n vector seeds = pool;\n for (int si=0; si(now - t0).count();\n if (elapsed > 0.55) break;\n\n State st = pool[si];\n // apply a macro chain without evaluation, keeping only valid single-cycle states\n int chains = 60;\n for (int t=0;t recs;\n recs.reserve(L);\n for (int k=0;k tmp;\n if (!recs.empty() && !traverseChoice0(st.nei, N, tmp)) {\n for (int i=(int)recs.size()-1;i>=0;i--) undoFlip(st.nei, recs[i]);\n } else if (!recs.empty()) {\n st.proc0 = std::move(tmp);\n }\n }\n st.plan = evalCycle(H, N, st.proc0);\n seeds.push_back(std::move(st));\n }\n }\n sort(seeds.begin(), seeds.end(), cmp);\n if (seeds[0].plan.cost < best.plan.cost) best = seeds[0];\n\n // SA multi-start from top K seeds\n int K = min(6, (int)seeds.size());\n for (int k=0;k(nowG - t0).count();\n double rem = TL - elapsedG;\n if (rem <= 0.05) break;\n\n double slice = max(0.12, rem / (K - k));\n auto start = chrono::high_resolution_clock::now();\n\n State cur = seeds[k];\n long long curCost = cur.plan.cost;\n\n const double T0 = 25000.0, T1 = 80.0;\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double e = chrono::duration(now - start).count();\n if (e > slice) break;\n\n double prog = e / slice;\n double temp = T0 * pow(T1 / T0, prog);\n\n bool macro = (rng.nextDouble() < 0.30);\n vector recs;\n\n if (!macro) {\n int r = rng.nextInt(0, N-2);\n int c = rng.nextInt(0, N-2);\n auto rec = tryFlip(cur.nei, N, r, c);\n if (!rec.applied) continue;\n recs.push_back(rec);\n } else {\n int L = rng.nextInt(2, 12);\n recs.reserve(L);\n for (int i=0;i newProc0;\n if (!traverseChoice0(cur.nei, N, newProc0)) {\n for (int i=(int)recs.size()-1;i>=0;i--) undoFlip(cur.nei, recs[i]);\n continue;\n }\n Plan newPlan = evalCycle(H, N, newProc0);\n long long newCost = newPlan.cost;\n\n bool accept = false;\n if (newCost <= curCost) accept = true;\n else {\n double p = exp((double)(curCost - newCost) / temp);\n if (rng.nextDouble() < p) accept = true;\n }\n\n if (accept) {\n cur.proc0 = std::move(newProc0);\n cur.plan = newPlan;\n curCost = newCost;\n if (newCost < best.plan.cost) best = cur;\n } else {\n for (int i=(int)recs.size()-1;i>=0;i--) undoFlip(cur.nei, recs[i]);\n }\n }\n }\n\n auto ops = buildOutput(H, best.nei, N, best.proc0, best.plan);\n for (auto &s: ops) cout << s << \"\\n\";\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nstatic constexpr int N = 6;\nstatic constexpr int M = 15;\n\nstruct XorShift64 {\n uint64_t x = 88172645463325252ull;\n explicit XorShift64(uint64_t seed = 0) {\n if (seed) x ^= seed + 0x9e3779b97f4a7c15ULL;\n }\n uint64_t nextU64() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int lo, int hi) { // [lo, hi)\n return lo + (int)(nextU64() % (uint64_t)(hi - lo));\n }\n double nextDouble() { // [0,1)\n return (nextU64() >> 11) * (1.0 / 9007199254740992.0);\n }\n};\n\nstruct Seed {\n array x{};\n int v = 0;\n int mx = 0;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int Nin, Min, T;\n cin >> Nin >> Min >> T;\n const int S = 2 * Nin * (Nin - 1); // 60\n\n vector seeds(S);\n\n auto readSeeds = [&]() {\n for (int i = 0; i < S; i++) {\n int sum = 0, mx = 0;\n for (int l = 0; l < M; l++) {\n int a; cin >> a;\n seeds[i].x[l] = a;\n sum += a;\n mx = max(mx, a);\n }\n seeds[i].v = sum;\n seeds[i].mx = mx;\n }\n };\n readSeeds();\n\n auto pid = [&](int r, int c){ return r * N + c; };\n\n // edges among 36 positions\n vector> edges;\n edges.reserve(60);\n for (int r = 0; r < N; r++) for (int c = 0; c < N - 1; c++)\n edges.push_back({pid(r,c), pid(r,c+1)});\n for (int r = 0; r < N - 1; r++) for (int c = 0; c < N; c++)\n edges.push_back({pid(r,c), pid(r+1,c)});\n\n array, 36> nbr;\n for (auto [a,b] : edges) {\n nbr[a].push_back(b);\n nbr[b].push_back(a);\n }\n\n vector blackPos, whitePos;\n blackPos.reserve(18); whitePos.reserve(18);\n for (int r = 0; r < N; r++) for (int c = 0; c < N; c++) {\n if (((r + c) & 1) == 0) blackPos.push_back(pid(r,c));\n else whitePos.push_back(pid(r,c));\n }\n\n XorShift64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());\n\n vector> w(S, vector(S, 0.0));\n\n auto buildPairUtility = [&](int turn) {\n double zTail = 3.2 - 0.1 * turn; // 3.2 -> 2.3\n double tau = 80.0;\n\n for (int i = 0; i < S; i++) {\n for (int j = i + 1; j < S; j++) {\n double mean = 0.5 * (seeds[i].v + seeds[j].v);\n double diff2 = 0.0;\n int best = 0;\n for (int l = 0; l < M; l++) {\n int a = seeds[i].x[l], b = seeds[j].x[l];\n double d = double(a - b);\n diff2 += d * d;\n best += max(a, b);\n }\n double st = 0.5 * sqrt(diff2);\n double pot = min(best, mean + zTail * st);\n double val = exp(pot / tau);\n w[i][j] = w[j][i] = val;\n }\n w[i][i] = exp(seeds[i].v / tau);\n }\n };\n\n auto select36 = [&]() -> vector {\n const double beta = 5.0;\n const int mustKeep = 12;\n\n vector ids(S);\n iota(ids.begin(), ids.end(), 0);\n\n vector score(S);\n for (int i = 0; i < S; i++) score[i] = seeds[i].v + beta * seeds[i].mx;\n\n sort(ids.begin(), ids.end(), [&](int a, int b){\n if (score[a] != score[b]) return score[a] > score[b];\n return seeds[a].v > seeds[b].v;\n });\n\n vector picked(ids.begin(), ids.begin() + 36);\n vector in(S, 0);\n for (int x : picked) in[x] = 1;\n\n // per-criterion maxima\n for (int l = 0; l < M; l++) {\n int bestId = 0;\n for (int i = 1; i < S; i++) if (seeds[i].x[l] > seeds[bestId].x[l]) bestId = i;\n if (in[bestId]) continue;\n\n int worstIdx = 0;\n for (int i = 1; i < 36; i++) if (score[picked[i]] < score[picked[worstIdx]]) worstIdx = i;\n in[picked[worstIdx]] = 0;\n picked[worstIdx] = bestId;\n in[bestId] = 1;\n }\n\n // top-by-sum elites\n vector byV(S);\n iota(byV.begin(), byV.end(), 0);\n sort(byV.begin(), byV.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n\n for (int i = 0; i < mustKeep; i++) {\n int id = byV[i];\n if (in[id]) continue;\n\n int worstIdx = -1;\n double worstSc = 1e100;\n for (int j = 0; j < 36; j++) {\n bool isElite = false;\n for (int k = 0; k < mustKeep; k++) if (picked[j] == byV[k]) { isElite = true; break; }\n if (isElite) continue;\n if (score[picked[j]] < worstSc) { worstSc = score[picked[j]]; worstIdx = j; }\n }\n if (worstIdx == -1) {\n worstIdx = 0;\n for (int j = 1; j < 36; j++) if (score[picked[j]] < score[picked[worstIdx]]) worstIdx = j;\n }\n in[picked[worstIdx]] = 0;\n picked[worstIdx] = id;\n in[id] = 1;\n }\n\n return picked;\n };\n\n auto calcObjective = [&](const vector& grid) -> double {\n double obj = 0.0;\n for (auto [a,b] : edges) obj += w[grid[a]][grid[b]];\n return obj;\n };\n\n auto swapDelta = [&](const vector& grid, int p, int q) -> double {\n int A = grid[p], B = grid[q];\n double delta = 0.0;\n for (int n : nbr[p]) {\n if (n == q) continue;\n int C = grid[n];\n delta += w[B][C] - w[A][C];\n }\n for (int n : nbr[q]) {\n if (n == p) continue;\n int C = grid[n];\n delta += w[A][C] - w[B][C];\n }\n return delta;\n };\n\n auto makeHubInit = [&](const vector& picked) -> vector {\n int hub = picked[0];\n for (int s : picked) if (seeds[s].v > seeds[hub].v) hub = s;\n\n vector partners = picked;\n partners.erase(remove(partners.begin(), partners.end(), hub), partners.end());\n sort(partners.begin(), partners.end(), [&](int a, int b){\n return w[hub][a] > w[hub][b];\n });\n\n int hubPos = pid(2,2);\n vector around = {pid(1,2), pid(2,1), pid(2,3), pid(3,2)};\n\n vector grid(36, -1);\n grid[hubPos] = hub;\n for (int i = 0; i < 4 && i < (int)partners.size(); i++) grid[around[i]] = partners[i];\n\n vector used(S, 0);\n used[hub] = 1;\n for (int i = 0; i < 4 && i < (int)partners.size(); i++) used[partners[i]] = 1;\n\n int ptr = 0;\n for (int pos = 0; pos < 36; pos++) {\n if (grid[pos] != -1) continue;\n while (ptr < (int)picked.size() && used[picked[ptr]]) ptr++;\n grid[pos] = picked[ptr];\n used[picked[ptr]] = 1;\n ptr++;\n }\n return grid;\n };\n\n auto makeCheckerInit = [&](const vector& picked) -> vector {\n vector perm = picked;\n sort(perm.begin(), perm.end(), [&](int a, int b){ return seeds[a].v > seeds[b].v; });\n vector grid(36, -1);\n for (int i = 0; i < 18; i++) grid[blackPos[i]] = perm[i];\n for (int i = 0; i < 18; i++) grid[whitePos[i]] = perm[18 + i];\n return grid;\n };\n\n auto makeRandomInit = [&](const vector& picked) -> vector {\n vector perm = picked;\n for (int i = 35; i >= 1; i--) {\n int j = rng.nextInt(0, i + 1);\n swap(perm[i], perm[j]);\n }\n vector grid(36);\n for (int i = 0; i < 36; i++) grid[i] = perm[i];\n return grid;\n };\n\n // randomized greedy constructive init\n auto makeGreedyConstructInit = [&](const vector& picked, int randomness) -> vector {\n vector grid(36, -1);\n vector usedSeed(S, 0), filledPos(36, 0);\n\n int startSeed = picked[0];\n for (int s : picked) if (seeds[s].v > seeds[startSeed].v) startSeed = s;\n\n int startPos = pid(2,2);\n grid[startPos] = startSeed;\n usedSeed[startSeed] = 1;\n filledPos[startPos] = 1;\n\n vector remaining;\n remaining.reserve(35);\n for (int s : picked) if (s != startSeed) remaining.push_back(s);\n\n vector frontier;\n vector inFrontier(36, 0);\n auto addFrontier = [&](int p){\n if (!filledPos[p] && !inFrontier[p]) {\n inFrontier[p] = 1;\n frontier.push_back(p);\n }\n };\n for (int nb : nbr[startPos]) addFrontier(nb);\n\n auto anyEmptyPos = [&]() {\n for (int p = 0; p < 36; p++) if (!filledPos[p]) return p;\n return -1;\n };\n\n for (int step = 0; step < 35; step++) {\n if (frontier.empty()) {\n int p = anyEmptyPos();\n frontier.push_back(p);\n inFrontier[p] = 1;\n }\n\n // keep top-K candidates\n const int K = 4;\n array bestGain;\n array bestPos, bestIdx;\n for (int k = 0; k < K; k++) { bestGain[k] = -1e100; bestPos[k] = -1; bestIdx[k] = -1; }\n\n for (int pos : frontier) {\n array neigh; int deg=0;\n for (int nb : nbr[pos]) if (filledPos[nb]) neigh[deg++] = nb;\n if (deg == 0) continue;\n\n for (int i = 0; i < (int)remaining.size(); i++) {\n int s = remaining[i];\n double g = 0.0;\n for (int k = 0; k < deg; k++) g += w[s][ grid[neigh[k]] ];\n g += 1e-4 * seeds[s].v;\n\n // insert into top-K\n for (int k = 0; k < K; k++) {\n if (g > bestGain[k]) {\n for (int t = K - 1; t > k; t--) {\n bestGain[t] = bestGain[t-1];\n bestPos[t] = bestPos[t-1];\n bestIdx[t] = bestIdx[t-1];\n }\n bestGain[k] = g;\n bestPos[k] = pos;\n bestIdx[k] = i;\n break;\n }\n }\n }\n }\n\n int choose = 0;\n if (randomness > 0) {\n // choose among top candidates with fixed weights\n // more randomness -> more chance to pick lower-ranked\n double r = rng.nextDouble();\n double w0 = 0.55, w1 = 0.25, w2 = 0.13, w3 = 0.07;\n double soften = min(0.35, 0.08 * randomness);\n w0 -= 3 * soften; w1 += soften; w2 += soften; w3 += soften;\n if (r < w0) choose = 0;\n else if (r < w0 + w1) choose = 1;\n else if (r < w0 + w1 + w2) choose = 2;\n else choose = 3;\n }\n\n int pos = bestPos[choose];\n int idx = bestIdx[choose];\n\n if (pos == -1) { // deg==0 everywhere fallback\n pos = anyEmptyPos();\n idx = 0;\n }\n\n int s = remaining[idx];\n grid[pos] = s;\n usedSeed[s] = 1;\n filledPos[pos] = 1;\n\n // remove chosen seed from remaining\n remaining[idx] = remaining.back();\n remaining.pop_back();\n\n // remove pos from frontier\n inFrontier[pos] = 0;\n frontier.erase(remove(frontier.begin(), frontier.end(), pos), frontier.end());\n\n // add new frontier neighbors\n for (int nb : nbr[pos]) addFrontier(nb);\n }\n\n return grid;\n };\n\n auto initLayouts = [&](const vector& picked) -> vector> {\n // 5 initial layouts\n vector> inits;\n inits.push_back(makeHubInit(picked));\n inits.push_back(makeCheckerInit(picked));\n inits.push_back(makeGreedyConstructInit(picked, /*randomness=*/1));\n inits.push_back(makeGreedyConstructInit(picked, /*randomness=*/3));\n inits.push_back(makeRandomInit(picked));\n return inits;\n };\n\n auto runSA = [&](vector startGrid, double timeLimitSec, double T0, double T1) -> pair, double> {\n auto start = chrono::steady_clock::now();\n auto deadline = start + chrono::duration(timeLimitSec);\n\n vector cur = startGrid;\n double curObj = calcObjective(cur);\n\n vector best = cur;\n double bestObj = curObj;\n\n while (chrono::steady_clock::now() < deadline) {\n double tprog = chrono::duration(chrono::steady_clock::now() - start).count() / max(1e-9, timeLimitSec);\n if (tprog > 1.0) tprog = 1.0;\n double temp = T0 * pow(T1 / T0, tprog);\n\n int p = rng.nextInt(0, 36);\n int q = rng.nextInt(0, 36);\n if (p == q) continue;\n\n double delta = swapDelta(cur, p, q);\n if (delta >= 0.0 || rng.nextDouble() < exp(delta / temp)) {\n swap(cur[p], cur[q]);\n curObj += delta;\n if (curObj > bestObj) {\n bestObj = curObj;\n best = cur;\n }\n }\n }\n return {best, bestObj};\n };\n\n auto solvePlacementSA = [&](const vector& picked, double timeLimitSec) -> vector {\n auto inits = initLayouts(picked);\n int K = (int)inits.size();\n\n // scout less, refine more\n double phase1Frac = 0.35;\n double phase1 = timeLimitSec * phase1Frac;\n double phase2 = timeLimitSec - phase1;\n\n const double T0a = 3000.0, T1a = 8.0; // phase 1\n const double T0b = 3500.0, T1b = 8.0; // phase 2 (slightly hotter)\n\n vector>> cand; // (obj, grid)\n cand.reserve(K);\n\n double perInit = phase1 / K;\n for (int i = 0; i < K; i++) {\n auto [g, obj] = runSA(inits[i], perInit, T0a, T1a);\n cand.push_back({obj, std::move(g)});\n }\n\n // take top2\n nth_element(cand.begin(), cand.begin() + 1, cand.end(),\n [&](auto& a, auto& b){ return a.first > b.first; });\n auto best1 = cand[0];\n auto best2 = cand[1];\n if (best2.first > best1.first) swap(best1, best2);\n\n vector bestGrid = best1.second;\n double bestObj = best1.first;\n\n // refine best\n {\n auto [g, obj] = runSA(bestGrid, phase2 * 0.80, T0b, T1b);\n if (obj > bestObj) { bestObj = obj; bestGrid = std::move(g); }\n }\n // refine second-best a bit (robustness)\n {\n auto [g, obj] = runSA(best2.second, phase2 * 0.20, T0b, T1b);\n if (obj > bestObj) { bestObj = obj; bestGrid = std::move(g); }\n }\n\n return bestGrid;\n };\n\n auto allStart = chrono::steady_clock::now();\n auto allDeadline = allStart + chrono::milliseconds(1900);\n\n for (int t = 0; t < T; t++) {\n buildPairUtility(t);\n vector picked = select36();\n\n auto now = chrono::steady_clock::now();\n double remain = chrono::duration(allDeadline - now).count();\n if (remain < 0.02) remain = 0.02;\n double perTurn = remain / (T - t);\n\n vector grid = solvePlacementSA(picked, perTurn * 0.95);\n\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n if (c) cout << ' ';\n cout << grid[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n\n readSeeds();\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Pos { int x, y; };\nstatic inline int mod4(int x){ x%=4; if(x<0) x+=4; return x; }\n\nstruct Score {\n // lexicographic maximize: places, actions, then minimize rotCost\n int places = 0;\n int actions = 0;\n int rotCost = 0;\n};\nstatic inline bool betterScore(const Score& a, const Score& b){\n if(a.places != b.places) return a.places > b.places;\n if(a.actions != b.actions) return a.actions > b.actions;\n return a.rotCost < b.rotCost;\n}\nstatic inline Score addScore(const Score& s, int addPlace, int addAct, int addRot){\n return Score{s.places + addPlace, s.actions + addAct, s.rotCost + addRot};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n\n // Directions: 0=Up,1=Right,2=Down,3=Left\n const int dx4[4] = {-1, 0, 1, 0};\n const int dy4[4] = {0, 1, 0, -1};\n\n auto inside = [&](int x,int y)->bool{ return 0<=x && x> cur(N, vector(N, 0));\n vector> surplus(N, vector(N, 0)); // cur=1, target=0\n vector> deficit(N, vector(N, 0)); // cur=0, target=1\n int surplusCnt=0, deficitCnt=0;\n\n for(int i=0;i surList, defList;\n vector> surIdx(N, vector(N, -1));\n vector> defIdx(N, vector(N, -1));\n surList.reserve(N*N); defList.reserve(N*N);\n for(int i=0;i& lst, vector>& idx, int x, int y){\n int id = idx[x][y];\n if(id < 0) return;\n int last = (int)lst.size()-1;\n if(id != last){\n Pos p = lst[last];\n lst[id] = p;\n idx[p.x][p.y] = id;\n }\n lst.pop_back();\n idx[x][y] = -1;\n };\n\n // -------- Arm design: V' = V, lengths 1 and 2 --------\n int Vp = V; // 5..15\n cout << Vp << \"\\n\";\n vector len(Vp, 0);\n for(int u=1; u dir(Vp, 1); // initial all Right\n vector hold(Vp, 0);\n\n auto holdingCount = [&](){\n int c=0;\n for(int u=1; uint{\n int cw = mod4(to - from);\n int ccw = mod4(from - to);\n return min(cw, ccw); // 0,1,2\n };\n\n auto tipCell = [&](int px,int py,int u,int d)->Pos{\n return { px + len[u]*dx4[d], py + len[u]*dy4[d] };\n };\n\n struct Plan {\n vector rot; // size Vp\n vector act; // size Vp\n int places=0, picks=0;\n };\n\n // Greedy plan used for evaluation only (<=1 rotation)\n auto planGreedyAt = [&](int px,int py)->Plan{\n Plan pl;\n pl.rot.assign(Vp, '.');\n pl.act.assign(Vp, '.');\n pl.places = pl.picks = 0;\n\n vector usedCell(N*N, 0);\n auto cellId = [&](int x,int y){ return x*N+y; };\n\n struct Cand { int u; int cnt; };\n vector ord;\n vector> candDir(Vp);\n vector> candRot(Vp);\n vector candCnt(Vp, 0);\n\n // placements\n for(int u=1; u0) ord.push_back({u,cnt});\n }\n sort(ord.begin(), ord.end(), [&](const Cand& a, const Cand& b){\n if(a.cnt != b.cnt) return a.cnt < b.cnt;\n return a.u < b.u;\n });\n for(auto &c: ord){\n int u=c.u;\n for(int i=0;i0) ord.push_back({u,cnt});\n }\n sort(ord.begin(), ord.end(), [&](const Cand& a, const Cand& b){\n if(a.cnt != b.cnt) return a.cnt < b.cnt;\n return a.u < b.u;\n });\n for(auto &c: ord){\n int u=c.u;\n for(int i=0;ichar{\n // If we rotate right once, direction becomes dr; left once -> dl.\n int dr = mod4(dir[u] + 1);\n int dl = mod4(dir[u] + 3);\n\n auto sideValue = [&](int nd)->int{\n Pos p = tipCell(px,py,u,nd);\n if(!inside(p.x,p.y)) return 0;\n if(hold[u]){\n return deficit[p.x][p.y] ? 2 : 0;\n }else{\n return surplus[p.x][p.y] ? 2 : 0;\n }\n };\n int vr = sideValue(dr);\n int vl = sideValue(dl);\n if(vl > vr) return 'L';\n return 'R';\n };\n\n // Executed plan: exact subset DP over reachable cells (<=8) + rotate-idle-fingers prep\n auto planExecAt = [&](int px,int py)->Plan{\n Plan pl;\n pl.rot.assign(Vp, '.');\n pl.act.assign(Vp, '.');\n pl.places = pl.picks = 0;\n\n // Candidate cells: (L in {1,2}, d in 0..3) => up to 8\n vector cells;\n vector cellLen, cellDir;\n vector cellIsDef, cellIsSur;\n cells.reserve(8);\n\n for(int L=1; L<=2; L++){\n for(int d=0; d<4; d++){\n int x = px + L*dx4[d];\n int y = py + L*dy4[d];\n if(!inside(x,y)) continue;\n bool dup=false;\n for(auto &q: cells) if(q.x==x && q.y==y){ dup=true; break; }\n if(dup) continue;\n cells.push_back({x,y});\n cellLen.push_back(L);\n cellDir.push_back(d);\n cellIsDef.push_back(deficit[x][y]);\n cellIsSur.push_back(surplus[x][y]);\n }\n }\n int C = (int)cells.size();\n if(C==0) return pl;\n\n struct Opt { int c; char rot; int isPlace; int isPick; int rotCost; };\n vector> opts(Vp);\n\n for(int u=1; u 2) continue;\n for(int ci=0; ci 1) continue;\n char rotc = (dir[u]==td ? '.' : (mod4(dir[u]+1)==td ? 'R' : 'L'));\n int rcost = (rotc=='.'?0:1);\n\n if(hold[u] && cellIsDef[ci]) opts[u].push_back({ci, rotc, 1, 0, rcost});\n if(!hold[u] && cellIsSur[ci]) opts[u].push_back({ci, rotc, 0, 1, rcost});\n }\n }\n\n vector fingerList;\n fingerList.reserve(Vp-1);\n for(int u=1; u> dp(F+1, vector(MASKN, NEG));\n struct Prev { int pmask; int took; int optIdx; };\n vector> prv(F+1, vector(MASKN, {-1,0,-1}));\n\n dp[0][0] = Score{0,0,0};\n\n for(int i=0;i rotCmd(Vp,'.'), actCmd(Vp,'.');\n int mask = bestMask;\n for(int i=F; i>=1; i--){\n Prev pr = prv[i][mask];\n int u = fingerList[i-1];\n if(pr.took==1){\n auto &op = opts[u][pr.optIdx];\n rotCmd[u] = op.rot;\n actCmd[u] = 'P';\n if(op.isPlace) pl.places++;\n if(op.isPick) pl.picks++;\n }\n mask = pr.pmask;\n }\n\n // Additional free improvement: rotate idle fingers that are 180\u00b0 away from some actionable cell.\n for(int u=1; u 2) continue;\n\n // Check if there exists an actionable cell with dist==2\n bool needPrep = false;\n for(int d=0; d<4; d++){\n Pos p = tipCell(px,py,u,d);\n if(!inside(p.x,p.y)) continue;\n if(hold[u]){\n if(!deficit[p.x][p.y]) continue;\n }else{\n if(!surplus[p.x][p.y]) continue;\n }\n if(minRotDist(dir[u], d) == 2){\n needPrep = true;\n break;\n }\n }\n if(needPrep){\n rotCmd[u] = chooseLR_for_prep(px,py,u);\n }\n }\n\n pl.rot = std::move(rotCmd);\n pl.act = std::move(actCmd);\n return pl;\n };\n\n // Multi-prep 180\u00b0 (only used when absolutely no action is possible)\n auto planPrep180At = [&](int px,int py)->optional> {\n vector rotCmd(Vp, '.');\n bool any=false;\n\n for(int u=1; u 2) continue;\n // holding => place-prep\n if(hold[u]){\n bool need=false;\n for(int d=0; d<4; d++){\n Pos p = tipCell(px,py,u,d);\n if(!inside(p.x,p.y) || !deficit[p.x][p.y]) continue;\n if(minRotDist(dir[u], d)==2){ need=true; break; }\n }\n if(need){\n rotCmd[u] = chooseLR_for_prep(px,py,u);\n any=true;\n }\n } else {\n // empty => pick-prep\n bool need=false;\n for(int d=0; d<4; d++){\n Pos p = tipCell(px,py,u,d);\n if(!inside(p.x,p.y) || !surplus[p.x][p.y]) continue;\n if(minRotDist(dir[u], d)==2){ need=true; break; }\n }\n if(need){\n rotCmd[u] = chooseLR_for_prep(px,py,u);\n any=true;\n }\n }\n }\n\n if(!any) return nullopt;\n return rotCmd;\n };\n\n auto applyTurn = [&](char mv, const vector& rotCmd, const vector& actCmd)->int {\n int changes=0;\n if(mv=='U') rx--;\n else if(mv=='D') rx++;\n else if(mv=='L') ry--;\n else if(mv=='R') ry++;\n\n for(int u=1; u& lst, int K)->vector{\n vector> tmp;\n tmp.reserve(lst.size());\n for(int i=0;i<(int)lst.size();i++){\n int d = abs(lst[i].x - rx) + abs(lst[i].y - ry);\n tmp.push_back({d, i});\n }\n if((int)tmp.size() > K){\n nth_element(tmp.begin(), tmp.begin()+K, tmp.end());\n tmp.resize(K);\n }\n vector res;\n res.reserve(tmp.size());\n for(auto &p: tmp) res.push_back(lst[p.second]);\n return res;\n };\n\n // Choose goal (greedy estimator)\n auto chooseGoal = [&]()->optional{\n int h = holdingCount();\n bool wantPlace = (h > 0 && deficitCnt > 0);\n bool wantPick = (h < (Vp-1) && surplusCnt > 0);\n\n auto usableLens = [&](bool forPlace)->vector{\n vector lens;\n for(int u=1; u& cells, const vector& lens)->optional{\n unordered_set seen;\n seen.reserve(cells.size()*lens.size()*4*2);\n\n int bestScore = INT_MIN;\n Pos best{-1,-1};\n\n const int GOAL_GAIN_W = 6;\n\n for(const auto &c: cells){\n for(int L: lens){\n for(int d=0; d<4; d++){\n int nx = c.x - L*dx4[d];\n int ny = c.y - L*dy4[d];\n if(!inside(nx,ny)) continue;\n int key = nx*64 + ny;\n if(seen.count(key)) continue;\n seen.insert(key);\n\n int dist = abs(nx - rx) + abs(ny - ry);\n Plan p = planGreedyAt(nx, ny);\n int gain = p.places + p.picks;\n int score = GOAL_GAIN_W*gain - dist;\n if(score > bestScore){\n bestScore = score;\n best = {nx, ny};\n }\n }\n }\n }\n if(bestScore == INT_MIN) return nullopt;\n return best;\n };\n\n const int K = 60;\n if(wantPlace){\n auto cells = nearestK(defList, K);\n auto lens = usableLens(true);\n if(auto g = evalCandidates(cells, lens)) return g;\n }\n if(wantPick){\n auto cells = nearestK(surList, K);\n auto lens = usableLens(false);\n if(auto g = evalCandidates(cells, lens)) return g;\n }\n if(deficitCnt>0){\n auto cells = nearestK(defList, K);\n auto lens = usableLens(true);\n if(auto g = evalCandidates(cells, lens)) return g;\n }\n if(surplusCnt>0){\n auto cells = nearestK(surList, K);\n auto lens = usableLens(false);\n if(auto g = evalCandidates(cells, lens)) return g;\n }\n return nullopt;\n };\n\n // Sweep fallback snake\n vector snake;\n snake.reserve(N*N);\n for(int i=0;i=0;j--) snake.push_back({i,j});\n }\n int snakeIdx=0;\n auto moveChar = [&](Pos a, Pos b)->char{\n int dx=b.x-a.x, dy=b.y-a.y;\n if(dx==-1 && dy==0) return 'U';\n if(dx== 1 && dy==0) return 'D';\n if(dx==0 && dy==-1) return 'L';\n if(dx==0 && dy== 1) return 'R';\n return '.';\n };\n\n const int MAXT = 100000;\n int turns=0;\n int noChangeTurns=0;\n bool sweepMode=false;\n\n auto emitTurn = [&](char mv, const vector& rotCmd, const vector& actCmd){\n string cmd(2*Vp, '.');\n cmd[0]=mv;\n for(int u=1; u0){ noChangeTurns=0; sweepMode=false; }\n else noChangeTurns++;\n };\n\n // Init: set U/R/D/L pattern\n if(turns < MAXT){\n vector rotCmd(Vp,'.'), actCmd(Vp,'.');\n for(int u=1; u rotCmd(Vp,'.'), actCmd(Vp,'.');\n for(int u=1; u 0){\n emitTurn('.', stay.rot, stay.act);\n continue;\n }\n }\n\n // 2) if still no action, do explicit prep\n if(auto prep = planPrep180At(rx, ry)){\n vector actCmd(Vp,'.');\n emitTurn('.', *prep, actCmd);\n continue;\n }\n\n if(noChangeTurns > 250) sweepMode=true;\n\n // goal\n optional goalOpt;\n if(!sweepMode) goalOpt = chooseGoal();\n\n auto gainAtFast = [&](int x,int y)->int{\n Plan p = planGreedyAt(x,y);\n return p.places + p.picks;\n };\n\n char bestMv='.';\n int bestScore = INT_MIN;\n\n if(sweepMode){\n if(!(snake[snakeIdx].x==rx && snake[snakeIdx].y==ry)){\n int best=0, bestDist=INT_MAX;\n for(int i=0;i<(int)snake.size();i++){\n int dist = abs(snake[i].x-rx)+abs(snake[i].y-ry);\n if(distx) + abs(y1 - goalOpt->y);\n\n int idlePenalty = (mv.c=='.' && distToGoal>0 ? IDLE_PEN : 0);\n int score = W1*g1 + W2*g2 - WD*distToGoal - idlePenalty;\n if(score > bestScore){\n bestScore = score;\n bestMv = mv.c;\n }\n }\n }\n\n int nx=rx, ny=ry;\n if(bestMv=='U') nx--;\n else if(bestMv=='D') nx++;\n else if(bestMv=='L') ny--;\n else if(bestMv=='R') ny++;\n if(!inside(nx,ny)){ bestMv='.'; nx=rx; ny=ry; }\n\n Plan after = planExecAt(nx, ny);\n\n // if staying and still no action, prep\n if(bestMv=='.' && after.places + after.picks == 0){\n if(auto prep = planPrep180At(rx, ry)){\n vector actCmd(Vp,'.');\n emitTurn('.', *prep, actCmd);\n continue;\n }\n }\n\n emitTurn(bestMv, after.rot, after.act);\n }\n\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int l, int r) { return l + (int)(next_u64() % (uint64_t)(r - l + 1)); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); }\n};\n\nstatic inline double now_sec() {\n using namespace std::chrono;\n return duration_cast>(steady_clock::now().time_since_epoch()).count();\n}\n\nstruct Point { int x, y, w; };\nstruct Rect { int xl, xr, yb, yt; }; // inclusive\n\nstatic inline Rect clamp_rect(Rect r) {\n r.xl = max(0, min(100000, r.xl));\n r.xr = max(0, min(100000, r.xr));\n r.yb = max(0, min(100000, r.yb));\n r.yt = max(0, min(100000, r.yt));\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n if (w + h > 200000) {\n int cx = (r.xl + r.xr) / 2;\n int cy = (r.yb + r.yt) / 2;\n long long over = (w + h) - 200000;\n long long rw = min(over, w - 1);\n long long rh = min(over - rw, h - 1);\n long long neww = max(1LL, w - rw);\n long long newh = max(1LL, h - rh);\n\n r.xl = cx - (int)(neww / 2);\n r.xr = r.xl + (int)neww;\n r.yb = cy - (int)(newh / 2);\n r.yt = r.yb + (int)newh;\n\n if (r.xl < 0) { r.xr -= r.xl; r.xl = 0; }\n if (r.yb < 0) { r.yt -= r.yb; r.yb = 0; }\n if (r.xr > 100000) { int d = r.xr - 100000; r.xl -= d; r.xr = 100000; if (r.xl < 0) r.xl = 0; }\n if (r.yt > 100000) { int d = r.yt - 100000; r.yb -= d; r.yt = 100000; if (r.yb < 0) r.yb = 0; }\n if (r.xl >= r.xr) r.xr = min(100000, r.xl + 1);\n if (r.yb >= r.yt) r.yt = min(100000, r.yb + 1);\n }\n return r;\n}\nstatic inline bool rect_ok(const Rect& r) {\n if (r.xl < 0 || r.xr > 100000 || r.yb < 0 || r.yt > 100000) return false;\n if (r.xl >= r.xr || r.yb >= r.yt) return false;\n long long w = (long long)r.xr - r.xl;\n long long h = (long long)r.yt - r.yb;\n return (w + h <= 200000);\n}\n\n// ---- Static 2D BIT for fast rectangle evaluation ----\nstruct BIT2DStatic {\n struct Node {\n vector ys;\n vector pref; // pref[0]=0\n vector> tmp;\n };\n int M;\n vector xs;\n vector bit;\n\n void build(const vector& pts) {\n xs.clear();\n xs.reserve(pts.size());\n for (auto &p: pts) xs.push_back(p.x);\n sort(xs.begin(), xs.end());\n xs.erase(unique(xs.begin(), xs.end()), xs.end());\n M = (int)xs.size();\n bit.assign(M + 1, Node());\n\n for (auto &p: pts) {\n int xi = (int)(lower_bound(xs.begin(), xs.end(), p.x) - xs.begin()) + 1;\n for (int j = xi; j <= M; j += j & -j) bit[j].tmp.push_back({p.y, p.w});\n }\n for (int j = 1; j <= M; j++) {\n auto &t = bit[j].tmp;\n sort(t.begin(), t.end());\n vector ys, sums;\n ys.reserve(t.size());\n sums.reserve(t.size());\n for (int k = 0; k < (int)t.size();) {\n int y = t[k].first;\n int s = 0;\n while (k < (int)t.size() && t[k].first == y) { s += t[k].second; k++; }\n ys.push_back(y);\n sums.push_back(s);\n }\n bit[j].ys = move(ys);\n bit[j].pref.assign(bit[j].ys.size() + 1, 0);\n for (int i = 0; i < (int)sums.size(); i++) bit[j].pref[i+1] = bit[j].pref[i] + sums[i];\n bit[j].tmp.clear();\n bit[j].tmp.shrink_to_fit();\n }\n }\n\n inline int node_query(const Node& nd, int yBound) const {\n int pos = (int)(upper_bound(nd.ys.begin(), nd.ys.end(), yBound) - nd.ys.begin());\n return nd.pref[pos];\n }\n inline int prefix_query(int xBound, int yBound) const {\n if (xBound < 0 || yBound < 0) return 0;\n int xi = (int)(upper_bound(xs.begin(), xs.end(), xBound) - xs.begin());\n int res = 0;\n for (int j = xi; j > 0; j -= j & -j) res += node_query(bit[j], yBound);\n return res;\n }\n inline int rect_sum_inclusive(const Rect& r) const {\n int A = prefix_query(r.xr, r.yt);\n int B = prefix_query(r.xl - 1, r.yt);\n int C = prefix_query(r.xr, r.yb - 1);\n int D = prefix_query(r.xl - 1, r.yb - 1);\n return A - B - C + D;\n }\n};\n\n// ---- Staircase helpers ----\nstatic inline bool gap_ok(int Li, int Ui, int Lj, int Uj) {\n return max(Li, Lj) < min(Ui, Uj); // strict overlap\n}\nstatic inline long long Vlen_full(const vector& L, const vector& U) {\n int K = (int)L.size();\n long long v = 0;\n v += (long long)U[0] - L[0];\n v += (long long)U[K-1] - L[K-1];\n for (int i = 1; i < K; i++) {\n v += llabs((long long)L[i] - L[i-1]);\n v += llabs((long long)U[i] - U[i-1]);\n }\n return v;\n}\nstatic inline bool perim_ok(int XL, int XR, long long Vlen) {\n long long H = 2LL * (XR - XL);\n return H + Vlen <= 400000;\n}\nstatic inline vector build_xs(int XL, int XR, int K) {\n vector xs(K+1);\n xs[0] = XL; xs[K] = XR;\n long long width = (long long)XR - XL;\n for (int i = 1; i < K; i++) xs[i] = XL + (int)(width * i / K);\n for (int i = 1; i <= K; i++) xs[i] = max(xs[i], xs[i-1] + 1);\n xs[K] = XR;\n for (int i = K-1; i >= 0; i--) xs[i] = min(xs[i], xs[i+1] - 1);\n xs[0] = XL; xs[K] = XR;\n for (int i = 1; i <= K; i++) if (xs[i] <= xs[i-1]) xs[i] = xs[i-1] + 1;\n xs[K] = XR;\n return xs;\n}\n\nstruct SlabDS {\n vector ys;\n vector pref;\n vector> yw;\n vector my;\n inline int range_sum(int L, int U) const {\n if (ys.empty()) return 0;\n int l = (int)(lower_bound(ys.begin(), ys.end(), L) - ys.begin());\n int r = (int)(upper_bound(ys.begin(), ys.end(), U) - ys.begin());\n return pref[r] - pref[l];\n }\n};\n\nstruct SolveResult { int diff; vector> poly; };\n\nstatic inline void remove_collinear(vector>& poly) {\n auto is_col = [&](const pair& a, const pair& b, const pair& c){\n return (a.first == b.first && b.first == c.first) ||\n (a.second == b.second && b.second == c.second);\n };\n bool changed = true;\n while (changed && poly.size() >= 4) {\n changed = false;\n int m = (int)poly.size();\n vector> np;\n np.reserve(m);\n for (int i = 0; i < m; i++) {\n auto prev = poly[(i-1+m)%m];\n auto cur = poly[i];\n auto next = poly[(i+1)%m];\n if (is_col(prev, cur, next)) { changed = true; continue; }\n np.push_back(cur);\n }\n poly.swap(np);\n }\n}\n\n// quick estimate for time split (cheap O(N))\nstatic int quick_best_rect_estimate(const vector& pts, const vector& macks, uint64_t seed) {\n XorShift64 rng(seed);\n auto evalON = [&](const Rect& r)->int{\n int s = 0;\n for (auto &p: pts) if (r.xl <= p.x && p.x <= r.xr && r.yb <= p.y && p.y <= r.yt) s += p.w;\n return s;\n };\n int best = -1e9;\n for (int it = 0; it < 180; it++) {\n const auto& c = macks[rng.next_int(0, (int)macks.size()-1)];\n int w = rng.next_int(800, 60000);\n int h = rng.next_int(800, 60000);\n if (w + h > 200000) { int over = w + h - 200000; w = max(1, w - over/2); h = max(1, h - (over - over/2)); }\n Rect r{c.x - w/2, c.x + w/2, c.y - h/2, c.y + h/2};\n r = clamp_rect(r);\n if (!rect_ok(r)) continue;\n best = max(best, evalON(r));\n }\n return best;\n}\n\n// best subarray with length >= minLen using prefix minima\nstatic tuple best_subarray_minlen(const vector& a, int minLen) {\n int n = (int)a.size();\n minLen = min(minLen, n);\n vector pref(n+1, 0);\n for (int i = 0; i < n; i++) pref[i+1] = pref[i] + a[i];\n\n int bestSum = INT_MIN, bestL = 0, bestR = n-1;\n int minPref = pref[0], minPos = 0;\n for (int r = minLen-1; r < n; r++) {\n int lCand = r - (minLen-1);\n if (pref[lCand] < minPref) { minPref = pref[lCand]; minPos = lCand; }\n int sum = pref[r+1] - minPref;\n if (sum > bestSum) { bestSum = sum; bestL = minPos; bestR = r; }\n }\n return {bestSum, bestL, bestR};\n}\n\nstatic SolveResult solve_monotone(const vector& pts, const vector& macks,\n double endTime, uint64_t seed_add) {\n XorShift64 rng(seed_add ^ 0x9e3779b97f4a7c15ULL);\n\n BIT2DStatic bit2d;\n bit2d.build(pts);\n auto eval_rect_fast = [&](const Rect& r)->int { return bit2d.rect_sum_inclusive(r); };\n\n auto make_around = [&](const Point& c, int w, int h)->Rect{\n Rect r{c.x - w/2, c.x + w/2, c.y - h/2, c.y + h/2};\n r = clamp_rect(r);\n if (!(r.xl <= c.x && c.x <= r.xr && r.yb <= c.y && c.y <= r.yt))\n r = clamp_rect(Rect{c.x, c.x+1, c.y, c.y+1});\n return r;\n };\n\n // Warm rectangles\n vector> cand;\n cand.reserve(200000);\n for (int it = 0; it < 120000; it++) {\n if (now_sec() > endTime) break;\n const auto& c = macks[rng.next_int(0, (int)macks.size()-1)];\n double rr = rng.next_double();\n int w,h;\n if (rr < 0.60) { w = rng.next_int(200, 12000); h = rng.next_int(200, 12000); }\n else if (rr < 0.92) { w = rng.next_int(2000, 60000); h = rng.next_int(2000, 60000); }\n else { w = rng.next_int(12000, 98000); h = rng.next_int(12000, 98000); }\n if (w + h > 200000) {\n int over = w + h - 200000;\n w = max(1, w - over/2);\n h = max(1, h - (over - over/2));\n }\n Rect r = make_around(c, w, h);\n if (!rect_ok(r)) continue;\n cand.push_back({eval_rect_fast(r), r});\n }\n if (cand.empty()) return {-1000000000, {{0,0},{1,0},{1,1},{0,1}}};\n\n int keep = min(240, (int)cand.size());\n nth_element(cand.begin(), cand.begin() + keep, cand.end(),\n [&](auto &a, auto &b){ return a.first > b.first; });\n cand.resize(keep);\n sort(cand.begin(), cand.end(), [&](auto &a, auto &b){ return a.first > b.first; });\n\n int R = 10;\n vector starts;\n for (int i = 0; i < (int)cand.size() && (int)starts.size() < R; i++) starts.push_back(cand[i].second);\n while ((int)starts.size() < R) starts.push_back(starts[0]);\n\n int globalBestTot = -1e9;\n vector> globalBestPoly;\n\n struct Ivl2 { int L, U; };\n auto dp_init = [&](const vector>& cI, const vector>& cS,\n double alpha, vector& outL, vector& outU) {\n const int K = (int)cI.size();\n const int C = 6;\n const double NEG = -1e100;\n vector> dp(K);\n vector> prv(K);\n for (int i = 0; i < K; i++) for (int c = 0; c < C; c++) { dp[i][c] = NEG; prv[i][c] = -1; }\n\n for (int c = 0; c < C; c++) {\n auto iv = cI[0][c];\n dp[0][c] = (double)cS[0][c] - alpha * (double)(iv.U - iv.L);\n }\n for (int i = 1; i < K; i++) {\n for (int c = 0; c < C; c++) {\n auto cur = cI[i][c];\n double bestv = NEG; int bestp = -1;\n for (int p = 0; p < C; p++) {\n if (dp[i-1][p] <= NEG/2) continue;\n auto pre = cI[i-1][p];\n if (!gap_ok(pre.L, pre.U, cur.L, cur.U)) continue;\n double trans = alpha * (double)(abs(cur.L - pre.L) + abs(cur.U - pre.U));\n double val = dp[i-1][p] + (double)cS[i][c] - trans;\n if (val > bestv) { bestv = val; bestp = p; }\n }\n dp[i][c] = bestv; prv[i][c] = bestp;\n }\n }\n int bestc = 0; double bestv = NEG;\n for (int c = 0; c < C; c++) {\n if (dp[K-1][c] <= NEG/2) continue;\n auto iv = cI[K-1][c];\n double val = dp[K-1][c] - alpha * (double)(iv.U - iv.L);\n if (val > bestv) { bestv = val; bestc = c; }\n }\n outL.assign(K, 0); outU.assign(K, 1);\n int curc = bestc;\n for (int i = K-1; i >= 0; i--) {\n outL[i] = cI[i][curc].L;\n outU[i] = cI[i][curc].U;\n curc = prv[i][curc];\n if (i > 0 && curc < 0) {\n for (int j = 0; j < i; j++) { outL[j] = cI[j][0].L; outU[j] = cI[j][0].U; }\n break;\n }\n }\n };\n\n for (int rs = 0; rs < R; rs++) {\n if (now_sec() > endTime) break;\n\n Rect base = clamp_rect(starts[rs]);\n int XL = base.xl, XR = base.xr;\n int YB = base.yb, YT = base.yt;\n\n int width = XR - XL;\n if (width < 60) { XR = min(100000, XL + 60); width = XR - XL; }\n\n int K = 80 + width / 500;\n K = max(60, min(220, K));\n K = min(K, width);\n if (K < 4) K = 4;\n\n vector xs = build_xs(XL, XR, K);\n\n vector slabs(K);\n for (int i = 0; i < K; i++) slabs[i].yw.clear();\n for (auto &p: pts) {\n if (p.x < XL || p.x > XR) continue;\n int idx = (int)(upper_bound(xs.begin(), xs.end(), p.x) - xs.begin()) - 1;\n idx = max(0, min(K-1, idx));\n slabs[idx].yw.push_back({p.y, p.w});\n }\n for (int i = 0; i < K; i++) {\n auto &v = slabs[i].yw;\n sort(v.begin(), v.end());\n slabs[i].ys.clear();\n slabs[i].pref.assign(v.size()+1, 0);\n slabs[i].my.clear();\n slabs[i].ys.reserve(v.size());\n for (int j = 0; j < (int)v.size(); j++) {\n slabs[i].ys.push_back(v[j].first);\n slabs[i].pref[j+1] = slabs[i].pref[j] + v[j].second;\n if (v[j].second == +1) slabs[i].my.push_back(v[j].first);\n }\n }\n\n const int C = 6;\n vector> cI(K);\n vector> cS(K);\n\n for (int i = 0; i < K; i++) {\n cI[i][0] = {YB, YT};\n\n // Kadane\n Ivl2 kad{YB, YT};\n auto &v = slabs[i].yw;\n if (!v.empty()) {\n int M = (int)v.size();\n int bestSum = INT_MIN, curSum = 0;\n int start = 0, bestL = 0, bestR = -1;\n for (int j = 0; j < M; j++) {\n int w = v[j].second;\n if (curSum <= 0) { curSum = w; start = j; }\n else curSum += w;\n if (curSum > bestSum) { bestSum = curSum; bestL = start; bestR = j; }\n }\n if (bestSum > 0 && bestR >= bestL) {\n int l = v[bestL].first;\n int u = v[bestR].first;\n if (u <= l) u = min(100000, l + 1);\n kad = {max(0,l), min(100000,u)};\n }\n }\n cI[i][1] = kad;\n cI[i][2] = {max(0, kad.L - 500), min(100000, kad.U + 500)};\n\n Ivl2 perc{YB, YT};\n auto my = slabs[i].my;\n if ((int)my.size() >= 8) {\n sort(my.begin(), my.end());\n int p25 = my[(int)(0.25 * (my.size()-1))];\n int p75 = my[(int)(0.75 * (my.size()-1))];\n perc = {max(0, p25 - 260), min(100000, p75 + 260)};\n if (perc.U <= perc.L) perc.U = min(100000, perc.L + 1);\n }\n cI[i][3] = perc;\n\n Ivl2 small{YB, YT}, med{YB, YT};\n if (!slabs[i].my.empty()) {\n int y0 = slabs[i].my[rng.next_int(0, (int)slabs[i].my.size()-1)];\n small = {max(0, y0 - 140), min(100000, y0 + 140)};\n med = {max(0, y0 - 420), min(100000, y0 + 420)};\n if (small.U <= small.L) small.U = min(100000, small.L + 1);\n if (med.U <= med.L) med.U = min(100000, med.L + 1);\n }\n cI[i][4] = small;\n cI[i][5] = med;\n\n for (int c = 0; c < C; c++) cS[i][c] = slabs[i].range_sum(cI[i][c].L, cI[i][c].U);\n }\n\n // initial: base constant, DP alpha=0, DP alpha=0.01\n vector> initLs, initUs;\n initLs.push_back(vector(K, YB));\n initUs.push_back(vector(K, YT));\n {\n vector L,U; dp_init(cI, cS, 0.0, L, U);\n initLs.push_back(move(L)); initUs.push_back(move(U));\n }\n {\n vector L,U; dp_init(cI, cS, 0.010, L, U);\n initLs.push_back(move(L)); initUs.push_back(move(U));\n }\n\n auto eval_state = [&](const vector& Lc, const vector& Uc, int& sc, long long& v) {\n sc = 0;\n for (int i = 0; i < K; i++) sc += slabs[i].range_sum(Lc[i], Uc[i]);\n v = Vlen_full(Lc, Uc);\n };\n\n vector L, U;\n int total = -1e9;\n long long Vlen = (1LL<<60);\n for (int idx = 0; idx < (int)initLs.size(); idx++) {\n auto Lc = initLs[idx];\n auto Uc = initUs[idx];\n bool ok = true;\n for (int i = 0; i+1 < K; i++) if (!gap_ok(Lc[i],Uc[i],Lc[i+1],Uc[i+1])) { ok = false; break; }\n if (!ok) continue;\n int sc; long long v;\n eval_state(Lc, Uc, sc, v);\n if (!perim_ok(XL, XR, v)) continue;\n if (sc > total || (sc == total && v < Vlen)) { total = sc; Vlen = v; L = move(Lc); U = move(Uc); }\n }\n if (L.empty()) {\n L.assign(K, YB);\n U.assign(K, YT);\n total = 0;\n for (int i = 0; i < K; i++) total += slabs[i].range_sum(L[i], U[i]);\n Vlen = Vlen_full(L, U);\n }\n\n vector contrib(K, 0);\n for (int i = 0; i < K; i++) contrib[i] = slabs[i].range_sum(L[i], U[i]);\n\n int bestTot = total;\n long long bestV = Vlen;\n vector bestL = L, bestU = U;\n\n auto local_V_delta = [&](int i, int oldL, int oldU, int newL, int newU)->long long {\n long long d = 0;\n auto endterm = [&](int idx, int a, int b)->long long {\n if (idx == 0 || idx == K-1) return (long long)b - a;\n return 0LL;\n };\n d -= endterm(i, oldL, oldU);\n d += endterm(i, newL, newU);\n if (i-1 >= 0) {\n d -= llabs((long long)oldL - L[i-1]);\n d += llabs((long long)newL - L[i-1]);\n d -= llabs((long long)oldU - U[i-1]);\n d += llabs((long long)newU - U[i-1]);\n }\n if (i+1 < K) {\n d -= llabs((long long)L[i+1] - oldL);\n d += llabs((long long)L[i+1] - newL);\n d -= llabs((long long)U[i+1] - oldU);\n d += llabs((long long)U[i+1] - newU);\n }\n return d;\n };\n\n // adaptive local budget\n double curNow = now_sec();\n double remaining = max(0.0, endTime - curNow);\n int remainingR = max(1, R - rs);\n double budget = remaining / remainingR;\n double localEnd = curNow + budget;\n\n const double T0 = 28.0, T1 = 0.7;\n\n while (true) {\n double ct = now_sec();\n if (ct > endTime) break;\n if (ct > localEnd && rs < R-1) break;\n\n double prog = (ct - curNow) / max(1e-9, budget);\n prog = min(1.0, max(0.0, prog));\n double temp = T0 * pow(T1 / T0, prog);\n\n int i = rng.next_int(0, K-1);\n int oldLi = L[i], oldUi = U[i];\n int newL = oldLi, newU = oldUi;\n\n double dice = rng.next_double();\n if (dice < 0.20) {\n int maxD = (int)(9000 * (1.0 - prog) + 30);\n newL += rng.next_int(-maxD, maxD);\n } else if (dice < 0.40) {\n int maxD = (int)(9000 * (1.0 - prog) + 30);\n newU += rng.next_int(-maxD, maxD);\n } else if (dice < 0.58) {\n int maxD = (int)(7000 * (1.0 - prog) + 25);\n int d = rng.next_int(-maxD, maxD);\n newL += d; newU += d;\n } else if (dice < 0.74) {\n int c = rng.next_int(0, C-1);\n newL = cI[i][c].L;\n newU = cI[i][c].U;\n } else if (dice < 0.84) {\n if (i > 0 && rng.next_double() < 0.5) { newL = L[i-1]; newU = U[i-1]; }\n else if (i+1 < K) { newL = L[i+1]; newU = U[i+1]; }\n } else {\n int d = rng.next_int(-300, 300);\n newL += d;\n newU -= d;\n }\n\n // normalize interval\n newL = max(0, min(100000, newL));\n newU = max(0, min(100000, newU));\n if (newU <= newL) newU = min(100000, newL + 1);\n\n if (i-1 >= 0 && !gap_ok(L[i-1], U[i-1], newL, newU)) continue;\n if (i+1 < K && !gap_ok(newL, newU, L[i+1], U[i+1])) continue;\n\n long long dV = local_V_delta(i, oldLi, oldUi, newL, newU);\n long long newV = Vlen + dV;\n if (!perim_ok(XL, XR, newV)) continue;\n\n int newC = slabs[i].range_sum(newL, newU);\n int newTot = total - contrib[i] + newC;\n int dScore = newTot - total;\n\n bool accept = false;\n if (dScore > 0) accept = true;\n else if (dScore == 0) {\n if (newV < Vlen) accept = true;\n else accept = (rng.next_double() < 0.12);\n } else {\n double prob = exp((double)dScore / temp);\n if (rng.next_double() < prob) accept = true;\n }\n\n if (accept) {\n L[i] = newL; U[i] = newU;\n Vlen = newV;\n total = newTot;\n contrib[i] = newC;\n if (total > bestTot || (total == bestTot && Vlen < bestV)) {\n bestTot = total;\n bestV = Vlen;\n bestL = L;\n bestU = U;\n }\n }\n }\n\n // Build slab contributions\n vector slabC(K);\n for (int i = 0; i < K; i++) slabC[i] = slabs[i].range_sum(bestL[i], bestU[i]);\n\n // Try two trims: minLen=4 and minLen=1, choose best (with perimeter check)\n auto Vlen_sub = [&](int Lidx, int Ridx)->long long{\n long long v = 0;\n v += (long long)bestU[Lidx] - bestL[Lidx];\n v += (long long)bestU[Ridx] - bestL[Ridx];\n for (int i = Lidx+1; i <= Ridx; i++) {\n v += llabs((long long)bestL[i] - bestL[i-1]);\n v += llabs((long long)bestU[i] - bestU[i-1]);\n }\n return v;\n };\n\n int lbest = 0, rbest = K-1;\n int bestSum = bestTot;\n\n for (int minLen : {4, 1}) {\n if (K < minLen) continue;\n auto [sum, l, r] = best_subarray_minlen(slabC, minLen);\n int XLt = xs[l];\n int XRt = xs[r+1];\n long long Vt = Vlen_sub(l, r);\n if (!perim_ok(XLt, XRt, Vt)) continue;\n if (sum > bestSum) { bestSum = sum; lbest = l; rbest = r; }\n }\n bestTot = bestSum;\n\n // Build polygon from [lbest..rbest]\n int KK = rbest - lbest + 1;\n vector> poly;\n poly.reserve(4*KK + 10);\n auto pushv = [&](int x, int y) {\n if (!poly.empty() && poly.back().first == x && poly.back().second == y) return;\n poly.push_back({x,y});\n };\n\n pushv(xs[lbest], bestL[lbest]);\n for (int i = lbest; i < rbest; i++) {\n pushv(xs[i+1], bestL[i]);\n if (bestL[i+1] != bestL[i]) pushv(xs[i+1], bestL[i+1]);\n }\n pushv(xs[rbest+1], bestL[rbest]);\n\n if (bestU[rbest] != bestL[rbest]) pushv(xs[rbest+1], bestU[rbest]);\n\n for (int i = rbest; i >= lbest+1; i--) {\n pushv(xs[i], bestU[i]);\n if (bestU[i-1] != bestU[i]) pushv(xs[i], bestU[i-1]);\n }\n pushv(xs[lbest], bestU[lbest]);\n\n if (bestL[lbest] != bestU[lbest]) pushv(xs[lbest], bestL[lbest]);\n if (!poly.empty() && poly.front() == poly.back()) poly.pop_back();\n\n remove_collinear(poly);\n\n bool ok = (poly.size() >= 4 && poly.size() <= 1000);\n if (ok) {\n unordered_set seen;\n seen.reserve(poly.size()*2);\n for (auto &v: poly) {\n long long key = (long long)v.first * 200001LL + v.second;\n if (seen.count(key)) { ok = false; break; }\n seen.insert(key);\n }\n }\n if (!ok) {\n Rect r = clamp_rect(base);\n poly = {{r.xl,r.yb},{r.xr,r.yb},{r.xr,r.yt},{r.xl,r.yt}};\n bestTot = eval_rect_fast(r);\n }\n\n if (bestTot > globalBestTot) {\n globalBestTot = bestTot;\n globalBestPoly = move(poly);\n }\n }\n\n if (globalBestPoly.empty()) globalBestPoly = {{0,0},{1,0},{1,1},{0,1}};\n return {globalBestTot, globalBestPoly};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector pts(2*N);\n vector macks; macks.reserve(N);\n\n // deterministic seed from input (FNV-1a-like)\n uint64_t h = 1469598103934665603ULL;\n auto mix = [&](uint64_t v){ h ^= v; h *= 1099511628211ULL; };\n\n for (int i = 0; i < 2*N; i++) {\n int x,y; cin >> x >> y;\n int w = (i < N) ? +1 : -1;\n pts[i] = {x,y,w};\n if (i < N) macks.push_back({x,y,+1});\n mix((uint64_t)x * 1000003ULL + (uint64_t)y + (uint64_t)(w+2) * 1000000007ULL);\n }\n\n double t0 = now_sec();\n const double TL = 1.95;\n double hardEnd = t0 + TL * 0.99;\n\n uint64_t baseSeed = h ^ 0xA5A5A5A5A5A5A5A5ULL;\n\n // swapped instance\n vector ptsS = pts;\n vector macksS; macksS.reserve(macks.size());\n for (auto &p: ptsS) swap(p.x, p.y);\n for (auto &p: macks) macksS.push_back({p.y, p.x, +1});\n\n // adaptive time split, but less aggressive (reduce risk)\n int estA = quick_best_rect_estimate(pts, macks, baseSeed ^ 0xAAAABBBBULL);\n int estB = quick_best_rect_estimate(ptsS, macksS, baseSeed ^ 0xCCCCDDDDULL);\n double a = max(1.0, (double)(estA + 200));\n double b = max(1.0, (double)(estB + 200));\n double fracA = a / (a + b);\n fracA = min(0.55, max(0.45, fracA));\n\n double endA = t0 + (hardEnd - t0) * fracA;\n double endB = hardEnd;\n\n SolveResult A = solve_monotone(pts, macks, endA, baseSeed ^ 0x11111111ULL);\n SolveResult B = solve_monotone(ptsS, macksS, endB, baseSeed ^ 0x22222222ULL);\n for (auto &v: B.poly) swap(v.first, v.second);\n\n SolveResult best = (B.diff > A.diff) ? B : A;\n\n cout << best.poly.size() << \"\\n\";\n for (auto &v: best.poly) cout << v.first << \" \" << v.second << \"\\n\";\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct Op {\n int p;\n int r; // 0/1\n char d; // 'L' or 'U'\n int b; // -1 or previous index\n};\n\nstruct Placed {\n ll x=0, y=0, w=0, h=0;\n};\n\nstatic inline bool overlapPosLen(ll a1, ll a2, ll b1, ll b2) {\n return max(a1, b1) < min(a2, b2);\n}\n\nstruct RNG {\n uint64_t x;\n explicit RNG(uint64_t seed=88172645463325252ULL) : x(seed) {}\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int lo, int hi) { return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1)); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); }\n};\n\nstatic inline pair place_one(const Placed placed[], int i, ll w, ll h, char d, int b) {\n ll x=0, y=0;\n if (d == 'U') {\n x = 0;\n if (b != -1) x = placed[b].x + placed[b].w;\n y = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(x, x+w, pj.x, pj.x+pj.w)) y = max(y, pj.y + pj.h);\n }\n } else { // 'L'\n y = 0;\n if (b != -1) y = placed[b].y + placed[b].h;\n x = 0;\n for (int j = 0; j < i; j++) {\n const auto &pj = placed[j];\n if (overlapPosLen(y, y+h, pj.y, pj.y+pj.h)) x = max(x, pj.x + pj.w);\n }\n }\n return {x,y};\n}\n\npair simulate_ops(const vector& ops, const vector& W, const vector& H) {\n int N = (int)ops.size();\n vector placed(N);\n ll maxX=0, maxY=0;\n for (int i = 0; i < N; i++) {\n const auto& op = ops[i];\n ll w = W[op.p], h = H[op.p];\n if (op.r) swap(w,h);\n auto [x,y] = place_one(placed.data(), i, w, h, op.d, op.b);\n placed[i] = Placed{x,y,w,h};\n maxX = max(maxX, x+w);\n maxY = max(maxY, y+h);\n }\n return {maxX, maxY};\n}\n\n// O(i*K) topK selection\nstatic inline void topK_by_right(const Placed placed[], int i, int K, vector& out) {\n out.clear();\n vector> best;\n best.reserve(K);\n for(int j=0;j best[0].first) {\n best[0] = {key,j};\n int t=0;\n while(t+1 best[t+1].first) { swap(best[t], best[t+1]); t++; }\n }\n }\n for(auto &p: best) out.push_back(p.second);\n sort(out.begin(), out.end());\n out.erase(unique(out.begin(), out.end()), out.end());\n}\nstatic inline void topK_by_bottom(const Placed placed[], int i, int K, vector& out) {\n out.clear();\n vector> best;\n best.reserve(K);\n for(int j=0;j best[0].first) {\n best[0] = {key,j};\n int t=0;\n while(t+1 best[t+1].first) { swap(best[t], best[t+1]); t++; }\n }\n }\n for(auto &p: best) out.push_back(p.second);\n sort(out.begin(), out.end());\n out.erase(unique(out.begin(), out.end()), out.end());\n}\n\n// Key: minimize perimeter, tie-break by aspect difference\nstatic inline ll key_WH(ll W, ll H) {\n return (W + H) * 1000000LL + min(1000000, llabs(W - H));\n}\n\nstruct Candidate {\n vector ops;\n ll estW=0, estH=0, estObj=(1LL<<62);\n string tag;\n};\n\nCandidate make_all_one_row(const vector& w, const vector& h, uint64_t seed) {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n for(int i=0;i& w, const vector& h, uint64_t seed) {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n for(int i=0;i& w, const vector& h, ll Wlim, uint64_t seed) {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n int prevAnchor=-1;\n ll rowW=0, rowH=0;\n int rowTall=-1; ll rowTallH=-1;\n auto finish_row=[&](){\n prevAnchor=rowTall;\n rowW=0; rowH=0;\n rowTall=-1; rowTallH=-1;\n };\n\n for(int i=0;i0){\n bool fit0 = (rowW+w0<=Wlim), fit1=(rowW+w1<=Wlim);\n if(!fit0 && !fit1) finish_row();\n else if(rowW > (ll)llround((long double)Wlim*0.95L) && rng.next_double()<0.20) finish_row();\n }\n\n int r=0;\n bool fit0 = (rowW+w0<=Wlim), fit1=(rowW+w1<=Wlim);\n if(fit0 && fit1){\n ll rh0=max(rowH,h0), rh1=max(rowH,h1);\n if(rh1rowTallH){ rowTallH=hh; rowTall=i; }\n }\n\n auto [W,Hh]=simulate_ops(c.ops,w,h);\n c.estW=W; c.estH=Hh; c.estObj=W+Hh; c.tag=\"rowShelf\";\n return c;\n}\n\nCandidate make_col_shelf(const vector& w, const vector& h, ll Hlim, uint64_t seed) {\n int N=(int)w.size();\n RNG rng(seed);\n Candidate c; c.ops.resize(N);\n\n int prevAnchor=-1;\n ll colH=0, colW=0;\n int colWide=-1; ll colWideW=-1;\n auto finish_col=[&](){\n prevAnchor=colWide;\n colH=0; colW=0;\n colWide=-1; colWideW=-1;\n };\n\n for(int i=0;i0){\n bool fit0 = (colH+h0<=Hlim), fit1=(colH+h1<=Hlim);\n if(!fit0 && !fit1) finish_col();\n else if(colH > (ll)llround((long double)Hlim*0.95L) && rng.next_double()<0.20) finish_col();\n }\n\n int r=0;\n bool fit0 = (colH+h0<=Hlim), fit1=(colH+h1<=Hlim);\n if(fit0 && fit1){\n ll cw0=max(colW,w0), cw1=max(colW,w1);\n if(cw1colWideW){ colWideW=ww; colWide=i; }\n }\n\n auto [W,Hh]=simulate_ops(c.ops,w,h);\n c.estW=W; c.estH=Hh; c.estObj=W+Hh; c.tag=\"colShelf\";\n return c;\n}\n\nCandidate make_greedy_mosaic(const vector& w, const vector& h,\n uint64_t seed, int Kanchor, int randAnchor, double pPreferL,\n string tag=\"greedy\") {\n const int MAXN=100;\n int N=(int)w.size();\n RNG rng(seed);\n\n array placed{};\n array ops{};\n ll curW=0, curH=0;\n\n vector BU, BL, tmp;\n\n for(int i=0;i0){\n topK_by_right(placed.data(), i, Kanchor, tmp); BU.insert(BU.end(), tmp.begin(), tmp.end());\n topK_by_bottom(placed.data(), i, Kanchor, tmp); BL.insert(BL.end(), tmp.begin(), tmp.end());\n for(int t=0;t& w, const vector& h,\n uint64_t seed, int beamWidth, int Kanchor, int randAnchor,\n double pPreferL, string tag=\"beam\") {\n const int MAXN=100;\n int N=(int)w.size();\n RNG rng(seed);\n\n struct State {\n ll W=0, H=0;\n ll key=0;\n array placed;\n array ops;\n };\n\n vector cur, nxt;\n cur.reserve(beamWidth);\n nxt.reserve(beamWidth*48);\n cur.push_back(State{});\n\n vector BU, BL, tmp;\n\n for(int i=0;i0){\n topK_by_right(st.placed.data(), i, Kanchor, tmp); BU.insert(BU.end(), tmp.begin(), tmp.end());\n topK_by_bottom(st.placed.data(), i, Kanchor, tmp); BL.insert(BL.end(), tmp.begin(), tmp.end());\n for(int t=0;t& Bset){\n ll ww=(r? w1:w0), hh=(r? h1:h0);\n for(int b: Bset){\n auto [x,y] = place_one(st.placed.data(), i, ww, hh, d, b);\n ll nW=max(st.W, x+ww), nH=max(st.H, y+hh);\n ll k = key_WH(nW, nH);\n\n State ns;\n ns.W=nW; ns.H=nH; ns.key=k;\n if(i>0){\n memcpy(ns.placed.data(), st.placed.data(), sizeof(Placed)*i);\n memcpy(ns.ops.data(), st.ops.data(), sizeof(Op)*i);\n }\n ns.placed[i]=Placed{x,y,ww,hh};\n ns.ops[i]=Op{i,r,d,b};\n nxt.push_back(ns);\n }\n };\n\n for(int rr=0; rr<2; rr++){\n int r=rr;\n if(rng.next_double()<0.05) r^=1;\n if(tryLFirst){\n expand(r,'L',BL);\n expand(r,'U',BU);\n }else{\n expand(r,'U',BU);\n expand(r,'L',BL);\n }\n }\n }\n\n if((int)nxt.size() > beamWidth){\n nth_element(nxt.begin(), nxt.begin()+beamWidth, nxt.end(),\n [](const State& a, const State& b){ return a.key < b.key; });\n nxt.resize(beamWidth);\n }\n sort(nxt.begin(), nxt.end(), [](const State& a, const State& b){ return a.key < b.key; });\n cur.swap(nxt);\n }\n\n const State& best = cur.front();\n Candidate c;\n c.ops.resize(N);\n for(int i=0;i& w, const vector& h,\n int start, uint64_t seed,\n int Kanchor=10, int randAnchor=2, double pPreferL=0.5,\n string tag=\"repair\") {\n int N=(int)w.size();\n RNG rng(seed);\n\n Candidate c;\n c.ops = base.ops;\n\n vector placed(N);\n ll curW=0, curH=0;\n\n // build prefix using base\n for(int i=0;i BU, BL, tmp;\n\n for(int i=start;i0){\n topK_by_right(placed.data(), i, Kanchor, tmp); BU.insert(BU.end(), tmp.begin(), tmp.end());\n topK_by_bottom(placed.data(), i, Kanchor, tmp); BL.insert(BL.end(), tmp.begin(), tmp.end());\n for(int t=0;t> N >> T >> sigma;\n vector wp(N), hp(N);\n for(int i=0;i> wp[i] >> hp[i];\n\n auto t0 = chrono::high_resolution_clock::now();\n auto elapsed = [&](){\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - t0).count();\n };\n\n const double GEN_LIMIT = 2.25; // candidate generation\n const double REPAIR_LIMIT = 2.45; // add repairs after sorting\n\n long double areaSum=0;\n ll sumW=0, sumH=0;\n for(int i=0;i(1, (ll)floor(sqrt(areaSum)));\n\n vector pool;\n pool.reserve(400);\n\n auto prune_pool = [&](int keep){\n if((int)pool.size() <= keep*2) return;\n nth_element(pool.begin(), pool.begin()+keep, pool.end(),\n [](const Candidate& a, const Candidate& b){ return a.estObj < b.estObj; });\n pool.resize(keep);\n };\n auto addCand = [&](Candidate&& c){\n pool.push_back(std::move(c));\n if((int)pool.size() > 260) prune_pool(140);\n };\n\n // Baselines\n addCand(make_all_one_row(wp,hp,1));\n addCand(make_all_one_col(wp,hp,2));\n\n // Shelves (cheap insurance)\n {\n vector factors = {0.60L,0.75L,0.90L,1.00L,1.15L,1.35L,1.55L};\n uint64_t seedBase = 1234567;\n for(int fi=0; fi<(int)factors.size() && elapsed()(1, min(Wlim, sumW));\n addCand(make_row_shelf(wp,hp,Wlim,seedBase + 1000ULL*fi));\n }\n for(int fi=0; fi<(int)factors.size() && elapsed()(1, min(Hlim, sumH));\n addCand(make_col_shelf(wp,hp,Hlim,seedBase + 20000ULL + 1000ULL*fi));\n }\n }\n\n // Time-bounded generator (similar to best-performing approach)\n uint64_t seedGreedy = 700000;\n uint64_t seedBeam = 9000000;\n vector biasList = {0.25,0.32,0.40,0.50,0.60,0.68,0.75};\n int biasIdx = 0;\n\n while(elapsed() < GEN_LIMIT){\n double bl = biasList[biasIdx++ % (int)biasList.size()];\n\n // Greedy\n {\n int K = 10 + (biasIdx & 1); // 10/11\n int R = 2 + (biasIdx % 3 == 0); // 2/3\n addCand(make_greedy_mosaic(wp,hp, seedGreedy++, K, R, bl, \"greedy\"));\n }\n if(elapsed() >= GEN_LIMIT) break;\n\n // Beam\n {\n int B = 20 + (biasIdx % 4) * 4; // 20,24,28,32\n int K = 7 + (biasIdx % 3); // 7,8,9\n int R = 1;\n addCand(make_beam_mosaic(wp,hp, seedBeam++, B, K, R, bl, \"beam\"));\n }\n prune_pool(140);\n }\n\n sort(pool.begin(), pool.end(), [](const Candidate& a, const Candidate& b){\n return a.estObj < b.estObj;\n });\n\n // Add LNS repairs to top candidates, time-guarded\n RNG rrng(424242);\n int baseTop = min(12, (int)pool.size());\n vector pivots = {N/4, N/2, (3*N)/4};\n for(int k=0; k= REPAIR_LIMIT) break;\n double bl = biasList[rrng.next_int(0, (int)biasList.size()-1)];\n addCand(repair_suffix_greedy(pool[k], wp, hp, pv, rrng.next_u64(), 10, 2, bl, \"repair\"));\n }\n }\n\n sort(pool.begin(), pool.end(), [](const Candidate& a, const Candidate& b){\n return a.estObj < b.estObj;\n });\n\n // Output top candidates; repeat best measured after that.\n int KEEP = min(min(T, 90), (int)pool.size());\n pool.resize(KEEP);\n\n ll bestMeasured = (1LL<<62);\n int bestIdx = 0;\n\n for(int t=0;t> Wm >> Hm)) return 0;\n ll measured = Wm + Hm;\n if(measured < bestMeasured){\n bestMeasured = measured;\n bestIdx = useIdx;\n }\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nstatic inline uint32_t xorshift32(uint32_t &x) {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n}\nstatic inline double rand01(uint32_t &x) {\n return (double)xorshift32(x) / 4294967296.0;\n}\n\nstruct BFSResult { vector dist, prev; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n\n vector> edges(M);\n vector> g(N);\n g.assign(N, {});\n unordered_set edgeSet;\n edgeSet.reserve(M * 2);\n\n auto keyEdge = [&](int u, int v)->long long{\n if (u > v) swap(u, v);\n return (long long)u * N + v;\n };\n\n for (int i = 0; i < M; i++) {\n int u, v; cin >> u >> v;\n edges[i] = {u, v};\n g[u].push_back(v);\n g[v].push_back(u);\n edgeSet.insert(keyEdge(u, v));\n }\n for (int i = 0; i < N; i++) { int x, y; cin >> x >> y; } // unused\n\n auto multiSourceBFS = [&](const vector& roots)->BFSResult{\n const int INF = 1e9;\n BFSResult res;\n res.dist.assign(N, INF);\n res.prev.assign(N, -1);\n deque q;\n for (int r : roots) {\n res.dist[r] = 0;\n res.prev[r] = -1;\n q.push_back(r);\n }\n while (!q.empty()) {\n int v = q.front(); q.pop_front();\n int nd = res.dist[v] + 1;\n for (int to : g[v]) {\n if (res.dist[to] > nd) {\n res.dist[to] = nd;\n res.prev[to] = v;\n q.push_back(to);\n }\n }\n }\n return res;\n };\n\n // -----------------------\n // 1) Root selection to cover all vertices within distance <= H\n // -----------------------\n int root0 = (int)(min_element(A.begin(), A.end()) - A.begin());\n vector roots = {root0};\n\n while (true) {\n auto bfs = multiSourceBFS(roots);\n int far = -1, farD = -1;\n for (int i = 0; i < N; i++) if (bfs.dist[i] > farD) { farD = bfs.dist[i]; far = i; }\n if (farD <= H) break;\n\n int cur = far;\n int steps = farD - H;\n int child1 = -1, child2 = -1;\n for (int s = 0; s < steps; s++) {\n child2 = child1;\n child1 = cur;\n cur = bfs.prev[cur];\n if (cur == -1) break;\n }\n if (cur == -1) { roots.push_back(far); continue; }\n\n int best = cur;\n auto consider = [&](int v){\n if (v == -1) return;\n if (A[v] < A[best]) best = v;\n };\n consider(child1);\n consider(child2);\n roots.push_back(best);\n }\n\n // Remove redundant roots greedily\n {\n uint32_t rng = 123456789u;\n vector order = roots;\n for (int i = (int)order.size() - 1; i > 0; i--) {\n int j = (int)(xorshift32(rng) % (i + 1));\n swap(order[i], order[j]);\n }\n vector alive(N, 0);\n for (int r : roots) alive[r] = 1;\n\n for (int r : order) {\n if (!alive[r]) continue;\n vector tmp;\n for (int rr : roots) if (alive[rr] && rr != r) tmp.push_back(rr);\n if (tmp.empty()) continue;\n\n auto bfs = multiSourceBFS(tmp);\n int mx = 0;\n for (int i = 0; i < N; i++) mx = max(mx, bfs.dist[i]);\n if (mx <= H) alive[r] = 0;\n }\n vector nr;\n for (int r : roots) if (alive[r]) nr.push_back(r);\n roots.swap(nr);\n }\n\n // -----------------------\n // 2) Initial forest by BFS\n // -----------------------\n auto bfs = multiSourceBFS(roots);\n vector parent(N, -1), depth(N, 0);\n for (int v = 0; v < N; v++) {\n if (bfs.dist[v] <= H) {\n parent[v] = bfs.prev[v];\n depth[v] = bfs.dist[v];\n } else {\n parent[v] = -1;\n depth[v] = 0;\n }\n }\n\n // -----------------------\n // 3) Children structure with O(1) remove\n // -----------------------\n vector> children(N);\n vector idxInChild(N, -1);\n\n auto addChild = [&](int p, int v){\n idxInChild[v] = (int)children[p].size();\n children[p].push_back(v);\n };\n auto removeChild = [&](int p, int v){\n int idx = idxInChild[v];\n if (idx < 0) return;\n int last = children[p].back();\n children[p][idx] = last;\n idxInChild[last] = idx;\n children[p].pop_back();\n idxInChild[v] = -1;\n };\n auto rebuildChildren = [&](){\n children.assign(N, {});\n idxInChild.assign(N, -1);\n for (int v = 0; v < N; v++) if (parent[v] != -1) addChild(parent[v], v);\n };\n rebuildChildren();\n\n // subtree marking (for best-neighbor)\n vector mark(N, 0);\n int markToken = 1;\n vector st, sub;\n st.reserve(N);\n sub.reserve(N);\n\n auto collectSubtree = [&](int v, long long &sumA, int &maxD) {\n sumA = 0;\n maxD = -1;\n sub.clear();\n st.clear();\n st.push_back(v);\n markToken++;\n if (markToken == INT_MAX) { mark.assign(N, 0); markToken = 1; }\n while (!st.empty()) {\n int x = st.back(); st.pop_back();\n sub.push_back(x);\n mark[x] = markToken;\n sumA += A[x];\n maxD = max(maxD, depth[x]);\n for (int ch : children[x]) st.push_back(ch);\n }\n };\n\n auto acceptGain = [&](long long gain, double T, uint32_t &rng)->bool {\n if (gain >= 0) return true;\n double p = exp((double)gain / T);\n return rand01(rng) < p;\n };\n\n // -----------------------\n // 4) SA (single long run)\n // -----------------------\n uint32_t rng = 987654321u;\n auto start = chrono::steady_clock::now();\n auto elapsed = [&](){\n return chrono::duration(chrono::steady_clock::now() - start).count();\n };\n const double TL = 1.93;\n const double T0 = 20000.0;\n const double T1 = 50.0;\n\n auto pickVertexBiased = [&]()->int{\n int best = (int)(xorshift32(rng) % N);\n long long bestKey = 1LL * A[best] * (H - depth[best] + 1);\n for (int k = 0; k < 3; k++) {\n int v = (int)(xorshift32(rng) % N);\n long long key = 1LL * A[v] * (H - depth[v] + 1);\n if (key > bestKey) { bestKey = key; best = v; }\n }\n return best;\n };\n\n int it = 0;\n while (true) {\n if ((it & 2047) == 0) {\n if (elapsed() > TL) break;\n }\n it++;\n\n double prog = elapsed() / TL;\n if (prog > 1.0) prog = 1.0;\n double T = T0 * pow(T1 / T0, prog);\n\n int mode = (int)(xorshift32(rng) % 100);\n\n if (mode < 80) {\n int v = pickVertexBiased();\n\n long long sumA; int maxD;\n collectSubtree(v, sumA, maxD);\n\n int bestU = -2; // -1 cut, >=0 parent, -2 none\n int bestDelta = 0;\n long long bestGain = LLONG_MIN;\n\n if (parent[v] != -1) {\n int delta = -depth[v];\n long long gain = 1LL * delta * sumA;\n bestU = -1; bestDelta = delta; bestGain = gain;\n }\n\n for (int u : g[v]) {\n if (u == parent[v]) continue;\n if (mark[u] == markToken) continue; // cycle\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n int delta = newDepthV - depth[v];\n if (maxD + delta > H) continue;\n long long gain = 1LL * delta * sumA;\n if (gain > bestGain) {\n bestGain = gain;\n bestU = u;\n bestDelta = delta;\n }\n }\n if (bestU == -2) continue;\n\n if (rand01(rng) < 0.12) {\n vector> cand;\n cand.reserve(g[v].size() + 1);\n if (parent[v] != -1) cand.push_back({-1, -depth[v]});\n for (int u : g[v]) {\n if (u == parent[v]) continue;\n if (mark[u] == markToken) continue;\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n int delta = newDepthV - depth[v];\n if (maxD + delta > H) continue;\n cand.push_back({u, delta});\n }\n if (!cand.empty()) {\n auto [u, delta] = cand[xorshift32(rng) % cand.size()];\n bestU = u;\n bestDelta = delta;\n bestGain = 1LL * bestDelta * sumA;\n }\n }\n\n if (!acceptGain(bestGain, T, rng)) continue;\n\n int oldp = parent[v];\n if (oldp != -1) removeChild(oldp, v);\n if (bestU == -1) parent[v] = -1;\n else { parent[v] = bestU; addChild(bestU, v); }\n for (int x : sub) depth[x] += bestDelta;\n\n } else {\n auto [a, b] = edges[xorshift32(rng) % M];\n int u, v;\n if (xorshift32(rng) & 1) { u = a; v = b; }\n else { u = b; v = a; }\n\n if (u == v) continue;\n if (parent[v] == u) continue;\n\n bool cycle = false;\n int cur = u;\n for (int step = 0; step <= H && cur != -1; step++) {\n if (cur == v) { cycle = true; break; }\n cur = parent[cur];\n }\n if (cycle) continue;\n\n int newDepthV = depth[u] + 1;\n if (newDepthV > H) continue;\n int delta = newDepthV - depth[v];\n\n long long sumA; int maxD;\n collectSubtree(v, sumA, maxD);\n if (maxD + delta > H) continue;\n\n long long gain = 1LL * delta * sumA;\n if (!acceptGain(gain, T, rng)) continue;\n\n int oldp = parent[v];\n if (oldp != -1) removeChild(oldp, v);\n parent[v] = u;\n addChild(u, v);\n for (int x : sub) depth[x] += delta;\n }\n }\n\n // -----------------------\n // 5) One-pass conservative root-attach (only if depth[u] >= 2)\n // -----------------------\n auto findRoot = [&](int v)->int{\n while (parent[v] != -1) v = parent[v];\n return v;\n };\n\n vector rootsNow;\n rootsNow.reserve(N);\n for (int v = 0; v < N; v++) if (parent[v] == -1) rootsNow.push_back(v);\n\n struct Info { int r; long long sumA; int maxD; vector nodes; };\n vector infos;\n infos.reserve(rootsNow.size());\n\n for (int r : rootsNow) {\n Info info;\n info.r = r;\n info.sumA = 0;\n info.maxD = 0;\n info.nodes.clear();\n st.clear();\n st.push_back(r);\n while (!st.empty()) {\n int x = st.back(); st.pop_back();\n info.nodes.push_back(x);\n info.sumA += A[x];\n info.maxD = max(info.maxD, depth[x]);\n for (int ch : children[x]) st.push_back(ch);\n }\n infos.push_back(std::move(info));\n }\n\n // attach bigger trees first\n sort(infos.begin(), infos.end(), [&](const Info& a, const Info& b){\n return a.sumA > b.sumA;\n });\n\n for (auto &info : infos) {\n int r = info.r;\n if (parent[r] != -1) continue; // might have been attached already\n\n int bestU = -1;\n int bestDepthU = -1;\n\n for (int u : g[r]) {\n if (depth[u] < 2) continue; // conservative: delta >= 3\n int ru = findRoot(u);\n if (ru == r) continue; // same tree => cycle\n int delta = depth[u] + 1;\n if (info.maxD + delta > H) continue; // must fit\n if (depth[u] > bestDepthU) {\n bestDepthU = depth[u];\n bestU = u;\n }\n }\n if (bestU == -1) continue;\n\n int delta = depth[bestU] + 1;\n parent[r] = bestU;\n addChild(bestU, r);\n for (int x : info.nodes) depth[x] += delta;\n }\n\n // -----------------------\n // 6) Final legality + minimal fixing\n // -----------------------\n for (int v = 0; v < N; v++) {\n if (parent[v] != -1 && !edgeSet.count(keyEdge(v, parent[v]))) parent[v] = -1;\n }\n rebuildChildren();\n\n auto recomputeDepth = [&]()->vector{\n vector dep(N, -1);\n deque q;\n for (int v = 0; v < N; v++) if (parent[v] == -1) {\n dep[v] = 0;\n q.push_back(v);\n }\n while (!q.empty()) {\n int x = q.front(); q.pop_front();\n for (int ch : children[x]) {\n if (dep[ch] != -1) continue;\n dep[ch] = dep[x] + 1;\n q.push_back(ch);\n }\n }\n return dep;\n };\n\n for (int rep = 0; rep < 3; rep++) {\n auto dep = recomputeDepth();\n bool changed = false;\n for (int v = 0; v < N; v++) if (dep[v] == -1) { parent[v] = -1; changed = true; }\n if (!changed) break;\n rebuildChildren();\n }\n\n for (int rep = 0; rep < 4; rep++) {\n auto dep = recomputeDepth();\n bool changed = false;\n for (int v = 0; v < N; v++) if (dep[v] == H + 1) { parent[v] = -1; changed = true; }\n if (!changed) { depth.swap(dep); break; }\n rebuildChildren();\n }\n\n depth = recomputeDepth();\n for (int v = 0; v < N; v++) if (depth[v] < 0 || depth[v] > H) parent[v] = -1;\n\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << \"\\n\";\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstatic constexpr int NMAX = 20;\n\nstruct XorShift {\n uint64_t x=88172645463325252ull;\n explicit XorShift(uint64_t seed=0){\n if(seed) x ^= seed + 0x9e3779b97f4a7c15ull;\n }\n uint64_t next_u64(){\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int next_int(int n){ return (int)(next_u64() % (uint64_t)n); }\n};\n\nstruct Board {\n int N=0;\n array,NMAX> a{};\n int oniCnt=0;\n\n void init(int n, const vector& C){\n N=n; oniCnt=0;\n for(int i=0;i=1;j--) a[i][j]=a[i][j-1];\n a[i][0]='.';\n }\n void shiftColUp(int j){\n char removed = a[0][j];\n if(removed=='x') oniCnt--;\n for(int i=0;i=1;i--) a[i][j]=a[i-1][j];\n a[0][j]='.';\n }\n\n void applySingle(char dir, int p){\n if(dir=='L') shiftRowLeft(p);\n else if(dir=='R') shiftRowRight(p);\n else if(dir=='U') shiftColUp(p);\n else shiftColDown(p);\n }\n};\n\nstruct FlushCand {\n char dir;\n int p;\n int k;\n int gain;\n};\n\nstatic inline int safeEdgeScore(const Board& bd){\n int N = bd.N;\n int score = 0;\n for(int i=0;i0.\nstatic void collectFlushesFull(const Board& bd, vector& out){\n out.clear();\n int N = bd.N;\n\n for(int i=0;i0) out.push_back({'L', i, k, g});\n }\n g=0;\n int maxK = N-(last+1);\n for(int k=1;k<=maxK;k++){\n if(bd.a[i][N-k]=='x') g++;\n if(g>0) out.push_back({'R', i, k, g});\n }\n }\n\n for(int j=0;j0) out.push_back({'U', j, k, g});\n }\n g=0;\n int maxK = N-(last+1);\n for(int k=1;k<=maxK;k++){\n if(bd.a[N-k][j]=='x') g++;\n if(g>0) out.push_back({'D', j, k, g});\n }\n }\n}\n\nstatic inline void applyFlush(Board& bd, char dir, int p, int k,\n vector>* ops, int limit){\n for(int t=0;tsize() >= limit) return;\n if(ops) ops->push_back({dir,p});\n bd.applySingle(dir,p);\n }\n}\n\n// Baseline guaranteed reversible method (always safe from initial board).\nstatic vector> buildBaselineGuaranteed(int N, const vector& C){\n vector rowFirstF(N, N), rowLastF(N, -1);\n vector colFirstF(N, N), colLastF(N, -1);\n vector> oni;\n\n for(int i=0;i> ops;\n ops.reserve(1600);\n for(auto [i,j] : oni){\n if(rowFirstF[i] > j){\n int k=j+1;\n for(int t=0;t i){\n int k=i+1;\n for(int t=0;t 4*N*N) return {};\n return ops;\n}\n\n// Cheap rollout step.\nstatic int greedyStep(Board& bd, XorShift& rng, int remainingMoves){\n if(remainingMoves <= 0) return 0;\n\n vector flushes;\n collectFlushesFull(bd, flushes);\n if(!flushes.empty()){\n int best = 0;\n for(int i=1;i<(int)flushes.size(); i++){\n const auto& a = flushes[i];\n const auto& b = flushes[best];\n long long lhs = 1LL*a.gain*b.k;\n long long rhs = 1LL*b.gain*a.k;\n if(lhs != rhs) { if(lhs > rhs) best = i; }\n else if(a.gain != b.gain) { if(a.gain > b.gain) best = i; }\n else if(a.k != b.k) { if(a.k < b.k) best = i; }\n else if(rng.next_int(6)==0) best = i;\n }\n int k = min(flushes[best].k, remainingMoves);\n applyFlush(bd, flushes[best].dir, flushes[best].p, k, nullptr, 0);\n return k;\n }\n\n // rearrangement single\n int N = bd.N;\n char bestD = 0; int bestP = -1;\n long long bestV = LLONG_MIN;\n for(int p=0;p bestV){\n bestV = v; bestD = d; bestP = p;\n }\n }\n }\n if(bestP==-1) return 0;\n bd.applySingle(bestD, bestP);\n return 1;\n}\n\nstatic long long rolloutValue(const Board& start, int maxMoves, XorShift& rng){\n Board bd = start;\n int startOni = bd.oniCnt;\n int used = 0;\n while(used < maxMoves && bd.oniCnt > 0){\n int c = greedyStep(bd, rng, maxMoves - used);\n if(c<=0) break;\n used += c;\n }\n int removed = startOni - bd.oniCnt;\n\n int safe = safeEdgeScore(bd);\n int nextG = bestFlushGain(bd);\n int edgeF = edgeFukuCount(bd);\n int legal = legalMoveCount(bd);\n\n long long v = 0;\n v += 30000LL * removed;\n v -= 800LL * used;\n v -= 20000LL * bd.oniCnt;\n v += 15LL * safe;\n v += 6000LL * nextG;\n v -= 150LL * edgeF;\n v += 8LL * legal;\n return v;\n}\n\nstruct HeuParams {\n bool enable2 = false;\n int Kflush = 10;\n int L1 = 12, L2 = 6;\n int rollFlushBase = 18;\n int rollRearrBase = 16;\n int margin2 = 80;\n};\n\nstatic vector> runHeuristic(const vector& C, uint64_t seed,\n chrono::high_resolution_clock::time_point startAll,\n double timeLimitSec,\n const HeuParams& P,\n int bestHeuLen){\n const int N = (int)C.size();\n const int LIMIT = 4*N*N;\n XorShift rng(seed);\n\n auto time_ok = [&](){\n double t = chrono::duration(chrono::high_resolution_clock::now() - startAll).count();\n return t < timeLimitSec;\n };\n\n Board bd;\n bd.init(N, C);\n vector> ops;\n ops.reserve(LIMIT);\n\n vector flushes;\n int stagnant = 0;\n\n while(bd.oniCnt > 0 && (int)ops.size() < LIMIT && time_ok()){\n if(bestHeuLen >= 0 && (int)ops.size() >= bestHeuLen) return {}; // prune bad runs\n\n collectFlushesFull(bd, flushes);\n if(!flushes.empty()){\n sort(flushes.begin(), flushes.end(), [&](const FlushCand& a, const FlushCand& b){\n long long lhs = 1LL*a.gain*b.k;\n long long rhs = 1LL*b.gain*a.k;\n if(lhs != rhs) return lhs > rhs;\n if(a.gain != b.gain) return a.gain > b.gain;\n return a.k < b.k;\n });\n\n int K = min(P.Kflush, flushes.size());\n int maxRoll = P.rollFlushBase + bd.oniCnt/2;\n maxRoll = min(maxRoll, 36);\n\n long long bestV = LLONG_MIN;\n FlushCand best = flushes[0];\n\n int baseSafe = safeEdgeScore(bd);\n int baseEdgeF = edgeFukuCount(bd);\n\n for(int i=0;i bestV || (v==bestV && c.k < best.k)){\n bestV = v;\n best = c;\n }\n }\n\n applyFlush(bd, best.dir, best.p, best.k, &ops, LIMIT);\n stagnant = 0;\n continue;\n }\n\n // rearrangement\n struct M1 { char d; int p; long long quick; Board after; int afterBestG; };\n vector ms;\n ms.reserve(80);\n\n int baseSafe = safeEdgeScore(bd);\n int baseEdgeF = edgeFukuCount(bd);\n\n for(int p=0;p b.quick; });\n\n int L1 = min(P.L1, ms.size());\n int maxRoll1 = P.rollRearrBase + bd.oniCnt/3;\n maxRoll1 = min(maxRoll1, 28);\n\n long long best1V = LLONG_MIN;\n int best1Idx = 0;\n for(int i=0;i best1V){\n best1V = v;\n best1Idx = i;\n }\n }\n\n bool allow2 = P.enable2 && (stagnant >= 2) && (ms[best1Idx].afterBestG < 2);\n {\n double t = chrono::duration(chrono::high_resolution_clock::now() - startAll).count();\n if(t > timeLimitSec * 0.93) allow2 = false;\n }\n\n if(allow2){\n long long bestPairV = best1V;\n int bestI = -1; char bestD2 = 0; int bestP2 = -1;\n\n int L1b = min(6, L1);\n int L2 = P.L2;\n int maxRoll2 = (P.rollRearrBase - 2) + bd.oniCnt/5;\n maxRoll2 = min(maxRoll2, 20);\n\n for(int i=0;i cand2; cand2.reserve(80);\n\n int baseSafe1 = safeEdgeScore(t1);\n int baseEdgeF1 = edgeFukuCount(t1);\n\n for(int p=0;p(L2, cand2.size());\n nth_element(cand2.begin(), cand2.begin()+take, cand2.end(),\n [](const S2& a, const S2& b){ return a.q > b.q; });\n cand2.resize(take);\n\n for(auto &c2 : cand2){\n long long v = ms[i].quick + c2.q + rolloutValue(c2.after, maxRoll2, rng) - 800;\n if(v > bestPairV){\n bestPairV = v;\n bestI = i; bestD2 = c2.d; bestP2 = c2.p;\n }\n }\n }\n\n if(bestI != -1 && bestPairV > best1V + P.margin2){\n ops.push_back({ms[bestI].d, ms[bestI].p});\n bd.applySingle(ms[bestI].d, ms[bestI].p);\n if((int)ops.size() < LIMIT && bd.legalSingle(bestD2, bestP2)){\n ops.push_back({bestD2, bestP2});\n bd.applySingle(bestD2, bestP2);\n }\n stagnant++;\n if(stagnant > 650) break;\n continue;\n }\n }\n\n ops.push_back({ms[best1Idx].d, ms[best1Idx].p});\n bd.applySingle(ms[best1Idx].d, ms[best1Idx].p);\n stagnant++;\n if(stagnant > 650) break;\n }\n\n if(bd.oniCnt == 0) return ops;\n return {};\n}\n\n// ---- Post optimization: validate and try deletions ----\nstatic bool validateOps(const vector& C, const vector>& ops){\n Board bd;\n bd.init((int)C.size(), C);\n int N = bd.N;\n for(auto [d,p] : ops){\n // must not eject o\n if(d=='L'){ if(bd.a[p][0]=='o') return false; }\n else if(d=='R'){ if(bd.a[p][N-1]=='o') return false; }\n else if(d=='U'){ if(bd.a[0][p]=='o') return false; }\n else { if(bd.a[N-1][p]=='o') return false; }\n bd.applySingle(d,p);\n }\n return bd.oniCnt==0;\n}\n\nstatic void postOptimize(const vector& C,\n vector>& ops,\n chrono::high_resolution_clock::time_point startAll,\n double timeLimitSec){\n auto time_ok = [&](){\n double t = chrono::duration(chrono::high_resolution_clock::now() - startAll).count();\n return t < timeLimitSec;\n };\n if(ops.empty()) return;\n if(!validateOps(C, ops)) return;\n\n // 1) shorten runs by trimming from the end\n for(int i=0; i<(int)ops.size() && time_ok(); ){\n int j=i+1;\n while(j<(int)ops.size() && ops[j]==ops[i]) j++;\n // try trimming tail of [i,j)\n while(j-i>=2 && time_ok()){\n auto cand = ops;\n cand.erase(cand.begin() + (j-1));\n if(validateOps(C, cand)){\n ops.swap(cand);\n j--; // run shortened\n }else break;\n }\n i = j;\n }\n\n // 2) try removing single operations (limited)\n int attempts = 0;\n for(int i=0; i<(int)ops.size() && time_ok(); i++){\n if(attempts >= 200) break;\n attempts++;\n auto cand = ops;\n cand.erase(cand.begin() + i);\n if(validateOps(C, cand)){\n ops.swap(cand);\n i = max(-1, i-2); // re-check around\n }\n }\n}\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector C(N);\n for(int i=0;i> C[i];\n\n const int LIMIT = 4*N*N;\n auto baseline = buildBaselineGuaranteed(N, C);\n\n auto startAll = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 1.90;\n\n uint64_t baseSeed = chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift master(baseSeed);\n\n vector> bestHeuOps;\n int bestHeuLen = -1;\n\n auto elapsed = [&](){\n return chrono::duration(chrono::high_resolution_clock::now() - startAll).count();\n };\n\n HeuParams fast;\n fast.enable2 = false;\n fast.Kflush = 8;\n fast.L1 = 10; fast.L2 = 5;\n fast.rollFlushBase = 14;\n fast.rollRearrBase = 12;\n\n HeuParams heavy;\n heavy.enable2 = true;\n heavy.Kflush = 10;\n heavy.L1 = 12; heavy.L2 = 6;\n heavy.rollFlushBase = 18;\n heavy.rollRearrBase = 16;\n heavy.margin2 = 80;\n\n // Phase A\n while(elapsed() < TIME_LIMIT * 0.70){\n uint64_t seed = master.next_u64();\n auto ops = runHeuristic(C, seed, startAll, TIME_LIMIT, fast, bestHeuLen);\n if(!ops.empty() && (bestHeuLen < 0 || (int)ops.size() < bestHeuLen)){\n bestHeuLen = (int)ops.size();\n bestHeuOps = std::move(ops);\n if(bestHeuLen <= 104) break;\n }\n }\n // Phase B\n while(elapsed() < TIME_LIMIT * 0.92){\n uint64_t seed = master.next_u64();\n auto ops = runHeuristic(C, seed, startAll, TIME_LIMIT, heavy, bestHeuLen);\n if(!ops.empty() && (bestHeuLen < 0 || (int)ops.size() < bestHeuLen)){\n bestHeuLen = (int)ops.size();\n bestHeuOps = std::move(ops);\n if(bestHeuLen <= 103) break;\n }\n }\n\n // Post-optimize best heuristic using remaining time\n if(bestHeuLen >= 0 && elapsed() < TIME_LIMIT){\n postOptimize(C, bestHeuOps, startAll, TIME_LIMIT);\n bestHeuLen = (int)bestHeuOps.size();\n }\n\n // Choose output between heuristic and baseline\n vector> out;\n if(bestHeuLen >= 0) out = bestHeuOps;\n else out = baseline;\n if(!baseline.empty() && (int)out.size() > (int)baseline.size()) out = baseline;\n if(out.empty() || (int)out.size() > LIMIT) out = baseline;\n\n for(auto [d,p] : out) cout << d << \" \" << p << \"\\n\";\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint64_t next_u64() { x ^= x << 7; x ^= x >> 9; return x; }\n int next_int(int lo, int hi) { return lo + (int)(next_u64() % (uint64_t)(hi - lo + 1)); }\n double next_double() { return (next_u64() >> 11) * (1.0 / 9007199254740992.0); } // [0,1)\n};\n\nstatic constexpr int NMAX = 100;\n\nstatic inline long long simulate_plan(int N, int L,\n const int a[NMAX], const int b[NMAX],\n const int target[NMAX],\n int outCnt[NMAX]) {\n for (int i = 0; i < N; i++) outCnt[i] = 0;\n int x = 0;\n outCnt[x] = 1;\n for (int step = 1; step < L; step++) {\n int nx = (outCnt[x] & 1) ? a[x] : b[x];\n x = nx;\n outCnt[x]++;\n }\n long long err = 0;\n for (int i = 0; i < N; i++) err += llabs((long long)outCnt[i] - (long long)target[i]);\n return err;\n}\n\n// Project D to integer Dem: Dem[j] >= 0, sum(Dem)=L, close to D\nstatic vector project_to_simplex_nonneg_sumL(const vector& D, long long L) {\n int N = (int)D.size();\n auto sum_pos = [&](double lambda) -> double {\n double s = 0;\n for (auto v : D) {\n double x = (double)v - lambda;\n if (x > 0) s += x;\n }\n return s;\n };\n\n double lo = 0.0, hi = 0.0;\n for (auto v : D) hi = max(hi, (double)v);\n for (int it = 0; it < 80; it++) {\n double mid = (lo + hi) * 0.5;\n if (sum_pos(mid) > (double)L) lo = mid;\n else hi = mid;\n }\n double lambda = hi;\n\n vector Dem(N, 0);\n vector frac(N, 0.0);\n long long sInt = 0;\n for (int i = 0; i < N; i++) {\n double x = (double)D[i] - lambda;\n if (x < 0) x = 0;\n long long f = (long long)floor(x);\n Dem[i] = f;\n sInt += f;\n frac[i] = x - (double)f;\n }\n long long rem = L - sInt;\n vector idx(N);\n iota(idx.begin(), idx.end(), 0);\n\n if (rem > 0) {\n sort(idx.begin(), idx.end(), [&](int i, int j){\n if (frac[i] != frac[j]) return frac[i] > frac[j];\n return i < j;\n });\n for (int k = 0; k < N && rem > 0; k++, rem--) Dem[idx[k]]++;\n } else if (rem < 0) {\n sort(idx.begin(), idx.end(), [&](int i, int j){\n if (frac[i] != frac[j]) return frac[i] < frac[j];\n return i < j;\n });\n long long need = -rem;\n for (int k = 0; k < N && need > 0; k++) {\n int i = idx[k];\n if (Dem[i] > 0) { Dem[i]--; need--; }\n }\n }\n return Dem;\n}\n\n// Start-aware proportional target for prefix length Ls.\nstatic array make_prefix_target_startaware(const int T[NMAX], int N, int L, int Ls) {\n array Ts{};\n if (Ls <= 0) return Ts;\n if (Ls == 1) { Ts[0] = 1; return Ts; }\n\n int Lp = Ls - 1;\n long long sum = 0;\n vector> frac;\n frac.reserve(N);\n\n for (int i = 0; i < N; i++) {\n long long v = (long long)T[i] * (long long)Lp;\n int x = (int)(v / L);\n Ts[i] = x;\n sum += x;\n frac.push_back({v % L, i});\n }\n\n int rem = Lp - (int)sum;\n sort(frac.begin(), frac.end(), [&](auto &a, auto &b){\n if (a.first != b.first) return a.first > b.first;\n return a.second < b.second;\n });\n for (int k = 0; k < N && rem > 0; k++, rem--) Ts[frac[k].second]++;\n\n Ts[0] += 1;\n return Ts;\n}\n\n// Optimizer for mapping x[i] using weights T[i] into bins, target Dem[bin].\nstruct FastAssignOptimizer {\n int N;\n const int *T;\n const long long *Dem;\n XorShift64 *rng;\n\n vector x;\n array binSum{};\n long long cost = (1LL<<62);\n\n static inline long long absll(long long v){ return v<0?-v:v; }\n\n long long compute_cost() const {\n long long c = 0;\n for (int j = 0; j < N; j++) c += absll(binSum[j] - Dem[j]);\n return c;\n }\n\n void greedy_init_sampled() {\n x.assign(N, 0);\n for (int j = 0; j < N; j++) binSum[j] = 0;\n\n vector items(N);\n iota(items.begin(), items.end(), 0);\n stable_sort(items.begin(), items.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] > T[j];\n return i < j;\n });\n\n for (int idx = 0; idx < N; idx++) {\n int i = items[idx];\n long long w = T[i];\n\n int bestJ = rng->next_int(0, N - 1);\n long long bestVal = llabs((binSum[bestJ] + w) - Dem[bestJ]);\n\n for (int s = 0; s < 12; s++) {\n int j = rng->next_int(0, N - 1);\n long long v = llabs((binSum[j] + w) - Dem[j]);\n if (v < bestVal) { bestVal = v; bestJ = j; }\n }\n if (rng->next_double() < 0.25) {\n for (int j = 0; j < N; j++) {\n long long v = llabs((binSum[j] + w) - Dem[j]);\n if (v < bestVal) { bestVal = v; bestJ = j; }\n }\n }\n\n x[i] = bestJ;\n binSum[bestJ] += w;\n }\n cost = compute_cost();\n }\n\n void run_sa(int iterations, double t0, double t1) {\n vector heavy(N);\n iota(heavy.begin(), heavy.end(), 0);\n stable_sort(heavy.begin(), heavy.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] > T[j];\n return i < j;\n });\n int Kheavy = min(N, 35);\n\n auto part_cost = [&](int j)->long long { return llabs(binSum[j] - Dem[j]); };\n\n for (int it = 0; it < iterations; it++) {\n double prog = (double)it / max(1, iterations - 1);\n double temp = t0 * pow(t1 / t0, prog);\n\n bool doSwap = (rng->next_double() < 0.30);\n\n if (!doSwap) {\n int i = heavy[rng->next_int(0, Kheavy - 1)];\n long long w = T[i];\n if (w == 0) continue;\n\n int from = x[i];\n int to = from;\n\n long long bestNeed = LLONG_MIN;\n for (int s = 0; s < 10; s++) {\n int j = rng->next_int(0, N - 1);\n long long need = Dem[j] - binSum[j];\n if (need > bestNeed) { bestNeed = need; to = j; }\n }\n if (to == from) continue;\n\n long long oldPart = part_cost(from) + part_cost(to);\n long long newFromSum = binSum[from] - w;\n long long newToSum = binSum[to] + w;\n long long newPart = llabs(newFromSum - Dem[from]) + llabs(newToSum - Dem[to]);\n long long newCost = cost + (newPart - oldPart);\n\n bool accept = false;\n if (newCost <= cost) accept = true;\n else {\n double xprob = (double)(cost - newCost) / temp;\n if (xprob > -50.0 && rng->next_double() < exp(xprob)) accept = true;\n }\n if (accept) {\n x[i] = to;\n binSum[from] -= w;\n binSum[to] += w;\n cost = newCost;\n }\n } else {\n int i = heavy[rng->next_int(0, Kheavy - 1)];\n int k = heavy[rng->next_int(0, Kheavy - 1)];\n if (i == k) continue;\n\n int bi = x[i], bk = x[k];\n if (bi == bk) continue;\n\n long long wi = T[i], wk = T[k];\n long long oldPart = part_cost(bi) + part_cost(bk);\n\n long long newBiSum = binSum[bi] - wi + wk;\n long long newBkSum = binSum[bk] - wk + wi;\n long long newPart = llabs(newBiSum - Dem[bi]) + llabs(newBkSum - Dem[bk]);\n long long newCost = cost + (newPart - oldPart);\n\n bool accept = false;\n if (newCost <= cost) accept = true;\n else {\n double xprob = (double)(cost - newCost) / temp;\n if (xprob > -50.0 && rng->next_double() < exp(xprob)) accept = true;\n }\n if (accept) {\n x[i] = bk; x[k] = bi;\n binSum[bi] = newBiSum;\n binSum[bk] = newBkSum;\n cost = newCost;\n }\n }\n }\n }\n};\n\nstatic void build_cycle_from_order(const vector& order, int succ[NMAX], int pred[NMAX]) {\n int N = (int)order.size();\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n succ[u] = v;\n pred[v] = u;\n }\n}\n\nstatic vector make_pendulum(const vector& sorted) {\n int N = (int)sorted.size();\n vector ord;\n ord.reserve(N);\n for (int i = 0; i < N; i += 2) ord.push_back(sorted[i]);\n int start = (N % 2 == 0 ? N - 1 : N - 2);\n for (int i = start; i >= 1; i -= 2) ord.push_back(sorted[i]);\n return ord;\n}\n\nstatic vector make_nearest_by_T(int N, const int T[NMAX], XorShift64 &rng, int start) {\n vector ord;\n ord.reserve(N);\n vector used(N, 0);\n int cur = start;\n ord.push_back(cur);\n used[cur] = 1;\n for (int step = 1; step < N; step++) {\n vector> cand;\n cand.reserve(N);\n for (int j = 0; j < N; j++) if (!used[j]) cand.emplace_back(abs(T[j] - T[cur]), j);\n int take = min(6, (int)cand.size());\n nth_element(cand.begin(), cand.begin() + take - 1, cand.end());\n int pick = rng.next_int(0, take - 1);\n int nxt = cand[pick].second;\n ord.push_back(nxt);\n used[nxt] = 1;\n cur = nxt;\n }\n return ord;\n}\n\n// Conservative cycle cost and local improvement\nstatic long long cycle_cost(const vector& order, const int T[NMAX]) {\n int N = (int)order.size();\n long long neg = 0, diff = 0;\n for (int k = 0; k < N; k++) {\n int cur = order[k];\n int prv = order[(k - 1 + N) % N];\n long long bad = (long long)T[prv] - 2LL * T[cur];\n if (bad > 0) neg += bad;\n diff += llabs((long long)T[prv] - (long long)T[cur]);\n }\n return neg * 1000LL + diff;\n}\nstatic void improve_cycle_locally(vector& order, const int T[NMAX], XorShift64& rng) {\n long long best = cycle_cost(order, T);\n for (int it = 0; it < 260; it++) {\n int i = rng.next_int(0, (int)order.size() - 1);\n int j = rng.next_int(0, (int)order.size() - 1);\n if (i == j) continue;\n swap(order[i], order[j]);\n long long c = cycle_cost(order, T);\n if (c <= best) best = c;\n else swap(order[i], order[j]);\n }\n}\n\nstruct Candidate {\n array a, b;\n bool a_fixed;\n long long shortErr;\n long long fullErr;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, L;\n cin >> N >> L;\n static int T[NMAX];\n for (int i = 0; i < N; i++) cin >> T[i];\n\n uint64_t seed = (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count();\n XorShift64 rng(seed);\n\n auto tStart = chrono::high_resolution_clock::now();\n const double TL = 1.90;\n const double TL_CAND = 1.65;\n\n const int LsCand = 50000;\n const int LsSA = 40000;\n const int KEEP_K = 14;\n\n array TsCand = make_prefix_target_startaware(T, N, L, LsCand);\n array TsSA = make_prefix_target_startaware(T, N, L, LsSA);\n\n static int cnt_short[NMAX], cnt_full[NMAX], cnt_state[NMAX], cnt_tmp2[NMAX];\n\n // base orders\n vector asc(N);\n iota(asc.begin(), asc.end(), 0);\n stable_sort(asc.begin(), asc.end(), [&](int i, int j){\n if (T[i] != T[j]) return T[i] < T[j];\n return i < j;\n });\n vector desc = asc;\n reverse(desc.begin(), desc.end());\n vector pend = make_pendulum(asc);\n vector pend2 = make_pendulum(desc);\n\n auto perturb = [&](const vector& base, int swaps)->vector {\n vector o = base;\n for (int s = 0; s < swaps; s++) {\n int i = rng.next_int(0, N - 1);\n int j = rng.next_int(0, N - 1);\n swap(o[i], o[j]);\n }\n return o;\n };\n auto block_shuffle = [&](const vector& base)->vector {\n int B = 5;\n vector> blocks(B);\n for (int i = 0; i < N; i++) blocks[i % B].push_back(base[i]);\n vector perm(B);\n iota(perm.begin(), perm.end(), 0);\n for (int i = 0; i < B; i++) swap(perm[i], perm[rng.next_int(0, B - 1)]);\n vector res; res.reserve(N);\n for (int k = 0; k < B; k++) for (int v : blocks[perm[k]]) res.push_back(v);\n return res;\n };\n auto random_perm = [&]()->vector {\n vector r(N);\n iota(r.begin(), r.end(), 0);\n for (int i = 0; i < N; i++) swap(r[i], r[rng.next_int(0, N - 1)]);\n return r;\n };\n\n // keep top-K by shortErr\n auto worseFirst = [&](const Candidate& x, const Candidate& y){ return x.shortErr < y.shortErr; };\n priority_queue, decltype(worseFirst)> pq(worseFirst);\n\n auto push_candidate = [&](const array& a, const array& b, bool a_fixed) {\n Candidate c;\n c.a = a; c.b = b; c.a_fixed = a_fixed;\n c.shortErr = simulate_plan(N, LsCand, a.data(), b.data(), TsCand.data(), cnt_short);\n c.fullErr = (1LL<<62);\n if ((int)pq.size() < KEEP_K) pq.push(c);\n else if (c.shortErr < pq.top().shortErr) { pq.pop(); pq.push(c); }\n };\n\n auto eval_fixed_cycle = [&](vector cycOrder, bool fixA) {\n improve_cycle_locally(cycOrder, T, rng);\n\n int fixedSucc[NMAX], fixedPred[NMAX];\n for (int i = 0; i < N; i++) fixedSucc[i] = fixedPred[i] = i;\n build_cycle_from_order(cycOrder, fixedSucc, fixedPred);\n\n vector D(N);\n for (int j = 0; j < N; j++) D[j] = 2LL * T[j] - (long long)T[fixedPred[j]];\n vector Dem = project_to_simplex_nonneg_sumL(D, (long long)L);\n\n for (int r = 0; r < 2; r++) {\n FastAssignOptimizer opt;\n opt.N = N;\n opt.T = T;\n opt.Dem = Dem.data();\n opt.rng = &rng;\n opt.greedy_init_sampled();\n int iters = (r == 0 ? 120000 : 85000);\n opt.run_sa(iters, 9000.0, 4.0);\n\n array a, b;\n if (fixA) {\n for (int i = 0; i < N; i++) a[i] = fixedSucc[i];\n for (int i = 0; i < N; i++) b[i] = opt.x[i];\n } else {\n for (int i = 0; i < N; i++) b[i] = fixedSucc[i];\n for (int i = 0; i < N; i++) a[i] = opt.x[i];\n }\n push_candidate(a, b, fixA);\n }\n };\n\n // ---- Candidate exploration loop ----\n int it = 0;\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - tStart).count();\n if (elapsed > TL_CAND) break;\n\n vector ord;\n if (it == 0) ord = asc;\n else if (it == 1) ord = desc;\n else if (it == 2) ord = pend;\n else if (it == 3) ord = pend2;\n else if (it == 4) ord = make_nearest_by_T(N, T, rng, 0);\n else {\n int typ = rng.next_int(0, 6);\n if (typ == 0) ord = perturb(asc, 3 + rng.next_int(0, 6));\n else if (typ == 1) ord = perturb(desc, 3 + rng.next_int(0, 6));\n else if (typ == 2) ord = block_shuffle(asc);\n else if (typ == 3) ord = block_shuffle(desc);\n else if (typ == 4) ord = make_nearest_by_T(N, T, rng, rng.next_int(0, N - 1));\n else ord = random_perm();\n }\n\n eval_fixed_cycle(ord, true);\n eval_fixed_cycle(ord, false);\n it++;\n }\n\n // Full evaluate kept candidates\n vector kept;\n while (!pq.empty()) { kept.push_back(pq.top()); pq.pop(); }\n reverse(kept.begin(), kept.end());\n\n Candidate best;\n best.fullErr = (1LL<<62);\n for (auto &c : kept) {\n c.fullErr = simulate_plan(N, L, c.a.data(), c.b.data(), T, cnt_full);\n if (c.fullErr < best.fullErr) best = c;\n }\n\n // ---- Final SA: two-stage filter; pick i by surplus and j by deficit ----\n array a_cur = best.a;\n array b_cur = best.b;\n array a_best = best.a;\n array b_best = best.b;\n\n long long err_cur = simulate_plan(N, L, a_cur.data(), b_cur.data(), T, cnt_state);\n long long err_best = err_cur;\n long long errS_cur = simulate_plan(N, LsSA, a_cur.data(), b_cur.data(), TsSA.data(), cnt_short);\n\n auto tMid = chrono::high_resolution_clock::now();\n double elapsed0 = chrono::duration(tMid - tStart).count();\n double remTime = max(1e-9, TL - elapsed0);\n\n array idxSur, idxDef;\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - tStart).count();\n if (elapsed > TL) break;\n double prog = (elapsed - elapsed0) / remTime;\n prog = min(1.0, max(0.0, prog));\n\n double tempS = 650.0 * pow(5.0 / 650.0, prog);\n double temp = 750.0 * pow(6.0 / 750.0, prog);\n\n // build surplus list and deficit list (N=100 is cheap)\n for (int i = 0; i < N; i++) { idxSur[i] = i; idxDef[i] = i; }\n int K = 30;\n nth_element(idxSur.begin(), idxSur.begin() + K, idxSur.end(),\n [&](int i, int j){ return (cnt_state[i] - T[i]) > (cnt_state[j] - T[j]); });\n nth_element(idxDef.begin(), idxDef.begin() + K, idxDef.end(),\n [&](int i, int j){ return (T[i] - cnt_state[i]) > (T[j] - cnt_state[j]); });\n\n double r = rng.next_double();\n int moveType = (r < 0.55) ? 0 : (r < 0.90 ? 1 : 2); // 0 single, 1 swap, 2 3-cycle(rare)\n\n auto &X = best.a_fixed ? b_cur : a_cur;\n\n int i1=-1,i2=-1,i3=-1;\n int old1=-1,old2=-1,old3=-1;\n\n if (moveType == 0) {\n i1 = idxSur[rng.next_int(0, K - 1)];\n old1 = X[i1];\n int j = idxDef[rng.next_int(0, K - 1)];\n if (j == old1) continue;\n X[i1] = j;\n } else if (moveType == 1) {\n i1 = idxSur[rng.next_int(0, K - 1)];\n i2 = idxSur[rng.next_int(0, K - 1)];\n if (i1 == i2) continue;\n old1 = X[i1]; old2 = X[i2];\n if (old1 == old2) continue;\n swap(X[i1], X[i2]);\n } else {\n i1 = idxSur[rng.next_int(0, K - 1)];\n i2 = idxSur[rng.next_int(0, K - 1)];\n i3 = idxSur[rng.next_int(0, K - 1)];\n if (i1 == i2 || i2 == i3 || i1 == i3) continue;\n old1 = X[i1]; old2 = X[i2]; old3 = X[i3];\n if (old1 == old2 && old2 == old3) continue;\n // rotate\n X[i2] = old1;\n X[i3] = old2;\n X[i1] = old3;\n }\n\n // stage 1: short eval\n long long errS_new = simulate_plan(N, LsSA, a_cur.data(), b_cur.data(), TsSA.data(), cnt_short);\n bool acceptS = false;\n if (errS_new <= errS_cur) acceptS = true;\n else {\n double xprob = (double)(errS_cur - errS_new) / tempS;\n if (xprob > -50.0 && rng.next_double() < exp(xprob)) acceptS = true;\n }\n if (!acceptS) {\n if (moveType == 0) X[i1] = old1;\n else if (moveType == 1) { X[i1] = old1; X[i2] = old2; }\n else { X[i1] = old1; X[i2] = old2; X[i3] = old3; }\n continue;\n }\n\n // stage 2: full eval\n long long err_new = simulate_plan(N, L, a_cur.data(), b_cur.data(), T, cnt_tmp2);\n bool accept = false;\n if (err_new <= err_cur) accept = true;\n else {\n double xprob = (double)(err_cur - err_new) / temp;\n if (xprob > -50.0 && rng.next_double() < exp(xprob)) accept = true;\n }\n\n if (accept) {\n err_cur = err_new;\n errS_cur = errS_new;\n for (int k2 = 0; k2 < N; k2++) cnt_state[k2] = cnt_tmp2[k2];\n if (err_cur < err_best) {\n err_best = err_cur;\n a_best = a_cur;\n b_best = b_cur;\n }\n } else {\n if (moveType == 0) X[i1] = old1;\n else if (moveType == 1) { X[i1] = old1; X[i2] = old2; }\n else { X[i1] = old1; X[i2] = old2; X[i3] = old3; }\n }\n }\n\n for (int i = 0; i < N; i++) {\n cout << a_best[i] << ' ' << b_best[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nstruct DSU {\n int n;\n vector p, r;\n DSU(int n=0){ init(n); }\n void init(int n_) {\n n = n_;\n p.resize(n);\n r.assign(n,0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int a){ return p[a]==a?a:p[a]=find(p[a]);}\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a] 0; s /= 2) {\n int rx = (x & s) ? 1 : 0;\n int ry = (y & s) ? 1 : 0;\n d += (uint32_t)s * (uint32_t)s * (uint32_t)((3 * rx) ^ ry);\n rot(s, x, y, rx, ry);\n }\n return d;\n}\n\nstatic inline long long dist2_center(int ax, int ay, int bx, int by){\n long long dx = ax - bx;\n long long dy = ay - by;\n return dx*dx + dy*dy;\n}\n\n// splitmix64 deterministic RNG (only for greedy tie-break)\nstatic inline uint64_t splitmix64(uint64_t &x) {\n uint64_t z = (x += 0x9e3779b97f4a7c15ULL);\n z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;\n z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;\n return z ^ (z >> 31);\n}\n\nstruct GroupInfo {\n vector nodes;\n bool exactKnown = false;\n vector> exactEdges;\n vector> queryEdges;\n};\n\nstatic pair, long long> build_groups_greedy_chainScore(\n const vector& order,\n const vector& ex,\n const vector& ey,\n const vector& G,\n uint64_t *rnd // nullable\n){\n const int N = (int)order.size();\n const int M = (int)G.size();\n\n vector pref(N, 0);\n for(int i=0;i+1long long{\n if(s<=1) return 0LL;\n return pref[p+s-1] - pref[p];\n };\n\n map cnt;\n for(int x: G) cnt[x]++;\n\n auto pop_size = [&](int s){\n auto it = cnt.find(s);\n if(it==cnt.end()) return false;\n if(--it->second==0) cnt.erase(it);\n return true;\n };\n\n auto collect_candidates = [&](int nrem, int grem)->vector{\n vector cands;\n cands.reserve(32);\n\n for(auto it = cnt.begin(); it != cnt.end() && (int)cands.size() < 6; ++it)\n if(it->first <= nrem) cands.push_back(it->first);\n\n int added = 0;\n for(auto it = cnt.rbegin(); it != cnt.rend() && added < 4; ++it){\n if(it->first <= nrem) { cands.push_back(it->first); added++; }\n }\n\n double target = (grem > 0) ? (double)nrem / (double)grem : (double)nrem;\n vector keys;\n keys.reserve(cnt.size());\n for(auto &kv: cnt) keys.push_back(kv.first);\n auto it = lower_bound(keys.begin(), keys.end(), (int)llround(target));\n for(int d=-3; d<=3; d++){\n int idx = (int)(it - keys.begin()) + d;\n if(0 <= idx && idx < (int)keys.size()){\n int s = keys[idx];\n if(s <= nrem) cands.push_back(s);\n }\n }\n\n sort(cands.begin(), cands.end());\n cands.erase(unique(cands.begin(), cands.end()), cands.end());\n if(cands.empty()){\n for(auto &kv: cnt) if(kv.first <= nrem) { cands.push_back(kv.first); break; }\n }\n return cands;\n };\n\n vector glist;\n glist.reserve(M);\n\n int p = 0;\n int groupsRem = M;\n long long totalChain = 0;\n\n while(groupsRem > 0){\n int nrem = N - p;\n if(groupsRem == 1){\n int s = nrem;\n if(!pop_size(s)){\n s = cnt.rbegin()->first;\n pop_size(s);\n }\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+s);\n totalChain += chainCost(p, s);\n glist.push_back(std::move(gi));\n p += s;\n groupsRem--;\n break;\n }\n\n auto cands = collect_candidates(nrem, groupsRem);\n\n long double target = (long double)nrem / (long double)groupsRem;\n const long double lambda = 1e4L;\n\n vector> scored;\n scored.reserve(cands.size());\n for(int s: cands){\n if(s > nrem) continue;\n long double avg = 0;\n if(s >= 2) avg = (long double)chainCost(p, s) / (long double)(s - 1);\n long double val = avg + lambda * fabsl((long double)s - target);\n scored.push_back({val, s});\n }\n if(scored.empty()){\n int s = cnt.begin()->first;\n if(s > nrem) s = cnt.rbegin()->first;\n pop_size(s);\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+s);\n totalChain += chainCost(p, s);\n glist.push_back(std::move(gi));\n p += s;\n groupsRem--;\n continue;\n }\n\n sort(scored.begin(), scored.end(), [&](auto &a, auto &b){\n if(a.first != b.first) return a.first < b.first;\n return a.second < b.second;\n });\n\n int bestS = scored[0].second;\n if(rnd){\n int K = min(3, (int)scored.size());\n uint64_t r = splitmix64(*rnd);\n int pick = 0;\n if(K == 3){\n int t = (int)(r % 7);\n pick = (t < 4) ? 0 : (t < 6 ? 1 : 2);\n }else if(K == 2){\n int t = (int)(r % 4);\n pick = (t < 3) ? 0 : 1;\n }\n bestS = scored[pick].second;\n }\n\n pop_size(bestS);\n GroupInfo gi;\n gi.nodes.assign(order.begin()+p, order.begin()+p+bestS);\n totalChain += chainCost(p, bestS);\n glist.push_back(std::move(gi));\n p += bestS;\n groupsRem--;\n }\n\n return {glist, totalChain};\n}\n\n// approximate MST cost (Prim) using center d2: used for query prioritization only\nstatic long long approx_mst_d2_group(const vector& nodes,\n const vector& ex,\n const vector& ey)\n{\n int g = (int)nodes.size();\n if(g <= 1) return 0;\n vector best(g, (1LL<<62));\n vector used(g, 0);\n best[0] = 0;\n long long total = 0;\n for(int it=0; it> N >> M >> Q >> L >> W;\n vector G(M);\n for(int i=0;i> G[i];\n\n vector lx(N), rx(N), ly(N), ry(N);\n for(int i=0;i> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n vector ex(N), ey(N);\n for(int i=0;iint{\n return (int)llround((long double)v * 65535.0L / 10000.0L);\n };\n\n // Candidate orders (4)\n vector> orders;\n // Hilbert(x,y)\n {\n vector key(N);\n for(int i=0;i ord(N); iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(key[a]!=key[b]) return key[a] key(N);\n for(int i=0;i ord(N); iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(key[a]!=key[b]) return key[a] ord(N); iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(ex[a]!=ex[b]) return ex[a] ord(N); iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(ey[a]!=ey[b]) return ey[a] glist;\n const int TRIALS_PER_ORDER = 6;\n\n for(int oi=0; oi<(int)orders.size(); oi++){\n {\n auto [tmp, sc] = build_groups_greedy_chainScore(orders[oi], ex, ey, G, nullptr);\n if(sc < bestChain){\n bestChain = sc;\n glist = std::move(tmp);\n }\n }\n for(int t=0;t hkey(N);\n for(int i=0;i outIdx(M); iota(outIdx.begin(), outIdx.end(), 0);\n sort(outIdx.begin(), outIdx.end(), [&](int a,int b){\n if(G[a]!=G[b]) return G[a] grpIdx(M); iota(grpIdx.begin(), grpIdx.end(), 0);\n sort(grpIdx.begin(), grpIdx.end(), [&](int a,int b){\n int sa=(int)glist[a].nodes.size(), sb=(int)glist[b].nodes.size();\n if(sa!=sb) return sa groupForOut(M, -1);\n for(int i=0;i& subset)->vector>{\n int l = (int)subset.size();\n cout << \"? \" << l;\n for(int v: subset) cout << \" \" << v;\n cout << \"\\n\" << flush;\n vector> ret;\n ret.reserve(l-1);\n for(int i=0;i> a >> b;\n if(a>b) swap(a,b);\n ret.push_back({a,b});\n }\n return ret;\n };\n\n int usedQ = 0;\n\n // approx cost for prioritization\n vector approxCost(M, 0);\n for(int gi=0; gi exactCandidates;\n for(int gi=0; gigb;\n if(approxCost[a]!=approxCost[b]) return approxCost[a]>approxCost[b];\n return a= Q) break;\n auto ret = do_query(glist[gi].nodes);\n glist[gi].exactKnown = true;\n glist[gi].exactEdges = std::move(ret);\n usedQ++;\n }\n\n // (2) Large groups: greedy full-pass per group, expensive first, by offsets\n vector largeGroups;\n for(int gi=0; gi L) largeGroups.push_back(gi);\n sort(largeGroups.begin(), largeGroups.end(), [&](int a,int b){\n if(approxCost[a]!=approxCost[b]) return approxCost[a] > approxCost[b];\n return glist[a].nodes.size() > glist[b].nodes.size();\n });\n\n auto do_pass_full = [&](int gi, int startPos){\n auto &vec = glist[gi].nodes;\n int g = (int)vec.size();\n int step = L - 1;\n for(int pos = startPos; pos < g-1 && usedQ < Q; pos += step){\n int l = min(L, g - pos);\n if(l < 2) break;\n vector subset(vec.begin()+pos, vec.begin()+pos+l);\n auto ret = do_query(subset);\n glist[gi].queryEdges.insert(glist[gi].queryEdges.end(), ret.begin(), ret.end());\n usedQ++;\n }\n };\n\n if(usedQ < Q && L >= 3){\n int step = L - 1;\n vector offsets = {0, step/2, step/3, (2*step)/3};\n sort(offsets.begin(), offsets.end());\n offsets.erase(unique(offsets.begin(), offsets.end()), offsets.end());\n offsets.erase(remove_if(offsets.begin(), offsets.end(), [&](int x){ return x<0 || x>=step; }), offsets.end());\n // keep 0 first\n offsets.erase(remove(offsets.begin(), offsets.end(), 0), offsets.end());\n offsets.insert(offsets.begin(), 0);\n\n for(int off: offsets){\n for(int gi: largeGroups){\n if(usedQ >= Q) break;\n do_pass_full(gi, off);\n }\n if(usedQ >= Q) break;\n }\n }\n\n // ---- Output ----\n cout << \"!\\n\" << flush;\n\n auto edge_key = [&](int u,int v)->int{\n if(u>v) swap(u,v);\n return u*1024 + v; // N<=800\n };\n\n for(int outk=0; outkv) swap(u,v);\n cout << u << \" \" << v << \"\\n\";\n continue;\n }\n\n // Candidate edges (unique), with query-edge preference\n unordered_set seen;\n seen.reserve((size_t)g * 128);\n\n vector> candQuery;\n candQuery.reserve(info.queryEdges.size());\n for(auto &e: info.queryEdges){\n int u=e.first, v=e.second;\n if(u>v) swap(u,v);\n int key = edge_key(u,v);\n if(seen.insert(key).second) candQuery.push_back({u,v});\n }\n\n vector> candOther;\n candOther.reserve((size_t)g * 128);\n\n auto add_other = [&](int u,int v){\n if(u==v) return;\n if(u>v) swap(u,v);\n int key = edge_key(u,v);\n if(seen.insert(key).second) candOther.push_back({u,v});\n };\n\n // chain\n for(int i=0;i byx = vec, byy = vec;\n sort(byx.begin(), byx.end(), [&](int a,int b){\n if(ex[a]!=ex[b]) return ex[a]> tmp;\n tmp.reserve(g-1);\n for(int jj=0; jj kNN)\n nth_element(tmp.begin(), tmp.begin()+kNN, tmp.end(),\n [](auto &a, auto &b){ return a.first < b.first; });\n int take = min(kNN, (int)tmp.size());\n for(int t=0;t lid;\n lid.reserve((size_t)g*2);\n for(int i=0;i all;\n all.reserve(candQuery.size() + candOther.size());\n\n for(auto &e: candQuery) all.push_back({e.first, e.second, dist2_center(ex[e.first], ey[e.first], ex[e.second], ey[e.second]), true});\n for(auto &e: candOther) all.push_back({e.first, e.second, dist2_center(ex[e.first], ey[e.first], ex[e.second], ey[e.second]), false});\n\n sort(all.begin(), all.end(), [&](const CE& a, const CE& b){\n long double wa = (long double)a.d2 * (a.isQuery ? 0.58L : 1.0L);\n long double wb = (long double)b.d2 * (b.isQuery ? 0.58L : 1.0L);\n if(wa != wb) return wa < wb;\n if(a.isQuery != b.isQuery) return a.isQuery > b.isQuery;\n if(a.u != b.u) return a.u < b.u;\n return a.v < b.v;\n });\n\n DSU dsu(g);\n vector> chosen;\n chosen.reserve(g-1);\n\n for(auto &e: all){\n int a = lid[e.u], b = lid[e.v];\n if(dsu.unite(a,b)){\n chosen.push_back({e.u, e.v});\n if((int)chosen.size() == g-1) break;\n }\n }\n\n // fallback connect\n while((int)chosen.size() < g-1){\n for(int i=0;iv) swap(u,v);\n cout << u << \" \" << v << \"\\n\";\n }\n }\n\n cout << flush;\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nstatic constexpr int N = 20;\nstatic constexpr int MAXP = N * N;\n\nstruct Pos { int r, c; };\nstatic inline int pid(int r,int c){ return r*N+c; }\nstatic inline bool inside(int r,int c){ return 0<=r && r seq;\n};\n\nstatic uint64_t hash_fixed(const vector& v){\n uint64_t h = 1469598103934665603ULL;\n for(int x: v){\n h ^= (uint64_t)(x + 1);\n h *= 1099511628211ULL;\n }\n return h;\n}\nstatic void fixed_add(vector& lst, int cell){\n auto it = lower_bound(lst.begin(), lst.end(), cell);\n if(it==lst.end() || *it!=cell) lst.insert(it, cell);\n}\nstatic void fixed_remove(vector& lst, int cell){\n auto it = lower_bound(lst.begin(), lst.end(), cell);\n if(it!=lst.end() && *it==cell) lst.erase(it);\n}\n\nstatic vector neigh4_cells(const Pos& p){\n vector v;\n v.reserve(4);\n for(int d=0; d<4; d++){\n int nr=p.r+dr[d], nc=p.c+dc[d];\n if(inside(nr,nc)) v.push_back(pid(nr,nc));\n }\n return v;\n}\n\n// prioritized candidate list for temporary toggles during one leg\nstatic vector build_leg_candidates(const Pos& cur, const Pos& tgt, const optional& nxt,\n const bitset& fixed){\n Pos c1{cur.r, tgt.c};\n Pos c2{tgt.r, cur.c};\n\n vector v;\n v.reserve(24);\n auto add = [&](int id){\n if(fixed.test(id)) return;\n for(int x: v) if(x==id) return;\n v.push_back(id);\n };\n for(int id: neigh4_cells(tgt)) add(id);\n for(int id: neigh4_cells(cur)) add(id);\n for(int id: neigh4_cells(c1)) add(id);\n for(int id: neigh4_cells(c2)) add(id);\n if(nxt){\n for(int id: neigh4_cells(*nxt)) add(id);\n }\n return v;\n}\n\n// Per-leg BFS with fixed permanent blocks + local temporary toggles (mask), must end mask=0.\nstruct LegBFS {\n int KMAX;\n vector cand;\n array cid{};\n int C=0, MASKS=1, STATES=0;\n\n vector dist;\n vector parent;\n vector pack;\n vector seen;\n int stamp = 1;\n vector q;\n\n LegBFS(int kmax): KMAX(kmax) { cid.fill(-1); }\n\n void set_candidates(const vector& cells, const bitset& fixed) {\n cid.fill(-1);\n cand.clear();\n for(int id: cells){\n if(fixed.test(id)) continue;\n if(cid[id] != -1) continue;\n cid[id] = (int)cand.size();\n cand.push_back(id);\n if((int)cand.size() >= KMAX) break;\n }\n C = (int)cand.size();\n MASKS = 1 << C;\n STATES = MAXP * MASKS;\n\n dist.assign(STATES, 0);\n parent.assign(STATES, -1);\n pack.assign(STATES, 0);\n seen.assign(STATES, 0);\n q.reserve(STATES/8);\n stamp = 1;\n }\n\n inline bool isBlocked(int cell, int mask, const bitset& fixed) const {\n if(fixed.test(cell)) return true;\n int idx = cid[cell];\n if(idx < 0) return false;\n return (mask >> idx) & 1;\n }\n\n int slide_endpoint(int pos, int dir, int mask, const vector& fixedList) const {\n int r = pos / N, c = pos % N;\n\n int best = INT_MAX;\n if(dir==0) best = r + 1;\n if(dir==1) best = N - r;\n if(dir==2) best = c + 1;\n if(dir==3) best = N - c;\n\n for(int b: fixedList){\n int br=b/N, bc=b%N;\n int d = INT_MAX;\n if(dir==0){ if(bc==c && brr) d = br-r; }\n if(dir==2){ if(br==r && bcc) d = bc-c; }\n if(d < best) best = d;\n }\n for(int i=0;i>i)&1){\n int b = cand[i];\n int br=b/N, bc=b%N;\n int d = INT_MAX;\n if(dir==0){ if(bc==c && brr) d = br-r; }\n if(dir==2){ if(br==r && bcc) d = bc-c; }\n if(d < best) best = d;\n }\n\n int step = best - 1;\n return pid(r + dr[dir]*step, c + dc[dir]*step);\n }\n\n BFSPlan solve(Pos s, Pos t,\n const bitset& fixed,\n const vector& fixedList) {\n BFSPlan res;\n auto sid = [&](int pos, int mask){ return pos*MASKS + mask; };\n\n int sPos = pid(s.r,s.c), tPos = pid(t.r,t.c);\n int sState = sid(sPos, 0);\n int gState = sid(tPos, 0);\n\n stamp++;\n if(stamp == INT_MAX){\n fill(seen.begin(), seen.end(), 0);\n stamp = 1;\n }\n\n q.clear();\n int head=0;\n seen[sState]=stamp;\n dist[sState]=0;\n parent[sState]=-1;\n q.push_back(sState);\n\n while(head < (int)q.size()){\n int st = q[head++];\n if(st == gState) break;\n\n int pos = st / MASKS;\n int mask = st % MASKS;\n int dcur = dist[st];\n int r = pos / N, c = pos % N;\n\n for(int dir=0; dir<4; dir++){\n // Move\n {\n int nr=r+dr[dir], nc=c+dc[dir];\n if(inside(nr,nc)){\n int np = pid(nr,nc);\n if(!isBlocked(np, mask, fixed)){\n int ns = sid(np, mask);\n if(seen[ns] != stamp){\n seen[ns]=stamp;\n dist[ns]=(int16_t)(dcur+1);\n parent[ns]=st;\n pack[ns]=(uint8_t)((0u<<2)|(unsigned)dir);\n q.push_back(ns);\n }\n }\n }\n }\n // Slide\n {\n int np = slide_endpoint(pos, dir, mask, fixedList);\n int ns = sid(np, mask);\n if(seen[ns] != stamp){\n seen[ns]=stamp;\n dist[ns]=(int16_t)(dcur+1);\n parent[ns]=st;\n pack[ns]=(uint8_t)((1u<<2)|(unsigned)dir);\n q.push_back(ns);\n }\n }\n // Alter local\n {\n int ar=r+dr[dir], ac=c+dc[dir];\n if(inside(ar,ac)){\n int aid=pid(ar,ac);\n int idx = cid[aid];\n if(idx >= 0){\n int nmask = mask ^ (1< rev;\n int st = gState;\n while(st != sState){\n rev.push_back(pack[st]);\n st = parent[st];\n }\n reverse(rev.begin(), rev.end());\n res.seq = move(rev);\n return res;\n }\n};\n\n// Move+Slide-only heuristic under permanent blocks (position-only BFS)\nstatic int slide_endpoint_fixed(int pos, int dir, const vector& fixedList){\n int r = pos / N, c = pos % N;\n int best = INT_MAX;\n if(dir==0) best = r + 1;\n if(dir==1) best = N - r;\n if(dir==2) best = c + 1;\n if(dir==3) best = N - c;\n for(int b: fixedList){\n int br=b/N, bc=b%N;\n int d = INT_MAX;\n if(dir==0){ if(bc==c && brr) d = br-r; }\n if(dir==2){ if(br==r && bcc) d = bc-c; }\n if(d < best) best = d;\n }\n int step = best - 1;\n return pid(r + dr[dir]*step, c + dc[dir]*step);\n}\n\nstatic int heuristic_ms(Pos s, Pos t, const bitset& fixed, const vector& fixedList){\n int sp=pid(s.r,s.c), tp=pid(t.r,t.c);\n array dist;\n dist.fill((int16_t)-1);\n queue q;\n dist[sp]=0; q.push(sp);\n while(!q.empty()){\n int pos=q.front(); q.pop();\n int dcur=dist[pos];\n if(pos==tp) return dcur;\n int r=pos/N, c=pos%N;\n for(int dir=0; dir<4; dir++){\n int nr=r+dr[dir], nc=c+dc[dir];\n if(inside(nr,nc)){\n int np=pid(nr,nc);\n if(!fixed.test(np) && dist[np]==-1){\n dist[np]=dcur+1;\n q.push(np);\n }\n }\n int np = slide_endpoint_fixed(pos, dir, fixedList);\n if(dist[np]==-1){\n dist[np]=dcur+1;\n q.push(np);\n }\n }\n }\n return 999;\n}\n\nstruct PoolNode {\n bitset fixed;\n vector fixedList; // sorted\n int cost = 0;\n int eval = 0;\n int parent = -1;\n vector seg;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, M;\n cin >> n >> M;\n vector pts(M);\n for(int i=0;i> pts[i].r >> pts[i].c;\n\n // Map each cell to target index (0..M-1) or -1\n array targetIdx;\n targetIdx.fill(-1);\n for(int i=0;i(chrono::steady_clock::now()-tstart).count();\n };\n\n // Baseline (no permanent blocks)\n LegBFS baseSolver(10);\n vector baseline;\n baseline.reserve(1600);\n {\n bitset fixed; fixed.reset();\n vector fixedList;\n Pos cur = pts[0];\n for(int k=1;k nxt = (k+1(pts[k+1]) : nullopt;\n auto cells = build_leg_candidates(cur, tgt, nxt, fixed);\n baseSolver.set_candidates(cells, fixed);\n auto plan = baseSolver.solve(cur, tgt, fixed, fixedList);\n if(plan.dist == INT_MAX){\n int r=cur.r,c=cur.c;\n while(rtgt.r){ baseline.push_back((0u<<2)|0u); r--; } // U\n while(ctgt.c){ baseline.push_back((0u<<2)|2u); c--; } // L\n }else{\n baseline.insert(baseline.end(), plan.seq.begin(), plan.seq.end());\n }\n cur = tgt;\n }\n }\n\n // Beam search constants (expanded a bit)\n const int BEAM_W_BASE = 56;\n const int BMAX = 8;\n const int BLOCK_PEN = 2;\n const int H2_DIV = 3;\n\n LegBFS legSolver(10);\n\n vector pool;\n pool.reserve(90000);\n auto new_node = [&](PoolNode&& nd)->int{\n pool.push_back(move(nd));\n return (int)pool.size()-1;\n };\n\n vector beam;\n beam.reserve(BEAM_W_BASE);\n {\n PoolNode init;\n init.fixed.reset();\n init.fixedList.clear();\n init.cost = 0;\n init.eval = 0;\n init.parent = -1;\n init.seg.clear();\n beam.push_back(new_node(move(init)));\n }\n\n for(int k=1;k memoH1, memoH2;\n memoH1.reserve(4096);\n memoH2.reserve(4096);\n\n vector candIdx;\n candIdx.reserve(BEAM_W * 28);\n\n unordered_map bestCostForHash;\n bestCostForHash.reserve(8192);\n\n auto getH = [&](unordered_map& memo, uint64_t hkey,\n Pos a, Pos b, const PoolNode& nd)->int{\n auto it = memo.find(hkey);\n if(it!=memo.end()) return it->second;\n int v = heuristic_ms(a, b, nd.fixed, nd.fixedList);\n memo.emplace(hkey, v);\n return v;\n };\n\n auto compute_eval = [&](PoolNode& nd)->int{\n uint64_t hkey = hash_fixed(nd.fixedList);\n int h1 = has1 ? getH(memoH1, hkey, tgt, t1, nd) : 0;\n int h2 = has2 ? getH(memoH2, hkey, t1, t2, nd) : 0;\n return nd.cost + h1 + (has2 ? h2 / H2_DIV : 0) + BLOCK_PEN * (int)nd.fixedList.size();\n };\n\n auto consider = [&](PoolNode&& nd){\n if(nd.cost > 2*N*M) return;\n uint64_t hkey = hash_fixed(nd.fixedList);\n auto it = bestCostForHash.find(hkey);\n if(it!=bestCostForHash.end() && it->second <= nd.cost) return;\n bestCostForHash[hkey] = nd.cost;\n nd.eval = compute_eval(nd);\n candIdx.push_back(new_node(move(nd)));\n };\n\n // forbid permanent blocks only on FUTURE targets (index > k)\n auto forbid_perm_cell = [&](int cell)->bool{\n int ti = targetIdx[cell];\n return (ti != -1 && ti > k);\n };\n\n for(int bi=0; bi<(int)beam.size(); bi++){\n if(elapsed_sec() > 1.93) break;\n\n int idx = beam[bi];\n const PoolNode& curNode = pool[idx];\n\n // plan leg\n optional nxtOpt = has1 ? optional(t1) : nullopt;\n auto cells = build_leg_candidates(start, tgt, nxtOpt, curNode.fixed);\n legSolver.set_candidates(cells, curNode.fixed);\n auto plan = legSolver.solve(start, tgt, curNode.fixed, curNode.fixedList);\n if(plan.dist == INT_MAX) continue;\n\n PoolNode reached;\n reached.fixed = curNode.fixed;\n reached.fixedList = curNode.fixedList;\n reached.cost = curNode.cost + plan.dist;\n reached.parent = idx;\n reached.seg = plan.seq;\n\n vector> neigh;\n neigh.reserve(4);\n for(int d=0; d<4; d++){\n int nr=tgt.r+dr[d], nc=tgt.c+dc[d];\n if(!inside(nr,nc)) continue;\n int nb=pid(nr,nc);\n if(forbid_perm_cell(nb)) continue;\n neigh.push_back({nb,d});\n }\n int L = (int)neigh.size();\n\n auto apply_toggle = [&](PoolNode& nd, int nb, int dir)->bool{\n if(nd.fixed.test(nb)){\n nd.fixed.reset(nb);\n fixed_remove(nd.fixedList, nb);\n nd.seg.push_back((2u<<2)|(uint8_t)dir);\n nd.cost += 1;\n return true;\n }else{\n if((int)nd.fixedList.size() >= BMAX) return false;\n nd.fixed.set(nb);\n fixed_add(nd.fixedList, nb);\n nd.seg.push_back((2u<<2)|(uint8_t)dir);\n nd.cost += 1;\n return true;\n }\n };\n\n // 0\n consider(PoolNode(reached));\n\n // 1\n for(int i=0;i= 3){\n for(int i=0;i 1.95){\n beam.clear();\n break;\n }\n\n int keep = min(BEAM_W, (int)candIdx.size());\n nth_element(candIdx.begin(), candIdx.begin()+keep-1, candIdx.end(),\n [&](int a, int b){\n const auto& A = pool[a];\n const auto& B = pool[b];\n if(A.eval != B.eval) return A.eval < B.eval;\n return A.cost < B.cost;\n });\n candIdx.resize(keep);\n sort(candIdx.begin(), candIdx.end(),\n [&](int a, int b){\n const auto& A = pool[a];\n const auto& B = pool[b];\n if(A.eval != B.eval) return A.eval < B.eval;\n return A.cost < B.cost;\n });\n beam.swap(candIdx);\n }\n\n // choose best between baseline and beam result\n vector bestActions = baseline;\n if(!beam.empty()){\n int bestIdx = beam[0];\n for(int idx: beam){\n if(pool[idx].cost < pool[bestIdx].cost) bestIdx = idx;\n }\n if(pool[bestIdx].cost < (int)baseline.size() && pool[bestIdx].cost <= 2*N*M){\n vector> segs;\n int cur = bestIdx;\n while(cur != -1){\n segs.push_back(pool[cur].seg);\n cur = pool[cur].parent;\n }\n reverse(segs.begin(), segs.end());\n vector out;\n out.reserve(pool[bestIdx].cost);\n for(auto& s: segs) out.insert(out.end(), s.begin(), s.end());\n if((int)out.size() <= 2*N*M) bestActions.swap(out);\n }\n }\n\n for(uint8_t b : bestActions){\n int act = (b>>2)&3;\n int dir = b&3;\n cout << actChar(act) << ' ' << dirChar(dir) << \"\\n\";\n }\n return 0;\n}"}}}