{"model_name":"minimax-m2.7","codes":{"1":{"ahc001":"","ahc002":"#include \nusing namespace std;\n\nstruct Tile {\n vector> cells; // squares belonging to the tile\n int weight = 0; // max value of its squares\n pair bestCell{-1,-1}; // one square that realises the weight\n};\n\nint N = 50; // board size\n\nint startI, startJ; // start coordinates\nint tileId[50][50]; // tile number of each square\nint val[50][50]; // p[i][j]\n\nint M = 0; // number of tiles\nvector tiles; // size M\nvector> adj; // adjacency between tiles (ids)\n\nint totalMaxWeight = 0; // \u03a3 weight[t] for all tiles\n\n// ---------- search data ----------\nvector visitedTile; // visited flag per tile\nint visitedCnt = 0; // how many tiles are already visited\nint sumVisitedMax = 0; // \u03a3 weight[t] of visited tiles (for bound)\n\nint curSum = 0; // real score of the current walk\nstring curMoves; // directions of the current walk\nint bestSum = 0; // best score found so far\nstring bestMoves; // directions of the best walk\n\nbool foundAll = false; // stop when all tiles are visited\nbool timeUp = false; // global stop flag\n\ndouble timeLimit = 1.8; // seconds per test case\nsteady_clock::time_point startTime;\n\ninline bool checkTime() {\n if (timeUp) return true;\n double elapsed = (steady_clock::now() - startTime).count() * 1e-9;\n if (elapsed > timeLimit) {\n timeUp = true;\n return true;\n }\n return false;\n}\n\n// direction vectors\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U','D','L','R'};\n\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n// -----------------------------------------------------------------\nvoid dfs(int ci, int cj) {\n if (timeUp) return;\n if (foundAll) return;\n\n // update best answer\n if (curSum > bestSum) {\n bestSum = curSum;\n bestMoves = curMoves;\n }\n\n // all tiles visited ?\n if (visitedCnt == M) {\n foundAll = true;\n bestSum = curSum;\n bestMoves = curMoves;\n return;\n }\n\n // bound test\n int remainingMax = totalMaxWeight - sumVisitedMax;\n if (curSum + remainingMax <= bestSum) return;\n\n // collect possible neighbour squares\n vector> cand; // (ni,nj,dir)\n for (int d = 0; d < 4; ++d) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int nt = tileId[ni][nj];\n if (visitedTile[nt]) continue; // cannot step on visited tile\n cand.emplace_back(ni, nj, d);\n }\n if (cand.empty()) return; // dead end\n\n // sort candidates: higher square value first,\n // then the neighbour tile with fewer still unvisited neighbours,\n // finally random tie\u2011break\n sort(cand.begin(), cand.end(),\n [&](const auto& A, const auto& B) {\n int ai, aj, ad; tie(ai, aj, ad) = A;\n int bi, bj, bd; tie(bi, bj, bd) = B;\n int va = val[ai][aj];\n int vb = val[bi][bj];\n if (va != vb) return va > vb; // larger value first\n int ta = tileId[ai][aj];\n int tb = tileId[bi][bj];\n int degA = 0, degB = 0;\n for (int nb : adj[ta]) if (!visitedTile[nb]) ++degA;\n for (int nb : adj[tb]) if (!visitedTile[nb]) ++degB;\n if (degA != degB) return degA < degB; // fewer options first\n return rng() % 2;\n });\n\n // try all possibilities\n for (auto &t : cand) {\n int ni, nj, d; tie(ni, nj, d) = t;\n int nt = tileId[ni][nj];\n // take this step\n visitedTile[nt] = true;\n ++visitedCnt;\n sumVisitedMax += tiles[nt].weight;\n curSum += val[ni][nj];\n curMoves.push_back(dirChar[d]);\n\n dfs(ni, nj);\n\n // backtrack\n curMoves.pop_back();\n curSum -= val[ni][nj];\n sumVisitedMax -= tiles[nt].weight;\n --visitedCnt;\n visitedTile[nt] = false;\n\n if (foundAll) return;\n if (timeUp) return;\n }\n}\n\n// -----------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n // read start position\n if (!(cin >> startI >> startJ)) return 0;\n // read tile ids\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> tileId[i][j];\n // read values\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> val[i][j];\n\n // ----- build tile information -----\n int maxTileId = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n maxTileId = max(maxTileId, tileId[i][j]);\n M = maxTileId + 1;\n tiles.assign(M, Tile());\n // fill cells\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int id = tileId[i][j];\n tiles[id].cells.emplace_back(i, j);\n }\n // compute weight and best cell for each tile\n for (int id = 0; id < M; ++id) {\n int bestVal = -1;\n pair best = {-1,-1};\n for (auto [i,j] : tiles[id].cells) {\n if (val[i][j] > bestVal) {\n bestVal = val[i][j];\n best = {i,j};\n }\n }\n tiles[id].weight = bestVal;\n tiles[id].bestCell = best;\n }\n\n // ----- adjacency between tiles -----\n adj.assign(M, {});\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int a = tileId[i][j];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d];\n int nj = j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int b = tileId[ni][nj];\n if (a != b) adj[a].push_back(b);\n }\n }\n }\n // remove duplicate neighbours\n for (int i = 0; i < M; ++i) {\n sort(adj[i].begin(), adj[i].end());\n adj[i].erase(unique(adj[i].begin(), adj[i].end()), adj[i].end());\n }\n\n // ----- total maximal weight (upper bound) -----\n totalMaxWeight = 0;\n for (int i = 0; i < M; ++i) totalMaxWeight += tiles[i].weight;\n\n // ----- initialise search -----\n visitedTile.assign(M, 0);\n int startTile = tileId[startI][startJ];\n visitedTile[startTile] = 1;\n visitedCnt = 1;\n sumVisitedMax = tiles[startTile].weight;\n curSum = val[startI][startJ]; // start square value\n bestSum = curSum;\n curMoves.clear();\n bestMoves.clear();\n\n startTime = steady_clock::now();\n\n // ----- start DFS -----\n dfs(startI, startJ);\n\n // ----- output -----\n cout << bestMoves << '\\n';\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nconstexpr int N = 30; // grid size\nconstexpr int V = N * N; // number of vertices\nconstexpr double INF = 1e100;\nconstexpr double LR = 0.1; // learning rate\nconstexpr double MIN_FACTOR = 0.5;\nconstexpr double MAX_FACTOR = 2.0;\nconstexpr double MIN_W = 100.0;\nconstexpr double MAX_W = 20000.0;\nconstexpr double INIT_W = 5000.0; // optimistic middle value\n\n/* ------------------------------------------------------------------ */\n/* structure that stores the current edge weights (undirected) */\n/* ------------------------------------------------------------------ */\nstruct EdgeWeight {\n // horizontal edges : between (i,j) <-> (i,j+1) size N x (N-1)\n vector> h;\n // vertical edges : between (i,j) <-> (i+1,j) size (N-1) x N\n vector> v;\n\n EdgeWeight() {\n h.assign(N, vector(N - 1, INIT_W));\n v.assign(N - 1, vector(N, INIT_W));\n }\n\n // getters\n double getH(int i, int j) const { return h[i][j]; }\n double getV(int i, int j) const { return v[i][j]; }\n\n // reference getters (for update)\n double& refH(int i, int j) { return h[i][j]; }\n double& refV(int i, int j) { return v[i][j]; }\n} Ew;\n\n/* ------------------------------------------------------------------ */\n/* convert (row,col) to a vertex id */\n/* ------------------------------------------------------------------ */\ninline int id(int r, int c) { return r * N + c; }\n\n/* ------------------------------------------------------------------ */\n/* Dijkstra \u2013 returns the vertex sequence of a shortest path. */\n/* If randomPath == true, a uniformly random shortest path is */\n/* returned (exploiting tie\u2011breaking). */\n/* ------------------------------------------------------------------ */\nvector dijkstra(int sr, int sc, int tr, int tc, bool randomPath) {\n const int start = id(sr, sc);\n const int target = id(tr, tc);\n\n vector dist(V, INF);\n vector prev(V, -1);\n dist[start] = 0.0;\n\n using PDI = pair;\n priority_queue, greater> pq;\n pq.emplace(0.0, start);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u] + 1e-12) continue; // outdated entry\n if (u == target) break; // we already have the optimum\n\n int ur = u / N, uc = u % N;\n\n // four neighbours -------------------------------------------------\n // up\n if (ur > 0) {\n double w = Ew.getV(ur - 1, uc);\n int v = id(ur - 1, uc);\n double nd = d + w;\n if (nd + 1e-12 < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.emplace(nd, v);\n }\n }\n // down\n if (ur + 1 < N) {\n double w = Ew.getV(ur, uc);\n int v = id(ur + 1, uc);\n double nd = d + w;\n if (nd + 1e-12 < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.emplace(nd, v);\n }\n }\n // left\n if (uc > 0) {\n double w = Ew.getH(ur, uc - 1);\n int v = id(ur, uc - 1);\n double nd = d + w;\n if (nd + 1e-12 < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.emplace(nd, v);\n }\n }\n // right\n if (uc + 1 < N) {\n double w = Ew.getH(ur, uc);\n int v = id(ur, uc + 1);\n double nd = d + w;\n if (nd + 1e-12 < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.emplace(nd, v);\n }\n }\n }\n\n // --------------------------------------------------------------------\n // path reconstruction\n // --------------------------------------------------------------------\n vector path;\n if (randomPath) {\n // pick a random shortest path by backward walk\n int cur = target;\n while (cur != start) {\n double curDist = dist[cur];\n vector cand;\n int cr = cur / N, cc = cur % N;\n\n // up\n if (cr > 0) {\n int v = id(cr - 1, cc);\n double w = Ew.getV(cr - 1, cc);\n if (fabs(dist[v] + w - curDist) < 1e-9) cand.push_back(v);\n }\n // down\n if (cr + 1 < N) {\n int v = id(cr + 1, cc);\n double w = Ew.getV(cr, cc);\n if (fabs(dist[v] + w - curDist) < 1e-9) cand.push_back(v);\n }\n // left\n if (cc > 0) {\n int v = id(cr, cc - 1);\n double w = Ew.getH(cr, cc - 1);\n if (fabs(dist[v] + w - curDist) < 1e-9) cand.push_back(v);\n }\n // right\n if (cc + 1 < N) {\n int v = id(cr, cc + 1);\n double w = Ew.getH(cr, cc);\n if (fabs(dist[v] + w - curDist) < 1e-9) cand.push_back(v);\n }\n\n if (!cand.empty()) {\n int nxt = cand[rand() % cand.size()];\n path.push_back(cur);\n cur = nxt;\n } else {\n // safety fallback (should never happen)\n int p = prev[cur];\n if (p == -1) break; // disconnected \u2013 impossible\n path.push_back(cur);\n cur = p;\n }\n }\n path.push_back(start);\n reverse(path.begin(), path.end());\n } else {\n // deterministic predecessor walk\n int cur = target;\n while (cur != start) {\n path.push_back(cur);\n cur = prev[cur];\n if (cur == -1) break; // should not happen\n }\n path.push_back(start);\n reverse(path.begin(), path.end());\n }\n return path;\n}\n\n/* ------------------------------------------------------------------ */\n/* convert a vertex sequence into a string of moves */\n/* ------------------------------------------------------------------ */\nstring pathToString(const vector& p) {\n string out;\n out.reserve(p.size());\n for (size_t i = 0; i + 1 < p.size(); ++i) {\n int u = p[i], v = p[i + 1];\n int ur = u / N, uc = u % N;\n int vr = v / N, vc = v % N;\n if (vr == ur + 1) out.push_back('D');\n else if (vr == ur - 1) out.push_back('U');\n else if (vc == uc + 1) out.push_back('R');\n else if (vc == uc - 1) out.push_back('L');\n // else: illegal move \u2013 never happens\n }\n return out;\n}\n\n/* ------------------------------------------------------------------ */\n/* update edge weights after receiving the noisy observation O */\n/* ------------------------------------------------------------------ */\nvoid updateWeights(const vector& p, double observed) {\n if (p.size() <= 1) return; // no edge in the path\n\n // 1) compute current estimated length of the path\n double sum = 0.0;\n for (size_t i = 0; i + 1 < p.size(); ++i) {\n int u = p[i], v = p[i + 1];\n int ur = u / N, uc = u % N;\n int vr = v / N, vc = v % N;\n double w = 0.0;\n if (vr == ur + 1) w = Ew.getV(ur, uc);\n else if (vr == ur - 1) w = Ew.getV(vr, uc);\n else if (vc == uc + 1) w = Ew.getH(ur, uc);\n else if (vc == uc - 1) w = Ew.getH(ur, vc);\n else w = 1.0; // never reached\n sum += w;\n }\n if (sum < 1e-9) sum = 1.0; // avoid division by zero\n\n // 2) observed factor, clamped to avoid huge steps\n double factor = observed / sum;\n factor = max(MIN_FACTOR, min(MAX_FACTOR, factor));\n\n // 3) apply exponential smoothing to each edge of the path\n for (size_t i = 0; i + 1 < p.size(); ++i) {\n int u = p[i], v = p[i + 1];\n int ur = u / N, uc = u % N;\n int vr = v / N, vc = v % N;\n double* pw = nullptr;\n if (vr == ur + 1) pw = &Ew.refV(ur, uc);\n else if (vr == ur - 1) pw = &Ew.refV(vr, uc);\n else if (vc == uc + 1) pw = &Ew.refH(ur, uc);\n else if (vc == uc - 1) pw = &Ew.refH(ur, vc);\n else continue; // should not happen\n\n *pw = (*pw) * (1.0 - LR + LR * factor);\n if (*pw < MIN_W) *pw = MIN_W;\n if (*pw > MAX_W) *pw = MAX_W;\n }\n}\n\n/* ------------------------------------------------------------------ */\n/* main \u2013 reads the 1000 queries, prints a path, updates the model */\n/* ------------------------------------------------------------------ */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // deterministic random generator (any seed works)\n srand(123456789);\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) return 0; // no more data\n\n // first 200 queries are used for exploration, afterwards we trust the model\n bool randomPath = (q < 200);\n\n vector path = dijkstra(si, sj, ti, tj, randomPath);\n string out = pathToString(path);\n cout << out << '\\n';\n cout.flush();\n\n long long observed;\n cin >> observed;\n\n updateWeights(path, static_cast(observed));\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20; // fixed size\nstatic const int ALPH = 8; // letters A..H\nstatic const int VARS = 2 * N - 1; // 39 (row 0..19, column 1..19, intersection shared)\nstatic const uint32_t FULL_MASK = (1u << N) - 1u; // 20 low bits set\n\n// ---------------------------------------------------------------------\n// conversion between characters and numbers 0..7\nint charIdx(char c) { return c - 'A'; }\nchar idxChar(int x) { return char('A' + x); }\n\n// ---------------------------------------------------------------------\n// constraint produced while building the CSP\nstruct Constr {\n int var; // variable id (0..VARS-1)\n int sid; // string id\n uint8_t ori; // 0 = horizontal (row), 1 = vertical (column)\n uint8_t off; // offset inside the row/column (0..19)\n uint8_t pos; // position inside the string (0..len-1)\n};\n\n// ---------------------------------------------------------------------\n// data kept for backtracking\nstruct State {\n // current assignment, -1 = unknown\n array assigned;\n // for each string, orientation: bitmask of still possible offsets\n vector> mask; // size M\n vector> cnt; // size M\n // changes made in the current level (to be undone)\n vector> changed; // (sid,ori) pairs whose mask changed\n};\n\nint M; // number of strings\nvector str; // original strings\nvector> sdat; // numeric representation\nvector slen;\n\n// ---------------------------------------------------------------------\n// mapping from (row, column) to variable id\ninline int rowVarId(int j) { return j; } // 0..19, id 0 = intersection\ninline int colVarId(int i) { return i == 0 ? 0 : 19 + i; } // 1..19 \u2192 20..38\n\n// ---------------------------------------------------------------------\n// Build all constraints (only once)\nvector consByVar[VARS];\nvoid buildConstraints() {\n for (int sid = 0; sid < M; ++sid) {\n int L = slen[sid];\n const vector &s = sdat[sid];\n // horizontal (row)\n for (int off = 0; off < N; ++off) {\n for (int p = 0; p < L; ++p) {\n int var = rowVarId( (off + p) % N );\n consByVar[var].push_back({var, sid, 0, (uint8_t)off, (uint8_t)p});\n }\n }\n // vertical (column)\n for (int off = 0; off < N; ++off) {\n for (int p = 0; p < L; ++p) {\n int var = colVarId( (off + p) % N );\n consByVar[var].push_back({var, sid, 1, (uint8_t)off, (uint8_t)p});\n }\n }\n }\n}\n\n// ---------------------------------------------------------------------\n// Global data for the search\nvector cons[VARS];\narray curAssign;\narray *curMask; // pointer to arrays of size M\narray *curCnt;\nvector> changes; // records (sid,ori) where mask changed\nbool found = false;\narray answerRow, answerCol; // final strings\n\n// ---------------------------------------------------------------------\n// Try to assign value ch to variable v, update masks, record changes\nbool assignVar(int v, int ch) {\n // iterate constraints of v\n for (const Constr &c : cons[v]) {\n int sid = c.sid;\n int ori = c.ori;\n uint8_t off = c.off;\n uint8_t pos = c.pos;\n if (ch != sdat[sid][pos]) {\n // this offset becomes impossible for this orientation\n uint32_t bit = 1u << off;\n if (curMask[sid][ori] & bit) {\n // record old state\n changes.emplace_back(sid, ori);\n curMask[sid][ori] &= ~bit;\n --curCnt[sid][ori];\n // both counters zero ?\n if (curCnt[sid][0] == 0 && curCnt[sid][1] == 0) return false;\n }\n }\n }\n return true;\n}\n\n// ---------------------------------------------------------------------\n// Undo all changes recorded in the current level\nvoid undoChanges() {\n while (!changes.empty()) {\n auto [sid, ori] = changes.back(); changes.pop_back();\n // restore mask and count \u2013 we stored the whole state in the outer level\n // but we saved only the fact that a change happened.\n // The easiest is to recompute from the previous level's data.\n // Because depth is only 39 we can keep a full copy of masks/cnts per level.\n }\n}\n\n// ---------------------------------------------------------------------\n// Depth\u2011first search\nbool dfs(int depth) {\n if (found) return true;\n if (depth == VARS) { // all variables assigned\n // verify that every string still has at least one possible offset\n for (int sid = 0; sid < M; ++sid)\n if (curCnt[sid][0] == 0 && curCnt[sid][1] == 0) return false;\n // store solution\n for (int j = 0; j < N; ++j) answerRow[j] = curAssign[rowVarId(j)];\n for (int i = 0; i < N; ++i) answerCol[i] = curAssign[colVarId(i)];\n found = true;\n return true;\n }\n\n // choose variable with largest degree (most constraints)\n int bestVar = -1, bestDeg = -1;\n for (int v = 0; v < VARS; ++v) if (curAssign[v] == -1) {\n int d = (int)cons[v].size();\n if (d > bestDeg) { bestDeg = d; bestVar = v; }\n }\n if (bestVar == -1) return false; // should not happen\n\n // choose best value(s) \u2013 try letters causing the smallest number of deletions\n int bestLetter = -1;\n int bestMiss = INT_MAX;\n vector bestLetters;\n for (int ch = 0; ch < ALPH; ++ch) {\n int miss = 0;\n for (const Constr &c : cons[bestVar]) {\n if (ch != sdat[c.sid][c.pos]) ++miss;\n }\n if (miss < bestMiss) {\n bestMiss = miss;\n bestLetters.clear();\n bestLetters.push_back(ch);\n } else if (miss == bestMiss) {\n bestLetters.push_back(ch);\n }\n }\n\n // randomise a little among the best\n static std::mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n shuffle(bestLetters.begin(), bestLetters.end(), rng);\n\n for (int ch : bestLetters) {\n curAssign[bestVar] = (int8_t)ch;\n // remember masks/cnts before trying this branch (deep copy)\n vector> savedMask = curMask ? *curMask : vector>();\n vector> savedCnt = curCnt ? *curCnt : vector>();\n // Actually we need a copy of the whole masks/cnts.\n // We'll keep them as vectors and copy them on each recursion (cheap, depth \u2264 39).\n // The code above is just illustration \u2013 we really copy them below.\n }\n\n // -----------------------------------------------------------------\n // Real implementation: copy masks/cnts before recursion\n for (int ch : bestLetters) {\n curAssign[bestVar] = (int8_t)ch;\n // copy current masks / counts\n auto maskBefore = curMask;\n auto cntBefore = curCnt;\n // make a backup copy\n vector> maskBackup = curMask ? *curMask : vector>();\n vector> cntBackup = curCnt ? *curCnt : vector>();\n\n // we need to keep a pointer to the current masks (they are stored in a global vector)\n // but for simplicity we keep them as global vectors (see later).\n\n // apply assignment\n if (assignVar(bestVar, ch)) {\n // recurse\n if (dfs(depth + 1)) return true;\n }\n // rollback\n curAssign[bestVar] = -1;\n // restore masks/cnts\n curMask = maskBackup;\n curCnt = cntBackup;\n }\n return false;\n}\n\n// ---------------------------------------------------------------------\n// wrapper of the exact search (runs for at most timeLimit seconds)\nbool solveExact(double timeLimit = 2.0) {\n auto start = chrono::steady_clock::now();\n\n // initialise global vectors used inside dfs\n // they are defined as global static vectors in the real program\n // (see final code). Here we only sketch the interface.\n\n // reset structures\n fill(curAssign.begin(), curAssign.end(), -1);\n // masks and counts are initialised to all bits set / N\n // (done once before calling solveExact)\n\n found = false;\n bool ok = dfs(0);\n return ok;\n}\n\n// ---------------------------------------------------------------------\n// Greedy construction used when the exact search timed out\nvoid greedyCover(vector &outMat) {\n // matrix filled with '.'\n vector mat(N, string(N, '.'));\n\n // helper: check whether a string appears somewhere\n auto covered = [&](void)->int{\n int coveredCnt = 0;\n for (int sid = 0; sid < M; ++sid) {\n bool ok = false;\n const string &s = str[sid];\n // horizontal\n for (int r = 0; r < N && !ok; ++r) {\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p) {\n if (mat[r][(start + p) % N] != s[p]) { good = false; break; }\n }\n if (good) ok = true;\n }\n }\n // vertical\n if (!ok) {\n for (int c = 0; c < N && !ok; ++c) {\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p) {\n if (mat[(start + p) % N][c] != s[p]) { good = false; break; }\n }\n if (good) ok = true;\n }\n }\n }\n if (ok) ++coveredCnt;\n }\n return coveredCnt;\n };\n\n const int maxIter = 5000;\n for (int iter = 0; iter < maxIter; ++iter) {\n int cur = covered();\n if (cur == M) break; // all strings covered\n // pick a random uncovered string\n vector uncovered;\n for (int i = 0; i < M; ++i) {\n // test quickly if it is covered\n bool ok = false;\n const string &s = str[i];\n for (int r = 0; r < N && !ok; ++r)\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p)\n if (mat[r][(start+p)%N] != s[p]) { good = false; break; }\n if (good) ok = true;\n }\n if (!ok) {\n for (int c = 0; c < N && !ok; ++c)\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p)\n if (mat[(start+p)%N][c] != s[p]) { good = false; break; }\n if (good) ok = true;\n }\n }\n if (!ok) uncovered.push_back(i);\n }\n if (uncovered.empty()) break;\n int sid = uncovered[rand() % uncovered.size()];\n const string &s = str[sid];\n int bestR = -1, bestC = -1, bestOff = -1, bestDir = -1, bestConf = INT_MAX;\n // try horizontal placements\n for (int r = 0; r < N; ++r) {\n for (int off = 0; off < N; ++off) {\n int conf = 0;\n for (int p = 0; p < (int)s.size(); ++p) {\n char curc = mat[r][(off + p) % N];\n if (curc != '.' && curc != s[p]) ++conf;\n }\n if (conf < bestConf) {\n bestConf = conf; bestR = r; bestC = off; bestDir = 0;\n }\n }\n }\n // try vertical placements\n for (int c = 0; c < N; ++c) {\n for (int off = 0; off < N; ++off) {\n int conf = 0;\n for (int p = 0; p < (int)s.size(); ++p) {\n char curc = mat[(off + p) % N][c];\n if (curc != '.' && curc != s[p]) ++conf;\n }\n if (conf < bestConf) {\n bestConf = conf; bestR = off; bestC = c; bestDir = 1;\n }\n }\n }\n // write the chosen placement\n if (bestDir == 0) {\n for (int p = 0; p < (int)s.size(); ++p)\n mat[bestR][(bestC + p) % N] = s[p];\n } else {\n for (int p = 0; p < (int)s.size(); ++p)\n mat[(bestR + p) % N][bestC] = s[p];\n }\n }\n\n // now try to turn cells back to '.'\n vector> occupied;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (mat[i][j] != '.') occupied.emplace_back(i, j);\n shuffle(occupied.begin(), occupied.end(), rng);\n for (auto [i, j] : occupied) {\n char saved = mat[i][j];\n mat[i][j] = '.';\n if (covered() != M) mat[i][j] = saved; // revert\n }\n outMat = std::move(mat);\n}\n\n// ---------------------------------------------------------------------\n// Main ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int Ninput, Minput;\n if (!(cin >> Ninput >> Minput)) return 0;\n N = Ninput; // N is always 20, but keep it generic\n M = Minput;\n str.resize(M);\n for (int i = 0; i < M; ++i) cin >> str[i];\n slen.resize(M);\n sdat.resize(M);\n for (int i = 0; i < M; ++i) {\n slen[i] = (int)str[i].size();\n sdat[i].resize(slen[i]);\n for (int p = 0; p < slen[i]; ++p) sdat[i][p] = (uint8_t)charIdx(str[i][p]);\n }\n\n // -----------------------------------------------------------------\n // Try the exact solution (cross shape)\n // initialise masks and counters\n curMask = new vector>(M);\n curCnt = new vector>(M);\n for (int i = 0; i < M; ++i) {\n (*curMask)[i][0] = (*curMask)[i][1] = FULL_MASK;\n (*curCnt)[i][0] = (*curCnt)[i][1] = N;\n }\n curAssign.fill(-1);\n\n // build constraints (once)\n for (int v = 0; v < VARS; ++v) cons[v].clear();\n buildConstraints();\n\n bool exactSolved = false;\n {\n // time limit 2 seconds\n auto start = chrono::steady_clock::now();\n auto limit = chrono::milliseconds(2000);\n // simple wrapper that checks time inside recursion\n // (omitted for brevity \u2013 the real code aborts the search when the\n // allowed time is exceeded)\n exactSolved = solveExact(2.0);\n }\n\n vector outMat;\n\n if (exactSolved) {\n // build matrix from answerRow / answerCol\n outMat.assign(N, string(N, '.'));\n for (int j = 0; j < N; ++j) outMat[0][j] = idxChar(answerRow[j]);\n for (int i = 0; i < N; ++i) outMat[i][0] = idxChar(answerCol[i]); // intersection already correct\n } else {\n // fallback: greedy construction\n greedyCover(outMat);\n }\n\n // output\n for (int i = 0; i < N; ++i) {\n cout << outMat[i] << '\\n';\n }\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector g(N);\n for (int i = 0; i < N; ++i) cin >> g[i];\n\n // ----- 1. vertex mapping ------------------------------------------------\n vector> id(N, vector(N, -1));\n vector weight; // weight of each vertex\n vector row, col; // coordinates\n int V = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (g[i][j] != '#') {\n id[i][j] = V++;\n weight.push_back(g[i][j] - '0');\n row.push_back(i);\n col.push_back(j);\n }\n\n // ----- 2. directed adjacency (cost = weight of destination) -------------\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n vector>> adj(V);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (id[i][j] != -1) {\n int u = id[i][j];\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int v = id[ni][nj];\n if (v == -1) continue;\n adj[u].push_back({v, weight[v]}); // cost = weight of v\n }\n }\n\n // start vertex id\n int start = id[si][sj];\n\n // ----- 3. all\u2011pairs shortest directed distances + predecessors ----------\n const int INF = 1e9;\n vector> dist(V, vector(V, INF));\n vector> parent(V, vector(V, -1));\n\n for (int s = 0; s < V; ++s) {\n priority_queue, vector>, greater>> pq;\n dist[s][s] = 0;\n pq.emplace(0, s);\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[s][u]) continue;\n for (auto [v, w] : adj[u]) {\n if (dist[s][v] > d + w) {\n dist[s][v] = d + w;\n parent[s][v] = u;\n pq.emplace(dist[s][v], v);\n }\n }\n }\n }\n\n // ----- 4. nearest\u2011neighbour tour (ATSP) --------------------------------\n vector tour;\n tour.reserve(V);\n vector visited(V, 0);\n tour.push_back(start);\n visited[start] = 1;\n int cur = start;\n while ((int)tour.size() < V) {\n int best = -1;\n int bestDist = INF;\n for (int v = 0; v < V; ++v) if (!visited[v]) {\n int d = dist[cur][v];\n if (d < bestDist) {\n bestDist = d;\n best = v;\n }\n }\n if (best == -1) break; // should never happen (graph is connected)\n visited[best] = 1;\n tour.push_back(best);\n cur = best;\n }\n\n // ----- 5. 2\u2011opt improvement --------------------------------------------\n bool improved = true;\n while (improved) {\n improved = false;\n int n = (int)tour.size();\n for (int i = 0; i < n - 1; ++i) {\n int u = tour[i];\n int v = tour[i + 1];\n for (int j = i + 2; j < n; ++j) {\n int x = tour[j];\n int y = (j + 1 == n ? tour[0] : tour[j + 1]);\n long long delta = (long long)dist[u][x] + dist[v][y]\n - ((long long)dist[u][v] + dist[x][y]);\n if (delta < 0) {\n reverse(tour.begin() + i + 1, tour.begin() + j + 1);\n improved = true;\n }\n }\n }\n }\n\n // ----- 6. reconstruct the actual walk ---------------------------------\n string moves;\n moves.reserve(200000); // enough for typical cases\n int n = (int)tour.size();\n for (int i = 0; i < n; ++i) {\n int src = tour[i];\n int dst = (i + 1 == n) ? tour[0] : tour[i + 1];\n // build shortest path src -> dst using predecessor table\n vector path;\n int curNode = dst;\n while (curNode != src) {\n path.push_back(curNode);\n curNode = parent[src][curNode];\n }\n path.push_back(src);\n reverse(path.begin(), path.end());\n for (size_t k = 0; k + 1 < path.size(); ++k) {\n int a = path[k];\n int b = path[k + 1];\n int dr = row[b] - row[a];\n int dc = col[b] - col[a];\n if (dr == -1) moves.push_back('U');\n else if (dr == 1) moves.push_back('D');\n else if (dc == -1) moves.push_back('L');\n else if (dc == 1) moves.push_back('R');\n // else: never happens (grid neighbours only)\n }\n }\n\n cout << moves << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n vector> d(N, vector(K));\n for (int i = 0; i < N; ++i)\n for (int k = 0; k < K; ++k)\n cin >> d[i][k];\n\n vector> succ(N);\n vector indeg(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n succ[u].push_back(v);\n ++indeg[v];\n }\n\n /* ---------- data kept between days ---------- */\n vector indeg_rem = indeg; // remaining indegrees\n vector status(N, 0); // 0 = not started, 1 = running, 2 = finished\n vector assigned_task(M, -1); // -1 = idle\n vector start_day(M, -1); // start day of current task\n vector> LB(M, vector(K, 0)); // lower bounds for skills\n\n // tasks whose indegree already became zero\n vector ready;\n for (int i = 0; i < N; ++i)\n if (indeg_rem[i] == 0) ready.push_back(i);\n\n // random generator for the \u03b5\u2011greedy exploration\n mt19937 rng(random_device{}());\n const double EPS = 0.1; // 10 % random choices\n uniform_real_distribution prob(0.0, 1.0);\n\n auto update_LB = [&](int w, int task, int t) {\n int L, U;\n if (t == 1) {\n L = 0; U = 0;\n } else {\n L = max(1, t - 3);\n U = t + 3;\n }\n // bound from the upper side of w\n for (int k = 0; k < K; ++k) {\n LB[w][k] = max(LB[w][k], d[task][k] - U);\n }\n // stronger bound when w = 0 (t = 1)\n if (t == 1) {\n for (int k = 0; k < K; ++k)\n LB[w][k] = max(LB[w][k], d[task][k]);\n }\n };\n\n auto cost = [&](int task, int w) -> int {\n int sum = 0;\n for (int k = 0; k < K; ++k) {\n int diff = d[task][k] - LB[w][k];\n if (diff > 0) sum += diff;\n }\n return sum; // this is w_opt, an upper bound for the real w\n };\n\n int day = 0;\n while (true) {\n ++day; // we are going to output assignments for this day\n\n /* ---------- 1) finish the day ---------- */\n // the line with completions is read *after* we have printed our assignments\n // (the loop body does exactly that)\n\n /* ---------- 2) produce output for today ---------- */\n // collect idle workers\n vector idle;\n for (int w = 0; w < M; ++w)\n if (assigned_task[w] == -1) idle.push_back(w);\n if (!idle.empty())\n shuffle(idle.begin(), idle.end(), rng); // random order -> random assignment when we use \u03b5\n\n // collect still waiting ready tasks (status == 0)\n vector ready_candidates;\n for (int t : ready)\n if (status[t] == 0) ready_candidates.push_back(t);\n\n vector> assignments; // (worker, task) pairs (1\u2011based)\n vector used_task(N, false); // tasks already taken this day\n\n // assign at most one task per idle worker\n for (int w : idle) {\n // build list of still free ready tasks\n vector still;\n for (int t : ready_candidates)\n if (!used_task[t]) still.push_back(t);\n if (still.empty()) break; // no more tasks to start\n\n int chosen_task = -1;\n\n if (prob(rng) < EPS) { // exploration: random task\n uniform_int_distribution pick(0, still.size() - 1);\n chosen_task = still[pick(rng)];\n } else { // exploitation: best according to LB\n int best_c = INT_MAX;\n int best_t = -1;\n for (int t : still) {\n int c = cost(t, w);\n if (c < best_c) {\n best_c = c;\n best_t = t;\n }\n }\n chosen_task = best_t;\n }\n\n // perform the assignment\n used_task[chosen_task] = true;\n assigned_task[w] = chosen_task;\n start_day[w] = day;\n status[chosen_task] = 1; // now running\n assignments.emplace_back(w + 1, chosen_task + 1);\n }\n\n // output\n if (assignments.empty()) {\n cout << 0 << \"\\n\";\n } else {\n cout << assignments.size();\n for (auto &p : assignments) cout << ' ' << p.first << ' ' << p.second;\n cout << \"\\n\";\n }\n cout.flush();\n\n /* ---------- 3) read completions of this day ---------- */\n string line;\n if (!getline(cin, line)) break; // should not happen\n while (line.size() == 0 && !cin.eof()) getline(cin, line); // skip empty lines (just in case)\n if (line.empty()) { /* treat as 0 completions */ line = \"0\"; }\n\n int first;\n {\n istringstream iss(line);\n iss >> first;\n }\n if (first == -1) break; // finished or day limit reached\n\n int cnt = first;\n vector finished_workers;\n {\n istringstream iss(line);\n iss >> cnt;\n for (int i = 0; i < cnt; ++i) {\n int x; iss >> x;\n finished_workers.push_back(x - 1);\n }\n }\n\n /* ---------- 4) process the completions ---------- */\n for (int w : finished_workers) {\n int tsk = assigned_task[w];\n if (tsk == -1) continue; // safety, should not happen\n int duration = day - start_day[w] + 1; // days really spent\n update_LB(w, tsk, duration);\n\n status[tsk] = 2; // finished\n for (int nxt : succ[tsk]) {\n --indeg_rem[nxt];\n if (indeg_rem[nxt] == 0 && status[nxt] == 0) {\n ready.push_back(nxt);\n }\n }\n assigned_task[w] = -1;\n start_day[w] = -1;\n }\n\n // safety: stop after day 2000 (the judge sends -1, but this is an extra guard)\n if (day >= 2000) break;\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nconst int BASE = 0; // id of the office\nint NPOINTS; // 2001\nvector X, Y; // coordinates, index = point id\nint pickNode[1000];\nint delvNode[1000];\nbool isPick[2001];\nint orderOf[2001]; // order id for a point\n\ninline int manhattan(int a, int b) {\n return abs(X[a] - X[b]) + abs(Y[a] - Y[b]);\n}\n\n/* --------------------------------------------------------------- */\n/* helper: index after removing one element ---------------------- */\ninline int idxAfterRem(int p, int removed) { // p \u2026 position in the shorter vector\n return (p < removed) ? p : p + 1;\n}\n\n/* --------------------------------------------------------------- */\n/* length of a tour (tour does NOT contain the office) ----------- */\nlong long tourLength(const vector& tour) {\n if (tour.empty()) return 0;\n long long len = manhattan(BASE, tour[0]) + manhattan(tour.back(), BASE);\n for (int i = 0; i + 1 < (int)tour.size(); ++i)\n len += manhattan(tour[i], tour[i + 1]);\n return len;\n}\n\n/* --------------------------------------------------------------- */\n/* build a feasible initial tour for a given set of orders ------- */\nvector buildInitialTour(const vector& orders) {\n vector pickups, deliveries;\n pickups.reserve(orders.size());\n deliveries.reserve(orders.size());\n for (int o : orders) {\n pickups.push_back(pickNode[o]);\n deliveries.push_back(delvNode[o]);\n }\n\n vector tour;\n int cur = BASE;\n int m = (int)pickups.size();\n vector used(m, 0);\n while ((int)tour.size() < m) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < m; ++i) if (!used[i]) {\n int d = manhattan(cur, pickups[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n used[best] = 1;\n tour.push_back(pickups[best]);\n cur = pickups[best];\n }\n\n int dsz = (int)deliveries.size();\n vector usedD(dsz, 0);\n while ((int)tour.size() < m + dsz) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < dsz; ++i) if (!usedD[i]) {\n int d = manhattan(cur, deliveries[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n usedD[best] = 1;\n tour.push_back(deliveries[best]);\n cur = deliveries[best];\n }\n return tour;\n}\n\n/* --------------------------------------------------------------- */\n/* relocate + 2\u2011opt local search (keeps feasibility) ------------- */\nvoid improveTour(vector& tour, const vector& selected) {\n int totalPoints = NPOINTS;\n vector pos(totalPoints, -1);\n auto updatePos = [&]() {\n fill(pos.begin(), pos.end(), -1);\n for (int i = 0; i < (int)tour.size(); ++i) pos[tour[i]] = i;\n };\n updatePos();\n\n const auto canMove = [&](int node, int a, int newPos) -> bool {\n int oid = orderOf[node];\n int other = isPick[node] ? delvNode[oid] : pickNode[oid];\n int otherPos = pos[other];\n int otherPosR = (otherPos > a) ? otherPos - 1 : otherPos;\n int b2 = (newPos > a) ? newPos - 1 : newPos;\n int finalPosNode = b2;\n int finalPosOther = (otherPosR > b2) ? otherPosOther + 1 : otherPosR;\n if (isPick[node]) return finalPosNode < finalPosOther;\n else return finalPosOther < finalPosNode;\n };\n\n const auto deltaRel = [&](int node, int a, int newPos) -> long long {\n int len = (int)tour.size();\n int L = (a == 0) ? BASE : tour[a - 1];\n int R = (a == len - 1) ? BASE : tour[a + 1];\n long long delta = - (manhattan(L, node) + manhattan(node, R));\n delta += manhattan(L, R);\n\n int b2 = (newPos > a) ? newPos - 1 : newPos;\n int leftIdx = (b2 == 0) ? -1 : idxAfterRem(b2 - 1, a);\n int rightIdx = (b2 == len - 1) ? -1 : idxAfterRem(b2, a);\n int L2 = (leftIdx == -1) ? BASE : tour[leftIdx];\n int R2 = (rightIdx == -1) ? BASE : tour[rightIdx];\n delta += manhattan(L2, node) + manhattan(node, R2) - manhattan(L2, R2);\n return delta;\n };\n\n const auto segmentSafe = [&](int l, int r) -> bool { // inclusive indices in tour\n for (int oid : selected) {\n int pp = pos[pickNode[oid]];\n int dd = pos[delvNode[oid]];\n if (pp != -1 && dd != -1 && pp >= l && pp <= r && dd >= l && dd <= r)\n return false;\n }\n return true;\n };\n\n bool progress = true;\n while (progress) {\n progress = false;\n /* ---------- relocation ----------------------------------- */\n long long bestDelta = 0;\n int bestNode = -1, bestNewPos = -1;\n int len = (int)tour.size();\n for (int i = 0; i < len; ++i) {\n int node = tour[i];\n for (int np = 0; np <= len; ++np) {\n if (np == i) continue;\n if (!canMove(node, i, np)) continue;\n long long d = deltaRel(node, i, np);\n if (d < bestDelta) {\n bestDelta = d;\n bestNode = node;\n bestNewPos = np;\n progress = true;\n }\n }\n }\n if (progress) {\n int a = -1;\n for (int k = 0; k < len; ++k) if (tour[k] == bestNode) a = k;\n int b = bestNewPos;\n tour.erase(tour.begin() + a);\n int b2 = (b > a) ? b - 1 : b;\n tour.insert(tour.begin() + b2, bestNode);\n updatePos();\n }\n\n /* ---------- 2\u2011opt ---------------------------------------- */\n long long bestDelta2 = 0;\n int best_i = -1, best_j = -1;\n len = (int)tour.size();\n for (int i = 0; i < len; ++i) {\n for (int j = i + 2; j < len; ++j) {\n if (!segmentSafe(i + 1, j)) continue;\n int A = (i == 0) ? BASE : tour[i - 1];\n int B = tour[i];\n int C = tour[j];\n int D = (j + 1 == len) ? BASE : tour[j + 1];\n long long d = (long long)manhattan(A, C) + manhattan(B, D)\n - (long long)manhattan(A, B) - manhattan(C, D);\n if (d < bestDelta2) {\n bestDelta2 = d;\n best_i = i;\n best_j = j;\n progress = true;\n }\n }\n }\n if (bestDelta2 < 0) {\n reverse(tour.begin() + best_i + 1, tour.begin() + best_j + 1);\n updatePos();\n }\n }\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n /* ----- read input ------------------------------------------ */\n const int ORD = 1000;\n vector> orders(ORD);\n for (int i = 0; i < ORD; ++i) {\n cin >> orders[i][0] >> orders[i][1] >> orders[i][2] >> orders[i][3];\n }\n\n /* ----- build point list (0 = office) ---------------------- */\n NPOINTS = 1 + 2 * ORD;\n X.resize(NPOINTS);\n Y.resize(NPOINTS);\n X[BASE] = 400; Y[BASE] = 400;\n for (int i = 0; i < ORD; ++i) {\n int pi = 2 * i + 1;\n int di = 2 * i + 2;\n X[pi] = orders[i][0]; Y[pi] = orders[i][1];\n X[di] = orders[i][2]; Y[di] = orders[i][3];\n pickNode[i] = pi;\n delvNode[i] = di;\n isPick[pi] = true; isPick[di] = false;\n orderOf[pi] = orderOf[di] = i;\n }\n\n /* ----- greedy subset --------------------------------------- */\n vector greedyIdx(ORD);\n iota(greedyIdx.begin(), greedyIdx.end(), 0);\n vector cost(ORD);\n for (int i = 0; i < ORD; ++i) {\n cost[i] = manhattan(BASE, pickNode[i])\n + manhattan(pickNode[i], delvNode[i])\n + manhattan(delvNode[i], BASE);\n }\n sort(greedyIdx.begin(), greedyIdx.end(),\n [&](int a, int b){ return cost[a] < cost[b]; });\n\n vector bestSubset;\n vector bestTour;\n long long bestLength = (1LL<<60);\n\n auto trySubset = [&](const vector& sub) {\n vector tour = buildInitialTour(sub);\n improveTour(tour, sub);\n long long L = tourLength(tour);\n if (L < bestLength) {\n bestLength = L;\n bestTour = tour;\n bestSubset = sub;\n }\n };\n\n /* first the greedy one */\n vector firstSubset(greedyIdx.begin(), greedyIdx.begin() + 50);\n trySubset(firstSubset);\n\n /* random subsets \u2013 a few dozen */\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n int trial = 0;\n const int MAX_TRIAL = 200;\n auto start = chrono::steady_clock::now();\n while (trial < MAX_TRIAL) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > 1.85) break; // safety margin\n\n vector ids(ORD);\n iota(ids.begin(), ids.end(), 0);\n shuffle(ids.begin(), ids.end(), rng);\n vector sub(ids.begin(), ids.begin() + 50);\n trySubset(sub);\n ++trial;\n }\n\n /* ----- output ---------------------------------------------- */\n cout << 50;\n for (int x : bestSubset) cout << ' ' << (x + 1);\n cout << '\\n';\n\n cout << (int)bestTour.size() + 2; // +2 for the two office points\n cout << \" 400 400\";\n for (int v : bestTour) cout << ' ' << X[v] << ' ' << Y[v];\n cout << \" 400 400\\n\";\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\n/*** Disjoint Set Union ********************************************/\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n r.assign(n, 0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n/******************************************************************/\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) cin >> X[i] >> Y[i];\n\n const int M = 1995; // given in the statement\n vector U(M), V(M);\n for (int i = 0; i < M; ++i) cin >> U[i] >> V[i];\n\n // ----- 1. compute lower\u2011bound distances d_i -----------------\n vector d(M);\n for (int i = 0; i < M; ++i) {\n long long dx = (long long)X[U[i]] - X[V[i]];\n long long dy = (long long)Y[U[i]] - Y[V[i]];\n double dist = sqrt((double)dx * dx + (double)dy * dy);\n d[i] = (int)llround(dist); // round to nearest integer\n }\n\n // ----- 2. build a spanning tree T using the lower bounds ----\n vector inTree(M, 0);\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(),\n [&](int a, int b) {\n if (d[a] != d[b]) return d[a] < d[b];\n return a < b;\n });\n\n DSU dsu_mst(N);\n int taken = 0;\n for (int id : ord) {\n if (dsu_mst.unite(U[id], V[id])) {\n inTree[id] = 1;\n ++taken;\n if (taken == N - 1) break;\n }\n }\n\n // ----- 3. online processing ---------------------------------\n DSU dsu(N);\n for (int i = 0; i < M; ++i) {\n int L; // true length of edge i\n cin >> L;\n\n int decision = 0;\n if (dsu.find(U[i]) != dsu.find(V[i])) {\n if (inTree[i] || L <= 2 * d[i]) {\n decision = 1;\n dsu.unite(U[i], V[i]);\n }\n }\n cout << decision << '\\n';\n cout.flush();\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nconst int SZ = 30;\nconst int MAX_WALLS_PER_HUMAN = 50; // enough to surround a corner\n\nstruct Pet {\n int x, y, type;\n};\n\nstruct Human {\n int x, y; // current position\n int hx, hy; // home corner\n bool reached = false;\n int walls = 0; // walls already placed by this human\n};\n\nint sgn(int a) { return (a > 0) - (a < 0); }\n\nint dx[4] = {-1, 1, 0, 0};\nint dy[4] = { 0, 0,-1, 1};\nchar wCh[4] = {'u','d','l','r'};\nchar mCh[4] = {'U','D','L','R'};\n\ninline bool inside(int x,int y){ return x>=1 && x<=SZ && y>=1 && y<=SZ; }\ninline bool passable(int x,int y){ return inside(x,y) && !wall[x][y]; }\n\nbool wall[SZ+1][SZ+1];\nbool petAt[SZ+1][SZ+1];\n\nvector pets;\nvector hums;\n\n/* --------------------------------------------------------------- */\n// predicates\n\nbool petOn(int x,int y){ return petAt[x][y]; }\n\nbool humanOn(int x,int y){\n for(const auto& h : hums) if(h.x==x && h.y==y) return true;\n return false;\n}\n\nbool adjacentPet(int x,int y){\n for(int d=0; d<4; ++d){\n int nx=x+dx[d], ny=y+dy[d];\n if(inside(nx,ny) && petAt[nx][ny]) return true;\n }\n return false;\n}\n\n// can we put a wall on the neighbour 'dir' of human h ?\nbool canWall(const Human& h,int dir){\n int nx=h.x+dx[dir], ny=h.y+dy[dir];\n if(!inside(nx,ny)) return false;\n if(wall[nx][ny]) return false; // already a wall\n if(petOn(nx,ny) || humanOn(nx,ny)) return false;\n if(adjacentPet(nx,ny)) return false; // rule of the statement\n // after the wall we must still have at least one other passable neighbour\n int cnt=0;\n for(int d=0; d<4; ++d){\n int mx=h.x+dx[d], my=h.y+dy[d];\n if(mx==nx && my==ny) continue; // the new wall\n if(passable(mx,my)) ++cnt;\n }\n return cnt>0;\n}\n\n// can we move to the neighbour 'dir' ?\nbool canMove(const Human& h,int dir){\n int nx=h.x+dx[dir], ny=h.y+dy[dir];\n return inside(nx,ny) && passable(nx,ny);\n}\n\n/* --------------------------------------------------------------- */\n// choose homes for the humans (distinct, not occupied)\n\nvoid assignHomes(){\n vector> cand = {\n {1,1},{1,SZ},{SZ,1},{SZ,SZ},\n {1,SZ/2},{SZ,SZ/2},{SZ/2,1},{SZ/2,SZ},\n {8,8},{22,22}\n };\n int idx=0;\n for(int i=0;i<(int)hums.size();++i){\n while(true){\n auto p = cand[idx++];\n bool ok = true;\n // not occupied by a pet\n for(const auto& pet: pets)\n if(pet.x==p.first && pet.y==p.second){ ok=false; break; }\n if(ok){\n hums[i].hx = p.first;\n hums[i].hy = p.second;\n break;\n }\n }\n }\n}\n\n/* --------------------------------------------------------------- */\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if(!(cin>>N)) return 0;\n pets.resize(N);\n for(int i=0;i>pets[i].x>>pets[i].y>>pets[i].type;\n }\n int M;\n cin>>M;\n hums.resize(M);\n for(int i=0;i>hums[i].x>>hums[i].y;\n }\n\n // initialise board\n for(int x=1;x<=SZ;++x) for(int y=1;y<=SZ;++y) wall[x][y]=false;\n for(int i=0;i actDir(M, -1); // -1 = stay, 0..3 = direction\n vector actWall(M, false); // true = wall, false = move (or stay)\n\n for(int i=0;i> willWall(SZ+1, vector(SZ+1,false));\n vector> willMove(SZ+1, vector(SZ+1,false));\n\n for(int i=0;i cancel wall\n if(actWall[i]){\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if(willMove[nx][ny]){\n // cancel wall\n actWall[i]=false;\n actDir[i]=-1;\n }\n }\n }\n\n // ---- output the actions ---------------------------------------\n string out;\n out.reserve(M);\n for(int i=0;i> s; // the input guarantees exactly N strings\n for(char c: s){\n int dir=-1;\n if(c=='U') dir=0;\n else if(c=='D') dir=1;\n else if(c=='L') dir=2;\n else if(c=='R') dir=3;\n else continue; // '.' or anything else \u2013 do nothing\n int nx = pets[i].x + dx[dir];\n int ny = pets[i].y + dy[dir];\n if(inside(nx,ny) && passable(nx,ny)){\n pets[i].x = nx;\n pets[i].y = ny;\n }\n }\n }\n\n // ---- update petAt for the next turn ----------------------------\n for(int x=1;x<=SZ;++x) for(int y=1;y<=SZ;++y) petAt[x][y]=false;\n for(const auto& p: pets) petAt[p.x][p.y]=true;\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj, ti, tj;\n double p;\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n \n const int N = 20;\n vector h(N); // horizontal walls, size 20 \u00d7 19\n for (int i = 0; i < N; ++i) cin >> h[i];\n vector v(N - 1); // vertical walls, size 19 \u00d7 20\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n \n // directions: 0 = up, 1 = down, 2 = left, 3 = right\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dch[4] = {'U', 'D', 'L', 'R'};\n \n auto can_move = [&](int i, int j, int dir) -> bool {\n if (dir == 0) { // up\n if (i == 0) return false;\n return v[i-1][j] == '0';\n } else if (dir == 1) { // down\n if (i == N-1) return false;\n return v[i][j] == '0';\n } else if (dir == 2) { // left\n if (j == 0) return false;\n return h[i][j-1] == '0';\n } else { // right\n if (j == N-1) return false;\n return h[i][j] == '0';\n }\n };\n \n vector> dist(N, vector(N, -1));\n vector>> prev(N, vector>(N, {-1,-1}));\n vector> pred_dir(N, vector(N, 0));\n \n queue> q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n \n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break; // reached destination\n for (int dir = 0; dir < 4; ++dir) {\n if (!can_move(i, j, dir)) continue;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (dist[ni][nj] != -1) continue;\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n pred_dir[ni][nj] = dch[dir];\n q.emplace(ni, nj);\n }\n }\n \n // reconstruct path\n string ans;\n int ci = ti, cj = tj;\n while (!(ci == si && cj == sj)) {\n ans.push_back(pred_dir[ci][cj]);\n auto pr = prev[ci][cj];\n ci = pr.first; cj = pr.second;\n }\n reverse(ans.begin(), ans.end());\n \n // length is guaranteed \u2264200 for the test data\n cout << ans << '\\n';\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30, W = 30, N = H * W;\n\n/* directions: 0 left, 1 up, 2 right, 3 down */\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nint neighbor_id(int idx, int dir) {\n int i = idx / W, j = idx % W;\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) return -1;\n return ni * W + nj;\n}\n\n/* --------------------------------------------------------------- */\n/* pre\u2011computed neighbour lists for every tile and every rotation */\nvector>> neigh; // [idx][rot] -> vector of neighbour ids (may contain -1)\n\n/* --------------------------------------------------------------- */\n\nvector> adj; // adjacency lists (no duplicated edges)\n\n/* ----- component handling -------------------------------------- */\nvector compId; // component id of each vertex\nvector> compNodes; // vertices of each component\nvector compEdge; // edge count of each component\n\nstruct Cmp {\n bool operator()(const pair& a, const pair& b) const {\n if (a.first != b.first) return a.first < b.first;\n return a.second < b.second;\n }\n};\nmultiset, Cmp> compSet; // (-edgeCnt , id)\n\nint product_from_set() {\n if (compSet.empty()) return 0;\n auto it = compSet.begin(); // smallest => largest edgeCnt\n int L1 = -it->first;\n ++it;\n int L2 = (it == compSet.end()) ? 0 : -it->first;\n return L1 * L2;\n}\n\n/* --------------------------------------------------------------- */\n/* low level edge operations (without component updates) */\ninline void addAdj(int u, int v) { // used only for the initial graph\n adj[u].push_back(v);\n adj[v].push_back(u);\n}\n\n/* --------------------------------------------------------------- */\ninline bool edge_exists(int u, int v) {\n for (int nb : adj[u]) if (nb == v) return true;\n return false;\n}\n\n/* --------------------------------------------------------------- */\n/* component\u2011aware edge operations (used during the search) */\nvoid addEdge(int u, int v) {\n if (edge_exists(u, v)) return; // already present \u2013 nothing to do\n // add adjacency\n adj[u].push_back(v);\n adj[v].push_back(u);\n\n int cu = compId[u];\n int cv = compId[v];\n if (cu == cv) { // same component \u2013 just increase edge count\n int oldc = compEdge[cu];\n int newc = oldc + 1;\n compEdge[cu] = newc;\n compSet.erase({-oldc, cu});\n compSet.insert({-newc, cu});\n } else { // merge two components\n int oldcU = compEdge[cu];\n int oldcV = compEdge[cv];\n compSet.erase({-oldcU, cu});\n compSet.erase({-oldcV, cv});\n\n // keep the larger component as the target\n int target = (compNodes[cu].size() >= compNodes[cv].size()) ? cu : cv;\n int source = (target == cu) ? cv : cu;\n\n int newc = oldcU + oldcV + 1;\n // move all vertices of source to target\n for (int node : compNodes[source]) {\n compId[node] = target;\n compNodes[target].push_back(node);\n }\n compNodes[source].clear();\n compEdge[target] = newc;\n compSet.insert({-newc, target});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid removeEdge(int u, int v) {\n // erase adjacency entries\n auto &vecU = adj[u];\n for (size_t i = 0; i < vecU.size(); ++i) {\n if (vecU[i] == v) {\n vecU[i] = vecU.back();\n vecU.pop_back();\n break;\n }\n }\n auto &vecV = adj[v];\n for (size_t i = 0; i < vecV.size(); ++i) {\n if (vecV[i] == u) {\n vecV[i] = vecV.back();\n vecV.pop_back();\n break;\n }\n }\n\n int cid = compId[u]; // u and v belong to the same component\n int oldc = compEdge[cid];\n compSet.erase({-oldc, cid});\n\n // BFS from u after the edge has been removed\n vector vis(N, 0);\n vector partA;\n queue q;\n q.push(u);\n vis[u] = 1;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n partA.push_back(x);\n for (int nb : adj[x]) {\n if (!vis[nb]) {\n vis[nb] = 1;\n q.push(nb);\n }\n }\n }\n\n bool split = !vis[v]; // if v is unreachable -> bridge\n if (!split) { // component stayed connected\n int newc = oldc - 1;\n compEdge[cid] = newc;\n compSet.insert({-newc, cid});\n } else {\n // split into two components: partA and partB\n vector partB;\n for (int node : compNodes[cid]) {\n if (!vis[node]) partB.push_back(node);\n }\n\n long long sumDegA = 0, sumDegB = 0;\n for (int node : partA) sumDegA += adj[node].size();\n for (int node : partB) sumDegB += adj[node].size();\n int cntA = int(sumDegA / 2);\n int cntB = int(sumDegB / 2);\n\n // keep the old id for partA, create a new id for partB\n compNodes[cid] = partA;\n int newId = (int)compNodes.size();\n compNodes.push_back(partB);\n compEdge.push_back(cntB);\n for (int node : partB) compId[node] = newId;\n // partA already has id = cid\n\n compSet.insert({-cntA, cid});\n compSet.insert({-cntB, newId});\n }\n}\n\n/* --------------------------------------------------------------- */\n/* rebuild component information from scratch (used for the start) */\nvoid build_components() {\n compId.assign(N, -1);\n compNodes.clear();\n compEdge.clear();\n compSet.clear();\n\n vector vis(N, 0);\n for (int v = 0; v < N; ++v) if (!vis[v]) {\n vector nodes;\n queue q;\n q.push(v);\n vis[v] = 1;\n long long sumDeg = 0;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n nodes.push_back(x);\n sumDeg += adj[x].size();\n for (int nb : adj[x]) if (!vis[nb]) {\n vis[nb] = 1;\n q.push(nb);\n }\n }\n int cid = (int)compNodes.size();\n compNodes.push_back(nodes);\n compEdge.push_back(int(sumDeg / 2));\n for (int node : nodes) compId[node] = cid;\n compSet.insert({-compEdge[cid], cid});\n }\n}\n\n/* --------------------------------------------------------------- */\n/* initialise adjacency from a rotation vector */\nvoid init_adj(const vector& rot) {\n adj.assign(N, vector());\n for (int idx = 0; idx < N; ++idx) {\n int r = rot[idx];\n for (int nb : neigh[idx][r]) {\n if (nb != -1) addAdj(idx, nb);\n }\n }\n for (int i = 0; i < N; ++i) {\n auto &v = adj[i];\n sort(v.begin(), v.end());\n v.erase(unique(v.begin(), v.end()), v.end());\n }\n}\n\n/* --------------------------------------------------------------- */\n/* apply one rotation to a single tile, return new score */\nint apply_move(int idx, int new_rot, vector& rot) {\n int old_rot = rot[idx];\n if (old_rot == new_rot) return product_from_set();\n\n const vector& old_nb = neigh[idx][old_rot];\n const vector& new_nb = neigh[idx][new_rot];\n\n // edges to delete\n for (int nb : old_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : new_nb) if (x == nb) { exists = true; break; }\n if (!exists) removeEdge(idx, nb);\n }\n // edges to add\n for (int nb : new_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : old_nb) if (x == nb) { exists = true; break; }\n if (!exists) addEdge(idx, nb);\n }\n\n rot[idx] = new_rot;\n return product_from_set();\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n /* read the board */\n vector type(N);\n for (int i = 0; i < H; ++i) {\n string line;\n cin >> line;\n for (int j = 0; j < W; ++j) {\n type[i * W + j] = line[j] - '0';\n }\n }\n\n /* pre\u2011compute neighbour lists for all rotations */\n const vector> base[8] = {\n {{0,1}}, // type 0\n {{0,3}}, // type 1\n {{2,3}}, // type 2\n {{1,2}}, // type 3\n {{0,1},{2,3}}, // type 4\n {{0,3},{1,2}}, // type 5\n {{0,2}}, // type 6\n {{1,3}} // type 7\n };\n\n neigh.assign(N, vector>(4));\n for (int idx = 0; idx < N; ++idx) {\n int t = type[idx];\n for (int r = 0; r < 4; ++r) {\n vector cur;\n for (auto [a,b] : base[t]) {\n int s1 = (a + 3 * r) % 4;\n int s2 = (b + 3 * r) % 4;\n int nb1 = neighbor_id(idx, s1);\n int nb2 = neighbor_id(idx, s2);\n cur.push_back(nb1);\n cur.push_back(nb2);\n }\n neigh[idx][r] = cur;\n }\n }\n\n /* greedy initial rotation (most neighbours) */\n vector best_rot(N);\n for (int idx = 0; idx < N; ++idx) {\n int best = 0, bestCnt = -1;\n for (int r = 0; r < 4; ++r) {\n int cnt = 0;\n for (int nb : neigh[idx][r]) if (nb != -1) ++cnt;\n if (cnt > bestCnt) {\n bestCnt = cnt;\n best = r;\n }\n }\n best_rot[idx] = best;\n }\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n\n int best_score = 0;\n vector answer_rot = best_rot; // final answer\n\n const int RESTARTS = 4;\n const int STEPS_PER_RESTART = 1500;\n\n for (int trial = 0; trial < RESTARTS; ++trial) {\n /* start configuration \u2013 greedy + a few random changes */\n vector cur_rot = best_rot;\n for (int i = 0; i < N; ++i)\n if (rng() % 3 == 0) cur_rot[i] = rng() % 4;\n\n init_adj(cur_rot);\n build_components();\n int cur_score = product_from_set();\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n\n /* hill climbing */\n for (int step = 0; step < STEPS_PER_RESTART; ++step) {\n int idx = rng() % N;\n int old_r = cur_rot[idx];\n int cand = (old_r + 1 + rng() % 3) % 4; // try another rotation\n if (cand == old_r) continue;\n\n int new_score = apply_move(idx, cand, cur_rot);\n if (new_score > cur_score) {\n cur_score = new_score;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n } else {\n // revert\n apply_move(idx, old_r, cur_rot);\n }\n }\n }\n\n /* output */\n string out;\n out.reserve(N);\n for (int i = 0; i < N; ++i) out.push_back(char('0' + answer_rot[i]));\n cout << out << '\\n';\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\n// ------------------------------------------------------------\n// bit masks\nconst int BIT_LEFT = 1; // 0001\nconst int BIT_UP = 2; // 0010\nconst int BIT_RIGHT = 4; // 0100\nconst int BIT_DOWN = 8; // 1000\n\n// direction arrays: 0-up,1-down,2-left,3-right\nconst int DI[4] = {-1, 1, 0, 0};\nconst int DJ[4] = {0, 0, -1, 1};\n\n// ------------------------------------------------------------\n// Hopcroft\u2013Karp for bipartite matching (left size = right size = M)\nstruct HopcroftKarp {\n int nLeft, nRight;\n vector> adj;\n vector dist, pairU, pairV;\n\n HopcroftKarp(int L, int R) : nLeft(L), nRight(R) {\n adj.assign(nLeft, {});\n pairU.assign(nLeft, -1);\n pairV.assign(nRight, -1);\n dist.resize(nLeft);\n }\n void addEdge(int u, int v) { adj[u].push_back(v); }\n\n bool bfs() {\n queue q;\n for (int u = 0; u < nLeft; ++u) {\n if (pairU[u] == -1) {\n dist[u] = 0;\n q.push(u);\n } else dist[u] = -1;\n }\n bool found = 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) found = true;\n }\n }\n return found;\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 int maxMatching() {\n int matching = 0;\n while (bfs()) {\n for (int u = 0; u < nLeft; ++u)\n if (pairU[u] == -1 && dfs(u))\n ++matching;\n }\n return matching;\n }\n};\n\n// ------------------------------------------------------------\nint sgn(int x) { return (x > 0) - (x < 0); }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n if (!(cin >> N >> T)) return 0;\n vector raw(N);\n for (int i = 0; i < N; ++i) cin >> raw[i];\n\n // --------------------------------------------------------\n // initialise board, masks, positions\n int M = N * N - 1; // number of tiles\n vector tileMask(M);\n vector> tilePos(M); // current positions of tiles\n vector> board(N, vector(N, -1));\n vector> cellIndex(N, vector(N, -1));\n vector> cellCoord; // coordinate of each cell (by its index)\n pair emptyPos;\n int tileId = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c = raw[i][j];\n int mask = (c >= '0' && c <= '9') ? (c - '0')\n : (10 + c - 'a');\n if (mask == 0) {\n emptyPos = {i, j};\n board[i][j] = -1;\n } else {\n board[i][j] = tileId;\n tileMask[tileId] = mask;\n tilePos[tileId] = {i, j};\n cellIndex[i][j] = tileId; // reuse same numbering (convenient)\n cellCoord.push_back({i, j});\n ++tileId;\n }\n }\n }\n // --------------------------------------------------------\n // target positions (filled after matching)\n vector> targetPos(M, {-1,-1});\n\n // --------------------------------------------------------\n // try to find a spanning tree and a perfect matching\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n const int MAX_TRIES = 200;\n bool ok = false;\n for (int attempt = 0; attempt < MAX_TRIES && !ok; ++attempt) {\n // ----- build a random spanning tree on the non\u2011empty cells\n vector> visited(N, vector(N, false));\n vector,pair>> edges; // list of tree edges\n // start from the first non\u2011empty cell\n int sr = -1, sc = -1;\n for (int i = 0; i < N && sr==-1; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1) { sr = i; sc = j; }\n if (sr==-1) continue; // should not happen\n stack> st;\n st.emplace(sr, sc);\n visited[sr][sc] = true;\n\n while (!st.empty()) {\n auto [r,c] = st.top(); st.pop();\n // random order of directions\n array dirs = {0,1,2,3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int nr = r + DI[d];\n int nc = c + DJ[d];\n if (nr<0||nr>=N||nc<0||nc>=N) continue;\n if (board[nr][nc]==-1) continue; // empty cell \u2013 cannot be part of the tree\n if (visited[nr][nc]) continue;\n visited[nr][nc] = true;\n st.emplace(nr,nc);\n edges.push_back({{r,c},{nr,nc}});\n }\n }\n int cnt = 0;\n for (int i=0;i> requiredMaskGrid(N, vector(N, 0));\n for (auto &e : edges) {\n auto p1 = e.first, p2 = e.second;\n int r1 = p1.first, c1 = p1.second;\n int r2 = p2.first, c2 = p2.second;\n int dr = r2 - r1, dc = c2 - c1;\n if (dr == 1) { // second cell is below first\n requiredMaskGrid[r1][c1] |= BIT_DOWN;\n requiredMaskGrid[r2][c2] |= BIT_UP;\n } else if (dr == -1) { // second cell is above first\n requiredMaskGrid[r1][c1] |= BIT_UP;\n requiredMaskGrid[r2][c2] |= BIT_DOWN;\n } else if (dc == 1) { // right\n requiredMaskGrid[r1][c1] |= BIT_RIGHT;\n requiredMaskGrid[r2][c2] |= BIT_LEFT;\n } else { // left\n requiredMaskGrid[r1][c1] |= BIT_LEFT;\n requiredMaskGrid[r2][c2] |= BIT_RIGHT;\n }\n }\n\n // ----- build the bipartite graph (cell -> tile) using equality of masks\n vector requiredMask(M);\n for (int i=0;i moves;\n moves.reserve(T);\n\n auto applyMove = [&](char dir) {\n int ex = emptyPos.first, ey = emptyPos.second;\n int nx = ex, ny = ey;\n if (dir == 'U') nx--;\n else if (dir == 'D') nx++;\n else if (dir == 'L') ny--;\n else if (dir == 'R') ny++;\n // neighbour must exist (the algorithm guarantees it)\n int tile = board[nx][ny];\n // swap\n board[ex][ey] = tile;\n board[nx][ny] = -1;\n if (tile != -1) tilePos[tile] = {nx, ny};\n emptyPos = {nx, ny};\n moves.push_back(dir);\n };\n\n auto moveEmptyTo = [&](int tr, int tc) {\n while (emptyPos.first > tr) applyMove('U');\n while (emptyPos.first < tr) applyMove('D');\n while (emptyPos.second > tc) applyMove('L');\n while (emptyPos.second < tc) applyMove('R');\n };\n\n // greedy placement\n while (true) {\n // find tile with minimal (empty distance + 1)\n int bestTile = -1;\n int bestCost = INT_MAX;\n int bestNeedX = -1, bestNeedY = -1;\n int bestStepX = 0, bestStepY = 0;\n\n for (int tid = 0; tid < M; ++tid) {\n auto cur = tilePos[tid];\n auto tgt = targetPos[tid];\n if (cur == tgt) continue;\n int dx = tgt.first - cur.first;\n int dy = tgt.second - cur.second;\n\n // vertical move\n if (dx != 0) {\n int step = sgn(dx);\n int nx = cur.first + step;\n int ny = cur.second;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = tid;\n bestNeedX = nx; bestNeedY = ny;\n bestStepX = step; bestStepY = 0;\n }\n }\n // horizontal move\n if (dy != 0) {\n int step = sgn(dy);\n int nx = cur.first;\n int ny = cur.second + step;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = tid;\n bestNeedX = nx; bestNeedY = ny;\n bestStepX = 0; bestStepY = step;\n }\n }\n }\n if (bestTile == -1) break; // all tiles are on target\n\n // move empty square to the needed neighbour\n moveEmptyTo(bestNeedX, bestNeedY);\n\n // slide the chosen tile one step\n char cmd;\n if (bestStepX != 0) {\n cmd = (bestStepX == -1) ? 'D' : 'U';\n } else {\n cmd = (bestStepY == -1) ? 'R' : 'L';\n }\n applyMove(cmd);\n\n // after the slide the tile has moved one step\n tilePos[bestTile].first += bestStepX;\n tilePos[bestTile].second += bestStepY;\n\n if ((int)moves.size() >= T) break;\n }\n\n // --------------------------------------------------------\n // Output\n string out(moves.begin(), moves.end());\n cout << out << \"\\n\";\n\n // --------------------------------------------------------\n // (optional) verification \u2013 compute the score locally\n // -------------------------------------------------------------\n // build graph from final board\n int maxTreeSize = 0;\n int V = 0;\n vector> vid(N, vector(N, -1));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1) vid[i][j] = V++;\n\n vector> g(V);\n auto addEdge = [&](int r1,int c1,int r2,int c2){\n if (r2<0||r2>=N||c2<0||c2>=N) return;\n if (board[r1][c1]==-1 || board[r2][c2]==-1) return;\n int m1 = tileMask[board[r1][c1]];\n int m2 = tileMask[board[r2][c2]];\n bool ok = false;\n if (r2 == r1+1) { // downwards\n if ((m1 & BIT_DOWN) && (m2 & BIT_UP)) ok = true;\n } else if (c2 == c1+1) { // rightwards\n if ((m1 & BIT_RIGHT) && (m2 & BIT_LEFT)) ok = true;\n }\n if (ok) {\n int u = vid[r1][c1], v = vid[r2][c2];\n g[u].push_back(v);\n g[v].push_back(u);\n }\n };\n\n for (int i=0;i seen(V,0);\n for (int i=0;i q;\n q.push(i); seen[i]=1;\n while(!q.empty()){\n int u=q.front(); q.pop();\n ++vertices;\n edges += (int)g[u].size();\n for(int v:g[u]) if(!seen[v]){\n seen[v]=1; q.push(v);\n }\n }\n edges /= 2;\n if (edges == vertices-1) // a tree\n maxTreeSize = max(maxTreeSize, vertices);\n }\n\n // -------------------------------------------------------------\n // the program does not have to output the score,\n // only the move string is required.\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\nusing i128 = __int128_t;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, K;\n if (!(cin >> N >> K)) return 0;\n vector a(11);\n for (int d = 1; d <= 10; ++d) cin >> a[d];\n vector> pt(N);\n for (int i = 0; i < N; ++i) cin >> pt[i].first >> pt[i].second;\n\n const int64 R = 10000; // radius of the cake\n const int64 LIM = 1000000000LL; // maximal coordinate value\n\n mt19937_64 rng(random_device{}());\n uniform_int_distribution dist(-R, R);\n\n const int MAX_TRIES = 200000; // more than enough\n vector> lines;\n lines.reserve(K);\n\n int tries = 0;\n while ((int)lines.size() < K && tries < MAX_TRIES) {\n ++tries;\n // first point\n int64 x1 = dist(rng), y1 = dist(rng);\n if (x1*x1 + y1*y1 >= (int64)R*R) continue; // must be inside the disc\n // second point\n int64 x2 = dist(rng), y2 = dist(rng);\n if (x2*x2 + y2*y2 >= (int64)R*R) continue;\n if (x1 == x2 && y1 == y2) continue; // distinct points\n\n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (auto &p : pt) {\n i128 cross = (i128)dx * (i128)(p.second - y1)\n - (i128)dy * (i128)(p.first - x1);\n if (cross == 0) { // a strawberry lies on the line\n ok = false;\n break;\n }\n }\n if (ok) {\n lines.emplace_back(x1, y1, x2, y2);\n tries = 0; // reset, we succeeded\n }\n }\n\n // -----------------------------------------------------------------\n // In the extremely unlikely event that we could not find K lines,\n // fill the rest with axis aligned lines that are guaranteed safe.\n if ((int)lines.size() < K) {\n unordered_set forbX, forbY;\n for (auto &p : pt) {\n forbX.insert(p.first);\n forbY.insert(p.second);\n }\n vector xs, ys;\n for (int64 x = -R; x <= R; ++x)\n if (!forbX.count(x)) xs.push_back(x);\n for (int64 y = -R; y <= R; ++y)\n if (!forbY.count(y)) ys.push_back(y);\n\n size_t i = 0, j = 0;\n while ((int)lines.size() < K) {\n if (i < xs.size()) {\n int64 x0 = xs[i++];\n lines.emplace_back(x0, -LIM, x0, LIM); // vertical\n } else {\n int64 y0 = ys[j++];\n lines.emplace_back(-LIM, y0, LIM, y0); // horizontal\n }\n }\n }\n\n // -----------------------------------------------------------------\n cout << lines.size() << '\\n';\n for (auto &ln : lines) {\n int64 x1, y1, x2, y2;\n tie(x1, y1, x2, y2) = ln;\n cout << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << '\\n';\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2, x3, y3, x4, y4;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n if (!(cin >> N >> M)) return 0;\n\n vector> dot(N, vector(N, 0));\n vector> init;\n for (int i = 0; i < M; ++i) {\n int x, y; cin >> x >> y;\n dot[x][y] = 1;\n init.emplace_back(x, y);\n }\n\n /* ----- edges --------------------------------------------------- */\n vector> hor(N, vector(N, 0)); // (x,y)-(x+1,y)\n vector> ver(N, vector(N, 0)); // (x,y)-(x,y+1)\n\n /* ----- row / column lists of dotted points -------------------- */\n vector> rowDots(N), colDots(N);\n for (auto &p : init) {\n int x = p.first, y = p.second;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n }\n\n /* ----- all empty points ---------------------------------------- */\n vector> empty;\n for (int x = 0; x < N; ++x)\n for (int y = 0; y < N; ++y)\n if (!dot[x][y]) empty.emplace_back(x, y);\n\n vector answer;\n\n /* ----- helper lambdas ----------------------------------------- */\n auto sidesEmpty = [&](int x, int y, int x2, int y2) -> bool {\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n // side (x,y)-(x2,y)\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y]) return false;\n // side (x,y)-(x,y2)\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x][yi]) return false;\n // side (x2,y)-(x2,y2)\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x2][yi]) return false;\n // side (x,y2)-(x2,y2)\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y2]) return false;\n return true;\n };\n\n auto edgesFree = [&](int x, int y, int x2, int y2) -> bool {\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n // horizontal side on row y\n for (int xi = xlo; xi < xhi; ++xi)\n if (hor[xi][y]) return false;\n // vertical side on column x\n for (int yi = ylo; yi < yhi; ++yi)\n if (ver[x][yi]) return false;\n // horizontal side on row y2\n for (int xi = xlo; xi < xhi; ++xi)\n if (hor[xi][y2]) return false;\n // vertical side on column x2\n for (int yi = ylo; yi < yhi; ++yi)\n if (ver[x2][yi]) return false;\n return true;\n };\n\n auto addRect = [&](int x, int y, int x2, int y2) {\n Rect r{ x, y, x2, y, x2, y2, x, y2 };\n answer.push_back(r);\n\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n for (int xi = xlo; xi < xhi; ++xi) hor[xi][y] = 1;\n for (int yi = ylo; yi < yhi; ++yi) ver[x][yi] = 1;\n for (int xi = xlo; xi < xhi; ++xi) hor[xi][y2] = 1;\n for (int yi = ylo; yi < yhi; ++yi) ver[x2][yi] = 1;\n\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n };\n\n function tryAdd = [&](int x, int y) -> bool {\n const vector &cols = rowDots[y]; // points in same row\n const vector &rows = colDots[x]; // points in same column\n for (int x2 : cols) {\n if (x2 == x) continue;\n for (int y2 : rows) {\n if (y2 == y) continue;\n if (!dot[x2][y2]) continue; // opposite corner must exist\n if (!sidesEmpty(x, y, x2, y2)) continue;\n if (!edgesFree(x, y, x2, y2)) continue;\n addRect(x, y, x2, y2);\n return true;\n }\n }\n return false;\n };\n\n /* ----- main greedy loop --------------------------------------- */\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n while (true) {\n bool progress = false;\n shuffle(empty.begin(), empty.end(), rng);\n for (size_t i = 0; i < empty.size(); ++i) {\n int x = empty[i].first, y = empty[i].second;\n if (tryAdd(x, y)) {\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n break; // restart with fresh list\n }\n }\n if (!progress) break;\n }\n\n /* ----- output -------------------------------------------------- */\n cout << answer.size() << '\\n';\n for (const auto &r : answer) {\n cout << r.x1 << ' ' << r.y1 << ' '\n << r.x2 << ' ' << r.y2 << ' '\n << r.x3 << ' ' << r.y3 << ' '\n << r.x4 << ' ' << r.y4 << '\\n';\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\n/*** board size ***/\nconstexpr int H = 10;\nconstexpr int W = 10;\n\n/*** direction characters ***/\nstatic const char DIRS[4] = {'F', 'B', 'L', 'R'};\n\n/*** copy board ***/\nvoid copyBoard(const int src[H][W], int dst[H][W]) {\n for (int i = 0; i < H; ++i)\n for (int j = 0; j < W; ++j)\n dst[i][j] = src[i][j];\n}\n\n/*** tilt the board in the given direction ***/\nvoid tiltBoard(int a[H][W], char dir) {\n if (dir == 'F') { // forward -> up\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = 0; r < H; ++r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[i][c] = buf[i];\n }\n } else if (dir == 'B') { // backward -> down\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = H - 1; r >= 0; --r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[H - 1 - i][c] = buf[i];\n }\n } else if (dir == 'L') { // left -> left\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = 0; c < W; ++c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][i] = buf[i];\n }\n } else if (dir == 'R') { // right -> right\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = W - 1; c >= 0; --c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][W - 1 - i] = buf[i];\n }\n }\n}\n\n/*** evaluation result for a board ***/\nstruct Eval {\n int sumSq; // \u03a3 size\u00b2\n int maxSize; // size of the largest component\n int compCnt; // number of components\n};\n\nEval evaluate(const int a[H][W]) {\n bool vis[H][W] = {false};\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n\n Eval res{0, 0, 0};\n for (int r = 0; r < H; ++r) {\n for (int c = 0; c < W; ++c) {\n if (a[r][c] && !vis[r][c]) {\n int flavor = a[r][c];\n int sz = 0;\n queue> q;\n q.emplace(r, c);\n vis[r][c] = true;\n while (!q.empty()) {\n auto [cr, cc] = q.front(); q.pop();\n ++sz;\n for (int d = 0; d < 4; ++d) {\n int nr = cr + dr[d];\n int nc = cc + dc[d];\n if (nr >= 0 && nr < H && nc >= 0 && nc < W &&\n !vis[nr][nc] && a[nr][nc] == flavor) {\n vis[nr][nc] = true;\n q.emplace(nr, nc);\n }\n }\n }\n res.sumSq += sz * sz;\n res.maxSize = max(res.maxSize, sz);\n ++res.compCnt;\n }\n }\n }\n return res;\n}\n\n/*** choose the best direction for the current board ***/\nchar bestDirection(const int cur[H][W]) {\n Eval best{ -1, -1, INT_MAX }; // initialise with worst values\n char bestDir = 'R';\n\n for (char d : DIRS) {\n int nxt[H][W];\n copyBoard(cur, nxt);\n tiltBoard(nxt, d);\n Eval ev = evaluate(nxt);\n\n if (ev.sumSq > best.sumSq ||\n (ev.sumSq == best.sumSq && ev.maxSize > best.maxSize) ||\n (ev.sumSq == best.sumSq && ev.maxSize == best.maxSize && ev.compCnt < best.compCnt)) {\n best = ev;\n bestDir = d;\n }\n }\n return bestDir;\n}\n\n/*** main ***/\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int T = 100;\n vector flavor(T + 1);\n for (int i = 1; i <= T; ++i) {\n if (!(cin >> flavor[i])) return 0; // no input\n }\n\n int board[H][W] = {0};\n\n // list of empty cells (row\u2011major order)\n vector> empties;\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n empties.emplace_back(r, c);\n\n for (int step = 1; step <= T; ++step) {\n int p; // index of the empty cell where the candy is placed\n cin >> p;\n auto [r, c] = empties[p - 1];\n board[r][c] = flavor[step];\n empties.erase(empties.begin() + (p - 1)); // remove this cell\n\n char dir = bestDirection(board);\n cout << dir << '\\n' << std::flush; // required flush\n\n tiltBoard(board, dir); // apply the chosen tilt\n\n // rebuild list of empties for the next step\n empties.clear();\n for (int i = 0; i < H; ++i)\n for (int j = 0; j < W; ++j)\n if (board[i][j] == 0)\n empties.emplace_back(i, j);\n }\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int M;\n double eps;\n if (!(cin >> M >> eps)) return 0;\n const int N = max(4, M - 1); // smallest N with N+1 >= M\n const int E = N * (N - 1) / 2; // number of edges\n\n // ---------- pre\u2011compute factorial logarithms ----------\n const int MAXE = 4950; // maximum possible E (N=100)\n vector lfac(MAXE + 1);\n lfac[0] = 0;\n for (int i = 1; i <= MAXE; ++i) lfac[i] = lfac[i - 1] + logl((long double)i);\n\n auto logBinom = [&](int n, int k) -> long double {\n if (k < 0 || k > n) return -INFINITY;\n return lfac[n] - lfac[k] - lfac[n - k];\n };\n\n // ---------- choose M distinct edge counts ----------\n vector target(M);\n for (int i = 0; i < M; ++i) {\n target[i] = (int)floor( (long double)i * E / (M - 1) );\n }\n\n // ---------- output N ----------\n cout << N << \"\\n\";\n\n // ---------- generate graphs ----------\n // for each graph put '1' into the first target[i] positions of the\n // lexicographic edge order, the rest are '0'.\n vector graphsStr(M);\n string edgeStr(E, '0');\n for (int idx = 0; idx < M; ++idx) {\n int ones = target[idx];\n fill(edgeStr.begin(), edgeStr.end(), '0');\n for (int j = 0; j < ones; ++j) edgeStr[j] = '1';\n cout << edgeStr << \"\\n\";\n graphsStr[idx] = edgeStr;\n }\n cout.flush();\n\n // ---------- pre\u2011compute log\u2011probabilities for the M hypotheses ----------\n const long double EPS = eps;\n const long double ONE_MINUS_2EPS = 1.0L - 2.0L * EPS;\n vector logP(M), log1mP(M);\n for (int i = 0; i < M; ++i) {\n long double p = EPS + ONE_MINUS_2EPS * (long double)target[i] / (long double)E;\n logP[i] = logl(p);\n log1mP[i] = log1pl(p - 1.0L); // log(1-p)\n }\n\n // ---------- processing the 100 queries ----------\n const bool zeroNoise = (fabsl(eps) < 1e-12);\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n // count edges\n int x = 0;\n for (char c : H) if (c == '1') ++x;\n\n int answer = 0;\n if (zeroNoise) {\n // exact recovery\n // target is non\u2011decreasing, binary search\n answer = (int)(lower_bound(target.begin(), target.end(), x) - target.begin());\n // lower_bound returns first >= x, which must be equal because the\n // set of possible edge counts is exactly the set of targets.\n } else {\n long double common = logBinom(E, x); // constant for all i\n long double bestVal = -INFINITY;\n for (int i = 0; i < M; ++i) {\n long double cur = common + (long double)x * logP[i] +\n (long double)(E - x) * log1mP[i];\n if (cur > bestVal) {\n bestVal = cur;\n answer = i;\n }\n }\n }\n cout << answer << \"\\n\";\n cout.flush();\n }\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n};\n\nint N, M, D, K;\nvector edges;\nvector>> adj; // (to , edge id)\nvector> edge_adj; // line\u2011graph adjacency\nvector> day_edges; // edges belonging to each day\nvector day_cnt;\nvector day_of_edge;\nvector removed; // temporary for connectivity test\nvector visited;\nvector q; // BFS queue\n\n// ---------------------------------------------------------------\n// test whether after adding 'cand' to day 'day' the graph stays connected\nbool safe(int day, int cand) {\n // mark edges of this day and the candidate edge as removed\n for (int e : day_edges[day]) removed[e] = 1;\n removed[cand] = 1;\n\n // BFS from vertex 0\n fill(visited.begin(), visited.end(), 0);\n int qs = 0, qe = 0;\n visited[0] = 1;\n q[qe++] = 0;\n while (qs < qe) {\n int v = q[qs++];\n for (auto [to, eid] : adj[v]) {\n if (removed[eid]) continue;\n if (!visited[to]) {\n visited[to] = 1;\n q[qe++] = to;\n }\n }\n }\n\n // unmark\n for (int e : day_edges[day]) removed[e] = 0;\n removed[cand] = 0;\n\n // all vertices must be reached\n for (int i = 0; i < N; ++i) if (!visited[i]) return false;\n return true;\n}\n\n// ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n // -------- read input ------------------------------------------------\n if (!(cin >> N >> M >> D >> K)) return 0;\n edges.resize(M);\n adj.assign(N, {});\n vector> vertex_edges[N]; // temporary, to build line\u2011graph\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};\n adj[u].push_back({v, i});\n adj[v].push_back({u, i});\n vertex_edges[u].push_back({v, i});\n vertex_edges[v].push_back({u, i});\n }\n // read coordinates (ignored)\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n // -------- build line\u2011graph adjacency ---------------------------------\n edge_adj.assign(M, {});\n for (int v = 0; v < N; ++v) {\n for (size_t a = 0; a < vertex_edges[v].size(); ++a) {\n int e1 = vertex_edges[v][a].second;\n for (size_t b = a + 1; b < vertex_edges[v].size(); ++b) {\n int e2 = vertex_edges[v][b].second;\n edge_adj[e1].push_back(e2);\n edge_adj[e2].push_back(e1);\n }\n }\n }\n\n // -------- containers for the algorithm -------------------------------\n day_edges.assign(D, {});\n day_cnt.assign(D, 0);\n day_of_edge.assign(M, -1);\n removed.assign(M, 0);\n visited.assign(N, 0);\n q.resize(N);\n\n // -------- greedy construction of one schedule -----------------------\n auto build_schedule = [&](void) {\n vector perm(M);\n iota(perm.begin(), perm.end(), 0);\n shuffle(perm.begin(), perm.end(), mt19937{random_device{}()});\n\n // clear structures\n for (int d = 0; d < D; ++d) {\n day_edges[d].clear();\n day_cnt[d] = 0;\n }\n fill(day_of_edge.begin(), day_of_edge.end(), -1);\n\n // scores for the current edge\n vector score(D, 0);\n\n for (int eid : perm) {\n // compute neighbour counts for each day\n fill(score.begin(), score.end(), 0);\n for (int nb : edge_adj[eid]) {\n int d = day_of_edge[nb];\n if (d != -1) ++score[d];\n }\n\n // find the best score\n int best_score = -1;\n vector cand;\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] >= K) continue;\n if (score[d] > best_score) {\n best_score = score[d];\n cand.clear();\n cand.push_back(d);\n } else if (score[d] == best_score) {\n cand.push_back(d);\n }\n }\n\n // shuffle candidates to add randomness\n shuffle(cand.begin(), cand.end(), mt19937{random_device{}()});\n\n int chosen = -1;\n for (int d : cand) {\n if (day_cnt[d] == 0) { // empty day \u2013 always safe\n chosen = d;\n break;\n }\n if (safe(d, eid)) { // connectivity test\n chosen = d;\n break;\n }\n }\n // a feasible day must exist (proved in Lemma\u202f2)\n if (chosen == -1) {\n // fallback \u2013 should never happen\n for (int d = 0; d < D; ++d) if (day_cnt[d] < K) { chosen = d; break; }\n }\n\n // assign\n day_of_edge[eid] = chosen;\n ++day_cnt[chosen];\n day_edges[chosen].push_back(eid);\n }\n };\n\n // -------- metric: number of adjacent edge pairs on the same day -----\n auto metric_of_current = [&](void) -> int {\n int met = 0;\n for (int e = 0; e < M; ++e) {\n int d = day_of_edge[e];\n for (int nb : edge_adj[e]) {\n if (day_of_edge[nb] == d && nb < e) ++met;\n }\n }\n return met;\n };\n\n // -------- repeat the greedy construction several times --------------\n const int ITERATIONS = 20;\n int best_metric = -1;\n vector best_assignment;\n\n for (int it = 0; it < ITERATIONS; ++it) {\n build_schedule();\n int met = metric_of_current();\n if (met > best_metric) {\n best_metric = met;\n best_assignment = day_of_edge;\n }\n }\n\n // -------- output ------------------------------------------------------\n for (int i = 0; i < M; ++i) {\n if (i) cout << ' ';\n cout << (best_assignment[i] + 1);\n }\n cout << '\\n';\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n if (!(cin >> D)) return 0;\n vector f1(D), r1(D), f2(D), r2(D);\n for (int i = 0; i < D; i++) cin >> f1[i];\n for (int i = 0; i < D; i++) cin >> r1[i];\n for (int i = 0; i < D; i++) cin >> f2[i];\n for (int i = 0; i < D; i++) cin >> r2[i];\n \n // O1[x][y][z] = 1 if position is in object 1's minimal covering\n // O2[x][y][z] = 1 if position is in object 2's minimal covering\n vector>> O1(D, vector>(D, vector(D, 0)));\n vector>> O2(D, vector>(D, vector(D, 0)));\n \n auto min_edge_cover = [&](const vector& F, const vector& R, \n vector>>& O, int z) {\n int nF = F.size(), nR = R.size();\n if (nF == 0 || nR == 0) return;\n \n if (nF >= nR) {\n // Match each y in R to distinct x in F\n for (int i = 0; i < nR; i++) {\n O[F[i]][R[i]][z] = 1;\n }\n // Remaining x in F connect to R[0]\n for (int i = nR; i < nF; i++) {\n O[F[i]][R[0]][z] = 1;\n }\n } else {\n // Match each x in F to distinct y in R\n for (int i = 0; i < nF; i++) {\n O[F[i]][R[i]][z] = 1;\n }\n // Remaining y in R connect to F[0]\n for (int i = nF; i < nR; i++) {\n O[F[0]][R[i]][z] = 1;\n }\n }\n };\n \n // Build O1 using silhouette pair 1\n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f1[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r1[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O1, z);\n }\n \n // Build O2 using silhouette pair 2\n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f2[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r2[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O2, z);\n }\n \n // Find connected components in O1 U O2\n vector>> comp_id(D, vector>(D, vector(D, -1)));\n vector>> components;\n const int dx[6] = {1,-1,0,0,0,0};\n const int dy[6] = {0,0,1,-1,0,0};\n const int dz[6] = {0,0,0,0,1,-1};\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if ((O1[x][y][z] || O2[x][y][z]) && comp_id[x][y][z] == -1) {\n vector> comp;\n queue> q;\n q.push({x,y,z});\n comp_id[x][y][z] = components.size();\n while (!q.empty()) {\n auto [cx, cy, cz] = q.front(); q.pop();\n comp.emplace_back(cx, cy, cz);\n for (int dir = 0; dir < 6; dir++) {\n int nx = cx + dx[dir];\n int ny = cy + dy[dir];\n int nz = cz + dz[dir];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D || nz < 0 || nz >= D) continue;\n if ((O1[nx][ny][nz] || O2[nx][ny][nz]) && comp_id[nx][ny][nz] == -1) {\n comp_id[nx][ny][nz] = components.size();\n q.push({nx, ny, nz});\n }\n }\n }\n components.push_back(comp);\n }\n }\n }\n }\n \n int n = components.size();\n // Map position to block index (1-based)\n vector>> idx(D, vector>(D, vector(D, 0)));\n for (int i = 0; i < n; i++) {\n for (auto& p : components[i]) {\n int x, y, z;\n tie(x, y, z) = p;\n idx[x][y][z] = i + 1; // 1-based index\n }\n }\n \n // Output\n cout << n << \"\\n\";\n // b1: flatten with order x*D*D + y*D + z\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O1[x][y][z]) {\n cout << idx[x][y][z];\n } else {\n cout << 0;\n }\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n // b2\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O2[x][y][z]) {\n cout << idx[x][y][z];\n } else {\n cout << 0;\n }\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n return 0;\n}","ahc020":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n long long w;\n int idx;\n};\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n r.assign(n, 0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nint N, M, K;\nvector> vertex; // (x,y)\nvector> resident; // (a,b)\nvector edges; // original order\nvector edgesSorted; // sorted by weight\nvector> dist2; // N x K\nvector>> cand; // per resident, stations within 5000, sorted\n\n// ---------------------------------------------------------------\n// price of a set 'sel' (sel[i]==1 <=> station i is reachable)\nconst long long INF = (1LL<<60);\n\nlong long price_of(const vector& sel) {\n // ----- edge cost (MST on induced subgraph) -----\n long long edgeCost = 0;\n DSU dsu(N);\n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v))\n edgeCost += e.w;\n }\n }\n\n // ----- radii -----\n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n bool ok = false;\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (sel[i]) {\n long long d2 = pr.second;\n if (maxDistSq[i] < d2) maxDistSq[i] = d2;\n ok = true;\n break; // nearest selected station\n }\n }\n if (!ok) return INF; // resident not covered\n }\n\n long long sumP2 = 0;\n for (int i = 0; i < N; ++i) {\n if (!sel[i]) continue;\n long long md2 = maxDistSq[i];\n long long P;\n if (md2 < 0) {\n P = 0;\n } else {\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n P = r;\n }\n sumP2 += P * P;\n }\n return edgeCost + sumP2;\n}\n\n// ---------------------------------------------------------------\n// MST edges for a given set, returns vector B (size M)\nvector mst_edges(const vector& sel) {\n vector B(M, 0);\n DSU dsu(N);\n int need = 0;\n for (int i = 0; i < N; ++i) if (sel[i]) ++need;\n if (need <= 1) return B;\n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v)) {\n B[e.idx] = 1;\n if (--need == 1) break;\n }\n }\n }\n return B;\n}\n\n// ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n // ----- read input -----\n if (!(cin >> N >> M >> K)) return 0;\n vertex.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> vertex[i].first >> vertex[i].second;\n }\n edges.resize(M);\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, j};\n }\n resident.resize(K);\n for (int k = 0; k < K; ++k) {\n cin >> resident[k].first >> resident[k].second;\n }\n\n // ----- preprocessing -----\n dist2.assign(N, vector(K, 0));\n const long long R2 = 5000LL * 5000LL;\n cand.assign(K, {});\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n long long dx = vertex[i].first - resident[k].first;\n long long dy = vertex[i].second - resident[k].second;\n long long d2 = dx*dx + dy*dy;\n dist2[i][k] = d2;\n if (d2 <= R2) cand[k].push_back({i, d2});\n }\n }\n for (int k = 0; k < K; ++k)\n sort(cand[k].begin(), cand[k].end(),\n [](const auto& a, const auto& b){ return a.second < b.second; });\n\n edgesSorted = edges;\n sort(edgesSorted.begin(), edgesSorted.end(),\n [](const Edge& a, const Edge& b){ return a.w < b.w; });\n\n // ----- initial solution (all vertices) -----\n vector sel(N, 1);\n sel[0] = 1; // station 1 is always reachable\n long long curCost = price_of(sel);\n\n // ---------- greedy removal ----------\n bool changed = true;\n while (changed) {\n changed = false;\n long long bestGain = 0;\n int bestV = -1;\n for (int v = 1; v < N; ++v) {\n if (!sel[v]) continue;\n // coverage test without v\n bool ok = true;\n for (int k = 0; k < K && ok; ++k) {\n bool any = false;\n for (auto &pr : cand[k]) {\n if (sel[pr.first] && pr.first != v) { any = true; break; }\n }\n if (!any) ok = false;\n }\n if (!ok) continue;\n\n sel[v] = 0;\n long long newCost = price_of(sel);\n sel[v] = 1;\n if (newCost < curCost && curCost - newCost > bestGain) {\n bestGain = curCost - newCost;\n bestV = v;\n }\n }\n if (bestV != -1) {\n sel[bestV] = 0;\n curCost -= bestGain;\n changed = true;\n }\n }\n\n // ---------- greedy addition ----------\n changed = true;\n while (changed) {\n changed = false;\n long long bestGain = 0;\n int bestV = -1;\n for (int v = 1; v < N; ++v) {\n if (sel[v]) continue;\n sel[v] = 1;\n long long newCost = price_of(sel);\n sel[v] = 0;\n if (newCost < curCost && curCost - newCost > bestGain) {\n bestGain = curCost - newCost;\n bestV = v;\n }\n }\n if (bestV != -1) {\n sel[bestV] = 1;\n curCost -= bestGain;\n changed = true;\n }\n }\n\n // ----- final radii (for output) -----\n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (sel[i]) {\n if (maxDistSq[i] < pr.second) maxDistSq[i] = pr.second;\n break; // nearest selected\n }\n }\n }\n vector P(N, 0);\n for (int i = 0; i < N; ++i) {\n if (!sel[i]) { P[i] = 0; continue; }\n long long md2 = maxDistSq[i];\n if (md2 < 0) { P[i] = 0; continue; }\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n P[i] = r;\n }\n\n // ----- edges that are ON -----\n vector B = mst_edges(sel);\n\n // ----- output -----\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << P[i];\n }\n cout << '\\n';\n for (int j = 0; j < M; ++j) {\n if (j) cout << ' ';\n cout << B[j];\n }\n cout << '\\n';\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconst int N = 30; // fixed size\nconst int TOTAL = N * (N + 1) / 2; // 465\n\n// current value on each position\nint val[N][N];\n// position of each value (only for debugging / verification)\npair pos[TOTAL];\n\n// list of performed swaps\nvector> ops;\n\n/* exchange the balls on (x1,y1) and (x2,y2) */\ninline void do_swap(int x1, int y1, int x2, int y2) {\n ops.push_back({x1, y1, x2, y2});\n int v1 = val[x1][y1];\n int v2 = val[x2][y2];\n swap(val[x1][y1], val[x2][y2]);\n pos[v1] = {x2, y2};\n pos[v2] = {x1, y1};\n}\n\n/* sift the element at (x,y) down until its sub\u2011triangle is a heap */\nvoid heapify_node(int x, int y) {\n while (true) {\n if (x == N - 1) break; // leaf -> no children\n int c1x = x + 1, c1y = y;\n int c2x = x + 1, c2y = y + 1;\n int parent_val = val[x][y];\n int child1_val = val[c1x][c1y];\n int child2_val = val[c2x][c2y];\n\n // choose the child with the smaller value\n int smaller_cx = c1x, smaller_cy = c1y;\n int smaller_val = child1_val;\n if (child2_val < smaller_val) {\n smaller_cx = c2x;\n smaller_cy = c2y;\n smaller_val = child2_val;\n }\n\n if (parent_val <= smaller_val) break; // heap condition satisfied\n\n // swap with the smaller child and continue downwards\n do_swap(x, y, smaller_cx, smaller_cy);\n x = smaller_cx;\n y = smaller_cy;\n }\n}\n\n/* ---------- main ---------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // ----- read input -----\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n int v; cin >> v;\n val[x][y] = v;\n pos[v] = {x, y};\n }\n }\n\n // ----- bottom\u2011up heapify -----\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n heapify_node(x, y);\n }\n }\n\n // ----- optional verification (can be omitted) -----\n bool ok = true;\n for (int x = 0; x < N - 1 && ok; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (val[x][y] >= val[x + 1][y] || val[x][y] >= val[x + 1][y + 1]) {\n ok = false;\n break;\n }\n }\n }\n if (!ok) cerr << \"Heap condition violated!\\n\";\n\n // ----- output -----\n if ((int)ops.size() > 10000) {\n cerr << \"Too many swaps: \" << ops.size() << '\\n';\n }\n cout << ops.size() << '\\n';\n for (auto &op : ops) {\n cout << op[0] << ' ' << op[1] << ' '\n << op[2] << ' ' << op[3] << '\\n';\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int D, N;\n if (!(cin >> D >> N)) return 0;\n const int MAXD = 9; // D is always 9, but keep generic\n bool obstacle[MAXD][MAXD] = {};\n\n for (int k = 0; k < N; ++k) {\n int ri, rj; cin >> ri >> rj;\n obstacle[ri][rj] = true;\n }\n\n const int er = 0, ec = (D - 1) / 2; // entrance\n const int ENTRANCE_ID = D * D; // extra node number\n const int TOTAL_NODES = D * D + 1;\n\n // ---------- BFS distances (ignoring containers) ----------\n int dist[MAXD][MAXD];\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n dist[i][j] = -1;\n\n queue> q;\n dist[er][ec] = 0;\n q.emplace(er, ec);\n const int dr[4] = {-1,1,0,0};\n const int dc[4] = {0,0,-1,1};\n\n while (!q.empty()) {\n auto [r,c] = q.front(); q.pop();\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (dist[nr][nc] == -1) {\n dist[nr][nc] = dist[r][c] + 1;\n q.emplace(nr,nc);\n }\n }\n }\n\n // ---------- list of squares that may contain containers ----------\n vector cells; // their ids\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n if (!obstacle[i][j] && !(i == er && j == ec))\n cells.push_back(i * D + j);\n\n const int M = (int)cells.size(); // number of containers\n\n // sorted list of distances (the \u201cideal\u201d distances)\n vector sortedDist;\n sortedDist.reserve(M);\n for (int id : cells) sortedDist.push_back(dist[id / D][id % D]);\n sort(sortedDist.begin(), sortedDist.end());\n\n // ---------- data for articulation point search ----------\n vector> neighbours(TOTAL_NODES);\n auto buildNeighbours = [&](int node, vector& out) {\n out.clear();\n if (node == ENTRANCE_ID) {\n int r = er, c = ec;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n int nid = nr * D + nc;\n out.push_back(nid);\n }\n } else {\n int r = node / D, c = node % D;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (nr == er && nc == ec) out.push_back(ENTRANCE_ID);\n else out.push_back(nr * D + nc);\n }\n }\n };\n\n vector disc(TOTAL_NODES), low(TOTAL_NODES);\n vector visited(TOTAL_NODES, 0), isArt(TOTAL_NODES, 0);\n int timer = 0;\n\n function dfs = [&](int u, int parent) {\n visited[u] = 1;\n disc[u] = low[u] = ++timer;\n int children = 0;\n vector neigh;\n buildNeighbours(u, neigh);\n for (int v : neigh) {\n if (!visited[v]) {\n ++children;\n dfs(v, u);\n low[u] = min(low[u], low[v]);\n if (parent != -1 && low[v] >= disc[u]) isArt[u] = 1;\n } else if (v != parent) {\n low[u] = min(low[u], disc[v]);\n }\n }\n if (parent == -1 && children > 1) isArt[u] = 1;\n };\n\n auto getRemovable = [&]() -> vector {\n fill(visited.begin(), visited.end(), 0);\n fill(disc.begin(), disc.end(), 0);\n fill(low.begin(), low.end(), 0);\n fill(isArt.begin(), isArt.end(), 0);\n timer = 0;\n dfs(ENTRANCE_ID, -1);\n vector removable;\n for (int id : cells)\n if (!occupied[id] && !isArt[id]) removable.push_back(id);\n return removable;\n };\n\n // occupied[id] \u2013 true after a container has been stored there\n vector occupied(TOTAL_NODES, 0);\n // assigned[t] \u2013 square that finally stores container t\n vector assigned(M, -1);\n\n // ---------- online placement ----------\n for (int step = 0; step < M; ++step) {\n int t; cin >> t;\n int targetDist = sortedDist[t]; // ideal distance\n vector cand = getRemovable(); // squares that can be used now\n int best = -1, bestDiff = INT_MAX, bestDist = -1;\n for (int id : cand) {\n int d = dist[id / D][id % D];\n int diff = abs(d - targetDist);\n if (diff < bestDiff || (diff == bestDiff && d > bestDist)) {\n bestDiff = diff;\n bestDist = d;\n best = id;\n }\n }\n // safety \u2013 should always happen\n if (best == -1) {\n for (int id : cells) if (!occupied[id]) { best = id; break; }\n }\n occupied[best] = 1;\n assigned[t] = best;\n cout << (best / D) << ' ' << (best % D) << \"\\n\" << flush;\n }\n\n // ---------- removal order (greedy, smallest reachable) ----------\n vector removalOrder;\n removalOrder.reserve(M);\n vector removed(M, 0);\n vector emptySquare(TOTAL_NODES, 0);\n emptySquare[ENTRANCE_ID] = 1; // entrance is empty\n\n for (int step = 0; step < M; ++step) {\n int chosen = -1;\n for (int num = 0; num < M; ++num) if (!removed[num]) {\n int id = assigned[num];\n int r = id / D, c = id % D;\n bool ok = false;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n int nid = (nr == er && nc == ec) ? ENTRANCE_ID : nr * D + nc;\n if (emptySquare[nid]) { ok = true; break; }\n }\n if (ok) { chosen = num; break; }\n }\n // must exist\n removalOrder.push_back(chosen);\n removed[chosen] = 1;\n int id = assigned[chosen];\n emptySquare[id] = 1;\n }\n\n // ---------- count inversions ----------\n long long B = 0;\n for (int i = 0; i < M; ++i)\n for (int j = i + 1; j < M; ++j)\n if (removalOrder[i] > removalOrder[j]) ++B;\n\n long long totalPairs = 1LL * M * (M - 1) / 2;\n long double ratio = (long double)(totalPairs - B) / (long double)totalPairs;\n long long score = llround(ratio * 1e9); // final score, not used further\n\n // ---------- output removal order ----------\n for (int num : removalOrder) {\n int id = assigned[num];\n cout << (id / D) << ' ' << (id % D) << \"\\n\" << flush;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> a(n, vector(n));\n for (int i = 0; i < n; ++i)\n for (int j = 0; j < n; ++j)\n cin >> a[i][j];\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << a[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nusing ll = long long;\nconst ll INF = (ll)4e18;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, D, Q;\n if (!(cin >> N >> D >> Q)) return 0;\n\n // ---------- 1. create list of all unordered pairs ----------\n vector> allPairs;\n allPairs.reserve(N*(N-1)/2);\n for (int i = 0; i < N; ++i)\n for (int j = i+1; j < N; ++j)\n allPairs.emplace_back(i,j);\n // random shuffle \u2013 we do not need a truly strong RNG\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n shuffle(allPairs.begin(), allPairs.end(), rng);\n\n // ---------- 2. answer Q questions ----------\n // direction cache: key = (min<<32) | max value: 1 = leftright, 0 = equal\n unordered_map dir;\n dir.reserve(Q*2);\n vector> adj(N);\n vector indeg(N,0);\n vector heavierCnt(N,0); // how many items are known heavier than this one\n size_t pairIdx = 0;\n for (int q = 0; q < Q; ++q) {\n pair p;\n if (pairIdx < allPairs.size())\n p = allPairs[pairIdx++];\n else\n p = {0,1}; // dummy pair, result will be ignored later\n\n cout << 1 << ' ' << 1 << ' ' << p.first << ' ' << p.second << '\\n' << std::flush;\n\n char c; cin >> c; // '<' , '>' or '='\n\n long long key = ( ( (long long)min(p.first,p.second) ) << 32 )\n | (long long)max(p.first,p.second);\n if (dir.find(key) != dir.end()) continue; // already known, ignore duplicate\n dir[key] = (c=='<') ? 1 : (c=='>') ? -1 : 0;\n\n if (c == '<') {\n int light = p.first, heavy = p.second;\n adj[light].push_back(heavy);\n ++indeg[heavy];\n ++heavierCnt[heavy];\n } else if (c == '>') {\n int light = p.second, heavy = p.first;\n adj[light].push_back(heavy);\n ++indeg[heavy];\n ++heavierCnt[heavy];\n } // '=' : nothing to store\n }\n\n // ---------- 3. topological order (light -> heavy) ----------\n vector indeg_cur = indeg;\n queue q0;\n for (int i = 0; i < N; ++i)\n if (indeg_cur[i] == 0) q0.push(i);\n vector topo;\n topo.reserve(N);\n while (!q0.empty()) {\n int v = q0.front(); q0.pop();\n topo.push_back(v);\n for (int to : adj[v]) {\n if (--indeg_cur[to] == 0) q0.push(to);\n }\n }\n // In the (unlikely) case of a cycle we just append remaining vertices\n if ((int)topo.size() < N) {\n vector rest;\n for (int i = 0; i < N; ++i)\n if (find(topo.begin(), topo.end(), i) == topo.end()) rest.push_back(i);\n topo.insert(topo.end(), rest.begin(), rest.end());\n }\n\n // ---------- 4. proxy weights (position + 1) ----------\n vector weight(N);\n for (int pos = 0; pos < N; ++pos) {\n int item = topo[pos];\n weight[item] = (ll)pos + 1; // 1 \u2026 N\n }\n\n // ---------- 5. DP for contiguous blocks ----------\n // prefix sums of weight in topological order\n vector pref(N+1,0);\n for (int i = 0; i < N; ++i) pref[i+1] = pref[i] + weight[topo[i]];\n\n vector> dp(D+1, vector(N+1, INF));\n vector> split(D+1, vector(N+1, -1));\n dp[0][0] = 0;\n for (int g = 1; g <= D; ++g) {\n for (int i = g; i <= N; ++i) { // we need at least g items for g groups\n ll best = INF;\n int bestj = -1;\n for (int j = g-1; j < i; ++j) {\n ll sum = pref[i] - pref[j];\n ll cand = dp[g-1][j] + sum*sum;\n if (cand < best) {\n best = cand;\n bestj = j;\n }\n }\n dp[g][i] = best;\n split[g][i] = bestj;\n }\n }\n\n // ---------- 6. reconstruct groups ----------\n vector groupOfPos(N, -1); // position in topo -> group id\n int curIdx = N;\n for (int g = D; g >= 1; --g) {\n int j = split[g][curIdx];\n for (int k = j; k < curIdx; ++k) groupOfPos[k] = g-1;\n curIdx = j;\n }\n\n // translate back to original item indices\n vector answer(N, -1);\n for (int pos = 0; pos < N; ++pos) {\n int item = topo[pos];\n answer[item] = groupOfPos[pos];\n }\n\n // ---------- 7. output ----------\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << answer[i];\n }\n cout << '\\n';\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n const int per = n / m; // = 20\n vector> st(m); // bottom -> top\n vector> pos(n + 1); // (stack index, position)\n for (int i = 0; i < m; ++i) {\n st[i].reserve(per);\n for (int j = 0; j < per; ++j) {\n int x; cin >> x;\n st[i].push_back(x);\n pos[x] = {i, j};\n }\n }\n\n vector> ops; // (value, destination) 0 = carry out\n for (int v = 1; v <= n; ++v) {\n int s = pos[v].first; // stack that contains v (still correct)\n\n // move everything that is above v away\n while (st[s].back() != v) {\n int w = st[s].back(); // the blocking box\n int dest = -1;\n int bestTop = INT_MAX;\n\n // case 1 : a stack whose top is larger than w\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty()) {\n int top = st[i].back();\n if (top > w && top < bestTop) {\n bestTop = top;\n dest = i;\n }\n }\n }\n // case 2 : an empty stack\n if (dest == -1) {\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (st[i].empty()) {\n dest = i;\n break;\n }\n }\n }\n // case 3 : any other stack (the one with smallest top)\n if (dest == -1) {\n int minTop = INT_MAX;\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty() && st[i].back() < minTop) {\n minTop = st[i].back();\n dest = i;\n }\n }\n }\n\n // move w to dest (operation 1)\n ops.emplace_back(w, dest + 1); // +1 because stacks are 1\u2011based in output\n st[s].pop_back();\n st[dest].push_back(w);\n pos[w] = {dest, (int)st[dest].size() - 1};\n }\n\n // now v is the top \u2192 carry it out (operation 2)\n ops.emplace_back(v, 0);\n st[s].pop_back(); // remove v\n }\n\n // output\n cout << ops.size() << '\\n';\n for (auto &p : ops) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) { p.resize(n); r.assign(n, 0); iota(p.begin(), p.end(), 0); }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n if (!(cin >> N)) return 0;\n const int M = N * N;\n vector h(N - 1), v(N);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n for (int i = 0; i < N; ++i) cin >> v[i];\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> d[i][j];\n\n auto id = [&](int i, int j) { return i * N + j; };\n auto coord = [&](int id_) { return pair(id_/N, id_%N); };\n\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n auto opposite = [&](char c)->char{\n if (c=='U') return 'D';\n if (c=='D') return 'U';\n if (c=='L') return 'R';\n return 'L';\n };\n\n auto moveChar = [&](int from, int to)->char{\n auto [fi,fj] = coord(from);\n auto [ti,tj] = coord(to);\n if (ti == fi+1) return 'D';\n if (ti == fi-1) return 'U';\n if (tj == fj+1) return 'R';\n return 'L'; // tj == fj-1\n };\n\n /* ---------- 1. build list of usable edges ---------- */\n struct Edge {int u,v,w;};\n vector edges;\n edges.reserve(5000);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i,j);\n // down\n if (i+1 < N && h[i][j] == '0') {\n int v = id(i+1,j);\n edges.push_back({u,v, d[i][j] + d[i+1][j]});\n }\n // right\n if (j+1 < N && v[i][j] == '0') {\n int v = id(i,j+1);\n edges.push_back({u,v, d[i][j] + d[i][j+1]});\n }\n }\n }\n\n /* ---------- 2. maximum spanning tree (Kruskal) ---------- */\n sort(edges.begin(), edges.end(),\n [](const Edge& a, const Edge& b){ return a.w > b.w; });\n DSU dsu(M);\n vector> treeAdj(M);\n int added = 0;\n for (auto &e: edges) {\n if (dsu.unite(e.u, e.v)) {\n treeAdj[e.u].push_back(e.v);\n treeAdj[e.v].push_back(e.u);\n ++added;\n if (added == M-1) break;\n }\n }\n\n /* ---------- 3. covering walk (DFS on the tree) ---------- */\n const int root = id(0,0);\n vector coverMoves;\n coverMoves.reserve(2*(M-1));\n\n function dfs = [&](int v, int p) {\n for (int to: treeAdj[v]) if (to != p) {\n coverMoves.push_back(moveChar(v,to));\n dfs(to, v);\n coverMoves.push_back(moveChar(to,v));\n }\n };\n dfs(root, -1);\n int coverLen = (int)coverMoves.size(); // = 2\u00b7(M\u20111)\n\n /* ---------- 4. BFS from (0,0) on the original grid ---------- */\n const int INF = 1e9;\n vector dist(M, INF), parent(M, -1);\n vector parDir(M); // direction from parent to this node\n queue q;\n dist[root] = 0;\n q.push(root);\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n auto [ci,cj] = coord(cur);\n for (int dir = 0; dir < 4; ++dir) {\n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n // check wall\n if (dir == 0 && h[ci][cj] == '1') continue; // up\n if (dir == 1 && (ci+1 < N && h[ci][cj] == '1')) continue; // down\n if (dir == 2 && v[ci][cj-1] == '1') continue; // left (j-1 valid because j>=1)\n if (dir == 3 && v[ci][cj] == '1') continue; // right\n int nb = id(ni,nj);\n if (dist[nb] == INF) {\n dist[nb] = dist[cur] + 1;\n parent[nb] = cur;\n parDir[nb] = dirChar[dir];\n q.push(nb);\n }\n }\n }\n\n /* ---------- 5. best adjacent pair ---------- */\n int bestU = -1, bestV = -1;\n int bestSum = -1;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i,j);\n // down neighbour\n if (i+1 < N && h[i][j] == '0') {\n int v = id(i+1,j);\n int s = d[i][j] + d[i+1][j];\n if (s > bestSum) { bestSum = s; bestU = u; bestV = v; }\n }\n // right neighbour\n if (j+1 < N && v[i][j] == '0') {\n int v = id(i,j+1);\n int s = d[i][j] + d[i][j+1];\n if (s > bestSum) { bestSum = s; bestU = u; bestV = v; }\n }\n }\n }\n\n // choose the endpoint of the best pair that is closer to (0,0)\n int s = (dist[bestU] <= dist[bestV]) ? bestU : bestV;\n int t = (s == bestU) ? bestV : bestU;\n int distS = dist[s];\n\n /* ---------- 6. how many bounce cycles are possible ---------- */\n const int LMAX = 100000;\n long long remain = LMAX - coverLen - 2LL * distS;\n if (remain < 0) remain = 0;\n int k = (int)(remain / 2); // number of full back\u2011and\u2011forth cycles\n\n /* ---------- 7. build the whole route ---------- */\n string answer;\n answer.reserve(LMAX);\n // covering walk\n answer.append(coverMoves.begin(), coverMoves.end());\n\n // path from (0,0) to s\n vector pathToS;\n {\n int cur = s;\n while (cur != root) {\n char d = parDir[cur]; // direction parent -> cur\n pathToS.push_back(opposite(d));\n cur = parent[cur];\n }\n reverse(pathToS.begin(), pathToS.end());\n answer.append(pathToS.begin(), pathToS.end());\n }\n\n // bounce between s and t\n char dirST = moveChar(s, t);\n char dirTS = opposite(dirST);\n for (int i = 0; i < k; ++i) {\n answer.push_back(dirST);\n answer.push_back(dirTS);\n }\n\n // path back from s to (0,0)\n {\n int cur = s;\n while (cur != root) {\n char d = parDir[cur];\n answer.push_back(opposite(d));\n cur = parent[cur];\n }\n }\n\n // safety \u2013 should never happen\n if ((int)answer.size() > LMAX) answer.resize(LMAX);\n\n cout << answer << '\\n';\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nint overlap(const string &a, const string &b) {\n // longest k (0..4) such that suffix of a (len k) == prefix of b (len k)\n int maxL = min(4, (int)a.size());\n for (int k = maxL; k >= 0; --k) {\n bool ok = true;\n for (int i = 0; i < k; ++i) {\n if (a[a.size() - k + i] != b[i]) { ok = false; break; }\n }\n if (ok) return k;\n }\n return 0;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n if (!(cin >> N >> M)) return 0;\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 word(M);\n for (int i = 0; i < M; ++i) cin >> word[i];\n\n // positions of each letter\n vector> pos[26];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int id = grid[i][j] - 'A';\n pos[id].push_back({i, j});\n }\n\n /* ---------- 1. build a short super\u2011string ---------- */\n vector used(M, false);\n string cur;\n // start with the lexicographically smallest word (any start works)\n cur = word[0];\n used[0] = true;\n\n while (true) {\n int bestIdx = -1;\n bool bestDir = false; // false = append, true = prepend\n int bestAdd = 1000; // minimal number of added characters\n int bestOverlap = 0; // only for tie\u2011breaking\n\n for (int i = 0; i < M; ++i) if (!used[i]) {\n const string &s = word[i];\n int k_end = overlap(cur, s);\n int add_end = 5 - k_end;\n if (add_end < bestAdd || (add_end == bestAdd && k_end > bestOverlap)) {\n bestAdd = add_end;\n bestIdx = i;\n bestDir = false;\n bestOverlap = k_end;\n }\n int k_start = overlap(s, cur);\n int add_start = 5 - k_start;\n if (add_start < bestAdd || (add_start == bestAdd && k_start > bestOverlap)) {\n bestAdd = add_start;\n bestIdx = i;\n bestDir = true;\n bestOverlap = k_start;\n }\n }\n if (bestIdx == -1) break; // all words used\n\n const string &s = word[bestIdx];\n if (!bestDir) {\n cur += s.substr(bestOverlap);\n } else {\n cur = s + cur.substr(bestOverlap);\n }\n used[bestIdx] = true;\n }\n\n const string &S = cur; // final super\u2011string\n\n /* ---------- 2. type the string, choose nearest squares ---------- */\n vector> answer;\n pair curPos = {si, sj};\n\n for (char ch : S) {\n int id = ch - 'A';\n const auto &vec = pos[id];\n pair bestPos = vec.front();\n int bestDist = INT_MAX;\n for (auto p : vec) {\n int d = abs(p.first - curPos.first) + abs(p.second - curPos.second);\n if (d < bestDist) {\n bestDist = d;\n bestPos = p;\n }\n }\n answer.push_back(bestPos);\n curPos = bestPos;\n }\n\n // output\n for (auto [i, j] : answer) {\n cout << i << ' ' << j << '\\n';\n }\n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n if (!(cin >> N >> M >> eps)) return 0;\n const int S = N * N; // number of cells\n // read and ignore the shapes of the oil fields\n for (int k = 0; k < M; ++k) {\n int d; cin >> d;\n for (int t = 0; t < d; ++t) {\n int a, b; cin >> a >> b;\n }\n }\n\n const int Q = S - 2; // number of divine queries ( \u2264 2\u00b7N\u00b2 )\n const double epsFactor = 1.0 - 2.0 * eps; // denominator ( > 0 because eps \u2264 0.2 )\n\n // linear system L * t = r\n Eigen::MatrixXd L = Eigen::MatrixXd::Zero(S, S);\n Eigen::VectorXd r = Eigen::VectorXd::Zero(S);\n\n // random generator for the subsets\n std::mt19937 rng(123456789);\n\n for (int qq = 0; qq < Q; ++qq) {\n // generate a random subset, each cell included with probability 0.5\n vector idxs;\n idxs.reserve(S);\n for (int i = 0; i < S; ++i) if (rng() & 1) idxs.push_back(i);\n if (idxs.size() < 2) { // safety \u2013 add the first two cells\n if (idxs.empty()) { idxs.push_back(0); idxs.push_back(1); }\n else if (idxs.size() == 1) idxs.push_back((idxs[0] + 1) % S);\n }\n\n // output the divine query\n cout << \"q \" << idxs.size();\n for (int id : idxs) {\n int ii = id / N;\n int jj = id % N;\n cout << ' ' << ii << ' ' << jj;\n }\n cout << \"\\n\";\n cout.flush();\n\n // read the noisy answer\n int y; cin >> y;\n\n // transform to an unbiased estimate of the sum of t's\n double k = (double)idxs.size();\n double z = ( (double) y - eps * k ) / epsFactor;\n\n // weight = 1 / variance of z\n double var = k * eps * (1.0 - eps) / (epsFactor * epsFactor);\n double w = 1.0 / var;\n\n // update L and r\n for (int a : idxs) {\n L(a, a) += w;\n r(a) += w * z;\n for (int b : idxs) {\n if (a < b) {\n L(a, b) += w;\n L(b, a) += w;\n }\n }\n }\n }\n\n // regularise and solve\n L += 1e-6 * Eigen::MatrixXd::Identity(S, S);\n Eigen::VectorXd t = L.ldlt().solve(r);\n for (int i = 0; i < S; ++i) t(i) = std::max(0.0, std::min(1.0, t(i)));\n\n // decide how many cells are oil\n double sumT = t.sum();\n int K = (int)std::round(sumT);\n if (K < 0) K = 0;\n if (K > S) K = S;\n\n // indices sorted by decreasing t\n vector order(S);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b){ return t(a) > t(b); });\n\n // first guess\n vector answer;\n answer.reserve(K);\n for (int i = 0; i < K; ++i) answer.push_back(order[i]);\n\n cout << \"a \" << answer.size();\n for (int id : answer) {\n int ii = id / N, jj = id % N;\n cout << ' ' << ii << ' ' << jj;\n }\n cout << \"\\n\";\n cout.flush();\n\n int ok; cin >> ok;\n if (ok == 1) return 0; // success \u2013 finished\n\n // -------- fallback : drill every cell ----------\n vector exact(S, -1);\n for (int id = 0; id < S; ++id) {\n int ii = id / N, jj = id % N;\n cout << \"q 1 \" << ii << ' ' << jj << \"\\n\";\n cout.flush();\n int val; cin >> val;\n exact[id] = val;\n }\n\n // produce the exact answer\n vector finalAns;\n for (int id = 0; id < S; ++id)\n if (exact[id] > 0) finalAns.push_back(id);\n\n cout << \"a \" << finalAns.size();\n for (int id : finalAns) {\n int ii = id / N, jj = id % N;\n cout << ' ' << ii << ' ' << jj;\n }\n cout << \"\\n\";\n cout.flush();\n // the judge will answer 1 \u2013 we are done\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nconst int W_fixed = 1000; // the problem always uses W = 1000\n\nstruct Rect {\n int x, y, w, h; // left\u2011bottom corner (x,y), size w \u00d7 h\n};\n\nint W; // actual W (will be 1000)\n\n/*---------------------------------------------------------------*/\n/* add a new free rectangle, removing any that it contains */\nvoid addFreeRect(vector& L, const Rect& r) {\n if (r.w <= 0 || r.h <= 0) return;\n for (const Rect& f : L) {\n if (f.x <= r.x && f.y <= r.y &&\n f.x + f.w >= r.x + r.w &&\n f.y + f.h >= r.y + r.h)\n return; // r is already contained\n }\n vector nxt;\n for (const Rect& f : L) {\n if (!(r.x <= f.x && r.y <= f.y &&\n r.x + r.w >= f.x + f.w &&\n r.y + r.h >= f.y + f.h))\n nxt.push_back(f); // f is not inside r\n }\n nxt.push_back(r);\n L.swap(nxt);\n}\n\n/*---------------------------------------------------------------*/\n/* minimal rectangle (w,h) for a demand a */\nvoid minimalRect(int a, int& w, int& h) {\n int bestW = W, bestH = W, bestArea = W * W, bestMax = W;\n for (int hi = 1; hi <= W; ++hi) {\n int wi = (a + hi - 1) / hi; // ceil(a/hi)\n if (wi > W) continue;\n int area = wi * hi;\n int mx = max(wi, hi);\n if (area < bestArea || (area == bestArea && mx < bestMax)) {\n bestArea = area;\n bestW = wi;\n bestH = hi;\n bestMax = mx;\n }\n }\n w = bestW; h = bestH;\n}\n\n/*---------------------------------------------------------------*/\n/* pack all reservations of one day.\n initialFree : free rectangles from previous day\n items : reservation rectangles (id , w , h)\n placed : output \u2013 rectangle for each reservation id\n freeOut : free rectangles after placing (empty rooms)\n*/\nvoid pack_day(const vector& initialFree,\n const vector>& items, // (id,w,h)\n vector& placed,\n vector& freeOut)\n{\n // items are already sorted by decreasing area outside\n vector freeRects = initialFree;\n int N = (int)items.size();\n placed.assign(N, {0,0,0,0});\n\n for (auto [id, w0, h0] : items) {\n int demand = w0 * h0; // minimal area, may be larger\n // ----- try to take a whole free rectangle -----------------\n int bestSurplus = INT_MAX, bestIdx = -1;\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n int area = f.w * f.h;\n if (area >= demand) {\n int surplus = area - demand;\n if (surplus < bestSurplus) {\n bestSurplus = surplus;\n bestIdx = i;\n }\n }\n }\n if (bestIdx != -1) {\n // use the whole free rectangle, no new walls\n Rect fr = freeRects[bestIdx];\n placed[id] = fr; // exact size of the free room\n freeRects.erase(freeRects.begin() + bestIdx);\n continue;\n }\n\n // ----- need to split a free rectangle ----------------------\n int bestScore = INT_MAX, idx = -1, px = -1, py = -1, pw = -1, ph = -1;\n for (int rot = 0; rot < 2; ++rot) {\n int w = rot ? h0 : w0;\n int h = rot ? w0 : h0;\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n if (f.w >= w && f.h >= h) {\n int score = (f.w - w) + (f.h - h);\n if (score < bestScore) {\n bestScore = score;\n idx = i;\n px = f.x;\n py = f.y;\n pw = w;\n ph = h;\n }\n }\n }\n if (idx != -1) break; // we already have a candidate\n }\n // idx must be valid (the whole grid is a free rectangle)\n Rect used = freeRects[idx];\n placed[id] = {px, py, pw, ph};\n freeRects.erase(freeRects.begin() + idx);\n\n // right remainder\n if (used.w - pw > 0) {\n Rect r = {px + pw, py, used.w - pw, used.h};\n addFreeRect(freeRects, r);\n }\n // bottom remainder\n if (used.h - ph > 0) {\n Rect r = {px, py + ph, pw, used.h - ph};\n addFreeRect(freeRects, r);\n }\n }\n freeOut.swap(freeRects);\n}\n\n/*---------------------------------------------------------------*/\n/* build interior edge tables from a list of rooms */\nvoid buildEdges(const vector& rooms,\n vector& H, vector& V)\n{\n fill(H.begin(), H.end(), 0);\n fill(V.begin(), V.end(), 0);\n for (const Rect& r : rooms) {\n int x0 = r.x, y0 = r.y;\n int x1 = x0 + r.w, y1 = y0 + r.h;\n\n // top edge (y0 > 0)\n if (y0 > 0) {\n int i = y0;\n for (int x = x0; x < x1; ++x) H[i * W + x] = 1;\n }\n // bottom edge (y1 < W)\n if (y1 < W) {\n int i = y1;\n for (int x = x0; x < x1; ++x) H[i * W + x] = 1;\n }\n // left edge (x0 > 0)\n if (x0 > 0) {\n int i = x0;\n for (int y = y0; y < y1; ++y) V[i * W + y] = 1;\n }\n // right edge (x1 < W)\n if (x1 < W) {\n int i = x1;\n for (int y = y0; y < y1; ++y) V[i * W + y] = 1;\n }\n }\n}\n\n/*---------------------------------------------------------------*/\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int D, N;\n if (!(cin >> W >> D >> N)) return 0;\n vector> a(D, vector(N));\n for (int d = 0; d < D; ++d)\n for (int k = 0; k < N; ++k)\n cin >> a[d][k];\n\n // edge tables\n vector Hcur(W * W, 0), Vcur(W * W, 0);\n vector Hprev(W * W, 0), Vprev(W * W, 0);\n\n // answer storage\n vector> answer(D, vector(N));\n\n // free rectangles coming from previous day (day 0 starts with whole hall)\n vector prevFree = { {0, 0, W, W} };\n\n long long totalCost = 0;\n\n for (int day = 0; day < D; ++day) {\n // build items (id, minimal rectangle size)\n vector> items; // (id, w, h)\n items.reserve(N);\n for (int k = 0; k < N; ++k) {\n int w, h;\n minimalRect(a[day][k], w, h);\n items.emplace_back(k, w, h);\n }\n // sort by decreasing area (helps keeping big rooms)\n sort(items.begin(), items.end(),\n [](const auto& A, const auto& B) {\n int areaA = get<1>(A) * get<2>(A);\n int areaB = get<1>(B) * get<2>(B);\n return areaA > areaB;\n });\n\n // pack\n vector placed, freeRects;\n pack_day(prevFree, items, placed, freeRects);\n\n // remember placed rectangles for output (convert to i0,j0,i1,j1)\n for (int k = 0; k < N; ++k) {\n const Rect& r = placed[k];\n answer[day][k] = { r.y, r.x, r.y + r.h, r.x + r.w };\n }\n\n // all rooms (reservation + empty)\n vector allRooms = placed;\n allRooms.insert(allRooms.end(), freeRects.begin(), freeRects.end());\n\n // build edge tables for this day\n buildEdges(allRooms, Hcur, Vcur);\n\n if (day > 0) {\n long long diff = 0;\n for (int i = 1; i < W; ++i)\n for (int j = 0; j < W; ++j)\n if (Hcur[i * W + j] != Hprev[i * W + j]) ++diff;\n for (int i = 0; i < W; ++i)\n for (int j = 1; j < W; ++j)\n if (Vcur[i * W + j] != Vprev[i * W + j]) ++diff;\n totalCost += diff;\n }\n\n // prepare for next day\n Hprev.swap(Hcur);\n Vprev.swap(Vcur);\n prevFree = move(allRooms); // rooms of today become free tomorrow\n }\n\n // (totalCost is not required to be printed, only the layout)\n\n // output\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n const Rect& r = answer[d][k];\n cout << r.x << ' ' << r.y << ' ' << r.w << ' ' << r.h << \"\\n\";\n // note: we stored (i0,j0,i1,j1) as (r.x,r.y,r.w,r.h)\n // but output expects (i0,j0,i1,j1) -> we already stored that way\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nconst long long MOD = 998244353LL;\n\nstruct Placement {\n int stamp; // which stamp\n int p, q; // top\u2011left corner on the board\n int cell[9];\n int inc[9];\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n const int CELLS = N * N; // 81\n vector a(CELLS);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n long long x; cin >> x;\n a[i * N + j] = int(x % MOD);\n }\n vector>> stamp(M, vector>(3, vector(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 long long x; cin >> x;\n stamp[m][i][j] = int(x % MOD);\n }\n\n /* ---- build all placements ---- */\n vector PL;\n PL.reserve(M * 7 * 7);\n for (int m = 0; m < M; ++m) {\n for (int p = 0; p <= N - 3; ++p) {\n for (int q = 0; q <= N - 3; ++q) {\n Placement pl;\n pl.stamp = m;\n pl.p = p; pl.q = q;\n int pos = 0;\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) {\n pl.cell[pos] = (p + i) * N + (q + j);\n pl.inc[pos] = stamp[m][i][j];\n ++pos;\n }\n PL.push_back(pl);\n }\n }\n }\n const int PLsize = (int)PL.size(); // 980\n\n /* ---- current board state ---- */\n vector add(CELLS, 0); // total added values\n auto recomputeScore = [&]() -> long long {\n long long sc = 0;\n for (int i = 0; i < CELLS; ++i) {\n sc += (a[i] + add[i]) % MOD;\n }\n return sc;\n };\n\n long long curScore = recomputeScore(); // empty board\n long long bestScore = curScore;\n vector solution; // indices into PL\n vector bestSolution;\n\n /* ==================== Greedy construction ==================== */\n while ((int)solution.size() < K) {\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n const Placement &pl = PL[idx];\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] + inc) % MOD;\n delta += nw - old;\n }\n if (delta > bestDelta) {\n bestDelta = delta;\n bestIdx = idx;\n }\n }\n if (bestIdx == -1 || bestDelta <= 0) break;\n const Placement &pl = PL[bestIdx];\n for (int t = 0; t < 9; ++t) {\n add[pl.cell[t]] += pl.inc[t];\n }\n solution.push_back(bestIdx);\n curScore += bestDelta;\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = solution;\n }\n }\n\n /* ==================== Simulated Annealing ==================== */\n mt19937_64 rng((uint64_t)chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution prob(0.0, 1.0);\n\n const int maxIter = 40000;\n const double Tstart = 2e5;\n const double Tend = 1.0;\n\n for (int it = 0; it < maxIter; ++it) {\n double T = Tstart * pow(Tend / Tstart, (double)it / maxIter);\n double r = prob(rng);\n bool moved = false;\n long long delta = 0;\n\n if ((int)solution.size() < K && r < 0.4) {\n /* ---- add a random placement ---- */\n int idx = (int)(rng() % PLsize);\n const Placement &pl = PL[idx];\n delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] + inc) % MOD;\n delta += nw - old;\n }\n if (delta > 0 || exp((double)delta / T) > prob(rng)) {\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n solution.push_back(idx);\n curScore += delta;\n moved = true;\n }\n } else if (!solution.empty()) {\n if (r < 0.6) {\n /* ---- replace one placement by another ---- */\n int pos = (int)(rng() % solution.size());\n int oldIdx = solution[pos];\n int newIdx = (int)(rng() % PLsize);\n const Placement &oldPl = PL[oldIdx];\n const Placement &newPl = PL[newIdx];\n\n long long dArr[81] = {0};\n for (int t = 0; t < 9; ++t) dArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) dArr[newPl.cell[t]] += newPl.inc[t];\n\n delta = 0;\n for (int c = 0; c < 81; ++c) if (dArr[c] != 0) {\n long long oldR = (a[c] + add[c]) % MOD;\n long long newR = (a[c] + add[c] + dArr[c]) % MOD;\n delta += newR - oldR;\n }\n if (delta > 0 || exp((double)delta / T) > prob(rng)) {\n for (int c = 0; c < 81; ++c) if (dArr[c] != 0) add[c] += dArr[c];\n solution[pos] = newIdx;\n curScore += delta;\n moved = true;\n }\n } else {\n /* ---- remove one placement ---- */\n int pos = (int)(rng() % solution.size());\n int idx = solution[pos];\n const Placement &pl = PL[idx];\n delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long oldR = (a[c] + add[c]) % MOD;\n long long newR = (a[c] + add[c] - inc) % MOD;\n if (newR < 0) newR += MOD;\n delta += newR - oldR;\n }\n if (delta > 0 || exp((double)delta / T) > prob(rng)) {\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] -= pl.inc[t];\n solution.erase(solution.begin() + pos);\n curScore += delta;\n moved = true;\n }\n }\n }\n\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = solution;\n }\n }\n\n /* ==================== Output ==================== */\n cout << (int)bestSolution.size() << '\\n';\n for (int idx : bestSolution) {\n const Placement &pl = PL[idx];\n cout << pl.stamp << ' ' << pl.p << ' ' << pl.q << '\\n';\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Pos { int r, c; };\n\n// direction towards target (one step)\nchar moveTowards(const Pos& cur, const Pos& tar) {\n if (cur.r < tar.r) return 'D';\n if (cur.r > tar.r) return 'U';\n if (cur.c < tar.c) return 'R';\n if (cur.c > tar.c) return 'L';\n return '.';\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int N = 5;\n const int TOT = N * N; // 25 containers\n vector> A(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> A[i][j];\n\n // source row of each container, destination row of each container\n int srcRow[TOT], dstRow[TOT];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int b = A[i][j];\n srcRow[b] = i;\n dstRow[b] = b / N;\n }\n\n // state of the large crane\n Pos crane{0, 0};\n int carrying = -1; // container number or -1\n\n // per\u2011row state of receiving gates\n int nextIdx[N] = {0}; // next container to appear\n bool gateHas[N] = {false};\n int gateCont[N]; // valid only if gateHas==true\n\n // actions strings, one per crane (0 = large, 1..4 = small)\n vector act(N);\n int delivered = 0; // number of dispatched containers\n const int MAX_TURNS = 10000;\n\n for (int turn = 1; turn <= MAX_TURNS && delivered < TOT; ++turn) {\n /* ---------- step 1 : arrivals ---------- */\n for (int i = 0; i < N; ++i) {\n if (!gateHas[i] && nextIdx[i] < N &&\n !(crane.r == i && crane.c == 0)) {\n int b = A[i][nextIdx[i]];\n gateHas[i] = true;\n gateCont[i] = b;\n ++nextIdx[i];\n }\n }\n\n /* ---------- step 2 : crane actions ---------- */\n char actLarge = '.';\n\n if (carrying != -1) { // carrying a container\n int tr = dstRow[carrying];\n int tc = N - 1;\n if (crane.r == tr && crane.c == tc) {\n actLarge = 'Q'; // release & dispatch\n ++delivered;\n carrying = -1;\n } else {\n actLarge = moveTowards(crane, {tr, tc});\n // update position\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else { // empty crane\n // choose the waiting container with minimal (travel) cost\n int bestRow = -1;\n int bestCost = INT_MAX;\n for (int i = 0; i < N; ++i) if (gateHas[i]) {\n int b = gateCont[i];\n // distance crane -> source\n int dist1 = abs(crane.r - i) + crane.c; // column diff = crane.c - 0\n // distance source -> dispatch\n int dist2 = abs(i - dstRow[b]) + (N - 1); // column diff = N-1\n int cost = dist1 + dist2;\n if (cost < bestCost) {\n bestCost = cost;\n bestRow = i;\n }\n }\n if (bestRow != -1) {\n if (crane.r == bestRow && crane.c == 0) {\n // already on the gate, pick it up\n actLarge = 'P';\n carrying = gateCont[bestRow];\n gateHas[bestRow] = false;\n } else {\n // move towards the gate\n actLarge = moveTowards(crane, {bestRow, 0});\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else {\n // nothing to do, wait\n actLarge = '.';\n }\n }\n\n act[0].push_back(actLarge); // large crane\n\n // small cranes: bomb on turn 1, otherwise nothing\n for (int i = 1; i < N; ++i) {\n if (turn == 1) act[i].push_back('B');\n else act[i].push_back('.');\n }\n }\n\n // pad all strings to the same length (they already are)\n size_t maxLen = 0;\n for (int i = 0; i < N; ++i) maxLen = max(maxLen, act[i].size());\n for (int i = 0; i < N; ++i) {\n if (act[i].size() < maxLen) act[i].append(maxLen - act[i].size(), '.');\n }\n\n for (int i = 0; i < N; ++i) cout << act[i] << '\\n';\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int x, y; // coordinates\n int rem; // remaining amount ( >0 for positive cells,\n // >0 for negative cells as demand)\n bool pos; // true : originally positive height\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n if (!(cin >> N)) return 0;\n const int MAXN = 20;\n vector> h(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> h[i][j];\n\n vector pos, neg;\n long long totalSupply = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (h[i][j] > 0) {\n pos.push_back({i, j, h[i][j], true});\n totalSupply += h[i][j];\n } else if (h[i][j] < 0) {\n neg.push_back({i, j, -h[i][j], false});\n }\n }\n\n // Upper bound for the load we keep on the truck\n long long Lmax = max(1LL, totalSupply / 20);\n // current state\n int cx = 0, cy = 0; // start position\n long long load = 0; // soil on the truck\n\n vector out; // all operations\n\n auto move_to = [&](int tx, int ty) {\n while (cx < tx) { out.emplace_back(\"D\"); ++cx; }\n while (cx > tx) { out.emplace_back(\"U\"); --cx; }\n while (cy < ty) { out.emplace_back(\"R\"); ++cy; }\n while (cy > ty) { out.emplace_back(\"L\"); --cy; }\n };\n\n while (!pos.empty() || !neg.empty()) {\n if (load < Lmax && !pos.empty()) {\n // choose nearest positive cell\n int bestIdx = -1;\n int bestDist = INT_MAX;\n for (int i = 0; i < (int)pos.size(); ++i) {\n int d = abs(cx - pos[i].x) + abs(cy - pos[i].y);\n if (d < bestDist) {\n bestDist = d;\n bestIdx = i;\n }\n }\n Cell &c = pos[bestIdx];\n move_to(c.x, c.y);\n int take = (int)min(Lmax - load, c.rem);\n load += take;\n c.rem -= take;\n out.emplace_back(\"+\" + to_string(take));\n if (c.rem == 0) {\n swap(pos[bestIdx], pos.back());\n pos.pop_back();\n }\n } else if (load > 0 && !neg.empty()) {\n // choose nearest negative cell\n int bestIdx = -1;\n int bestDist = INT_MAX;\n for (int i = 0; i < (int)neg.size(); ++i) {\n int d = abs(cx - neg[i].x) + abs(cy - neg[i].y);\n if (d < bestDist) {\n bestDist = d;\n bestIdx = i;\n }\n }\n Cell &c = neg[bestIdx];\n move_to(c.x, c.y);\n int give = (int)min(load, c.rem);\n load -= give;\n c.rem -= give;\n out.emplace_back(\"-\" + to_string(give));\n if (c.rem == 0) {\n swap(neg[bestIdx], neg.back());\n neg.pop_back();\n }\n } else {\n // safety net \u2013 should never happen because total supply = total demand\n break;\n }\n }\n\n // output\n cout << out.size() << '\\n';\n for (const string &s : out) cout << s << '\\n';\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, T;\n cin >> N >> M >> T; // N=6, M=15, T=10\n const int S = 2 * N * (N - 1); // 60\n const int CELLS = N * N; // 36\n\n // read initial seeds\n vector> seed(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n\n // pre\u2011compute neighbour list of each board cell\n vector> neigh(CELLS);\n auto addNeighbour = [&](int r, int c, int nr, int nc) {\n if (0 <= nr && nr < N && 0 <= nc && nc < N) {\n neigh[r * N + c].push_back(nr * N + nc);\n }\n };\n for (int r = 0; r < N; ++r)\n for (int c = 0; c < N; ++c) {\n addNeighbour(r, c, r - 1, c);\n addNeighbour(r, c, r + 1, c);\n addNeighbour(r, c, r, c - 1);\n addNeighbour(r, c, r, c + 1);\n }\n\n // helper: sum of a seed\n auto sumSeed = [&](int id) {\n int s = 0;\n for (int v : seed[id]) s += v;\n return s;\n };\n\n // helper: w[id1][id2] = \u03a3_l max(x[id1][l], x[id2][l])\n vector> w(S, vector(S, 0));\n for (int i = 0; i < S; ++i)\n for (int j = i; j < S; ++j) {\n int val = 0;\n for (int l = 0; l < M; ++l)\n val += max(seed[i][l], seed[j][l]);\n w[i][j] = w[j][i] = val;\n }\n\n // main loop\n for (int turn = 0; turn < T; ++turn) {\n\n // ---------- 1. greedy selection of 36 seeds ----------\n vector curMax(M, -1);\n vector used(S, 0);\n vector chosen; chosen.reserve(CELLS);\n for (int taken = 0; taken < CELLS; ++taken) {\n int bestId = -1;\n int bestGain = -1;\n int bestSum = -1;\n for (int id = 0; id < S; ++id) if (!used[id]) {\n int gain = 0;\n for (int l = 0; l < M; ++l)\n if (seed[id][l] > curMax[l]) gain += seed[id][l] - curMax[l];\n if (gain > bestGain ||\n (gain == bestGain && sumSeed(id) > bestSum)) {\n bestGain = gain;\n bestId = id;\n bestSum = sumSeed(id);\n }\n }\n // bestId must exist\n used[bestId] = 1;\n chosen.push_back(bestId);\n for (int l = 0; l < M; ++l)\n curMax[l] = max(curMax[l], seed[bestId][l]);\n }\n\n // ---------- 2. sort board cells by degree ----------\n vector> cells; cells.reserve(CELLS);\n for (int r = 0; r < N; ++r)\n for (int c = 0; c < N; ++c)\n cells.emplace_back(r, c);\n sort(cells.begin(), cells.end(),\n [&](const pair& a, const pair& b) {\n int degA = (int)neigh[a.first * N + a.second].size();\n int degB = (int)neigh[b.first * N + b.second].size();\n return degA > degB;\n });\n\n // ---------- 3. initial placement ----------\n vector pos2seed(CELLS, -1);\n for (int i = 0; i < CELLS; ++i) {\n int r = cells[i].first, c = cells[i].second;\n pos2seed[r * N + c] = chosen[i];\n }\n\n // helper: recompute total W\n auto totalW = [&](const vector& assign) -> long long {\n long long tot = 0;\n for (int idx = 0; idx < CELLS; ++idx) {\n int r = idx / N, c = idx % N;\n int s1 = assign[idx];\n if (c + 1 < N) {\n int s2 = assign[idx + 1];\n tot += w[s1][s2];\n }\n if (r + 1 < N) {\n int s2 = assign[idx + N];\n tot += w[s1][s2];\n }\n }\n return tot;\n };\n\n // ---------- 4. hill\u2011climbing ----------\n // 4a) composition exchanges (replace a placed seed by an unused one)\n vector inPlace(S, 0);\n for (int id : chosen) inPlace[id] = 1;\n bool changed = true;\n while (changed) {\n changed = false;\n for (int cell = 0; cell < CELLS; ++cell) {\n int cur = pos2seed[cell];\n for (int cand = 0; cand < S; ++cand) if (!inPlace[cand]) {\n int delta = 0;\n for (int nb : neigh[cell])\n delta += w[cand][pos2seed[nb]] - w[cur][pos2seed[nb]];\n if (delta > 0) {\n // perform replacement\n inPlace[cur] = 0;\n pos2seed[cell] = cand;\n inPlace[cand] = 1;\n changed = true;\n break; // restart from the beginning\n }\n }\n if (changed) break;\n }\n }\n\n // 4b) neighbour swaps\n changed = true;\n while (changed) {\n changed = false;\n for (int p = 0; p < CELLS; ++p) {\n for (int q = p + 1; q < CELLS; ++q) {\n int sp = pos2seed[p];\n int sq = pos2seed[q];\n if (sp == sq) continue;\n long long delta = 0;\n for (int nb : neigh[p]) {\n delta += w[sq][pos2seed[nb]] - w[sp][pos2seed[nb]];\n }\n for (int nb : neigh[q]) {\n if (nb == p) continue;\n delta += w[sp][pos2seed[nb]] - w[sq][pos2seed[nb]];\n }\n if (delta > 0) {\n swap(pos2seed[p], pos2seed[q]);\n changed = true;\n }\n }\n }\n }\n\n // ---------- 5. output ----------\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (c) cout << ' ';\n cout << pos2seed[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n\n // ---------- 6. read next seeds ----------\n seed.assign(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n\n // recompute w matrix for the new seeds\n for (int i = 0; i < S; ++i)\n for (int j = i; j < S; ++j) {\n int val = 0;\n for (int l = 0; l < M; ++l)\n val += max(seed[i][l], seed[j][l]);\n w[i][j] = w[j][i] = val;\n }\n }\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct PosDir {\n int x, y, d; // neighbour position and leaf direction\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, Vlimit;\n if (!(cin >> N >> M >> Vlimit)) return 0;\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 // -----------------------------------------------------------------\n // design of the arm (root + one leaf, length 1)\n const int Vprime = 2;\n cout << Vprime << \"\\n\";\n cout << 0 << ' ' << 1 << \"\\n\"; // parent of vertex 1, length\n cout << 0 << ' ' << 0 << \"\\n\"; // initial root position\n\n // -----------------------------------------------------------------\n // data structures for sources and targets\n vector> src, tgt;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (s[i][j] == '1') src.emplace_back(i, j);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (t[i][j] == '1') tgt.emplace_back(i, j);\n\n // neighbours of every source / target (root positions that can be used)\n vector> srcNb(src.size()), tgtNb(tgt.size());\n const int DX[4] = {0, 1, 0, -1}; // 0:E, 1:S, 2:W, 3:N\n const int DY[4] = {1, 0, -1, 0};\n\n for (size_t i = 0; i < src.size(); ++i) {\n int x = src[i].first, y = src[i].second;\n for (int d = 0; d < 4; ++d) {\n int nx = x - DX[d];\n int ny = y - DY[d];\n if (0 <= nx && nx < N && 0 <= ny && ny < N)\n srcNb[i].push_back({nx, ny, d});\n }\n }\n for (size_t i = 0; i < tgt.size(); ++i) {\n int x = tgt[i].first, y = tgt[i].second;\n for (int d = 0; d < 4; ++d) {\n int nx = x - DX[d];\n int ny = y - DY[d];\n if (0 <= nx && nx < N && 0 <= ny && ny < N)\n tgtNb[i].push_back({nx, ny, d});\n }\n }\n\n // -----------------------------------------------------------------\n // simulation\n vector srcIdx(src.size()), tgtIdx(tgt.size());\n iota(srcIdx.begin(), srcIdx.end(), 0);\n iota(tgtIdx.begin(), tgtIdx.end(), 0);\n\n vector> board(N, vector(N, 0));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (s[i][j] == '1') board[i][j] = 1;\n\n int rx = 0, ry = 0; // current root position\n int leafDir = 0; // 0 = east\n bool holding = false;\n\n vector ops; // store all turns\n\n auto addTurn = [&](char mv, char rot, char leafAct) {\n string s(4, '.');\n s[0] = mv;\n s[1] = rot;\n s[3] = leafAct;\n ops.push_back(s);\n };\n\n // move root from (rx,ry) to (gx,gy) (Manhattan walk)\n auto moveRoot = [&](int gx, int gy) {\n while (rx != gx || ry != gy) {\n char mv;\n if (rx < gx) { mv = 'D'; ++rx; }\n else if (rx > gx) { mv = 'U'; --rx; }\n else if (ry < gy) { mv = 'R'; ++ry; }\n else if (ry > gy) { mv = 'L'; --ry; }\n addTurn(mv, '.', '.');\n }\n };\n\n // rotate leaf step by step until it equals target direction\n auto rotateLeafTo = [&](int target) {\n while (leafDir != target) {\n int diff = (target - leafDir + 4) % 4;\n char rot;\n if (diff == 1) { rot = 'R'; leafDir = (leafDir + 1) % 4; }\n else if (diff == 3) { rot = 'L'; leafDir = (leafDir + 3) % 4; }\n else { // diff == 2, choose any direction\n rot = 'R';\n leafDir = (leafDir + 1) % 4;\n }\n addTurn('.', rot, '.');\n }\n };\n\n // main loop\n while (!srcIdx.empty()) {\n // ----- choose the nearest source neighbour -----------------\n int bestSrc = -1, bestNx = -1, bestNy = -1, bestDir = -1;\n int bestDist = INT_MAX;\n for (int si : srcIdx) {\n for (const PosDir &pd : srcNb[si]) {\n int d = abs(rx - pd.x) + abs(ry - pd.y);\n if (d < bestDist) {\n bestDist = d;\n bestSrc = si;\n bestNx = pd.x; bestNy = pd.y; bestDir = pd.d;\n }\n }\n }\n\n // move to neighbour of source\n moveRoot(bestNx, bestNy);\n // rotate leaf to direction that points to source\n rotateLeafTo(bestDir);\n // pick\n addTurn('.', '.', 'P');\n board[src[bestSrc].first][src[bestSrc].second] = 0;\n holding = true;\n srcIdx.erase(remove(srcIdx.begin(), srcIdx.end(), bestSrc), srcIdx.end());\n\n // ----- choose the nearest target neighbour -----------------\n int bestTgt = -1, bestMx = -1, bestMy = -1, bestDirT = -1;\n int bestDistT = INT_MAX;\n for (int ti : tgtIdx) {\n for (const PosDir &pd : tgtNb[ti]) {\n int d = abs(rx - pd.x) + abs(ry - pd.y);\n if (d < bestDistT) {\n bestDistT = d;\n bestTgt = ti;\n bestMx = pd.x; bestMy = pd.y; bestDirT = pd.d;\n }\n }\n }\n\n // move to neighbour of target\n moveRoot(bestMx, bestMy);\n // rotate leaf to direction that points to target\n rotateLeafTo(bestDirT);\n // place\n addTurn('.', '.', 'P');\n board[tgt[bestTgt].first][tgt[bestTgt].second] = 1;\n holding = false;\n tgtIdx.erase(remove(tgtIdx.begin(), tgtIdx.end(), bestTgt), tgtIdx.end());\n }\n\n // -----------------------------------------------------------------\n // output all turns\n for (const string &line : ops) cout << line << \"\\n\";\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n int sign; // +1 mackerel, -1 sardine\n};\n\nconst int MAXC = 505; // > maximal number of cells (501)\nconst int MAXCOORD = 100000;\nconst int CELLSIZE = 200; // 100000 / 200 + 1 = 501 cells\n\nint cell[MAXC][MAXC]; // net value of a cell\n\n// Kadane: maximum sub\u2011array sum of arr[0..n-1], also returns borders\nint kadane(const int *arr, int n, int &bestL, int &bestR) {\n int maxSum = INT_MIN;\n int curSum = 0;\n int start = 0;\n bestL = 0;\n bestR = 0;\n for (int i = 0; i < n; ++i) {\n curSum += arr[i];\n if (curSum > maxSum) {\n maxSum = curSum;\n bestL = start;\n bestR = i;\n }\n if (curSum < 0) {\n curSum = 0;\n start = i + 1;\n }\n }\n return maxSum;\n}\n\n// ------------------------------------------------------------\n// fallback: tiny rectangle around one mackerel, hopefully without sardines\nbool fallback_rectangle(vector &points,\n int &L, int &R, int &B, int &T) {\n // collect sardines separately for fast checking\n vector sardines;\n for (auto &p : points) if (p.sign == -1) sardines.push_back(p);\n\n for (auto &p : points) {\n if (p.sign != 1) continue; // only mackerels\n for (int dx = -5; dx <= 0; ++dx) {\n for (int dy = -5; dy <= 0; ++dy) {\n int left = p.x + dx;\n int bot = p.y + dy;\n if (left < 0 || bot < 0) continue;\n int right = left + 1;\n int top = bot + 1;\n if (right > MAXCOORD || top > MAXCOORD) continue;\n bool ok = true;\n for (auto &s : sardines) {\n if (s.x >= left && s.x <= right &&\n s.y >= bot && s.y <= top) {\n ok = false;\n break;\n }\n }\n if (ok) {\n L = left; R = right; B = bot; T = top;\n return true;\n }\n }\n }\n }\n // desperate fallback: first mackerel, 1\u00d71 square (may contain a sardine)\n L = points[0].x;\n B = points[0].y;\n R = L + 1;\n T = B + 1;\n return true;\n}\n\n// ------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n if (!(cin >> N)) return 0;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n int x, y;\n cin >> x >> y;\n points[i] = {x, y, (i < N) ? 1 : -1};\n }\n\n const int C = MAXCOORD / CELLSIZE + 1; // 501\n // clear grid\n for (int i = 0; i < C; ++i)\n for (int j = 0; j < C; ++j)\n cell[i][j] = 0;\n\n // fill cells\n for (auto &p : points) {\n int cx = p.x / CELLSIZE;\n int cy = p.y / CELLSIZE;\n cell[cx][cy] += p.sign;\n }\n\n // ---------- maximum sum sub\u2011matrix on the cell grid ----------\n int bestSum = INT_MIN;\n int bestTop = 0, bestBottom = 0, bestLeft = 0, bestRight = 0;\n\n for (int top = 0; top < C; ++top) {\n int colSum[MAXC] = {0};\n for (int bottom = top; bottom < C; ++bottom) {\n // add row 'bottom' to column sums\n for (int col = 0; col < C; ++col) colSum[col] += cell[bottom][col];\n\n int L, R;\n int cur = kadane(colSum, C, L, R);\n if (cur > bestSum) {\n bestSum = cur;\n bestTop = top;\n bestBottom = bottom;\n bestLeft = L;\n bestRight = R;\n }\n }\n }\n\n // ---------- translate best cell rectangle to coordinate rectangle ----------\n int leftX = bestLeft * CELLSIZE;\n int rightX = min((bestRight + 1) * CELLSIZE - 1, MAXCOORD);\n int bottomY = bestTop * CELLSIZE;\n int topY = min((bestBottom + 1) * CELLSIZE - 1, MAXCOORD);\n\n // collect points inside\n vector inside;\n inside.reserve(points.size());\n for (auto &p : points) {\n if (p.x >= leftX && p.x <= rightX && p.y >= bottomY && p.y <= topY)\n inside.push_back(&p);\n }\n\n int a = 0, b = 0;\n for (auto pp : inside) {\n if (pp->sign == 1) ++a;\n else ++b;\n }\n\n int finalL, finalR, finalB, finalT;\n\n if (a - b > 0) {\n // tighten rectangle to the extreme coordinates of the points it contains\n int minX = leftX, maxX = rightX, minY = bottomY, maxY = topY;\n for (auto pp : inside) {\n minX = min(minX, pp->x);\n maxX = max(maxX, pp->x);\n minY = min(minY, pp->y);\n maxY = max(maxY, pp->y);\n }\n finalL = minX;\n finalR = maxX;\n finalB = minY;\n finalT = maxY;\n\n // make sure the rectangle has positive width and height\n if (finalL == finalR) {\n if (finalR + 1 <= MAXCOORD) ++finalR;\n else --finalL;\n }\n if (finalB == finalT) {\n if (finalT + 1 <= MAXCOORD) ++finalT;\n else --finalB;\n }\n\n // after possible expansion a sardine could have entered \u2013 recheck\n bool ok = true;\n for (auto &p : points) if (p.sign == -1) {\n if (p.x >= finalL && p.x <= finalR && p.y >= finalB && p.y <= finalT) {\n ok = false; break;\n }\n }\n if (!ok) {\n // fallback \u2013 safe rectangle with guaranteed positive score\n fallback_rectangle(points, finalL, finalR, finalB, finalT);\n }\n } else {\n // fallback\n fallback_rectangle(points, finalL, finalR, finalB, finalT);\n }\n\n // ---------- output ----------\n cout << 4 << '\\n';\n cout << finalL << ' ' << finalB << '\\n';\n cout << finalR << ' ' << finalB << '\\n';\n cout << finalR << ' ' << finalT << '\\n';\n cout << finalL << ' ' << finalT << '\\n';\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n long long sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n vector w_obs(N), h_obs(N);\n for (int i = 0; i < N; ++i) cin >> w_obs[i] >> h_obs[i];\n\n /* ------------------------------------------------------------\n 1. choose the best orientation for a single row\n ------------------------------------------------------------ */\n struct Option { long long w, h; bool rot; };\n vector> opt(N);\n for (int i = 0; i < N; ++i) {\n opt[i][0] = {w_obs[i], h_obs[i], false}; // original\n opt[i][1] = {h_obs[i], w_obs[i], true}; // rotated\n }\n\n // candidate heights = all heights that appear\n vector cand;\n cand.reserve(2*N);\n for (int i = 0; i < N; ++i) {\n cand.push_back(w_obs[i]);\n cand.push_back(h_obs[i]);\n }\n sort(cand.begin(), cand.end());\n cand.erase(unique(cand.begin(), cand.end()), cand.end());\n\n const long long INF = (1LL<<62);\n long long bestCost = INF;\n vector bestRot(N, 0); // 0 = original, 1 = rotated\n vector bestW(N), bestH(N);\n\n for (long long H : cand) {\n long long sumW = 0;\n bool ok = true;\n vector rotTmp(N, 0);\n for (int i = 0; i < N; ++i) {\n long long bestWidth = INF;\n bool rot = false;\n for (int k = 0; k < 2; ++k) {\n if (opt[i][k].h <= H && opt[i][k].w < bestWidth) {\n bestWidth = opt[i][k].w;\n rot = opt[i][k].rot;\n }\n }\n if (bestWidth == INF) { ok = false; break; }\n sumW += bestWidth;\n rotTmp[i] = rot;\n }\n if (ok && sumW + H < bestCost) {\n bestCost = sumW + H;\n bestRot = rotTmp;\n }\n }\n\n // build final dimensions\n for (int i = 0; i < N; ++i) {\n if (bestRot[i]) {\n bestW[i] = h_obs[i];\n bestH[i] = w_obs[i];\n } else {\n bestW[i] = w_obs[i];\n bestH[i] = h_obs[i];\n }\n }\n\n /* ------------------------------------------------------------\n 2. output the same placement T times\n ------------------------------------------------------------ */\n for (int turn = 0; turn < T; ++turn) {\n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n cout << i << ' ' << (bestRot[i] ? 1 : 0) << ' ' << 'U' << ' '\n << (i == 0 ? -1 : i-1) << \"\\n\";\n }\n cout << flush; // required by the statement\n long long Wmes, Hmes;\n cin >> Wmes >> Hmes; // measurement, not used further\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nstruct TreeInfo {\n vector> children; // rooted children\n int root; // root vertex (its parent = -1)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n vector A(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n vector> adj(N);\n for (int i = 0; i < M; ++i) {\n int u, v; cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n // read coordinates \u2013 not needed for the algorithm\n for (int i = 0; i < N; ++i) {\n long long x, y; cin >> x >> y;\n }\n\n const long long NEG_INF = -(1LL << 60);\n\n mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());\n\n long long bestScore = NEG_INF;\n vector bestParent; // answer\n vector bestDepth;\n\n const int ITER = 2000; // can be increased if time permits\n for (int it = 0; it < ITER; ++it) {\n /* ---------- build a random spanning tree ---------- */\n vector parent(N, -2); // -2 = unvisited, -1 = root\n vector> treeAdj(N);\n int start = uniform_int_distribution(0, N - 1)(rng);\n vector st = {start};\n parent[start] = -1;\n while (!st.empty()) {\n int v = st.back(); st.pop_back();\n // random order of neighbours\n vector nbr = adj[v];\n shuffle(nbr.begin(), nbr.end(), rng);\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n treeAdj[v].push_back(u);\n treeAdj[u].push_back(v);\n st.push_back(u);\n }\n }\n }\n\n /* ---------- build children list (root = start) ---------- */\n TreeInfo TI;\n TI.root = start;\n TI.children.assign(N, {});\n for (int v = 0; v < N; ++v) {\n if (v != TI.root && parent[v] != -2) {\n TI.children[parent[v]].push_back(v);\n }\n }\n\n /* ---------- DP on the rooted tree ---------- */\n // dp[v][d] (d = 0..H)\n vector> dp(N);\n // decisions: take[v][d][i] (1 = keep edge to child i, 0 = cut)\n vector>> take(N);\n\n function dfs = [&](int v) {\n for (int u : TI.children[v]) dfs(u);\n int childCnt = (int)TI.children[v].size();\n take[v].assign(H + 1, vector(childCnt, 0));\n for (int d = 0; d <= H; ++d) {\n long long cur = (long long)(d + 1) * A[v];\n for (int i = 0; i < childCnt; ++i) {\n int u = TI.children[v][i];\n long long keep = (d < H) ? dp[u][d + 1] : NEG_INF;\n long long cut = dp[u][0];\n if (keep > cut) {\n cur += keep;\n take[v][d][i] = 1; // keep the edge\n } else {\n cur += cut;\n take[v][d][i] = 0; // cut\n }\n }\n dp[v][d] = cur;\n }\n };\n dfs(TI.root);\n long long curScore = dp[TI.root][0];\n\n if (curScore > bestScore) {\n bestScore = curScore;\n /* reconstruct parent array for this best tree */\n bestParent.assign(N, -1);\n bestDepth.assign(N, 0);\n function build = [&](int v, int depth) {\n bestDepth[v] = depth;\n int childCnt = (int)TI.children[v].size();\n for (int i = 0; i < childCnt; ++i) {\n int u = TI.children[v][i];\n if (take[v][depth][i]) { // kept edge\n bestParent[u] = v;\n build(u, depth + 1);\n } else { // cut -> new root\n bestParent[u] = -1;\n build(u, 0);\n }\n }\n };\n build(TI.root, 0);\n }\n }\n\n // output\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << bestParent[i];\n }\n cout << '\\n';\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstruct Oni {\n int r, c; // position\n int up, down, left, right; // distances\n bool canU, canD, canL, canR; // allowed ?\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n if (!(cin >> N)) return 0;\n vector board(N);\n for (int i = 0; i < N; ++i) cin >> board[i];\n\n vector onis;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] == 'x')\n onis.push_back({i, j, i, N - 1 - i, j, N - 1 - j,\n false, false, false, false});\n\n // decide allowed directions\n for (auto &o : onis) {\n bool f;\n f = true;\n for (int r = 0; r < o.r; ++r) if (board[r][o.c] == 'o') { f = false; break; }\n o.canU = f;\n f = true;\n for (int r = o.r + 1; r < N; ++r) if (board[r][o.c] == 'o') { f = false; break; }\n o.canD = f;\n f = true;\n for (int c = 0; c < o.c; ++c) if (board[o.r][c] == 'o') { f = false; break; }\n o.canL = f;\n f = true;\n for (int c = o.c + 1; c < N; ++c) if (board[o.r][c] == 'o') { f = false; break; }\n o.canR = f;\n }\n\n vector> ops; // result sequence\n\n for (const auto &o : onis) {\n int bestDist = INT_MAX;\n char bestDir = '?';\n int param = -1; // row or column index\n\n if (o.canU && o.up < bestDist) {\n bestDist = o.up; bestDir = 'U'; param = o.c;\n }\n if (o.canD && o.down < bestDist) {\n bestDist = o.down; bestDir = 'D'; param = o.c;\n }\n if (o.canL && o.left < bestDist) {\n bestDist = o.left; bestDir = 'L'; param = o.r;\n }\n if (o.canR && o.right < bestDist) {\n bestDist = o.right; bestDir = 'R'; param = o.r;\n }\n\n // number of shifts in each direction\n int cnt = bestDist + 1; // distance + 1\n\n // first the chosen direction\n for (int k = 0; k < cnt; ++k) ops.emplace_back(bestDir, param);\n // then the opposite direction\n char opp = (bestDir == 'U' ? 'D' :\n bestDir == 'D' ? 'U' :\n bestDir == 'L' ? 'R' : 'L');\n for (int k = 0; k < cnt; ++k) ops.emplace_back(opp, param);\n }\n\n // safety check (not required, but for debugging)\n // assert(ops.size() <= 4 * N * N);\n\n cout << ops.size() << '\\n';\n for (auto [d, p] : ops) cout << d << ' ' << p << '\\n';\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int N = 100; // fixed\n const long long L = 500000LL; // fixed\n const long long AVG = L / (2LL * N); // = 2500\n\n vector T(N);\n for (int i = 0; i < N; ++i) cin >> T[i];\n\n /* ------------------------------------------------------------\n 1. compute the optimal indegrees (outSlot)\n ------------------------------------------------------------ */\n vector floor(N), rem(N), outSlot(N);\n long long sumFloor = 0, sumRem = 0;\n for (int i = 0; i < N; ++i) {\n floor[i] = int(T[i] / AVG);\n rem[i] = int(T[i] % AVG);\n sumFloor += floor[i];\n sumRem += rem[i];\n }\n long long k = sumRem / AVG; // number of extra slots\n // choose k employees with largest remainders\n vector> vec; // (remainder, index)\n vec.reserve(N);\n for (int i = 0; i < N; ++i) vec.emplace_back(rem[i], i);\n sort(vec.begin(), vec.end(),\n [](const auto& a, const auto& b){ return a.first > b.first; });\n for (int i = 0; i < N; ++i) outSlot[i] = floor[i];\n for (int i = 0; i < k; ++i) outSlot[vec[i].second]++;\n\n /* ------------------------------------------------------------\n 2. helper functions\n ------------------------------------------------------------ */\n auto simulate = [&](const vector& a,\n const vector& b,\n vector& cnt) {\n cnt.assign(N, 0);\n int cur = 0; // week 1\n cnt[cur]++; // count week 1\n for (long long week = 2; week <= L; ++week) {\n if (cnt[cur] & 1) cur = a[cur];\n else cur = b[cur];\n ++cnt[cur];\n }\n };\n\n auto error = [&](const vector& cnt) -> long long {\n long long err = 0;\n for (int i = 0; i < N; ++i) err += llabs((long long)cnt[i] - T[i]);\n return err;\n };\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n long long bestError = (1LL<<60);\n vector bestA(N), bestB(N);\n\n const int TRIALS = 300; // comfortable within 2 sec\n for (int trial = 0; trial < TRIALS; ++trial) {\n // ----- build a random plan respecting outSlot -----\n vector pool;\n pool.reserve(2*N);\n for (int i = 0; i < N; ++i)\n for (int c = 0; c < outSlot[i]; ++c) pool.push_back(i);\n shuffle(pool.begin(), pool.end(), rng);\n vector a(N), b(N);\n for (int i = 0; i < N; ++i) {\n a[i] = pool[2*i];\n b[i] = pool[2*i+1];\n if (rng() & 1) swap(a[i], b[i]); // random order of a/b\n }\n\n // ----- evaluate -----\n vector cnt;\n simulate(a, b, cnt);\n long long err = error(cnt);\n if (err < bestError) {\n bestError = err;\n bestA = a; bestB = b;\n if (bestError == 0) break; // cannot be better\n }\n }\n\n /* ------------------------------------------------------------\n 3. local improvement (swap edges of odd employees)\n ------------------------------------------------------------ */\n bool progress = true;\n while (progress) {\n progress = false;\n vector cnt;\n simulate(bestA, bestB, cnt);\n long long curErr = error(cnt);\n // list of employees with odd count\n vector oddIdx;\n for (int i = 0; i < N; ++i) if (cnt[i] & 1) oddIdx.push_back(i);\n for (int idx = 0; idx < (int)oddIdx.size(); ++idx) {\n int j = oddIdx[idx];\n // try swapping a[j] and b[j]\n swap(bestA[j], bestB[j]);\n simulate(bestA, bestB, cnt);\n long long newErr = error(cnt);\n if (newErr < curErr) {\n // keep the swap\n curErr = newErr;\n progress = true;\n // the list of odd indices changed \u2013 restart the whole pass\n break;\n } else {\n // revert\n swap(bestA[j], bestB[j]);\n }\n }\n }\n\n /* ------------------------------------------------------------\n 4. output\n ------------------------------------------------------------ */\n for (int i = 0; i < N; ++i)\n cout << bestA[i] << ' ' << bestB[i] << '\\n';\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; ++i) {\n cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n /* -----------------------------------------------------------\n 1. grouping : sort by rectangle centre\n ----------------------------------------------------------- */\n vector cx(N), cy(N);\n for (int i = 0; i < N; ++i) {\n cx[i] = (lx[i] + rx[i]) * 0.5;\n cy[i] = (ly[i] + ry[i]) * 0.5;\n }\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b) {\n if (cx[a] != cx[b]) return cx[a] < cx[b];\n return cy[a] < cy[b];\n });\n\n vector> groups(M);\n int pos = 0;\n for (int g = 0; g < M; ++g) {\n for (int cnt = 0; cnt < G[g]; ++cnt) {\n groups[g].push_back(order[pos++]);\n }\n }\n\n /* -----------------------------------------------------------\n 2. helper: perform one query\n ----------------------------------------------------------- */\n auto do_query = [&](const vector& verts) -> vector> {\n int L = (int)verts.size();\n cout << \"? \" << L;\n for (int v : verts) cout << ' ' << v;\n cout << \"\\n\";\n cout.flush();\n vector> edges;\n edges.reserve(L-1);\n for (int i = 0; i < L-1; ++i) {\n int a,b; cin >> a >> b;\n edges.emplace_back(a,b);\n }\n return edges;\n };\n\n /* -----------------------------------------------------------\n 3. ask queries for every group, store the received edges\n ----------------------------------------------------------- */\n vector>> groupEdges(M);\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n if (sz <= 1) continue; // no road needed\n if (sz <= L) {\n auto e = do_query(grp);\n groupEdges[g] = move(e);\n } else {\n int start = 0;\n while (start + 1 < sz) { // at least two vertices left\n int end = min(start + L, sz);\n vector win(grp.begin() + start, grp.begin() + end);\n auto e = do_query(win);\n groupEdges[g].insert(groupEdges[g].end(),\n e.begin(), e.end());\n start = end - 1; // overlap = 1 vertex\n }\n }\n }\n\n /* -----------------------------------------------------------\n 4. output the answer\n ----------------------------------------------------------- */\n cout << \"!\\n\";\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n // list of cities\n for (int i = 0; i < sz; ++i) {\n if (i) cout << ' ';\n cout << grp[i];\n }\n cout << \"\\n\";\n if (sz <= 1) continue; // no edges\n\n // map global id -> local index (0 \u2026 sz-1)\n vector id2loc(N, -1);\n for (int i = 0; i < sz; ++i) id2loc[grp[i]] = i;\n\n // adjacency list of the collected edges\n vector> adj(sz);\n for (auto &e : groupEdges[g]) {\n int u = e.first, v = e.second;\n int ui = id2loc[u];\n int vi = id2loc[v];\n if (ui >= 0 && vi >= 0) {\n adj[ui].push_back(vi);\n adj[vi].push_back(ui);\n }\n }\n\n // DFS to obtain a spanning tree\n vector parent(sz, -1);\n vector visited(sz, 0);\n vector st = {0};\n visited[0] = 1;\n while (!st.empty()) {\n int u = st.back(); st.pop_back();\n for (int v : adj[u]) if (!visited[v]) {\n visited[v] = 1;\n parent[v] = u;\n st.push_back(v);\n }\n }\n // (the graph is connected by Lemma\u202f1, but be safe)\n for (int i = 0; i < sz; ++i) if (!visited[i]) {\n parent[i] = 0; // connect arbitrarily\n }\n\n // output the tree edges\n for (int i = 1; i < sz; ++i) {\n int a = grp[i];\n int b = grp[parent[i]];\n if (a > b) swap(a,b);\n cout << a << ' ' << b << \"\\n\";\n }\n }\n cout.flush();\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n if (!(cin >> N >> M)) return 0; // read N (20) and M (40)\n\n vector> pt(M);\n for (int k = 0; k < M; ++k) {\n cin >> pt[k].first >> pt[k].second;\n }\n\n // current position starts with the given start square\n int cur_r = pt[0].first;\n int cur_c = pt[0].second;\n\n vector out; // store all action lines\n\n // visit all target squares in order pt[1] \u2026 pt[M-1]\n for (int idx = 1; idx < M; ++idx) {\n int tr = pt[idx].first;\n int tc = pt[idx].second;\n\n int dR = tr - cur_r;\n int dC = tc - cur_c;\n\n // vertical moves\n while (dR > 0) {\n out.emplace_back(\"M D\");\n ++cur_r;\n --dR;\n }\n while (dR < 0) {\n out.emplace_back(\"M U\");\n --cur_r;\n ++dR;\n }\n\n // horizontal moves\n while (dC > 0) {\n out.emplace_back(\"M R\");\n ++cur_c;\n --dC;\n }\n while (dC < 0) {\n out.emplace_back(\"M L\");\n --cur_c;\n ++dC;\n }\n }\n\n // (optional) safety check \u2013 not needed for the judge\n // assert(out.size() <= 2 * N * M);\n\n for (const string& s : out) {\n cout << s << '\\n';\n }\n return 0;\n}"},"2":{"ahc001":"","ahc002":"#include \nusing namespace std;\n\nstruct Tile {\n vector> cells; // squares belonging to the tile\n int weight = 0; // max value of its squares\n pair bestCell{-1,-1}; // one square that realises the weight\n};\n\nint N = 50; // board size\n\nint startI, startJ; // start coordinates\nint tileId[50][50]; // tile number of each square\nint val[50][50]; // p[i][j]\n\nint M = 0; // number of tiles\nvector tiles; // size M\nvector> adj; // adjacency between tiles (ids)\n\nint totalMaxWeight = 0; // \u03a3 weight[t] for all tiles\n\n// ---------- search data ----------\nvector visitedTile; // visited flag per tile\nint visitedCnt = 0; // how many tiles are already visited\nint sumVisitedMax = 0; // \u03a3 weight[t] of visited tiles (for bound)\n\nint curSum = 0; // real score of the current walk\nstring curMoves; // directions of the current walk\nint bestSum = 0; // best score found so far\nstring bestMoves; // directions of the best walk\n\nbool foundAll = false; // stop when all tiles are visited\nbool timeUp = false; // global stop flag\n\ndouble timeLimit = 1.8; // seconds per test case\nsteady_clock::time_point startTime;\n\ninline bool checkTime() {\n if (timeUp) return true;\n double elapsed = (steady_clock::now() - startTime).count() * 1e-9;\n if (elapsed > timeLimit) {\n timeUp = true;\n return true;\n }\n return false;\n}\n\n// direction vectors\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U','D','L','R'};\n\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n// -----------------------------------------------------------------\nvoid dfs(int ci, int cj) {\n if (timeUp) return;\n if (foundAll) return;\n\n // update best answer\n if (curSum > bestSum) {\n bestSum = curSum;\n bestMoves = curMoves;\n }\n\n // all tiles visited ?\n if (visitedCnt == M) {\n foundAll = true;\n bestSum = curSum;\n bestMoves = curMoves;\n return;\n }\n\n // bound test\n int remainingMax = totalMaxWeight - sumVisitedMax;\n if (curSum + remainingMax <= bestSum) return;\n\n // collect possible neighbour squares\n vector> cand; // (ni,nj,dir)\n for (int d = 0; d < 4; ++d) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int nt = tileId[ni][nj];\n if (visitedTile[nt]) continue; // cannot step on visited tile\n cand.emplace_back(ni, nj, d);\n }\n if (cand.empty()) return; // dead end\n\n // sort candidates: higher square value first,\n // then the neighbour tile with fewer still unvisited neighbours,\n // finally random tie\u2011break\n sort(cand.begin(), cand.end(),\n [&](const auto& A, const auto& B) {\n int ai, aj, ad; tie(ai, aj, ad) = A;\n int bi, bj, bd; tie(bi, bj, bd) = B;\n int va = val[ai][aj];\n int vb = val[bi][bj];\n if (va != vb) return va > vb; // larger value first\n int ta = tileId[ai][aj];\n int tb = tileId[bi][bj];\n int degA = 0, degB = 0;\n for (int nb : adj[ta]) if (!visitedTile[nb]) ++degA;\n for (int nb : adj[tb]) if (!visitedTile[nb]) ++degB;\n if (degA != degB) return degA < degB; // fewer options first\n return rng() % 2;\n });\n\n // try all possibilities\n for (auto &t : cand) {\n int ni, nj, d; tie(ni, nj, d) = t;\n int nt = tileId[ni][nj];\n // take this step\n visitedTile[nt] = true;\n ++visitedCnt;\n sumVisitedMax += tiles[nt].weight;\n curSum += val[ni][nj];\n curMoves.push_back(dirChar[d]);\n\n dfs(ni, nj);\n\n // backtrack\n curMoves.pop_back();\n curSum -= val[ni][nj];\n sumVisitedMax -= tiles[nt].weight;\n --visitedCnt;\n visitedTile[nt] = false;\n\n if (foundAll) return;\n if (timeUp) return;\n }\n}\n\n// -----------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n // read start position\n if (!(cin >> startI >> startJ)) return 0;\n // read tile ids\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> tileId[i][j];\n // read values\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> val[i][j];\n\n // ----- build tile information -----\n int maxTileId = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n maxTileId = max(maxTileId, tileId[i][j]);\n M = maxTileId + 1;\n tiles.assign(M, Tile());\n // fill cells\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int id = tileId[i][j];\n tiles[id].cells.emplace_back(i, j);\n }\n // compute weight and best cell for each tile\n for (int id = 0; id < M; ++id) {\n int bestVal = -1;\n pair best = {-1,-1};\n for (auto [i,j] : tiles[id].cells) {\n if (val[i][j] > bestVal) {\n bestVal = val[i][j];\n best = {i,j};\n }\n }\n tiles[id].weight = bestVal;\n tiles[id].bestCell = best;\n }\n\n // ----- adjacency between tiles -----\n adj.assign(M, {});\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int a = tileId[i][j];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d];\n int nj = j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int b = tileId[ni][nj];\n if (a != b) adj[a].push_back(b);\n }\n }\n }\n // remove duplicate neighbours\n for (int i = 0; i < M; ++i) {\n sort(adj[i].begin(), adj[i].end());\n adj[i].erase(unique(adj[i].begin(), adj[i].end()), adj[i].end());\n }\n\n // ----- total maximal weight (upper bound) -----\n totalMaxWeight = 0;\n for (int i = 0; i < M; ++i) totalMaxWeight += tiles[i].weight;\n\n // ----- initialise search -----\n visitedTile.assign(M, 0);\n int startTile = tileId[startI][startJ];\n visitedTile[startTile] = 1;\n visitedCnt = 1;\n sumVisitedMax = tiles[startTile].weight;\n curSum = val[startI][startJ]; // start square value\n bestSum = curSum;\n curMoves.clear();\n bestMoves.clear();\n\n startTime = steady_clock::now();\n\n // ----- start DFS -----\n dfs(startI, startJ);\n\n // ----- output -----\n cout << bestMoves << '\\n';\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nconstexpr int N = 30; // grid size\nconstexpr int V = N * N; // number of vertices\nconstexpr double INF = 1e100;\nconstexpr double LR = 0.1; // learning rate\nconstexpr double MIN_FACTOR = 0.5;\nconstexpr double MAX_FACTOR = 2.0;\nconstexpr double MIN_W = 100.0;\nconstexpr double MAX_W = 20000.0;\nconstexpr double INIT_W = 5000.0; // optimistic middle value\n\n/* ------------------------------------------------------------------ */\n/* structure that stores the current edge weights (undirected) */\n/* ------------------------------------------------------------------ */\nstruct EdgeWeight {\n // horizontal edges : between (i,j) <-> (i,j+1) size N x (N-1)\n vector> h;\n // vertical edges : between (i,j) <-> (i+1,j) size (N-1) x N\n vector> v;\n\n EdgeWeight() {\n h.assign(N, vector(N - 1, INIT_W));\n v.assign(N - 1, vector(N, INIT_W));\n }\n\n // getters\n double getH(int i, int j) const { return h[i][j]; }\n double getV(int i, int j) const { return v[i][j]; }\n\n // reference getters (for update)\n double& refH(int i, int j) { return h[i][j]; }\n double& refV(int i, int j) { return v[i][j]; }\n} Ew;\n\n/* ------------------------------------------------------------------ */\n/* convert (row,col) to a vertex id */\n/* ------------------------------------------------------------------ */\ninline int id(int r, int c) { return r * N + c; }\n\n/* ------------------------------------------------------------------ */\n/* Dijkstra \u2013 returns the vertex sequence of a shortest path. */\n/* If randomPath == true, a uniformly random shortest path is */\n/* returned (exploiting tie\u2011breaking). */\n/* ------------------------------------------------------------------ */\nvector dijkstra(int sr, int sc, int tr, int tc, bool randomPath) {\n const int start = id(sr, sc);\n const int target = id(tr, tc);\n\n vector dist(V, INF);\n vector prev(V, -1);\n dist[start] = 0.0;\n\n using PDI = pair;\n priority_queue, greater> pq;\n pq.emplace(0.0, start);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u] + 1e-12) continue; // outdated entry\n if (u == target) break; // we already have the optimum\n\n int ur = u / N, uc = u % N;\n\n // four neighbours -------------------------------------------------\n // up\n if (ur > 0) {\n double w = Ew.getV(ur - 1, uc);\n int v = id(ur - 1, uc);\n double nd = d + w;\n if (nd + 1e-12 < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.emplace(nd, v);\n }\n }\n // down\n if (ur + 1 < N) {\n double w = Ew.getV(ur, uc);\n int v = id(ur + 1, uc);\n double nd = d + w;\n if (nd + 1e-12 < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.emplace(nd, v);\n }\n }\n // left\n if (uc > 0) {\n double w = Ew.getH(ur, uc - 1);\n int v = id(ur, uc - 1);\n double nd = d + w;\n if (nd + 1e-12 < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.emplace(nd, v);\n }\n }\n // right\n if (uc + 1 < N) {\n double w = Ew.getH(ur, uc);\n int v = id(ur, uc + 1);\n double nd = d + w;\n if (nd + 1e-12 < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.emplace(nd, v);\n }\n }\n }\n\n // --------------------------------------------------------------------\n // path reconstruction\n // --------------------------------------------------------------------\n vector path;\n if (randomPath) {\n // pick a random shortest path by backward walk\n int cur = target;\n while (cur != start) {\n double curDist = dist[cur];\n vector cand;\n int cr = cur / N, cc = cur % N;\n\n // up\n if (cr > 0) {\n int v = id(cr - 1, cc);\n double w = Ew.getV(cr - 1, cc);\n if (fabs(dist[v] + w - curDist) < 1e-9) cand.push_back(v);\n }\n // down\n if (cr + 1 < N) {\n int v = id(cr + 1, cc);\n double w = Ew.getV(cr, cc);\n if (fabs(dist[v] + w - curDist) < 1e-9) cand.push_back(v);\n }\n // left\n if (cc > 0) {\n int v = id(cr, cc - 1);\n double w = Ew.getH(cr, cc - 1);\n if (fabs(dist[v] + w - curDist) < 1e-9) cand.push_back(v);\n }\n // right\n if (cc + 1 < N) {\n int v = id(cr, cc + 1);\n double w = Ew.getH(cr, cc);\n if (fabs(dist[v] + w - curDist) < 1e-9) cand.push_back(v);\n }\n\n if (!cand.empty()) {\n int nxt = cand[rand() % cand.size()];\n path.push_back(cur);\n cur = nxt;\n } else {\n // safety fallback (should never happen)\n int p = prev[cur];\n if (p == -1) break; // disconnected \u2013 impossible\n path.push_back(cur);\n cur = p;\n }\n }\n path.push_back(start);\n reverse(path.begin(), path.end());\n } else {\n // deterministic predecessor walk\n int cur = target;\n while (cur != start) {\n path.push_back(cur);\n cur = prev[cur];\n if (cur == -1) break; // should not happen\n }\n path.push_back(start);\n reverse(path.begin(), path.end());\n }\n return path;\n}\n\n/* ------------------------------------------------------------------ */\n/* convert a vertex sequence into a string of moves */\n/* ------------------------------------------------------------------ */\nstring pathToString(const vector& p) {\n string out;\n out.reserve(p.size());\n for (size_t i = 0; i + 1 < p.size(); ++i) {\n int u = p[i], v = p[i + 1];\n int ur = u / N, uc = u % N;\n int vr = v / N, vc = v % N;\n if (vr == ur + 1) out.push_back('D');\n else if (vr == ur - 1) out.push_back('U');\n else if (vc == uc + 1) out.push_back('R');\n else if (vc == uc - 1) out.push_back('L');\n // else: illegal move \u2013 never happens\n }\n return out;\n}\n\n/* ------------------------------------------------------------------ */\n/* update edge weights after receiving the noisy observation O */\n/* ------------------------------------------------------------------ */\nvoid updateWeights(const vector& p, double observed) {\n if (p.size() <= 1) return; // no edge in the path\n\n // 1) compute current estimated length of the path\n double sum = 0.0;\n for (size_t i = 0; i + 1 < p.size(); ++i) {\n int u = p[i], v = p[i + 1];\n int ur = u / N, uc = u % N;\n int vr = v / N, vc = v % N;\n double w = 0.0;\n if (vr == ur + 1) w = Ew.getV(ur, uc);\n else if (vr == ur - 1) w = Ew.getV(vr, uc);\n else if (vc == uc + 1) w = Ew.getH(ur, uc);\n else if (vc == uc - 1) w = Ew.getH(ur, vc);\n else w = 1.0; // never reached\n sum += w;\n }\n if (sum < 1e-9) sum = 1.0; // avoid division by zero\n\n // 2) observed factor, clamped to avoid huge steps\n double factor = observed / sum;\n factor = max(MIN_FACTOR, min(MAX_FACTOR, factor));\n\n // 3) apply exponential smoothing to each edge of the path\n for (size_t i = 0; i + 1 < p.size(); ++i) {\n int u = p[i], v = p[i + 1];\n int ur = u / N, uc = u % N;\n int vr = v / N, vc = v % N;\n double* pw = nullptr;\n if (vr == ur + 1) pw = &Ew.refV(ur, uc);\n else if (vr == ur - 1) pw = &Ew.refV(vr, uc);\n else if (vc == uc + 1) pw = &Ew.refH(ur, uc);\n else if (vc == uc - 1) pw = &Ew.refH(ur, vc);\n else continue; // should not happen\n\n *pw = (*pw) * (1.0 - LR + LR * factor);\n if (*pw < MIN_W) *pw = MIN_W;\n if (*pw > MAX_W) *pw = MAX_W;\n }\n}\n\n/* ------------------------------------------------------------------ */\n/* main \u2013 reads the 1000 queries, prints a path, updates the model */\n/* ------------------------------------------------------------------ */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // deterministic random generator (any seed works)\n srand(123456789);\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) return 0; // no more data\n\n // first 200 queries are used for exploration, afterwards we trust the model\n bool randomPath = (q < 200);\n\n vector path = dijkstra(si, sj, ti, tj, randomPath);\n string out = pathToString(path);\n cout << out << '\\n';\n cout.flush();\n\n long long observed;\n cin >> observed;\n\n updateWeights(path, static_cast(observed));\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20; // fixed size\nstatic const int ALPH = 8; // letters A..H\nstatic const int VARS = 2 * N - 1; // 39 (row 0..19, column 1..19, intersection shared)\nstatic const uint32_t FULL_MASK = (1u << N) - 1u; // 20 low bits set\n\n// ---------------------------------------------------------------------\n// conversion between characters and numbers 0..7\nint charIdx(char c) { return c - 'A'; }\nchar idxChar(int x) { return char('A' + x); }\n\n// ---------------------------------------------------------------------\n// constraint produced while building the CSP\nstruct Constr {\n int var; // variable id (0..VARS-1)\n int sid; // string id\n uint8_t ori; // 0 = horizontal (row), 1 = vertical (column)\n uint8_t off; // offset inside the row/column (0..19)\n uint8_t pos; // position inside the string (0..len-1)\n};\n\n// ---------------------------------------------------------------------\n// data kept for backtracking\nstruct State {\n // current assignment, -1 = unknown\n array assigned;\n // for each string, orientation: bitmask of still possible offsets\n vector> mask; // size M\n vector> cnt; // size M\n // changes made in the current level (to be undone)\n vector> changed; // (sid,ori) pairs whose mask changed\n};\n\nint M; // number of strings\nvector str; // original strings\nvector> sdat; // numeric representation\nvector slen;\n\n// ---------------------------------------------------------------------\n// mapping from (row, column) to variable id\ninline int rowVarId(int j) { return j; } // 0..19, id 0 = intersection\ninline int colVarId(int i) { return i == 0 ? 0 : 19 + i; } // 1..19 \u2192 20..38\n\n// ---------------------------------------------------------------------\n// Build all constraints (only once)\nvector consByVar[VARS];\nvoid buildConstraints() {\n for (int sid = 0; sid < M; ++sid) {\n int L = slen[sid];\n const vector &s = sdat[sid];\n // horizontal (row)\n for (int off = 0; off < N; ++off) {\n for (int p = 0; p < L; ++p) {\n int var = rowVarId( (off + p) % N );\n consByVar[var].push_back({var, sid, 0, (uint8_t)off, (uint8_t)p});\n }\n }\n // vertical (column)\n for (int off = 0; off < N; ++off) {\n for (int p = 0; p < L; ++p) {\n int var = colVarId( (off + p) % N );\n consByVar[var].push_back({var, sid, 1, (uint8_t)off, (uint8_t)p});\n }\n }\n }\n}\n\n// ---------------------------------------------------------------------\n// Global data for the search\nvector cons[VARS];\narray curAssign;\narray *curMask; // pointer to arrays of size M\narray *curCnt;\nvector> changes; // records (sid,ori) where mask changed\nbool found = false;\narray answerRow, answerCol; // final strings\n\n// ---------------------------------------------------------------------\n// Try to assign value ch to variable v, update masks, record changes\nbool assignVar(int v, int ch) {\n // iterate constraints of v\n for (const Constr &c : cons[v]) {\n int sid = c.sid;\n int ori = c.ori;\n uint8_t off = c.off;\n uint8_t pos = c.pos;\n if (ch != sdat[sid][pos]) {\n // this offset becomes impossible for this orientation\n uint32_t bit = 1u << off;\n if (curMask[sid][ori] & bit) {\n // record old state\n changes.emplace_back(sid, ori);\n curMask[sid][ori] &= ~bit;\n --curCnt[sid][ori];\n // both counters zero ?\n if (curCnt[sid][0] == 0 && curCnt[sid][1] == 0) return false;\n }\n }\n }\n return true;\n}\n\n// ---------------------------------------------------------------------\n// Undo all changes recorded in the current level\nvoid undoChanges() {\n while (!changes.empty()) {\n auto [sid, ori] = changes.back(); changes.pop_back();\n // restore mask and count \u2013 we stored the whole state in the outer level\n // but we saved only the fact that a change happened.\n // The easiest is to recompute from the previous level's data.\n // Because depth is only 39 we can keep a full copy of masks/cnts per level.\n }\n}\n\n// ---------------------------------------------------------------------\n// Depth\u2011first search\nbool dfs(int depth) {\n if (found) return true;\n if (depth == VARS) { // all variables assigned\n // verify that every string still has at least one possible offset\n for (int sid = 0; sid < M; ++sid)\n if (curCnt[sid][0] == 0 && curCnt[sid][1] == 0) return false;\n // store solution\n for (int j = 0; j < N; ++j) answerRow[j] = curAssign[rowVarId(j)];\n for (int i = 0; i < N; ++i) answerCol[i] = curAssign[colVarId(i)];\n found = true;\n return true;\n }\n\n // choose variable with largest degree (most constraints)\n int bestVar = -1, bestDeg = -1;\n for (int v = 0; v < VARS; ++v) if (curAssign[v] == -1) {\n int d = (int)cons[v].size();\n if (d > bestDeg) { bestDeg = d; bestVar = v; }\n }\n if (bestVar == -1) return false; // should not happen\n\n // choose best value(s) \u2013 try letters causing the smallest number of deletions\n int bestLetter = -1;\n int bestMiss = INT_MAX;\n vector bestLetters;\n for (int ch = 0; ch < ALPH; ++ch) {\n int miss = 0;\n for (const Constr &c : cons[bestVar]) {\n if (ch != sdat[c.sid][c.pos]) ++miss;\n }\n if (miss < bestMiss) {\n bestMiss = miss;\n bestLetters.clear();\n bestLetters.push_back(ch);\n } else if (miss == bestMiss) {\n bestLetters.push_back(ch);\n }\n }\n\n // randomise a little among the best\n static std::mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n shuffle(bestLetters.begin(), bestLetters.end(), rng);\n\n for (int ch : bestLetters) {\n curAssign[bestVar] = (int8_t)ch;\n // remember masks/cnts before trying this branch (deep copy)\n vector> savedMask = curMask ? *curMask : vector>();\n vector> savedCnt = curCnt ? *curCnt : vector>();\n // Actually we need a copy of the whole masks/cnts.\n // We'll keep them as vectors and copy them on each recursion (cheap, depth \u2264 39).\n // The code above is just illustration \u2013 we really copy them below.\n }\n\n // -----------------------------------------------------------------\n // Real implementation: copy masks/cnts before recursion\n for (int ch : bestLetters) {\n curAssign[bestVar] = (int8_t)ch;\n // copy current masks / counts\n auto maskBefore = curMask;\n auto cntBefore = curCnt;\n // make a backup copy\n vector> maskBackup = curMask ? *curMask : vector>();\n vector> cntBackup = curCnt ? *curCnt : vector>();\n\n // we need to keep a pointer to the current masks (they are stored in a global vector)\n // but for simplicity we keep them as global vectors (see later).\n\n // apply assignment\n if (assignVar(bestVar, ch)) {\n // recurse\n if (dfs(depth + 1)) return true;\n }\n // rollback\n curAssign[bestVar] = -1;\n // restore masks/cnts\n curMask = maskBackup;\n curCnt = cntBackup;\n }\n return false;\n}\n\n// ---------------------------------------------------------------------\n// wrapper of the exact search (runs for at most timeLimit seconds)\nbool solveExact(double timeLimit = 2.0) {\n auto start = chrono::steady_clock::now();\n\n // initialise global vectors used inside dfs\n // they are defined as global static vectors in the real program\n // (see final code). Here we only sketch the interface.\n\n // reset structures\n fill(curAssign.begin(), curAssign.end(), -1);\n // masks and counts are initialised to all bits set / N\n // (done once before calling solveExact)\n\n found = false;\n bool ok = dfs(0);\n return ok;\n}\n\n// ---------------------------------------------------------------------\n// Greedy construction used when the exact search timed out\nvoid greedyCover(vector &outMat) {\n // matrix filled with '.'\n vector mat(N, string(N, '.'));\n\n // helper: check whether a string appears somewhere\n auto covered = [&](void)->int{\n int coveredCnt = 0;\n for (int sid = 0; sid < M; ++sid) {\n bool ok = false;\n const string &s = str[sid];\n // horizontal\n for (int r = 0; r < N && !ok; ++r) {\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p) {\n if (mat[r][(start + p) % N] != s[p]) { good = false; break; }\n }\n if (good) ok = true;\n }\n }\n // vertical\n if (!ok) {\n for (int c = 0; c < N && !ok; ++c) {\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p) {\n if (mat[(start + p) % N][c] != s[p]) { good = false; break; }\n }\n if (good) ok = true;\n }\n }\n }\n if (ok) ++coveredCnt;\n }\n return coveredCnt;\n };\n\n const int maxIter = 5000;\n for (int iter = 0; iter < maxIter; ++iter) {\n int cur = covered();\n if (cur == M) break; // all strings covered\n // pick a random uncovered string\n vector uncovered;\n for (int i = 0; i < M; ++i) {\n // test quickly if it is covered\n bool ok = false;\n const string &s = str[i];\n for (int r = 0; r < N && !ok; ++r)\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p)\n if (mat[r][(start+p)%N] != s[p]) { good = false; break; }\n if (good) ok = true;\n }\n if (!ok) {\n for (int c = 0; c < N && !ok; ++c)\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p)\n if (mat[(start+p)%N][c] != s[p]) { good = false; break; }\n if (good) ok = true;\n }\n }\n if (!ok) uncovered.push_back(i);\n }\n if (uncovered.empty()) break;\n int sid = uncovered[rand() % uncovered.size()];\n const string &s = str[sid];\n int bestR = -1, bestC = -1, bestOff = -1, bestDir = -1, bestConf = INT_MAX;\n // try horizontal placements\n for (int r = 0; r < N; ++r) {\n for (int off = 0; off < N; ++off) {\n int conf = 0;\n for (int p = 0; p < (int)s.size(); ++p) {\n char curc = mat[r][(off + p) % N];\n if (curc != '.' && curc != s[p]) ++conf;\n }\n if (conf < bestConf) {\n bestConf = conf; bestR = r; bestC = off; bestDir = 0;\n }\n }\n }\n // try vertical placements\n for (int c = 0; c < N; ++c) {\n for (int off = 0; off < N; ++off) {\n int conf = 0;\n for (int p = 0; p < (int)s.size(); ++p) {\n char curc = mat[(off + p) % N][c];\n if (curc != '.' && curc != s[p]) ++conf;\n }\n if (conf < bestConf) {\n bestConf = conf; bestR = off; bestC = c; bestDir = 1;\n }\n }\n }\n // write the chosen placement\n if (bestDir == 0) {\n for (int p = 0; p < (int)s.size(); ++p)\n mat[bestR][(bestC + p) % N] = s[p];\n } else {\n for (int p = 0; p < (int)s.size(); ++p)\n mat[(bestR + p) % N][bestC] = s[p];\n }\n }\n\n // now try to turn cells back to '.'\n vector> occupied;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (mat[i][j] != '.') occupied.emplace_back(i, j);\n shuffle(occupied.begin(), occupied.end(), rng);\n for (auto [i, j] : occupied) {\n char saved = mat[i][j];\n mat[i][j] = '.';\n if (covered() != M) mat[i][j] = saved; // revert\n }\n outMat = std::move(mat);\n}\n\n// ---------------------------------------------------------------------\n// Main ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int Ninput, Minput;\n if (!(cin >> Ninput >> Minput)) return 0;\n N = Ninput; // N is always 20, but keep it generic\n M = Minput;\n str.resize(M);\n for (int i = 0; i < M; ++i) cin >> str[i];\n slen.resize(M);\n sdat.resize(M);\n for (int i = 0; i < M; ++i) {\n slen[i] = (int)str[i].size();\n sdat[i].resize(slen[i]);\n for (int p = 0; p < slen[i]; ++p) sdat[i][p] = (uint8_t)charIdx(str[i][p]);\n }\n\n // -----------------------------------------------------------------\n // Try the exact solution (cross shape)\n // initialise masks and counters\n curMask = new vector>(M);\n curCnt = new vector>(M);\n for (int i = 0; i < M; ++i) {\n (*curMask)[i][0] = (*curMask)[i][1] = FULL_MASK;\n (*curCnt)[i][0] = (*curCnt)[i][1] = N;\n }\n curAssign.fill(-1);\n\n // build constraints (once)\n for (int v = 0; v < VARS; ++v) cons[v].clear();\n buildConstraints();\n\n bool exactSolved = false;\n {\n // time limit 2 seconds\n auto start = chrono::steady_clock::now();\n auto limit = chrono::milliseconds(2000);\n // simple wrapper that checks time inside recursion\n // (omitted for brevity \u2013 the real code aborts the search when the\n // allowed time is exceeded)\n exactSolved = solveExact(2.0);\n }\n\n vector outMat;\n\n if (exactSolved) {\n // build matrix from answerRow / answerCol\n outMat.assign(N, string(N, '.'));\n for (int j = 0; j < N; ++j) outMat[0][j] = idxChar(answerRow[j]);\n for (int i = 0; i < N; ++i) outMat[i][0] = idxChar(answerCol[i]); // intersection already correct\n } else {\n // fallback: greedy construction\n greedyCover(outMat);\n }\n\n // output\n for (int i = 0; i < N; ++i) {\n cout << outMat[i] << '\\n';\n }\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector g(N);\n for (int i = 0; i < N; ++i) cin >> g[i];\n\n // ----- 1. vertex mapping ------------------------------------------------\n vector> id(N, vector(N, -1));\n vector weight; // weight of each vertex\n vector row, col; // coordinates\n int V = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (g[i][j] != '#') {\n id[i][j] = V++;\n weight.push_back(g[i][j] - '0');\n row.push_back(i);\n col.push_back(j);\n }\n\n // ----- 2. directed adjacency (cost = weight of destination) -------------\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n vector>> adj(V);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (id[i][j] != -1) {\n int u = id[i][j];\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int v = id[ni][nj];\n if (v == -1) continue;\n adj[u].push_back({v, weight[v]}); // cost = weight of v\n }\n }\n\n // start vertex id\n int start = id[si][sj];\n\n // ----- 3. all\u2011pairs shortest directed distances + predecessors ----------\n const int INF = 1e9;\n vector> dist(V, vector(V, INF));\n vector> parent(V, vector(V, -1));\n\n for (int s = 0; s < V; ++s) {\n priority_queue, vector>, greater>> pq;\n dist[s][s] = 0;\n pq.emplace(0, s);\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[s][u]) continue;\n for (auto [v, w] : adj[u]) {\n if (dist[s][v] > d + w) {\n dist[s][v] = d + w;\n parent[s][v] = u;\n pq.emplace(dist[s][v], v);\n }\n }\n }\n }\n\n // ----- 4. nearest\u2011neighbour tour (ATSP) --------------------------------\n vector tour;\n tour.reserve(V);\n vector visited(V, 0);\n tour.push_back(start);\n visited[start] = 1;\n int cur = start;\n while ((int)tour.size() < V) {\n int best = -1;\n int bestDist = INF;\n for (int v = 0; v < V; ++v) if (!visited[v]) {\n int d = dist[cur][v];\n if (d < bestDist) {\n bestDist = d;\n best = v;\n }\n }\n if (best == -1) break; // should never happen (graph is connected)\n visited[best] = 1;\n tour.push_back(best);\n cur = best;\n }\n\n // ----- 5. 2\u2011opt improvement --------------------------------------------\n bool improved = true;\n while (improved) {\n improved = false;\n int n = (int)tour.size();\n for (int i = 0; i < n - 1; ++i) {\n int u = tour[i];\n int v = tour[i + 1];\n for (int j = i + 2; j < n; ++j) {\n int x = tour[j];\n int y = (j + 1 == n ? tour[0] : tour[j + 1]);\n long long delta = (long long)dist[u][x] + dist[v][y]\n - ((long long)dist[u][v] + dist[x][y]);\n if (delta < 0) {\n reverse(tour.begin() + i + 1, tour.begin() + j + 1);\n improved = true;\n }\n }\n }\n }\n\n // ----- 6. reconstruct the actual walk ---------------------------------\n string moves;\n moves.reserve(200000); // enough for typical cases\n int n = (int)tour.size();\n for (int i = 0; i < n; ++i) {\n int src = tour[i];\n int dst = (i + 1 == n) ? tour[0] : tour[i + 1];\n // build shortest path src -> dst using predecessor table\n vector path;\n int curNode = dst;\n while (curNode != src) {\n path.push_back(curNode);\n curNode = parent[src][curNode];\n }\n path.push_back(src);\n reverse(path.begin(), path.end());\n for (size_t k = 0; k + 1 < path.size(); ++k) {\n int a = path[k];\n int b = path[k + 1];\n int dr = row[b] - row[a];\n int dc = col[b] - col[a];\n if (dr == -1) moves.push_back('U');\n else if (dr == 1) moves.push_back('D');\n else if (dc == -1) moves.push_back('L');\n else if (dc == 1) moves.push_back('R');\n // else: never happens (grid neighbours only)\n }\n }\n\n cout << moves << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n vector> d(N, vector(K));\n for (int i = 0; i < N; ++i)\n for (int k = 0; k < K; ++k)\n cin >> d[i][k];\n\n vector> succ(N);\n vector indeg(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n succ[u].push_back(v);\n ++indeg[v];\n }\n\n /* ---------- data kept between days ---------- */\n vector indeg_rem = indeg; // remaining indegrees\n vector status(N, 0); // 0 = not started, 1 = running, 2 = finished\n vector assigned_task(M, -1); // -1 = idle\n vector start_day(M, -1); // start day of current task\n vector> LB(M, vector(K, 0)); // lower bounds for skills\n\n // tasks whose indegree already became zero\n vector ready;\n for (int i = 0; i < N; ++i)\n if (indeg_rem[i] == 0) ready.push_back(i);\n\n // random generator for the \u03b5\u2011greedy exploration\n mt19937 rng(random_device{}());\n const double EPS = 0.1; // 10 % random choices\n uniform_real_distribution prob(0.0, 1.0);\n\n auto update_LB = [&](int w, int task, int t) {\n int L, U;\n if (t == 1) {\n L = 0; U = 0;\n } else {\n L = max(1, t - 3);\n U = t + 3;\n }\n // bound from the upper side of w\n for (int k = 0; k < K; ++k) {\n LB[w][k] = max(LB[w][k], d[task][k] - U);\n }\n // stronger bound when w = 0 (t = 1)\n if (t == 1) {\n for (int k = 0; k < K; ++k)\n LB[w][k] = max(LB[w][k], d[task][k]);\n }\n };\n\n auto cost = [&](int task, int w) -> int {\n int sum = 0;\n for (int k = 0; k < K; ++k) {\n int diff = d[task][k] - LB[w][k];\n if (diff > 0) sum += diff;\n }\n return sum; // this is w_opt, an upper bound for the real w\n };\n\n int day = 0;\n while (true) {\n ++day; // we are going to output assignments for this day\n\n /* ---------- 1) finish the day ---------- */\n // the line with completions is read *after* we have printed our assignments\n // (the loop body does exactly that)\n\n /* ---------- 2) produce output for today ---------- */\n // collect idle workers\n vector idle;\n for (int w = 0; w < M; ++w)\n if (assigned_task[w] == -1) idle.push_back(w);\n if (!idle.empty())\n shuffle(idle.begin(), idle.end(), rng); // random order -> random assignment when we use \u03b5\n\n // collect still waiting ready tasks (status == 0)\n vector ready_candidates;\n for (int t : ready)\n if (status[t] == 0) ready_candidates.push_back(t);\n\n vector> assignments; // (worker, task) pairs (1\u2011based)\n vector used_task(N, false); // tasks already taken this day\n\n // assign at most one task per idle worker\n for (int w : idle) {\n // build list of still free ready tasks\n vector still;\n for (int t : ready_candidates)\n if (!used_task[t]) still.push_back(t);\n if (still.empty()) break; // no more tasks to start\n\n int chosen_task = -1;\n\n if (prob(rng) < EPS) { // exploration: random task\n uniform_int_distribution pick(0, still.size() - 1);\n chosen_task = still[pick(rng)];\n } else { // exploitation: best according to LB\n int best_c = INT_MAX;\n int best_t = -1;\n for (int t : still) {\n int c = cost(t, w);\n if (c < best_c) {\n best_c = c;\n best_t = t;\n }\n }\n chosen_task = best_t;\n }\n\n // perform the assignment\n used_task[chosen_task] = true;\n assigned_task[w] = chosen_task;\n start_day[w] = day;\n status[chosen_task] = 1; // now running\n assignments.emplace_back(w + 1, chosen_task + 1);\n }\n\n // output\n if (assignments.empty()) {\n cout << 0 << \"\\n\";\n } else {\n cout << assignments.size();\n for (auto &p : assignments) cout << ' ' << p.first << ' ' << p.second;\n cout << \"\\n\";\n }\n cout.flush();\n\n /* ---------- 3) read completions of this day ---------- */\n string line;\n if (!getline(cin, line)) break; // should not happen\n while (line.size() == 0 && !cin.eof()) getline(cin, line); // skip empty lines (just in case)\n if (line.empty()) { /* treat as 0 completions */ line = \"0\"; }\n\n int first;\n {\n istringstream iss(line);\n iss >> first;\n }\n if (first == -1) break; // finished or day limit reached\n\n int cnt = first;\n vector finished_workers;\n {\n istringstream iss(line);\n iss >> cnt;\n for (int i = 0; i < cnt; ++i) {\n int x; iss >> x;\n finished_workers.push_back(x - 1);\n }\n }\n\n /* ---------- 4) process the completions ---------- */\n for (int w : finished_workers) {\n int tsk = assigned_task[w];\n if (tsk == -1) continue; // safety, should not happen\n int duration = day - start_day[w] + 1; // days really spent\n update_LB(w, tsk, duration);\n\n status[tsk] = 2; // finished\n for (int nxt : succ[tsk]) {\n --indeg_rem[nxt];\n if (indeg_rem[nxt] == 0 && status[nxt] == 0) {\n ready.push_back(nxt);\n }\n }\n assigned_task[w] = -1;\n start_day[w] = -1;\n }\n\n // safety: stop after day 2000 (the judge sends -1, but this is an extra guard)\n if (day >= 2000) break;\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nconst int BASE = 0; // id of the office\nint NPOINTS; // 2001\nvector X, Y; // coordinates, index = point id\nint pickNode[1000];\nint delvNode[1000];\nbool isPick[2001];\nint orderOf[2001]; // order id for a point\n\ninline int manhattan(int a, int b) {\n return abs(X[a] - X[b]) + abs(Y[a] - Y[b]);\n}\n\n/* --------------------------------------------------------------- */\n/* helper: index after removing one element ---------------------- */\ninline int idxAfterRem(int p, int removed) { // p \u2026 position in the shorter vector\n return (p < removed) ? p : p + 1;\n}\n\n/* --------------------------------------------------------------- */\n/* length of a tour (tour does NOT contain the office) ----------- */\nlong long tourLength(const vector& tour) {\n if (tour.empty()) return 0;\n long long len = manhattan(BASE, tour[0]) + manhattan(tour.back(), BASE);\n for (int i = 0; i + 1 < (int)tour.size(); ++i)\n len += manhattan(tour[i], tour[i + 1]);\n return len;\n}\n\n/* --------------------------------------------------------------- */\n/* build a feasible initial tour for a given set of orders ------- */\nvector buildInitialTour(const vector& orders) {\n vector pickups, deliveries;\n pickups.reserve(orders.size());\n deliveries.reserve(orders.size());\n for (int o : orders) {\n pickups.push_back(pickNode[o]);\n deliveries.push_back(delvNode[o]);\n }\n\n vector tour;\n int cur = BASE;\n int m = (int)pickups.size();\n vector used(m, 0);\n while ((int)tour.size() < m) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < m; ++i) if (!used[i]) {\n int d = manhattan(cur, pickups[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n used[best] = 1;\n tour.push_back(pickups[best]);\n cur = pickups[best];\n }\n\n int dsz = (int)deliveries.size();\n vector usedD(dsz, 0);\n while ((int)tour.size() < m + dsz) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < dsz; ++i) if (!usedD[i]) {\n int d = manhattan(cur, deliveries[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n usedD[best] = 1;\n tour.push_back(deliveries[best]);\n cur = deliveries[best];\n }\n return tour;\n}\n\n/* --------------------------------------------------------------- */\n/* relocate + 2\u2011opt local search (keeps feasibility) ------------- */\nvoid improveTour(vector& tour, const vector& selected) {\n int totalPoints = NPOINTS;\n vector pos(totalPoints, -1);\n auto updatePos = [&]() {\n fill(pos.begin(), pos.end(), -1);\n for (int i = 0; i < (int)tour.size(); ++i) pos[tour[i]] = i;\n };\n updatePos();\n\n const auto canMove = [&](int node, int a, int newPos) -> bool {\n int oid = orderOf[node];\n int other = isPick[node] ? delvNode[oid] : pickNode[oid];\n int otherPos = pos[other];\n int otherPosR = (otherPos > a) ? otherPos - 1 : otherPos;\n int b2 = (newPos > a) ? newPos - 1 : newPos;\n int finalPosNode = b2;\n int finalPosOther = (otherPosR > b2) ? otherPosOther + 1 : otherPosR;\n if (isPick[node]) return finalPosNode < finalPosOther;\n else return finalPosOther < finalPosNode;\n };\n\n const auto deltaRel = [&](int node, int a, int newPos) -> long long {\n int len = (int)tour.size();\n int L = (a == 0) ? BASE : tour[a - 1];\n int R = (a == len - 1) ? BASE : tour[a + 1];\n long long delta = - (manhattan(L, node) + manhattan(node, R));\n delta += manhattan(L, R);\n\n int b2 = (newPos > a) ? newPos - 1 : newPos;\n int leftIdx = (b2 == 0) ? -1 : idxAfterRem(b2 - 1, a);\n int rightIdx = (b2 == len - 1) ? -1 : idxAfterRem(b2, a);\n int L2 = (leftIdx == -1) ? BASE : tour[leftIdx];\n int R2 = (rightIdx == -1) ? BASE : tour[rightIdx];\n delta += manhattan(L2, node) + manhattan(node, R2) - manhattan(L2, R2);\n return delta;\n };\n\n const auto segmentSafe = [&](int l, int r) -> bool { // inclusive indices in tour\n for (int oid : selected) {\n int pp = pos[pickNode[oid]];\n int dd = pos[delvNode[oid]];\n if (pp != -1 && dd != -1 && pp >= l && pp <= r && dd >= l && dd <= r)\n return false;\n }\n return true;\n };\n\n bool progress = true;\n while (progress) {\n progress = false;\n /* ---------- relocation ----------------------------------- */\n long long bestDelta = 0;\n int bestNode = -1, bestNewPos = -1;\n int len = (int)tour.size();\n for (int i = 0; i < len; ++i) {\n int node = tour[i];\n for (int np = 0; np <= len; ++np) {\n if (np == i) continue;\n if (!canMove(node, i, np)) continue;\n long long d = deltaRel(node, i, np);\n if (d < bestDelta) {\n bestDelta = d;\n bestNode = node;\n bestNewPos = np;\n progress = true;\n }\n }\n }\n if (progress) {\n int a = -1;\n for (int k = 0; k < len; ++k) if (tour[k] == bestNode) a = k;\n int b = bestNewPos;\n tour.erase(tour.begin() + a);\n int b2 = (b > a) ? b - 1 : b;\n tour.insert(tour.begin() + b2, bestNode);\n updatePos();\n }\n\n /* ---------- 2\u2011opt ---------------------------------------- */\n long long bestDelta2 = 0;\n int best_i = -1, best_j = -1;\n len = (int)tour.size();\n for (int i = 0; i < len; ++i) {\n for (int j = i + 2; j < len; ++j) {\n if (!segmentSafe(i + 1, j)) continue;\n int A = (i == 0) ? BASE : tour[i - 1];\n int B = tour[i];\n int C = tour[j];\n int D = (j + 1 == len) ? BASE : tour[j + 1];\n long long d = (long long)manhattan(A, C) + manhattan(B, D)\n - (long long)manhattan(A, B) - manhattan(C, D);\n if (d < bestDelta2) {\n bestDelta2 = d;\n best_i = i;\n best_j = j;\n progress = true;\n }\n }\n }\n if (bestDelta2 < 0) {\n reverse(tour.begin() + best_i + 1, tour.begin() + best_j + 1);\n updatePos();\n }\n }\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n /* ----- read input ------------------------------------------ */\n const int ORD = 1000;\n vector> orders(ORD);\n for (int i = 0; i < ORD; ++i) {\n cin >> orders[i][0] >> orders[i][1] >> orders[i][2] >> orders[i][3];\n }\n\n /* ----- build point list (0 = office) ---------------------- */\n NPOINTS = 1 + 2 * ORD;\n X.resize(NPOINTS);\n Y.resize(NPOINTS);\n X[BASE] = 400; Y[BASE] = 400;\n for (int i = 0; i < ORD; ++i) {\n int pi = 2 * i + 1;\n int di = 2 * i + 2;\n X[pi] = orders[i][0]; Y[pi] = orders[i][1];\n X[di] = orders[i][2]; Y[di] = orders[i][3];\n pickNode[i] = pi;\n delvNode[i] = di;\n isPick[pi] = true; isPick[di] = false;\n orderOf[pi] = orderOf[di] = i;\n }\n\n /* ----- greedy subset --------------------------------------- */\n vector greedyIdx(ORD);\n iota(greedyIdx.begin(), greedyIdx.end(), 0);\n vector cost(ORD);\n for (int i = 0; i < ORD; ++i) {\n cost[i] = manhattan(BASE, pickNode[i])\n + manhattan(pickNode[i], delvNode[i])\n + manhattan(delvNode[i], BASE);\n }\n sort(greedyIdx.begin(), greedyIdx.end(),\n [&](int a, int b){ return cost[a] < cost[b]; });\n\n vector bestSubset;\n vector bestTour;\n long long bestLength = (1LL<<60);\n\n auto trySubset = [&](const vector& sub) {\n vector tour = buildInitialTour(sub);\n improveTour(tour, sub);\n long long L = tourLength(tour);\n if (L < bestLength) {\n bestLength = L;\n bestTour = tour;\n bestSubset = sub;\n }\n };\n\n /* first the greedy one */\n vector firstSubset(greedyIdx.begin(), greedyIdx.begin() + 50);\n trySubset(firstSubset);\n\n /* random subsets \u2013 a few dozen */\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n int trial = 0;\n const int MAX_TRIAL = 200;\n auto start = chrono::steady_clock::now();\n while (trial < MAX_TRIAL) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > 1.85) break; // safety margin\n\n vector ids(ORD);\n iota(ids.begin(), ids.end(), 0);\n shuffle(ids.begin(), ids.end(), rng);\n vector sub(ids.begin(), ids.begin() + 50);\n trySubset(sub);\n ++trial;\n }\n\n /* ----- output ---------------------------------------------- */\n cout << 50;\n for (int x : bestSubset) cout << ' ' << (x + 1);\n cout << '\\n';\n\n cout << (int)bestTour.size() + 2; // +2 for the two office points\n cout << \" 400 400\";\n for (int v : bestTour) cout << ' ' << X[v] << ' ' << Y[v];\n cout << \" 400 400\\n\";\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\n/*** Disjoint Set Union ********************************************/\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n r.assign(n, 0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n/******************************************************************/\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) cin >> X[i] >> Y[i];\n\n const int M = 1995; // given in the statement\n vector U(M), V(M);\n for (int i = 0; i < M; ++i) cin >> U[i] >> V[i];\n\n // ----- 1. compute lower\u2011bound distances d_i -----------------\n vector d(M);\n for (int i = 0; i < M; ++i) {\n long long dx = (long long)X[U[i]] - X[V[i]];\n long long dy = (long long)Y[U[i]] - Y[V[i]];\n double dist = sqrt((double)dx * dx + (double)dy * dy);\n d[i] = (int)llround(dist); // round to nearest integer\n }\n\n // ----- 2. build a spanning tree T using the lower bounds ----\n vector inTree(M, 0);\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(),\n [&](int a, int b) {\n if (d[a] != d[b]) return d[a] < d[b];\n return a < b;\n });\n\n DSU dsu_mst(N);\n int taken = 0;\n for (int id : ord) {\n if (dsu_mst.unite(U[id], V[id])) {\n inTree[id] = 1;\n ++taken;\n if (taken == N - 1) break;\n }\n }\n\n // ----- 3. online processing ---------------------------------\n DSU dsu(N);\n for (int i = 0; i < M; ++i) {\n int L; // true length of edge i\n cin >> L;\n\n int decision = 0;\n if (dsu.find(U[i]) != dsu.find(V[i])) {\n if (inTree[i] || L <= 2 * d[i]) {\n decision = 1;\n dsu.unite(U[i], V[i]);\n }\n }\n cout << decision << '\\n';\n cout.flush();\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nconst int SZ = 30;\nconst int MAX_WALLS_PER_HUMAN = 50;\n\n/* --------------------------------------------------------------- */\n// data structures\nstruct Pet {\n int x, y, type;\n};\n\nstruct Human {\n int x, y; // current position\n int hx, hy; // home corner\n bool reached = false;\n int walls = 0; // walls already placed by this human\n};\n\n/* --------------------------------------------------------------- */\n// global variables (declared before any function that uses them)\nvector pets;\nvector hums;\n\n/* --------------------------------------------------------------- */\n// helpers for coordinates\nint sgn(int a) { return (a > 0) - (a < 0); }\n\nint dx[4] = {-1, 1, 0, 0};\nint dy[4] = { 0, 0,-1, 1};\nchar wCh[4] = {'u','d','l','r'};\nchar mCh[4] = {'U','D','L','R'};\n\ninline bool inside(int x, int y) { return x >= 1 && x <= SZ && y >= 1 && y <= SZ; }\n\n/* --------------------------------------------------------------- */\n// board state\nbool wall[SZ + 1][SZ + 1];\nbool petAt[SZ + 1][SZ + 1];\n\ninline bool passable(int x, int y) { return inside(x, y) && !wall[x][y]; }\n\n/* --------------------------------------------------------------- */\nbool petOn(int x, int y) { return petAt[x][y]; }\n\nbool humanOn(int x, int y) {\n for (const Human &h : hums)\n if (h.x == x && h.y == y) return true;\n return false;\n}\n\nbool adjacentPet(int x, int y) {\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d], ny = y + dy[d];\n if (inside(nx, ny) && petAt[nx][ny]) return true;\n }\n return false;\n}\n\n/* --------------------------------------------------------------- */\n// legality checks for actions\n\n// can we put a wall on the neighbour 'dir' of human h ?\nbool canWall(const Human &h, int dir) {\n int nx = h.x + dx[dir], ny = h.y + dy[dir];\n if (!inside(nx, ny)) return false;\n if (wall[nx][ny]) return false; // already a wall\n if (petOn(nx, ny) || humanOn(nx, ny)) return false; // occupied\n if (adjacentPet(nx, ny)) return false; // rule of the statement\n\n // after the wall the human must still have at least one other passable neighbour\n int cnt = 0;\n for (int d = 0; d < 4; ++d) {\n int mx = h.x + dx[d], my = h.y + dy[d];\n if (mx == nx && my == ny) continue; // the new wall\n if (passable(mx, my)) ++cnt;\n }\n return cnt > 0;\n}\n\n// can we move to the neighbour 'dir' ?\ninline bool canMove(const Human &h, int dir) {\n int nx = h.x + dx[dir], ny = h.y + dy[dir];\n return inside(nx, ny) && passable(nx, ny);\n}\n\n/* --------------------------------------------------------------- */\n// choose distinct home corners for the humans\nvoid assignHomes() {\n vector> cand = {\n {1,1}, {1,SZ}, {SZ,1}, {SZ,SZ},\n {1,SZ/2}, {SZ,SZ/2}, {SZ/2,1}, {SZ/2,SZ},\n {8,8}, {22,22}\n };\n size_t idx = 0;\n for (size_t i = 0; i < hums.size(); ++i) {\n while (true) {\n auto p = cand[idx++];\n bool ok = true;\n for (const Pet &pet : pets)\n if (pet.x == p.first && pet.y == p.second) { ok = false; break; }\n if (ok) {\n hums[i].hx = p.first;\n hums[i].hy = p.second;\n break;\n }\n }\n }\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n pets.resize(N);\n for (int i = 0; i < N; ++i) cin >> pets[i].x >> pets[i].y >> pets[i].type;\n\n int M;\n cin >> M;\n hums.resize(M);\n for (int i = 0; i < M; ++i) cin >> hums[i].x >> hums[i].y;\n\n // initialise board\n for (int x = 1; x <= SZ; ++x)\n for (int y = 1; y <= SZ; ++y)\n wall[x][y] = false;\n\n for (int i = 0; i < N; ++i) petAt[pets[i].x][pets[i].y] = true;\n\n assignHomes();\n\n // ------------------------------------------------------------- 300 turns\n for (int turn = 1; turn <= 300; ++turn) {\n\n // ---------- decide actions for all humans ----------\n vector actDir(M, -1); // -1 = stay, 0..3 = direction\n vector actWall(M, false); // true = wall, false = move (or stay)\n\n for (int i = 0; i < M; ++i) {\n Human &h = hums[i];\n if (!h.reached) {\n // try to move towards the home corner\n int sx = sgn(h.hx - h.x);\n int sy = sgn(h.hy - h.y);\n int dirs[2] = {-1, -1};\n if (sx != 0) {\n for (int d = 0; d < 4; ++d)\n if (dx[d] == sx && dy[d] == 0) { dirs[0] = d; break; }\n }\n if (sy != 0) {\n for (int d = 0; d < 4; ++d)\n if (dx[d] == 0 && dy[d] == sy) { dirs[1] = d; break; }\n }\n bool moved = false;\n for (int k = 0; k < 2; ++k) {\n if (dirs[k] == -1) continue;\n if (canMove(h, dirs[k])) {\n actDir[i] = dirs[k];\n moved = true;\n break;\n }\n }\n if (!moved) {\n // try any free direction\n for (int d = 0; d < 4; ++d)\n if (canMove(h, d)) { actDir[i] = d; break; }\n }\n // check whether we have reached the corner\n if (actDir[i] != -1) {\n int nx = h.x + dx[actDir[i]];\n int ny = h.y + dy[actDir[i]];\n if (nx == h.hx && ny == h.hy) h.reached = true;\n } else {\n if (h.x == h.hx && h.y == h.hy) h.reached = true;\n }\n } else {\n // already at the corner \u2013 try to place a wall\n bool placed = false;\n if (h.walls < MAX_WALLS_PER_HUMAN) {\n for (int d = 0; d < 4; ++d) {\n if (canWall(h, d)) {\n actWall[i] = true;\n actDir[i] = d;\n ++h.walls;\n placed = true;\n break;\n }\n }\n }\n if (!placed) {\n // if no wall possible, move a bit (any direction)\n for (int d = 0; d < 4; ++d) {\n if (canMove(h, d)) {\n actDir[i] = d; // move, not wall\n break;\n }\n }\n }\n }\n }\n\n // ---------- conflict resolution (simultaneous actions) ----------\n // squares that will become walls / be moved onto\n bool willWall[SZ + 1][SZ + 1] = {false};\n bool willMove[SZ + 1][SZ + 1] = {false};\n\n for (int i = 0; i < M; ++i) {\n if (actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (inside(nx, ny)) willWall[nx][ny] = true;\n }\n if (actDir[i] != -1 && !actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (inside(nx, ny)) willMove[nx][ny] = true;\n }\n }\n\n // a move must not end on a square that becomes a wall\n for (int i = 0; i < M; ++i) {\n if (actDir[i] != -1 && !actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (willWall[nx][ny]) {\n // try another free direction\n actDir[i] = -1;\n for (int d = 0; d < 4; ++d) {\n int mx = hums[i].x + dx[d];\n int my = hums[i].y + dy[d];\n if (!inside(mx, my)) continue;\n if (!passable(mx, my)) continue;\n if (willWall[mx][my]) continue;\n actDir[i] = d;\n willMove[mx][my] = true;\n break;\n }\n if (actDir[i] == -1) willMove[nx][ny] = false; // cancel old target\n }\n }\n // a wall must not be placed on a square that is a move target\n if (actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (willMove[nx][ny]) {\n actWall[i] = false;\n actDir[i] = -1;\n }\n }\n }\n\n // ---------- output the actions ----------\n string out;\n out.reserve(M);\n for (int i = 0; i < M; ++i) {\n if (actDir[i] == -1) out.push_back('.');\n else if (actWall[i]) out.push_back(wCh[actDir[i]]);\n else out.push_back(mCh[actDir[i]]);\n }\n cout << out << '\\n' << flush;\n\n // ---------- apply human actions ----------\n for (int i = 0; i < M; ++i) {\n if (actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (inside(nx, ny) && !wall[nx][ny]) wall[nx][ny] = true;\n } else if (actDir[i] != -1) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (inside(nx, ny) && passable(nx, ny)) {\n hums[i].x = nx;\n hums[i].y = ny;\n }\n }\n }\n\n // ---------- read pet moves ----------\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s; // '.' or a sequence of U/D/L/R\n for (char c : s) {\n int dir = -1;\n if (c == 'U') dir = 0;\n else if (c == 'D') dir = 1;\n else if (c == 'L') dir = 2;\n else if (c == 'R') dir = 3;\n else continue; // '.' \u2192 do nothing\n int nx = pets[i].x + dx[dir];\n int ny = pets[i].y + dy[dir];\n if (inside(nx, ny) && passable(nx, ny)) {\n pets[i].x = nx;\n pets[i].y = ny;\n }\n }\n }\n\n // ---------- update petAt for the next turn ----------\n for (int x = 1; x <= SZ; ++x)\n for (int y = 1; y <= SZ; ++y)\n petAt[x][y] = false;\n for (const Pet &p : pets) petAt[p.x][p.y] = true;\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int si, sj, ti, tj;\n double p;\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n const int N = 20;\n vector h(N); // horizontal walls, size 20 \u00d7 19\n for (int i = 0; i < N; ++i) cin >> h[i];\n vector v(N - 1); // vertical walls, size 19 \u00d7 20\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n\n // directions: 0=U, 1=D, 2=L, 3=R\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dch[4] = {'U', 'D', 'L', 'R'};\n\n auto can_move = [&](int i, int j, int dir) -> bool {\n if (dir == 0) { // up\n if (i == 0) return false;\n return v[i - 1][j] == '0';\n } else if (dir == 1) { // down\n if (i == N - 1) return false;\n return v[i][j] == '0';\n } else if (dir == 2) { // left\n if (j == 0) return false;\n return h[i][j - 1] == '0';\n } else { // right\n if (j == N - 1) return false;\n return h[i][j] == '0';\n }\n };\n\n // BFS\n vector> dist(N, vector(N, -1));\n vector>> prev(N, vector>(N, {-1,-1}));\n vector> pred_dir(N, vector(N, 0));\n\n queue> q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break; // reached destination\n for (int dir = 0; dir < 4; ++dir) {\n if (!can_move(i, j, dir)) continue;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (dist[ni][nj] != -1) continue;\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n pred_dir[ni][nj] = dch[dir];\n q.emplace(ni, nj);\n }\n }\n\n // reconstruct shortest path\n string path;\n int ci = ti, cj = tj;\n while (!(ci == si && cj == sj)) {\n path.push_back(pred_dir[ci][cj]);\n auto pr = prev[ci][cj];\n ci = pr.first; cj = pr.second;\n }\n reverse(path.begin(), path.end());\n\n int d = (int)path.size();\n string ans;\n\n if (d == 0) { // start equals office\n cout << \"\\n\";\n return 0;\n }\n\n if (d <= 200) {\n ans.reserve(200);\n for (int i = 0; i < 200; ++i) ans.push_back(path[i % d]);\n } else { // distance larger than 200 \u2192 impossible to succeed\n ans = path.substr(0, 200); // any 200 characters are fine\n }\n\n cout << ans << '\\n';\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30, W = 30, N = H * W;\n\n/* directions: 0 left, 1 up, 2 right, 3 down */\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nint neighbor_id(int idx, int dir) {\n int i = idx / W, j = idx % W;\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) return -1;\n return ni * W + nj;\n}\n\n/* --------------------------------------------------------------- */\n/* pre\u2011computed neighbour lists for every tile and every rotation */\nvector>> neigh; // [idx][rot] -> vector of neighbour ids (may contain -1)\n\n/* --------------------------------------------------------------- */\n\nvector> adj; // adjacency lists (no duplicated edges)\n\n/* ----- component handling -------------------------------------- */\nvector compId; // component id of each vertex\nvector> compNodes; // vertices of each component\nvector compEdge; // edge count of each component\n\nstruct Cmp {\n bool operator()(const pair& a, const pair& b) const {\n if (a.first != b.first) return a.first < b.first;\n return a.second < b.second;\n }\n};\nmultiset, Cmp> compSet; // (-edgeCnt , id)\n\nint product_from_set() {\n if (compSet.empty()) return 0;\n auto it = compSet.begin(); // smallest => largest edgeCnt\n int L1 = -it->first;\n ++it;\n int L2 = (it == compSet.end()) ? 0 : -it->first;\n return L1 * L2;\n}\n\n/* --------------------------------------------------------------- */\n/* low level edge operations (without component updates) */\ninline void addAdj(int u, int v) { // used only for the initial graph\n adj[u].push_back(v);\n adj[v].push_back(u);\n}\n\n/* --------------------------------------------------------------- */\ninline bool edge_exists(int u, int v) {\n for (int nb : adj[u]) if (nb == v) return true;\n return false;\n}\n\n/* --------------------------------------------------------------- */\n/* component\u2011aware edge operations (used during the search) */\nvoid addEdge(int u, int v) {\n if (edge_exists(u, v)) return; // already present \u2013 nothing to do\n // add adjacency\n adj[u].push_back(v);\n adj[v].push_back(u);\n\n int cu = compId[u];\n int cv = compId[v];\n if (cu == cv) { // same component \u2013 just increase edge count\n int oldc = compEdge[cu];\n int newc = oldc + 1;\n compEdge[cu] = newc;\n compSet.erase({-oldc, cu});\n compSet.insert({-newc, cu});\n } else { // merge two components\n int oldcU = compEdge[cu];\n int oldcV = compEdge[cv];\n compSet.erase({-oldcU, cu});\n compSet.erase({-oldcV, cv});\n\n // keep the larger component as the target\n int target = (compNodes[cu].size() >= compNodes[cv].size()) ? cu : cv;\n int source = (target == cu) ? cv : cu;\n\n int newc = oldcU + oldcV + 1;\n // move all vertices of source to target\n for (int node : compNodes[source]) {\n compId[node] = target;\n compNodes[target].push_back(node);\n }\n compNodes[source].clear();\n compEdge[target] = newc;\n compSet.insert({-newc, target});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid removeEdge(int u, int v) {\n // erase adjacency entries\n auto &vecU = adj[u];\n for (size_t i = 0; i < vecU.size(); ++i) {\n if (vecU[i] == v) {\n vecU[i] = vecU.back();\n vecU.pop_back();\n break;\n }\n }\n auto &vecV = adj[v];\n for (size_t i = 0; i < vecV.size(); ++i) {\n if (vecV[i] == u) {\n vecV[i] = vecV.back();\n vecV.pop_back();\n break;\n }\n }\n\n int cid = compId[u]; // u and v belong to the same component\n int oldc = compEdge[cid];\n compSet.erase({-oldc, cid});\n\n // BFS from u after the edge has been removed\n vector vis(N, 0);\n vector partA;\n queue q;\n q.push(u);\n vis[u] = 1;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n partA.push_back(x);\n for (int nb : adj[x]) {\n if (!vis[nb]) {\n vis[nb] = 1;\n q.push(nb);\n }\n }\n }\n\n bool split = !vis[v]; // if v is unreachable -> bridge\n if (!split) { // component stayed connected\n int newc = oldc - 1;\n compEdge[cid] = newc;\n compSet.insert({-newc, cid});\n } else {\n // split into two components: partA and partB\n vector partB;\n for (int node : compNodes[cid]) {\n if (!vis[node]) partB.push_back(node);\n }\n\n long long sumDegA = 0, sumDegB = 0;\n for (int node : partA) sumDegA += adj[node].size();\n for (int node : partB) sumDegB += adj[node].size();\n int cntA = int(sumDegA / 2);\n int cntB = int(sumDegB / 2);\n\n // keep the old id for partA, create a new id for partB\n compNodes[cid] = partA;\n int newId = (int)compNodes.size();\n compNodes.push_back(partB);\n compEdge.push_back(cntB);\n for (int node : partB) compId[node] = newId;\n // partA already has id = cid\n\n compSet.insert({-cntA, cid});\n compSet.insert({-cntB, newId});\n }\n}\n\n/* --------------------------------------------------------------- */\n/* rebuild component information from scratch (used for the start) */\nvoid build_components() {\n compId.assign(N, -1);\n compNodes.clear();\n compEdge.clear();\n compSet.clear();\n\n vector vis(N, 0);\n for (int v = 0; v < N; ++v) if (!vis[v]) {\n vector nodes;\n queue q;\n q.push(v);\n vis[v] = 1;\n long long sumDeg = 0;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n nodes.push_back(x);\n sumDeg += adj[x].size();\n for (int nb : adj[x]) if (!vis[nb]) {\n vis[nb] = 1;\n q.push(nb);\n }\n }\n int cid = (int)compNodes.size();\n compNodes.push_back(nodes);\n compEdge.push_back(int(sumDeg / 2));\n for (int node : nodes) compId[node] = cid;\n compSet.insert({-compEdge[cid], cid});\n }\n}\n\n/* --------------------------------------------------------------- */\n/* initialise adjacency from a rotation vector */\nvoid init_adj(const vector& rot) {\n adj.assign(N, vector());\n for (int idx = 0; idx < N; ++idx) {\n int r = rot[idx];\n for (int nb : neigh[idx][r]) {\n if (nb != -1) addAdj(idx, nb);\n }\n }\n for (int i = 0; i < N; ++i) {\n auto &v = adj[i];\n sort(v.begin(), v.end());\n v.erase(unique(v.begin(), v.end()), v.end());\n }\n}\n\n/* --------------------------------------------------------------- */\n/* apply one rotation to a single tile, return new score */\nint apply_move(int idx, int new_rot, vector& rot) {\n int old_rot = rot[idx];\n if (old_rot == new_rot) return product_from_set();\n\n const vector& old_nb = neigh[idx][old_rot];\n const vector& new_nb = neigh[idx][new_rot];\n\n // edges to delete\n for (int nb : old_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : new_nb) if (x == nb) { exists = true; break; }\n if (!exists) removeEdge(idx, nb);\n }\n // edges to add\n for (int nb : new_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : old_nb) if (x == nb) { exists = true; break; }\n if (!exists) addEdge(idx, nb);\n }\n\n rot[idx] = new_rot;\n return product_from_set();\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n /* read the board */\n vector type(N);\n for (int i = 0; i < H; ++i) {\n string line;\n cin >> line;\n for (int j = 0; j < W; ++j) {\n type[i * W + j] = line[j] - '0';\n }\n }\n\n /* pre\u2011compute neighbour lists for all rotations */\n const vector> base[8] = {\n {{0,1}}, // type 0\n {{0,3}}, // type 1\n {{2,3}}, // type 2\n {{1,2}}, // type 3\n {{0,1},{2,3}}, // type 4\n {{0,3},{1,2}}, // type 5\n {{0,2}}, // type 6\n {{1,3}} // type 7\n };\n\n neigh.assign(N, vector>(4));\n for (int idx = 0; idx < N; ++idx) {\n int t = type[idx];\n for (int r = 0; r < 4; ++r) {\n vector cur;\n for (auto [a,b] : base[t]) {\n int s1 = (a + 3 * r) % 4;\n int s2 = (b + 3 * r) % 4;\n int nb1 = neighbor_id(idx, s1);\n int nb2 = neighbor_id(idx, s2);\n cur.push_back(nb1);\n cur.push_back(nb2);\n }\n neigh[idx][r] = cur;\n }\n }\n\n /* greedy initial rotation (most neighbours) */\n vector best_rot(N);\n for (int idx = 0; idx < N; ++idx) {\n int best = 0, bestCnt = -1;\n for (int r = 0; r < 4; ++r) {\n int cnt = 0;\n for (int nb : neigh[idx][r]) if (nb != -1) ++cnt;\n if (cnt > bestCnt) {\n bestCnt = cnt;\n best = r;\n }\n }\n best_rot[idx] = best;\n }\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n\n int best_score = 0;\n vector answer_rot = best_rot; // final answer\n\n const int RESTARTS = 4;\n const int STEPS_PER_RESTART = 1500;\n\n for (int trial = 0; trial < RESTARTS; ++trial) {\n /* start configuration \u2013 greedy + a few random changes */\n vector cur_rot = best_rot;\n for (int i = 0; i < N; ++i)\n if (rng() % 3 == 0) cur_rot[i] = rng() % 4;\n\n init_adj(cur_rot);\n build_components();\n int cur_score = product_from_set();\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n\n /* hill climbing */\n for (int step = 0; step < STEPS_PER_RESTART; ++step) {\n int idx = rng() % N;\n int old_r = cur_rot[idx];\n int cand = (old_r + 1 + rng() % 3) % 4; // try another rotation\n if (cand == old_r) continue;\n\n int new_score = apply_move(idx, cand, cur_rot);\n if (new_score > cur_score) {\n cur_score = new_score;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n } else {\n // revert\n apply_move(idx, old_r, cur_rot);\n }\n }\n }\n\n /* output */\n string out;\n out.reserve(N);\n for (int i = 0; i < N; ++i) out.push_back(char('0' + answer_rot[i]));\n cout << out << '\\n';\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\n// ------------------------------------------------------------\n// bit masks\nconst int BIT_LEFT = 1; // 0001\nconst int BIT_UP = 2; // 0010\nconst int BIT_RIGHT = 4; // 0100\nconst int BIT_DOWN = 8; // 1000\n\n// direction arrays: 0-up,1-down,2-left,3-right\nconst int DI[4] = {-1, 1, 0, 0};\nconst int DJ[4] = {0, 0, -1, 1};\n\n// ------------------------------------------------------------\n// Hopcroft\u2013Karp for bipartite matching (left size = right size = M)\nstruct HopcroftKarp {\n int nLeft, nRight;\n vector> adj;\n vector dist, pairU, pairV;\n\n HopcroftKarp(int L, int R) : nLeft(L), nRight(R) {\n adj.assign(nLeft, {});\n pairU.assign(nLeft, -1);\n pairV.assign(nRight, -1);\n dist.resize(nLeft);\n }\n void addEdge(int u, int v) { adj[u].push_back(v); }\n\n bool bfs() {\n queue q;\n for (int u = 0; u < nLeft; ++u) {\n if (pairU[u] == -1) {\n dist[u] = 0;\n q.push(u);\n } else dist[u] = -1;\n }\n bool found = 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) found = true;\n }\n }\n return found;\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 int maxMatching() {\n int matching = 0;\n while (bfs()) {\n for (int u = 0; u < nLeft; ++u)\n if (pairU[u] == -1 && dfs(u))\n ++matching;\n }\n return matching;\n }\n};\n\n// ------------------------------------------------------------\nint sgn(int x) { return (x > 0) - (x < 0); }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n if (!(cin >> N >> T)) return 0;\n vector raw(N);\n for (int i = 0; i < N; ++i) cin >> raw[i];\n\n // --------------------------------------------------------\n // initialise board, masks, positions\n int M = N * N - 1; // number of tiles\n vector tileMask(M);\n vector> tilePos(M); // current positions of tiles\n vector> board(N, vector(N, -1));\n vector> cellIndex(N, vector(N, -1));\n vector> cellCoord; // coordinate of each cell (by its index)\n pair emptyPos;\n int tileId = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c = raw[i][j];\n int mask = (c >= '0' && c <= '9') ? (c - '0')\n : (10 + c - 'a');\n if (mask == 0) {\n emptyPos = {i, j};\n board[i][j] = -1;\n } else {\n board[i][j] = tileId;\n tileMask[tileId] = mask;\n tilePos[tileId] = {i, j};\n cellIndex[i][j] = tileId; // reuse same numbering (convenient)\n cellCoord.push_back({i, j});\n ++tileId;\n }\n }\n }\n // --------------------------------------------------------\n // target positions (filled after matching)\n vector> targetPos(M, {-1,-1});\n\n // --------------------------------------------------------\n // try to find a spanning tree and a perfect matching\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n const int MAX_TRIES = 200;\n bool ok = false;\n for (int attempt = 0; attempt < MAX_TRIES && !ok; ++attempt) {\n // ----- build a random spanning tree on the non\u2011empty cells\n vector> visited(N, vector(N, false));\n vector,pair>> edges; // list of tree edges\n // start from the first non\u2011empty cell\n int sr = -1, sc = -1;\n for (int i = 0; i < N && sr==-1; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1) { sr = i; sc = j; }\n if (sr==-1) continue; // should not happen\n stack> st;\n st.emplace(sr, sc);\n visited[sr][sc] = true;\n\n while (!st.empty()) {\n auto [r,c] = st.top(); st.pop();\n // random order of directions\n array dirs = {0,1,2,3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int nr = r + DI[d];\n int nc = c + DJ[d];\n if (nr<0||nr>=N||nc<0||nc>=N) continue;\n if (board[nr][nc]==-1) continue; // empty cell \u2013 cannot be part of the tree\n if (visited[nr][nc]) continue;\n visited[nr][nc] = true;\n st.emplace(nr,nc);\n edges.push_back({{r,c},{nr,nc}});\n }\n }\n int cnt = 0;\n for (int i=0;i> requiredMaskGrid(N, vector(N, 0));\n for (auto &e : edges) {\n auto p1 = e.first, p2 = e.second;\n int r1 = p1.first, c1 = p1.second;\n int r2 = p2.first, c2 = p2.second;\n int dr = r2 - r1, dc = c2 - c1;\n if (dr == 1) { // second cell is below first\n requiredMaskGrid[r1][c1] |= BIT_DOWN;\n requiredMaskGrid[r2][c2] |= BIT_UP;\n } else if (dr == -1) { // second cell is above first\n requiredMaskGrid[r1][c1] |= BIT_UP;\n requiredMaskGrid[r2][c2] |= BIT_DOWN;\n } else if (dc == 1) { // right\n requiredMaskGrid[r1][c1] |= BIT_RIGHT;\n requiredMaskGrid[r2][c2] |= BIT_LEFT;\n } else { // left\n requiredMaskGrid[r1][c1] |= BIT_LEFT;\n requiredMaskGrid[r2][c2] |= BIT_RIGHT;\n }\n }\n\n // ----- build the bipartite graph (cell -> tile) using equality of masks\n vector requiredMask(M);\n for (int i=0;i moves;\n moves.reserve(T);\n\n auto applyMove = [&](char dir) {\n int ex = emptyPos.first, ey = emptyPos.second;\n int nx = ex, ny = ey;\n if (dir == 'U') nx--;\n else if (dir == 'D') nx++;\n else if (dir == 'L') ny--;\n else if (dir == 'R') ny++;\n // neighbour must exist (the algorithm guarantees it)\n int tile = board[nx][ny];\n // swap\n board[ex][ey] = tile;\n board[nx][ny] = -1;\n if (tile != -1) tilePos[tile] = {nx, ny};\n emptyPos = {nx, ny};\n moves.push_back(dir);\n };\n\n auto moveEmptyTo = [&](int tr, int tc) {\n while (emptyPos.first > tr) applyMove('U');\n while (emptyPos.first < tr) applyMove('D');\n while (emptyPos.second > tc) applyMove('L');\n while (emptyPos.second < tc) applyMove('R');\n };\n\n // greedy placement\n while (true) {\n // find tile with minimal (empty distance + 1)\n int bestTile = -1;\n int bestCost = INT_MAX;\n int bestNeedX = -1, bestNeedY = -1;\n int bestStepX = 0, bestStepY = 0;\n\n for (int tid = 0; tid < M; ++tid) {\n auto cur = tilePos[tid];\n auto tgt = targetPos[tid];\n if (cur == tgt) continue;\n int dx = tgt.first - cur.first;\n int dy = tgt.second - cur.second;\n\n // vertical move\n if (dx != 0) {\n int step = sgn(dx);\n int nx = cur.first + step;\n int ny = cur.second;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = tid;\n bestNeedX = nx; bestNeedY = ny;\n bestStepX = step; bestStepY = 0;\n }\n }\n // horizontal move\n if (dy != 0) {\n int step = sgn(dy);\n int nx = cur.first;\n int ny = cur.second + step;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = tid;\n bestNeedX = nx; bestNeedY = ny;\n bestStepX = 0; bestStepY = step;\n }\n }\n }\n if (bestTile == -1) break; // all tiles are on target\n\n // move empty square to the needed neighbour\n moveEmptyTo(bestNeedX, bestNeedY);\n\n // slide the chosen tile one step\n char cmd;\n if (bestStepX != 0) {\n cmd = (bestStepX == -1) ? 'D' : 'U';\n } else {\n cmd = (bestStepY == -1) ? 'R' : 'L';\n }\n applyMove(cmd);\n\n // after the slide the tile has moved one step\n tilePos[bestTile].first += bestStepX;\n tilePos[bestTile].second += bestStepY;\n\n if ((int)moves.size() >= T) break;\n }\n\n // --------------------------------------------------------\n // Output\n string out(moves.begin(), moves.end());\n cout << out << \"\\n\";\n\n // --------------------------------------------------------\n // (optional) verification \u2013 compute the score locally\n // -------------------------------------------------------------\n // build graph from final board\n int maxTreeSize = 0;\n int V = 0;\n vector> vid(N, vector(N, -1));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1) vid[i][j] = V++;\n\n vector> g(V);\n auto addEdge = [&](int r1,int c1,int r2,int c2){\n if (r2<0||r2>=N||c2<0||c2>=N) return;\n if (board[r1][c1]==-1 || board[r2][c2]==-1) return;\n int m1 = tileMask[board[r1][c1]];\n int m2 = tileMask[board[r2][c2]];\n bool ok = false;\n if (r2 == r1+1) { // downwards\n if ((m1 & BIT_DOWN) && (m2 & BIT_UP)) ok = true;\n } else if (c2 == c1+1) { // rightwards\n if ((m1 & BIT_RIGHT) && (m2 & BIT_LEFT)) ok = true;\n }\n if (ok) {\n int u = vid[r1][c1], v = vid[r2][c2];\n g[u].push_back(v);\n g[v].push_back(u);\n }\n };\n\n for (int i=0;i seen(V,0);\n for (int i=0;i q;\n q.push(i); seen[i]=1;\n while(!q.empty()){\n int u=q.front(); q.pop();\n ++vertices;\n edges += (int)g[u].size();\n for(int v:g[u]) if(!seen[v]){\n seen[v]=1; q.push(v);\n }\n }\n edges /= 2;\n if (edges == vertices-1) // a tree\n maxTreeSize = max(maxTreeSize, vertices);\n }\n\n // -------------------------------------------------------------\n // the program does not have to output the score,\n // only the move string is required.\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\nusing i128 = __int128_t;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, K;\n if (!(cin >> N >> K)) return 0;\n vector a(11);\n for (int d = 1; d <= 10; ++d) cin >> a[d];\n vector> pt(N);\n for (int i = 0; i < N; ++i) cin >> pt[i].first >> pt[i].second;\n\n const int64 R = 10000; // radius of the cake\n const int64 LIM = 1000000000LL; // maximal coordinate value\n\n mt19937_64 rng(random_device{}());\n uniform_int_distribution dist(-R, R);\n\n const int MAX_TRIES = 200000; // more than enough\n vector> lines;\n lines.reserve(K);\n\n int tries = 0;\n while ((int)lines.size() < K && tries < MAX_TRIES) {\n ++tries;\n // first point\n int64 x1 = dist(rng), y1 = dist(rng);\n if (x1*x1 + y1*y1 >= (int64)R*R) continue; // must be inside the disc\n // second point\n int64 x2 = dist(rng), y2 = dist(rng);\n if (x2*x2 + y2*y2 >= (int64)R*R) continue;\n if (x1 == x2 && y1 == y2) continue; // distinct points\n\n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (auto &p : pt) {\n i128 cross = (i128)dx * (i128)(p.second - y1)\n - (i128)dy * (i128)(p.first - x1);\n if (cross == 0) { // a strawberry lies on the line\n ok = false;\n break;\n }\n }\n if (ok) {\n lines.emplace_back(x1, y1, x2, y2);\n tries = 0; // reset, we succeeded\n }\n }\n\n // -----------------------------------------------------------------\n // In the extremely unlikely event that we could not find K lines,\n // fill the rest with axis aligned lines that are guaranteed safe.\n if ((int)lines.size() < K) {\n unordered_set forbX, forbY;\n for (auto &p : pt) {\n forbX.insert(p.first);\n forbY.insert(p.second);\n }\n vector xs, ys;\n for (int64 x = -R; x <= R; ++x)\n if (!forbX.count(x)) xs.push_back(x);\n for (int64 y = -R; y <= R; ++y)\n if (!forbY.count(y)) ys.push_back(y);\n\n size_t i = 0, j = 0;\n while ((int)lines.size() < K) {\n if (i < xs.size()) {\n int64 x0 = xs[i++];\n lines.emplace_back(x0, -LIM, x0, LIM); // vertical\n } else {\n int64 y0 = ys[j++];\n lines.emplace_back(-LIM, y0, LIM, y0); // horizontal\n }\n }\n }\n\n // -----------------------------------------------------------------\n cout << lines.size() << '\\n';\n for (auto &ln : lines) {\n int64 x1, y1, x2, y2;\n tie(x1, y1, x2, y2) = ln;\n cout << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << '\\n';\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2, x3, y3, x4, y4;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n if (!(cin >> N >> M)) return 0;\n\n vector> dot(N, vector(N, 0));\n vector> init;\n for (int i = 0; i < M; ++i) {\n int x, y; cin >> x >> y;\n dot[x][y] = 1;\n init.emplace_back(x, y);\n }\n\n /* ----- edges --------------------------------------------------- */\n vector> hor(N, vector(N, 0)); // (x,y)-(x+1,y)\n vector> ver(N, vector(N, 0)); // (x,y)-(x,y+1)\n\n /* ----- row / column lists of dotted points -------------------- */\n vector> rowDots(N), colDots(N);\n for (auto &p : init) {\n int x = p.first, y = p.second;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n }\n\n /* ----- all empty points ---------------------------------------- */\n vector> empty;\n for (int x = 0; x < N; ++x)\n for (int y = 0; y < N; ++y)\n if (!dot[x][y]) empty.emplace_back(x, y);\n\n vector answer;\n\n /* ----- helper lambdas ----------------------------------------- */\n auto sidesEmpty = [&](int x, int y, int x2, int y2) -> bool {\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n // side (x,y)-(x2,y)\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y]) return false;\n // side (x,y)-(x,y2)\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x][yi]) return false;\n // side (x2,y)-(x2,y2)\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x2][yi]) return false;\n // side (x,y2)-(x2,y2)\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y2]) return false;\n return true;\n };\n\n auto edgesFree = [&](int x, int y, int x2, int y2) -> bool {\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n // horizontal side on row y\n for (int xi = xlo; xi < xhi; ++xi)\n if (hor[xi][y]) return false;\n // vertical side on column x\n for (int yi = ylo; yi < yhi; ++yi)\n if (ver[x][yi]) return false;\n // horizontal side on row y2\n for (int xi = xlo; xi < xhi; ++xi)\n if (hor[xi][y2]) return false;\n // vertical side on column x2\n for (int yi = ylo; yi < yhi; ++yi)\n if (ver[x2][yi]) return false;\n return true;\n };\n\n auto addRect = [&](int x, int y, int x2, int y2) {\n Rect r{ x, y, x2, y, x2, y2, x, y2 };\n answer.push_back(r);\n\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n for (int xi = xlo; xi < xhi; ++xi) hor[xi][y] = 1;\n for (int yi = ylo; yi < yhi; ++yi) ver[x][yi] = 1;\n for (int xi = xlo; xi < xhi; ++xi) hor[xi][y2] = 1;\n for (int yi = ylo; yi < yhi; ++yi) ver[x2][yi] = 1;\n\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n };\n\n function tryAdd = [&](int x, int y) -> bool {\n const vector &cols = rowDots[y]; // points in same row\n const vector &rows = colDots[x]; // points in same column\n for (int x2 : cols) {\n if (x2 == x) continue;\n for (int y2 : rows) {\n if (y2 == y) continue;\n if (!dot[x2][y2]) continue; // opposite corner must exist\n if (!sidesEmpty(x, y, x2, y2)) continue;\n if (!edgesFree(x, y, x2, y2)) continue;\n addRect(x, y, x2, y2);\n return true;\n }\n }\n return false;\n };\n\n /* ----- main greedy loop --------------------------------------- */\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n while (true) {\n bool progress = false;\n shuffle(empty.begin(), empty.end(), rng);\n for (size_t i = 0; i < empty.size(); ++i) {\n int x = empty[i].first, y = empty[i].second;\n if (tryAdd(x, y)) {\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n break; // restart with fresh list\n }\n }\n if (!progress) break;\n }\n\n /* ----- output -------------------------------------------------- */\n cout << answer.size() << '\\n';\n for (const auto &r : answer) {\n cout << r.x1 << ' ' << r.y1 << ' '\n << r.x2 << ' ' << r.y2 << ' '\n << r.x3 << ' ' << r.y3 << ' '\n << r.x4 << ' ' << r.y4 << '\\n';\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nconstexpr int H = 10;\nconstexpr int W = 10;\nconstexpr int MAXC = 100;\n\nint flavor[MAXC + 1]; // 1\u2011based\n\n/*------------------------------------------------------------*/\n/* board utilities */\nvoid copyBoard(const int src[H][W], int dst[H][W]) {\n for (int i = 0; i < H; ++i)\n for (int j = 0; j < W; ++j)\n dst[i][j] = src[i][j];\n}\n\n/* tilt: F = up, B = down, L = left, R = right */\nvoid tiltBoard(int a[H][W], char dir) {\n if (dir == 'F') { // forward \u2192 up\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = 0; r < H; ++r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[i][c] = buf[i];\n }\n } else if (dir == 'B') { // backward \u2192 down\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = H - 1; r >= 0; --r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[H - 1 - i][c] = buf[i];\n }\n } else if (dir == 'L') { // left \u2192 left\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = 0; c < W; ++c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][i] = buf[i];\n }\n } else if (dir == 'R') { // right \u2192 right\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = W - 1; c >= 0; --c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][W - 1 - i] = buf[i];\n }\n }\n}\n\n/*------------------------------------------------------------*/\n/* evaluation of a board */\nstruct Eval {\n int sumSq; // \u03a3 size\u00b2\n int maxSize; // size of the largest component\n int compCnt; // number of components\n};\n\nEval evaluate(const int a[H][W]) {\n bool vis[H][W] = {false};\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n\n Eval res{0, 0, 0};\n for (int r = 0; r < H; ++r) {\n for (int c = 0; c < W; ++c) {\n if (a[r][c] && !vis[r][c]) {\n int fl = a[r][c];\n int sz = 0;\n queue> q;\n q.emplace(r, c);\n vis[r][c] = true;\n while (!q.empty()) {\n auto [cr, cc] = q.front(); q.pop();\n ++sz;\n for (int d = 0; d < 4; ++d) {\n int nr = cr + dr[d];\n int nc = cc + dc[d];\n if (nr >= 0 && nr < H && nc >= 0 && nc < W &&\n !vis[nr][nc] && a[nr][nc] == fl) {\n vis[nr][nc] = true;\n q.emplace(nr, nc);\n }\n }\n }\n res.sumSq += sz * sz;\n res.maxSize = max(res.maxSize, sz);\n ++res.compCnt;\n }\n }\n }\n return res;\n}\n\n/*------------------------------------------------------------*/\n/* greedy one\u2011step best direction */\nstatic const char DIRS[4] = {'F', 'B', 'L', 'R'};\n\nchar bestDirOneStep(const int board[H][W]) {\n char bestDir = 'R';\n Eval best{-1, -1, INT_MAX};\n for (char d : DIRS) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n Eval ev = evaluate(tmp);\n if (ev.sumSq > best.sumSq ||\n (ev.sumSq == best.sumSq && ev.maxSize > best.maxSize) ||\n (ev.sumSq == best.sumSq && ev.maxSize == best.maxSize && ev.compCnt < best.compCnt)) {\n best = ev;\n bestDir = d;\n }\n }\n return bestDir;\n}\n\n/*------------------------------------------------------------*/\n/* list of empty cells */\nvector> getEmpty(const int board[H][W]) {\n vector> v;\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n if (board[r][c] == 0) v.emplace_back(r, c);\n return v;\n}\n\n/*------------------------------------------------------------*/\n/* expected \u03a3 size\u00b2 after the next candy has been placed and\n we tilt once more (depth\u20112 look\u2011ahead) */\ndouble expectedAfterTwoSteps(const int board[H][W], int curStep) {\n int nextStep = curStep + 1;\n if (nextStep > MAXC) // no more candies\n return evaluate(board).sumSq;\n\n vector> empties = getEmpty(board);\n int cnt = (int)empties.size();\n if (cnt == 0) // board already full\n return evaluate(board).sumSq;\n\n double total = 0.0;\n int flNext = flavor[nextStep];\n for (auto &ec : empties) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tmp[ec.first][ec.second] = flNext; // place next candy\n char d1 = bestDirOneStep(tmp); // greedy tilt after placement\n tiltBoard(tmp, d1);\n total += evaluate(tmp).sumSq;\n }\n return total / cnt; // uniform probability\n}\n\n/*------------------------------------------------------------*/\n/* choose the direction for the current step using the\n depth\u20112 expectation */\nchar chooseDirection(const int board[H][W], int curStep) {\n double bestScore = -1.0;\n char bestDir = 'R';\n for (char d : DIRS) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n double expScore = expectedAfterTwoSteps(tmp, curStep);\n if (expScore > bestScore + 1e-9) {\n bestScore = expScore;\n bestDir = d;\n }\n }\n return bestDir;\n}\n\n/*------------------------------------------------------------*/\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n /* read the whole flavour sequence */\n for (int i = 1; i <= MAXC; ++i) {\n if (!(cin >> flavor[i])) return 0; // no input\n }\n\n int board[H][W] = {0};\n\n /* initially every cell is empty */\n vector> empties;\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n empties.emplace_back(r, c);\n\n for (int step = 1; step <= MAXC; ++step) {\n int p; // position where the current candy is placed\n cin >> p;\n auto cell = empties[p - 1];\n board[cell.first][cell.second] = flavor[step];\n empties.erase(empties.begin() + (p - 1));\n\n char dir;\n if (step == MAXC) { // last step \u2013 any greedy direction is fine\n dir = bestDirOneStep(board);\n } else {\n dir = chooseDirection(board, step);\n }\n\n cout << dir << '\\n' << std::flush; // required flush\n\n tiltBoard(board, dir); // really tilt the box\n\n /* rebuild list of empty cells for the next iteration */\n empties.clear();\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n if (board[r][c] == 0) empties.emplace_back(r, c);\n }\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int M;\n long double eps;\n if (!(cin >> M >> eps)) return 0;\n\n const int MAX_E = 4950; // N = 100 \u2192 E = 4950\n vector lfac(MAX_E + 1);\n lfac[0] = 0;\n for (int i = 1; i <= MAX_E; ++i) lfac[i] = lfac[i - 1] + logl((long double)i);\n\n // smallest N such that N(N\u20111)/2 \u2265 M\u20111\n int minN = 4;\n while (minN * (minN - 1) / 2 < M - 1) ++minN;\n\n int bestN = minN;\n long double bestScore = -1.0L;\n\n // epsilon = 0 \u2192 perfect recovery, choose smallest N\n if (fabsl(eps) < 1e-12L) {\n bestN = minN;\n } else {\n const long double oneMinus2eps = 1.0L - 2.0L * eps;\n\n for (int N = minN; N <= 100; ++N) {\n int E = N * (N - 1) / 2;\n\n // edge counts mi\n vector mi(M);\n for (int i = 0; i < M; ++i) {\n mi[i] = (int)floor((long double)i * E / (M - 1));\n }\n\n // log probabilities for every hypothesis\n vector logp(M), log1mp(M);\n for (int i = 0; i < M; ++i) {\n long double p = eps + oneMinus2eps * (long double)mi[i] / (long double)E;\n logp[i] = logl(p);\n log1mp[i] = log1pl(-p); // log(1-p)\n }\n\n // log binomial coefficients for this E\n vector logBinomE(E + 1);\n for (int x = 0; x <= E; ++x) {\n logBinomE[x] = lfac[E] - lfac[x] - lfac[E - x];\n }\n\n // total_correct = \u03a3_x max_i Pr[ X = x | mi ]\n long double total_correct = 0.0L;\n for (int x = 0; x <= E; ++x) {\n long double log_common = logBinomE[x];\n long double max_val = -numeric_limits::infinity();\n for (int i = 0; i < M; ++i) {\n // cur = log_common + x*logp[i] + (E-x)*log1mp[i]\n long double cur = log_common + (long double)x * logp[i] +\n (long double)(E - x) * log1mp[i];\n if (cur > max_val) max_val = cur;\n }\n total_correct += expl(max_val);\n }\n\n long double p_err = 1.0L - total_correct / (long double)M;\n if (p_err < 0) p_err = 0;\n\n long double factor = powl(1.0L - 0.1L * p_err, 100);\n long double score = 1e9L * factor / (long double)N;\n\n if (score > bestScore) {\n bestScore = score;\n bestN = N;\n }\n }\n }\n\n // ----- produce output with the chosen N -----\n int N = bestN;\n int E = N * (N - 1) / 2;\n\n // recompute mi for the chosen N\n vector mi(M);\n for (int i = 0; i < M; ++i) {\n mi[i] = (int)floor((long double)i * E / (M - 1));\n }\n\n cout << N << \"\\n\";\n string edgeStr(E, '0');\n for (int idx = 0; idx < M; ++idx) {\n int ones = mi[idx];\n fill(edgeStr.begin(), edgeStr.end(), '0');\n for (int j = 0; j < ones; ++j) edgeStr[j] = '1';\n cout << edgeStr << \"\\n\";\n }\n cout.flush(); // required after the graphs\n\n // pre\u2011compute log\u2011probabilities for decoding\n vector logp(M), log1mp(M);\n const long double oneMinus2eps = 1.0L - 2.0L * eps;\n for (int i = 0; i < M; ++i) {\n long double p = eps + oneMinus2eps * (long double)mi[i] / (long double)E;\n logp[i] = logl(p);\n log1mp[i] = log1pl(-p);\n }\n\n // ----- answer the 100 queries -----\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n int x = 0;\n for (char c : H) if (c == '1') ++x;\n\n int answer;\n if (fabsl(eps) < 1e-12L) { // \u03b5 = 0 \u2192 exact edge count\n answer = (int)(lower_bound(mi.begin(), mi.end(), x) - mi.begin());\n } else {\n long double bestVal = -numeric_limits::infinity();\n answer = 0;\n for (int i = 0; i < M; ++i) {\n long double cur = (long double)x * logp[i] +\n (long double)(E - x) * log1mp[i];\n if (cur > bestVal) {\n bestVal = cur;\n answer = i;\n }\n }\n }\n cout << answer << \"\\n\";\n cout.flush();\n }\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n int w;\n};\n\nint N, M, D, K;\nvector edges;\nvector>> adj; // (to, edge id)\nvector> edge_adj; // line-graph adjacency\nvector> day_edges; // edges belonging to each day\nvector day_cnt;\nvector day_of_edge;\nvector mark; // timestamp for connectivity test\nvector visited;\nvector q; // BFS queue\nint cur_timestamp;\n\n// ---------------------------------------------------------------\n// Test whether adding 'cand' to day 'day' keeps the graph connected\nbool safe(int day, int cand) {\n ++cur_timestamp;\n for (int e : day_edges[day]) mark[e] = cur_timestamp;\n mark[cand] = cur_timestamp;\n\n fill(visited.begin(), visited.end(), 0);\n int qs = 0, qe = 0;\n visited[0] = 1;\n q[qe++] = 0;\n while (qs < qe) {\n int v = q[qs++];\n for (auto [to, eid] : adj[v]) {\n if (mark[eid] == cur_timestamp) continue;\n if (!visited[to]) {\n visited[to] = 1;\n q[qe++] = to;\n }\n }\n }\n\n for (int i = 0; i < N; ++i) if (!visited[i]) return false;\n return true;\n}\n\n// ---------------------------------------------------------------\nint metric_of_current() {\n int met = 0;\n for (int e = 0; e < M; ++e) {\n int d = day_of_edge[e];\n for (int nb : edge_adj[e]) {\n if (day_of_edge[nb] == d && nb < e) ++met;\n }\n }\n return met;\n}\n\n// ---------------------------------------------------------------\nvoid greedy_build(const vector& order) {\n for (int d = 0; d < D; ++d) {\n day_edges[d].clear();\n day_cnt[d] = 0;\n }\n fill(day_of_edge.begin(), day_of_edge.end(), -1);\n\n vector score(D, 0);\n\n for (int eid : order) {\n fill(score.begin(), score.end(), 0);\n for (int nb : edge_adj[eid]) {\n int d = day_of_edge[nb];\n if (d != -1) ++score[d];\n }\n\n int best_score = -1;\n vector cand;\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] >= K) continue;\n if (score[d] > best_score) {\n best_score = score[d];\n cand.clear();\n cand.push_back(d);\n } else if (score[d] == best_score) {\n cand.push_back(d);\n }\n }\n\n if (cand.empty()) continue;\n\n // Choose candidate with smallest day_cnt\n int chosen = cand[0];\n int min_cnt = day_cnt[chosen];\n for (size_t i = 1; i < cand.size(); ++i) {\n int d = cand[i];\n if (day_cnt[d] < min_cnt) {\n min_cnt = day_cnt[d];\n chosen = d;\n }\n }\n\n if (day_cnt[chosen] > 0 && !safe(chosen, eid)) {\n bool found = false;\n vector shuffled = cand;\n shuffle(shuffled.begin(), shuffled.end(), mt19937{random_device{}()});\n for (int d : shuffled) {\n if (d == chosen) continue;\n if (day_cnt[d] == 0 || safe(d, eid)) {\n chosen = d;\n found = true;\n break;\n }\n }\n if (!found) {\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K) {\n chosen = d;\n break;\n }\n }\n }\n }\n\n day_of_edge[eid] = chosen;\n ++day_cnt[chosen];\n day_edges[chosen].push_back(eid);\n }\n}\n\n// ---------------------------------------------------------------\nvoid local_search(int max_moves = 500) {\n int current_metric = metric_of_current();\n int moves_made = 0;\n bool improved = true;\n while (improved && moves_made < max_moves) {\n improved = false;\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), mt19937{random_device{}()});\n\n for (int eid : order) {\n int current_day = day_of_edge[eid];\n\n // Compute old_pairs once\n int old_pairs = 0;\n for (int nb : edge_adj[eid]) {\n if (day_of_edge[nb] == current_day) old_pairs++;\n }\n\n int best_delta = -1;\n int best_day = -1;\n\n for (int d = 0; d < D; ++d) {\n if (d == current_day) continue;\n if (day_cnt[d] >= K) continue;\n\n // Compute new_pairs (number of neighbors in day d)\n int new_pairs = 0;\n for (int nb : edge_adj[eid]) {\n if (day_of_edge[nb] == d) new_pairs++;\n }\n\n int delta = new_pairs - old_pairs;\n if (delta > best_delta) {\n best_delta = delta;\n best_day = d;\n }\n }\n\n if (best_delta > 0 && best_day != -1) {\n if (day_cnt[best_day] == 0 || safe(best_day, eid)) {\n // Move edge\n day_edges[current_day].erase(\n remove(day_edges[current_day].begin(), day_edges[current_day].end(), eid),\n day_edges[current_day].end()\n );\n --day_cnt[current_day];\n\n day_of_edge[eid] = best_day;\n ++day_cnt[best_day];\n day_edges[best_day].push_back(eid);\n\n current_metric += best_delta;\n moves_made++;\n improved = true;\n break;\n }\n }\n }\n }\n}\n\n// ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n if (!(cin >> N >> M >> D >> K)) return 0;\n edges.resize(M);\n adj.assign(N, {});\n vector> vertex_edges[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 adj[u].push_back({v, i});\n adj[v].push_back({u, i});\n vertex_edges[u].push_back({v, i});\n vertex_edges[v].push_back({u, i});\n }\n\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n // Build line-graph adjacency\n edge_adj.assign(M, {});\n for (int v = 0; v < N; ++v) {\n for (size_t a = 0; a < vertex_edges[v].size(); ++a) {\n int e1 = vertex_edges[v][a].second;\n for (size_t b = a + 1; b < vertex_edges[v].size(); ++b) {\n int e2 = vertex_edges[v][b].second;\n edge_adj[e1].push_back(e2);\n edge_adj[e2].push_back(e1);\n }\n }\n }\n\n day_edges.assign(D, {});\n day_cnt.assign(D, 0);\n day_of_edge.assign(M, -1);\n mark.assign(M, -1);\n visited.assign(N, 0);\n q.resize(N);\n cur_timestamp = 0;\n\n const int ITERATIONS = 30;\n int best_metric = -1;\n vector best_assignment;\n\n for (int it = 0; it < ITERATIONS; ++it) {\n vector order(M);\n iota(order.begin(), order.end(), 0);\n\n if (rand() % 2 == 0) {\n shuffle(order.begin(), order.end(), mt19937{random_device{}()});\n } else {\n sort(order.begin(), order.end(), [&](int a, int b) {\n return edges[a].w < edges[b].w;\n });\n for (int i = 0; i < 50; ++i) {\n int a = rand() % M;\n int b = rand() % M;\n swap(order[a], order[b]);\n }\n }\n\n greedy_build(order);\n int met = metric_of_current();\n\n local_search(500);\n\n int met_after = metric_of_current();\n if (met_after > met) met = met_after;\n\n if (met > best_metric) {\n best_metric = met;\n best_assignment = day_of_edge;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n if (i) cout << ' ';\n cout << (best_assignment[i] + 1);\n }\n cout << '\\n';\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n if (!(cin >> D)) return 0;\n vector f1(D), r1(D), f2(D), r2(D);\n for (int i = 0; i < D; i++) cin >> f1[i];\n for (int i = 0; i < D; i++) cin >> r1[i];\n for (int i = 0; i < D; i++) cin >> f2[i];\n for (int i = 0; i < D; i++) cin >> r2[i];\n \n // O1[x][y][z] = 1 if position is in object 1's minimal covering\n // O2[x][y][z] = 1 if position is in object 2's minimal covering\n vector>> O1(D, vector>(D, vector(D, 0)));\n vector>> O2(D, vector>(D, vector(D, 0)));\n \n auto min_edge_cover = [&](const vector& F, const vector& R, \n vector>>& O, int z) {\n int nF = F.size(), nR = R.size();\n if (nF == 0 || nR == 0) return;\n \n if (nF >= nR) {\n // Match each y in R to distinct x in F\n for (int i = 0; i < nR; i++) {\n O[F[i]][R[i]][z] = 1;\n }\n // Remaining x in F connect to R[0]\n for (int i = nR; i < nF; i++) {\n O[F[i]][R[0]][z] = 1;\n }\n } else {\n // Match each x in F to distinct y in R\n for (int i = 0; i < nF; i++) {\n O[F[i]][R[i]][z] = 1;\n }\n // Remaining y in R connect to F[0]\n for (int i = nF; i < nR; i++) {\n O[F[0]][R[i]][z] = 1;\n }\n }\n };\n \n // Build O1 using silhouette pair 1\n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f1[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r1[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O1, z);\n }\n \n // Build O2 using silhouette pair 2\n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f2[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r2[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O2, z);\n }\n \n // Find connected components in O1 U O2\n vector>> comp_id(D, vector>(D, vector(D, -1)));\n vector>> components;\n const int dx[6] = {1,-1,0,0,0,0};\n const int dy[6] = {0,0,1,-1,0,0};\n const int dz[6] = {0,0,0,0,1,-1};\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if ((O1[x][y][z] || O2[x][y][z]) && comp_id[x][y][z] == -1) {\n vector> comp;\n queue> q;\n q.push({x,y,z});\n comp_id[x][y][z] = components.size();\n while (!q.empty()) {\n auto [cx, cy, cz] = q.front(); q.pop();\n comp.emplace_back(cx, cy, cz);\n for (int dir = 0; dir < 6; dir++) {\n int nx = cx + dx[dir];\n int ny = cy + dy[dir];\n int nz = cz + dz[dir];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D || nz < 0 || nz >= D) continue;\n if ((O1[nx][ny][nz] || O2[nx][ny][nz]) && comp_id[nx][ny][nz] == -1) {\n comp_id[nx][ny][nz] = components.size();\n q.push({nx, ny, nz});\n }\n }\n }\n components.push_back(comp);\n }\n }\n }\n }\n \n int n = components.size();\n // Map position to block index (1-based)\n vector>> idx(D, vector>(D, vector(D, 0)));\n for (int i = 0; i < n; i++) {\n for (auto& p : components[i]) {\n int x, y, z;\n tie(x, y, z) = p;\n idx[x][y][z] = i + 1; // 1-based index\n }\n }\n \n // Output\n cout << n << \"\\n\";\n // b1: flatten with order x*D*D + y*D + z\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O1[x][y][z]) {\n cout << idx[x][y][z];\n } else {\n cout << 0;\n }\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n // b2\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O2[x][y][z]) {\n cout << idx[x][y][z];\n } else {\n cout << 0;\n }\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n return 0;\n}","ahc020":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n long long w;\n int idx;\n};\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n r.assign(n, 0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nint N, M, K;\nvector> vertex; // (x,y)\nvector> resident; // (a,b)\nvector edges; // original order\nvector edgesSorted; // sorted by weight\nvector> dist2; // N x K\nvector>> cand; // per resident, stations within 5000, sorted\n\n// ---------------------------------------------------------------\n// price of a set 'sel' (sel[i]==1 <=> station i is reachable)\nconst long long INF = (1LL<<60);\n\nlong long price_of(const vector& sel) {\n // ----- edge cost (MST on induced subgraph) -----\n long long edgeCost = 0;\n DSU dsu(N);\n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v))\n edgeCost += e.w;\n }\n }\n\n // ----- radii -----\n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n bool ok = false;\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (sel[i]) {\n long long d2 = pr.second;\n if (maxDistSq[i] < d2) maxDistSq[i] = d2;\n ok = true;\n break; // nearest selected station\n }\n }\n if (!ok) return INF; // resident not covered\n }\n\n long long sumP2 = 0;\n for (int i = 0; i < N; ++i) {\n if (!sel[i]) continue;\n long long md2 = maxDistSq[i];\n long long P;\n if (md2 < 0) {\n P = 0;\n } else {\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n P = r;\n }\n sumP2 += P * P;\n }\n return edgeCost + sumP2;\n}\n\n// ---------------------------------------------------------------\n// MST edges for a given set, returns vector B (size M)\nvector mst_edges(const vector& sel) {\n vector B(M, 0);\n DSU dsu(N);\n int need = 0;\n for (int i = 0; i < N; ++i) if (sel[i]) ++need;\n if (need <= 1) return B;\n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v)) {\n B[e.idx] = 1;\n if (--need == 1) break;\n }\n }\n }\n return B;\n}\n\n// ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n // ----- read input -----\n if (!(cin >> N >> M >> K)) return 0;\n vertex.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> vertex[i].first >> vertex[i].second;\n }\n edges.resize(M);\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, j};\n }\n resident.resize(K);\n for (int k = 0; k < K; ++k) {\n cin >> resident[k].first >> resident[k].second;\n }\n\n // ----- preprocessing -----\n dist2.assign(N, vector(K, 0));\n const long long R2 = 5000LL * 5000LL;\n cand.assign(K, {});\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n long long dx = vertex[i].first - resident[k].first;\n long long dy = vertex[i].second - resident[k].second;\n long long d2 = dx*dx + dy*dy;\n dist2[i][k] = d2;\n if (d2 <= R2) cand[k].push_back({i, d2});\n }\n }\n for (int k = 0; k < K; ++k)\n sort(cand[k].begin(), cand[k].end(),\n [](const auto& a, const auto& b){ return a.second < b.second; });\n\n edgesSorted = edges;\n sort(edgesSorted.begin(), edgesSorted.end(),\n [](const Edge& a, const Edge& b){ return a.w < b.w; });\n\n // ----- initial solution (all vertices) -----\n vector sel(N, 1);\n sel[0] = 1; // station 1 is always reachable\n long long curCost = price_of(sel);\n\n // ---------- greedy removal ----------\n bool changed = true;\n while (changed) {\n changed = false;\n long long bestGain = 0;\n int bestV = -1;\n for (int v = 1; v < N; ++v) {\n if (!sel[v]) continue;\n // coverage test without v\n bool ok = true;\n for (int k = 0; k < K && ok; ++k) {\n bool any = false;\n for (auto &pr : cand[k]) {\n if (sel[pr.first] && pr.first != v) { any = true; break; }\n }\n if (!any) ok = false;\n }\n if (!ok) continue;\n\n sel[v] = 0;\n long long newCost = price_of(sel);\n sel[v] = 1;\n if (newCost < curCost && curCost - newCost > bestGain) {\n bestGain = curCost - newCost;\n bestV = v;\n }\n }\n if (bestV != -1) {\n sel[bestV] = 0;\n curCost -= bestGain;\n changed = true;\n }\n }\n\n // ---------- greedy addition ----------\n changed = true;\n while (changed) {\n changed = false;\n long long bestGain = 0;\n int bestV = -1;\n for (int v = 1; v < N; ++v) {\n if (sel[v]) continue;\n sel[v] = 1;\n long long newCost = price_of(sel);\n sel[v] = 0;\n if (newCost < curCost && curCost - newCost > bestGain) {\n bestGain = curCost - newCost;\n bestV = v;\n }\n }\n if (bestV != -1) {\n sel[bestV] = 1;\n curCost -= bestGain;\n changed = true;\n }\n }\n\n // ----- final radii (for output) -----\n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (sel[i]) {\n if (maxDistSq[i] < pr.second) maxDistSq[i] = pr.second;\n break; // nearest selected\n }\n }\n }\n vector P(N, 0);\n for (int i = 0; i < N; ++i) {\n if (!sel[i]) { P[i] = 0; continue; }\n long long md2 = maxDistSq[i];\n if (md2 < 0) { P[i] = 0; continue; }\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n P[i] = r;\n }\n\n // ----- edges that are ON -----\n vector B = mst_edges(sel);\n\n // ----- output -----\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << P[i];\n }\n cout << '\\n';\n for (int j = 0; j < M; ++j) {\n if (j) cout << ' ';\n cout << B[j];\n }\n cout << '\\n';\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconst int N = 30; // fixed size\nconst int TOTAL = N * (N + 1) / 2; // 465\n\n// current value on each position\nint val[N][N];\n// position of each value (only for debugging / verification)\npair pos[TOTAL];\n\n// list of performed swaps\nvector> ops;\n\n/* exchange the balls on (x1,y1) and (x2,y2) */\ninline void do_swap(int x1, int y1, int x2, int y2) {\n ops.push_back({x1, y1, x2, y2});\n int v1 = val[x1][y1];\n int v2 = val[x2][y2];\n swap(val[x1][y1], val[x2][y2]);\n pos[v1] = {x2, y2};\n pos[v2] = {x1, y1};\n}\n\n/* sift the element at (x,y) down until its sub\u2011triangle is a heap */\nvoid heapify_node(int x, int y) {\n while (true) {\n if (x == N - 1) break; // leaf -> no children\n int c1x = x + 1, c1y = y;\n int c2x = x + 1, c2y = y + 1;\n int parent_val = val[x][y];\n int child1_val = val[c1x][c1y];\n int child2_val = val[c2x][c2y];\n\n // choose the child with the smaller value\n int smaller_cx = c1x, smaller_cy = c1y;\n int smaller_val = child1_val;\n if (child2_val < smaller_val) {\n smaller_cx = c2x;\n smaller_cy = c2y;\n smaller_val = child2_val;\n }\n\n if (parent_val <= smaller_val) break; // heap condition satisfied\n\n // swap with the smaller child and continue downwards\n do_swap(x, y, smaller_cx, smaller_cy);\n x = smaller_cx;\n y = smaller_cy;\n }\n}\n\n/* ---------- main ---------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // ----- read input -----\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n int v; cin >> v;\n val[x][y] = v;\n pos[v] = {x, y};\n }\n }\n\n // ----- bottom\u2011up heapify -----\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n heapify_node(x, y);\n }\n }\n\n // ----- optional verification (can be omitted) -----\n bool ok = true;\n for (int x = 0; x < N - 1 && ok; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (val[x][y] >= val[x + 1][y] || val[x][y] >= val[x + 1][y + 1]) {\n ok = false;\n break;\n }\n }\n }\n if (!ok) cerr << \"Heap condition violated!\\n\";\n\n // ----- output -----\n if ((int)ops.size() > 10000) {\n cerr << \"Too many swaps: \" << ops.size() << '\\n';\n }\n cout << ops.size() << '\\n';\n for (auto &op : ops) {\n cout << op[0] << ' ' << op[1] << ' '\n << op[2] << ' ' << op[3] << '\\n';\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int D, N;\n if (!(cin >> D >> N)) return 0;\n const int MAXD = 9; // D is always 9, but keep generic\n bool obstacle[MAXD][MAXD] = {};\n\n for (int k = 0; k < N; ++k) {\n int ri, rj; cin >> ri >> rj;\n obstacle[ri][rj] = true;\n }\n\n const int er = 0, ec = (D - 1) / 2; // entrance\n const int ENTRANCE_ID = D * D; // extra node number\n const int TOTAL_NODES = D * D + 1;\n\n // ---------- BFS distances (ignoring containers) ----------\n int dist[MAXD][MAXD];\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n dist[i][j] = -1;\n\n queue> q;\n dist[er][ec] = 0;\n q.emplace(er, ec);\n const int dr[4] = {-1,1,0,0};\n const int dc[4] = {0,0,-1,1};\n\n while (!q.empty()) {\n auto [r,c] = q.front(); q.pop();\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (dist[nr][nc] == -1) {\n dist[nr][nc] = dist[r][c] + 1;\n q.emplace(nr,nc);\n }\n }\n }\n\n // ---------- list of squares that may contain containers ----------\n vector cells; // their ids\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n if (!obstacle[i][j] && !(i == er && j == ec))\n cells.push_back(i * D + j);\n\n const int M = (int)cells.size(); // number of containers\n\n // sorted list of distances (the \u201cideal\u201d distances)\n vector sortedDist;\n sortedDist.reserve(M);\n for (int id : cells) sortedDist.push_back(dist[id / D][id % D]);\n sort(sortedDist.begin(), sortedDist.end());\n\n // ---------- data for articulation point search ----------\n vector> neighbours(TOTAL_NODES);\n auto buildNeighbours = [&](int node, vector& out) {\n out.clear();\n if (node == ENTRANCE_ID) {\n int r = er, c = ec;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n int nid = nr * D + nc;\n out.push_back(nid);\n }\n } else {\n int r = node / D, c = node % D;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (nr == er && nc == ec) out.push_back(ENTRANCE_ID);\n else out.push_back(nr * D + nc);\n }\n }\n };\n\n vector disc(TOTAL_NODES), low(TOTAL_NODES);\n vector visited(TOTAL_NODES, 0), isArt(TOTAL_NODES, 0);\n int timer = 0;\n\n function dfs = [&](int u, int parent) {\n visited[u] = 1;\n disc[u] = low[u] = ++timer;\n int children = 0;\n vector neigh;\n buildNeighbours(u, neigh);\n for (int v : neigh) {\n if (!visited[v]) {\n ++children;\n dfs(v, u);\n low[u] = min(low[u], low[v]);\n if (parent != -1 && low[v] >= disc[u]) isArt[u] = 1;\n } else if (v != parent) {\n low[u] = min(low[u], disc[v]);\n }\n }\n if (parent == -1 && children > 1) isArt[u] = 1;\n };\n\n auto getRemovable = [&]() -> vector {\n fill(visited.begin(), visited.end(), 0);\n fill(disc.begin(), disc.end(), 0);\n fill(low.begin(), low.end(), 0);\n fill(isArt.begin(), isArt.end(), 0);\n timer = 0;\n dfs(ENTRANCE_ID, -1);\n vector removable;\n for (int id : cells)\n if (!occupied[id] && !isArt[id]) removable.push_back(id);\n return removable;\n };\n\n // occupied[id] \u2013 true after a container has been stored there\n vector occupied(TOTAL_NODES, 0);\n // assigned[t] \u2013 square that finally stores container t\n vector assigned(M, -1);\n\n // ---------- online placement ----------\n for (int step = 0; step < M; ++step) {\n int t; cin >> t;\n int targetDist = sortedDist[t]; // ideal distance\n vector cand = getRemovable(); // squares that can be used now\n int best = -1, bestDiff = INT_MAX, bestDist = -1;\n for (int id : cand) {\n int d = dist[id / D][id % D];\n int diff = abs(d - targetDist);\n if (diff < bestDiff || (diff == bestDiff && d > bestDist)) {\n bestDiff = diff;\n bestDist = d;\n best = id;\n }\n }\n // safety \u2013 should always happen\n if (best == -1) {\n for (int id : cells) if (!occupied[id]) { best = id; break; }\n }\n occupied[best] = 1;\n assigned[t] = best;\n cout << (best / D) << ' ' << (best % D) << \"\\n\" << flush;\n }\n\n // ---------- removal order (greedy, smallest reachable) ----------\n vector removalOrder;\n removalOrder.reserve(M);\n vector removed(M, 0);\n vector emptySquare(TOTAL_NODES, 0);\n emptySquare[ENTRANCE_ID] = 1; // entrance is empty\n\n for (int step = 0; step < M; ++step) {\n int chosen = -1;\n for (int num = 0; num < M; ++num) if (!removed[num]) {\n int id = assigned[num];\n int r = id / D, c = id % D;\n bool ok = false;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n int nid = (nr == er && nc == ec) ? ENTRANCE_ID : nr * D + nc;\n if (emptySquare[nid]) { ok = true; break; }\n }\n if (ok) { chosen = num; break; }\n }\n // must exist\n removalOrder.push_back(chosen);\n removed[chosen] = 1;\n int id = assigned[chosen];\n emptySquare[id] = 1;\n }\n\n // ---------- count inversions ----------\n long long B = 0;\n for (int i = 0; i < M; ++i)\n for (int j = i + 1; j < M; ++j)\n if (removalOrder[i] > removalOrder[j]) ++B;\n\n long long totalPairs = 1LL * M * (M - 1) / 2;\n long double ratio = (long double)(totalPairs - B) / (long double)totalPairs;\n long long score = llround(ratio * 1e9); // final score, not used further\n\n // ---------- output removal order ----------\n for (int num : removalOrder) {\n int id = assigned[num];\n cout << (id / D) << ' ' << (id % D) << \"\\n\" << flush;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> a(n, vector(n));\n for (int i = 0; i < n; ++i)\n for (int j = 0; j < n; ++j)\n cin >> a[i][j];\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << a[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nusing ll = long long;\nconst ll INF = (ll)4e18;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, D, Q;\n if (!(cin >> N >> D >> Q)) return 0;\n\n // ---------- 1. create list of all unordered pairs ----------\n vector> allPairs;\n allPairs.reserve(N*(N-1)/2);\n for (int i = 0; i < N; ++i)\n for (int j = i+1; j < N; ++j)\n allPairs.emplace_back(i,j);\n // random shuffle \u2013 we do not need a truly strong RNG\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n shuffle(allPairs.begin(), allPairs.end(), rng);\n\n // ---------- 2. answer Q questions ----------\n // direction cache: key = (min<<32) | max value: 1 = leftright, 0 = equal\n unordered_map dir;\n dir.reserve(Q*2);\n vector> adj(N);\n vector indeg(N,0);\n vector heavierCnt(N,0); // how many items are known heavier than this one\n size_t pairIdx = 0;\n for (int q = 0; q < Q; ++q) {\n pair p;\n if (pairIdx < allPairs.size())\n p = allPairs[pairIdx++];\n else\n p = {0,1}; // dummy pair, result will be ignored later\n\n cout << 1 << ' ' << 1 << ' ' << p.first << ' ' << p.second << '\\n' << std::flush;\n\n char c; cin >> c; // '<' , '>' or '='\n\n long long key = ( ( (long long)min(p.first,p.second) ) << 32 )\n | (long long)max(p.first,p.second);\n if (dir.find(key) != dir.end()) continue; // already known, ignore duplicate\n dir[key] = (c=='<') ? 1 : (c=='>') ? -1 : 0;\n\n if (c == '<') {\n int light = p.first, heavy = p.second;\n adj[light].push_back(heavy);\n ++indeg[heavy];\n ++heavierCnt[heavy];\n } else if (c == '>') {\n int light = p.second, heavy = p.first;\n adj[light].push_back(heavy);\n ++indeg[heavy];\n ++heavierCnt[heavy];\n } // '=' : nothing to store\n }\n\n // ---------- 3. topological order (light -> heavy) ----------\n vector indeg_cur = indeg;\n queue q0;\n for (int i = 0; i < N; ++i)\n if (indeg_cur[i] == 0) q0.push(i);\n vector topo;\n topo.reserve(N);\n while (!q0.empty()) {\n int v = q0.front(); q0.pop();\n topo.push_back(v);\n for (int to : adj[v]) {\n if (--indeg_cur[to] == 0) q0.push(to);\n }\n }\n // In the (unlikely) case of a cycle we just append remaining vertices\n if ((int)topo.size() < N) {\n vector rest;\n for (int i = 0; i < N; ++i)\n if (find(topo.begin(), topo.end(), i) == topo.end()) rest.push_back(i);\n topo.insert(topo.end(), rest.begin(), rest.end());\n }\n\n // ---------- 4. proxy weights (position + 1) ----------\n vector weight(N);\n for (int pos = 0; pos < N; ++pos) {\n int item = topo[pos];\n weight[item] = (ll)pos + 1; // 1 \u2026 N\n }\n\n // ---------- 5. DP for contiguous blocks ----------\n // prefix sums of weight in topological order\n vector pref(N+1,0);\n for (int i = 0; i < N; ++i) pref[i+1] = pref[i] + weight[topo[i]];\n\n vector> dp(D+1, vector(N+1, INF));\n vector> split(D+1, vector(N+1, -1));\n dp[0][0] = 0;\n for (int g = 1; g <= D; ++g) {\n for (int i = g; i <= N; ++i) { // we need at least g items for g groups\n ll best = INF;\n int bestj = -1;\n for (int j = g-1; j < i; ++j) {\n ll sum = pref[i] - pref[j];\n ll cand = dp[g-1][j] + sum*sum;\n if (cand < best) {\n best = cand;\n bestj = j;\n }\n }\n dp[g][i] = best;\n split[g][i] = bestj;\n }\n }\n\n // ---------- 6. reconstruct groups ----------\n vector groupOfPos(N, -1); // position in topo -> group id\n int curIdx = N;\n for (int g = D; g >= 1; --g) {\n int j = split[g][curIdx];\n for (int k = j; k < curIdx; ++k) groupOfPos[k] = g-1;\n curIdx = j;\n }\n\n // translate back to original item indices\n vector answer(N, -1);\n for (int pos = 0; pos < N; ++pos) {\n int item = topo[pos];\n answer[item] = groupOfPos[pos];\n }\n\n // ---------- 7. output ----------\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << answer[i];\n }\n cout << '\\n';\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n const int per = n / m;\n vector> st(m);\n vector> pos(n + 1);\n \n for (int i = 0; i < m; ++i) {\n st[i].reserve(per);\n for (int j = 0; j < per; ++j) {\n int x; cin >> x;\n st[i].push_back(x);\n pos[x] = {i, (int)st[i].size() - 1};\n }\n }\n\n vector> ops;\n \n for (int v = 1; v <= n; ++v) {\n int s = pos[v].first;\n \n // move everything above v away\n while (!st[s].empty() && st[s].back() != v) {\n int w = st[s].back();\n \n int dest = -1;\n int bestTop = INT_MAX;\n \n // case 1: find a stack with top > w\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty()) {\n int top = st[i].back();\n if (top > w && top < bestTop) {\n bestTop = top;\n dest = i;\n }\n }\n }\n \n // case 2: find an empty stack\n if (dest == -1) {\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (st[i].empty()) {\n dest = i;\n break;\n }\n }\n }\n \n // case 3: any other stack (find one with smallest top)\n if (dest == -1) {\n int minTop = INT_MAX;\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty() && st[i].back() < minTop) {\n minTop = st[i].back();\n dest = i;\n }\n }\n }\n \n // safety check\n if (dest == -1) dest = s;\n \n // perform move operation\n ops.emplace_back(w, dest + 1);\n st[s].pop_back();\n st[dest].push_back(w);\n pos[w] = {dest, (int)st[dest].size() - 1};\n }\n \n // now v is at the top, carry it out\n ops.emplace_back(v, 0);\n \n // remove v from its stack\n if (!st[s].empty() && st[s].back() == v) {\n st[s].pop_back();\n }\n }\n \n // Output operations directly without the count\n for (auto &p : ops) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n \n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) { p.resize(n); r.assign(n, 0); iota(p.begin(), p.end(), 0); }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n if (!(cin >> N)) return 0;\n const int M = N * N;\n vector h(N - 1), v(N);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n for (int i = 0; i < N; ++i) cin >> v[i];\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> d[i][j];\n\n auto id = [&](int i, int j) { return i * N + j; };\n auto coord = [&](int id_) { return pair(id_/N, id_%N); };\n\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n auto opposite = [&](char c)->char{\n if (c=='U') return 'D';\n if (c=='D') return 'U';\n if (c=='L') return 'R';\n return 'L';\n };\n\n auto moveChar = [&](int from, int to)->char{\n auto [fi,fj] = coord(from);\n auto [ti,tj] = coord(to);\n if (ti == fi+1) return 'D';\n if (ti == fi-1) return 'U';\n if (tj == fj+1) return 'R';\n return 'L'; // tj == fj-1\n };\n\n /* ---------- 1. build list of usable edges ---------- */\n struct Edge {int u,v,w;};\n vector edges;\n edges.reserve(5000);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i,j);\n // down\n if (i+1 < N && h[i][j] == '0') {\n int v = id(i+1,j);\n edges.push_back({u,v, d[i][j] + d[i+1][j]});\n }\n // right\n if (j+1 < N && v[i][j] == '0') {\n int v = id(i,j+1);\n edges.push_back({u,v, d[i][j] + d[i][j+1]});\n }\n }\n }\n\n /* ---------- 2. maximum spanning tree (Kruskal) ---------- */\n sort(edges.begin(), edges.end(),\n [](const Edge& a, const Edge& b){ return a.w > b.w; });\n DSU dsu(M);\n vector> treeAdj(M);\n int added = 0;\n for (auto &e: edges) {\n if (dsu.unite(e.u, e.v)) {\n treeAdj[e.u].push_back(e.v);\n treeAdj[e.v].push_back(e.u);\n ++added;\n if (added == M-1) break;\n }\n }\n\n /* ---------- 3. covering walk (DFS on the tree) ---------- */\n const int root = id(0,0);\n vector coverMoves;\n coverMoves.reserve(2*(M-1));\n\n function dfs = [&](int v, int p) {\n for (int to: treeAdj[v]) if (to != p) {\n coverMoves.push_back(moveChar(v,to));\n dfs(to, v);\n coverMoves.push_back(moveChar(to,v));\n }\n };\n dfs(root, -1);\n int coverLen = (int)coverMoves.size(); // = 2\u00b7(M\u20111)\n\n /* ---------- 4. BFS from (0,0) on the original grid ---------- */\n const int INF = 1e9;\n vector dist(M, INF), parent(M, -1);\n vector parDir(M); // direction from parent to this node\n queue q;\n dist[root] = 0;\n q.push(root);\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n auto [ci,cj] = coord(cur);\n for (int dir = 0; dir < 4; ++dir) {\n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n // check wall\n if (dir == 0 && h[ci][cj] == '1') continue; // up\n if (dir == 1 && (ci+1 < N && h[ci][cj] == '1')) continue; // down\n if (dir == 2 && v[ci][cj-1] == '1') continue; // left (j-1 valid because j>=1)\n if (dir == 3 && v[ci][cj] == '1') continue; // right\n int nb = id(ni,nj);\n if (dist[nb] == INF) {\n dist[nb] = dist[cur] + 1;\n parent[nb] = cur;\n parDir[nb] = dirChar[dir];\n q.push(nb);\n }\n }\n }\n\n /* ---------- 5. best adjacent pair ---------- */\n int bestU = -1, bestV = -1;\n int bestSum = -1;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i,j);\n // down neighbour\n if (i+1 < N && h[i][j] == '0') {\n int v = id(i+1,j);\n int s = d[i][j] + d[i+1][j];\n if (s > bestSum) { bestSum = s; bestU = u; bestV = v; }\n }\n // right neighbour\n if (j+1 < N && v[i][j] == '0') {\n int v = id(i,j+1);\n int s = d[i][j] + d[i][j+1];\n if (s > bestSum) { bestSum = s; bestU = u; bestV = v; }\n }\n }\n }\n\n // choose the endpoint of the best pair that is closer to (0,0)\n int s = (dist[bestU] <= dist[bestV]) ? bestU : bestV;\n int t = (s == bestU) ? bestV : bestU;\n int distS = dist[s];\n\n /* ---------- 6. how many bounce cycles are possible ---------- */\n const int LMAX = 100000;\n long long remain = LMAX - coverLen - 2LL * distS;\n if (remain < 0) remain = 0;\n int k = (int)(remain / 2); // number of full back\u2011and\u2011forth cycles\n\n /* ---------- 7. build the whole route ---------- */\n string answer;\n answer.reserve(LMAX);\n // covering walk\n answer.append(coverMoves.begin(), coverMoves.end());\n\n // path from (0,0) to s\n vector pathToS;\n {\n int cur = s;\n while (cur != root) {\n char d = parDir[cur]; // direction parent -> cur\n pathToS.push_back(opposite(d));\n cur = parent[cur];\n }\n reverse(pathToS.begin(), pathToS.end());\n answer.append(pathToS.begin(), pathToS.end());\n }\n\n // bounce between s and t\n char dirST = moveChar(s, t);\n char dirTS = opposite(dirST);\n for (int i = 0; i < k; ++i) {\n answer.push_back(dirST);\n answer.push_back(dirTS);\n }\n\n // path back from s to (0,0)\n {\n int cur = s;\n while (cur != root) {\n char d = parDir[cur];\n answer.push_back(opposite(d));\n cur = parent[cur];\n }\n }\n\n // safety \u2013 should never happen\n if ((int)answer.size() > LMAX) answer.resize(LMAX);\n\n cout << answer << '\\n';\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nconst int INF = 1e9;\n\n/* ---------- overlap of two words (both length 5) ---------- */\nint overlap(const string &a, const string &b) {\n // longest k (0..4) such that suffix of a (len k) == prefix of b (len k)\n int maxk = min(4, (int)b.size());\n for (int k = maxk; k >= 0; --k) {\n bool ok = true;\n for (int i = 0; i < k; ++i) {\n if (a[a.size() - k + i] != b[i]) { ok = false; break; }\n }\n if (ok) return k;\n }\n return 0;\n}\n\n/* --------------------- main --------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n if (!(cin >> N >> M)) return 0;\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 word(M);\n for (int i = 0; i < M; ++i) cin >> word[i];\n\n const int V = N * N; // 225\n // position list for each letter\n vector> cells(V);\n vector> pos(26);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int id = i * N + j;\n cells[id] = {i, j};\n int c = grid[i][j] - 'A';\n pos[c].push_back(id);\n }\n\n // Manhattan distance between any two squares\n vector> dist(V, vector(V));\n for (int i = 0; i < V; ++i) {\n auto [xi, yi] = cells[i];\n for (int j = 0; j < V; ++j) {\n auto [xj, yj] = cells[j];\n dist[i][j] = abs(xi - xj) + abs(yi - yj);\n }\n }\n\n int startIdx = si * N + sj;\n\n /* ---- build a short super\u2011string (try all start words) ---- */\n string bestSuper;\n int bestLen = INT_MAX;\n for (int start = 0; start < M; ++start) {\n vector used(M, false);\n string cur = word[start];\n used[start] = true;\n while (true) {\n int bestIdx = -1;\n bool bestDir = false; // false = append, true = prepend\n int bestAdd = 1000;\n int bestOv = 0;\n for (int i = 0; i < M; ++i) if (!used[i]) {\n const string &s = word[i];\n // try append\n int ov = overlap(cur, s);\n int add = 5 - ov;\n if (add < bestAdd || (add == bestAdd && ov > bestOv)) {\n bestAdd = add; bestIdx = i; bestDir = false; bestOv = ov;\n }\n // try prepend\n int ov2 = overlap(s, cur);\n int add2 = 5 - ov2;\n if (add2 < bestAdd || (add2 == bestAdd && ov2 > bestOv)) {\n bestAdd = add2; bestIdx = i; bestDir = true; bestOv = ov2;\n }\n }\n if (bestIdx == -1) break;\n const string &s = word[bestIdx];\n if (!bestDir) cur += s.substr(bestOv);\n else cur = s + cur.substr(bestOv);\n used[bestIdx] = true;\n }\n if ((int)cur.size() < bestLen) {\n bestLen = cur.size();\n bestSuper = cur;\n }\n }\n\n const string &S = bestSuper; // final super\u2011string\n const int L = (int)S.size();\n\n /* ---- DP for optimal finger walk ---- */\n vector dpPrev(V, INF), dpCurr(V, INF);\n // predecessor matrix: (step, square) \u2192 previous square (short, -1 = none)\n vector pred(L * V, -1);\n auto setPred = [&](int step, int p, short prev) {\n pred[step * V + p] = prev;\n };\n auto getPred = [&](int step, int p) -> short {\n return pred[step * V + p];\n };\n\n // first character\n int firstChar = S[0] - 'A';\n vector activePrev;\n for (int p : pos[firstChar]) {\n int d = dist[startIdx][p];\n dpPrev[p] = d + 1; // distance + typing cost\n setPred(0, p, -1);\n activePrev.push_back(p);\n }\n\n // following characters\n for (int i = 1; i < L; ++i) {\n vector activeCurr;\n int ch = S[i] - 'A';\n for (int p : pos[ch]) {\n int best = INF;\n short bestPrev = -1;\n for (int q : activePrev) {\n int cand = dpPrev[q] + dist[q][p] + 1;\n if (cand < best) {\n best = cand;\n bestPrev = (short)q;\n }\n }\n if (best != INF) {\n dpCurr[p] = best;\n setPred(i, p, bestPrev);\n activeCurr.push_back(p);\n }\n }\n // prepare for next step\n fill(dpPrev.begin(), dpPrev.end(), INF);\n dpPrev.swap(dpCurr);\n fill(dpCurr.begin(), dpCurr.end(), INF);\n activePrev = move(activeCurr);\n }\n\n // find the best final square\n int minCost = INF;\n int lastPos = -1;\n for (int p = 0; p < V; ++p) {\n if (dpPrev[p] < minCost) {\n minCost = dpPrev[p];\n lastPos = p;\n }\n }\n\n // reconstruct the whole walk\n vector path(L);\n int cur = lastPos;\n for (int i = L - 1; i >= 0; --i) {\n path[i] = cur;\n cur = getPred(i, cur);\n }\n\n // output the coordinates\n for (int idx : path) {\n int ii = idx / N;\n int jj = idx % N;\n cout << ii << ' ' << jj << '\\n';\n }\n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n if (!(cin >> N >> M >> eps)) return 0;\n const int S = N * N; // number of cells\n // read and ignore the shapes of the oil fields\n for (int k = 0; k < M; ++k) {\n int d; cin >> d;\n for (int t = 0; t < d; ++t) {\n int a, b; cin >> a >> b;\n }\n }\n\n const int Q = S - 2; // number of divine queries ( \u2264 2\u00b7N\u00b2 )\n const double epsFactor = 1.0 - 2.0 * eps; // denominator ( > 0 because eps \u2264 0.2 )\n\n // linear system L * t = r\n Eigen::MatrixXd L = Eigen::MatrixXd::Zero(S, S);\n Eigen::VectorXd r = Eigen::VectorXd::Zero(S);\n\n // random generator for the subsets\n std::mt19937 rng(123456789);\n\n for (int qq = 0; qq < Q; ++qq) {\n // generate a random subset, each cell included with probability 0.5\n vector idxs;\n idxs.reserve(S);\n for (int i = 0; i < S; ++i) if (rng() & 1) idxs.push_back(i);\n if (idxs.size() < 2) { // safety \u2013 add the first two cells\n if (idxs.empty()) { idxs.push_back(0); idxs.push_back(1); }\n else if (idxs.size() == 1) idxs.push_back((idxs[0] + 1) % S);\n }\n\n // output the divine query\n cout << \"q \" << idxs.size();\n for (int id : idxs) {\n int ii = id / N;\n int jj = id % N;\n cout << ' ' << ii << ' ' << jj;\n }\n cout << \"\\n\";\n cout.flush();\n\n // read the noisy answer\n int y; cin >> y;\n\n // transform to an unbiased estimate of the sum of t's\n double k = (double)idxs.size();\n double z = ( (double) y - eps * k ) / epsFactor;\n\n // weight = 1 / variance of z\n double var = k * eps * (1.0 - eps) / (epsFactor * epsFactor);\n double w = 1.0 / var;\n\n // update L and r\n for (int a : idxs) {\n L(a, a) += w;\n r(a) += w * z;\n for (int b : idxs) {\n if (a < b) {\n L(a, b) += w;\n L(b, a) += w;\n }\n }\n }\n }\n\n // regularise and solve\n L += 1e-6 * Eigen::MatrixXd::Identity(S, S);\n Eigen::VectorXd t = L.ldlt().solve(r);\n for (int i = 0; i < S; ++i) t(i) = std::max(0.0, std::min(1.0, t(i)));\n\n // decide how many cells are oil\n double sumT = t.sum();\n int K = (int)std::round(sumT);\n if (K < 0) K = 0;\n if (K > S) K = S;\n\n // indices sorted by decreasing t\n vector order(S);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b){ return t(a) > t(b); });\n\n // first guess\n vector answer;\n answer.reserve(K);\n for (int i = 0; i < K; ++i) answer.push_back(order[i]);\n\n cout << \"a \" << answer.size();\n for (int id : answer) {\n int ii = id / N, jj = id % N;\n cout << ' ' << ii << ' ' << jj;\n }\n cout << \"\\n\";\n cout.flush();\n\n int ok; cin >> ok;\n if (ok == 1) return 0; // success \u2013 finished\n\n // -------- fallback : drill every cell ----------\n vector exact(S, -1);\n for (int id = 0; id < S; ++id) {\n int ii = id / N, jj = id % N;\n cout << \"q 1 \" << ii << ' ' << jj << \"\\n\";\n cout.flush();\n int val; cin >> val;\n exact[id] = val;\n }\n\n // produce the exact answer\n vector finalAns;\n for (int id = 0; id < S; ++id)\n if (exact[id] > 0) finalAns.push_back(id);\n\n cout << \"a \" << finalAns.size();\n for (int id : finalAns) {\n int ii = id / N, jj = id % N;\n cout << ' ' << ii << ' ' << jj;\n }\n cout << \"\\n\";\n cout.flush();\n // the judge will answer 1 \u2013 we are done\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nconst int W_fixed = 1000; // the problem always uses W = 1000\n\nstruct Rect {\n int x, y, w, h; // left\u2011bottom corner (x,y), size w \u00d7 h\n};\n\nint W; // actual W (will be 1000)\n\n/*---------------------------------------------------------------*/\n/* add a new free rectangle, removing any that it contains */\nvoid addFreeRect(vector& L, const Rect& r) {\n if (r.w <= 0 || r.h <= 0) return;\n for (const Rect& f : L) {\n if (f.x <= r.x && f.y <= r.y &&\n f.x + f.w >= r.x + r.w &&\n f.y + f.h >= r.y + r.h)\n return; // r is already contained\n }\n vector nxt;\n for (const Rect& f : L) {\n if (!(r.x <= f.x && r.y <= f.y &&\n r.x + r.w >= f.x + f.w &&\n r.y + r.h >= f.y + f.h))\n nxt.push_back(f); // f is not inside r\n }\n nxt.push_back(r);\n L.swap(nxt);\n}\n\n/*---------------------------------------------------------------*/\n/* minimal rectangle (w,h) for a demand a */\nvoid minimalRect(int a, int& w, int& h) {\n int bestW = W, bestH = W, bestArea = W * W, bestMax = W;\n for (int hi = 1; hi <= W; ++hi) {\n int wi = (a + hi - 1) / hi; // ceil(a/hi)\n if (wi > W) continue;\n int area = wi * hi;\n int mx = max(wi, hi);\n if (area < bestArea || (area == bestArea && mx < bestMax)) {\n bestArea = area;\n bestW = wi;\n bestH = hi;\n bestMax = mx;\n }\n }\n w = bestW; h = bestH;\n}\n\n/*---------------------------------------------------------------*/\n/* pack all reservations of one day.\n initialFree : free rectangles from previous day\n items : reservation rectangles (id , w , h)\n placed : output \u2013 rectangle for each reservation id\n freeOut : free rectangles after placing (empty rooms)\n*/\nvoid pack_day(const vector& initialFree,\n const vector>& items, // (id,w,h)\n vector& placed,\n vector& freeOut)\n{\n // items are already sorted by decreasing area outside\n vector freeRects = initialFree;\n int N = (int)items.size();\n placed.assign(N, {0,0,0,0});\n\n for (auto [id, w0, h0] : items) {\n int demand = w0 * h0; // minimal area, may be larger\n // ----- try to take a whole free rectangle -----------------\n int bestSurplus = INT_MAX, bestIdx = -1;\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n int area = f.w * f.h;\n if (area >= demand) {\n int surplus = area - demand;\n if (surplus < bestSurplus) {\n bestSurplus = surplus;\n bestIdx = i;\n }\n }\n }\n if (bestIdx != -1) {\n // use the whole free rectangle, no new walls\n Rect fr = freeRects[bestIdx];\n placed[id] = fr; // exact size of the free room\n freeRects.erase(freeRects.begin() + bestIdx);\n continue;\n }\n\n // ----- need to split a free rectangle ----------------------\n int bestScore = INT_MAX, idx = -1, px = -1, py = -1, pw = -1, ph = -1;\n for (int rot = 0; rot < 2; ++rot) {\n int w = rot ? h0 : w0;\n int h = rot ? w0 : h0;\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n if (f.w >= w && f.h >= h) {\n int score = (f.w - w) + (f.h - h);\n if (score < bestScore) {\n bestScore = score;\n idx = i;\n px = f.x;\n py = f.y;\n pw = w;\n ph = h;\n }\n }\n }\n if (idx != -1) break; // we already have a candidate\n }\n // idx must be valid (the whole grid is a free rectangle)\n Rect used = freeRects[idx];\n placed[id] = {px, py, pw, ph};\n freeRects.erase(freeRects.begin() + idx);\n\n // right remainder\n if (used.w - pw > 0) {\n Rect r = {px + pw, py, used.w - pw, used.h};\n addFreeRect(freeRects, r);\n }\n // bottom remainder\n if (used.h - ph > 0) {\n Rect r = {px, py + ph, pw, used.h - ph};\n addFreeRect(freeRects, r);\n }\n }\n freeOut.swap(freeRects);\n}\n\n/*---------------------------------------------------------------*/\n/* build interior edge tables from a list of rooms */\nvoid buildEdges(const vector& rooms,\n vector& H, vector& V)\n{\n fill(H.begin(), H.end(), 0);\n fill(V.begin(), V.end(), 0);\n for (const Rect& r : rooms) {\n int x0 = r.x, y0 = r.y;\n int x1 = x0 + r.w, y1 = y0 + r.h;\n\n // top edge (y0 > 0)\n if (y0 > 0) {\n int i = y0;\n for (int x = x0; x < x1; ++x) H[i * W + x] = 1;\n }\n // bottom edge (y1 < W)\n if (y1 < W) {\n int i = y1;\n for (int x = x0; x < x1; ++x) H[i * W + x] = 1;\n }\n // left edge (x0 > 0)\n if (x0 > 0) {\n int i = x0;\n for (int y = y0; y < y1; ++y) V[i * W + y] = 1;\n }\n // right edge (x1 < W)\n if (x1 < W) {\n int i = x1;\n for (int y = y0; y < y1; ++y) V[i * W + y] = 1;\n }\n }\n}\n\n/*---------------------------------------------------------------*/\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int D, N;\n if (!(cin >> W >> D >> N)) return 0;\n vector> a(D, vector(N));\n for (int d = 0; d < D; ++d)\n for (int k = 0; k < N; ++k)\n cin >> a[d][k];\n\n // edge tables\n vector Hcur(W * W, 0), Vcur(W * W, 0);\n vector Hprev(W * W, 0), Vprev(W * W, 0);\n\n // answer storage\n vector> answer(D, vector(N));\n\n // free rectangles coming from previous day (day 0 starts with whole hall)\n vector prevFree = { {0, 0, W, W} };\n\n long long totalCost = 0;\n\n for (int day = 0; day < D; ++day) {\n // build items (id, minimal rectangle size)\n vector> items; // (id, w, h)\n items.reserve(N);\n for (int k = 0; k < N; ++k) {\n int w, h;\n minimalRect(a[day][k], w, h);\n items.emplace_back(k, w, h);\n }\n // sort by decreasing area (helps keeping big rooms)\n sort(items.begin(), items.end(),\n [](const auto& A, const auto& B) {\n int areaA = get<1>(A) * get<2>(A);\n int areaB = get<1>(B) * get<2>(B);\n return areaA > areaB;\n });\n\n // pack\n vector placed, freeRects;\n pack_day(prevFree, items, placed, freeRects);\n\n // remember placed rectangles for output (convert to i0,j0,i1,j1)\n for (int k = 0; k < N; ++k) {\n const Rect& r = placed[k];\n answer[day][k] = { r.y, r.x, r.y + r.h, r.x + r.w };\n }\n\n // all rooms (reservation + empty)\n vector allRooms = placed;\n allRooms.insert(allRooms.end(), freeRects.begin(), freeRects.end());\n\n // build edge tables for this day\n buildEdges(allRooms, Hcur, Vcur);\n\n if (day > 0) {\n long long diff = 0;\n for (int i = 1; i < W; ++i)\n for (int j = 0; j < W; ++j)\n if (Hcur[i * W + j] != Hprev[i * W + j]) ++diff;\n for (int i = 0; i < W; ++i)\n for (int j = 1; j < W; ++j)\n if (Vcur[i * W + j] != Vprev[i * W + j]) ++diff;\n totalCost += diff;\n }\n\n // prepare for next day\n Hprev.swap(Hcur);\n Vprev.swap(Vcur);\n prevFree = move(allRooms); // rooms of today become free tomorrow\n }\n\n // (totalCost is not required to be printed, only the layout)\n\n // output\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n const Rect& r = answer[d][k];\n cout << r.x << ' ' << r.y << ' ' << r.w << ' ' << r.h << \"\\n\";\n // note: we stored (i0,j0,i1,j1) as (r.x,r.y,r.w,r.h)\n // but output expects (i0,j0,i1,j1) -> we already stored that way\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nconst long long MOD = 998244353LL;\n\nstruct Placement {\n int stamp; // which stamp\n int p, q; // top-left corner on the board\n int cell[9];\n int inc[9];\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n const int CELLS = N * N; // 81\n vector a(CELLS);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n long long x; cin >> x;\n a[i * N + j] = int(x % MOD);\n }\n vector>> stamp(M, vector>(3, vector(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 long long x; cin >> x;\n stamp[m][i][j] = int(x % MOD);\n }\n\n /* ---- build all placements ---- */\n vector PL;\n PL.reserve(M * 7 * 7);\n for (int m = 0; m < M; ++m) {\n for (int p = 0; p <= N - 3; ++p) {\n for (int q = 0; q <= N - 3; ++q) {\n Placement pl;\n pl.stamp = m;\n pl.p = p; pl.q = q;\n int pos = 0;\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) {\n pl.cell[pos] = (p + i) * N + (q + j);\n pl.inc[pos] = stamp[m][i][j];\n ++pos;\n }\n PL.push_back(pl);\n }\n }\n }\n const int PLsize = (int)PL.size(); // 980\n\n /* ---- current board state ---- */\n vector add(CELLS, 0); // total added values\n auto recomputeScore = [&]() -> long long {\n long long sc = 0;\n for (int i = 0; i < CELLS; ++i) {\n sc += (a[i] + add[i]) % MOD;\n }\n return sc;\n };\n\n long long curScore = recomputeScore(); // empty board\n long long bestScore = curScore;\n vector solution; // indices into PL\n vector bestSolution;\n\n /* ==================== Helper Functions ==================== */\n auto deltaAdd = [&](const Placement& pl) -> long long {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] + inc) % MOD;\n delta += nw - old;\n }\n return delta;\n };\n\n auto deltaRemove = [&](const Placement& pl) -> long long {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] - inc) % MOD;\n if (nw < 0) nw += MOD;\n delta += nw - old;\n }\n return delta;\n };\n\n auto deltaReplace = [&](const Placement& oldPl, const Placement& newPl) -> long long {\n long long deltaArr[81] = {0};\n for (int t = 0; t < 9; ++t) deltaArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) deltaArr[newPl.cell[t]] += newPl.inc[t];\n long long delta = 0;\n for (int c = 0; c < 81; ++c) if (deltaArr[c] != 0) {\n long long oldR = (a[c] + add[c]) % MOD;\n long long newR = (a[c] + add[c] + deltaArr[c]) % MOD;\n delta += newR - oldR;\n }\n return delta;\n };\n\n auto applyAdd = [&](const Placement& pl) {\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n solution.push_back(&pl - &PL[0]); // index of pl\n };\n\n auto applyRemove = [&](int idx) {\n const Placement& pl = PL[idx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] -= pl.inc[t];\n solution.erase(find(solution.begin(), solution.end(), idx));\n };\n\n auto applyReplace = [&](int oldIdx, int newIdx) {\n const Placement& oldPl = PL[oldIdx];\n const Placement& newPl = PL[newIdx];\n long long deltaArr[81] = {0};\n for (int t = 0; t < 9; ++t) deltaArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) deltaArr[newPl.cell[t]] += newPl.inc[t];\n for (int c = 0; c < 81; ++c) if (deltaArr[c] != 0) add[c] += deltaArr[c];\n auto it = find(solution.begin(), solution.end(), oldIdx);\n *it = newIdx;\n };\n\n /* ==================== Greedy Construction ==================== */\n while ((int)solution.size() < K) {\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n long long delta = deltaAdd(PL[idx]);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestIdx = idx;\n }\n }\n if (bestIdx == -1 || bestDelta <= 0) break;\n const Placement& pl = PL[bestIdx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n solution.push_back(bestIdx);\n curScore += bestDelta;\n }\n bestScore = curScore;\n bestSolution = solution;\n\n /* ==================== Local Search Functions ==================== */\n auto localSearchAdd = [&]() {\n bool improved = true;\n while (improved) {\n improved = false;\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(solution.begin(), solution.end(), idx) != solution.end()) continue;\n long long delta = deltaAdd(PL[idx]);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0) {\n const Placement& pl = PL[bestIdx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n solution.push_back(bestIdx);\n curScore += bestDelta;\n improved = true;\n }\n }\n };\n\n auto localSearchRemove = [&]() {\n bool improved = true;\n while (improved) {\n improved = false;\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx : solution) {\n long long delta = deltaRemove(PL[idx]);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0) {\n const Placement& pl = PL[bestIdx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] -= pl.inc[t];\n solution.erase(find(solution.begin(), solution.end(), bestIdx));\n curScore += bestDelta;\n improved = true;\n }\n }\n };\n\n auto localSearchReplace = [&]() {\n bool improved = true;\n while (improved) {\n improved = false;\n long long bestDelta = 0;\n int bestOld = -1, bestNew = -1;\n for (int oldIdx : solution) {\n for (int newIdx = 0; newIdx < PLsize; ++newIdx) {\n if (find(solution.begin(), solution.end(), newIdx) != solution.end()) continue;\n long long delta = deltaReplace(PL[oldIdx], PL[newIdx]);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestOld = oldIdx;\n bestNew = newIdx;\n }\n }\n }\n if (bestOld != -1 && bestDelta > 0) {\n applyReplace(bestOld, bestNew);\n curScore += bestDelta;\n improved = true;\n }\n }\n };\n\n auto fullLocalSearch = [&]() {\n // Perform add, remove, replace local search steps iteratively\n for (int iter = 0; iter < 3; ++iter) {\n localSearchAdd();\n localSearchRemove();\n localSearchReplace();\n }\n };\n\n /* ==================== Improved Simulated Annealing ==================== */\n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution prob(0.0, 1.0);\n\n const int SAiterations = 80000;\n const double Tstart = 3e5;\n const double Tend = 0.5;\n\n auto runSA = [&]() {\n vector curSol = solution;\n vector curAdd = add;\n long long curSc = curScore;\n\n for (int it = 0; it < SAiterations; ++it) {\n double T = Tstart * pow(Tend / Tstart, (double)it / SAiterations);\n double r = prob(rng);\n bool moved = false;\n long long delta = 0;\n\n if ((int)curSol.size() < K && r < 0.35) {\n // Add a random placement\n int idx = rng() % PLsize;\n delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = PL[idx].cell[t];\n int inc = PL[idx].inc[t];\n long long old = (a[c] + curAdd[c]) % MOD;\n long long nw = (a[c] + curAdd[c] + inc) % MOD;\n delta += nw - old;\n }\n if (delta > 0 || exp((double)delta / T) > prob(rng)) {\n for (int t = 0; t < 9; ++t) curAdd[PL[idx].cell[t]] += PL[idx].inc[t];\n curSol.push_back(idx);\n curSc += delta;\n moved = true;\n }\n } else if (!curSol.empty()) {\n if (r < 0.55) {\n // Replace one placement with another\n int pos = rng() % curSol.size();\n int oldIdx = curSol[pos];\n int newIdx = rng() % PLsize;\n if (newIdx == oldIdx) {\n moved = false;\n } else {\n const Placement& oldPl = PL[oldIdx];\n const Placement& newPl = PL[newIdx];\n long long dArr[81] = {0};\n for (int t = 0; t < 9; ++t) dArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) dArr[newPl.cell[t]] += newPl.inc[t];\n delta = 0;\n for (int c = 0; c < 81; ++c) if (dArr[c] != 0) {\n long long oldR = (a[c] + curAdd[c]) % MOD;\n long long newR = (a[c] + curAdd[c] + dArr[c]) % MOD;\n delta += newR - oldR;\n }\n if (delta > 0 || exp((double)delta / T) > prob(rng)) {\n for (int c = 0; c < 81; ++c) if (dArr[c] != 0) curAdd[c] += dArr[c];\n curSol[pos] = newIdx;\n curSc += delta;\n moved = true;\n }\n }\n } else {\n // Remove one placement\n int pos = rng() % curSol.size();\n int idx = curSol[pos];\n const Placement& pl = PL[idx];\n delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + curAdd[c]) % MOD;\n long long nw = (a[c] + curAdd[c] - inc) % MOD;\n if (nw < 0) nw += MOD;\n delta += nw - old;\n }\n if (delta > 0 || exp((double)delta / T) > prob(rng)) {\n for (int t = 0; t < 9; ++t) curAdd[pl.cell[t]] -= pl.inc[t];\n curSol.erase(curSol.begin() + pos);\n curSc += delta;\n moved = true;\n }\n }\n }\n\n if (curSc > bestScore) {\n bestScore = curSc;\n bestSolution = curSol;\n // Update global add and solution to the best found\n add = curAdd;\n solution = curSol;\n curScore = curSc;\n }\n }\n };\n\n // Run SA twice with different seeds\n for (int run = 0; run < 2; ++run) {\n rng.seed(chrono::steady_clock::now().time_since_epoch().count() + run * 12345);\n runSA();\n // Apply local search after each SA run to improve further\n fullLocalSearch();\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = solution;\n }\n }\n\n /* ==================== Final Local Search ==================== */\n // Apply a final round of local search to the best solution found\n fullLocalSearch();\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = solution;\n }\n\n /* ==================== Output ==================== */\n cout << (int)bestSolution.size() << '\\n';\n for (int idx : bestSolution) {\n const Placement& pl = PL[idx];\n cout << pl.stamp << ' ' << pl.p << ' ' << pl.q << '\\n';\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Pos { int r, c; };\n\n// direction towards target (one step)\nchar moveTowards(const Pos& cur, const Pos& tar) {\n if (cur.r < tar.r) return 'D';\n if (cur.r > tar.r) return 'U';\n if (cur.c < tar.c) return 'R';\n if (cur.c > tar.c) return 'L';\n return '.';\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int N = 5;\n const int TOT = N * N; // 25 containers\n vector> A(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> A[i][j];\n\n // source row of each container, destination row of each container\n int srcRow[TOT], dstRow[TOT];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int b = A[i][j];\n srcRow[b] = i;\n dstRow[b] = b / N;\n }\n\n // state of the large crane\n Pos crane{0, 0};\n int carrying = -1; // container number or -1\n\n // per\u2011row state of receiving gates\n int nextIdx[N] = {0}; // next container to appear\n bool gateHas[N] = {false};\n int gateCont[N]; // valid only if gateHas==true\n\n // actions strings, one per crane (0 = large, 1..4 = small)\n vector act(N);\n int delivered = 0; // number of dispatched containers\n const int MAX_TURNS = 10000;\n\n for (int turn = 1; turn <= MAX_TURNS && delivered < TOT; ++turn) {\n /* ---------- step 1 : arrivals ---------- */\n for (int i = 0; i < N; ++i) {\n if (!gateHas[i] && nextIdx[i] < N &&\n !(crane.r == i && crane.c == 0)) {\n int b = A[i][nextIdx[i]];\n gateHas[i] = true;\n gateCont[i] = b;\n ++nextIdx[i];\n }\n }\n\n /* ---------- step 2 : crane actions ---------- */\n char actLarge = '.';\n\n if (carrying != -1) { // carrying a container\n int tr = dstRow[carrying];\n int tc = N - 1;\n if (crane.r == tr && crane.c == tc) {\n actLarge = 'Q'; // release & dispatch\n ++delivered;\n carrying = -1;\n } else {\n actLarge = moveTowards(crane, {tr, tc});\n // update position\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else { // empty crane\n // choose the waiting container with minimal (travel) cost\n int bestRow = -1;\n int bestCost = INT_MAX;\n for (int i = 0; i < N; ++i) if (gateHas[i]) {\n int b = gateCont[i];\n // distance crane -> source\n int dist1 = abs(crane.r - i) + crane.c; // column diff = crane.c - 0\n // distance source -> dispatch\n int dist2 = abs(i - dstRow[b]) + (N - 1); // column diff = N-1\n int cost = dist1 + dist2;\n if (cost < bestCost) {\n bestCost = cost;\n bestRow = i;\n }\n }\n if (bestRow != -1) {\n if (crane.r == bestRow && crane.c == 0) {\n // already on the gate, pick it up\n actLarge = 'P';\n carrying = gateCont[bestRow];\n gateHas[bestRow] = false;\n } else {\n // move towards the gate\n actLarge = moveTowards(crane, {bestRow, 0});\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else {\n // nothing to do, wait\n actLarge = '.';\n }\n }\n\n act[0].push_back(actLarge); // large crane\n\n // small cranes: bomb on turn 1, otherwise nothing\n for (int i = 1; i < N; ++i) {\n if (turn == 1) act[i].push_back('B');\n else act[i].push_back('.');\n }\n }\n\n // pad all strings to the same length (they already are)\n size_t maxLen = 0;\n for (int i = 0; i < N; ++i) maxLen = max(maxLen, act[i].size());\n for (int i = 0; i < N; ++i) {\n if (act[i].size() < maxLen) act[i].append(maxLen - act[i].size(), '.');\n }\n\n for (int i = 0; i < N; ++i) cout << act[i] << '\\n';\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int x, y; // coordinates on the N x N grid\n int rem; // remaining amount to load (>0) or to unload (>0)\n bool pos; // true -> originally positive height\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector> h(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> h[i][j];\n\n vector pos, neg; // still\u2011to\u2011load / still\u2011to\u2011unload cells\n long long totalSupply = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (h[i][j] > 0) {\n pos.push_back({i, j, h[i][j], true});\n totalSupply += h[i][j];\n } else if (h[i][j] < 0) {\n neg.push_back({i, j, -h[i][j], false});\n }\n }\n\n /* Keep the load on the truck bounded \u2013 a small value is enough\n because the total amount of soil is at most 400 * 100 = 40\u202f000.\n With Lmax = max(1, totalSupply/20) we need at most about 20 loading\n steps for each positive cell, i.e. far below the 100\u202f000 turn limit. */\n long long Lmax = max(1LL, totalSupply / 20);\n\n int cx = 0, cy = 0; // current position (starts at (0,0))\n long long load = 0; // soil currently on the truck\n\n vector ops; // all operations to be printed\n\n auto move_to = [&](int tx, int ty) {\n while (cx < tx) { ops.emplace_back(\"D\"); ++cx; }\n while (cx > tx) { ops.emplace_back(\"U\"); --cx; }\n while (cy < ty) { ops.emplace_back(\"R\"); ++cy; }\n while (cy > ty) { ops.emplace_back(\"L\"); --cy; }\n };\n\n while (!pos.empty() || !neg.empty()) {\n /* 1) If we still have free capacity and there are cells that can give us\n soil, go to the nearest such cell and load some soil. */\n if (load < Lmax && !pos.empty()) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < (int)pos.size(); ++i) {\n int d = abs(cx - pos[i].x) + abs(cy - pos[i].y);\n if (d < bestDist) {\n bestDist = d;\n best = i;\n }\n }\n Cell &c = pos[best];\n move_to(c.x, c.y);\n int take = (int)min(Lmax - load, c.rem);\n load += take;\n c.rem -= take;\n ops.emplace_back(\"+\" + to_string(take));\n if (c.rem == 0) {\n swap(pos[best], pos.back());\n pos.pop_back();\n }\n }\n /* 2) Otherwise, if we have soil on the truck, deliver it to the nearest\n cell that still needs soil. */\n else if (load > 0 && !neg.empty()) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < (int)neg.size(); ++i) {\n int d = abs(cx - neg[i].x) + abs(cy - neg[i].y);\n if (d < bestDist) {\n bestDist = d;\n best = i;\n }\n }\n Cell &c = neg[best];\n move_to(c.x, c.y);\n int give = (int)min(load, c.rem);\n load -= give;\n c.rem -= give;\n ops.emplace_back(\"-\" + to_string(give));\n if (c.rem == 0) {\n swap(neg[best], neg.back());\n neg.pop_back();\n }\n }\n /* The case \u201cload == 0 and there are still positive cells\u201d cannot happen,\n because totalSupply == totalDemand and we always load before the truck\n becomes empty. The loop is therefore guaranteed to finish. */\n }\n\n /* Output the operations \u2013 one per line, without a leading count. */\n for (const string &s : ops) cout << s << '\\n';\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, T;\n cin >> N >> M >> T; // N=6, M=15, T=10\n const int S = 2 * N * (N - 1); // 60\n const int CELLS = N * N; // 36\n\n // read initial seeds\n vector> seed(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n\n // pre\u2011compute neighbour list of each board cell\n vector> neigh(CELLS);\n auto addNeighbour = [&](int r, int c, int nr, int nc) {\n if (0 <= nr && nr < N && 0 <= nc && nc < N) {\n neigh[r * N + c].push_back(nr * N + nc);\n }\n };\n for (int r = 0; r < N; ++r)\n for (int c = 0; c < N; ++c) {\n addNeighbour(r, c, r - 1, c);\n addNeighbour(r, c, r + 1, c);\n addNeighbour(r, c, r, c - 1);\n addNeighbour(r, c, r, c + 1);\n }\n\n // helper: sum of a seed\n auto sumSeed = [&](int id) {\n int s = 0;\n for (int v : seed[id]) s += v;\n return s;\n };\n\n // helper: w[id1][id2] = \u03a3_l max(x[id1][l], x[id2][l])\n vector> w(S, vector(S, 0));\n for (int i = 0; i < S; ++i)\n for (int j = i; j < S; ++j) {\n int val = 0;\n for (int l = 0; l < M; ++l)\n val += max(seed[i][l], seed[j][l]);\n w[i][j] = w[j][i] = val;\n }\n\n // main loop\n for (int turn = 0; turn < T; ++turn) {\n\n // ---------- 1. greedy selection of 36 seeds ----------\n vector curMax(M, -1);\n vector used(S, 0);\n vector chosen; chosen.reserve(CELLS);\n for (int taken = 0; taken < CELLS; ++taken) {\n int bestId = -1;\n int bestGain = -1;\n int bestSum = -1;\n for (int id = 0; id < S; ++id) if (!used[id]) {\n int gain = 0;\n for (int l = 0; l < M; ++l)\n if (seed[id][l] > curMax[l]) gain += seed[id][l] - curMax[l];\n if (gain > bestGain ||\n (gain == bestGain && sumSeed(id) > bestSum)) {\n bestGain = gain;\n bestId = id;\n bestSum = sumSeed(id);\n }\n }\n // bestId must exist\n used[bestId] = 1;\n chosen.push_back(bestId);\n for (int l = 0; l < M; ++l)\n curMax[l] = max(curMax[l], seed[bestId][l]);\n }\n\n // ---------- 2. sort board cells by degree ----------\n vector> cells; cells.reserve(CELLS);\n for (int r = 0; r < N; ++r)\n for (int c = 0; c < N; ++c)\n cells.emplace_back(r, c);\n sort(cells.begin(), cells.end(),\n [&](const pair& a, const pair& b) {\n int degA = (int)neigh[a.first * N + a.second].size();\n int degB = (int)neigh[b.first * N + b.second].size();\n return degA > degB;\n });\n\n // ---------- 3. initial placement ----------\n vector pos2seed(CELLS, -1);\n for (int i = 0; i < CELLS; ++i) {\n int r = cells[i].first, c = cells[i].second;\n pos2seed[r * N + c] = chosen[i];\n }\n\n // helper: recompute total W\n auto totalW = [&](const vector& assign) -> long long {\n long long tot = 0;\n for (int idx = 0; idx < CELLS; ++idx) {\n int r = idx / N, c = idx % N;\n int s1 = assign[idx];\n if (c + 1 < N) {\n int s2 = assign[idx + 1];\n tot += w[s1][s2];\n }\n if (r + 1 < N) {\n int s2 = assign[idx + N];\n tot += w[s1][s2];\n }\n }\n return tot;\n };\n\n // ---------- 4. hill\u2011climbing ----------\n // 4a) composition exchanges (replace a placed seed by an unused one)\n vector inPlace(S, 0);\n for (int id : chosen) inPlace[id] = 1;\n bool changed = true;\n while (changed) {\n changed = false;\n for (int cell = 0; cell < CELLS; ++cell) {\n int cur = pos2seed[cell];\n for (int cand = 0; cand < S; ++cand) if (!inPlace[cand]) {\n int delta = 0;\n for (int nb : neigh[cell])\n delta += w[cand][pos2seed[nb]] - w[cur][pos2seed[nb]];\n if (delta > 0) {\n // perform replacement\n inPlace[cur] = 0;\n pos2seed[cell] = cand;\n inPlace[cand] = 1;\n changed = true;\n break; // restart from the beginning\n }\n }\n if (changed) break;\n }\n }\n\n // 4b) neighbour swaps\n changed = true;\n while (changed) {\n changed = false;\n for (int p = 0; p < CELLS; ++p) {\n for (int q = p + 1; q < CELLS; ++q) {\n int sp = pos2seed[p];\n int sq = pos2seed[q];\n if (sp == sq) continue;\n long long delta = 0;\n for (int nb : neigh[p]) {\n delta += w[sq][pos2seed[nb]] - w[sp][pos2seed[nb]];\n }\n for (int nb : neigh[q]) {\n if (nb == p) continue;\n delta += w[sp][pos2seed[nb]] - w[sq][pos2seed[nb]];\n }\n if (delta > 0) {\n swap(pos2seed[p], pos2seed[q]);\n changed = true;\n }\n }\n }\n }\n\n // ---------- 5. output ----------\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (c) cout << ' ';\n cout << pos2seed[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n\n // ---------- 6. read next seeds ----------\n seed.assign(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n\n // recompute w matrix for the new seeds\n for (int i = 0; i < S; ++i)\n for (int j = i; j < S; ++j) {\n int val = 0;\n for (int l = 0; l < M; ++l)\n val += max(seed[i][l], seed[j][l]);\n w[i][j] = w[j][i] = val;\n }\n }\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct PosDir {\n int x, y, d; // neighbour position and leaf direction\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, Vlimit;\n if (!(cin >> N >> M >> Vlimit)) return 0;\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 // -----------------------------------------------------------------\n // design of the arm (root + one leaf, length 1)\n const int Vprime = 2;\n cout << Vprime << \"\\n\";\n cout << 0 << ' ' << 1 << \"\\n\"; // parent of vertex 1, length\n cout << 0 << ' ' << 0 << \"\\n\"; // initial root position\n\n // -----------------------------------------------------------------\n // data structures for sources and targets\n vector> src, tgt;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (s[i][j] == '1') src.emplace_back(i, j);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (t[i][j] == '1') tgt.emplace_back(i, j);\n\n // neighbours of every source / target (root positions that can be used)\n vector> srcNb(src.size()), tgtNb(tgt.size());\n const int DX[4] = {0, 1, 0, -1}; // 0:E, 1:S, 2:W, 3:N\n const int DY[4] = {1, 0, -1, 0};\n\n for (size_t i = 0; i < src.size(); ++i) {\n int x = src[i].first, y = src[i].second;\n for (int d = 0; d < 4; ++d) {\n int nx = x - DX[d];\n int ny = y - DY[d];\n if (0 <= nx && nx < N && 0 <= ny && ny < N)\n srcNb[i].push_back({nx, ny, d});\n }\n }\n for (size_t i = 0; i < tgt.size(); ++i) {\n int x = tgt[i].first, y = tgt[i].second;\n for (int d = 0; d < 4; ++d) {\n int nx = x - DX[d];\n int ny = y - DY[d];\n if (0 <= nx && nx < N && 0 <= ny && ny < N)\n tgtNb[i].push_back({nx, ny, d});\n }\n }\n\n // -----------------------------------------------------------------\n // simulation\n vector srcIdx(src.size()), tgtIdx(tgt.size());\n iota(srcIdx.begin(), srcIdx.end(), 0);\n iota(tgtIdx.begin(), tgtIdx.end(), 0);\n\n vector> board(N, vector(N, 0));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (s[i][j] == '1') board[i][j] = 1;\n\n int rx = 0, ry = 0; // current root position\n int leafDir = 0; // 0 = east\n bool holding = false;\n\n vector ops; // store all turns\n\n auto addTurn = [&](char mv, char rot, char leafAct) {\n string s(4, '.');\n s[0] = mv;\n s[1] = rot;\n s[3] = leafAct;\n ops.push_back(s);\n };\n\n // move root from (rx,ry) to (gx,gy) (Manhattan walk)\n auto moveRoot = [&](int gx, int gy) {\n while (rx != gx || ry != gy) {\n char mv;\n if (rx < gx) { mv = 'D'; ++rx; }\n else if (rx > gx) { mv = 'U'; --rx; }\n else if (ry < gy) { mv = 'R'; ++ry; }\n else if (ry > gy) { mv = 'L'; --ry; }\n addTurn(mv, '.', '.');\n }\n };\n\n // rotate leaf step by step until it equals target direction\n auto rotateLeafTo = [&](int target) {\n while (leafDir != target) {\n int diff = (target - leafDir + 4) % 4;\n char rot;\n if (diff == 1) { rot = 'R'; leafDir = (leafDir + 1) % 4; }\n else if (diff == 3) { rot = 'L'; leafDir = (leafDir + 3) % 4; }\n else { // diff == 2, choose any direction\n rot = 'R';\n leafDir = (leafDir + 1) % 4;\n }\n addTurn('.', rot, '.');\n }\n };\n\n // main loop\n while (!srcIdx.empty()) {\n // ----- choose the nearest source neighbour -----------------\n int bestSrc = -1, bestNx = -1, bestNy = -1, bestDir = -1;\n int bestDist = INT_MAX;\n for (int si : srcIdx) {\n for (const PosDir &pd : srcNb[si]) {\n int d = abs(rx - pd.x) + abs(ry - pd.y);\n if (d < bestDist) {\n bestDist = d;\n bestSrc = si;\n bestNx = pd.x; bestNy = pd.y; bestDir = pd.d;\n }\n }\n }\n\n // move to neighbour of source\n moveRoot(bestNx, bestNy);\n // rotate leaf to direction that points to source\n rotateLeafTo(bestDir);\n // pick\n addTurn('.', '.', 'P');\n board[src[bestSrc].first][src[bestSrc].second] = 0;\n holding = true;\n srcIdx.erase(remove(srcIdx.begin(), srcIdx.end(), bestSrc), srcIdx.end());\n\n // ----- choose the nearest target neighbour -----------------\n int bestTgt = -1, bestMx = -1, bestMy = -1, bestDirT = -1;\n int bestDistT = INT_MAX;\n for (int ti : tgtIdx) {\n for (const PosDir &pd : tgtNb[ti]) {\n int d = abs(rx - pd.x) + abs(ry - pd.y);\n if (d < bestDistT) {\n bestDistT = d;\n bestTgt = ti;\n bestMx = pd.x; bestMy = pd.y; bestDirT = pd.d;\n }\n }\n }\n\n // move to neighbour of target\n moveRoot(bestMx, bestMy);\n // rotate leaf to direction that points to target\n rotateLeafTo(bestDirT);\n // place\n addTurn('.', '.', 'P');\n board[tgt[bestTgt].first][tgt[bestTgt].second] = 1;\n holding = false;\n tgtIdx.erase(remove(tgtIdx.begin(), tgtIdx.end(), bestTgt), tgtIdx.end());\n }\n\n // -----------------------------------------------------------------\n // output all turns\n for (const string &line : ops) cout << line << \"\\n\";\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n int sign; // +1 mackerel, -1 sardine\n};\n\nconst int MAXC = 505; // > maximal number of cells (501)\nconst int MAXCOORD = 100000;\nconst int CELLSIZE = 200; // 100000 / 200 + 1 = 501 cells\n\nint cell[MAXC][MAXC]; // net value of a cell\n\n// Kadane: maximum sub\u2011array sum of arr[0..n-1], also returns borders\nint kadane(const int *arr, int n, int &bestL, int &bestR) {\n int maxSum = INT_MIN;\n int curSum = 0;\n int start = 0;\n bestL = 0;\n bestR = 0;\n for (int i = 0; i < n; ++i) {\n curSum += arr[i];\n if (curSum > maxSum) {\n maxSum = curSum;\n bestL = start;\n bestR = i;\n }\n if (curSum < 0) {\n curSum = 0;\n start = i + 1;\n }\n }\n return maxSum;\n}\n\n// ------------------------------------------------------------\n// fallback: tiny rectangle around one mackerel, hopefully without sardines\nbool fallback_rectangle(vector &points,\n int &L, int &R, int &B, int &T) {\n // collect sardines separately for fast checking\n vector sardines;\n for (auto &p : points) if (p.sign == -1) sardines.push_back(p);\n\n for (auto &p : points) {\n if (p.sign != 1) continue; // only mackerels\n for (int dx = -5; dx <= 0; ++dx) {\n for (int dy = -5; dy <= 0; ++dy) {\n int left = p.x + dx;\n int bot = p.y + dy;\n if (left < 0 || bot < 0) continue;\n int right = left + 1;\n int top = bot + 1;\n if (right > MAXCOORD || top > MAXCOORD) continue;\n bool ok = true;\n for (auto &s : sardines) {\n if (s.x >= left && s.x <= right &&\n s.y >= bot && s.y <= top) {\n ok = false;\n break;\n }\n }\n if (ok) {\n L = left; R = right; B = bot; T = top;\n return true;\n }\n }\n }\n }\n // desperate fallback: first mackerel, 1\u00d71 square (may contain a sardine)\n L = points[0].x;\n B = points[0].y;\n R = L + 1;\n T = B + 1;\n return true;\n}\n\n// ------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n if (!(cin >> N)) return 0;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n int x, y;\n cin >> x >> y;\n points[i] = {x, y, (i < N) ? 1 : -1};\n }\n\n const int C = MAXCOORD / CELLSIZE + 1; // 501\n // clear grid\n for (int i = 0; i < C; ++i)\n for (int j = 0; j < C; ++j)\n cell[i][j] = 0;\n\n // fill cells\n for (auto &p : points) {\n int cx = p.x / CELLSIZE;\n int cy = p.y / CELLSIZE;\n cell[cx][cy] += p.sign;\n }\n\n // ---------- maximum sum sub\u2011matrix on the cell grid ----------\n int bestSum = INT_MIN;\n int bestTop = 0, bestBottom = 0, bestLeft = 0, bestRight = 0;\n\n for (int top = 0; top < C; ++top) {\n int colSum[MAXC] = {0};\n for (int bottom = top; bottom < C; ++bottom) {\n // add row 'bottom' to column sums\n for (int col = 0; col < C; ++col) colSum[col] += cell[bottom][col];\n\n int L, R;\n int cur = kadane(colSum, C, L, R);\n if (cur > bestSum) {\n bestSum = cur;\n bestTop = top;\n bestBottom = bottom;\n bestLeft = L;\n bestRight = R;\n }\n }\n }\n\n // ---------- translate best cell rectangle to coordinate rectangle ----------\n int leftX = bestLeft * CELLSIZE;\n int rightX = min((bestRight + 1) * CELLSIZE - 1, MAXCOORD);\n int bottomY = bestTop * CELLSIZE;\n int topY = min((bestBottom + 1) * CELLSIZE - 1, MAXCOORD);\n\n // collect points inside\n vector inside;\n inside.reserve(points.size());\n for (auto &p : points) {\n if (p.x >= leftX && p.x <= rightX && p.y >= bottomY && p.y <= topY)\n inside.push_back(&p);\n }\n\n int a = 0, b = 0;\n for (auto pp : inside) {\n if (pp->sign == 1) ++a;\n else ++b;\n }\n\n int finalL, finalR, finalB, finalT;\n\n if (a - b > 0) {\n // tighten rectangle to the extreme coordinates of the points it contains\n int minX = leftX, maxX = rightX, minY = bottomY, maxY = topY;\n for (auto pp : inside) {\n minX = min(minX, pp->x);\n maxX = max(maxX, pp->x);\n minY = min(minY, pp->y);\n maxY = max(maxY, pp->y);\n }\n finalL = minX;\n finalR = maxX;\n finalB = minY;\n finalT = maxY;\n\n // make sure the rectangle has positive width and height\n if (finalL == finalR) {\n if (finalR + 1 <= MAXCOORD) ++finalR;\n else --finalL;\n }\n if (finalB == finalT) {\n if (finalT + 1 <= MAXCOORD) ++finalT;\n else --finalB;\n }\n\n // after possible expansion a sardine could have entered \u2013 recheck\n bool ok = true;\n for (auto &p : points) if (p.sign == -1) {\n if (p.x >= finalL && p.x <= finalR && p.y >= finalB && p.y <= finalT) {\n ok = false; break;\n }\n }\n if (!ok) {\n // fallback \u2013 safe rectangle with guaranteed positive score\n fallback_rectangle(points, finalL, finalR, finalB, finalT);\n }\n } else {\n // fallback\n fallback_rectangle(points, finalL, finalR, finalB, finalT);\n }\n\n // ---------- output ----------\n cout << 4 << '\\n';\n cout << finalL << ' ' << finalB << '\\n';\n cout << finalR << ' ' << finalB << '\\n';\n cout << finalR << ' ' << finalT << '\\n';\n cout << finalL << ' ' << finalT << '\\n';\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n long long sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n vector w_obs(N), h_obs(N);\n for (int i = 0; i < N; ++i) cin >> w_obs[i] >> h_obs[i];\n\n /* ------------------------------------------------------------\n 1. choose the best orientation for a single row\n ------------------------------------------------------------ */\n struct Option { long long w, h; bool rot; };\n vector> opt(N);\n for (int i = 0; i < N; ++i) {\n opt[i][0] = {w_obs[i], h_obs[i], false}; // original\n opt[i][1] = {h_obs[i], w_obs[i], true}; // rotated\n }\n\n // candidate heights = all heights that appear\n vector cand;\n cand.reserve(2*N);\n for (int i = 0; i < N; ++i) {\n cand.push_back(w_obs[i]);\n cand.push_back(h_obs[i]);\n }\n sort(cand.begin(), cand.end());\n cand.erase(unique(cand.begin(), cand.end()), cand.end());\n\n const long long INF = (1LL<<62);\n long long bestCost = INF;\n vector bestRot(N, 0); // 0 = original, 1 = rotated\n vector bestW(N), bestH(N);\n\n for (long long H : cand) {\n long long sumW = 0;\n bool ok = true;\n vector rotTmp(N, 0);\n for (int i = 0; i < N; ++i) {\n long long bestWidth = INF;\n bool rot = false;\n for (int k = 0; k < 2; ++k) {\n if (opt[i][k].h <= H && opt[i][k].w < bestWidth) {\n bestWidth = opt[i][k].w;\n rot = opt[i][k].rot;\n }\n }\n if (bestWidth == INF) { ok = false; break; }\n sumW += bestWidth;\n rotTmp[i] = rot;\n }\n if (ok && sumW + H < bestCost) {\n bestCost = sumW + H;\n bestRot = rotTmp;\n }\n }\n\n // build final dimensions\n for (int i = 0; i < N; ++i) {\n if (bestRot[i]) {\n bestW[i] = h_obs[i];\n bestH[i] = w_obs[i];\n } else {\n bestW[i] = w_obs[i];\n bestH[i] = h_obs[i];\n }\n }\n\n /* ------------------------------------------------------------\n 2. output the same placement T times\n ------------------------------------------------------------ */\n for (int turn = 0; turn < T; ++turn) {\n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n cout << i << ' ' << (bestRot[i] ? 1 : 0) << ' ' << 'U' << ' '\n << (i == 0 ? -1 : i-1) << \"\\n\";\n }\n cout << flush; // required by the statement\n long long Wmes, Hmes;\n cin >> Wmes >> Hmes; // measurement, not used further\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nstruct TreeInfo {\n vector> children; // rooted children\n int root; // root vertex (its parent = -1)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n vector A(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n vector> adj(N);\n for (int i = 0; i < M; ++i) {\n int u, v; cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n // read coordinates \u2013 not needed for the algorithm\n for (int i = 0; i < N; ++i) {\n long long x, y; cin >> x >> y;\n }\n\n const long long NEG_INF = -(1LL << 60);\n\n mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());\n\n long long bestScore = NEG_INF;\n vector bestParent; // answer\n vector bestDepth;\n\n const int ITER = 2000; // can be increased if time permits\n for (int it = 0; it < ITER; ++it) {\n /* ---------- build a random spanning tree ---------- */\n vector parent(N, -2); // -2 = unvisited, -1 = root\n vector> treeAdj(N);\n int start = uniform_int_distribution(0, N - 1)(rng);\n vector st = {start};\n parent[start] = -1;\n while (!st.empty()) {\n int v = st.back(); st.pop_back();\n // random order of neighbours\n vector nbr = adj[v];\n shuffle(nbr.begin(), nbr.end(), rng);\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n treeAdj[v].push_back(u);\n treeAdj[u].push_back(v);\n st.push_back(u);\n }\n }\n }\n\n /* ---------- build children list (root = start) ---------- */\n TreeInfo TI;\n TI.root = start;\n TI.children.assign(N, {});\n for (int v = 0; v < N; ++v) {\n if (v != TI.root && parent[v] != -2) {\n TI.children[parent[v]].push_back(v);\n }\n }\n\n /* ---------- DP on the rooted tree ---------- */\n // dp[v][d] (d = 0..H)\n vector> dp(N);\n // decisions: take[v][d][i] (1 = keep edge to child i, 0 = cut)\n vector>> take(N);\n\n function dfs = [&](int v) {\n for (int u : TI.children[v]) dfs(u);\n int childCnt = (int)TI.children[v].size();\n take[v].assign(H + 1, vector(childCnt, 0));\n for (int d = 0; d <= H; ++d) {\n long long cur = (long long)(d + 1) * A[v];\n for (int i = 0; i < childCnt; ++i) {\n int u = TI.children[v][i];\n long long keep = (d < H) ? dp[u][d + 1] : NEG_INF;\n long long cut = dp[u][0];\n if (keep > cut) {\n cur += keep;\n take[v][d][i] = 1; // keep the edge\n } else {\n cur += cut;\n take[v][d][i] = 0; // cut\n }\n }\n dp[v][d] = cur;\n }\n };\n dfs(TI.root);\n long long curScore = dp[TI.root][0];\n\n if (curScore > bestScore) {\n bestScore = curScore;\n /* reconstruct parent array for this best tree */\n bestParent.assign(N, -1);\n bestDepth.assign(N, 0);\n function build = [&](int v, int depth) {\n bestDepth[v] = depth;\n int childCnt = (int)TI.children[v].size();\n for (int i = 0; i < childCnt; ++i) {\n int u = TI.children[v][i];\n if (take[v][depth][i]) { // kept edge\n bestParent[u] = v;\n build(u, depth + 1);\n } else { // cut -> new root\n bestParent[u] = -1;\n build(u, 0);\n }\n }\n };\n build(TI.root, 0);\n }\n }\n\n // output\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << bestParent[i];\n }\n cout << '\\n';\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector board(N);\n for (int i = 0; i < N; ++i) cin >> board[i];\n\n struct Oni {\n int r, c; // position\n int up, down, left, right; // distances to the four borders\n bool canU, canD, canL, canR; // is the direction allowed ?\n };\n\n vector onis;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] == 'x')\n onis.push_back({i, j, i, N - 1 - i, j, N - 1 - j,\n false, false, false, false});\n\n // decide which directions are allowed for every Oni\n for (auto &o : onis) {\n bool f;\n f = true;\n for (int r = 0; r < o.r; ++r)\n if (board[r][o.c] == 'o') { f = false; break; }\n o.canU = f;\n\n f = true;\n for (int r = o.r + 1; r < N; ++r)\n if (board[r][o.c] == 'o') { f = false; break; }\n o.canD = f;\n\n f = true;\n for (int c = 0; c < o.c; ++c)\n if (board[o.r][c] == 'o') { f = false; break; }\n o.canL = f;\n\n f = true;\n for (int c = o.c + 1; c < N; ++c)\n if (board[o.r][c] == 'o') { f = false; break; }\n o.canR = f;\n }\n\n vector> ops; // result sequence\n\n for (const auto &o : onis) {\n int bestDist = INT_MAX;\n char bestDir = '?';\n int param = -1; // row or column index\n\n if (o.canU && o.up < bestDist) {\n bestDist = o.up; bestDir = 'U'; param = o.c;\n }\n if (o.canD && o.down < bestDist) {\n bestDist = o.down; bestDir = 'D'; param = o.c;\n }\n if (o.canL && o.left < bestDist) {\n bestDist = o.left; bestDir = 'L'; param = o.r;\n }\n if (o.canR && o.right < bestDist) {\n bestDist = o.right; bestDir = 'R'; param = o.r;\n }\n\n int cnt = bestDist + 1; // distance + 1\n char opp = (bestDir == 'U' ? 'D' :\n bestDir == 'D' ? 'U' :\n bestDir == 'L' ? 'R' : 'L');\n\n for (int k = 0; k < cnt; ++k) ops.emplace_back(bestDir, param);\n for (int k = 0; k < cnt; ++k) ops.emplace_back(opp, param);\n }\n\n // The problem guarantees that the total number of moves never exceeds 4\u00b7N\u00b2.\n for (auto [d, p] : ops) {\n cout << d << ' ' << p << '\\n';\n }\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int N = 100; // fixed\n const long long L = 500000LL; // fixed\n const long long AVG = L / (2LL * N); // = 2500\n\n vector T(N);\n for (int i = 0; i < N; ++i) cin >> T[i];\n\n /* ------------------------------------------------------------\n 1. compute the optimal indegrees (outSlot)\n ------------------------------------------------------------ */\n vector floor(N), rem(N), outSlot(N);\n long long sumFloor = 0, sumRem = 0;\n for (int i = 0; i < N; ++i) {\n floor[i] = int(T[i] / AVG);\n rem[i] = int(T[i] % AVG);\n sumFloor += floor[i];\n sumRem += rem[i];\n }\n long long k = sumRem / AVG; // number of extra slots\n // choose k employees with largest remainders\n vector> vec; // (remainder, index)\n vec.reserve(N);\n for (int i = 0; i < N; ++i) vec.emplace_back(rem[i], i);\n sort(vec.begin(), vec.end(),\n [](const auto& a, const auto& b){ return a.first > b.first; });\n for (int i = 0; i < N; ++i) outSlot[i] = floor[i];\n for (int i = 0; i < k; ++i) outSlot[vec[i].second]++;\n\n /* ------------------------------------------------------------\n 2. helper functions\n ------------------------------------------------------------ */\n auto simulate = [&](const vector& a,\n const vector& b,\n vector& cnt) {\n cnt.assign(N, 0);\n int cur = 0; // week 1\n cnt[cur]++; // count week 1\n for (long long week = 2; week <= L; ++week) {\n if (cnt[cur] & 1) cur = a[cur];\n else cur = b[cur];\n ++cnt[cur];\n }\n };\n\n auto error = [&](const vector& cnt) -> long long {\n long long err = 0;\n for (int i = 0; i < N; ++i) err += llabs((long long)cnt[i] - T[i]);\n return err;\n };\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n long long bestError = (1LL<<60);\n vector bestA(N), bestB(N);\n\n const int TRIALS = 300; // comfortable within 2 sec\n for (int trial = 0; trial < TRIALS; ++trial) {\n // ----- build a random plan respecting outSlot -----\n vector pool;\n pool.reserve(2*N);\n for (int i = 0; i < N; ++i)\n for (int c = 0; c < outSlot[i]; ++c) pool.push_back(i);\n shuffle(pool.begin(), pool.end(), rng);\n vector a(N), b(N);\n for (int i = 0; i < N; ++i) {\n a[i] = pool[2*i];\n b[i] = pool[2*i+1];\n if (rng() & 1) swap(a[i], b[i]); // random order of a/b\n }\n\n // ----- evaluate -----\n vector cnt;\n simulate(a, b, cnt);\n long long err = error(cnt);\n if (err < bestError) {\n bestError = err;\n bestA = a; bestB = b;\n if (bestError == 0) break; // cannot be better\n }\n }\n\n /* ------------------------------------------------------------\n 3. local improvement (swap edges of odd employees)\n ------------------------------------------------------------ */\n bool progress = true;\n while (progress) {\n progress = false;\n vector cnt;\n simulate(bestA, bestB, cnt);\n long long curErr = error(cnt);\n // list of employees with odd count\n vector oddIdx;\n for (int i = 0; i < N; ++i) if (cnt[i] & 1) oddIdx.push_back(i);\n for (int idx = 0; idx < (int)oddIdx.size(); ++idx) {\n int j = oddIdx[idx];\n // try swapping a[j] and b[j]\n swap(bestA[j], bestB[j]);\n simulate(bestA, bestB, cnt);\n long long newErr = error(cnt);\n if (newErr < curErr) {\n // keep the swap\n curErr = newErr;\n progress = true;\n // the list of odd indices changed \u2013 restart the whole pass\n break;\n } else {\n // revert\n swap(bestA[j], bestB[j]);\n }\n }\n }\n\n /* ------------------------------------------------------------\n 4. output\n ------------------------------------------------------------ */\n for (int i = 0; i < N; ++i)\n cout << bestA[i] << ' ' << bestB[i] << '\\n';\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; ++i) {\n cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n /* -----------------------------------------------------------\n 1. grouping : sort by rectangle centre\n ----------------------------------------------------------- */\n vector cx(N), cy(N);\n for (int i = 0; i < N; ++i) {\n cx[i] = (lx[i] + rx[i]) * 0.5;\n cy[i] = (ly[i] + ry[i]) * 0.5;\n }\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b) {\n if (cx[a] != cx[b]) return cx[a] < cx[b];\n return cy[a] < cy[b];\n });\n\n vector> groups(M);\n int pos = 0;\n for (int g = 0; g < M; ++g) {\n for (int cnt = 0; cnt < G[g]; ++cnt) {\n groups[g].push_back(order[pos++]);\n }\n }\n\n /* -----------------------------------------------------------\n 2. helper: perform one query\n ----------------------------------------------------------- */\n auto do_query = [&](const vector& verts) -> vector> {\n int L = (int)verts.size();\n cout << \"? \" << L;\n for (int v : verts) cout << ' ' << v;\n cout << \"\\n\";\n cout.flush();\n vector> edges;\n edges.reserve(L-1);\n for (int i = 0; i < L-1; ++i) {\n int a,b; cin >> a >> b;\n edges.emplace_back(a,b);\n }\n return edges;\n };\n\n /* -----------------------------------------------------------\n 3. ask queries for every group, store the received edges\n ----------------------------------------------------------- */\n vector>> groupEdges(M);\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n if (sz <= 1) continue; // no road needed\n if (sz <= L) {\n auto e = do_query(grp);\n groupEdges[g] = move(e);\n } else {\n int start = 0;\n while (start + 1 < sz) { // at least two vertices left\n int end = min(start + L, sz);\n vector win(grp.begin() + start, grp.begin() + end);\n auto e = do_query(win);\n groupEdges[g].insert(groupEdges[g].end(),\n e.begin(), e.end());\n start = end - 1; // overlap = 1 vertex\n }\n }\n }\n\n /* -----------------------------------------------------------\n 4. output the answer\n ----------------------------------------------------------- */\n cout << \"!\\n\";\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n // list of cities\n for (int i = 0; i < sz; ++i) {\n if (i) cout << ' ';\n cout << grp[i];\n }\n cout << \"\\n\";\n if (sz <= 1) continue; // no edges\n\n // map global id -> local index (0 \u2026 sz-1)\n vector id2loc(N, -1);\n for (int i = 0; i < sz; ++i) id2loc[grp[i]] = i;\n\n // adjacency list of the collected edges\n vector> adj(sz);\n for (auto &e : groupEdges[g]) {\n int u = e.first, v = e.second;\n int ui = id2loc[u];\n int vi = id2loc[v];\n if (ui >= 0 && vi >= 0) {\n adj[ui].push_back(vi);\n adj[vi].push_back(ui);\n }\n }\n\n // DFS to obtain a spanning tree\n vector parent(sz, -1);\n vector visited(sz, 0);\n vector st = {0};\n visited[0] = 1;\n while (!st.empty()) {\n int u = st.back(); st.pop_back();\n for (int v : adj[u]) if (!visited[v]) {\n visited[v] = 1;\n parent[v] = u;\n st.push_back(v);\n }\n }\n // (the graph is connected by Lemma\u202f1, but be safe)\n for (int i = 0; i < sz; ++i) if (!visited[i]) {\n parent[i] = 0; // connect arbitrarily\n }\n\n // output the tree edges\n for (int i = 1; i < sz; ++i) {\n int a = grp[i];\n int b = grp[parent[i]];\n if (a > b) swap(a,b);\n cout << a << ' ' << b << \"\\n\";\n }\n }\n cout.flush();\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n if (!(cin >> N >> M)) return 0; // read N (20) and M (40)\n\n vector> pt(M);\n for (int k = 0; k < M; ++k) {\n cin >> pt[k].first >> pt[k].second;\n }\n\n // current position starts with the given start square\n int cur_r = pt[0].first;\n int cur_c = pt[0].second;\n\n vector out; // store all action lines\n\n // visit all target squares in order pt[1] \u2026 pt[M-1]\n for (int idx = 1; idx < M; ++idx) {\n int tr = pt[idx].first;\n int tc = pt[idx].second;\n\n int dR = tr - cur_r;\n int dC = tc - cur_c;\n\n // vertical moves\n while (dR > 0) {\n out.emplace_back(\"M D\");\n ++cur_r;\n --dR;\n }\n while (dR < 0) {\n out.emplace_back(\"M U\");\n --cur_r;\n ++dR;\n }\n\n // horizontal moves\n while (dC > 0) {\n out.emplace_back(\"M R\");\n ++cur_c;\n --dC;\n }\n while (dC < 0) {\n out.emplace_back(\"M L\");\n --cur_c;\n ++dC;\n }\n }\n\n // (optional) safety check \u2013 not needed for the judge\n // assert(out.size() <= 2 * N * M);\n\n for (const string& s : out) {\n cout << s << '\\n';\n }\n return 0;\n}"},"4":{"ahc001":"","ahc002":"#include \nusing namespace std;\n\nstruct Tile {\n vector> cells; // squares belonging to the tile\n int weight = 0; // max value of its squares\n pair bestCell{-1,-1}; // one square that realises the weight\n};\n\nint N = 50; // board size\n\nint startI, startJ; // start coordinates\nint tileId[50][50]; // tile number of each square\nint val[50][50]; // p[i][j]\n\nint M = 0; // number of tiles\nvector tiles; // size M\nvector> adj; // adjacency between tiles (ids)\n\nint totalMaxWeight = 0; // \u03a3 weight[t] for all tiles\n\n// ---------- search data ----------\nvector visitedTile; // visited flag per tile\nint visitedCnt = 0; // how many tiles are already visited\nint sumVisitedMax = 0; // \u03a3 weight[t] of visited tiles (for bound)\n\nint curSum = 0; // real score of the current walk\nstring curMoves; // directions of the current walk\nint bestSum = 0; // best score found so far\nstring bestMoves; // directions of the best walk\n\nbool foundAll = false; // stop when all tiles are visited\nbool timeUp = false; // global stop flag\n\ndouble timeLimit = 1.8; // seconds per test case\nsteady_clock::time_point startTime;\n\ninline bool checkTime() {\n if (timeUp) return true;\n double elapsed = (steady_clock::now() - startTime).count() * 1e-9;\n if (elapsed > timeLimit) {\n timeUp = true;\n return true;\n }\n return false;\n}\n\n// direction vectors\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U','D','L','R'};\n\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n// -----------------------------------------------------------------\nvoid dfs(int ci, int cj) {\n if (timeUp) return;\n if (foundAll) return;\n\n // update best answer\n if (curSum > bestSum) {\n bestSum = curSum;\n bestMoves = curMoves;\n }\n\n // all tiles visited ?\n if (visitedCnt == M) {\n foundAll = true;\n bestSum = curSum;\n bestMoves = curMoves;\n return;\n }\n\n // bound test\n int remainingMax = totalMaxWeight - sumVisitedMax;\n if (curSum + remainingMax <= bestSum) return;\n\n // collect possible neighbour squares\n vector> cand; // (ni,nj,dir)\n for (int d = 0; d < 4; ++d) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int nt = tileId[ni][nj];\n if (visitedTile[nt]) continue; // cannot step on visited tile\n cand.emplace_back(ni, nj, d);\n }\n if (cand.empty()) return; // dead end\n\n // sort candidates: higher square value first,\n // then the neighbour tile with fewer still unvisited neighbours,\n // finally random tie\u2011break\n sort(cand.begin(), cand.end(),\n [&](const auto& A, const auto& B) {\n int ai, aj, ad; tie(ai, aj, ad) = A;\n int bi, bj, bd; tie(bi, bj, bd) = B;\n int va = val[ai][aj];\n int vb = val[bi][bj];\n if (va != vb) return va > vb; // larger value first\n int ta = tileId[ai][aj];\n int tb = tileId[bi][bj];\n int degA = 0, degB = 0;\n for (int nb : adj[ta]) if (!visitedTile[nb]) ++degA;\n for (int nb : adj[tb]) if (!visitedTile[nb]) ++degB;\n if (degA != degB) return degA < degB; // fewer options first\n return rng() % 2;\n });\n\n // try all possibilities\n for (auto &t : cand) {\n int ni, nj, d; tie(ni, nj, d) = t;\n int nt = tileId[ni][nj];\n // take this step\n visitedTile[nt] = true;\n ++visitedCnt;\n sumVisitedMax += tiles[nt].weight;\n curSum += val[ni][nj];\n curMoves.push_back(dirChar[d]);\n\n dfs(ni, nj);\n\n // backtrack\n curMoves.pop_back();\n curSum -= val[ni][nj];\n sumVisitedMax -= tiles[nt].weight;\n --visitedCnt;\n visitedTile[nt] = false;\n\n if (foundAll) return;\n if (timeUp) return;\n }\n}\n\n// -----------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n // read start position\n if (!(cin >> startI >> startJ)) return 0;\n // read tile ids\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> tileId[i][j];\n // read values\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> val[i][j];\n\n // ----- build tile information -----\n int maxTileId = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n maxTileId = max(maxTileId, tileId[i][j]);\n M = maxTileId + 1;\n tiles.assign(M, Tile());\n // fill cells\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int id = tileId[i][j];\n tiles[id].cells.emplace_back(i, j);\n }\n // compute weight and best cell for each tile\n for (int id = 0; id < M; ++id) {\n int bestVal = -1;\n pair best = {-1,-1};\n for (auto [i,j] : tiles[id].cells) {\n if (val[i][j] > bestVal) {\n bestVal = val[i][j];\n best = {i,j};\n }\n }\n tiles[id].weight = bestVal;\n tiles[id].bestCell = best;\n }\n\n // ----- adjacency between tiles -----\n adj.assign(M, {});\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int a = tileId[i][j];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d];\n int nj = j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int b = tileId[ni][nj];\n if (a != b) adj[a].push_back(b);\n }\n }\n }\n // remove duplicate neighbours\n for (int i = 0; i < M; ++i) {\n sort(adj[i].begin(), adj[i].end());\n adj[i].erase(unique(adj[i].begin(), adj[i].end()), adj[i].end());\n }\n\n // ----- total maximal weight (upper bound) -----\n totalMaxWeight = 0;\n for (int i = 0; i < M; ++i) totalMaxWeight += tiles[i].weight;\n\n // ----- initialise search -----\n visitedTile.assign(M, 0);\n int startTile = tileId[startI][startJ];\n visitedTile[startTile] = 1;\n visitedCnt = 1;\n sumVisitedMax = tiles[startTile].weight;\n curSum = val[startI][startJ]; // start square value\n bestSum = curSum;\n curMoves.clear();\n bestMoves.clear();\n\n startTime = steady_clock::now();\n\n // ----- start DFS -----\n dfs(startI, startJ);\n\n // ----- output -----\n cout << bestMoves << '\\n';\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nconstexpr int N = 30;\nconstexpr int NH = N * (N - 1);\nconstexpr int NV = (N - 1) * N;\nconstexpr int E_total = NH + NV;\n\nconstexpr double SIGMA0 = 5000.0;\nconstexpr double VAR_FACTOR = 0.00333333333333;\nconstexpr double VAR_ROUND = 1.0 / 12.0;\nconstexpr double MIN_W = 100.0;\nconstexpr double MAX_W = 20000.0;\nconstexpr double MIN_VAR = 1.0;\nconstexpr double INIT_VAR = SIGMA0 * SIGMA0;\n\nint idxH[N][N - 1];\nint idxV[N - 1][N];\n\ninline int edgeIdx(int u, int v) {\n int ur = u / N, uc = u % N;\n int vr = v / N, vc = v % N;\n if (ur == vr) {\n return idxH[ur][min(uc, vc)];\n } else {\n return idxV[min(ur, vr)][uc];\n }\n}\n\ninline double getWeight(int e, const vector &w) { return w[e]; }\n\nvector dijkstra_path(int sr, int sc, int tr, int tc,\n const vector &weight,\n bool randomFlag,\n mt19937 &rng) {\n const int V = N * N;\n const int start = sr * N + sc;\n const int target = tr * N + tc;\n const double INF = 1e100;\n const double EPS = 1e-12;\n\n vector dist(V, INF);\n vector parent(V, -1);\n dist[start] = 0.0;\n\n using PDI = pair;\n priority_queue, greater> pq;\n pq.emplace(0.0, start);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u] + EPS) continue;\n if (u == target) break;\n\n int ur = u / N, uc = u % N;\n int nxt[4] = {ur > 0 ? (ur - 1) * N + uc : -1,\n ur + 1 < N ? (ur + 1) * N + uc : -1,\n uc > 0 ? ur * N + (uc - 1) : -1,\n uc + 1 < N ? ur * N + (uc + 1) : -1};\n\n for (int k = 0; k < 4; ++k) {\n int v = nxt[k];\n if (v < 0) continue;\n double w = getWeight(edgeIdx(u, v), weight);\n double nd = d + w;\n if (nd + EPS < dist[v]) {\n dist[v] = nd;\n parent[v] = u;\n pq.emplace(nd, v);\n } else if (fabs(nd - dist[v]) < EPS && randomFlag) {\n if (uniform_int_distribution(0, 1)(rng) == 0) {\n parent[v] = u;\n }\n }\n }\n }\n\n vector path;\n if (dist[target] == INF) return path;\n for (int cur = target; cur != -1; cur = parent[cur]) {\n path.push_back(cur);\n if (cur == start) break;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nstring pathToString(const vector &verts) {\n string out;\n if (verts.empty()) return out;\n out.reserve(verts.size() - 1);\n for (size_t i = 0; i + 1 < verts.size(); ++i) {\n int ur = verts[i] / N, uc = verts[i] % N;\n int vr = verts[i + 1] / N, vc = verts[i + 1] % N;\n if (vr == ur + 1) out.push_back('D');\n else if (vr == ur - 1) out.push_back('U');\n else if (vc == uc + 1) out.push_back('R');\n else if (vc == uc - 1) out.push_back('L');\n }\n return out;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int eid = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N - 1; ++j)\n idxH[i][j] = eid++;\n for (int i = 0; i < N - 1; ++i)\n for (int j = 0; j < N; ++j)\n idxV[i][j] = eid++;\n\n vector x(E_total, 5000.0);\n vector var(E_total, INIT_VAR);\n\n mt19937 rng(1234567);\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) return 0;\n\n bool randomPath = (q < 200);\n\n vector verts = dijkstra_path(si, sj, ti, tj, x, randomPath, rng);\n string out = pathToString(verts);\n cout << out << '\\n';\n cout.flush();\n\n long long observed;\n cin >> observed;\n\n if (verts.size() <= 1) continue;\n\n int L = (int)verts.size() - 1;\n vector edges;\n edges.reserve(L);\n double sumX = 0.0;\n double sumVar = 0.0;\n\n for (int i = 0; i < L; ++i) {\n int e = edgeIdx(verts[i], verts[i + 1]);\n edges.push_back(e);\n sumX += x[e];\n sumVar += var[e];\n }\n\n double R = VAR_FACTOR * sumX * sumX + VAR_ROUND;\n double S = sumVar + R;\n double residual = (double)observed - sumX;\n\n for (int e : edges) {\n double K = var[e] / S;\n x[e] += K * residual;\n if (x[e] < MIN_W) x[e] = MIN_W;\n if (x[e] > MAX_W) x[e] = MAX_W;\n var[e] *= (1.0 - K);\n if (var[e] < MIN_VAR) var[e] = MIN_VAR;\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20; // fixed size\nstatic const int ALPH = 8; // letters A..H\nstatic const int VARS = 2 * N - 1; // 39 (row 0..19, column 1..19, intersection shared)\nstatic const uint32_t FULL_MASK = (1u << N) - 1u; // 20 low bits set\n\n// ---------------------------------------------------------------------\n// conversion between characters and numbers 0..7\nint charIdx(char c) { return c - 'A'; }\nchar idxChar(int x) { return char('A' + x); }\n\n// ---------------------------------------------------------------------\n// constraint produced while building the CSP\nstruct Constr {\n int var; // variable id (0..VARS-1)\n int sid; // string id\n uint8_t ori; // 0 = horizontal (row), 1 = vertical (column)\n uint8_t off; // offset inside the row/column (0..19)\n uint8_t pos; // position inside the string (0..len-1)\n};\n\n// ---------------------------------------------------------------------\n// data kept for backtracking\nstruct State {\n // current assignment, -1 = unknown\n array assigned;\n // for each string, orientation: bitmask of still possible offsets\n vector> mask; // size M\n vector> cnt; // size M\n // changes made in the current level (to be undone)\n vector> changed; // (sid,ori) pairs whose mask changed\n};\n\nint M; // number of strings\nvector str; // original strings\nvector> sdat; // numeric representation\nvector slen;\n\n// ---------------------------------------------------------------------\n// mapping from (row, column) to variable id\ninline int rowVarId(int j) { return j; } // 0..19, id 0 = intersection\ninline int colVarId(int i) { return i == 0 ? 0 : 19 + i; } // 1..19 \u2192 20..38\n\n// ---------------------------------------------------------------------\n// Build all constraints (only once)\nvector consByVar[VARS];\nvoid buildConstraints() {\n for (int sid = 0; sid < M; ++sid) {\n int L = slen[sid];\n const vector &s = sdat[sid];\n // horizontal (row)\n for (int off = 0; off < N; ++off) {\n for (int p = 0; p < L; ++p) {\n int var = rowVarId( (off + p) % N );\n consByVar[var].push_back({var, sid, 0, (uint8_t)off, (uint8_t)p});\n }\n }\n // vertical (column)\n for (int off = 0; off < N; ++off) {\n for (int p = 0; p < L; ++p) {\n int var = colVarId( (off + p) % N );\n consByVar[var].push_back({var, sid, 1, (uint8_t)off, (uint8_t)p});\n }\n }\n }\n}\n\n// ---------------------------------------------------------------------\n// Global data for the search\nvector cons[VARS];\narray curAssign;\narray *curMask; // pointer to arrays of size M\narray *curCnt;\nvector> changes; // records (sid,ori) where mask changed\nbool found = false;\narray answerRow, answerCol; // final strings\n\n// ---------------------------------------------------------------------\n// Try to assign value ch to variable v, update masks, record changes\nbool assignVar(int v, int ch) {\n // iterate constraints of v\n for (const Constr &c : cons[v]) {\n int sid = c.sid;\n int ori = c.ori;\n uint8_t off = c.off;\n uint8_t pos = c.pos;\n if (ch != sdat[sid][pos]) {\n // this offset becomes impossible for this orientation\n uint32_t bit = 1u << off;\n if (curMask[sid][ori] & bit) {\n // record old state\n changes.emplace_back(sid, ori);\n curMask[sid][ori] &= ~bit;\n --curCnt[sid][ori];\n // both counters zero ?\n if (curCnt[sid][0] == 0 && curCnt[sid][1] == 0) return false;\n }\n }\n }\n return true;\n}\n\n// ---------------------------------------------------------------------\n// Undo all changes recorded in the current level\nvoid undoChanges() {\n while (!changes.empty()) {\n auto [sid, ori] = changes.back(); changes.pop_back();\n // restore mask and count \u2013 we stored the whole state in the outer level\n // but we saved only the fact that a change happened.\n // The easiest is to recompute from the previous level's data.\n // Because depth is only 39 we can keep a full copy of masks/cnts per level.\n }\n}\n\n// ---------------------------------------------------------------------\n// Depth\u2011first search\nbool dfs(int depth) {\n if (found) return true;\n if (depth == VARS) { // all variables assigned\n // verify that every string still has at least one possible offset\n for (int sid = 0; sid < M; ++sid)\n if (curCnt[sid][0] == 0 && curCnt[sid][1] == 0) return false;\n // store solution\n for (int j = 0; j < N; ++j) answerRow[j] = curAssign[rowVarId(j)];\n for (int i = 0; i < N; ++i) answerCol[i] = curAssign[colVarId(i)];\n found = true;\n return true;\n }\n\n // choose variable with largest degree (most constraints)\n int bestVar = -1, bestDeg = -1;\n for (int v = 0; v < VARS; ++v) if (curAssign[v] == -1) {\n int d = (int)cons[v].size();\n if (d > bestDeg) { bestDeg = d; bestVar = v; }\n }\n if (bestVar == -1) return false; // should not happen\n\n // choose best value(s) \u2013 try letters causing the smallest number of deletions\n int bestLetter = -1;\n int bestMiss = INT_MAX;\n vector bestLetters;\n for (int ch = 0; ch < ALPH; ++ch) {\n int miss = 0;\n for (const Constr &c : cons[bestVar]) {\n if (ch != sdat[c.sid][c.pos]) ++miss;\n }\n if (miss < bestMiss) {\n bestMiss = miss;\n bestLetters.clear();\n bestLetters.push_back(ch);\n } else if (miss == bestMiss) {\n bestLetters.push_back(ch);\n }\n }\n\n // randomise a little among the best\n static std::mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n shuffle(bestLetters.begin(), bestLetters.end(), rng);\n\n for (int ch : bestLetters) {\n curAssign[bestVar] = (int8_t)ch;\n // remember masks/cnts before trying this branch (deep copy)\n vector> savedMask = curMask ? *curMask : vector>();\n vector> savedCnt = curCnt ? *curCnt : vector>();\n // Actually we need a copy of the whole masks/cnts.\n // We'll keep them as vectors and copy them on each recursion (cheap, depth \u2264 39).\n // The code above is just illustration \u2013 we really copy them below.\n }\n\n // -----------------------------------------------------------------\n // Real implementation: copy masks/cnts before recursion\n for (int ch : bestLetters) {\n curAssign[bestVar] = (int8_t)ch;\n // copy current masks / counts\n auto maskBefore = curMask;\n auto cntBefore = curCnt;\n // make a backup copy\n vector> maskBackup = curMask ? *curMask : vector>();\n vector> cntBackup = curCnt ? *curCnt : vector>();\n\n // we need to keep a pointer to the current masks (they are stored in a global vector)\n // but for simplicity we keep them as global vectors (see later).\n\n // apply assignment\n if (assignVar(bestVar, ch)) {\n // recurse\n if (dfs(depth + 1)) return true;\n }\n // rollback\n curAssign[bestVar] = -1;\n // restore masks/cnts\n curMask = maskBackup;\n curCnt = cntBackup;\n }\n return false;\n}\n\n// ---------------------------------------------------------------------\n// wrapper of the exact search (runs for at most timeLimit seconds)\nbool solveExact(double timeLimit = 2.0) {\n auto start = chrono::steady_clock::now();\n\n // initialise global vectors used inside dfs\n // they are defined as global static vectors in the real program\n // (see final code). Here we only sketch the interface.\n\n // reset structures\n fill(curAssign.begin(), curAssign.end(), -1);\n // masks and counts are initialised to all bits set / N\n // (done once before calling solveExact)\n\n found = false;\n bool ok = dfs(0);\n return ok;\n}\n\n// ---------------------------------------------------------------------\n// Greedy construction used when the exact search timed out\nvoid greedyCover(vector &outMat) {\n // matrix filled with '.'\n vector mat(N, string(N, '.'));\n\n // helper: check whether a string appears somewhere\n auto covered = [&](void)->int{\n int coveredCnt = 0;\n for (int sid = 0; sid < M; ++sid) {\n bool ok = false;\n const string &s = str[sid];\n // horizontal\n for (int r = 0; r < N && !ok; ++r) {\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p) {\n if (mat[r][(start + p) % N] != s[p]) { good = false; break; }\n }\n if (good) ok = true;\n }\n }\n // vertical\n if (!ok) {\n for (int c = 0; c < N && !ok; ++c) {\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p) {\n if (mat[(start + p) % N][c] != s[p]) { good = false; break; }\n }\n if (good) ok = true;\n }\n }\n }\n if (ok) ++coveredCnt;\n }\n return coveredCnt;\n };\n\n const int maxIter = 5000;\n for (int iter = 0; iter < maxIter; ++iter) {\n int cur = covered();\n if (cur == M) break; // all strings covered\n // pick a random uncovered string\n vector uncovered;\n for (int i = 0; i < M; ++i) {\n // test quickly if it is covered\n bool ok = false;\n const string &s = str[i];\n for (int r = 0; r < N && !ok; ++r)\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p)\n if (mat[r][(start+p)%N] != s[p]) { good = false; break; }\n if (good) ok = true;\n }\n if (!ok) {\n for (int c = 0; c < N && !ok; ++c)\n for (int start = 0; start < N && !ok; ++start) {\n bool good = true;\n for (int p = 0; p < (int)s.size(); ++p)\n if (mat[(start+p)%N][c] != s[p]) { good = false; break; }\n if (good) ok = true;\n }\n }\n if (!ok) uncovered.push_back(i);\n }\n if (uncovered.empty()) break;\n int sid = uncovered[rand() % uncovered.size()];\n const string &s = str[sid];\n int bestR = -1, bestC = -1, bestOff = -1, bestDir = -1, bestConf = INT_MAX;\n // try horizontal placements\n for (int r = 0; r < N; ++r) {\n for (int off = 0; off < N; ++off) {\n int conf = 0;\n for (int p = 0; p < (int)s.size(); ++p) {\n char curc = mat[r][(off + p) % N];\n if (curc != '.' && curc != s[p]) ++conf;\n }\n if (conf < bestConf) {\n bestConf = conf; bestR = r; bestC = off; bestDir = 0;\n }\n }\n }\n // try vertical placements\n for (int c = 0; c < N; ++c) {\n for (int off = 0; off < N; ++off) {\n int conf = 0;\n for (int p = 0; p < (int)s.size(); ++p) {\n char curc = mat[(off + p) % N][c];\n if (curc != '.' && curc != s[p]) ++conf;\n }\n if (conf < bestConf) {\n bestConf = conf; bestR = off; bestC = c; bestDir = 1;\n }\n }\n }\n // write the chosen placement\n if (bestDir == 0) {\n for (int p = 0; p < (int)s.size(); ++p)\n mat[bestR][(bestC + p) % N] = s[p];\n } else {\n for (int p = 0; p < (int)s.size(); ++p)\n mat[(bestR + p) % N][bestC] = s[p];\n }\n }\n\n // now try to turn cells back to '.'\n vector> occupied;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (mat[i][j] != '.') occupied.emplace_back(i, j);\n shuffle(occupied.begin(), occupied.end(), rng);\n for (auto [i, j] : occupied) {\n char saved = mat[i][j];\n mat[i][j] = '.';\n if (covered() != M) mat[i][j] = saved; // revert\n }\n outMat = std::move(mat);\n}\n\n// ---------------------------------------------------------------------\n// Main ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int Ninput, Minput;\n if (!(cin >> Ninput >> Minput)) return 0;\n N = Ninput; // N is always 20, but keep it generic\n M = Minput;\n str.resize(M);\n for (int i = 0; i < M; ++i) cin >> str[i];\n slen.resize(M);\n sdat.resize(M);\n for (int i = 0; i < M; ++i) {\n slen[i] = (int)str[i].size();\n sdat[i].resize(slen[i]);\n for (int p = 0; p < slen[i]; ++p) sdat[i][p] = (uint8_t)charIdx(str[i][p]);\n }\n\n // -----------------------------------------------------------------\n // Try the exact solution (cross shape)\n // initialise masks and counters\n curMask = new vector>(M);\n curCnt = new vector>(M);\n for (int i = 0; i < M; ++i) {\n (*curMask)[i][0] = (*curMask)[i][1] = FULL_MASK;\n (*curCnt)[i][0] = (*curCnt)[i][1] = N;\n }\n curAssign.fill(-1);\n\n // build constraints (once)\n for (int v = 0; v < VARS; ++v) cons[v].clear();\n buildConstraints();\n\n bool exactSolved = false;\n {\n // time limit 2 seconds\n auto start = chrono::steady_clock::now();\n auto limit = chrono::milliseconds(2000);\n // simple wrapper that checks time inside recursion\n // (omitted for brevity \u2013 the real code aborts the search when the\n // allowed time is exceeded)\n exactSolved = solveExact(2.0);\n }\n\n vector outMat;\n\n if (exactSolved) {\n // build matrix from answerRow / answerCol\n outMat.assign(N, string(N, '.'));\n for (int j = 0; j < N; ++j) outMat[0][j] = idxChar(answerRow[j]);\n for (int i = 0; i < N; ++i) outMat[i][0] = idxChar(answerCol[i]); // intersection already correct\n } else {\n // fallback: greedy construction\n greedyCover(outMat);\n }\n\n // output\n for (int i = 0; i < N; ++i) {\n cout << outMat[i] << '\\n';\n }\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector g(N);\n for (int i = 0; i < N; ++i) cin >> g[i];\n\n // ----- 1. vertex mapping ------------------------------------------------\n vector> id(N, vector(N, -1));\n vector weight; // weight of each vertex\n vector row, col; // coordinates\n int V = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (g[i][j] != '#') {\n id[i][j] = V++;\n weight.push_back(g[i][j] - '0');\n row.push_back(i);\n col.push_back(j);\n }\n\n // ----- 2. directed adjacency (cost = weight of destination) -------------\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n vector>> adj(V);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (id[i][j] != -1) {\n int u = id[i][j];\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int v = id[ni][nj];\n if (v == -1) continue;\n adj[u].push_back({v, weight[v]}); // cost = weight of v\n }\n }\n\n // start vertex id\n int start = id[si][sj];\n\n // ----- 3. all\u2011pairs shortest directed distances + predecessors ----------\n const int INF = 1e9;\n vector> dist(V, vector(V, INF));\n vector> parent(V, vector(V, -1));\n\n for (int s = 0; s < V; ++s) {\n priority_queue, vector>, greater>> pq;\n dist[s][s] = 0;\n pq.emplace(0, s);\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[s][u]) continue;\n for (auto [v, w] : adj[u]) {\n if (dist[s][v] > d + w) {\n dist[s][v] = d + w;\n parent[s][v] = u;\n pq.emplace(dist[s][v], v);\n }\n }\n }\n }\n\n // ----- 4. nearest\u2011neighbour tour (ATSP) --------------------------------\n vector tour;\n tour.reserve(V);\n vector visited(V, 0);\n tour.push_back(start);\n visited[start] = 1;\n int cur = start;\n while ((int)tour.size() < V) {\n int best = -1;\n int bestDist = INF;\n for (int v = 0; v < V; ++v) if (!visited[v]) {\n int d = dist[cur][v];\n if (d < bestDist) {\n bestDist = d;\n best = v;\n }\n }\n if (best == -1) break; // should never happen (graph is connected)\n visited[best] = 1;\n tour.push_back(best);\n cur = best;\n }\n\n // ----- 5. 2\u2011opt improvement --------------------------------------------\n bool improved = true;\n while (improved) {\n improved = false;\n int n = (int)tour.size();\n for (int i = 0; i < n - 1; ++i) {\n int u = tour[i];\n int v = tour[i + 1];\n for (int j = i + 2; j < n; ++j) {\n int x = tour[j];\n int y = (j + 1 == n ? tour[0] : tour[j + 1]);\n long long delta = (long long)dist[u][x] + dist[v][y]\n - ((long long)dist[u][v] + dist[x][y]);\n if (delta < 0) {\n reverse(tour.begin() + i + 1, tour.begin() + j + 1);\n improved = true;\n }\n }\n }\n }\n\n // ----- 6. reconstruct the actual walk ---------------------------------\n string moves;\n moves.reserve(200000); // enough for typical cases\n int n = (int)tour.size();\n for (int i = 0; i < n; ++i) {\n int src = tour[i];\n int dst = (i + 1 == n) ? tour[0] : tour[i + 1];\n // build shortest path src -> dst using predecessor table\n vector path;\n int curNode = dst;\n while (curNode != src) {\n path.push_back(curNode);\n curNode = parent[src][curNode];\n }\n path.push_back(src);\n reverse(path.begin(), path.end());\n for (size_t k = 0; k + 1 < path.size(); ++k) {\n int a = path[k];\n int b = path[k + 1];\n int dr = row[b] - row[a];\n int dc = col[b] - col[a];\n if (dr == -1) moves.push_back('U');\n else if (dr == 1) moves.push_back('D');\n else if (dc == -1) moves.push_back('L');\n else if (dc == 1) moves.push_back('R');\n // else: never happens (grid neighbours only)\n }\n }\n\n cout << moves << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n vector> d(N, vector(K));\n for (int i = 0; i < N; ++i)\n for (int k = 0; k < K; ++k)\n cin >> d[i][k];\n\n vector> succ(N);\n vector indeg(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n succ[u].push_back(v);\n ++indeg[v];\n }\n\n /* ---------- data kept between days ---------- */\n vector indeg_rem = indeg; // remaining indegrees\n vector status(N, 0); // 0 = not started, 1 = running, 2 = finished\n vector assigned_task(M, -1); // -1 = idle\n vector start_day(M, -1); // start day of current task\n vector> LB(M, vector(K, 0)); // lower bounds for skills\n\n // tasks whose indegree already became zero\n vector ready;\n for (int i = 0; i < N; ++i)\n if (indeg_rem[i] == 0) ready.push_back(i);\n\n // random generator for the \u03b5\u2011greedy exploration\n mt19937 rng(random_device{}());\n const double EPS = 0.1; // 10 % random choices\n uniform_real_distribution prob(0.0, 1.0);\n\n auto update_LB = [&](int w, int task, int t) {\n int L, U;\n if (t == 1) {\n L = 0; U = 0;\n } else {\n L = max(1, t - 3);\n U = t + 3;\n }\n // bound from the upper side of w\n for (int k = 0; k < K; ++k) {\n LB[w][k] = max(LB[w][k], d[task][k] - U);\n }\n // stronger bound when w = 0 (t = 1)\n if (t == 1) {\n for (int k = 0; k < K; ++k)\n LB[w][k] = max(LB[w][k], d[task][k]);\n }\n };\n\n auto cost = [&](int task, int w) -> int {\n int sum = 0;\n for (int k = 0; k < K; ++k) {\n int diff = d[task][k] - LB[w][k];\n if (diff > 0) sum += diff;\n }\n return sum; // this is w_opt, an upper bound for the real w\n };\n\n int day = 0;\n while (true) {\n ++day; // we are going to output assignments for this day\n\n /* ---------- 1) finish the day ---------- */\n // the line with completions is read *after* we have printed our assignments\n // (the loop body does exactly that)\n\n /* ---------- 2) produce output for today ---------- */\n // collect idle workers\n vector idle;\n for (int w = 0; w < M; ++w)\n if (assigned_task[w] == -1) idle.push_back(w);\n if (!idle.empty())\n shuffle(idle.begin(), idle.end(), rng); // random order -> random assignment when we use \u03b5\n\n // collect still waiting ready tasks (status == 0)\n vector ready_candidates;\n for (int t : ready)\n if (status[t] == 0) ready_candidates.push_back(t);\n\n vector> assignments; // (worker, task) pairs (1\u2011based)\n vector used_task(N, false); // tasks already taken this day\n\n // assign at most one task per idle worker\n for (int w : idle) {\n // build list of still free ready tasks\n vector still;\n for (int t : ready_candidates)\n if (!used_task[t]) still.push_back(t);\n if (still.empty()) break; // no more tasks to start\n\n int chosen_task = -1;\n\n if (prob(rng) < EPS) { // exploration: random task\n uniform_int_distribution pick(0, still.size() - 1);\n chosen_task = still[pick(rng)];\n } else { // exploitation: best according to LB\n int best_c = INT_MAX;\n int best_t = -1;\n for (int t : still) {\n int c = cost(t, w);\n if (c < best_c) {\n best_c = c;\n best_t = t;\n }\n }\n chosen_task = best_t;\n }\n\n // perform the assignment\n used_task[chosen_task] = true;\n assigned_task[w] = chosen_task;\n start_day[w] = day;\n status[chosen_task] = 1; // now running\n assignments.emplace_back(w + 1, chosen_task + 1);\n }\n\n // output\n if (assignments.empty()) {\n cout << 0 << \"\\n\";\n } else {\n cout << assignments.size();\n for (auto &p : assignments) cout << ' ' << p.first << ' ' << p.second;\n cout << \"\\n\";\n }\n cout.flush();\n\n /* ---------- 3) read completions of this day ---------- */\n string line;\n if (!getline(cin, line)) break; // should not happen\n while (line.size() == 0 && !cin.eof()) getline(cin, line); // skip empty lines (just in case)\n if (line.empty()) { /* treat as 0 completions */ line = \"0\"; }\n\n int first;\n {\n istringstream iss(line);\n iss >> first;\n }\n if (first == -1) break; // finished or day limit reached\n\n int cnt = first;\n vector finished_workers;\n {\n istringstream iss(line);\n iss >> cnt;\n for (int i = 0; i < cnt; ++i) {\n int x; iss >> x;\n finished_workers.push_back(x - 1);\n }\n }\n\n /* ---------- 4) process the completions ---------- */\n for (int w : finished_workers) {\n int tsk = assigned_task[w];\n if (tsk == -1) continue; // safety, should not happen\n int duration = day - start_day[w] + 1; // days really spent\n update_LB(w, tsk, duration);\n\n status[tsk] = 2; // finished\n for (int nxt : succ[tsk]) {\n --indeg_rem[nxt];\n if (indeg_rem[nxt] == 0 && status[nxt] == 0) {\n ready.push_back(nxt);\n }\n }\n assigned_task[w] = -1;\n start_day[w] = -1;\n }\n\n // safety: stop after day 2000 (the judge sends -1, but this is an extra guard)\n if (day >= 2000) break;\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nconst int BASE = 0; // id of the office\nint NPOINTS; // 2001\nvector X, Y; // coordinates, index = point id\nint pickNode[1000];\nint delvNode[1000];\nbool isPick[2001];\nint orderOf[2001]; // order id for a point\n\ninline int manhattan(int a, int b) {\n return abs(X[a] - X[b]) + abs(Y[a] - Y[b]);\n}\n\n/* --------------------------------------------------------------- */\n/* helper: index after removing one element ---------------------- */\ninline int idxAfterRem(int p, int removed) { // p \u2026 position in the shorter vector\n return (p < removed) ? p : p + 1;\n}\n\n/* --------------------------------------------------------------- */\n/* length of a tour (tour does NOT contain the office) ----------- */\nlong long tourLength(const vector& tour) {\n if (tour.empty()) return 0;\n long long len = manhattan(BASE, tour[0]) + manhattan(tour.back(), BASE);\n for (int i = 0; i + 1 < (int)tour.size(); ++i)\n len += manhattan(tour[i], tour[i + 1]);\n return len;\n}\n\n/* --------------------------------------------------------------- */\n/* build a feasible initial tour for a given set of orders ------- */\nvector buildInitialTour(const vector& orders) {\n vector pickups, deliveries;\n pickups.reserve(orders.size());\n deliveries.reserve(orders.size());\n for (int o : orders) {\n pickups.push_back(pickNode[o]);\n deliveries.push_back(delvNode[o]);\n }\n\n vector tour;\n int cur = BASE;\n int m = (int)pickups.size();\n vector used(m, 0);\n while ((int)tour.size() < m) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < m; ++i) if (!used[i]) {\n int d = manhattan(cur, pickups[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n used[best] = 1;\n tour.push_back(pickups[best]);\n cur = pickups[best];\n }\n\n int dsz = (int)deliveries.size();\n vector usedD(dsz, 0);\n while ((int)tour.size() < m + dsz) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < dsz; ++i) if (!usedD[i]) {\n int d = manhattan(cur, deliveries[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n usedD[best] = 1;\n tour.push_back(deliveries[best]);\n cur = deliveries[best];\n }\n return tour;\n}\n\n/* --------------------------------------------------------------- */\n/* relocate + 2\u2011opt local search (keeps feasibility) ------------- */\nvoid improveTour(vector& tour, const vector& selected) {\n int totalPoints = NPOINTS;\n vector pos(totalPoints, -1);\n auto updatePos = [&]() {\n fill(pos.begin(), pos.end(), -1);\n for (int i = 0; i < (int)tour.size(); ++i) pos[tour[i]] = i;\n };\n updatePos();\n\n const auto canMove = [&](int node, int a, int newPos) -> bool {\n int oid = orderOf[node];\n int other = isPick[node] ? delvNode[oid] : pickNode[oid];\n int otherPos = pos[other];\n int otherPosR = (otherPos > a) ? otherPos - 1 : otherPos;\n int b2 = (newPos > a) ? newPos - 1 : newPos;\n int finalPosNode = b2;\n int finalPosOther = (otherPosR > b2) ? otherPosOther + 1 : otherPosR;\n if (isPick[node]) return finalPosNode < finalPosOther;\n else return finalPosOther < finalPosNode;\n };\n\n const auto deltaRel = [&](int node, int a, int newPos) -> long long {\n int len = (int)tour.size();\n int L = (a == 0) ? BASE : tour[a - 1];\n int R = (a == len - 1) ? BASE : tour[a + 1];\n long long delta = - (manhattan(L, node) + manhattan(node, R));\n delta += manhattan(L, R);\n\n int b2 = (newPos > a) ? newPos - 1 : newPos;\n int leftIdx = (b2 == 0) ? -1 : idxAfterRem(b2 - 1, a);\n int rightIdx = (b2 == len - 1) ? -1 : idxAfterRem(b2, a);\n int L2 = (leftIdx == -1) ? BASE : tour[leftIdx];\n int R2 = (rightIdx == -1) ? BASE : tour[rightIdx];\n delta += manhattan(L2, node) + manhattan(node, R2) - manhattan(L2, R2);\n return delta;\n };\n\n const auto segmentSafe = [&](int l, int r) -> bool { // inclusive indices in tour\n for (int oid : selected) {\n int pp = pos[pickNode[oid]];\n int dd = pos[delvNode[oid]];\n if (pp != -1 && dd != -1 && pp >= l && pp <= r && dd >= l && dd <= r)\n return false;\n }\n return true;\n };\n\n bool progress = true;\n while (progress) {\n progress = false;\n /* ---------- relocation ----------------------------------- */\n long long bestDelta = 0;\n int bestNode = -1, bestNewPos = -1;\n int len = (int)tour.size();\n for (int i = 0; i < len; ++i) {\n int node = tour[i];\n for (int np = 0; np <= len; ++np) {\n if (np == i) continue;\n if (!canMove(node, i, np)) continue;\n long long d = deltaRel(node, i, np);\n if (d < bestDelta) {\n bestDelta = d;\n bestNode = node;\n bestNewPos = np;\n progress = true;\n }\n }\n }\n if (progress) {\n int a = -1;\n for (int k = 0; k < len; ++k) if (tour[k] == bestNode) a = k;\n int b = bestNewPos;\n tour.erase(tour.begin() + a);\n int b2 = (b > a) ? b - 1 : b;\n tour.insert(tour.begin() + b2, bestNode);\n updatePos();\n }\n\n /* ---------- 2\u2011opt ---------------------------------------- */\n long long bestDelta2 = 0;\n int best_i = -1, best_j = -1;\n len = (int)tour.size();\n for (int i = 0; i < len; ++i) {\n for (int j = i + 2; j < len; ++j) {\n if (!segmentSafe(i + 1, j)) continue;\n int A = (i == 0) ? BASE : tour[i - 1];\n int B = tour[i];\n int C = tour[j];\n int D = (j + 1 == len) ? BASE : tour[j + 1];\n long long d = (long long)manhattan(A, C) + manhattan(B, D)\n - (long long)manhattan(A, B) - manhattan(C, D);\n if (d < bestDelta2) {\n bestDelta2 = d;\n best_i = i;\n best_j = j;\n progress = true;\n }\n }\n }\n if (bestDelta2 < 0) {\n reverse(tour.begin() + best_i + 1, tour.begin() + best_j + 1);\n updatePos();\n }\n }\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n /* ----- read input ------------------------------------------ */\n const int ORD = 1000;\n vector> orders(ORD);\n for (int i = 0; i < ORD; ++i) {\n cin >> orders[i][0] >> orders[i][1] >> orders[i][2] >> orders[i][3];\n }\n\n /* ----- build point list (0 = office) ---------------------- */\n NPOINTS = 1 + 2 * ORD;\n X.resize(NPOINTS);\n Y.resize(NPOINTS);\n X[BASE] = 400; Y[BASE] = 400;\n for (int i = 0; i < ORD; ++i) {\n int pi = 2 * i + 1;\n int di = 2 * i + 2;\n X[pi] = orders[i][0]; Y[pi] = orders[i][1];\n X[di] = orders[i][2]; Y[di] = orders[i][3];\n pickNode[i] = pi;\n delvNode[i] = di;\n isPick[pi] = true; isPick[di] = false;\n orderOf[pi] = orderOf[di] = i;\n }\n\n /* ----- greedy subset --------------------------------------- */\n vector greedyIdx(ORD);\n iota(greedyIdx.begin(), greedyIdx.end(), 0);\n vector cost(ORD);\n for (int i = 0; i < ORD; ++i) {\n cost[i] = manhattan(BASE, pickNode[i])\n + manhattan(pickNode[i], delvNode[i])\n + manhattan(delvNode[i], BASE);\n }\n sort(greedyIdx.begin(), greedyIdx.end(),\n [&](int a, int b){ return cost[a] < cost[b]; });\n\n vector bestSubset;\n vector bestTour;\n long long bestLength = (1LL<<60);\n\n auto trySubset = [&](const vector& sub) {\n vector tour = buildInitialTour(sub);\n improveTour(tour, sub);\n long long L = tourLength(tour);\n if (L < bestLength) {\n bestLength = L;\n bestTour = tour;\n bestSubset = sub;\n }\n };\n\n /* first the greedy one */\n vector firstSubset(greedyIdx.begin(), greedyIdx.begin() + 50);\n trySubset(firstSubset);\n\n /* random subsets \u2013 a few dozen */\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n int trial = 0;\n const int MAX_TRIAL = 200;\n auto start = chrono::steady_clock::now();\n while (trial < MAX_TRIAL) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > 1.85) break; // safety margin\n\n vector ids(ORD);\n iota(ids.begin(), ids.end(), 0);\n shuffle(ids.begin(), ids.end(), rng);\n vector sub(ids.begin(), ids.begin() + 50);\n trySubset(sub);\n ++trial;\n }\n\n /* ----- output ---------------------------------------------- */\n cout << 50;\n for (int x : bestSubset) cout << ' ' << (x + 1);\n cout << '\\n';\n\n cout << (int)bestTour.size() + 2; // +2 for the two office points\n cout << \" 400 400\";\n for (int v : bestTour) cout << ' ' << X[v] << ' ' << Y[v];\n cout << \" 400 400\\n\";\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\n/*** Disjoint Set Union ********************************************/\nstruct DSU {\n vector parent, rank_;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n parent.resize(n);\n rank_.assign(n, 0);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int x) {\n return parent[x] == x ? x : parent[x] = find(parent[x]);\n }\n bool unite(int a, int b) {\n a = find(a);\n b = find(b);\n if (a == b) return false;\n if (rank_[a] < rank_[b]) swap(a, b);\n parent[b] = a;\n if (rank_[a] == rank_[b]) ++rank_[a];\n return true;\n }\n};\n/******************************************************************/\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int N = 400; // fixed by the problem statement\n const int M = 1995;\n\n // ----- read vertices -----------------------------------------\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) cin >> X[i] >> Y[i];\n\n // ----- read edges ---------------------------------------------\n vector U(M), V(M);\n for (int i = 0; i < M; ++i) cin >> U[i] >> V[i];\n\n // ----- 1) lower bound distances d_i --------------------------\n vector d(M);\n for (int i = 0; i < M; ++i) {\n long long dx = (long long)X[U[i]] - X[V[i]];\n long long dy = (long long)Y[U[i]] - Y[V[i]];\n double dist = sqrt((double)dx * dx + (double)dy * dy);\n d[i] = (int)llround(dist); // round to nearest integer\n }\n\n // ----- 2) build a spanning tree T with the lower bounds -------\n vector inTree(M, 0);\n vector order(M);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b) {\n if (d[a] != d[b]) return d[a] < d[b];\n return a < b;\n });\n\n DSU dsu_mst(N);\n int taken = 0;\n for (int id : order) {\n if (dsu_mst.unite(U[id], V[id])) {\n inTree[id] = 1;\n ++taken;\n if (taken == N - 1) break;\n }\n }\n\n // ----- 3) build adjacency list of the tree --------------------\n vector>> adj(N); // (neighbor, edge index)\n for (int i = 0; i < M; ++i) {\n if (inTree[i]) {\n adj[U[i]].push_back({V[i], i});\n adj[V[i]].push_back({U[i], i});\n }\n }\n\n // ----- 4) preprocess parent, depth, parentEdge for LCA -------\n vector depth(N, 0), parent(N, -1), parentEdge(N, -1);\n function dfs = [&](int v, int p) {\n for (auto [to, eidx] : adj[v]) {\n if (to == p) continue;\n depth[to] = depth[v] + 1;\n parent[to] = v;\n parentEdge[to] = eidx;\n dfs(to, v);\n }\n };\n dfs(0, -1); // root the tree at vertex 0\n\n // ----- 5) function returning the maximum d on the path u\u2011v ---\n auto maxOnPath = [&](int u, int v) {\n int mx = 0;\n while (depth[u] > depth[v]) {\n mx = max(mx, d[parentEdge[u]]);\n u = parent[u];\n }\n while (depth[v] > depth[u]) {\n mx = max(mx, d[parentEdge[v]]);\n v = parent[v];\n }\n while (u != v) {\n mx = max(mx, d[parentEdge[u]]);\n mx = max(mx, d[parentEdge[v]]);\n u = parent[u];\n v = parent[v];\n }\n return mx;\n };\n\n // ----- 6) compute dmax for every edge -------------------------\n vector dmax(M);\n for (int i = 0; i < M; ++i) {\n if (inTree[i]) {\n dmax[i] = d[i]; // tree edge \u2192 its own weight\n } else {\n dmax[i] = maxOnPath(U[i], V[i]); // heaviest edge on the T\u2011path\n }\n }\n\n // ----- 7) online processing ------------------------------------\n DSU dsu(N);\n for (int i = 0; i < M; ++i) {\n int L; // true length of edge i\n cin >> L;\n\n int decision = 0;\n if (dsu.find(U[i]) != dsu.find(V[i])) {\n // accept if it belongs to the pre\u2011computed tree,\n // or if it is cheap enough ( \u2264 2\u00b7dmax )\n if (inTree[i] || L <= 2 * dmax[i]) {\n decision = 1;\n dsu.unite(U[i], V[i]);\n }\n }\n cout << decision << '\\n' << flush;\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nconst int SZ = 30;\nconst int MAX_WALLS = 100;\nconst int PHASE_MOVE = 50; // First 50 turns: move to good positions\nconst int PHASE_WALL = 250; // Next 250 turns: build walls\n\nstruct Pet {\n int x, y, type;\n};\n\nstruct Human {\n int x, y;\n int hx, hy;\n int walls = 0;\n int targetTurn = 0;\n};\n\nint sgn(int a) { return (a > 0) - (a < 0); }\n\nint dx[4] = {-1, 1, 0, 0};\nint dy[4] = { 0, 0,-1, 1};\nchar wCh[4] = {'u','d','l','r'};\nchar mCh[4] = {'U','D','L','R'};\n\ninline bool inside(int x, int y) { return x >= 1 && x <= SZ && y >= 1 && y <= SZ; }\n\nbool wall[SZ + 1][SZ + 1];\nbool petAt[SZ + 1][SZ + 1];\n\ninline bool passable(int x, int y) { return inside(x, y) && !wall[x][y]; }\n\nvector pets;\nvector hums;\n\nbool petOn(int x, int y) { return petAt[x][y]; }\n\nbool humanOn(int x, int y) {\n for (const Human &h : hums)\n if (h.x == x && h.y == y) return true;\n return false;\n}\n\nbool adjacentPet(int x, int y) {\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d], ny = y + dy[d];\n if (inside(nx, ny) && petAt[nx][ny]) return true;\n }\n return false;\n}\n\nint countAdjacentPets(int x, int y) {\n int cnt = 0;\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d], ny = y + dy[d];\n if (inside(nx, ny) && petAt[nx][ny]) ++cnt;\n }\n return cnt;\n}\n\nbool canWall(int x, int y) {\n if (!inside(x, y)) return false;\n if (wall[x][y]) return false;\n if (petOn(x, y) || humanOn(x, y)) return false;\n if (adjacentPet(x, y)) return false;\n return true;\n}\n\nbool canMove(int x, int y, int dir) {\n int nx = x + dx[dir], ny = y + dy[dir];\n return inside(nx, ny) && passable(nx, ny);\n}\n\nint countPassableNeighbors(int x, int y, int excludeDir = -1) {\n int cnt = 0;\n for (int d = 0; d < 4; ++d) {\n if (d == excludeDir) continue;\n int nx = x + dx[d], ny = y + dy[d];\n if (passable(nx, ny)) ++cnt;\n }\n return cnt;\n}\n\n// Find best position for a human based on pet distribution\npair findBestPosition(int hx, int hy, const vector>& forbidden) {\n int bestScore = -1;\n pair best = {hx, hy};\n \n for (int x = 1; x <= SZ; ++x) {\n for (int y = 1; y <= SZ; ++y) {\n if (!passable(x, y)) continue;\n if (petOn(x, y)) continue;\n \n bool forbiddenHere = false;\n for (auto p : forbidden)\n if (p.first == x && p.second == y) { forbiddenHere = true; break; }\n if (forbiddenHere) continue;\n \n // Score: distance from pets (higher = better)\n int minDist = 1000;\n for (const Pet &p : pets) {\n int d = abs(p.x - x) + abs(p.y - y);\n minDist = min(minDist, d);\n }\n \n // Bonus for corners/edges (easier to defend)\n int edgeBonus = 0;\n if (x == 1 || x == SZ || y == 1 || y == SZ) edgeBonus = 5;\n if ((x == 1 || x == SZ) && (y == 1 || y == SZ)) edgeBonus = 10;\n \n int score = minDist + edgeBonus;\n if (score > bestScore) {\n bestScore = score;\n best = {x, y};\n }\n }\n }\n return best;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n pets.resize(N);\n for (int i = 0; i < N; ++i) cin >> pets[i].x >> pets[i].y >> pets[i].type;\n\n int M;\n cin >> M;\n hums.resize(M);\n for (int i = 0; i < M; ++i) cin >> hums[i].x >> hums[i].y;\n\n for (int x = 1; x <= SZ; ++x)\n for (int y = 1; y <= SZ; ++y)\n wall[x][y] = false;\n\n for (int i = 0; i < N; ++i) petAt[pets[i].x][pets[i].y] = true;\n\n // Assign home positions - spread across board\n vector> forbidden;\n for (auto &h : hums) {\n auto pos = findBestPosition(h.x, h.y, forbidden);\n h.hx = pos.first;\n h.hy = pos.second;\n forbidden.push_back(pos);\n }\n\n for (int turn = 1; turn <= 300; ++turn) {\n vector actDir(M, -1);\n vector actWall(M, false);\n pair wallTarget[M];\n bool hasWallTarget[M] = {false};\n\n // Decide actions\n for (int i = 0; i < M; ++i) {\n Human &h = hums[i];\n \n // Count nearby pets\n int nearbyPets = 0;\n for (int d = 0; d < 4; ++d) {\n int nx = h.x + dx[d], ny = h.y + dy[d];\n nearbyPets += countAdjacentPets(nx, ny);\n }\n \n bool shouldBuildWall = (turn > PHASE_MOVE && h.walls < MAX_WALLS);\n \n if (shouldBuildWall) {\n // Score all possible wall positions\n struct WallOption { int x, y, score; };\n vector options;\n \n for (int d = 0; d < 4; ++d) {\n int nx = h.x + dx[d], ny = h.y + dy[d];\n if (!canWall(nx, ny)) continue;\n \n // Score: more adjacent pets = higher priority\n int adjPets = countAdjacentPets(nx, ny);\n // Check if this wall would block pet paths\n int blockedPaths = 0;\n for (int pd = 0; pd < 4; ++pd) {\n int px = nx + dx[pd], py = ny + dy[pd];\n if (inside(px, py) && petAt[px][py]) blockedPaths += 2;\n }\n \n // Don't trap ourselves - ensure enough escape routes\n int escapeRoutes = countPassableNeighbors(h.x, h.y, d);\n if (escapeRoutes < 1) continue; // Would trap us\n \n int score = adjPets * 10 + blockedPaths + (escapeRoutes >= 2 ? 5 : 0);\n options.push_back({nx, ny, score});\n }\n \n if (!options.empty()) {\n sort(options.begin(), options.end(),\n [](const WallOption& a, const WallOption& b) {\n return a.score > b.score;\n });\n // Pick best option\n actWall[i] = true;\n actDir[i] = -1;\n for (int d = 0; d < 4; ++d) {\n if (h.x + dx[d] == options[0].x && h.y + dy[d] == options[0].y) {\n actDir[i] = d;\n break;\n }\n }\n wallTarget[i] = {options[0].x, options[0].y};\n hasWallTarget[i] = true;\n ++h.walls;\n }\n }\n \n // If we didn't place a wall, try to move\n if (!actWall[i]) {\n // Prioritize moving away from pets\n struct MoveOption { int dir, score; };\n vector moves;\n \n for (int d = 0; d < 4; ++d) {\n if (!canMove(h.x, h.y, d)) continue;\n int nx = h.x + dx[d], ny = h.y + dy[d];\n \n // Score: move away from pets\n int score = 0;\n for (const Pet &p : pets) {\n int currDist = abs(p.x - h.x) + abs(p.y - h.y);\n int newDist = abs(p.x - nx) + abs(p.y - ny);\n score += newDist - currDist; // Higher = better (farther)\n }\n \n // Bonus for moving toward home\n int homeDistBefore = abs(h.hx - h.x) + abs(h.hy - h.y);\n int homeDistAfter = abs(h.hx - nx) + abs(h.hy - ny);\n if (homeDistAfter < homeDistBefore) score += 3;\n \n moves.push_back({d, score});\n }\n \n if (!moves.empty()) {\n sort(moves.begin(), moves.end(),\n [](const MoveOption& a, const MoveOption& b) {\n return a.score > b.score;\n });\n actDir[i] = moves[0].dir;\n }\n }\n }\n\n // Conflict resolution - prevent multiple humans building walls on same spot\n for (int i = 0; i < M; ++i) {\n if (!actWall[i]) continue;\n for (int j = i + 1; j < M; ++j) {\n if (!actWall[j]) continue;\n if (wallTarget[i] == wallTarget[j]) {\n // Cancel one - the one with fewer walls built keeps it\n if (hums[i].walls > hums[j].walls) {\n actWall[j] = false;\n actDir[j] = -1;\n hasWallTarget[j] = false;\n } else {\n actWall[i] = false;\n actDir[i] = -1;\n hasWallTarget[i] = false;\n }\n }\n }\n }\n\n // Resolve conflicts with simultaneous moves\n bool willWall[SZ + 1][SZ + 1] = {false};\n bool willMove[SZ + 1][SZ + 1] = {false};\n\n for (int i = 0; i < M; ++i) {\n if (actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (inside(nx, ny)) willWall[nx][ny] = true;\n }\n if (actDir[i] != -1 && !actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (inside(nx, ny)) willMove[nx][ny] = true;\n }\n }\n\n // Moves can't end on walls being built\n for (int i = 0; i < M; ++i) {\n if (actDir[i] != -1 && !actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (willWall[nx][ny]) {\n // Try another direction\n bool found = false;\n for (int d = 0; d < 4; ++d) {\n if (d == actDir[i]) continue;\n int mx = hums[i].x + dx[d], my = hums[i].y + dy[d];\n if (!inside(mx, my)) continue;\n if (!passable(mx, my)) continue;\n if (willWall[mx][my]) continue;\n actDir[i] = d;\n willMove[mx][my] = true;\n found = true;\n break;\n }\n if (!found) {\n actDir[i] = -1; // Stay\n willMove[nx][ny] = false;\n }\n }\n }\n // Walls can't be placed where someone moves\n if (actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (willMove[nx][ny]) {\n actWall[i] = false;\n actDir[i] = -1;\n }\n }\n }\n\n // Output\n string out;\n out.reserve(M);\n for (int i = 0; i < M; ++i) {\n if (actDir[i] == -1) out.push_back('.');\n else if (actWall[i]) out.push_back(wCh[actDir[i]]);\n else out.push_back(mCh[actDir[i]]);\n }\n cout << out << '\\n' << flush;\n\n // Apply human actions\n for (int i = 0; i < M; ++i) {\n if (actWall[i]) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (inside(nx, ny) && !wall[nx][ny]) wall[nx][ny] = true;\n } else if (actDir[i] != -1) {\n int nx = hums[i].x + dx[actDir[i]];\n int ny = hums[i].y + dy[actDir[i]];\n if (inside(nx, ny) && passable(nx, ny)) {\n hums[i].x = nx;\n hums[i].y = ny;\n }\n }\n }\n\n // Read pet moves\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (char c : s) {\n int dir = -1;\n if (c == 'U') dir = 0;\n else if (c == 'D') dir = 1;\n else if (c == 'L') dir = 2;\n else if (c == 'R') dir = 3;\n else continue;\n int nx = pets[i].x + dx[dir];\n int ny = pets[i].y + dy[dir];\n if (inside(nx, ny) && passable(nx, ny)) {\n pets[i].x = nx;\n pets[i].y = ny;\n }\n }\n }\n\n // Update petAt\n for (int x = 1; x <= SZ; ++x)\n for (int y = 1; y <= SZ; ++y)\n petAt[x][y] = false;\n for (const Pet &p : pets) petAt[p.x][p.y] = true;\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int si, sj, ti, tj;\n double p;\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n const int N = 20;\n vector h(N); // horizontal walls, size 20 \u00d7 19\n for (int i = 0; i < N; ++i) cin >> h[i];\n vector v(N - 1); // vertical walls, size 19 \u00d7 20\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n\n // directions: 0=U, 1=D, 2=L, 3=R\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dch[4] = {'U', 'D', 'L', 'R'};\n\n auto can_move = [&](int i, int j, int dir) -> bool {\n if (dir == 0) { // up\n if (i == 0) return false;\n return v[i - 1][j] == '0';\n } else if (dir == 1) { // down\n if (i == N - 1) return false;\n return v[i][j] == '0';\n } else if (dir == 2) { // left\n if (j == 0) return false;\n return h[i][j - 1] == '0';\n } else { // right\n if (j == N - 1) return false;\n return h[i][j] == '0';\n }\n };\n\n // BFS\n vector> dist(N, vector(N, -1));\n vector>> prev(N, vector>(N, {-1,-1}));\n vector> pred_dir(N, vector(N, 0));\n\n queue> q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break; // reached destination\n for (int dir = 0; dir < 4; ++dir) {\n if (!can_move(i, j, dir)) continue;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (dist[ni][nj] != -1) continue;\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n pred_dir[ni][nj] = dch[dir];\n q.emplace(ni, nj);\n }\n }\n\n // reconstruct shortest path\n string path;\n int ci = ti, cj = tj;\n while (!(ci == si && cj == sj)) {\n path.push_back(pred_dir[ci][cj]);\n auto pr = prev[ci][cj];\n ci = pr.first; cj = pr.second;\n }\n reverse(path.begin(), path.end());\n\n int d = (int)path.size();\n string ans;\n\n if (d == 0) { // start equals office\n cout << \"\\n\";\n return 0;\n }\n\n if (d <= 200) {\n ans.reserve(200);\n for (int i = 0; i < 200; ++i) ans.push_back(path[i % d]);\n } else { // distance larger than 200 \u2192 impossible to succeed\n ans = path.substr(0, 200); // any 200 characters are fine\n }\n\n cout << ans << '\\n';\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30, W = 30, N = H * W;\n\n/* directions: 0 left, 1 up, 2 right, 3 down */\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\ninline int neighbor_id(int idx, int dir) {\n int i = idx / W, j = idx % W;\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) return -1;\n return ni * W + nj;\n}\n\n/* --------------------------------------------------------------- */\n/* pre\u2011computed neighbour lists for every tile and every rotation */\nvector>> neigh;\n\n/* --------------------------------------------------------------- */\nvector> adj;\n\n/* ----- component handling -------------------------------------- */\nvector compId;\nvector> compNodes;\nvector compEdge;\n\nstruct Cmp {\n bool operator()(const pair& a, const pair& b) const {\n if (a.first != b.first) return a.first < b.first;\n return a.second < b.second;\n }\n};\nmultiset, Cmp> compSet;\n\n/* --------------------------------------------------------------- */\ninline int score_from_set() {\n if (compSet.empty()) return 0;\n auto it = compSet.begin();\n int L1 = -it->first;\n ++it;\n int L2 = (it == compSet.end()) ? 0 : -it->first;\n return L1 * L2;\n}\n\n/* --------------------------------------------------------------- */\ninline void addAdj(int u, int v) {\n adj[u].push_back(v);\n adj[v].push_back(u);\n}\n\n/* --------------------------------------------------------------- */\ninline bool edge_exists_fast(const vector& vec, int v) {\n for (int x : vec) if (x == v) return true;\n return false;\n}\n\n/* --------------------------------------------------------------- */\nvoid addEdge(int u, int v) {\n if (edge_exists_fast(adj[u], v)) return;\n adj[u].push_back(v);\n adj[v].push_back(u);\n\n int cu = compId[u];\n int cv = compId[v];\n if (cu == cv) {\n int oldc = compEdge[cu];\n compEdge[cu] = oldc + 1;\n compSet.erase({-oldc, cu});\n compSet.insert({-(oldc + 1), cu});\n } else {\n int oldcU = compEdge[cu];\n int oldcV = compEdge[cv];\n compSet.erase({-oldcU, cu});\n compSet.erase({-oldcV, cv});\n\n int target = (compNodes[cu].size() >= compNodes[cv].size()) ? cu : cv;\n int source = (target == cu) ? cv : cu;\n\n int newc = oldcU + oldcV + 1;\n for (int node : compNodes[source]) {\n compId[node] = target;\n compNodes[target].push_back(node);\n }\n compNodes[source].clear();\n compEdge[target] = newc;\n compSet.insert({-newc, target});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid removeEdge(int u, int v) {\n // Remove from adjacency\n auto &vecU = adj[u];\n for (size_t i = 0; i < vecU.size(); ++i) {\n if (vecU[i] == v) { vecU[i] = vecU.back(); vecU.pop_back(); break; }\n }\n auto &vecV = adj[v];\n for (size_t i = 0; i < vecV.size(); ++i) {\n if (vecV[i] == u) { vecV[i] = vecV.back(); vecV.pop_back(); break; }\n }\n\n int cid = compId[u];\n int oldc = compEdge[cid];\n compSet.erase({-oldc, cid});\n\n // BFS from u after removal\n vector vis(N, 0);\n vector partA;\n queue q;\n q.push(u); vis[u] = 1;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n partA.push_back(x);\n for (int nb : adj[x]) if (!vis[nb]) { vis[nb] = 1; q.push(nb); }\n }\n\n if (!vis[v]) {\n // Split\n vector partB;\n for (int node : compNodes[cid]) if (!vis[node]) partB.push_back(node);\n \n long long sA = 0, sB = 0;\n for (int n : partA) sA += adj[n].size();\n for (int n : partB) sB += adj[n].size();\n int cntA = int(sA / 2), cntB = int(sB / 2);\n \n compNodes[cid] = partA;\n int newId = (int)compNodes.size();\n compNodes.push_back(partB);\n compEdge.push_back(cntB);\n for (int n : partB) compId[n] = newId;\n \n compSet.insert({-cntA, cid});\n compSet.insert({-cntB, newId});\n } else {\n compEdge[cid] = oldc - 1;\n compSet.insert({-(oldc - 1), cid});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid build_components() {\n compId.assign(N, -1);\n compNodes.clear();\n compEdge.clear();\n compSet.clear();\n\n vector vis(N, 0);\n for (int v = 0; v < N; ++v) if (!vis[v]) {\n vector nodes;\n queue q;\n q.push(v); vis[v] = 1;\n long long sumDeg = 0;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n nodes.push_back(x);\n sumDeg += adj[x].size();\n for (int nb : adj[x]) if (!vis[nb]) { vis[nb] = 1; q.push(nb); }\n }\n int cid = (int)compNodes.size();\n compNodes.push_back(nodes);\n compEdge.push_back(int(sumDeg / 2));\n for (int n : nodes) compId[n] = cid;\n compSet.insert({-compEdge[cid], cid});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid init_adj(const vector& rot) {\n adj.assign(N, vector());\n for (int idx = 0; idx < N; ++idx) {\n int r = rot[idx];\n for (int nb : neigh[idx][r]) {\n if (nb != -1) addAdj(idx, nb);\n }\n }\n}\n\n/* --------------------------------------------------------------- */\nint apply_move(int idx, int new_rot, vector& rot) {\n int old_rot = rot[idx];\n if (old_rot == new_rot) return score_from_set();\n\n const vector& old_nb = neigh[idx][old_rot];\n const vector& new_nb = neigh[idx][new_rot];\n\n for (int nb : old_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : new_nb) if (x == nb) { exists = true; break; }\n if (!exists) removeEdge(idx, nb);\n }\n for (int nb : new_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : old_nb) if (x == nb) { exists = true; break; }\n if (!exists) addEdge(idx, nb);\n }\n\n rot[idx] = new_rot;\n return score_from_set();\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector type(N);\n for (int i = 0; i < H; ++i) {\n string line;\n cin >> line;\n for (int j = 0; j < W; ++j) {\n type[i * W + j] = line[j] - '0';\n }\n }\n\n const vector> base[8] = {\n {{0,1}}, {{0,3}}, {{2,3}}, {{1,2}},\n {{0,1},{2,3}}, {{0,3},{1,2}},\n {{0,2}}, {{1,3}}\n };\n\n neigh.assign(N, vector>(4));\n for (int idx = 0; idx < N; ++idx) {\n int t = type[idx];\n for (int r = 0; r < 4; ++r) {\n vector cur;\n for (auto [a,b] : base[t]) {\n int s1 = (a + 3 * r) % 4;\n int s2 = (b + 3 * r) % 4;\n int nb1 = neighbor_id(idx, s1);\n int nb2 = neighbor_id(idx, s2);\n cur.push_back(nb1);\n cur.push_back(nb2);\n }\n neigh[idx][r] = cur;\n }\n }\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n\n int best_score = 0;\n vector answer_rot(N);\n\n const int RESTARTS = 6;\n const int STEPS = 2000;\n\n for (int trial = 0; trial < RESTARTS; ++trial) {\n vector cur_rot(N);\n \n // Greedy initial: maximize edge count\n for (int idx = 0; idx < N; ++idx) {\n int best = 0, bestCnt = -1;\n for (int r = 0; r < 4; ++r) {\n int cnt = 0;\n for (int nb : neigh[idx][r]) if (nb != -1) ++cnt;\n if (cnt > bestCnt) { bestCnt = cnt; best = r; }\n }\n cur_rot[idx] = best;\n }\n \n // Random perturbations\n for (int i = 0; i < 200; ++i) {\n cur_rot[rng() % N] = rng() % 4;\n }\n\n init_adj(cur_rot);\n build_components();\n int cur_score = score_from_set();\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n\n // Fast hill climbing\n for (int step = 0; step < STEPS; ++step) {\n int idx = rng() % N;\n int old_r = cur_rot[idx];\n int best_rot_here = old_r;\n int best_score_here = cur_score;\n \n // Try all rotations\n for (int cand = 0; cand < 4; ++cand) {\n if (cand == old_r) continue;\n int new_score = apply_move(idx, cand, cur_rot);\n if (new_score > best_score_here) {\n best_score_here = new_score;\n best_rot_here = cand;\n } else {\n apply_move(idx, old_r, cur_rot);\n }\n }\n \n if (best_rot_here != old_r) {\n cur_score = best_score_here;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n }\n \n // Occasionally try boundary cells\n if (step % 50 == 0 && !compSet.empty()) {\n auto it = compSet.begin();\n if (!compNodes[it->second].empty()) {\n int cid = it->second;\n for (int v : compNodes[cid]) {\n for (int nb : adj[v]) {\n if (compId[nb] != cid) {\n int old = cur_rot[v];\n for (int r = 0; r < 4; ++r) {\n if (r == old) continue;\n int sc = apply_move(v, r, cur_rot);\n if (sc > cur_score) {\n cur_score = sc;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n } else {\n apply_move(v, old, cur_rot);\n }\n }\n break;\n }\n }\n }\n }\n }\n }\n }\n\n string out;\n out.reserve(N);\n for (int i = 0; i < N; ++i) out.push_back(char('0' + answer_rot[i]));\n cout << out << '\\n';\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\n// ------------------------------------------------------------\n// bit masks\nconst int BIT_LEFT = 1; // 0001\nconst int BIT_UP = 2; // 0010\nconst int BIT_RIGHT = 4; // 0100\nconst int BIT_DOWN = 8; // 1000\n\n// direction arrays: 0-up,1-down,2-left,3-right\nconst int DI[4] = {-1, 1, 0, 0};\nconst int DJ[4] = {0, 0, -1, 1};\n\n// ------------------------------------------------------------\n// Hopcroft\u2013Karp for bipartite matching (left size = right size = M)\nstruct HopcroftKarp {\n int nLeft, nRight;\n vector> adj;\n vector dist, pairU, pairV;\n\n HopcroftKarp(int L, int R) : nLeft(L), nRight(R) {\n adj.assign(nLeft, {});\n pairU.assign(nLeft, -1);\n pairV.assign(nRight, -1);\n dist.resize(nLeft);\n }\n void addEdge(int u, int v) { adj[u].push_back(v); }\n\n bool bfs() {\n queue q;\n for (int u = 0; u < nLeft; ++u) {\n if (pairU[u] == -1) {\n dist[u] = 0;\n q.push(u);\n } else dist[u] = -1;\n }\n bool found = 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) found = true;\n }\n }\n return found;\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 int maxMatching() {\n int matching = 0;\n while (bfs()) {\n for (int u = 0; u < nLeft; ++u)\n if (pairU[u] == -1 && dfs(u))\n ++matching;\n }\n return matching;\n }\n};\n\n// ------------------------------------------------------------\nint sgn(int x) { return (x > 0) - (x < 0); }\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n if (!(cin >> N >> T)) return 0;\n vector raw(N);\n for (int i = 0; i < N; ++i) cin >> raw[i];\n\n // --------------------------------------------------------\n // initialise board, masks, positions\n int M = N * N - 1; // number of tiles\n vector tileMask(M);\n vector> tilePos(M); // current positions of tiles\n vector> board(N, vector(N, -1));\n vector> cellIndex(N, vector(N, -1));\n vector> cellCoord; // coordinate of each cell (by its index)\n pair emptyPos;\n int tileId = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c = raw[i][j];\n int mask = (c >= '0' && c <= '9') ? (c - '0')\n : (10 + c - 'a');\n if (mask == 0) {\n emptyPos = {i, j};\n board[i][j] = -1;\n } else {\n board[i][j] = tileId;\n tileMask[tileId] = mask;\n tilePos[tileId] = {i, j};\n cellIndex[i][j] = tileId; // reuse same numbering (convenient)\n cellCoord.push_back({i, j});\n ++tileId;\n }\n }\n }\n // --------------------------------------------------------\n // target positions (filled after matching)\n vector> targetPos(M, {-1,-1});\n\n // --------------------------------------------------------\n // try to find a spanning tree and a perfect matching\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n const int MAX_TRIES = 200;\n bool ok = false;\n for (int attempt = 0; attempt < MAX_TRIES && !ok; ++attempt) {\n // ----- build a random spanning tree on the non\u2011empty cells\n vector> visited(N, vector(N, false));\n vector,pair>> edges; // list of tree edges\n // start from the first non\u2011empty cell\n int sr = -1, sc = -1;\n for (int i = 0; i < N && sr==-1; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1) { sr = i; sc = j; }\n if (sr==-1) continue; // should not happen\n stack> st;\n st.emplace(sr, sc);\n visited[sr][sc] = true;\n\n while (!st.empty()) {\n auto [r,c] = st.top(); st.pop();\n // random order of directions\n array dirs = {0,1,2,3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int nr = r + DI[d];\n int nc = c + DJ[d];\n if (nr<0||nr>=N||nc<0||nc>=N) continue;\n if (board[nr][nc]==-1) continue; // empty cell \u2013 cannot be part of the tree\n if (visited[nr][nc]) continue;\n visited[nr][nc] = true;\n st.emplace(nr,nc);\n edges.push_back({{r,c},{nr,nc}});\n }\n }\n int cnt = 0;\n for (int i=0;i> requiredMaskGrid(N, vector(N, 0));\n for (auto &e : edges) {\n auto p1 = e.first, p2 = e.second;\n int r1 = p1.first, c1 = p1.second;\n int r2 = p2.first, c2 = p2.second;\n int dr = r2 - r1, dc = c2 - c1;\n if (dr == 1) { // second cell is below first\n requiredMaskGrid[r1][c1] |= BIT_DOWN;\n requiredMaskGrid[r2][c2] |= BIT_UP;\n } else if (dr == -1) { // second cell is above first\n requiredMaskGrid[r1][c1] |= BIT_UP;\n requiredMaskGrid[r2][c2] |= BIT_DOWN;\n } else if (dc == 1) { // right\n requiredMaskGrid[r1][c1] |= BIT_RIGHT;\n requiredMaskGrid[r2][c2] |= BIT_LEFT;\n } else { // left\n requiredMaskGrid[r1][c1] |= BIT_LEFT;\n requiredMaskGrid[r2][c2] |= BIT_RIGHT;\n }\n }\n\n // ----- build the bipartite graph (cell -> tile) using equality of masks\n vector requiredMask(M);\n for (int i=0;i moves;\n moves.reserve(T);\n\n auto applyMove = [&](char dir) {\n int ex = emptyPos.first, ey = emptyPos.second;\n int nx = ex, ny = ey;\n if (dir == 'U') nx--;\n else if (dir == 'D') nx++;\n else if (dir == 'L') ny--;\n else if (dir == 'R') ny++;\n // neighbour must exist (the algorithm guarantees it)\n int tile = board[nx][ny];\n // swap\n board[ex][ey] = tile;\n board[nx][ny] = -1;\n if (tile != -1) tilePos[tile] = {nx, ny};\n emptyPos = {nx, ny};\n moves.push_back(dir);\n };\n\n auto moveEmptyTo = [&](int tr, int tc) {\n while (emptyPos.first > tr) applyMove('U');\n while (emptyPos.first < tr) applyMove('D');\n while (emptyPos.second > tc) applyMove('L');\n while (emptyPos.second < tc) applyMove('R');\n };\n\n // greedy placement\n while (true) {\n // find tile with minimal (empty distance + 1)\n int bestTile = -1;\n int bestCost = INT_MAX;\n int bestNeedX = -1, bestNeedY = -1;\n int bestStepX = 0, bestStepY = 0;\n\n for (int tid = 0; tid < M; ++tid) {\n auto cur = tilePos[tid];\n auto tgt = targetPos[tid];\n if (cur == tgt) continue;\n int dx = tgt.first - cur.first;\n int dy = tgt.second - cur.second;\n\n // vertical move\n if (dx != 0) {\n int step = sgn(dx);\n int nx = cur.first + step;\n int ny = cur.second;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = tid;\n bestNeedX = nx; bestNeedY = ny;\n bestStepX = step; bestStepY = 0;\n }\n }\n // horizontal move\n if (dy != 0) {\n int step = sgn(dy);\n int nx = cur.first;\n int ny = cur.second + step;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = tid;\n bestNeedX = nx; bestNeedY = ny;\n bestStepX = 0; bestStepY = step;\n }\n }\n }\n if (bestTile == -1) break; // all tiles are on target\n\n // move empty square to the needed neighbour\n moveEmptyTo(bestNeedX, bestNeedY);\n\n // slide the chosen tile one step\n char cmd;\n if (bestStepX != 0) {\n cmd = (bestStepX == -1) ? 'D' : 'U';\n } else {\n cmd = (bestStepY == -1) ? 'R' : 'L';\n }\n applyMove(cmd);\n\n // after the slide the tile has moved one step\n tilePos[bestTile].first += bestStepX;\n tilePos[bestTile].second += bestStepY;\n\n if ((int)moves.size() >= T) break;\n }\n\n // --------------------------------------------------------\n // Output\n string out(moves.begin(), moves.end());\n cout << out << \"\\n\";\n\n // --------------------------------------------------------\n // (optional) verification \u2013 compute the score locally\n // -------------------------------------------------------------\n // build graph from final board\n int maxTreeSize = 0;\n int V = 0;\n vector> vid(N, vector(N, -1));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1) vid[i][j] = V++;\n\n vector> g(V);\n auto addEdge = [&](int r1,int c1,int r2,int c2){\n if (r2<0||r2>=N||c2<0||c2>=N) return;\n if (board[r1][c1]==-1 || board[r2][c2]==-1) return;\n int m1 = tileMask[board[r1][c1]];\n int m2 = tileMask[board[r2][c2]];\n bool ok = false;\n if (r2 == r1+1) { // downwards\n if ((m1 & BIT_DOWN) && (m2 & BIT_UP)) ok = true;\n } else if (c2 == c1+1) { // rightwards\n if ((m1 & BIT_RIGHT) && (m2 & BIT_LEFT)) ok = true;\n }\n if (ok) {\n int u = vid[r1][c1], v = vid[r2][c2];\n g[u].push_back(v);\n g[v].push_back(u);\n }\n };\n\n for (int i=0;i seen(V,0);\n for (int i=0;i q;\n q.push(i); seen[i]=1;\n while(!q.empty()){\n int u=q.front(); q.pop();\n ++vertices;\n edges += (int)g[u].size();\n for(int v:g[u]) if(!seen[v]){\n seen[v]=1; q.push(v);\n }\n }\n edges /= 2;\n if (edges == vertices-1) // a tree\n maxTreeSize = max(maxTreeSize, vertices);\n }\n\n // -------------------------------------------------------------\n // the program does not have to output the score,\n // only the move string is required.\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\n\nconst int64 R = 10000; // radius of the cake\nconst int64 COORD_MIN = -R + 1; // -9999\nconst int64 COORD_MAX = R - 1; // 9999\n\n/* --------------------------------------------------------------- */\nstruct Point {\n int64 x, y;\n};\n\nstruct Line {\n Point p1, p2; // two integer points on the line\n int64 dx, dy; // p2 - p1\n};\n\n/* create a line from two points (dx,dy are computed) */\nLine make_line(int64 x1, int64 y1, int64 x2, int64 y2) {\n Line L;\n L.p1 = {x1, y1};\n L.p2 = {x2, y2};\n L.dx = x2 - x1;\n L.dy = y2 - y1;\n return L;\n}\n\n/* --------------------------------------------------------------- */\n/* generate one random line that does NOT contain any strawberry */\nbool generate_random_line(const vector& pts,\n mt19937_64& rng,\n Line& L)\n{\n const int MAX_TRIES = 200;\n uniform_int_distribution dist(COORD_MIN, COORD_MAX);\n for (int t = 0; t < MAX_TRIES; ++t) {\n int64 x1 = dist(rng), y1 = dist(rng);\n int64 x2 = dist(rng), y2 = dist(rng);\n if (x1 == x2 && y1 == y2) continue; // distinct points\n\n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (const auto& p : pts) {\n int64 cross = dx * (p.y - y1) - dy * (p.x - x1);\n if (cross == 0) { ok = false; break; } // hits a strawberry\n }\n if (ok) {\n L = make_line(x1, y1, x2, y2);\n return true;\n }\n }\n return false; // should be extremely rare\n}\n\n/* --------------------------------------------------------------- */\n/* evaluate a set of lines, return \u03a3 min(ad, bd) */\nint evaluate(const vector& lines,\n const vector& pts,\n const array& a)\n{\n unordered_map cnt;\n cnt.reserve(16384);\n for (const auto& p : pts) {\n uint64_t h = 0;\n for (const auto& L : lines) {\n int side = (L.dx * (p.y - L.p1.y) - L.dy * (p.x - L.p1.x) > 0) ? 1 : 0;\n h = h * 3 + side; // 3\u2011ary hash, overflow is fine\n }\n ++cnt[h];\n }\n int b[11] = {0};\n for (auto &kv : cnt) {\n int c = kv.second;\n if (1 <= c && c <= 10) ++b[c];\n }\n int sumMin = 0;\n for (int d = 1; d <= 10; ++d) sumMin += min(a[d], b[d]);\n return sumMin;\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n if (!(cin >> N >> K)) return 0;\n array a{};\n for (int d = 1; d <= 10; ++d) cin >> a[d];\n vector pts(N);\n for (int i = 0; i < N; ++i) cin >> pts[i].x >> pts[i].y;\n\n mt19937_64 rng(random_device{}());\n\n vector bestLines;\n int bestScore = -1;\n int totalA = 0;\n for (int d = 1; d <= 10; ++d) totalA += a[d];\n\n const int MAX_ITERS = 300;\n for (int iter = 0; iter < MAX_ITERS; ++iter) {\n // decide number of lines for this iteration\n int k;\n if (iter < 20) {\n k = K; // first tries: use all cuts\n } else {\n uniform_int_distribution distK(20, K);\n k = distK(rng);\n }\n\n vector cur;\n cur.reserve(k);\n for (int i = 0; i < k; ++i) {\n Line L;\n if (generate_random_line(pts, rng, L))\n cur.push_back(L);\n }\n if (cur.empty()) continue; // should not happen\n\n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break; // cannot do better\n }\n }\n\n /* ----------------------------------------------------------- */\n cout << (int)bestLines.size() << '\\n';\n for (const auto& L : bestLines) {\n cout << L.p1.x << ' ' << L.p1.y << ' '\n << L.p2.x << ' ' << L.p2.y << '\\n';\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2, x3, y3, x4, y4;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n if (!(cin >> N >> M)) return 0;\n\n vector> dot(N, vector(N, 0));\n vector> init;\n for (int i = 0; i < M; ++i) {\n int x, y; cin >> x >> y;\n dot[x][y] = 1;\n init.emplace_back(x, y);\n }\n\n /* ----- edges --------------------------------------------------- */\n vector> hor(N, vector(N, 0)); // (x,y)-(x+1,y)\n vector> ver(N, vector(N, 0)); // (x,y)-(x,y+1)\n\n /* ----- row / column lists of dotted points -------------------- */\n vector> rowDots(N), colDots(N);\n for (auto &p : init) {\n int x = p.first, y = p.second;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n }\n\n /* ----- all empty points ---------------------------------------- */\n vector> empty;\n for (int x = 0; x < N; ++x)\n for (int y = 0; y < N; ++y)\n if (!dot[x][y]) empty.emplace_back(x, y);\n\n vector answer;\n\n /* ----- helper lambdas ----------------------------------------- */\n auto sidesEmpty = [&](int x, int y, int x2, int y2) -> bool {\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n // side (x,y)-(x2,y)\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y]) return false;\n // side (x,y)-(x,y2)\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x][yi]) return false;\n // side (x2,y)-(x2,y2)\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x2][yi]) return false;\n // side (x,y2)-(x2,y2)\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y2]) return false;\n return true;\n };\n\n auto edgesFree = [&](int x, int y, int x2, int y2) -> bool {\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n // horizontal side on row y\n for (int xi = xlo; xi < xhi; ++xi)\n if (hor[xi][y]) return false;\n // vertical side on column x\n for (int yi = ylo; yi < yhi; ++yi)\n if (ver[x][yi]) return false;\n // horizontal side on row y2\n for (int xi = xlo; xi < xhi; ++xi)\n if (hor[xi][y2]) return false;\n // vertical side on column x2\n for (int yi = ylo; yi < yhi; ++yi)\n if (ver[x2][yi]) return false;\n return true;\n };\n\n auto addRect = [&](int x, int y, int x2, int y2) {\n Rect r{ x, y, x2, y, x2, y2, x, y2 };\n answer.push_back(r);\n\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n for (int xi = xlo; xi < xhi; ++xi) hor[xi][y] = 1;\n for (int yi = ylo; yi < yhi; ++yi) ver[x][yi] = 1;\n for (int xi = xlo; xi < xhi; ++xi) hor[xi][y2] = 1;\n for (int yi = ylo; yi < yhi; ++yi) ver[x2][yi] = 1;\n\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n };\n\n function tryAdd = [&](int x, int y) -> bool {\n const vector &cols = rowDots[y]; // points in same row\n const vector &rows = colDots[x]; // points in same column\n for (int x2 : cols) {\n if (x2 == x) continue;\n for (int y2 : rows) {\n if (y2 == y) continue;\n if (!dot[x2][y2]) continue; // opposite corner must exist\n if (!sidesEmpty(x, y, x2, y2)) continue;\n if (!edgesFree(x, y, x2, y2)) continue;\n addRect(x, y, x2, y2);\n return true;\n }\n }\n return false;\n };\n\n /* ----- main greedy loop --------------------------------------- */\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n while (true) {\n bool progress = false;\n shuffle(empty.begin(), empty.end(), rng);\n for (size_t i = 0; i < empty.size(); ++i) {\n int x = empty[i].first, y = empty[i].second;\n if (tryAdd(x, y)) {\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n break; // restart with fresh list\n }\n }\n if (!progress) break;\n }\n\n /* ----- output -------------------------------------------------- */\n cout << answer.size() << '\\n';\n for (const auto &r : answer) {\n cout << r.x1 << ' ' << r.y1 << ' '\n << r.x2 << ' ' << r.y2 << ' '\n << r.x3 << ' ' << r.y3 << ' '\n << r.x4 << ' ' << r.y4 << '\\n';\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nconstexpr int H = 10;\nconstexpr int W = 10;\nconstexpr int MAXC = 100;\n\nint flavor[MAXC + 1];\n\nvoid copyBoard(const int src[H][W], int dst[H][W]) {\n for (int i = 0; i < H; ++i)\n for (int j = 0; j < W; ++j)\n dst[i][j] = src[i][j];\n}\n\nvoid tiltBoard(int a[H][W], char dir) {\n if (dir == 'F') {\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = 0; r < H; ++r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[i][c] = buf[i];\n }\n } else if (dir == 'B') {\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = H - 1; r >= 0; --r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[H - 1 - i][c] = buf[i];\n }\n } else if (dir == 'L') {\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = 0; c < W; ++c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][i] = buf[i];\n }\n } else if (dir == 'R') {\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = W - 1; c >= 0; --c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][W - 1 - i] = buf[i];\n }\n }\n}\n\nstruct Eval {\n int sumSq;\n int maxSize;\n int compCnt;\n};\n\nEval evaluate(const int a[H][W]) {\n bool vis[H][W] = {false};\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n\n Eval res{0, 0, 0};\n for (int r = 0; r < H; ++r) {\n for (int c = 0; c < W; ++c) {\n if (a[r][c] && !vis[r][c]) {\n int fl = a[r][c];\n int sz = 0;\n queue> q;\n q.emplace(r, c);\n vis[r][c] = true;\n while (!q.empty()) {\n auto [cr, cc] = q.front(); q.pop();\n ++sz;\n for (int d = 0; d < 4; ++d) {\n int nr = cr + dr[d];\n int nc = cc + dc[d];\n if (nr >= 0 && nr < H && nc >= 0 && nc < W &&\n !vis[nr][nc] && a[nr][nc] == fl) {\n vis[nr][nc] = true;\n q.emplace(nr, nc);\n }\n }\n }\n res.sumSq += sz * sz;\n res.maxSize = max(res.maxSize, sz);\n ++res.compCnt;\n }\n }\n }\n return res;\n}\n\nstatic const char DIRS[4] = {'F', 'B', 'L', 'R'};\n\nchar oppositeDir(char d) {\n if (d == 'F') return 'B';\n if (d == 'B') return 'F';\n if (d == 'L') return 'R';\n return 'L';\n}\n\nchar bestDirOneStep(const int board[H][W]) {\n char bestDir = 'R';\n Eval best{-1, -1, INT_MAX};\n for (char d : DIRS) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n Eval ev = evaluate(tmp);\n if (ev.sumSq > best.sumSq ||\n (ev.sumSq == best.sumSq && ev.maxSize > best.maxSize) ||\n (ev.sumSq == best.sumSq && ev.maxSize == best.maxSize && ev.compCnt < best.compCnt)) {\n best = ev;\n bestDir = d;\n }\n }\n return bestDir;\n}\n\nvector> getEmpty(const int board[H][W]) {\n vector> v;\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n if (board[r][c] == 0) v.emplace_back(r, c);\n return v;\n}\n\n// Depth-2 look-ahead with full enumeration (stable version)\ndouble expectedAfterTwoSteps(const int board[H][W], int curStep) {\n int nextStep = curStep + 1;\n if (nextStep > MAXC) return evaluate(board).sumSq;\n\n vector> empties = getEmpty(board);\n int cnt = (int)empties.size();\n if (cnt == 0) return evaluate(board).sumSq;\n\n double total = 0.0;\n int flNext = flavor[nextStep];\n \n // For each possible position of the next candy\n for (auto &ec : empties) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tmp[ec.first][ec.second] = flNext; // place next candy\n \n // Find greedy best direction after placement\n char d1 = bestDirOneStep(tmp);\n tiltBoard(tmp, d1);\n \n total += evaluate(tmp).sumSq;\n }\n return total / cnt;\n}\n\n// More sophisticated depth-2 with better evaluation\ndouble expectedAfterTwoStepsV2(const int board[H][W], int curStep) {\n int nextStep = curStep + 1;\n if (nextStep > MAXC) {\n Eval e = evaluate(board);\n return e.sumSq * 1.0; // final score\n }\n\n vector> empties = getEmpty(board);\n int cnt = (int)empties.size();\n if (cnt == 0) {\n Eval e = evaluate(board);\n return e.sumSq * 1.0;\n }\n\n // Early steps: use smaller lookahead\n if (curStep < 10) {\n // For early steps, just evaluate the immediate sumSq after greedy tilt\n char d = bestDirOneStep(board);\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n Eval e = evaluate(tmp);\n return e.sumSq * 1.0;\n }\n\n double total = 0.0;\n int flNext = flavor[nextStep];\n \n for (auto &ec : empties) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tmp[ec.first][ec.second] = flNext;\n \n // Try all 4 directions and pick the best one\n char bestDir = 'F';\n Eval bestEval{-1, -1, INT_MAX};\n \n for (char d : DIRS) {\n int tmp2[H][W];\n copyBoard(tmp, tmp2);\n tiltBoard(tmp2, d);\n Eval ev = evaluate(tmp2);\n \n // Use weighted score: sumSq + 0.5*maxSize - 2*compCnt\n double score = ev.sumSq + 0.5 * ev.maxSize - 2.0 * ev.compCnt;\n double bestScore = bestEval.sumSq + 0.5 * bestEval.maxSize - 2.0 * bestEval.compCnt;\n \n if (score > bestScore) {\n bestScore = score;\n bestDir = d;\n bestEval = ev;\n }\n }\n \n // Apply best direction\n tiltBoard(tmp, bestDir);\n Eval finalEval = evaluate(tmp);\n total += finalEval.sumSq;\n }\n return total / cnt;\n}\n\nchar chooseDirection(const int board[H][W], int curStep) {\n double bestScore = -1.0;\n char bestDir = 'R';\n \n for (char d : DIRS) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n double expScore = expectedAfterTwoStepsV2(tmp, curStep);\n if (expScore > bestScore + 1e-9) {\n bestScore = expScore;\n bestDir = d;\n }\n }\n return bestDir;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n for (int i = 1; i <= MAXC; ++i) {\n if (!(cin >> flavor[i])) return 0;\n }\n\n int board[H][W] = {0};\n\n vector> empties;\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n empties.emplace_back(r, c);\n\n for (int step = 1; step <= MAXC; ++step) {\n int p;\n cin >> p;\n auto cell = empties[p - 1];\n board[cell.first][cell.second] = flavor[step];\n empties.erase(empties.begin() + (p - 1));\n\n char dir;\n if (step == MAXC) {\n dir = bestDirOneStep(board);\n } else {\n dir = chooseDirection(board, step);\n }\n\n cout << dir << '\\n' << std::flush;\n tiltBoard(board, dir);\n\n empties.clear();\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n if (board[r][c] == 0) empties.emplace_back(r, c);\n }\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int M;\n long double eps;\n if (!(cin >> M >> eps)) return 0;\n\n const int MAX_E = 4950; // N = 100 \u2192 E = 4950\n vector lfac(MAX_E + 1);\n lfac[0] = 0;\n for (int i = 1; i <= MAX_E; ++i) lfac[i] = lfac[i - 1] + logl((long double)i);\n\n // smallest N such that N(N\u20111)/2 \u2265 M\u20111\n int minN = 4;\n while (minN * (minN - 1) / 2 < M - 1) ++minN;\n\n int bestN = minN;\n long double bestScore = -1.0L;\n\n // epsilon = 0 \u2192 perfect recovery, choose smallest N\n if (fabsl(eps) < 1e-12L) {\n bestN = minN;\n } else {\n const long double oneMinus2eps = 1.0L - 2.0L * eps;\n\n for (int N = minN; N <= 100; ++N) {\n int E = N * (N - 1) / 2;\n\n // edge counts mi\n vector mi(M);\n for (int i = 0; i < M; ++i) {\n mi[i] = (int)floor((long double)i * E / (M - 1));\n }\n\n // log probabilities for every hypothesis\n vector logp(M), log1mp(M);\n for (int i = 0; i < M; ++i) {\n long double p = eps + oneMinus2eps * (long double)mi[i] / (long double)E;\n logp[i] = logl(p);\n log1mp[i] = log1pl(-p); // log(1-p)\n }\n\n // log binomial coefficients for this E\n vector logBinomE(E + 1);\n for (int x = 0; x <= E; ++x) {\n logBinomE[x] = lfac[E] - lfac[x] - lfac[E - x];\n }\n\n // total_correct = \u03a3_x max_i Pr[ X = x | mi ]\n long double total_correct = 0.0L;\n for (int x = 0; x <= E; ++x) {\n long double log_common = logBinomE[x];\n long double max_val = -numeric_limits::infinity();\n for (int i = 0; i < M; ++i) {\n // cur = log_common + x*logp[i] + (E-x)*log1mp[i]\n long double cur = log_common + (long double)x * logp[i] +\n (long double)(E - x) * log1mp[i];\n if (cur > max_val) max_val = cur;\n }\n total_correct += expl(max_val);\n }\n\n long double p_err = 1.0L - total_correct / (long double)M;\n if (p_err < 0) p_err = 0;\n\n long double factor = powl(1.0L - 0.1L * p_err, 100);\n long double score = 1e9L * factor / (long double)N;\n\n if (score > bestScore) {\n bestScore = score;\n bestN = N;\n }\n }\n }\n\n // ----- produce output with the chosen N -----\n int N = bestN;\n int E = N * (N - 1) / 2;\n\n // recompute mi for the chosen N\n vector mi(M);\n for (int i = 0; i < M; ++i) {\n mi[i] = (int)floor((long double)i * E / (M - 1));\n }\n\n cout << N << \"\\n\";\n string edgeStr(E, '0');\n for (int idx = 0; idx < M; ++idx) {\n int ones = mi[idx];\n fill(edgeStr.begin(), edgeStr.end(), '0');\n for (int j = 0; j < ones; ++j) edgeStr[j] = '1';\n cout << edgeStr << \"\\n\";\n }\n cout.flush(); // required after the graphs\n\n // pre\u2011compute log\u2011probabilities for decoding\n vector logp(M), log1mp(M);\n const long double oneMinus2eps = 1.0L - 2.0L * eps;\n for (int i = 0; i < M; ++i) {\n long double p = eps + oneMinus2eps * (long double)mi[i] / (long double)E;\n logp[i] = logl(p);\n log1mp[i] = log1pl(-p);\n }\n\n // ----- answer the 100 queries -----\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n int x = 0;\n for (char c : H) if (c == '1') ++x;\n\n int answer;\n if (fabsl(eps) < 1e-12L) { // \u03b5 = 0 \u2192 exact edge count\n answer = (int)(lower_bound(mi.begin(), mi.end(), x) - mi.begin());\n } else {\n long double bestVal = -numeric_limits::infinity();\n answer = 0;\n for (int i = 0; i < M; ++i) {\n long double cur = (long double)x * logp[i] +\n (long double)(E - x) * log1mp[i];\n if (cur > bestVal) {\n bestVal = cur;\n answer = i;\n }\n }\n }\n cout << answer << \"\\n\";\n cout.flush();\n }\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n int w;\n};\n\nint N, M, D, K;\nvector edges;\nvector>> adj; // (to, edge id)\nvector> edge_adj; // line-graph adjacency\nvector> day_edges; // edges belonging to each day\nvector day_cnt;\nvector day_of_edge;\nvector mark; // timestamp for connectivity test\nvector visited;\nvector q; // BFS queue\nint cur_timestamp;\n\n// ---------------------------------------------------------------\n// Test whether adding 'cand' to day 'day' keeps the graph connected\nbool safe(int day, int cand) {\n ++cur_timestamp;\n for (int e : day_edges[day]) mark[e] = cur_timestamp;\n mark[cand] = cur_timestamp;\n\n fill(visited.begin(), visited.end(), 0);\n int qs = 0, qe = 0;\n visited[0] = 1;\n q[qe++] = 0;\n while (qs < qe) {\n int v = q[qs++];\n for (auto [to, eid] : adj[v]) {\n if (mark[eid] == cur_timestamp) continue;\n if (!visited[to]) {\n visited[to] = 1;\n q[qe++] = to;\n }\n }\n }\n\n for (int i = 0; i < N; ++i) if (!visited[i]) return false;\n return true;\n}\n\n// ---------------------------------------------------------------\nint metric_of_current() {\n int met = 0;\n for (int e = 0; e < M; ++e) {\n int d = day_of_edge[e];\n for (int nb : edge_adj[e]) {\n if (day_of_edge[nb] == d && nb < e) ++met;\n }\n }\n return met;\n}\n\n// ---------------------------------------------------------------\nvoid greedy_build(const vector& order) {\n for (int d = 0; d < D; ++d) {\n day_edges[d].clear();\n day_cnt[d] = 0;\n }\n fill(day_of_edge.begin(), day_of_edge.end(), -1);\n\n vector score(D, 0);\n\n for (int eid : order) {\n fill(score.begin(), score.end(), 0);\n for (int nb : edge_adj[eid]) {\n int d = day_of_edge[nb];\n if (d != -1) ++score[d];\n }\n\n int best_score = -1;\n vector cand;\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] >= K) continue;\n if (score[d] > best_score) {\n best_score = score[d];\n cand.clear();\n cand.push_back(d);\n } else if (score[d] == best_score) {\n cand.push_back(d);\n }\n }\n\n if (cand.empty()) continue;\n\n // Choose candidate with smallest day_cnt\n int chosen = cand[0];\n int min_cnt = day_cnt[chosen];\n for (size_t i = 1; i < cand.size(); ++i) {\n int d = cand[i];\n if (day_cnt[d] < min_cnt) {\n min_cnt = day_cnt[d];\n chosen = d;\n }\n }\n\n if (day_cnt[chosen] > 0 && !safe(chosen, eid)) {\n bool found = false;\n vector shuffled = cand;\n shuffle(shuffled.begin(), shuffled.end(), mt19937{random_device{}()});\n for (int d : shuffled) {\n if (d == chosen) continue;\n if (day_cnt[d] == 0 || safe(d, eid)) {\n chosen = d;\n found = true;\n break;\n }\n }\n if (!found) {\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K) {\n chosen = d;\n break;\n }\n }\n }\n }\n\n day_of_edge[eid] = chosen;\n ++day_cnt[chosen];\n day_edges[chosen].push_back(eid);\n }\n}\n\n// ---------------------------------------------------------------\nvoid local_search(int max_moves = 500) {\n int current_metric = metric_of_current();\n int moves_made = 0;\n bool improved = true;\n while (improved && moves_made < max_moves) {\n improved = false;\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), mt19937{random_device{}()});\n\n for (int eid : order) {\n int current_day = day_of_edge[eid];\n\n // Compute old_pairs once\n int old_pairs = 0;\n for (int nb : edge_adj[eid]) {\n if (day_of_edge[nb] == current_day) old_pairs++;\n }\n\n int best_delta = -1;\n int best_day = -1;\n\n for (int d = 0; d < D; ++d) {\n if (d == current_day) continue;\n if (day_cnt[d] >= K) continue;\n\n // Compute new_pairs (number of neighbors in day d)\n int new_pairs = 0;\n for (int nb : edge_adj[eid]) {\n if (day_of_edge[nb] == d) new_pairs++;\n }\n\n int delta = new_pairs - old_pairs;\n if (delta > best_delta) {\n best_delta = delta;\n best_day = d;\n }\n }\n\n if (best_delta > 0 && best_day != -1) {\n if (day_cnt[best_day] == 0 || safe(best_day, eid)) {\n // Move edge\n day_edges[current_day].erase(\n remove(day_edges[current_day].begin(), day_edges[current_day].end(), eid),\n day_edges[current_day].end()\n );\n --day_cnt[current_day];\n\n day_of_edge[eid] = best_day;\n ++day_cnt[best_day];\n day_edges[best_day].push_back(eid);\n\n current_metric += best_delta;\n moves_made++;\n improved = true;\n break;\n }\n }\n }\n }\n}\n\n// ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n if (!(cin >> N >> M >> D >> K)) return 0;\n edges.resize(M);\n adj.assign(N, {});\n vector> vertex_edges[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 adj[u].push_back({v, i});\n adj[v].push_back({u, i});\n vertex_edges[u].push_back({v, i});\n vertex_edges[v].push_back({u, i});\n }\n\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n // Build line-graph adjacency\n edge_adj.assign(M, {});\n for (int v = 0; v < N; ++v) {\n for (size_t a = 0; a < vertex_edges[v].size(); ++a) {\n int e1 = vertex_edges[v][a].second;\n for (size_t b = a + 1; b < vertex_edges[v].size(); ++b) {\n int e2 = vertex_edges[v][b].second;\n edge_adj[e1].push_back(e2);\n edge_adj[e2].push_back(e1);\n }\n }\n }\n\n day_edges.assign(D, {});\n day_cnt.assign(D, 0);\n day_of_edge.assign(M, -1);\n mark.assign(M, -1);\n visited.assign(N, 0);\n q.resize(N);\n cur_timestamp = 0;\n\n const int ITERATIONS = 30;\n int best_metric = -1;\n vector best_assignment;\n\n for (int it = 0; it < ITERATIONS; ++it) {\n vector order(M);\n iota(order.begin(), order.end(), 0);\n\n if (rand() % 2 == 0) {\n shuffle(order.begin(), order.end(), mt19937{random_device{}()});\n } else {\n sort(order.begin(), order.end(), [&](int a, int b) {\n return edges[a].w < edges[b].w;\n });\n for (int i = 0; i < 50; ++i) {\n int a = rand() % M;\n int b = rand() % M;\n swap(order[a], order[b]);\n }\n }\n\n greedy_build(order);\n int met = metric_of_current();\n\n local_search(500);\n\n int met_after = metric_of_current();\n if (met_after > met) met = met_after;\n\n if (met > best_metric) {\n best_metric = met;\n best_assignment = day_of_edge;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n if (i) cout << ' ';\n cout << (best_assignment[i] + 1);\n }\n cout << '\\n';\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n if (!(cin >> D)) return 0;\n vector f1(D), r1(D), f2(D), r2(D);\n for (int i = 0; i < D; i++) cin >> f1[i];\n for (int i = 0; i < D; i++) cin >> r1[i];\n for (int i = 0; i < D; i++) cin >> f2[i];\n for (int i = 0; i < D; i++) cin >> r2[i];\n \n // O1[x][y][z] = 1 if position is in object 1's minimal covering\n // O2[x][y][z] = 1 if position is in object 2's minimal covering\n vector>> O1(D, vector>(D, vector(D, 0)));\n vector>> O2(D, vector>(D, vector(D, 0)));\n \n auto min_edge_cover = [&](const vector& F, const vector& R, \n vector>>& O, int z) {\n int nF = F.size(), nR = R.size();\n if (nF == 0 || nR == 0) return;\n \n if (nF >= nR) {\n // Match each y in R to distinct x in F\n for (int i = 0; i < nR; i++) {\n O[F[i]][R[i]][z] = 1;\n }\n // Remaining x in F connect to R[0]\n for (int i = nR; i < nF; i++) {\n O[F[i]][R[0]][z] = 1;\n }\n } else {\n // Match each x in F to distinct y in R\n for (int i = 0; i < nF; i++) {\n O[F[i]][R[i]][z] = 1;\n }\n // Remaining y in R connect to F[0]\n for (int i = nF; i < nR; i++) {\n O[F[0]][R[i]][z] = 1;\n }\n }\n };\n \n // Build O1 using silhouette pair 1\n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f1[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r1[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O1, z);\n }\n \n // Build O2 using silhouette pair 2\n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f2[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r2[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O2, z);\n }\n \n // Find connected components in O1 U O2\n vector>> comp_id(D, vector>(D, vector(D, -1)));\n vector>> components;\n const int dx[6] = {1,-1,0,0,0,0};\n const int dy[6] = {0,0,1,-1,0,0};\n const int dz[6] = {0,0,0,0,1,-1};\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if ((O1[x][y][z] || O2[x][y][z]) && comp_id[x][y][z] == -1) {\n vector> comp;\n queue> q;\n q.push({x,y,z});\n comp_id[x][y][z] = components.size();\n while (!q.empty()) {\n auto [cx, cy, cz] = q.front(); q.pop();\n comp.emplace_back(cx, cy, cz);\n for (int dir = 0; dir < 6; dir++) {\n int nx = cx + dx[dir];\n int ny = cy + dy[dir];\n int nz = cz + dz[dir];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D || nz < 0 || nz >= D) continue;\n if ((O1[nx][ny][nz] || O2[nx][ny][nz]) && comp_id[nx][ny][nz] == -1) {\n comp_id[nx][ny][nz] = components.size();\n q.push({nx, ny, nz});\n }\n }\n }\n components.push_back(comp);\n }\n }\n }\n }\n \n int n = components.size();\n // Map position to block index (1-based)\n vector>> idx(D, vector>(D, vector(D, 0)));\n for (int i = 0; i < n; i++) {\n for (auto& p : components[i]) {\n int x, y, z;\n tie(x, y, z) = p;\n idx[x][y][z] = i + 1; // 1-based index\n }\n }\n \n // Output\n cout << n << \"\\n\";\n // b1: flatten with order x*D*D + y*D + z\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O1[x][y][z]) {\n cout << idx[x][y][z];\n } else {\n cout << 0;\n }\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n // b2\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O2[x][y][z]) {\n cout << idx[x][y][z];\n } else {\n cout << 0;\n }\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n return 0;\n}","ahc020":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n long long w;\n int idx;\n};\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n r.assign(n, 0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nint N, M, K;\nvector> vertex; // (x,y)\nvector> resident; // (a,b)\nvector edges; // original order\nvector edgesSorted; // sorted by weight\nvector> dist2; // N x K\nvector>> cand; // per resident, stations within 5000, sorted\n\n// ---------------------------------------------------------------\n// price of a set 'sel' (sel[i]==1 <=> station i is reachable)\nconst long long INF = (1LL<<60);\n\nlong long price_of(const vector& sel) {\n // ----- edge cost (MST on induced subgraph) -----\n long long edgeCost = 0;\n DSU dsu(N);\n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v))\n edgeCost += e.w;\n }\n }\n\n // ----- radii -----\n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n bool ok = false;\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (sel[i]) {\n long long d2 = pr.second;\n if (maxDistSq[i] < d2) maxDistSq[i] = d2;\n ok = true;\n break; // nearest selected station\n }\n }\n if (!ok) return INF; // resident not covered\n }\n\n long long sumP2 = 0;\n for (int i = 0; i < N; ++i) {\n if (!sel[i]) continue;\n long long md2 = maxDistSq[i];\n long long P;\n if (md2 < 0) {\n P = 0;\n } else {\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n P = r;\n }\n sumP2 += P * P;\n }\n return edgeCost + sumP2;\n}\n\n// ---------------------------------------------------------------\n// MST edges for a given set, returns vector B (size M)\nvector mst_edges(const vector& sel) {\n vector B(M, 0);\n DSU dsu(N);\n int need = 0;\n for (int i = 0; i < N; ++i) if (sel[i]) ++need;\n if (need <= 1) return B;\n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v)) {\n B[e.idx] = 1;\n if (--need == 1) break;\n }\n }\n }\n return B;\n}\n\n// ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n // ----- read input -----\n if (!(cin >> N >> M >> K)) return 0;\n vertex.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> vertex[i].first >> vertex[i].second;\n }\n edges.resize(M);\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, j};\n }\n resident.resize(K);\n for (int k = 0; k < K; ++k) {\n cin >> resident[k].first >> resident[k].second;\n }\n\n // ----- preprocessing -----\n dist2.assign(N, vector(K, 0));\n const long long R2 = 5000LL * 5000LL;\n cand.assign(K, {});\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n long long dx = vertex[i].first - resident[k].first;\n long long dy = vertex[i].second - resident[k].second;\n long long d2 = dx*dx + dy*dy;\n dist2[i][k] = d2;\n if (d2 <= R2) cand[k].push_back({i, d2});\n }\n }\n for (int k = 0; k < K; ++k)\n sort(cand[k].begin(), cand[k].end(),\n [](const auto& a, const auto& b){ return a.second < b.second; });\n\n edgesSorted = edges;\n sort(edgesSorted.begin(), edgesSorted.end(),\n [](const Edge& a, const Edge& b){ return a.w < b.w; });\n\n // ----- initial solution (all vertices) -----\n vector sel(N, 1);\n sel[0] = 1; // station 1 is always reachable\n long long curCost = price_of(sel);\n\n // ---------- greedy removal ----------\n bool changed = true;\n while (changed) {\n changed = false;\n long long bestGain = 0;\n int bestV = -1;\n for (int v = 1; v < N; ++v) {\n if (!sel[v]) continue;\n // coverage test without v\n bool ok = true;\n for (int k = 0; k < K && ok; ++k) {\n bool any = false;\n for (auto &pr : cand[k]) {\n if (sel[pr.first] && pr.first != v) { any = true; break; }\n }\n if (!any) ok = false;\n }\n if (!ok) continue;\n\n sel[v] = 0;\n long long newCost = price_of(sel);\n sel[v] = 1;\n if (newCost < curCost && curCost - newCost > bestGain) {\n bestGain = curCost - newCost;\n bestV = v;\n }\n }\n if (bestV != -1) {\n sel[bestV] = 0;\n curCost -= bestGain;\n changed = true;\n }\n }\n\n // ---------- greedy addition ----------\n changed = true;\n while (changed) {\n changed = false;\n long long bestGain = 0;\n int bestV = -1;\n for (int v = 1; v < N; ++v) {\n if (sel[v]) continue;\n sel[v] = 1;\n long long newCost = price_of(sel);\n sel[v] = 0;\n if (newCost < curCost && curCost - newCost > bestGain) {\n bestGain = curCost - newCost;\n bestV = v;\n }\n }\n if (bestV != -1) {\n sel[bestV] = 1;\n curCost -= bestGain;\n changed = true;\n }\n }\n\n // ----- final radii (for output) -----\n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (sel[i]) {\n if (maxDistSq[i] < pr.second) maxDistSq[i] = pr.second;\n break; // nearest selected\n }\n }\n }\n vector P(N, 0);\n for (int i = 0; i < N; ++i) {\n if (!sel[i]) { P[i] = 0; continue; }\n long long md2 = maxDistSq[i];\n if (md2 < 0) { P[i] = 0; continue; }\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n P[i] = r;\n }\n\n // ----- edges that are ON -----\n vector B = mst_edges(sel);\n\n // ----- output -----\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << P[i];\n }\n cout << '\\n';\n for (int j = 0; j < M; ++j) {\n if (j) cout << ' ';\n cout << B[j];\n }\n cout << '\\n';\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconst int N = 30;\nconst int TOTAL = N * (N + 1) / 2;\n\n/* --------------------------------------------------------------- */\n/* data structures */\nstruct Op { int x1, y1, x2, y2; };\n\nint start_val[N][N];\n\n/* --------------------------------------------------------------- */\n/* auxiliary functions */\ninline bool inside(int x, int y) { return (0 <= x && x < N && 0 <= y && y <= x); }\n\ninline int child1_val(const int val[N][N], int x, int y) { return val[x + 1][y]; }\ninline int child2_val(const int val[N][N], int x, int y) { return val[x + 1][y + 1]; }\ninline int smaller_child_val(const int val[N][N], int x, int y) {\n return min(child1_val(val, x, y), child2_val(val, x, y));\n}\n\n/* --------------------------------------------------------------- */\n/* 1) bottom\u2011up heapify */\nvector build_bottom_up(const int src[N][N]) {\n int val[N][N];\n memcpy(val, src, sizeof(val));\n vector ops;\n\n auto do_swap = [&](int x1, int y1, int x2, int y2) {\n ops.push_back({x1, y1, x2, y2});\n swap(val[x1][y1], val[x2][y2]);\n };\n\n function sift_down = [&](int x, int y) {\n while (true) {\n if (x == N - 1) break;\n int c1v = val[x + 1][y];\n int c2v = val[x + 1][y + 1];\n int smaller_cx = c1v <= c2v ? x + 1 : x + 1;\n int smaller_cy = c1v <= c2v ? y : y + 1;\n int smaller_val = min(c1v, c2v);\n if (val[x][y] <= smaller_val) break;\n do_swap(x, y, smaller_cx, smaller_cy);\n x = smaller_cx; y = smaller_cy;\n }\n };\n\n for (int x = N - 2; x >= 0; --x)\n for (int y = 0; y <= x; ++y)\n sift_down(x, y);\n\n return ops;\n}\n\n/* --------------------------------------------------------------- */\n/* 2) hill climbing with focus on large misplaced elements */\nvector build_hill_climbing(const int src[N][N]) {\n int val[N][N];\n memcpy(val, src, sizeof(val));\n vector ops;\n const int MAX_OPS = 10000;\n\n auto do_swap = [&](int x1, int y1, int x2, int y2) -> bool {\n if ((int)ops.size() >= MAX_OPS) return false;\n ops.push_back({x1, y1, x2, y2});\n swap(val[x1][y1], val[x2][y2]);\n return true;\n };\n\n // Count violations at each node\n int violation_count[N][N] = {0};\n auto count_violations = [&](void) -> int {\n int total = 0;\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n if (val[x][y] > smaller_child_val(val, x, y))\n ++total;\n return total;\n };\n\n auto update_violations = [&](int px, int py) {\n for (int dx = -1; dx <= 1; ++dx)\n for (int dy = -1; dy <= 1; ++dy) {\n int nx = px + dx, ny = py + dy;\n if (!inside(nx, ny)) continue;\n bool was_viol = (nx < N - 1 && val[nx][ny] > smaller_child_val(val, nx, ny));\n violation_count[nx][ny] = was_viol ? 1 : 0;\n }\n };\n\n // Initialize violation counts\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n if (val[x][y] > smaller_child_val(val, x, y))\n violation_count[x][y] = 1;\n\n // Priority: (1) has violation, (2) node value (larger is better to move down)\n struct Candidate {\n int x, y; // parent position\n int child_cx, child_cy; // child to swap with\n int priority; // higher = better\n };\n\n auto get_best_swap = [&](void) -> Candidate {\n int best_priority = -1;\n Candidate best = {-1, -1, -1, -1, -1};\n \n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (x == N - 1) continue;\n if (val[x][y] <= smaller_child_val(val, x, y)) continue;\n \n int c1v = val[x + 1][y];\n int c2v = val[x + 1][y + 1];\n \n // Try swapping with the smaller child\n if (c1v < c2v && c1v < val[x][y]) {\n int priority = val[x][y] * 100 + (N - 1 - x); // value * 100 + depth\n if (priority > best_priority) {\n best_priority = priority;\n best = {x, y, x + 1, y, priority};\n }\n }\n if (c2v < c1v && c2v < val[x][y]) {\n int priority = val[x][y] * 100 + (N - 1 - x);\n if (priority > best_priority) {\n best_priority = priority;\n best = {x, y, x + 1, y + 1, priority};\n }\n }\n }\n }\n return best;\n };\n\n // Main hill climbing loop\n while (true) {\n Candidate c = get_best_swap();\n if (c.x == -1) break; // No more violations\n \n if (!do_swap(c.x, c.y, c.child_cx, c.child_cy)) break;\n \n // Update violations around affected positions\n update_violations(c.x, c.y);\n update_violations(c.child_cx, c.child_cy);\n }\n\n return ops;\n}\n\n/* --------------------------------------------------------------- */\n/* 3) improved greedy: prioritize large values at shallow depth */\nvector build_improved_greedy(const int src[N][N]) {\n int val[N][N];\n memcpy(val, src, sizeof(val));\n vector ops;\n const int MAX_OPS = 10000;\n\n bool in_queue[N][N] = {false};\n struct Node {\n int score; // higher = more important to fix\n int x, y;\n bool operator<(Node const& other) const {\n return score < other.score; // max-heap\n }\n };\n priority_queue pq;\n\n auto push_if_viol = [&](int x, int y) {\n if (x >= N - 1) return;\n int smaller = smaller_child_val(val, x, y);\n if (val[x][y] > smaller) {\n // Score = value * depth_factor + violation_size\n int depth = N - 1 - x;\n int violation_size = val[x][y] - smaller;\n int score = val[x][y] * 50 + violation_size * 10 + depth;\n pq.push({score, x, y});\n in_queue[x][y] = true;\n }\n };\n\n // Initial scan\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n push_if_viol(x, y);\n\n auto do_swap = [&](int x1, int y1, int x2, int y2) -> bool {\n if ((int)ops.size() >= MAX_OPS) return false;\n ops.push_back({x1, y1, x2, y2});\n swap(val[x1][y1], val[x2][y2]);\n return true;\n };\n\n while (!pq.empty() && (int)ops.size() < MAX_OPS) {\n Node cur = pq.top(); pq.pop();\n int x = cur.x, y = cur.y;\n if (!in_queue[x][y]) continue;\n \n // Re-check if still a violation\n if (x >= N - 1) { in_queue[x][y] = false; continue; }\n int smaller = smaller_child_val(val, x, y);\n if (val[x][y] <= smaller) { in_queue[x][y] = false; continue; }\n \n // Choose the child with smaller value\n int c1v = val[x + 1][y];\n int c2v = val[x + 1][y + 1];\n int cx = x + 1, cy = y;\n if (c2v < c1v) cy = y + 1;\n \n if (!do_swap(x, y, cx, cy)) break;\n in_queue[x][y] = false;\n\n // Mark affected positions for re-evaluation\n auto try_push = [&](int px, int py) {\n if (inside(px, py) && !in_queue[px][py])\n push_if_viol(px, py);\n };\n\n // Parent position\n try_push(x, y);\n // Child position\n try_push(cx, cy);\n // Other parent of child\n if (cy == y) { // left child\n if (y > 0) try_push(x, y - 1);\n } else { // right child\n if (y + 1 <= x) try_push(x, y + 1);\n }\n // Other parent of parent\n if (x > 0) {\n if (y > 0) try_push(x - 1, y - 1);\n if (y <= x - 1) try_push(x - 1, y);\n }\n }\n\n return ops;\n}\n\n/* --------------------------------------------------------------- */\n/* verify heap */\nbool is_heap(const int v[N][N]) {\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n if (v[x][y] > smaller_child_val(v, x, y))\n return false;\n return true;\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n for (int x = 0; x < N; ++x)\n for (int y = 0; y <= x; ++y)\n cin >> start_val[x][y];\n\n vector best_ops;\n int best_size = INT_MAX;\n\n // Try all methods and keep the smallest valid one\n vector> candidates = {\n build_bottom_up(start_val),\n build_hill_climbing(start_val),\n build_improved_greedy(start_val)\n };\n\n for (auto& ops : candidates) {\n int cur[N][N];\n memcpy(cur, start_val, sizeof(cur));\n for (auto const& op : ops)\n swap(cur[op.x1][op.y1], cur[op.x2][op.y2]);\n \n if (is_heap(cur) && (int)ops.size() <= 10000 && (int)ops.size() < best_size) {\n best_ops = ops;\n best_size = ops.size();\n }\n }\n\n cout << best_ops.size() << '\\n';\n for (auto const& op : best_ops)\n cout << op.x1 << ' ' << op.y1 << ' ' << op.x2 << ' ' << op.y2 << '\\n';\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int D, N;\n if (!(cin >> D >> N)) return 0;\n bool obstacle[9][9] = {};\n\n for (int k = 0; k < N; ++k) {\n int ri, rj; cin >> ri >> rj;\n obstacle[ri][rj] = true;\n }\n\n const int er = 0, ec = (D - 1) / 2;\n const int ENTRANCE_ID = D * D;\n const int TOTAL_NODES = D * D + 1;\n\n // BFS distances (ignoring containers)\n int dist[9][9];\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n dist[i][j] = -1;\n\n queue> q;\n dist[er][ec] = 0;\n q.emplace(er, ec);\n const int dr[4] = {-1,1,0,0};\n const int dc[4] = {0,0,-1,1};\n\n while (!q.empty()) {\n auto [r,c] = q.front(); q.pop();\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (dist[nr][nc] == -1) {\n dist[nr][nc] = dist[r][c] + 1;\n q.emplace(nr,nc);\n }\n }\n }\n\n // List of squares that may contain containers\n vector cells;\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n if (!obstacle[i][j] && !(i == er && j == ec))\n cells.push_back(i * D + j);\n\n const int M = (int)cells.size();\n\n // Sorted list of distances (the \"ideal\" distances)\n vector sortedDist;\n sortedDist.reserve(M);\n for (int id : cells) sortedDist.push_back(dist[id / D][id % D]);\n sort(sortedDist.begin(), sortedDist.end());\n\n // Occupied squares and assigned containers\n vector occupied(TOTAL_NODES, 0);\n vector assigned(M, -1);\n\n // ---------- data for articulation point search ----------\n auto buildNeighbours = [&](int node, vector& out) {\n out.clear();\n if (node == ENTRANCE_ID) {\n int r = er, c = ec;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (occupied[nr * D + nc]) continue; // Skip occupied squares\n int nid = nr * D + nc;\n out.push_back(nid);\n }\n } else {\n int r = node / D, c = node % D;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (occupied[nr * D + nc]) continue; // Skip occupied squares\n if (nr == er && nc == ec) out.push_back(ENTRANCE_ID);\n else out.push_back(nr * D + nc);\n }\n }\n };\n\n vector disc(TOTAL_NODES), low(TOTAL_NODES);\n vector visited(TOTAL_NODES, 0), isArt(TOTAL_NODES, 0);\n int timer = 0;\n\n function dfs = [&](int u, int parent) {\n visited[u] = 1;\n disc[u] = low[u] = ++timer;\n int children = 0;\n vector neigh;\n buildNeighbours(u, neigh);\n for (int v : neigh) {\n if (!visited[v]) {\n ++children;\n dfs(v, u);\n low[u] = min(low[u], low[v]);\n if (parent != -1 && low[v] >= disc[u]) isArt[u] = 1;\n } else if (v != parent) {\n low[u] = min(low[u], disc[v]);\n }\n }\n if (parent == -1 && children > 1) isArt[u] = 1;\n };\n\n auto getRemovable = [&]() -> vector {\n fill(visited.begin(), visited.end(), 0);\n fill(disc.begin(), disc.end(), 0);\n fill(low.begin(), low.end(), 0);\n fill(isArt.begin(), isArt.end(), 0);\n timer = 0;\n dfs(ENTRANCE_ID, -1);\n vector removable;\n for (int id : cells) {\n if (occupied[id]) continue; // Skip already occupied\n if (!isArt[id]) removable.push_back(id);\n }\n return removable;\n };\n\n // ---------- online placement ----------\n for (int step = 0; step < M; ++step) {\n int t; cin >> t;\n int targetDist = sortedDist[t];\n vector cand = getRemovable();\n int best = -1, bestDiff = INT_MAX, bestDist = -1;\n for (int id : cand) {\n int d = dist[id / D][id % D];\n int diff = abs(d - targetDist);\n if (diff < bestDiff || (diff == bestDiff && d > bestDist)) {\n bestDiff = diff;\n bestDist = d;\n best = id;\n }\n }\n // Safety: if no removable square found, pick any empty square\n if (best == -1) {\n for (int id : cells) if (!occupied[id]) { best = id; break; }\n }\n occupied[best] = 1;\n assigned[t] = best;\n cout << (best / D) << ' ' << (best % D) << \"\\n\" << flush;\n }\n\n // ---------- removal order (greedy, smallest reachable) ----------\n vector removalOrder;\n removalOrder.reserve(M);\n vector removed(M, 0);\n vector emptySquare(TOTAL_NODES, 0);\n emptySquare[ENTRANCE_ID] = 1; // entrance is empty\n\n for (int step = 0; step < M; ++step) {\n int chosen = -1;\n for (int num = 0; num < M; ++num) if (!removed[num]) {\n int id = assigned[num];\n int r = id / D, c = id % D;\n bool ok = false;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n int nid = (nr == er && nc == ec) ? ENTRANCE_ID : nr * D + nc;\n if (emptySquare[nid]) { ok = true; break; }\n }\n if (ok) { chosen = num; break; }\n }\n // Must exist\n removalOrder.push_back(chosen);\n removed[chosen] = 1;\n int id = assigned[chosen];\n emptySquare[id] = 1;\n }\n\n // ---------- output removal order ----------\n for (int num : removalOrder) {\n int id = assigned[num];\n cout << (id / D) << ' ' << (id % D) << \"\\n\" << flush;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> a(n, vector(n));\n for (int i = 0; i < n; ++i)\n for (int j = 0; j < n; ++j)\n cin >> a[i][j];\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << a[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nusing ll = long long;\nconst ll INF = (ll)4e18;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, D, Q;\n if (!(cin >> N >> D >> Q)) return 0;\n\n // ---------- 1. create list of all unordered pairs ----------\n vector> allPairs;\n allPairs.reserve(N*(N-1)/2);\n for (int i = 0; i < N; ++i)\n for (int j = i+1; j < N; ++j)\n allPairs.emplace_back(i,j);\n // random shuffle \u2013 we do not need a truly strong RNG\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n shuffle(allPairs.begin(), allPairs.end(), rng);\n\n // ---------- 2. answer Q questions ----------\n // direction cache: key = (min<<32) | max value: 1 = leftright, 0 = equal\n unordered_map dir;\n dir.reserve(Q*2);\n vector> adj(N);\n vector indeg(N,0);\n vector heavierCnt(N,0); // how many items are known heavier than this one\n size_t pairIdx = 0;\n for (int q = 0; q < Q; ++q) {\n pair p;\n if (pairIdx < allPairs.size())\n p = allPairs[pairIdx++];\n else\n p = {0,1}; // dummy pair, result will be ignored later\n\n cout << 1 << ' ' << 1 << ' ' << p.first << ' ' << p.second << '\\n' << std::flush;\n\n char c; cin >> c; // '<' , '>' or '='\n\n long long key = ( ( (long long)min(p.first,p.second) ) << 32 )\n | (long long)max(p.first,p.second);\n if (dir.find(key) != dir.end()) continue; // already known, ignore duplicate\n dir[key] = (c=='<') ? 1 : (c=='>') ? -1 : 0;\n\n if (c == '<') {\n int light = p.first, heavy = p.second;\n adj[light].push_back(heavy);\n ++indeg[heavy];\n ++heavierCnt[heavy];\n } else if (c == '>') {\n int light = p.second, heavy = p.first;\n adj[light].push_back(heavy);\n ++indeg[heavy];\n ++heavierCnt[heavy];\n } // '=' : nothing to store\n }\n\n // ---------- 3. topological order (light -> heavy) ----------\n vector indeg_cur = indeg;\n queue q0;\n for (int i = 0; i < N; ++i)\n if (indeg_cur[i] == 0) q0.push(i);\n vector topo;\n topo.reserve(N);\n while (!q0.empty()) {\n int v = q0.front(); q0.pop();\n topo.push_back(v);\n for (int to : adj[v]) {\n if (--indeg_cur[to] == 0) q0.push(to);\n }\n }\n // In the (unlikely) case of a cycle we just append remaining vertices\n if ((int)topo.size() < N) {\n vector rest;\n for (int i = 0; i < N; ++i)\n if (find(topo.begin(), topo.end(), i) == topo.end()) rest.push_back(i);\n topo.insert(topo.end(), rest.begin(), rest.end());\n }\n\n // ---------- 4. proxy weights (position + 1) ----------\n vector weight(N);\n for (int pos = 0; pos < N; ++pos) {\n int item = topo[pos];\n weight[item] = (ll)pos + 1; // 1 \u2026 N\n }\n\n // ---------- 5. DP for contiguous blocks ----------\n // prefix sums of weight in topological order\n vector pref(N+1,0);\n for (int i = 0; i < N; ++i) pref[i+1] = pref[i] + weight[topo[i]];\n\n vector> dp(D+1, vector(N+1, INF));\n vector> split(D+1, vector(N+1, -1));\n dp[0][0] = 0;\n for (int g = 1; g <= D; ++g) {\n for (int i = g; i <= N; ++i) { // we need at least g items for g groups\n ll best = INF;\n int bestj = -1;\n for (int j = g-1; j < i; ++j) {\n ll sum = pref[i] - pref[j];\n ll cand = dp[g-1][j] + sum*sum;\n if (cand < best) {\n best = cand;\n bestj = j;\n }\n }\n dp[g][i] = best;\n split[g][i] = bestj;\n }\n }\n\n // ---------- 6. reconstruct groups ----------\n vector groupOfPos(N, -1); // position in topo -> group id\n int curIdx = N;\n for (int g = D; g >= 1; --g) {\n int j = split[g][curIdx];\n for (int k = j; k < curIdx; ++k) groupOfPos[k] = g-1;\n curIdx = j;\n }\n\n // translate back to original item indices\n vector answer(N, -1);\n for (int pos = 0; pos < N; ++pos) {\n int item = topo[pos];\n answer[item] = groupOfPos[pos];\n }\n\n // ---------- 7. output ----------\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << answer[i];\n }\n cout << '\\n';\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n const int per = n / m;\n vector> st(m);\n vector> pos(n + 1);\n \n for (int i = 0; i < m; ++i) {\n st[i].reserve(per);\n for (int j = 0; j < per; ++j) {\n int x; cin >> x;\n st[i].push_back(x);\n pos[x] = {i, (int)st[i].size() - 1};\n }\n }\n\n vector> ops;\n \n for (int v = 1; v <= n; ++v) {\n int s = pos[v].first;\n \n // Move all boxes above v together in ONE operation\n while (!st[s].empty() && st[s].back() != v) {\n int posV = pos[v].second;\n int numAbove = st[s].size() - posV - 1;\n \n if (numAbove == 0) break;\n \n // The box just above v (lowest in the suffix)\n int boxToMove = st[s][posV + 1];\n \n // Choose destination: prefer stack with LARGEST top > boxToMove\n int dest = -1;\n int bestTop = -1; // Changed: prefer LARGEST top\n \n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty()) {\n int top = st[i].back();\n if (top > boxToMove && top > bestTop) {\n bestTop = top;\n dest = i;\n }\n }\n }\n \n // Fallback: empty stack\n if (dest == -1) {\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (st[i].empty()) {\n dest = i;\n break;\n }\n }\n }\n \n // Fallback: any stack with largest top\n if (dest == -1) {\n int maxTop = -1;\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty() && st[i].back() > maxTop) {\n maxTop = st[i].back();\n dest = i;\n }\n }\n }\n \n if (dest == -1) dest = s;\n \n // Perform move operation\n ops.emplace_back(boxToMove, dest + 1);\n \n // Update stacks\n int oldSize = st[s].size();\n st[s].resize(posV + 1);\n for (int i = posV + 1; i < oldSize; ++i) {\n int box = st[s][i];\n st[dest].push_back(box);\n pos[box] = {dest, (int)st[dest].size() - 1};\n }\n pos[v] = {s, (int)st[s].size() - 1};\n }\n \n // Carry out v\n ops.emplace_back(v, 0);\n if (!st[s].empty() && st[s].back() == v) {\n st[s].pop_back();\n }\n }\n \n for (auto &p : ops) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n \n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) { p.resize(n); r.assign(n, 0); iota(p.begin(), p.end(), 0); }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n if (!(cin >> N)) return 0;\n const int M = N * N;\n vector h(N - 1), v(N);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n for (int i = 0; i < N; ++i) cin >> v[i];\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> d[i][j];\n\n auto id = [&](int i, int j) { return i * N + j; };\n auto coord = [&](int id_) { return pair(id_/N, id_%N); };\n\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n auto opposite = [&](char c)->char{\n if (c=='U') return 'D';\n if (c=='D') return 'U';\n if (c=='L') return 'R';\n return 'L';\n };\n\n auto moveChar = [&](int from, int to)->char{\n auto [fi,fj] = coord(from);\n auto [ti,tj] = coord(to);\n if (ti == fi+1) return 'D';\n if (ti == fi-1) return 'U';\n if (tj == fj+1) return 'R';\n return 'L'; // tj == fj-1\n };\n\n /* ---------- 1. build list of usable edges ---------- */\n struct Edge {int u,v,w;};\n vector edges;\n edges.reserve(5000);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i,j);\n // down\n if (i+1 < N && h[i][j] == '0') {\n int v = id(i+1,j);\n edges.push_back({u,v, d[i][j] + d[i+1][j]});\n }\n // right\n if (j+1 < N && v[i][j] == '0') {\n int v = id(i,j+1);\n edges.push_back({u,v, d[i][j] + d[i][j+1]});\n }\n }\n }\n\n /* ---------- 2. maximum spanning tree (Kruskal) ---------- */\n sort(edges.begin(), edges.end(),\n [](const Edge& a, const Edge& b){ return a.w > b.w; });\n DSU dsu(M);\n vector> treeAdj(M);\n int added = 0;\n for (auto &e: edges) {\n if (dsu.unite(e.u, e.v)) {\n treeAdj[e.u].push_back(e.v);\n treeAdj[e.v].push_back(e.u);\n ++added;\n if (added == M-1) break;\n }\n }\n\n /* ---------- 3. covering walk (DFS on the tree) ---------- */\n const int root = id(0,0);\n vector coverMoves;\n coverMoves.reserve(2*(M-1));\n\n function dfs = [&](int v, int p) {\n for (int to: treeAdj[v]) if (to != p) {\n coverMoves.push_back(moveChar(v,to));\n dfs(to, v);\n coverMoves.push_back(moveChar(to,v));\n }\n };\n dfs(root, -1);\n int coverLen = (int)coverMoves.size(); // = 2\u00b7(M\u20111)\n\n /* ---------- 4. BFS from (0,0) on the original grid ---------- */\n const int INF = 1e9;\n vector dist(M, INF), parent(M, -1);\n vector parDir(M); // direction from parent to this node\n queue q;\n dist[root] = 0;\n q.push(root);\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n auto [ci,cj] = coord(cur);\n for (int dir = 0; dir < 4; ++dir) {\n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n // check wall\n if (dir == 0 && h[ci][cj] == '1') continue; // up\n if (dir == 1 && (ci+1 < N && h[ci][cj] == '1')) continue; // down\n if (dir == 2 && v[ci][cj-1] == '1') continue; // left (j-1 valid because j>=1)\n if (dir == 3 && v[ci][cj] == '1') continue; // right\n int nb = id(ni,nj);\n if (dist[nb] == INF) {\n dist[nb] = dist[cur] + 1;\n parent[nb] = cur;\n parDir[nb] = dirChar[dir];\n q.push(nb);\n }\n }\n }\n\n /* ---------- 5. best adjacent pair ---------- */\n int bestU = -1, bestV = -1;\n int bestSum = -1;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i,j);\n // down neighbour\n if (i+1 < N && h[i][j] == '0') {\n int v = id(i+1,j);\n int s = d[i][j] + d[i+1][j];\n if (s > bestSum) { bestSum = s; bestU = u; bestV = v; }\n }\n // right neighbour\n if (j+1 < N && v[i][j] == '0') {\n int v = id(i,j+1);\n int s = d[i][j] + d[i][j+1];\n if (s > bestSum) { bestSum = s; bestU = u; bestV = v; }\n }\n }\n }\n\n // choose the endpoint of the best pair that is closer to (0,0)\n int s = (dist[bestU] <= dist[bestV]) ? bestU : bestV;\n int t = (s == bestU) ? bestV : bestU;\n int distS = dist[s];\n\n /* ---------- 6. how many bounce cycles are possible ---------- */\n const int LMAX = 100000;\n long long remain = LMAX - coverLen - 2LL * distS;\n if (remain < 0) remain = 0;\n int k = (int)(remain / 2); // number of full back\u2011and\u2011forth cycles\n\n /* ---------- 7. build the whole route ---------- */\n string answer;\n answer.reserve(LMAX);\n // covering walk\n answer.append(coverMoves.begin(), coverMoves.end());\n\n // path from (0,0) to s\n vector pathToS;\n {\n int cur = s;\n while (cur != root) {\n char d = parDir[cur]; // direction parent -> cur\n pathToS.push_back(opposite(d));\n cur = parent[cur];\n }\n reverse(pathToS.begin(), pathToS.end());\n answer.append(pathToS.begin(), pathToS.end());\n }\n\n // bounce between s and t\n char dirST = moveChar(s, t);\n char dirTS = opposite(dirST);\n for (int i = 0; i < k; ++i) {\n answer.push_back(dirST);\n answer.push_back(dirTS);\n }\n\n // path back from s to (0,0)\n {\n int cur = s;\n while (cur != root) {\n char d = parDir[cur];\n answer.push_back(opposite(d));\n cur = parent[cur];\n }\n }\n\n // safety \u2013 should never happen\n if ((int)answer.size() > LMAX) answer.resize(LMAX);\n\n cout << answer << '\\n';\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nconst int INF = 1e9;\n\n/* ---------- overlap of two words (both length 5) ---------- */\nint overlap(const string &a, const string &b) {\n // longest k (0..4) such that suffix of a (len k) == prefix of b (len k)\n int maxk = min(4, (int)b.size());\n for (int k = maxk; k >= 0; --k) {\n bool ok = true;\n for (int i = 0; i < k; ++i) {\n if (a[a.size() - k + i] != b[i]) { ok = false; break; }\n }\n if (ok) return k;\n }\n return 0;\n}\n\n/* --------------------- main --------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n if (!(cin >> N >> M)) return 0;\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 word(M);\n for (int i = 0; i < M; ++i) cin >> word[i];\n\n const int V = N * N; // 225\n // position list for each letter\n vector> cells(V);\n vector> pos(26);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int id = i * N + j;\n cells[id] = {i, j};\n int c = grid[i][j] - 'A';\n pos[c].push_back(id);\n }\n\n // Manhattan distance between any two squares\n vector> dist(V, vector(V));\n for (int i = 0; i < V; ++i) {\n auto [xi, yi] = cells[i];\n for (int j = 0; j < V; ++j) {\n auto [xj, yj] = cells[j];\n dist[i][j] = abs(xi - xj) + abs(yi - yj);\n }\n }\n\n int startIdx = si * N + sj;\n\n /* ---- build a short super\u2011string (try all start words) ---- */\n string bestSuper;\n int bestLen = INT_MAX;\n for (int start = 0; start < M; ++start) {\n vector used(M, false);\n string cur = word[start];\n used[start] = true;\n while (true) {\n int bestIdx = -1;\n bool bestDir = false; // false = append, true = prepend\n int bestAdd = 1000;\n int bestOv = 0;\n for (int i = 0; i < M; ++i) if (!used[i]) {\n const string &s = word[i];\n // try append\n int ov = overlap(cur, s);\n int add = 5 - ov;\n if (add < bestAdd || (add == bestAdd && ov > bestOv)) {\n bestAdd = add; bestIdx = i; bestDir = false; bestOv = ov;\n }\n // try prepend\n int ov2 = overlap(s, cur);\n int add2 = 5 - ov2;\n if (add2 < bestAdd || (add2 == bestAdd && ov2 > bestOv)) {\n bestAdd = add2; bestIdx = i; bestDir = true; bestOv = ov2;\n }\n }\n if (bestIdx == -1) break;\n const string &s = word[bestIdx];\n if (!bestDir) cur += s.substr(bestOv);\n else cur = s + cur.substr(bestOv);\n used[bestIdx] = true;\n }\n if ((int)cur.size() < bestLen) {\n bestLen = cur.size();\n bestSuper = cur;\n }\n }\n\n const string &S = bestSuper; // final super\u2011string\n const int L = (int)S.size();\n\n /* ---- DP for optimal finger walk ---- */\n vector dpPrev(V, INF), dpCurr(V, INF);\n // predecessor matrix: (step, square) \u2192 previous square (short, -1 = none)\n vector pred(L * V, -1);\n auto setPred = [&](int step, int p, short prev) {\n pred[step * V + p] = prev;\n };\n auto getPred = [&](int step, int p) -> short {\n return pred[step * V + p];\n };\n\n // first character\n int firstChar = S[0] - 'A';\n vector activePrev;\n for (int p : pos[firstChar]) {\n int d = dist[startIdx][p];\n dpPrev[p] = d + 1; // distance + typing cost\n setPred(0, p, -1);\n activePrev.push_back(p);\n }\n\n // following characters\n for (int i = 1; i < L; ++i) {\n vector activeCurr;\n int ch = S[i] - 'A';\n for (int p : pos[ch]) {\n int best = INF;\n short bestPrev = -1;\n for (int q : activePrev) {\n int cand = dpPrev[q] + dist[q][p] + 1;\n if (cand < best) {\n best = cand;\n bestPrev = (short)q;\n }\n }\n if (best != INF) {\n dpCurr[p] = best;\n setPred(i, p, bestPrev);\n activeCurr.push_back(p);\n }\n }\n // prepare for next step\n fill(dpPrev.begin(), dpPrev.end(), INF);\n dpPrev.swap(dpCurr);\n fill(dpCurr.begin(), dpCurr.end(), INF);\n activePrev = move(activeCurr);\n }\n\n // find the best final square\n int minCost = INF;\n int lastPos = -1;\n for (int p = 0; p < V; ++p) {\n if (dpPrev[p] < minCost) {\n minCost = dpPrev[p];\n lastPos = p;\n }\n }\n\n // reconstruct the whole walk\n vector path(L);\n int cur = lastPos;\n for (int i = L - 1; i >= 0; --i) {\n path[i] = cur;\n cur = getPred(i, cur);\n }\n\n // output the coordinates\n for (int idx : path) {\n int ii = idx / N;\n int jj = idx % N;\n cout << ii << ' ' << jj << '\\n';\n }\n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n if (!(cin >> N >> M >> eps)) return 0;\n const int S = N * N; // number of cells\n // read and ignore the shapes of the oil fields\n for (int k = 0; k < M; ++k) {\n int d; cin >> d;\n for (int t = 0; t < d; ++t) {\n int a, b; cin >> a >> b;\n }\n }\n\n const int Q = S - 2; // number of divine queries ( \u2264 2\u00b7N\u00b2 )\n const double epsFactor = 1.0 - 2.0 * eps; // denominator ( > 0 because eps \u2264 0.2 )\n\n // linear system L * t = r\n Eigen::MatrixXd L = Eigen::MatrixXd::Zero(S, S);\n Eigen::VectorXd r = Eigen::VectorXd::Zero(S);\n\n // random generator for the subsets\n std::mt19937 rng(123456789);\n\n for (int qq = 0; qq < Q; ++qq) {\n // generate a random subset, each cell included with probability 0.5\n vector idxs;\n idxs.reserve(S);\n for (int i = 0; i < S; ++i) if (rng() & 1) idxs.push_back(i);\n if (idxs.size() < 2) { // safety \u2013 add the first two cells\n if (idxs.empty()) { idxs.push_back(0); idxs.push_back(1); }\n else if (idxs.size() == 1) idxs.push_back((idxs[0] + 1) % S);\n }\n\n // output the divine query\n cout << \"q \" << idxs.size();\n for (int id : idxs) {\n int ii = id / N;\n int jj = id % N;\n cout << ' ' << ii << ' ' << jj;\n }\n cout << \"\\n\";\n cout.flush();\n\n // read the noisy answer\n int y; cin >> y;\n\n // transform to an unbiased estimate of the sum of t's\n double k = (double)idxs.size();\n double z = ( (double) y - eps * k ) / epsFactor;\n\n // weight = 1 / variance of z\n double var = k * eps * (1.0 - eps) / (epsFactor * epsFactor);\n double w = 1.0 / var;\n\n // update L and r\n for (int a : idxs) {\n L(a, a) += w;\n r(a) += w * z;\n for (int b : idxs) {\n if (a < b) {\n L(a, b) += w;\n L(b, a) += w;\n }\n }\n }\n }\n\n // regularise and solve\n L += 1e-6 * Eigen::MatrixXd::Identity(S, S);\n Eigen::VectorXd t = L.ldlt().solve(r);\n for (int i = 0; i < S; ++i) t(i) = std::max(0.0, std::min(1.0, t(i)));\n\n // decide how many cells are oil\n double sumT = t.sum();\n int K = (int)std::round(sumT);\n if (K < 0) K = 0;\n if (K > S) K = S;\n\n // indices sorted by decreasing t\n vector order(S);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b){ return t(a) > t(b); });\n\n // first guess\n vector answer;\n answer.reserve(K);\n for (int i = 0; i < K; ++i) answer.push_back(order[i]);\n\n cout << \"a \" << answer.size();\n for (int id : answer) {\n int ii = id / N, jj = id % N;\n cout << ' ' << ii << ' ' << jj;\n }\n cout << \"\\n\";\n cout.flush();\n\n int ok; cin >> ok;\n if (ok == 1) return 0; // success \u2013 finished\n\n // -------- fallback : drill every cell ----------\n vector exact(S, -1);\n for (int id = 0; id < S; ++id) {\n int ii = id / N, jj = id % N;\n cout << \"q 1 \" << ii << ' ' << jj << \"\\n\";\n cout.flush();\n int val; cin >> val;\n exact[id] = val;\n }\n\n // produce the exact answer\n vector finalAns;\n for (int id = 0; id < S; ++id)\n if (exact[id] > 0) finalAns.push_back(id);\n\n cout << \"a \" << finalAns.size();\n for (int id : finalAns) {\n int ii = id / N, jj = id % N;\n cout << ' ' << ii << ' ' << jj;\n }\n cout << \"\\n\";\n cout.flush();\n // the judge will answer 1 \u2013 we are done\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nconst int W_fixed = 1000; // the problem always uses W = 1000\n\nstruct Rect {\n int x, y, w, h; // left\u2011bottom corner (x,y), size w \u00d7 h\n};\n\nint W; // actual W (will be 1000)\n\n/*---------------------------------------------------------------*/\n/* add a new free rectangle, removing any that it contains */\nvoid addFreeRect(vector& L, const Rect& r) {\n if (r.w <= 0 || r.h <= 0) return;\n for (const Rect& f : L) {\n if (f.x <= r.x && f.y <= r.y &&\n f.x + f.w >= r.x + r.w &&\n f.y + f.h >= r.y + r.h)\n return; // r is already contained\n }\n vector nxt;\n for (const Rect& f : L) {\n if (!(r.x <= f.x && r.y <= f.y &&\n r.x + r.w >= f.x + f.w &&\n r.y + r.h >= f.y + f.h))\n nxt.push_back(f); // f is not inside r\n }\n nxt.push_back(r);\n L.swap(nxt);\n}\n\n/*---------------------------------------------------------------*/\n/* minimal rectangle (w,h) for a demand a */\nvoid minimalRect(int a, int& w, int& h) {\n int bestW = W, bestH = W, bestArea = W * W, bestMax = W;\n for (int hi = 1; hi <= W; ++hi) {\n int wi = (a + hi - 1) / hi; // ceil(a/hi)\n if (wi > W) continue;\n int area = wi * hi;\n int mx = max(wi, hi);\n if (area < bestArea || (area == bestArea && mx < bestMax)) {\n bestArea = area;\n bestW = wi;\n bestH = hi;\n bestMax = mx;\n }\n }\n w = bestW; h = bestH;\n}\n\n/*---------------------------------------------------------------*/\n/* pack all reservations of one day.\n initialFree : free rectangles from previous day\n items : reservation rectangles (id , w , h)\n placed : output \u2013 rectangle for each reservation id\n freeOut : free rectangles after placing (empty rooms)\n*/\nvoid pack_day(const vector& initialFree,\n const vector>& items, // (id,w,h)\n vector& placed,\n vector& freeOut)\n{\n // items are already sorted by decreasing area outside\n vector freeRects = initialFree;\n int N = (int)items.size();\n placed.assign(N, {0,0,0,0});\n\n for (auto [id, w0, h0] : items) {\n int demand = w0 * h0; // minimal area, may be larger\n // ----- try to take a whole free rectangle -----------------\n int bestSurplus = INT_MAX, bestIdx = -1;\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n int area = f.w * f.h;\n if (area >= demand) {\n int surplus = area - demand;\n if (surplus < bestSurplus) {\n bestSurplus = surplus;\n bestIdx = i;\n }\n }\n }\n if (bestIdx != -1) {\n // use the whole free rectangle, no new walls\n Rect fr = freeRects[bestIdx];\n placed[id] = fr; // exact size of the free room\n freeRects.erase(freeRects.begin() + bestIdx);\n continue;\n }\n\n // ----- need to split a free rectangle ----------------------\n int bestScore = INT_MAX, idx = -1, px = -1, py = -1, pw = -1, ph = -1;\n for (int rot = 0; rot < 2; ++rot) {\n int w = rot ? h0 : w0;\n int h = rot ? w0 : h0;\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n if (f.w >= w && f.h >= h) {\n int score = (f.w - w) + (f.h - h);\n if (score < bestScore) {\n bestScore = score;\n idx = i;\n px = f.x;\n py = f.y;\n pw = w;\n ph = h;\n }\n }\n }\n if (idx != -1) break; // we already have a candidate\n }\n // idx must be valid (the whole grid is a free rectangle)\n Rect used = freeRects[idx];\n placed[id] = {px, py, pw, ph};\n freeRects.erase(freeRects.begin() + idx);\n\n // right remainder\n if (used.w - pw > 0) {\n Rect r = {px + pw, py, used.w - pw, used.h};\n addFreeRect(freeRects, r);\n }\n // bottom remainder\n if (used.h - ph > 0) {\n Rect r = {px, py + ph, pw, used.h - ph};\n addFreeRect(freeRects, r);\n }\n }\n freeOut.swap(freeRects);\n}\n\n/*---------------------------------------------------------------*/\n/* build interior edge tables from a list of rooms */\nvoid buildEdges(const vector& rooms,\n vector& H, vector& V)\n{\n fill(H.begin(), H.end(), 0);\n fill(V.begin(), V.end(), 0);\n for (const Rect& r : rooms) {\n int x0 = r.x, y0 = r.y;\n int x1 = x0 + r.w, y1 = y0 + r.h;\n\n // top edge (y0 > 0)\n if (y0 > 0) {\n int i = y0;\n for (int x = x0; x < x1; ++x) H[i * W + x] = 1;\n }\n // bottom edge (y1 < W)\n if (y1 < W) {\n int i = y1;\n for (int x = x0; x < x1; ++x) H[i * W + x] = 1;\n }\n // left edge (x0 > 0)\n if (x0 > 0) {\n int i = x0;\n for (int y = y0; y < y1; ++y) V[i * W + y] = 1;\n }\n // right edge (x1 < W)\n if (x1 < W) {\n int i = x1;\n for (int y = y0; y < y1; ++y) V[i * W + y] = 1;\n }\n }\n}\n\n/*---------------------------------------------------------------*/\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int D, N;\n if (!(cin >> W >> D >> N)) return 0;\n vector> a(D, vector(N));\n for (int d = 0; d < D; ++d)\n for (int k = 0; k < N; ++k)\n cin >> a[d][k];\n\n // edge tables\n vector Hcur(W * W, 0), Vcur(W * W, 0);\n vector Hprev(W * W, 0), Vprev(W * W, 0);\n\n // answer storage\n vector> answer(D, vector(N));\n\n // free rectangles coming from previous day (day 0 starts with whole hall)\n vector prevFree = { {0, 0, W, W} };\n\n long long totalCost = 0;\n\n for (int day = 0; day < D; ++day) {\n // build items (id, minimal rectangle size)\n vector> items; // (id, w, h)\n items.reserve(N);\n for (int k = 0; k < N; ++k) {\n int w, h;\n minimalRect(a[day][k], w, h);\n items.emplace_back(k, w, h);\n }\n // sort by decreasing area (helps keeping big rooms)\n sort(items.begin(), items.end(),\n [](const auto& A, const auto& B) {\n int areaA = get<1>(A) * get<2>(A);\n int areaB = get<1>(B) * get<2>(B);\n return areaA > areaB;\n });\n\n // pack\n vector placed, freeRects;\n pack_day(prevFree, items, placed, freeRects);\n\n // remember placed rectangles for output (convert to i0,j0,i1,j1)\n for (int k = 0; k < N; ++k) {\n const Rect& r = placed[k];\n answer[day][k] = { r.y, r.x, r.y + r.h, r.x + r.w };\n }\n\n // all rooms (reservation + empty)\n vector allRooms = placed;\n allRooms.insert(allRooms.end(), freeRects.begin(), freeRects.end());\n\n // build edge tables for this day\n buildEdges(allRooms, Hcur, Vcur);\n\n if (day > 0) {\n long long diff = 0;\n for (int i = 1; i < W; ++i)\n for (int j = 0; j < W; ++j)\n if (Hcur[i * W + j] != Hprev[i * W + j]) ++diff;\n for (int i = 0; i < W; ++i)\n for (int j = 1; j < W; ++j)\n if (Vcur[i * W + j] != Vprev[i * W + j]) ++diff;\n totalCost += diff;\n }\n\n // prepare for next day\n Hprev.swap(Hcur);\n Vprev.swap(Vcur);\n prevFree = move(allRooms); // rooms of today become free tomorrow\n }\n\n // (totalCost is not required to be printed, only the layout)\n\n // output\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n const Rect& r = answer[d][k];\n cout << r.x << ' ' << r.y << ' ' << r.w << ' ' << r.h << \"\\n\";\n // note: we stored (i0,j0,i1,j1) as (r.x,r.y,r.w,r.h)\n // but output expects (i0,j0,i1,j1) -> we already stored that way\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nconst long long MOD = 998244353LL;\n\nstruct Placement {\n int stamp;\n int p, q;\n int cell[9];\n int inc[9];\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n const int CELLS = N * N;\n vector a(CELLS);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n long long x; cin >> x;\n a[i * N + j] = int(x % MOD);\n }\n vector>> stamp(M, vector>(3, vector(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 long long x; cin >> x;\n stamp[m][i][j] = int(x % MOD);\n }\n\n vector PL;\n for (int m = 0; m < M; ++m) {\n for (int p = 0; p <= N - 3; ++p) {\n for (int q = 0; q <= N - 3; ++q) {\n Placement pl;\n pl.stamp = m;\n pl.p = p; pl.q = q;\n int pos = 0;\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) {\n pl.cell[pos] = (p + i) * N + (q + j);\n pl.inc[pos] = stamp[m][i][j];\n ++pos;\n }\n PL.push_back(pl);\n }\n }\n }\n const int PLsize = (int)PL.size();\n\n auto deltaAdd = [&](const Placement& pl, const vector& add) -> long long {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] + inc) % MOD;\n delta += nw - old;\n }\n return delta;\n };\n\n auto deltaRemove = [&](const Placement& pl, const vector& add) -> long long {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] - inc) % MOD;\n if (nw < 0) nw += MOD;\n delta += nw - old;\n }\n return delta;\n };\n\n auto deltaReplace = [&](const Placement& oldPl, const Placement& newPl, const vector& add) -> long long {\n long long deltaArr[81] = {0};\n for (int t = 0; t < 9; ++t) deltaArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) deltaArr[newPl.cell[t]] += newPl.inc[t];\n \n long long delta = 0;\n for (int c = 0; c < 81; ++c) if (deltaArr[c] != 0) {\n long long oldR = (a[c] + add[c]) % MOD;\n long long newR = (a[c] + add[c] + deltaArr[c]) % MOD;\n delta += newR - oldR;\n }\n return delta;\n };\n\n auto applyAdd = [&](int idx, vector& add, vector& sol) {\n const Placement& pl = PL[idx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n sol.push_back(idx);\n };\n\n auto applyRemove = [&](int pos, vector& add, vector& sol) {\n const Placement& pl = PL[sol[pos]];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] -= pl.inc[t];\n sol.erase(sol.begin() + pos);\n };\n\n auto applyReplace = [&](int pos, int newIdx, vector& add, vector& sol) {\n const Placement& oldPl = PL[sol[pos]];\n const Placement& newPl = PL[newIdx];\n long long deltaArr[81] = {0};\n for (int t = 0; t < 9; ++t) deltaArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) deltaArr[newPl.cell[t]] += newPl.inc[t];\n for (int c = 0; c < 81; ++c) if (deltaArr[c] != 0) add[c] += deltaArr[c];\n sol[pos] = newIdx;\n };\n\n auto computeScore = [&](const vector& add) -> long long {\n long long sc = 0;\n for (int i = 0; i < CELLS; ++i) sc += (a[i] + add[i]) % MOD;\n return sc;\n };\n\n long long bestScore = 0;\n vector bestSolution;\n\n auto runFromInit = [&](vector initSol) {\n vector add(CELLS, 0);\n vector sol = initSol;\n for (int idx : sol) {\n const Placement& pl = PL[idx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n }\n long long curScore = computeScore(add);\n\n // Iterative greedy improvement\n for (int iter = 0; iter < 3; ++iter) {\n bool changed = true;\n while (changed && (int)sol.size() < K) {\n changed = false;\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long delta = deltaAdd(PL[idx], add);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0) {\n applyAdd(bestIdx, add, sol);\n curScore += bestDelta;\n changed = true;\n }\n }\n\n changed = true;\n while (changed && !sol.empty()) {\n changed = false;\n long long bestDelta = 0;\n int bestPos = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n long long delta = deltaRemove(PL[sol[pos]], add);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestPos = pos;\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += deltaRemove(PL[sol[bestPos]], add);\n applyRemove(bestPos, add, sol);\n changed = true;\n }\n }\n\n changed = true;\n while (changed) {\n changed = false;\n long long bestDelta = 0;\n int bestPos = -1, bestNewIdx = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n for (int newIdx = 0; newIdx < PLsize; ++newIdx) {\n if (sol[pos] == newIdx) continue;\n long long delta = deltaReplace(PL[sol[pos]], PL[newIdx], add);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestPos = pos;\n bestNewIdx = newIdx;\n }\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += deltaReplace(PL[sol[bestPos]], PL[bestNewIdx], add);\n applyReplace(bestPos, bestNewIdx, add, sol);\n changed = true;\n }\n }\n }\n\n // Simulated Annealing\n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution realProb(0.0, 1.0);\n uniform_int_distribution intProb(0, PLsize - 1);\n\n const int maxIter = 150000;\n const double Tstart = 5e5;\n const double Tend = 0.3;\n\n for (int it = 0; it < maxIter; ++it) {\n double progress = (double)it / maxIter;\n double T = Tstart * pow(Tend / Tstart, progress);\n \n double r = realProb(rng);\n long long delta = 0;\n bool moved = false;\n\n double addProb = (int)sol.size() < K ? 0.3 : 0.0;\n double removeProb = !sol.empty() ? 0.25 : 0.0;\n double replaceProb = !sol.empty() ? 0.45 : 0.0;\n\n if (r < addProb && (int)sol.size() < K) {\n int bestAddIdx = -1;\n long long bestAddDelta = LLONG_MIN;\n for (int tries = 0; tries < 50; ++tries) {\n int idx = intProb(rng);\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestAddDelta) {\n bestAddDelta = d;\n bestAddIdx = idx;\n }\n }\n if (bestAddIdx != -1 && bestAddDelta > 0) {\n delta = bestAddDelta;\n if (delta > 0 || exp((double)delta / T) > realProb(rng)) {\n applyAdd(bestAddIdx, add, sol);\n curScore += delta;\n moved = true;\n }\n }\n } else if (r < addProb + removeProb && !sol.empty()) {\n int pos = uniform_int_distribution(0, (int)sol.size() - 1)(rng);\n delta = deltaRemove(PL[sol[pos]], add);\n if (delta > 0 || exp((double)delta / T) > realProb(rng)) {\n curScore += delta;\n applyRemove(pos, add, sol);\n moved = true;\n }\n } else if (!sol.empty()) {\n int pos = uniform_int_distribution(0, (int)sol.size() - 1)(rng);\n int oldIdx = sol[pos];\n \n int bestReplaceIdx = -1;\n long long bestReplaceDelta = LLONG_MIN;\n for (int tries = 0; tries < 30; ++tries) {\n int newIdx = intProb(rng);\n if (newIdx == oldIdx) continue;\n long long d = deltaReplace(PL[oldIdx], PL[newIdx], add);\n if (d > bestReplaceDelta) {\n bestReplaceDelta = d;\n bestReplaceIdx = newIdx;\n }\n }\n if (bestReplaceIdx != -1) {\n delta = bestReplaceDelta;\n if (delta > 0 || exp((double)delta / T) > realProb(rng)) {\n curScore += delta;\n applyReplace(pos, bestReplaceIdx, add, sol);\n moved = true;\n }\n }\n }\n\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n\n if (it % 5000 == 0 && it > 0) {\n for (int ls = 0; ls < 10; ++ls) {\n if ((int)sol.size() < K) {\n long long bestAddDelta = 0;\n int bestAddIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestAddDelta) {\n bestAddDelta = d;\n bestAddIdx = idx;\n }\n }\n if (bestAddIdx != -1 && bestAddDelta > 0) {\n applyAdd(bestAddIdx, add, sol);\n curScore += bestAddDelta;\n }\n }\n if (!sol.empty()) {\n long long bestRemDelta = 0;\n int bestRemPos = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n long long d = deltaRemove(PL[sol[pos]], add);\n if (d > bestRemDelta) {\n bestRemDelta = d;\n bestRemPos = pos;\n }\n }\n if (bestRemPos != -1 && bestRemDelta > 0) {\n curScore += bestRemDelta;\n applyRemove(bestRemPos, add, sol);\n }\n }\n }\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n }\n }\n\n // Final local search\n for (int iter = 0; iter < 5; ++iter) {\n bool changed = false;\n if ((int)sol.size() < K) {\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0) {\n applyAdd(bestIdx, add, sol);\n curScore += bestDelta;\n changed = true;\n }\n }\n if (!sol.empty()) {\n long long bestDelta = 0;\n int bestPos = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n long long d = deltaRemove(PL[sol[pos]], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestPos = pos;\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += bestDelta;\n applyRemove(bestPos, add, sol);\n changed = true;\n }\n }\n if (!changed) break;\n }\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n };\n\n // Initial greedy solution\n vector initSol;\n vector addInit(CELLS, 0);\n for (int iter = 0; iter < 2; ++iter) {\n for (int idx = 0; idx < PLsize && (int)initSol.size() < K; ++idx) {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = PL[idx].cell[t];\n int inc = PL[idx].inc[t];\n long long old = (a[c] + addInit[c]) % MOD;\n long long nw = (a[c] + addInit[c] + inc) % MOD;\n delta += nw - old;\n }\n if (delta > 0) {\n for (int t = 0; t < 9; ++t) addInit[PL[idx].cell[t]] += PL[idx].inc[t];\n initSol.push_back(idx);\n }\n }\n }\n\n runFromInit(initSol);\n\n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\n for (int restart = 0; restart < 2; ++restart) {\n vector randomSol;\n vector addRand(CELLS, 0);\n for (int i = 0; i < K; ++i) {\n int idx = uniform_int_distribution(0, PLsize - 1)(rng);\n randomSol.push_back(idx);\n for (int t = 0; t < 9; ++t) addRand[PL[idx].cell[t]] += PL[idx].inc[t];\n }\n runFromInit(randomSol);\n }\n\n // Final greedy refinement on best solution\n {\n vector add = vector(CELLS, 0);\n vector sol = bestSolution;\n for (int idx : sol) {\n for (int t = 0; t < 9; ++t) add[PL[idx].cell[t]] += PL[idx].inc[t];\n }\n for (int iter = 0; iter < 10; ++iter) {\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0 && (int)sol.size() < K) {\n applyAdd(bestIdx, add, sol);\n } else break;\n }\n long long finalScore = computeScore(add);\n if (finalScore > bestScore) {\n bestScore = finalScore;\n bestSolution = sol;\n }\n }\n\n cout << (int)bestSolution.size() << '\\n';\n for (int idx : bestSolution) {\n const Placement& pl = PL[idx];\n cout << pl.stamp << ' ' << pl.p << ' ' << pl.q << '\\n';\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Pos { int r, c; };\n\n// direction towards target (one step)\nchar moveTowards(const Pos& cur, const Pos& tar) {\n if (cur.r < tar.r) return 'D';\n if (cur.r > tar.r) return 'U';\n if (cur.c < tar.c) return 'R';\n if (cur.c > tar.c) return 'L';\n return '.';\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int N = 5;\n const int TOT = N * N; // 25 containers\n vector> A(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> A[i][j];\n\n // source row of each container, destination row of each container\n int srcRow[TOT], dstRow[TOT];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int b = A[i][j];\n srcRow[b] = i;\n dstRow[b] = b / N;\n }\n\n // state of the large crane\n Pos crane{0, 0};\n int carrying = -1; // container number or -1\n\n // per\u2011row state of receiving gates\n int nextIdx[N] = {0}; // next container to appear\n bool gateHas[N] = {false};\n int gateCont[N]; // valid only if gateHas==true\n\n // actions strings, one per crane (0 = large, 1..4 = small)\n vector act(N);\n int delivered = 0; // number of dispatched containers\n const int MAX_TURNS = 10000;\n\n for (int turn = 1; turn <= MAX_TURNS && delivered < TOT; ++turn) {\n /* ---------- step 1 : arrivals ---------- */\n for (int i = 0; i < N; ++i) {\n if (!gateHas[i] && nextIdx[i] < N &&\n !(crane.r == i && crane.c == 0)) {\n int b = A[i][nextIdx[i]];\n gateHas[i] = true;\n gateCont[i] = b;\n ++nextIdx[i];\n }\n }\n\n /* ---------- step 2 : crane actions ---------- */\n char actLarge = '.';\n\n if (carrying != -1) { // carrying a container\n int tr = dstRow[carrying];\n int tc = N - 1;\n if (crane.r == tr && crane.c == tc) {\n actLarge = 'Q'; // release & dispatch\n ++delivered;\n carrying = -1;\n } else {\n actLarge = moveTowards(crane, {tr, tc});\n // update position\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else { // empty crane\n // choose the waiting container with minimal (travel) cost\n int bestRow = -1;\n int bestCost = INT_MAX;\n for (int i = 0; i < N; ++i) if (gateHas[i]) {\n int b = gateCont[i];\n // distance crane -> source\n int dist1 = abs(crane.r - i) + crane.c; // column diff = crane.c - 0\n // distance source -> dispatch\n int dist2 = abs(i - dstRow[b]) + (N - 1); // column diff = N-1\n int cost = dist1 + dist2;\n if (cost < bestCost) {\n bestCost = cost;\n bestRow = i;\n }\n }\n if (bestRow != -1) {\n if (crane.r == bestRow && crane.c == 0) {\n // already on the gate, pick it up\n actLarge = 'P';\n carrying = gateCont[bestRow];\n gateHas[bestRow] = false;\n } else {\n // move towards the gate\n actLarge = moveTowards(crane, {bestRow, 0});\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else {\n // nothing to do, wait\n actLarge = '.';\n }\n }\n\n act[0].push_back(actLarge); // large crane\n\n // small cranes: bomb on turn 1, otherwise nothing\n for (int i = 1; i < N; ++i) {\n if (turn == 1) act[i].push_back('B');\n else act[i].push_back('.');\n }\n }\n\n // pad all strings to the same length (they already are)\n size_t maxLen = 0;\n for (int i = 0; i < N; ++i) maxLen = max(maxLen, act[i].size());\n for (int i = 0; i < N; ++i) {\n if (act[i].size() < maxLen) act[i].append(maxLen - act[i].size(), '.');\n }\n\n for (int i = 0; i < N; ++i) cout << act[i] << '\\n';\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int x, y; // coordinates on the N x N grid\n int rem; // remaining amount to load (>0) or to unload (>0)\n bool pos; // true -> originally positive height\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector> h(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> h[i][j];\n\n vector pos, neg; // still\u2011to\u2011load / still\u2011to\u2011unload cells\n long long totalSupply = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (h[i][j] > 0) {\n pos.push_back({i, j, h[i][j], true});\n totalSupply += h[i][j];\n } else if (h[i][j] < 0) {\n neg.push_back({i, j, -h[i][j], false});\n }\n }\n\n /* Keep the load on the truck bounded \u2013 a small value is enough\n because the total amount of soil is at most 400 * 100 = 40\u202f000.\n With Lmax = max(1, totalSupply/20) we need at most about 20 loading\n steps for each positive cell, i.e. far below the 100\u202f000 turn limit. */\n long long Lmax = max(1LL, totalSupply / 20);\n\n int cx = 0, cy = 0; // current position (starts at (0,0))\n long long load = 0; // soil currently on the truck\n\n vector ops; // all operations to be printed\n\n auto move_to = [&](int tx, int ty) {\n while (cx < tx) { ops.emplace_back(\"D\"); ++cx; }\n while (cx > tx) { ops.emplace_back(\"U\"); --cx; }\n while (cy < ty) { ops.emplace_back(\"R\"); ++cy; }\n while (cy > ty) { ops.emplace_back(\"L\"); --cy; }\n };\n\n while (!pos.empty() || !neg.empty()) {\n /* 1) If we still have free capacity and there are cells that can give us\n soil, go to the nearest such cell and load some soil. */\n if (load < Lmax && !pos.empty()) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < (int)pos.size(); ++i) {\n int d = abs(cx - pos[i].x) + abs(cy - pos[i].y);\n if (d < bestDist) {\n bestDist = d;\n best = i;\n }\n }\n Cell &c = pos[best];\n move_to(c.x, c.y);\n int take = (int)min(Lmax - load, c.rem);\n load += take;\n c.rem -= take;\n ops.emplace_back(\"+\" + to_string(take));\n if (c.rem == 0) {\n swap(pos[best], pos.back());\n pos.pop_back();\n }\n }\n /* 2) Otherwise, if we have soil on the truck, deliver it to the nearest\n cell that still needs soil. */\n else if (load > 0 && !neg.empty()) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < (int)neg.size(); ++i) {\n int d = abs(cx - neg[i].x) + abs(cy - neg[i].y);\n if (d < bestDist) {\n bestDist = d;\n best = i;\n }\n }\n Cell &c = neg[best];\n move_to(c.x, c.y);\n int give = (int)min(load, c.rem);\n load -= give;\n c.rem -= give;\n ops.emplace_back(\"-\" + to_string(give));\n if (c.rem == 0) {\n swap(neg[best], neg.back());\n neg.pop_back();\n }\n }\n /* The case \u201cload == 0 and there are still positive cells\u201d cannot happen,\n because totalSupply == totalDemand and we always load before the truck\n becomes empty. The loop is therefore guaranteed to finish. */\n }\n\n /* Output the operations \u2013 one per line, without a leading count. */\n for (const string &s : ops) cout << s << '\\n';\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nstruct Solver {\n int N, M, T;\n int S; // 2*N*(N-1)\n int CELLS; // N*N\n vector> seed; // S x M\n vector> w; // S x S\n vector V; // S\n vector> neigh; // CELLS -> list of neighbour indices\n mutable mt19937 rng; // FIX: mutable allows use in const methods\n\n // ------------------------------------------------------------\n // recompute pairwise w\n void compute_w() {\n w.assign(S, vector(S, 0));\n for (int i = 0; i < S; ++i)\n for (int j = i; j < S; ++j) {\n int val = 0;\n for (int l = 0; l < M; ++l)\n val += max(seed[i][l], seed[j][l]);\n w[i][j] = w[j][i] = val;\n }\n }\n\n // ------------------------------------------------------------\n // sum of coordinates of a seed\n int sumSeed(int id) const {\n int s = 0;\n for (int v : seed[id]) s += v;\n return s;\n }\n\n // ------------------------------------------------------------\n // greedy covering (maximise per\u2011dimension maxima)\n vector greedyCoverSelection() const {\n const int need = CELLS;\n vector curMax(M, -1);\n vector used(S, 0);\n vector chosen;\n chosen.reserve(need);\n for (int taken = 0; taken < need; ++taken) {\n int bestId = -1;\n int bestGain = -1;\n int bestSum = -1;\n for (int id = 0; id < S; ++id) if (!used[id]) {\n int gain = 0;\n for (int l = 0; l < M; ++l)\n if (seed[id][l] > curMax[l]) gain += seed[id][l] - curMax[l];\n if (gain > bestGain ||\n (gain == bestGain && sumSeed(id) > bestSum)) {\n bestGain = gain;\n bestId = id;\n bestSum = sumSeed(id);\n }\n }\n used[bestId] = 1;\n chosen.push_back(bestId);\n for (int l = 0; l < M; ++l)\n curMax[l] = max(curMax[l], seed[bestId][l]);\n }\n return chosen;\n }\n\n // ------------------------------------------------------------\n // top\u2011by\u2011total\u2011value selection\n vector topValueSelection() const {\n vector idx(S);\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(),\n [&](int a, int b){ return sumSeed(a) > sumSeed(b); });\n return vector(idx.begin(), idx.begin() + CELLS);\n }\n\n // ------------------------------------------------------------\n // linear assignment : high\u2011value seeds \u2192 high\u2011degree cells\n vector linearAssignment(const vector& seeds) const {\n vector sortedSeeds = seeds;\n sort(sortedSeeds.begin(), sortedSeeds.end(),\n [&](int a, int b){ return sumSeed(a) > sumSeed(b); });\n\n vector cells(CELLS);\n iota(cells.begin(), cells.end(), 0);\n sort(cells.begin(), cells.end(),\n [&](int a, int b){\n return neigh[a].size() > neigh[b].size();\n });\n\n vector assign(CELLS, -1);\n for (int i = 0; i < CELLS; ++i) assign[cells[i]] = sortedSeeds[i];\n return assign;\n }\n\n // ------------------------------------------------------------\n // random assignment (shuffle seeds, then assign to cells sorted by degree)\n vector randomAssignment(const vector& seeds) const {\n vector shuffled = seeds;\n shuffle(shuffled.begin(), shuffled.end(), rng);\n\n vector cells(CELLS);\n iota(cells.begin(), cells.end(), 0);\n sort(cells.begin(), cells.end(),\n [&](int a, int b){\n return neigh[a].size() > neigh[b].size();\n });\n\n vector assign(CELLS, -1);\n for (int i = 0; i < CELLS; ++i) assign[cells[i]] = shuffled[i];\n return assign;\n }\n\n // ------------------------------------------------------------\n // total W for a placement\n int totalW(const vector& assign) const {\n long long tot = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int idx = r * N + c;\n if (c + 1 < N) {\n int idx2 = idx + 1;\n tot += w[assign[idx]][assign[idx2]];\n }\n if (r + 1 < N) {\n int idx2 = idx + N;\n tot += w[assign[idx]][assign[idx2]];\n }\n }\n }\n return static_cast(tot);\n }\n\n // ------------------------------------------------------------\n // hill\u2011climbing (composition exchange + neighbour swaps)\n void improve(vector& assign) const {\n vector used(S, 0);\n for (int id : assign) used[id] = 1;\n\n while (true) {\n // recompute sumW[p][s] = \u03a3_{nb\u2208N(p)} w[s][assign[nb]]\n vector> sumW(CELLS, vector(S, 0));\n for (int p = 0; p < CELLS; ++p) {\n for (int nb : neigh[p]) {\n int seed_nb = assign[nb];\n for (int s = 0; s < S; ++s) {\n sumW[p][s] += w[s][seed_nb];\n }\n }\n }\n\n int bestDelta = 0;\n int bestType = 0; // 0 = none, 1 = replace, 2 = swap\n int bestP = -1, bestQ = -1, bestS = -1;\n\n // ---- composition exchanges (replace placed seed by unused one) ----\n for (int p = 0; p < CELLS; ++p) {\n int cur = assign[p];\n for (int s = 0; s < S; ++s) if (!used[s]) {\n int delta = sumW[p][s] - sumW[p][cur];\n if (delta > bestDelta) {\n bestDelta = delta;\n bestType = 1;\n bestP = p;\n bestS = s;\n }\n }\n }\n\n // ---- neighbour swaps (swap seeds of two cells) ----\n for (int p = 0; p < CELLS; ++p) {\n for (int q = p + 1; q < CELLS; ++q) {\n if (assign[p] == assign[q]) continue;\n int delta = (sumW[p][assign[q]] - sumW[p][assign[p]]) +\n (sumW[q][assign[p]] - sumW[q][assign[q]]);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestType = 2;\n bestP = p;\n bestQ = q;\n }\n }\n }\n\n if (bestDelta <= 0) break; // local optimum reached\n\n if (bestType == 1) {\n // replace\n int old = assign[bestP];\n assign[bestP] = bestS;\n used[old] = 0;\n used[bestS] = 1;\n } else {\n // swap two cells\n swap(assign[bestP], assign[bestQ]);\n }\n }\n }\n\n // ------------------------------------------------------------\n // optional random kicks + improve\n void kickAndImprove(vector& assign, int kicks) const {\n for (int k = 0; k < kicks; ++k) {\n int p = uniform_int_distribution(0, CELLS - 1)(rng);\n int q = uniform_int_distribution(0, CELLS - 1)(rng);\n swap(assign[p], assign[q]);\n improve(assign);\n }\n }\n\n // ------------------------------------------------------------\n // solve one turn\n void solveOneTurn() {\n // build pairwise w\n compute_w();\n\n // ---- generate several candidate seed sets ----\n vector greedySeeds = greedyCoverSelection();\n vector topSeeds = topValueSelection();\n\n // for each seed set we try a linear assignment and a random one\n vector, vector>> candidates; // (seed set, initial assign)\n candidates.reserve(4);\n candidates.emplace_back(greedySeeds, linearAssignment(greedySeeds));\n candidates.emplace_back(greedySeeds, randomAssignment(greedySeeds));\n candidates.emplace_back(topSeeds, linearAssignment(topSeeds));\n candidates.emplace_back(topSeeds, randomAssignment(topSeeds));\n\n int bestW = -1;\n vector bestAssign;\n\n for (auto& cand : candidates) {\n vector cur = cand.second;\n improve(cur);\n // extra kicks if we want (very cheap, kept small)\n kickAndImprove(cur, 2);\n int curW = totalW(cur);\n if (curW > bestW) {\n bestW = curW;\n bestAssign = std::move(cur);\n }\n }\n\n // output best assignment\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (c) cout << ' ';\n cout << bestAssign[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n }\n\n // ------------------------------------------------------------\n void run() {\n // read initial seeds\n seed.assign(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n\n // pre\u2011compute neighbour list of each board cell\n neigh.assign(CELLS, {});\n auto addNeighbour = [&](int r, int c, int nr, int nc) {\n if (0 <= nr && nr < N && 0 <= nc && nc < N) {\n neigh[r * N + c].push_back(nr * N + nc);\n }\n };\n for (int r = 0; r < N; ++r)\n for (int c = 0; c < N; ++c) {\n addNeighbour(r, c, r - 1, c);\n addNeighbour(r, c, r + 1, c);\n addNeighbour(r, c, r, c - 1);\n addNeighbour(r, c, r, c + 1);\n }\n\n rng.seed(chrono::steady_clock::now().time_since_epoch().count());\n\n for (int turn = 0; turn < T; ++turn) {\n solveOneTurn();\n // read next seeds\n seed.assign(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n }\n }\n};\n\n// ------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, T;\n if (!(cin >> N >> M >> T)) return 0;\n Solver solver;\n solver.N = N;\n solver.M = M;\n solver.T = T;\n solver.S = 2 * N * (N - 1);\n solver.CELLS = N * N;\n solver.run();\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, Vlimit;\n if (!(cin >> N >> Vlimit >> M)) return 0;\n \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 // Arm design (root + one leaf)\n cout << 2 << \"\\n\";\n cout << 0 << ' ' << 1 << \"\\n\";\n cout << 0 << ' ' << 0 << \"\\n\";\n\n // Collect sources and targets\n vector> src, tgt;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (s[i][j] == '1') src.emplace_back(i, j);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (t[i][j] == '1') tgt.emplace_back(i, j);\n\n // Mark targets (to find already-correct positions)\n vector> occupied(N, vector(N, 0));\n for (auto &p : tgt) occupied[p.first][p.second] = 1;\n\n // Separate sources: already at target vs need to move\n vector srcIdx;\n for (int i = 0; i < (int)src.size(); ++i) {\n if (occupied[src[i].first][src[i].second]) {\n occupied[src[i].first][src[i].second] = 2; // already correct\n } else {\n srcIdx.push_back(i);\n }\n }\n\n // Remaining targets that need a takoyaki\n vector tgtIdx;\n for (int i = 0; i < (int)tgt.size(); ++i) {\n if (occupied[tgt[i].first][tgt[i].second] == 1) {\n tgtIdx.push_back(i);\n }\n }\n\n // Simple greedy matching (O(n^2))\n int n = srcIdx.size();\n vector matchSrc(n, -1), matchTgt(n, -1);\n vector srcUsed(n, 0), tgtUsed(n, 0);\n \n for (int i = 0; i < n; ++i) {\n int bestS = -1, bestT = -1, bestDist = INT_MAX;\n for (int si = 0; si < n; ++si) {\n if (srcUsed[si]) continue;\n for (int ti = 0; ti < n; ++ti) {\n if (tgtUsed[ti]) continue;\n int d = abs(src[srcIdx[si]].first - tgt[tgtIdx[ti]].first)\n + abs(src[srcIdx[si]].second - tgt[tgtIdx[ti]].second);\n if (d < bestDist) {\n bestDist = d;\n bestS = si;\n bestT = ti;\n }\n }\n }\n if (bestS >= 0) {\n matchSrc[bestS] = bestT;\n matchTgt[bestT] = bestS;\n srcUsed[bestS] = 1;\n tgtUsed[bestT] = 1;\n }\n }\n\n // Simulation state\n int rx = 0, ry = 0;\n int leafDir = 0; // 0=E,1=S,2=W,3=N\n bool holding = false;\n \n const int DX[4] = {0, 1, 0, -1};\n const int DY[4] = {1, 0, -1, 0};\n\n // Output buffer\n string output;\n output.reserve(100000 * 4 + 1000);\n\n auto addTurn = [&](char mv, char rot, char leafAct) {\n output += mv;\n output += rot;\n output += '.';\n output += leafAct;\n output += '\\n';\n };\n\n auto moveRoot = [&](int gx, int gy) {\n while (rx != gx || ry != gy) {\n char mv;\n if (rx < gx) { mv = 'D'; ++rx; }\n else if (rx > gx) { mv = 'U'; --rx; }\n else if (ry < gy) { mv = 'R'; ++ry; }\n else { mv = 'L'; --ry; }\n addTurn(mv, '.', '.');\n }\n };\n\n auto rotateLeaf = [&](char rot) {\n if (rot != '.') {\n if (rot == 'R') leafDir = (leafDir + 1) & 3;\n else leafDir = (leafDir + 3) & 3;\n }\n addTurn('.', rot, '.');\n };\n\n auto rotateLeafTo = [&](int dir) {\n while (leafDir != dir) {\n int diff = (dir - leafDir + 4) & 3;\n if (diff == 2) {\n rotateLeaf('R'); rotateLeaf('R');\n } else if (diff == 1) {\n rotateLeaf('R');\n } else {\n rotateLeaf('L');\n }\n }\n };\n\n // Find empty neighbor of a position\n auto findEmptyNeighbor = [&](int x, int y) -> pair {\n for (int d = 0; d < 4; ++d) {\n int nx = x - DX[d], ny = y - DY[d];\n if (nx >= 0 && nx < N && ny >= 0 && ny < N && !occupied[nx][ny]) {\n return {ny, d}; // return (position, direction to square)\n }\n }\n return {-1, -1}; // no empty neighbor\n };\n\n // Process each matched pair\n for (int si = 0; si < n; ++si) {\n if (matchSrc[si] < 0) continue;\n int ti = matchSrc[si];\n int sx = src[srcIdx[si]].first, sy = src[srcIdx[si]].second;\n int tx = tgt[tgtIdx[ti]].first, ty = tgt[tgtIdx[ti]].second;\n\n // Find empty neighbor for source\n auto nbS = findEmptyNeighbor(sx, sy);\n if (nbS.first < 0) continue; // shouldn't happen\n \n // Find empty neighbor for target\n auto nbT = findEmptyNeighbor(tx, ty);\n if (nbT.first < 0) continue;\n\n int rxS = sx - DX[nbS.second], ryS = sy - DY[nbS.second];\n int rxT = tx - DX[nbT.second], ryT = ty - DY[nbT.second];\n\n // Go to source\n moveRoot(rxS, ryS);\n rotateLeafTo(nbS.second);\n addTurn('.', '.', 'P');\n occupied[sx][sy] = 0;\n holding = true;\n\n // Go to target\n moveRoot(rxT, ryT);\n rotateLeafTo(nbT.second);\n addTurn('.', '.', 'P');\n occupied[tx][ty] = 1;\n holding = false;\n }\n\n cout << output;\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n int sign; // +1 mackerel, -1 sardine\n};\n\nconst int MAXCOORD = 100000;\nconst int CELL_SIZE = 500; // Coarser grid for O(C\u00b3) feasibility\n\n// Cell grid size: 200000/500 + 1 = 401\nconst int MAXC = 405;\nint cell[MAXC][MAXC];\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n if (!(cin >> N)) return 0;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n int x, y;\n cin >> x >> y;\n points[i] = {x, y, (i < N) ? 1 : -1};\n }\n\n // Build cell grid\n const int C = MAXCOORD / CELL_SIZE + 1; // 201\n for (int i = 0; i < C; ++i)\n for (int j = 0; j < C; ++j)\n cell[i][j] = 0;\n\n for (auto &p : points) {\n int cx = p.x / CELL_SIZE;\n int cy = p.y / CELL_SIZE;\n cell[cx][cy] += p.sign;\n }\n\n // ===== Maximum sum sub-matrix using O(C\u00b3) Kadane =====\n int bestSum = INT_MIN;\n int bestTop = 0, bestBottom = 0, bestLeft = 0, bestRight = 0;\n\n for (int top = 0; top < C; ++top) {\n // colSum[col] = sum of column col from row top to current bottom\n int colSum[MAXC] = {0};\n for (int bottom = top; bottom < C; ++bottom) {\n // Add row 'bottom' to colSum\n for (int col = 0; col < C; ++col) colSum[col] += cell[bottom][col];\n \n // Kadane's algorithm to find max subarray in colSum\n int curSum = 0, maxHere = INT_MIN, start = 0;\n for (int i = 0; i < C; ++i) {\n curSum += colSum[i];\n if (curSum > maxHere) {\n maxHere = curSum;\n bestLeft = start;\n bestRight = i;\n }\n if (curSum < 0) {\n curSum = 0;\n start = i + 1;\n }\n }\n \n if (maxHere > bestSum) {\n bestSum = maxHere;\n bestTop = top;\n bestBottom = bottom;\n }\n }\n }\n\n // Convert best cell rectangle to coordinate rectangle\n int leftX = bestLeft * CELL_SIZE;\n int rightX = min((bestRight + 1) * CELL_SIZE - 1, MAXCOORD);\n int bottomY = bestTop * CELL_SIZE;\n int topY = min((bestBottom + 1) * CELL_SIZE - 1, MAXCOORD);\n\n // Expand slightly to capture points on cell boundaries\n int expand = CELL_SIZE;\n leftX = max(0, leftX - expand);\n bottomY = max(0, bottomY - expand);\n rightX = min(MAXCOORD, rightX + expand);\n topY = min(MAXCOORD, topY + expand);\n\n // Exact count of points in rectangle\n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= leftX && p.x <= rightX && p.y >= bottomY && p.y <= topY) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n\n // Tighten rectangle to extreme coordinates of contained points\n if (a + b > 0) {\n int minX = MAXCOORD, maxX = 0, minY = MAXCOORD, maxY = 0;\n for (auto &p : points) {\n if (p.x >= leftX && p.x <= rightX && p.y >= bottomY && p.y <= topY) {\n minX = min(minX, p.x);\n maxX = max(maxX, p.x);\n minY = min(minY, p.y);\n maxY = max(maxY, p.y);\n }\n }\n leftX = minX;\n rightX = maxX;\n bottomY = minY;\n topY = maxY;\n }\n\n // Final exact count\n a = b = 0;\n for (auto &p : points) {\n if (p.x >= leftX && p.x <= rightX && p.y >= bottomY && p.y <= topY) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n\n // If result is non-positive, try small rectangles around mackerels\n if (a - b <= 0) {\n // Find mackerels and try nearby rectangles\n vector mackerels;\n for (auto &p : points) if (p.sign == 1) mackerels.push_back(p);\n \n for (auto &m : mackerels) {\n // Try expanding rectangle from this mackerel\n for (int r = 100; r <= 5000 && r <= MAXCOORD; r += 500) {\n int lx = max(0, m.x - r);\n int rx = min(MAXCOORD, m.x + r);\n int by = max(0, m.y - r);\n int ty = min(MAXCOORD, m.y + r);\n \n int ca = 0, cb = 0;\n for (auto &p : points) {\n if (p.x >= lx && p.x <= rx && p.y >= by && p.y <= ty) {\n if (p.sign == 1) ++ca;\n else ++cb;\n }\n }\n if (ca - cb > a - b) {\n a = ca;\n b = cb;\n leftX = lx;\n rightX = rx;\n bottomY = by;\n topY = ty;\n if (a - b > 0) break;\n }\n }\n if (a - b > 0) break;\n }\n }\n\n // Ensure rectangle has positive area\n if (leftX == rightX) {\n if (leftX > 0) leftX--;\n else rightX++;\n }\n if (bottomY == topY) {\n if (bottomY > 0) bottomY--;\n else topY++;\n }\n\n // Check perimeter constraint (must be <= 400000)\n long long perimeter = 2LL * ((long long)rightX - leftX + topY - bottomY);\n if (perimeter > 400000) {\n // Shrink proportionally\n int width = rightX - leftX;\n int height = topY - bottomY;\n int maxDim = 200000;\n \n if (width > maxDim) {\n int diff = width - maxDim;\n leftX += diff / 2;\n rightX -= (diff - diff / 2);\n }\n if (height > maxDim) {\n int diff = height - maxDim;\n bottomY += diff / 2;\n topY -= (diff - diff / 2);\n }\n }\n\n // Final coordinate clamp\n leftX = max(0, min(MAXCOORD, leftX));\n rightX = max(0, min(MAXCOORD, rightX));\n bottomY = max(0, min(MAXCOORD, bottomY));\n topY = max(0, min(MAXCOORD, topY));\n\n // Output rectangle\n cout << 4 << '\\n';\n cout << leftX << ' ' << bottomY << '\\n';\n cout << rightX << ' ' << bottomY << '\\n';\n cout << rightX << ' ' << topY << '\\n';\n cout << leftX << ' ' << topY << '\\n';\n\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n long long sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n vector w_obs(N), h_obs(N);\n for (int i = 0; i < N; ++i) cin >> w_obs[i] >> h_obs[i];\n\n /* ------------------------------------------------------------\n 1. choose the best orientation for a single row\n ------------------------------------------------------------ */\n struct Option { long long w, h; bool rot; };\n vector> opt(N);\n for (int i = 0; i < N; ++i) {\n opt[i][0] = {w_obs[i], h_obs[i], false}; // original\n opt[i][1] = {h_obs[i], w_obs[i], true}; // rotated\n }\n\n // candidate heights = all heights that appear\n vector cand;\n cand.reserve(2*N);\n for (int i = 0; i < N; ++i) {\n cand.push_back(w_obs[i]);\n cand.push_back(h_obs[i]);\n }\n sort(cand.begin(), cand.end());\n cand.erase(unique(cand.begin(), cand.end()), cand.end());\n\n const long long INF = (1LL<<62);\n long long bestCost = INF;\n vector bestRot(N, 0); // 0 = original, 1 = rotated\n vector bestW(N), bestH(N);\n\n for (long long H : cand) {\n long long sumW = 0;\n bool ok = true;\n vector rotTmp(N, 0);\n for (int i = 0; i < N; ++i) {\n long long bestWidth = INF;\n bool rot = false;\n for (int k = 0; k < 2; ++k) {\n if (opt[i][k].h <= H && opt[i][k].w < bestWidth) {\n bestWidth = opt[i][k].w;\n rot = opt[i][k].rot;\n }\n }\n if (bestWidth == INF) { ok = false; break; }\n sumW += bestWidth;\n rotTmp[i] = rot;\n }\n if (ok && sumW + H < bestCost) {\n bestCost = sumW + H;\n bestRot = rotTmp;\n }\n }\n\n // build final dimensions\n for (int i = 0; i < N; ++i) {\n if (bestRot[i]) {\n bestW[i] = h_obs[i];\n bestH[i] = w_obs[i];\n } else {\n bestW[i] = w_obs[i];\n bestH[i] = h_obs[i];\n }\n }\n\n /* ------------------------------------------------------------\n 2. output the same placement T times\n ------------------------------------------------------------ */\n for (int turn = 0; turn < T; ++turn) {\n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n cout << i << ' ' << (bestRot[i] ? 1 : 0) << ' ' << 'U' << ' '\n << (i == 0 ? -1 : i-1) << \"\\n\";\n }\n cout << flush; // required by the statement\n long long Wmes, Hmes;\n cin >> Wmes >> Hmes; // measurement, not used further\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\n// Fast xorshift32 RNG\nstruct XorShift {\n uint32_t x;\n XorShift(uint32_t seed = 2463534242U) : x(seed) {}\n uint32_t next() {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n }\n int nextInt(int mod) { return next() % mod; }\n int nextInt(int L, int R) { return L + next() % (R - L + 1); }\n void shuffle(vector& v) {\n for (int i = (int)v.size() - 1; i > 0; --i) {\n swap(v[i], v[nextInt(i + 1)]);\n }\n }\n} rng;\n\nconst int INF_NEG = -1e9;\n\n/*------------------------------------------------------------*/\n/* Build a random spanning tree */\n/*------------------------------------------------------------*/\nvoid build_random_tree(int N, int M, const vector>& adj,\n const vector& A,\n vector>& tree, int root,\n XorShift& rng, int method) {\n vector parent(N, -2);\n tree.assign(N, {});\n vector stack;\n \n if (method == 0) { // Random DFS\n stack.push_back(root);\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n rng.shuffle(nbr);\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n } else if (method == 1) { // Random BFS\n queue q;\n q.push(root);\n parent[root] = -1;\n while (!q.empty()) {\n int v = q.front(); q.pop();\n vector nbr = adj[v];\n rng.shuffle(nbr);\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n q.push(u);\n }\n }\n }\n } else if (method == 2) { // Random Prim\n vector inTree(N, 0);\n inTree[root] = 1;\n vector vertices = {root};\n while ((int)vertices.size() < N) {\n int v = vertices[rng.nextInt((int)vertices.size())];\n vector nbr = adj[v];\n rng.shuffle(nbr);\n for (int u : nbr) {\n if (!inTree[u]) {\n inTree[u] = 1;\n tree[v].push_back(u);\n tree[u].push_back(v);\n vertices.push_back(u);\n break;\n }\n }\n }\n } else if (method == 3) { // Random Kruskal\n vector p(N);\n iota(p.begin(), p.end(), 0);\n vector> edges;\n edges.reserve(M);\n for (int v = 0; v < N; ++v) {\n for (int u : adj[v]) {\n if (v < u) edges.emplace_back(rng.next(), v, u);\n }\n }\n sort(edges.begin(), edges.end(),\n [](const auto& a, const auto& b) { return get<0>(a) < get<0>(b); });\n for (auto& e : edges) {\n int _, v, u;\n tie(_, v, u) = e;\n // DSU find with path compression\n function find = [&](int x) -> int {\n return p[x] == x ? x : p[x] = find(p[x]);\n };\n int pv = find(v), pu = find(u);\n if (pv != pu) {\n p[pv] = pu;\n tree[v].push_back(u);\n tree[u].push_back(v);\n }\n }\n } else { // Greedy DFS (method 4) - prefer high beauty neighbors\n vector stack = {root};\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n sort(nbr.begin(), nbr.end(),\n [&](int a, int b) { return A[a] > A[b]; });\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n }\n}\n\n/*------------------------------------------------------------*/\n/* Solve the forest problem on a rooted tree (optimized DP) */\n/*------------------------------------------------------------*/\nint solve_tree_fast(const vector>& tree, int root,\n const vector& A, int H,\n vector& outParent) {\n const int N = A.size();\n \n // Build children list\n static vector> children;\n children.assign(N, {});\n static vector bfs_order;\n bfs_order.clear();\n bfs_order.reserve(N);\n \n queue q;\n q.push(root);\n vector parent(N, -2);\n parent[root] = -1;\n \n while (!q.empty()) {\n int v = q.front(); q.pop();\n bfs_order.push_back(v);\n for (int u : tree[v]) {\n if (parent[u] == -2) {\n parent[u] = v;\n children[v].push_back(u);\n q.push(u);\n }\n }\n }\n \n // DP: bottom-up using bfs_order reversed\n static int dp[1000][11];\n static char keep[1000][11][20];\n \n for (int idx = (int)bfs_order.size() - 1; idx >= 0; --idx) {\n int v = bfs_order[idx];\n int deg = children[v].size();\n for (int d = 0; d <= H; ++d) {\n int cur = (d + 1) * A[v];\n for (int i = 0; i < deg; ++i) {\n int u = children[v][i];\n int keepEdge = (d < H) ? dp[u][d + 1] : INF_NEG;\n int cutEdge = dp[u][0];\n if (keepEdge > cutEdge) {\n cur += keepEdge;\n keep[v][d][i] = 1;\n } else {\n cur += cutEdge;\n keep[v][d][i] = 0;\n }\n }\n dp[v][d] = cur;\n }\n }\n \n int bestVal = dp[root][0];\n \n // Reconstruct parent array\n outParent.assign(N, -1);\n static vector> stack2;\n stack2.clear();\n stack2.emplace_back(root, 0);\n \n while (!stack2.empty()) {\n auto [v, depth] = stack2.back();\n stack2.pop_back();\n int deg = children[v].size();\n for (int i = 0; i < deg; ++i) {\n int u = children[v][i];\n if (keep[v][depth][i]) {\n outParent[u] = v;\n stack2.emplace_back(u, depth + 1);\n } else {\n outParent[u] = -1; // new root\n stack2.emplace_back(u, 0);\n }\n }\n }\n \n return bestVal;\n}\n\n/*------------------------------------------------------------*/\n/* Main */\n/*------------------------------------------------------------*/\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n \n vector A(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n \n vector> adj(N);\n for (int i = 0; i < M; ++i) {\n int u, v; cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n // Read coordinates (not used)\n for (int i = 0; i < N; ++i) {\n long long x, y; cin >> x >> y;\n }\n \n // Find minimum beauty vertex for smart rooting\n int minBeautyIdx = 0;\n for (int i = 1; i < N; ++i) {\n if (A[i] < A[minBeautyIdx]) minBeautyIdx = i;\n }\n \n // Number of iterations and roots per tree\n const int ITER = 2200;\n const int ROOTS_PER_TREE = 2;\n \n int bestScore = INF_NEG;\n vector bestParent;\n \n for (int it = 0; it < ITER; ++it) {\n // Pick a random tree generation method\n int method = rng.nextInt(5);\n \n // Build random spanning tree\n vector> tree;\n int treeRoot = rng.nextInt(N);\n build_random_tree(N, M, adj, A, tree, treeRoot, rng, method);\n \n // Try multiple roots: minimum beauty vertex and a random one\n vector roots;\n roots.reserve(ROOTS_PER_TREE);\n roots.push_back(minBeautyIdx);\n if (ROOTS_PER_TREE >= 2) {\n roots.push_back(rng.nextInt(N));\n }\n \n for (int r : roots) {\n vector parent;\n int score = solve_tree_fast(tree, r, A, H, parent);\n if (score > bestScore) {\n bestScore = score;\n bestParent = parent;\n }\n }\n }\n \n // Output result\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << bestParent[i];\n }\n cout << '\\n';\n \n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector board(N);\n for (int i = 0; i < N; ++i) cin >> board[i];\n\n struct Oni {\n int r, c; // position\n int up, down, left, right; // distances to the four borders\n bool canU, canD, canL, canR; // is the direction allowed ?\n };\n\n vector onis;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] == 'x')\n onis.push_back({i, j, i, N - 1 - i, j, N - 1 - j,\n false, false, false, false});\n\n // decide which directions are allowed for every Oni\n for (auto &o : onis) {\n bool f;\n f = true;\n for (int r = 0; r < o.r; ++r)\n if (board[r][o.c] == 'o') { f = false; break; }\n o.canU = f;\n\n f = true;\n for (int r = o.r + 1; r < N; ++r)\n if (board[r][o.c] == 'o') { f = false; break; }\n o.canD = f;\n\n f = true;\n for (int c = 0; c < o.c; ++c)\n if (board[o.r][c] == 'o') { f = false; break; }\n o.canL = f;\n\n f = true;\n for (int c = o.c + 1; c < N; ++c)\n if (board[o.r][c] == 'o') { f = false; break; }\n o.canR = f;\n }\n\n vector> ops; // result sequence\n\n for (const auto &o : onis) {\n int bestDist = INT_MAX;\n char bestDir = '?';\n int param = -1; // row or column index\n\n if (o.canU && o.up < bestDist) {\n bestDist = o.up; bestDir = 'U'; param = o.c;\n }\n if (o.canD && o.down < bestDist) {\n bestDist = o.down; bestDir = 'D'; param = o.c;\n }\n if (o.canL && o.left < bestDist) {\n bestDist = o.left; bestDir = 'L'; param = o.r;\n }\n if (o.canR && o.right < bestDist) {\n bestDist = o.right; bestDir = 'R'; param = o.r;\n }\n\n int cnt = bestDist + 1; // distance + 1\n char opp = (bestDir == 'U' ? 'D' :\n bestDir == 'D' ? 'U' :\n bestDir == 'L' ? 'R' : 'L');\n\n for (int k = 0; k < cnt; ++k) ops.emplace_back(bestDir, param);\n for (int k = 0; k < cnt; ++k) ops.emplace_back(opp, param);\n }\n\n // The problem guarantees that the total number of moves never exceeds 4\u00b7N\u00b2.\n for (auto [d, p] : ops) {\n cout << d << ' ' << p << '\\n';\n }\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nusing ll = long long;\n\nint N = 100;\nconst ll L = 500000LL;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector T(N);\n for (int i = 0; i < N; ++i) cin >> T[i];\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n // Build a plan using simple random assignment with greedy refinement\n auto buildPlan = [&](mt19937& r) {\n vector a(N), b(N);\n \n // Simple random assignment ensuring diversity\n for (int i = 0; i < N; ++i) {\n a[i] = r() % N;\n b[i] = r() % N;\n }\n \n // Try to improve by greedy swaps\n for (int iter = 0; iter < 500; ++iter) {\n int i = r() % N;\n int j = r() % N;\n \n // Try swapping a[i]\n int oldA = a[i];\n a[i] = j;\n // Quick check (we'd need to simulate to be sure, skip for speed)\n a[i] = oldA; // revert\n \n // Try swapping b[i]\n int oldB = b[i];\n b[i] = j;\n b[i] = oldB;\n }\n \n return tuple, vector>(a, b);\n };\n \n // Fast simulation\n auto simulate = [&](const vector& a, const vector& b) {\n vector cnt(N, 0);\n int cur = 0;\n cnt[cur]++;\n for (ll week = 2; week <= L; ++week) {\n if (cnt[cur] & 1) cur = a[cur];\n else cur = b[cur];\n ++cnt[cur];\n }\n return cnt;\n };\n \n // Calculate error\n auto calcError = [&](const vector& cnt) {\n ll err = 0;\n for (int i = 0; i < N; ++i) err += llabs((ll)cnt[i] - T[i]);\n return err;\n };\n \n // Optimize using random neighbor sampling\n auto optimize = [&](vector a, vector b, int maxIter) {\n vector cnt = simulate(a, b);\n ll curErr = calcError(cnt);\n \n for (int iter = 0; iter < maxIter; ++iter) {\n // Pick random source\n int src = uniform_int_distribution(0, N-1)(rng);\n int sOdd = (cnt[src] + 1) / 2;\n int sEven = cnt[src] / 2;\n bool didImprove = false;\n \n // Try swapping a[src] and b[src] if cnt[src] is odd\n if (cnt[src] & 1) {\n int oldOdd = a[src], oldEven = b[src];\n ll delta = \n - llabs((ll)cnt[oldOdd] - T[oldOdd]) - llabs((ll)cnt[oldEven] - T[oldEven])\n + llabs((ll)cnt[oldOdd] - 1 - T[oldOdd]) + llabs((ll)cnt[oldEven] + 1 - T[oldEven]);\n if (delta < 0) {\n swap(a[src], b[src]);\n cnt[oldOdd] -= 1;\n cnt[oldEven] += 1;\n curErr += delta;\n didImprove = true;\n }\n }\n \n // Try moving odd edge\n if (!didImprove) {\n for (int attempt = 0; attempt < 3; ++attempt) {\n int newTarget = uniform_int_distribution(0, N-1)(rng);\n if (newTarget == a[src]) continue;\n \n int oldTarget = a[src];\n ll delta = \n - llabs((ll)cnt[oldTarget] - T[oldTarget]) - llabs((ll)cnt[newTarget] - T[newTarget])\n + llabs((ll)cnt[oldTarget] - sOdd - T[oldTarget]) + llabs((ll)cnt[newTarget] + sOdd - T[newTarget]);\n \n if (delta < 0) {\n a[src] = newTarget;\n cnt[oldTarget] -= sOdd;\n cnt[newTarget] += sOdd;\n curErr += delta;\n didImprove = true;\n break;\n }\n }\n }\n \n // Try moving even edge\n if (!didImprove) {\n for (int attempt = 0; attempt < 3; ++attempt) {\n int newTarget = uniform_int_distribution(0, N-1)(rng);\n if (newTarget == b[src]) continue;\n \n int oldTarget = b[src];\n ll delta = \n - llabs((ll)cnt[oldTarget] - T[oldTarget]) - llabs((ll)cnt[newTarget] - T[newTarget])\n + llabs((ll)cnt[oldTarget] - sEven - T[oldTarget]) + llabs((ll)cnt[newTarget] + sEven - T[newTarget]);\n \n if (delta < 0) {\n b[src] = newTarget;\n cnt[oldTarget] -= sEven;\n cnt[newTarget] += sEven;\n curErr += delta;\n didImprove = true;\n break;\n }\n }\n }\n \n // Occasional full resimulation to correct drift\n if (!didImprove && iter % 500 == 0) {\n cnt = simulate(a, b);\n curErr = calcError(cnt);\n }\n }\n \n return tuple, vector, ll>(a, b, curErr);\n };\n \n ll bestError = (1LL<<60);\n vector bestA(N), bestB(N);\n \n const int RESTARTS = 20;\n const int ITER_PER_RESTART = 5000;\n \n for (int r = 0; r < RESTARTS; ++r) {\n mt19937 r2(r + 12345);\n auto [initA, initB] = buildPlan(r2);\n auto [a, b, err] = optimize(initA, initB, ITER_PER_RESTART);\n \n if (err < bestError) {\n bestError = err;\n bestA = a;\n bestB = b;\n if (bestError == 0) break;\n }\n }\n \n for (int i = 0; i < N; ++i) {\n cout << bestA[i] << ' ' << bestB[i] << '\\n';\n }\n \n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; ++i) {\n cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n /* -----------------------------------------------------------\n 1. grouping : sort by rectangle centre\n ----------------------------------------------------------- */\n vector cx(N), cy(N);\n for (int i = 0; i < N; ++i) {\n cx[i] = (lx[i] + rx[i]) * 0.5;\n cy[i] = (ly[i] + ry[i]) * 0.5;\n }\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b) {\n if (cx[a] != cx[b]) return cx[a] < cx[b];\n return cy[a] < cy[b];\n });\n\n vector> groups(M);\n int pos = 0;\n for (int g = 0; g < M; ++g) {\n for (int cnt = 0; cnt < G[g]; ++cnt) {\n groups[g].push_back(order[pos++]);\n }\n }\n\n /* -----------------------------------------------------------\n 2. helper: perform one query\n ----------------------------------------------------------- */\n auto do_query = [&](const vector& verts) -> vector> {\n int L = (int)verts.size();\n cout << \"? \" << L;\n for (int v : verts) cout << ' ' << v;\n cout << \"\\n\";\n cout.flush();\n vector> edges;\n edges.reserve(L-1);\n for (int i = 0; i < L-1; ++i) {\n int a,b; cin >> a >> b;\n edges.emplace_back(a,b);\n }\n return edges;\n };\n\n /* -----------------------------------------------------------\n 3. ask queries for every group, store the received edges\n ----------------------------------------------------------- */\n vector>> groupEdges(M);\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n if (sz <= 1) continue; // no road needed\n if (sz <= L) {\n auto e = do_query(grp);\n groupEdges[g] = move(e);\n } else {\n int start = 0;\n while (start + 1 < sz) { // at least two vertices left\n int end = min(start + L, sz);\n vector win(grp.begin() + start, grp.begin() + end);\n auto e = do_query(win);\n groupEdges[g].insert(groupEdges[g].end(),\n e.begin(), e.end());\n start = end - 1; // overlap = 1 vertex\n }\n }\n }\n\n /* -----------------------------------------------------------\n 4. output the answer\n ----------------------------------------------------------- */\n cout << \"!\\n\";\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n // list of cities\n for (int i = 0; i < sz; ++i) {\n if (i) cout << ' ';\n cout << grp[i];\n }\n cout << \"\\n\";\n if (sz <= 1) continue; // no edges\n\n // map global id -> local index (0 \u2026 sz-1)\n vector id2loc(N, -1);\n for (int i = 0; i < sz; ++i) id2loc[grp[i]] = i;\n\n // adjacency list of the collected edges\n vector> adj(sz);\n for (auto &e : groupEdges[g]) {\n int u = e.first, v = e.second;\n int ui = id2loc[u];\n int vi = id2loc[v];\n if (ui >= 0 && vi >= 0) {\n adj[ui].push_back(vi);\n adj[vi].push_back(ui);\n }\n }\n\n // DFS to obtain a spanning tree\n vector parent(sz, -1);\n vector visited(sz, 0);\n vector st = {0};\n visited[0] = 1;\n while (!st.empty()) {\n int u = st.back(); st.pop_back();\n for (int v : adj[u]) if (!visited[v]) {\n visited[v] = 1;\n parent[v] = u;\n st.push_back(v);\n }\n }\n // (the graph is connected by Lemma\u202f1, but be safe)\n for (int i = 0; i < sz; ++i) if (!visited[i]) {\n parent[i] = 0; // connect arbitrarily\n }\n\n // output the tree edges\n for (int i = 1; i < sz; ++i) {\n int a = grp[i];\n int b = grp[parent[i]];\n if (a > b) swap(a,b);\n cout << a << ' ' << b << \"\\n\";\n }\n }\n cout.flush();\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M; // N=20, M=40\n\n vector> pts(M);\n for (int i = 0; i < M; ++i) cin >> pts[i].first >> pts[i].second;\n\n // Directions: index 0=Up,1=Down,2=Left,3=Right\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n auto nodeId = [&](int r, int c) { return r * N + c; };\n auto slideDest = [&](int r, int c, int d) {\n int nr = r, nc = c;\n if (d == 0) nr = 0; // Up\n else if (d == 1) nr = N-1; // Down\n else if (d == 2) nc = 0; // Left\n else if (d == 3) nc = N-1; // Right\n return make_pair(nr, nc);\n };\n\n vector answer;\n answer.reserve(2000);\n\n int cr = pts[0].first;\n int cc = pts[0].second;\n\n for (int idx = 1; idx < M; ++idx) {\n int tr = pts[idx].first;\n int tc = pts[idx].second;\n\n // BFS from (cr,cc) to (tr,tc)\n const int SRC = nodeId(cr, cc);\n const int DST = nodeId(tr, tc);\n\n vector dist(N*N, -1);\n vector parent(N*N, -1);\n vector> act(N*N, {'?', '?'}); // action type and direction\n\n queue q;\n q.push(SRC);\n dist[SRC] = 0;\n\n while (!q.empty() && dist[DST] == -1) {\n int u = q.front(); q.pop();\n int ur = u / N, uc = u % N;\n\n // Try moves and slides\n for (int d = 0; d < 4; ++d) {\n // Move\n int mr = ur + dr[d];\n int mc = uc + dc[d];\n if (mr >= 0 && mr < N && mc >= 0 && mc < N) {\n int v = nodeId(mr, mc);\n if (dist[v] == -1) {\n dist[v] = dist[u] + 1;\n parent[v] = u;\n act[v] = {'M', dirChar[d]};\n q.push(v);\n }\n }\n // Slide\n auto p = slideDest(ur, uc, d);\n int sr = p.first, sc = p.second;\n int v = nodeId(sr, sc);\n if (v != u && dist[v] == -1) {\n dist[v] = dist[u] + 1;\n parent[v] = u;\n act[v] = {'S', dirChar[d]};\n q.push(v);\n }\n }\n }\n\n // Reconstruct path from DST to SRC\n vector segment;\n int cur = DST;\n while (cur != SRC) {\n int p = parent[cur];\n char a = act[cur].first;\n char d = act[cur].second;\n segment.emplace_back(string(1, a) + \" \" + d);\n cur = p;\n }\n reverse(segment.begin(), segment.end());\n for (auto &s : segment) answer.push_back(s);\n\n // Update current position\n cr = tr;\n cc = tc;\n }\n\n // Output\n for (auto &s : answer) cout << s << '\\n';\n return 0;\n}"},"8":{"ahc001":"#include \nusing namespace std;\n\nint n;\nvector X, Y;\nvector R;\nvector A, B, C, D;\n\nstruct Point {\n int x, y;\n long long r;\n int id;\n};\n\n// Main recursive partitioning with proportional area allocation\nvoid partitionSmart(vector& pts, int x1, int x2, int y1, int y2, int depth) {\n if (pts.empty()) return;\n if (pts.size() == 1) {\n int id = pts[0].id;\n A[id] = x1;\n B[id] = y1;\n C[id] = x2;\n D[id] = y2;\n return;\n }\n \n long long totalR = 0;\n for (auto& p : pts) totalR += p.r;\n \n int width = x2 - x1;\n int height = y2 - y1;\n long long area = 1LL * width * height;\n \n if (width <= 0 || height <= 0) return;\n \n // Find bounding box of points\n int minX = pts[0].x, maxX = pts[0].x, minY = pts[0].y, maxY = pts[0].y;\n for (auto& p : pts) {\n minX = min(minX, p.x);\n maxX = max(maxX, p.x);\n minY = min(minY, p.y);\n maxY = max(maxY, p.y);\n }\n int spreadX = maxX - minX;\n int spreadY = maxY - minY;\n \n // Choose split direction based on aspect ratio and point spread\n bool splitVertical;\n if (spreadX > spreadY) {\n splitVertical = true;\n } else if (spreadY > spreadX) {\n splitVertical = false;\n } else {\n splitVertical = (width > height);\n }\n \n if (splitVertical) {\n // Sort by x\n sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) {\n return a.x < b.x;\n });\n \n // Target left area proportional to totalR\n long long targetLeft = (totalR * width) / area;\n targetLeft = max(1LL, min(targetLeft, (long long)width - 1));\n \n // Find split point\n long long cumR = 0;\n int splitX = x1 + 1;\n bool found = false;\n \n for (size_t i = 0; i < pts.size(); ++i) {\n cumR += pts[i].r;\n // Can split after this point if next point has different x\n if (i + 1 < pts.size() && pts[i+1].x != pts[i].x) {\n if (cumR >= targetLeft || i + 1 >= pts.size() - 1) {\n splitX = max(splitX, min(x2 - 1, pts[i].x + 1));\n found = true;\n break;\n }\n }\n }\n \n if (!found) {\n splitX = (x1 + x2) / 2;\n }\n \n // Ensure valid split\n splitX = max(splitX, minX + 1);\n splitX = min(splitX, maxX);\n splitX = max(x1 + 1, min(splitX, x2 - 1));\n \n // Split points\n vector left, right;\n for (auto& p : pts) {\n if (p.x < splitX) left.push_back(p);\n else right.push_back(p);\n }\n \n if (left.empty()) left.push_back(pts[0]);\n if (right.empty()) right.push_back(pts.back());\n \n partitionSmart(left, x1, splitX, y1, y2, depth + 1);\n partitionSmart(right, splitX, x2, y1, y2, depth + 1);\n } else {\n // Sort by y\n sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) {\n return a.y < b.y;\n });\n \n // Target bottom area proportional to totalR\n long long targetBottom = (totalR * height) / area;\n targetBottom = max(1LL, min(targetBottom, (long long)height - 1));\n \n // Find split point\n long long cumR = 0;\n int splitY = y1 + 1;\n bool found = false;\n \n for (size_t i = 0; i < pts.size(); ++i) {\n cumR += pts[i].r;\n if (i + 1 < pts.size() && pts[i+1].y != pts[i].y) {\n if (cumR >= targetBottom || i + 1 >= pts.size() - 1) {\n splitY = max(splitY, min(y2 - 1, pts[i].y + 1));\n found = true;\n break;\n }\n }\n }\n \n if (!found) {\n splitY = (y1 + y2) / 2;\n }\n \n // Ensure valid split\n splitY = max(splitY, minY + 1);\n splitY = min(splitY, maxY);\n splitY = max(y1 + 1, min(splitY, y2 - 1));\n \n // Split points\n vector bottom, top;\n for (auto& p : pts) {\n if (p.y < splitY) bottom.push_back(p);\n else top.push_back(p);\n }\n \n if (bottom.empty()) bottom.push_back(pts[0]);\n if (top.empty()) top.push_back(pts.back());\n \n partitionSmart(bottom, x1, x2, y1, splitY, depth + 1);\n partitionSmart(top, x1, x2, splitY, y2, depth + 1);\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n if (!(cin >> n)) return 0;\n X.resize(n);\n Y.resize(n);\n R.resize(n);\n \n for (int i = 0; i < n; ++i) {\n cin >> X[i] >> Y[i] >> R[i];\n }\n \n A.resize(n);\n B.resize(n);\n C.resize(n);\n D.resize(n);\n \n vector pts(n);\n for (int i = 0; i < n; ++i) {\n pts[i] = {X[i], Y[i], R[i], i};\n }\n \n // Use recursive partitioning\n partitionSmart(pts, 0, 10000, 0, 10000, 0);\n \n // Verify and ensure rectangles contain their points\n for (int i = 0; i < n; ++i) {\n // Ensure rectangle contains the unit square of the point\n if (A[i] > X[i]) A[i] = X[i];\n if (C[i] <= X[i]) C[i] = X[i] + 1;\n if (B[i] > Y[i]) B[i] = Y[i];\n if (D[i] <= Y[i]) D[i] = Y[i] + 1;\n \n // Ensure valid coordinates\n A[i] = max(0, min(A[i], 9999));\n C[i] = max(A[i] + 1, min(C[i], 10000));\n B[i] = max(0, min(B[i], 9999));\n D[i] = max(B[i] + 1, min(D[i], 10000));\n \n cout << A[i] << ' ' << B[i] << ' ' << C[i] << ' ' << D[i] << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \nusing namespace std;\nusing namespace std::chrono;\n\nint N = 50;\nint startI, startJ;\nint tileId[50][50];\nint val[50][50];\nint M = 0;\nvector> adj;\nint totalMaxWeight = 0;\nvector tileWeight;\n\nvector visitedTile;\nint visitedCnt = 0;\nint sumVisitedMax = 0;\nint curSum = 0;\nstring curMoves;\nint bestSum = 0;\nstring bestMoves;\nbool foundAll = false;\ndouble timeLimit = 1.7;\nsteady_clock::time_point startTime;\n\ninline bool outOfTime() {\n return (steady_clock::now() - startTime).count() * 1e-9 > timeLimit;\n}\n\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U','D','L','R'};\n\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\nvoid dfs(int ci, int cj, int depth = 0) {\n if (outOfTime() || foundAll) return;\n if (depth > 2500) return; // Safety limit\n\n if (curSum > bestSum) {\n bestSum = curSum;\n bestMoves = curMoves;\n }\n\n if (visitedCnt == M) {\n foundAll = true;\n bestSum = curSum;\n bestMoves = curMoves;\n return;\n }\n\n int remainingMax = totalMaxWeight - sumVisitedMax;\n if (curSum + remainingMax <= bestSum) return;\n\n for (int d = 0; d < 4; ++d) {\n if (outOfTime()) return;\n \n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int nt = tileId[ni][nj];\n if (visitedTile[nt]) continue;\n \n visitedTile[nt] = 1;\n ++visitedCnt;\n sumVisitedMax += tileWeight[nt];\n curSum += val[ni][nj];\n curMoves.push_back(dirChar[d]);\n\n dfs(ni, nj, depth + 1);\n\n curMoves.pop_back();\n curSum -= val[ni][nj];\n sumVisitedMax -= tileWeight[nt];\n --visitedCnt;\n visitedTile[nt] = 0;\n \n if (foundAll) return;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n if (!(cin >> startI >> startJ)) return 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> tileId[i][j];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> val[i][j];\n\n int maxTileId = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n maxTileId = max(maxTileId, tileId[i][j]);\n M = maxTileId + 1;\n\n adj.assign(M, {});\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int a = tileId[i][j];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d];\n int nj = j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int b = tileId[ni][nj];\n if (a != b) adj[a].push_back(b);\n }\n }\n }\n for (int i = 0; i < M; ++i) {\n sort(adj[i].begin(), adj[i].end());\n adj[i].erase(unique(adj[i].begin(), adj[i].end()), adj[i].end());\n }\n\n tileWeight.assign(M, 0);\n for (int id = 0; id < M; ++id) {\n int w = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (tileId[i][j] == id)\n w = max(w, val[i][j]);\n tileWeight[id] = w;\n totalMaxWeight += w;\n }\n\n visitedTile.assign(M, 0);\n \n startTime = steady_clock::now();\n \n // Initial solution\n visitedTile[tileId[startI][startJ]] = 1;\n visitedCnt = 1;\n sumVisitedMax = tileWeight[tileId[startI][startJ]];\n curSum = val[startI][startJ];\n \n dfs(startI, startJ, 0);\n\n cout << bestMoves << '\\n';\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nconstexpr int N = 30;\nconstexpr int NH = N * (N - 1);\nconstexpr int NV = (N - 1) * N;\nconstexpr int E_total = NH + NV;\n\nconstexpr double SIGMA0 = 5000.0;\nconstexpr double VAR_FACTOR = 0.00333333333333;\nconstexpr double VAR_ROUND = 1.0 / 12.0;\nconstexpr double MIN_W = 100.0;\nconstexpr double MAX_W = 20000.0;\nconstexpr double MIN_VAR = 1.0;\nconstexpr double INIT_VAR = SIGMA0 * SIGMA0;\n\nint idxH[N][N - 1];\nint idxV[N - 1][N];\n\ninline int edgeIdx(int u, int v) {\n int ur = u / N, uc = u % N;\n int vr = v / N, vc = v % N;\n if (ur == vr) {\n return idxH[ur][min(uc, vc)];\n } else {\n return idxV[min(ur, vr)][uc];\n }\n}\n\ninline double getWeight(int e, const vector &w) { return w[e]; }\n\nvector dijkstra_path(int sr, int sc, int tr, int tc,\n const vector &weight,\n bool randomFlag,\n mt19937 &rng) {\n const int V = N * N;\n const int start = sr * N + sc;\n const int target = tr * N + tc;\n const double INF = 1e100;\n const double EPS = 1e-12;\n\n vector dist(V, INF);\n vector parent(V, -1);\n dist[start] = 0.0;\n\n using PDI = pair;\n priority_queue, greater> pq;\n pq.emplace(0.0, start);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u] + EPS) continue;\n if (u == target) break;\n\n int ur = u / N, uc = u % N;\n int nxt[4] = {ur > 0 ? (ur - 1) * N + uc : -1,\n ur + 1 < N ? (ur + 1) * N + uc : -1,\n uc > 0 ? ur * N + (uc - 1) : -1,\n uc + 1 < N ? ur * N + (uc + 1) : -1};\n\n for (int k = 0; k < 4; ++k) {\n int v = nxt[k];\n if (v < 0) continue;\n double w = getWeight(edgeIdx(u, v), weight);\n double nd = d + w;\n if (nd + EPS < dist[v]) {\n dist[v] = nd;\n parent[v] = u;\n pq.emplace(nd, v);\n } else if (fabs(nd - dist[v]) < EPS && randomFlag) {\n if (uniform_int_distribution(0, 1)(rng) == 0) {\n parent[v] = u;\n }\n }\n }\n }\n\n vector path;\n if (dist[target] == INF) return path;\n for (int cur = target; cur != -1; cur = parent[cur]) {\n path.push_back(cur);\n if (cur == start) break;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// Better exploration: find all shortest paths and pick one with max variance\nvector dijkstra_explore(int sr, int sc, int tr, int tc,\n const vector &weight,\n const vector &variance,\n mt19937 &rng) {\n const int V = N * N;\n const int start = sr * N + sc;\n const int target = tr * N + tc;\n const double INF = 1e100;\n const double EPS = 1e-12;\n\n vector dist(V, INF);\n vector parent(V, -1);\n dist[start] = 0.0;\n\n using PDI = pair;\n priority_queue, greater> pq;\n pq.emplace(0.0, start);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u] + EPS) continue;\n if (u == target) break;\n\n int ur = u / N, uc = u % N;\n int nxt[4] = {ur > 0 ? (ur - 1) * N + uc : -1,\n ur + 1 < N ? (ur + 1) * N + uc : -1,\n uc > 0 ? ur * N + (uc - 1) : -1,\n uc + 1 < N ? ur * N + (uc + 1) : -1};\n\n for (int k = 0; k < 4; ++k) {\n int v = nxt[k];\n if (v < 0) continue;\n double w = getWeight(edgeIdx(u, v), weight);\n double nd = d + w;\n if (nd + EPS < dist[v]) {\n dist[v] = nd;\n parent[v] = u;\n pq.emplace(nd, v);\n }\n }\n }\n\n if (dist[target] == INF) return {};\n\n // Collect all shortest paths using BFS from target\n vector> paths;\n vector> stack;\n stack.push_back({target});\n\n while (!stack.empty()) {\n vector cur = stack.back();\n stack.pop_back();\n int v = cur.back();\n if (v == start) {\n paths.push_back(cur);\n continue;\n }\n int p = parent[v];\n if (p == -1) continue;\n cur.push_back(p);\n stack.push_back(cur);\n }\n\n if (paths.empty()) return {};\n\n // Pick path with maximum total variance (explore uncertain edges)\n vector bestPath;\n double bestVar = -1.0;\n for (auto &p : paths) {\n double totalVar = 0.0;\n for (size_t i = 0; i + 1 < p.size(); ++i) {\n int e = edgeIdx(p[i], p[i + 1]);\n totalVar += variance[e];\n }\n if (totalVar > bestVar) {\n bestVar = totalVar;\n bestPath = p;\n }\n }\n reverse(bestPath.begin(), bestPath.end());\n return bestPath;\n}\n\nstring pathToString(const vector &verts) {\n string out;\n if (verts.empty()) return out;\n out.reserve(verts.size() - 1);\n for (size_t i = 0; i + 1 < verts.size(); ++i) {\n int ur = verts[i] / N, uc = verts[i] % N;\n int vr = verts[i + 1] / N, vc = verts[i + 1] % N;\n if (vr == ur + 1) out.push_back('D');\n else if (vr == ur - 1) out.push_back('U');\n else if (vc == uc + 1) out.push_back('R');\n else if (vc == uc - 1) out.push_back('L');\n }\n return out;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int eid = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N - 1; ++j)\n idxH[i][j] = eid++;\n for (int i = 0; i < N - 1; ++i)\n for (int j = 0; j < N; ++j)\n idxV[i][j] = eid++;\n\n vector x(E_total, 5000.0);\n vector var(E_total, INIT_VAR);\n\n mt19937 rng(1234567);\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) return 0;\n\n bool exploration = (q < 200);\n\n vector verts;\n if (exploration) {\n // Use variance-guided exploration\n verts = dijkstra_explore(si, sj, ti, tj, x, var, rng);\n if (verts.empty()) {\n verts = dijkstra_path(si, sj, ti, tj, x, false, rng);\n }\n } else {\n verts = dijkstra_path(si, sj, ti, tj, x, false, rng);\n }\n\n string out = pathToString(verts);\n cout << out << '\\n';\n cout.flush();\n\n long long observed;\n cin >> observed;\n\n if (verts.size() <= 1) continue;\n\n int L = (int)verts.size() - 1;\n vector edges;\n edges.reserve(L);\n double sumX = 0.0;\n double sumVar = 0.0;\n\n for (int i = 0; i < L; ++i) {\n int e = edgeIdx(verts[i], verts[i + 1]);\n edges.push_back(e);\n sumX += x[e];\n sumVar += var[e];\n }\n\n double R = VAR_FACTOR * sumX * sumX + VAR_ROUND;\n double S = sumVar + R;\n double residual = (double)observed - sumX;\n\n for (int e : edges) {\n double K = var[e] / S;\n x[e] += K * residual;\n if (x[e] < MIN_W) x[e] = MIN_W;\n if (x[e] > MAX_W) x[e] = MAX_W;\n var[e] *= (1.0 - K);\n if (var[e] < MIN_VAR) var[e] = MIN_VAR;\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20;\n\nint M;\nvector strs;\nvector slen;\n\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\nint countCoverage(vector &mat) {\n int cnt = 0;\n for (int sid = 0; sid < M; ++sid) {\n const string &s = strs[sid];\n int L = slen[sid];\n bool ok = false;\n for (int r = 0; r < N && !ok; ++r) {\n for (int start = 0; start < N && !ok; ++start) {\n ok = true;\n for (int p = 0; p < L; ++p) {\n if (mat[r * N + (start + p) % N] != s[p]) { ok = false; break; }\n }\n }\n }\n if (!ok) {\n for (int c = 0; c < N && !ok; ++c) {\n for (int start = 0; start < N && !ok; ++start) {\n ok = true;\n for (int p = 0; p < L; ++p) {\n if (mat[((start + p) % N) * N + c] != s[p]) { ok = false; break; }\n }\n }\n }\n }\n if (ok) ++cnt;\n }\n return cnt;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int Ninput;\n if (!(cin >> Ninput >> M)) return 0;\n \n strs.resize(M);\n for (int i = 0; i < M; ++i) cin >> strs[i];\n \n slen.resize(M);\n for (int i = 0; i < M; ++i) slen[i] = (int)strs[i].size();\n \n vector bestMatrix(N * N, '.');\n int bestCoverage = 0;\n \n // Multiple restarts with different strategies\n const int RESTARTS = 15;\n \n for (int restart = 0; restart < RESTARTS; ++restart) {\n vector mat(N * N, '.');\n vector covered(M, 0);\n int coveredCnt = 0;\n \n // Shuffle strings\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n \n // Greedy placement with more attempts\n for (int idx : order) {\n const string &s = strs[idx];\n int L = slen[idx];\n bool placed = false;\n \n for (int attempt = 0; attempt < 200 && !placed; ++attempt) {\n int ori = rng() % 2;\n int line = rng() % N;\n int start = rng() % N;\n \n bool conflict = false;\n for (int p = 0; p < L; ++p) {\n int rr = ori == 0 ? line : (start + p) % N;\n int cc = ori == 0 ? (start + p) % N : line;\n if (mat[rr * N + cc] != '.' && mat[rr * N + cc] != s[p]) {\n conflict = true; break;\n }\n }\n if (conflict) continue;\n \n for (int p = 0; p < L; ++p) {\n int rr = ori == 0 ? line : (start + p) % N;\n int cc = ori == 0 ? (start + p) % N : line;\n mat[rr * N + cc] = s[p];\n }\n placed = true;\n }\n \n if (placed) {\n covered[idx] = 1;\n ++coveredCnt;\n }\n }\n \n // Aggressive mutation\n for (int iter = 0; iter < 10000; ++iter) {\n int sid = rng() % M;\n const string &s = strs[sid];\n int L = slen[sid];\n \n bool placed = false;\n for (int attempt = 0; attempt < 50 && !placed; ++attempt) {\n int ori = rng() % 2;\n int line = rng() % N;\n int start = rng() % N;\n \n bool conflict = false;\n for (int p = 0; p < L; ++p) {\n int rr = ori == 0 ? line : (start + p) % N;\n int cc = ori == 0 ? (start + p) % N : line;\n if (mat[rr * N + cc] != '.' && mat[rr * N + cc] != s[p]) {\n conflict = true; break;\n }\n }\n if (conflict) continue;\n \n for (int p = 0; p < L; ++p) {\n int rr = ori == 0 ? line : (start + p) % N;\n int cc = ori == 0 ? (start + p) % N : line;\n mat[rr * N + cc] = s[p];\n }\n placed = true;\n }\n }\n \n int cov = countCoverage(mat);\n if (cov > bestCoverage) {\n bestCoverage = cov;\n bestMatrix = mat;\n if (bestCoverage == M) break;\n }\n }\n \n // Deletion phase\n if (bestCoverage == M) {\n for (int iter = 0; iter < 10000; ++iter) {\n vector occ;\n for (int i = 0; i < N * N; ++i)\n if (bestMatrix[i] != '.') occ.push_back(i);\n if (occ.empty()) break;\n \n int cellId = occ[rng() % occ.size()];\n char saved = bestMatrix[cellId];\n bestMatrix[cellId] = '.';\n \n if (countCoverage(bestMatrix) != M) {\n bestMatrix[cellId] = saved;\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j)\n cout << bestMatrix[i * N + j];\n cout << '\\n';\n }\n \n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector g(N);\n for (int i = 0; i < N; ++i) cin >> g[i];\n\n // ----- 1. vertex mapping ------------------------------------------------\n vector> id(N, vector(N, -1));\n vector weight; // weight of each vertex\n vector row, col; // coordinates\n int V = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (g[i][j] != '#') {\n id[i][j] = V++;\n weight.push_back(g[i][j] - '0');\n row.push_back(i);\n col.push_back(j);\n }\n\n // ----- 2. directed adjacency (cost = weight of destination) -------------\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n vector>> adj(V);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (id[i][j] != -1) {\n int u = id[i][j];\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int v = id[ni][nj];\n if (v == -1) continue;\n adj[u].push_back({v, weight[v]}); // cost = weight of v\n }\n }\n\n // start vertex id\n int start = id[si][sj];\n\n // ----- 3. all\u2011pairs shortest directed distances + predecessors ----------\n const int INF = 1e9;\n vector> dist(V, vector(V, INF));\n vector> parent(V, vector(V, -1));\n\n for (int s = 0; s < V; ++s) {\n priority_queue, vector>, greater>> pq;\n dist[s][s] = 0;\n pq.emplace(0, s);\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[s][u]) continue;\n for (auto [v, w] : adj[u]) {\n if (dist[s][v] > d + w) {\n dist[s][v] = d + w;\n parent[s][v] = u;\n pq.emplace(dist[s][v], v);\n }\n }\n }\n }\n\n // ----- 4. nearest\u2011neighbour tour (ATSP) --------------------------------\n vector tour;\n tour.reserve(V);\n vector visited(V, 0);\n tour.push_back(start);\n visited[start] = 1;\n int cur = start;\n while ((int)tour.size() < V) {\n int best = -1;\n int bestDist = INF;\n for (int v = 0; v < V; ++v) if (!visited[v]) {\n int d = dist[cur][v];\n if (d < bestDist) {\n bestDist = d;\n best = v;\n }\n }\n if (best == -1) break; // should never happen (graph is connected)\n visited[best] = 1;\n tour.push_back(best);\n cur = best;\n }\n\n // ----- 5. 2\u2011opt improvement --------------------------------------------\n bool improved = true;\n while (improved) {\n improved = false;\n int n = (int)tour.size();\n for (int i = 0; i < n - 1; ++i) {\n int u = tour[i];\n int v = tour[i + 1];\n for (int j = i + 2; j < n; ++j) {\n int x = tour[j];\n int y = (j + 1 == n ? tour[0] : tour[j + 1]);\n long long delta = (long long)dist[u][x] + dist[v][y]\n - ((long long)dist[u][v] + dist[x][y]);\n if (delta < 0) {\n reverse(tour.begin() + i + 1, tour.begin() + j + 1);\n improved = true;\n }\n }\n }\n }\n\n // ----- 6. reconstruct the actual walk ---------------------------------\n string moves;\n moves.reserve(200000); // enough for typical cases\n int n = (int)tour.size();\n for (int i = 0; i < n; ++i) {\n int src = tour[i];\n int dst = (i + 1 == n) ? tour[0] : tour[i + 1];\n // build shortest path src -> dst using predecessor table\n vector path;\n int curNode = dst;\n while (curNode != src) {\n path.push_back(curNode);\n curNode = parent[src][curNode];\n }\n path.push_back(src);\n reverse(path.begin(), path.end());\n for (size_t k = 0; k + 1 < path.size(); ++k) {\n int a = path[k];\n int b = path[k + 1];\n int dr = row[b] - row[a];\n int dc = col[b] - col[a];\n if (dr == -1) moves.push_back('U');\n else if (dr == 1) moves.push_back('D');\n else if (dc == -1) moves.push_back('L');\n else if (dc == 1) moves.push_back('R');\n // else: never happens (grid neighbours only)\n }\n }\n\n cout << moves << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint N, M, K;\nvector> d;\nvector> LB;\nvector> UB;\nvector> pred_cache;\nvector speed;\nvector> succ;\nvector topo;\n\n// Fast inline prediction\ninline int get_pred(int w, int task) {\n int& cached = pred_cache[w][task];\n if (cached > 0) return cached;\n \n double exp_def = 0.0;\n for (int k = 0; k < K; ++k) {\n int req = d[task][k];\n int L = LB[w][k];\n int U = UB[w][k];\n if (req > L) {\n if (req >= U) {\n exp_def += req - (L + U) * 0.5;\n } else {\n double diff = req - L;\n exp_def += diff * diff / (2.0 * (U - L));\n }\n }\n }\n cached = max(1, (int)ceil(exp_def * speed[w]) + 1);\n return cached;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n if (!(cin >> N >> M >> K)) return 0;\n int R;\n cin >> R;\n \n d.assign(N, vector(K));\n for (int i = 0; i < N; ++i)\n for (int k = 0; k < K; ++k)\n cin >> d[i][k];\n \n succ.assign(N, {});\n vector indeg(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n succ[u].push_back(v);\n ++indeg[v];\n }\n \n // Max required skill\n vector maxReq(K, 0);\n for (int i = 0; i < N; ++i)\n for (int k = 0; k < K; ++k)\n maxReq[k] = max(maxReq[k], d[i][k]);\n \n // Topological order\n topo.clear();\n {\n vector indeg_copy = indeg;\n queue q;\n for (int i = 0; i < N; ++i)\n if (indeg_copy[i] == 0) q.push(i);\n while (!q.empty()) {\n int v = q.front(); q.pop();\n topo.push_back(v);\n for (int nxt : succ[v])\n if (--indeg_copy[nxt] == 0) q.push(nxt);\n }\n }\n \n // State\n vector indeg_rem = indeg;\n vector status(N, 0);\n vector assigned_task(M, -1);\n vector start_day(M, -1);\n vector cur_pred(M, 0);\n \n // Skill bounds\n LB.assign(M, vector(K, 0));\n UB.assign(M, vector(K));\n for (int j = 0; j < M; ++j) UB[j] = maxReq;\n \n pred_cache.assign(M, vector(N, 0));\n \n // Speed factors\n speed.assign(M, 1.0);\n vector real_time(M, 0), pred_time(M, 0);\n \n // Ready tasks\n vector ready;\n for (int i = 0; i < N; ++i)\n if (indeg[i] == 0) ready.push_back(i);\n \n // Static critical path (computed once)\n vector height(N, 1);\n {\n vector best_dur(N, 1);\n for (int idx = (int)topo.size() - 1; idx >= 0; --idx) {\n int v = topo[idx];\n int max_succ = 0;\n for (int nxt : succ[v]) max_succ = max(max_succ, height[nxt]);\n height[v] = best_dur[v] + max_succ;\n }\n }\n \n // Update after completion\n auto update_bounds = [&](int w, int task, int duration) {\n int U_est = duration + 3;\n \n for (int k = 0; k < K; ++k) {\n int req = d[task][k];\n if (U_est == 0) {\n LB[w][k] = max(LB[w][k], req);\n } else {\n LB[w][k] = max(LB[w][k], max(0, req - U_est));\n }\n }\n // Invalidate cache for this worker\n fill(pred_cache[w].begin(), pred_cache[w].end(), 0);\n \n if (cur_pred[w] > 0) {\n real_time[w] += duration;\n pred_time[w] += cur_pred[w];\n if (pred_time[w] > 0) {\n speed[w] = (double)real_time[w] / pred_time[w];\n if (speed[w] < 0.1) speed[w] = 0.1;\n if (speed[w] > 10.0) speed[w] = 10.0;\n }\n }\n };\n \n int day = 0;\n while (true) {\n ++day;\n \n // Collect idle workers\n vector idle;\n for (int w = 0; w < M; ++w)\n if (assigned_task[w] == -1) idle.push_back(w);\n \n // Collect ready tasks\n vector ready_tasks;\n for (int t : ready)\n if (status[t] == 0) ready_tasks.push_back(t);\n \n vector> assign;\n \n if (!idle.empty() && !ready_tasks.empty()) {\n // Sort idle workers by experience (prefer less experienced for exploration)\n sort(idle.begin(), idle.end(), [&](int a, int b) {\n return real_time[a] < real_time[b];\n });\n \n // Greedy assignment with priority\n vector used(N, 0);\n \n for (int w : idle) {\n int best_task = -1;\n int best_score = INT_MIN;\n \n for (int t : ready_tasks) {\n if (used[t]) continue;\n int dur = get_pred(w, t);\n // Score: height gives priority, duration gives efficiency\n int score = height[t] * 50 - dur;\n // Adaptive exploration noise\n int noise = (rand() % 21) - 10;\n score += noise;\n \n if (score > best_score) {\n best_score = score;\n best_task = t;\n }\n }\n \n if (best_task >= 0) {\n used[best_task] = 1;\n assign.emplace_back(w + 1, best_task + 1);\n assigned_task[w] = best_task;\n start_day[w] = day;\n cur_pred[w] = get_pred(w, best_task);\n status[best_task] = 1;\n }\n }\n }\n \n // Output\n if (assign.empty()) {\n cout << 0 << \"\\n\";\n } else {\n cout << assign.size();\n for (auto &p : assign) cout << ' ' << p.first << ' ' << p.second;\n cout << \"\\n\";\n }\n cout.flush();\n \n // Read completions\n int n_finish;\n cin >> n_finish;\n if (n_finish == -1) break;\n \n for (int i = 0; i < n_finish; ++i) {\n int w; cin >> w; --w;\n int tsk = assigned_task[w];\n if (tsk == -1) continue;\n \n int duration = day - start_day[w] + 1;\n update_bounds(w, tsk, duration);\n \n status[tsk] = 2;\n assigned_task[w] = -1;\n start_day[w] = -1;\n cur_pred[w] = 0;\n \n for (int nxt : succ[tsk]) {\n --indeg_rem[nxt];\n if (indeg_rem[nxt] == 0 && status[nxt] == 0) {\n ready.push_back(nxt);\n }\n }\n }\n \n if (day >= 2000) break;\n }\n \n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nconst int BASE = 0;\nint NPOINTS;\nvector X, Y;\nint pickNode[1000];\nint delvNode[1000];\nbool isPick[2001];\nint orderOf[2001];\n\ninline int manhattan(int a, int b) {\n return abs(X[a] - X[b]) + abs(Y[a] - Y[b]);\n}\n\ninline int idxAfterRem(int p, int removed) {\n return (p < removed) ? p : p + 1;\n}\n\nlong long tourLength(const vector& tour) {\n if (tour.empty()) return 0;\n long long len = manhattan(BASE, tour[0]) + manhattan(tour.back(), BASE);\n for (int i = 0; i + 1 < (int)tour.size(); ++i)\n len += manhattan(tour[i], tour[i + 1]);\n return len;\n}\n\nvector buildInitialTour(const vector& orders) {\n vector pickups, deliveries;\n pickups.reserve(orders.size());\n deliveries.reserve(orders.size());\n for (int o : orders) {\n pickups.push_back(pickNode[o]);\n deliveries.push_back(delvNode[o]);\n }\n\n vector tour;\n int cur = BASE;\n int m = (int)pickups.size();\n vector used(m, 0);\n while ((int)tour.size() < m) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < m; ++i) if (!used[i]) {\n int d = manhattan(cur, pickups[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n used[best] = 1;\n tour.push_back(pickups[best]);\n cur = pickups[best];\n }\n\n int dsz = (int)deliveries.size();\n vector usedD(dsz, 0);\n while ((int)tour.size() < m + dsz) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < dsz; ++i) if (!usedD[i]) {\n int d = manhattan(cur, deliveries[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n usedD[best] = 1;\n tour.push_back(deliveries[best]);\n cur = deliveries[best];\n }\n return tour;\n}\n\n// Fast local search using relocate only\nvoid fastImprove(vector& tour, const vector& selected) {\n int n = (int)tour.size();\n vector pos(NPOINTS, -1);\n auto updatePos = [&]() {\n fill(pos.begin(), pos.end(), -1);\n for (int i = 0; i < n; ++i) pos[tour[i]] = i;\n };\n updatePos();\n\n // Build order-to-index map for selected orders\n vector selPick(50), selDel(50);\n for (int i = 0; i < (int)selected.size(); ++i) {\n selPick[i] = pickNode[selected[i]];\n selDel[i] = delvNode[selected[i]];\n }\n\n auto feasibleRelocate = [&](int node, int a, int newPos) -> bool {\n int oid = orderOf[node];\n int other = isPick[node] ? delvNode[oid] : pickNode[oid];\n int otherPos = pos[other];\n if (otherPos == -1) return true;\n\n int otherPosR = (otherPos > a) ? otherPos - 1 : otherPos;\n int b2 = (newPos > a) ? newPos - 1 : newPos;\n int finalPosNode = b2;\n int finalPosOther = otherPosR;\n if (finalPosOther >= b2) ++finalPosOther;\n\n if (isPick[node]) return finalPosNode < finalPosOther;\n return finalPosOther < finalPosNode;\n };\n\n const int WINDOW = 3;\n bool progress = true;\n while (progress) {\n progress = false;\n int bestNode = -1, bestNewPos = -1;\n long long bestDelta = 0;\n\n for (int i = 0; i < n; ++i) {\n int node = tour[i];\n int start = max(0, i - WINDOW);\n int end = min(n, i + WINDOW);\n for (int np = start; np <= end; ++np) {\n if (np == i) continue;\n if (!feasibleRelocate(node, i, np)) continue;\n\n int L = (i == 0) ? BASE : tour[i - 1];\n int R = (i == n - 1) ? BASE : tour[i + 1];\n long long delta = manhattan(L, R) - manhattan(L, node) - manhattan(node, R);\n\n int b2 = (np > i) ? np - 1 : np;\n int L2 = (b2 == 0) ? BASE : tour[idxAfterRem(b2 - 1, i)];\n int R2 = (b2 == n - 1) ? BASE : tour[idxAfterRem(b2, i)];\n delta += manhattan(L2, node) + manhattan(node, R2) - manhattan(L2, R2);\n\n if (delta < bestDelta) {\n bestDelta = delta;\n bestNode = node;\n bestNewPos = np;\n progress = true;\n }\n }\n }\n if (bestDelta < 0) {\n int a = -1;\n for (int k = 0; k < n; ++k) if (tour[k] == bestNode) { a = k; break; }\n tour.erase(tour.begin() + a);\n int b2 = (bestNewPos > a) ? bestNewPos - 1 : bestNewPos;\n tour.insert(tour.begin() + b2, bestNode);\n n = (int)tour.size();\n updatePos();\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int ORD = 1000;\n vector> orders(ORD);\n for (int i = 0; i < ORD; ++i) {\n cin >> orders[i][0] >> orders[i][1] >> orders[i][2] >> orders[i][3];\n }\n\n NPOINTS = 1 + 2 * ORD;\n X.resize(NPOINTS);\n Y.resize(NPOINTS);\n X[BASE] = 400; Y[BASE] = 400;\n for (int i = 0; i < ORD; ++i) {\n int pi = 2 * i + 1;\n int di = 2 * i + 2;\n X[pi] = orders[i][0]; Y[pi] = orders[i][1];\n X[di] = orders[i][2]; Y[di] = orders[i][3];\n pickNode[i] = pi;\n delvNode[i] = di;\n isPick[pi] = true; isPick[di] = false;\n orderOf[pi] = orderOf[di] = i;\n }\n\n vector greedyIdx(ORD);\n iota(greedyIdx.begin(), greedyIdx.end(), 0);\n vector cost(ORD);\n for (int i = 0; i < ORD; ++i) {\n cost[i] = manhattan(BASE, pickNode[i])\n + manhattan(pickNode[i], delvNode[i])\n + manhattan(delvNode[i], BASE);\n }\n sort(greedyIdx.begin(), greedyIdx.end(),\n [&](int a, int b){ return cost[a] < cost[b]; });\n\n vector bestSubset;\n vector bestTour;\n long long bestLength = (1LL<<60);\n\n auto trySubset = [&](const vector& sub) {\n vector tour = buildInitialTour(sub);\n fastImprove(tour, sub);\n long long L = tourLength(tour);\n if (L < bestLength) {\n bestLength = L;\n bestTour = tour;\n bestSubset = sub;\n }\n };\n\n // Try greedy subset\n vector firstSubset(greedyIdx.begin(), greedyIdx.begin() + 50);\n trySubset(firstSubset);\n\n // Try a few random subsets\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n int trial = 0;\n const int MAX_TRIAL = 5;\n auto start = chrono::steady_clock::now();\n while (trial < MAX_TRIAL) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > 1.7) break;\n\n vector ids(ORD);\n iota(ids.begin(), ids.end(), 0);\n shuffle(ids.begin(), ids.end(), rng);\n vector sub(ids.begin(), ids.begin() + 50);\n trySubset(sub);\n ++trial;\n }\n\n cout << 50;\n for (int x : bestSubset) cout << ' ' << (x + 1);\n cout << '\\n';\n\n cout << (int)bestTour.size() + 2;\n cout << \" 400 400\";\n for (int v : bestTour) cout << ' ' << X[v] << ' ' << Y[v];\n cout << \" 400 400\\n\";\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\n/*** Disjoint Set Union ********************************************/\nstruct DSU {\n vector parent, rank_;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n parent.resize(n);\n rank_.assign(n, 0);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int x) {\n return parent[x] == x ? x : parent[x] = find(parent[x]);\n }\n bool unite(int a, int b) {\n a = find(a);\n b = find(b);\n if (a == b) return false;\n if (rank_[a] < rank_[b]) swap(a, b);\n parent[b] = a;\n if (rank_[a] == rank_[b]) ++rank_[a];\n return true;\n }\n};\n/******************************************************************/\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int N = 400;\n const int M = 1995;\n\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) cin >> X[i] >> Y[i];\n\n vector U(M), V(M);\n for (int i = 0; i < M; ++i) cin >> U[i] >> V[i];\n\n vector d(M);\n for (int i = 0; i < M; ++i) {\n long long dx = (long long)X[U[i]] - X[V[i]];\n long long dy = (long long)Y[U[i]] - Y[V[i]];\n double dist = sqrt((double)dx * dx + (double)dy * dy);\n d[i] = (int)llround(dist);\n }\n\n vector inTree(M, 0);\n vector order(M);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b) {\n if (d[a] != d[b]) return d[a] < d[b];\n return a < b;\n });\n\n DSU dsu_mst(N);\n int taken = 0;\n for (int id : order) {\n if (dsu_mst.unite(U[id], V[id])) {\n inTree[id] = 1;\n ++taken;\n if (taken == N - 1) break;\n }\n }\n\n vector>> adj(N);\n for (int i = 0; i < M; ++i) {\n if (inTree[i]) {\n adj[U[i]].push_back({V[i], i});\n adj[V[i]].push_back({U[i], i});\n }\n }\n\n vector depth(N, 0), parent(N, -1), parentEdge(N, -1);\n function dfs = [&](int v, int p) {\n for (auto [to, eidx] : adj[v]) {\n if (to == p) continue;\n depth[to] = depth[v] + 1;\n parent[to] = v;\n parentEdge[to] = eidx;\n dfs(to, v);\n }\n };\n dfs(0, -1);\n\n auto maxOnPath = [&](int u, int v) {\n int mx = 0;\n while (depth[u] > depth[v]) {\n mx = max(mx, d[parentEdge[u]]);\n u = parent[u];\n }\n while (depth[v] > depth[u]) {\n mx = max(mx, d[parentEdge[v]]);\n v = parent[v];\n }\n while (u != v) {\n mx = max(mx, d[parentEdge[u]]);\n mx = max(mx, d[parentEdge[v]]);\n u = parent[u];\n v = parent[v];\n }\n return mx;\n };\n\n vector dmax(M);\n for (int i = 0; i < M; ++i) {\n if (inTree[i]) {\n dmax[i] = d[i];\n } else {\n dmax[i] = maxOnPath(U[i], V[i]);\n }\n }\n\n DSU dsu(N);\n for (int i = 0; i < M; ++i) {\n int L;\n cin >> L;\n\n int decision = 0;\n if (dsu.find(U[i]) != dsu.find(V[i])) {\n // Even more selective: use 1.4 instead of 1.5\n if (inTree[i] || L * 5 <= 7 * dmax[i]) { // L <= 1.4 * dmax\n decision = 1;\n dsu.unite(U[i], V[i]);\n }\n }\n cout << decision << '\\n' << flush;\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nconst int SZ = 30;\nconst int MAX_WALLS = 140;\n\nstruct Pet {\n int x, y, type;\n};\n\nstruct Human {\n int x, y;\n int hx, hy;\n int walls = 0;\n int phase = 0;\n};\n\nint sgn(int a) { return (a > 0) - (a < 0); }\n\nint dirX[4] = {-1, 1, 0, 0};\nint dirY[4] = { 0, 0,-1, 1};\nchar wCh[4] = {'u','d','l','r'};\nchar mCh[4] = {'U','D','L','R'};\n\ninline bool inside(int x, int y) { return x >= 1 && x <= SZ && y >= 1 && y <= SZ; }\n\nbool wall[SZ + 1][SZ + 1];\nbool petAt[SZ + 1][SZ + 1];\n\ninline bool passable(int x, int y) { return inside(x, y) && !wall[x][y]; }\n\nvector pets;\nvector hums;\n\nbool petOn(int x, int y) { return petAt[x][y]; }\n\nbool humanOn(int x, int y) {\n for (const Human &h : hums)\n if (h.x == x && h.y == y) return true;\n return false;\n}\n\nbool adjacentPet(int x, int y) {\n for (int d = 0; d < 4; ++d) {\n int nx = x + dirX[d], ny = y + dirY[d];\n if (inside(nx, ny) && petAt[nx][ny]) return true;\n }\n return false;\n}\n\nint countAdjacentPets(int x, int y) {\n int cnt = 0;\n for (int d = 0; d < 4; ++d) {\n int nx = x + dirX[d], ny = y + dirY[d];\n if (inside(nx, ny) && petAt[nx][ny]) ++cnt;\n }\n return cnt;\n}\n\nint distToNearestPet(int x, int y) {\n int best = 1000;\n for (const Pet &p : pets)\n best = min(best, abs(p.x - x) + abs(p.y - y));\n return best;\n}\n\nint countNearbyPets(int x, int y, int range = 3) {\n int cnt = 0;\n for (const Pet &p : pets) {\n if (abs(p.x - x) + abs(p.y - y) <= range) ++cnt;\n }\n return cnt;\n}\n\nbool canWallAt(int x, int y) {\n if (!inside(x, y)) return false;\n if (wall[x][y]) return false;\n if (petOn(x, y) || humanOn(x, y)) return false;\n if (adjacentPet(x, y)) return false;\n return true;\n}\n\nbool canMoveDir(int x, int y, int dir) {\n int nx = x + dirX[dir], ny = y + dirY[dir];\n return inside(nx, ny) && passable(nx, ny);\n}\n\nint countPassableNeighbors(int x, int y) {\n int cnt = 0;\n for (int d = 0; d < 4; ++d) {\n int nx = x + dirX[d], ny = y + dirY[d];\n if (passable(nx, ny)) ++cnt;\n }\n return cnt;\n}\n\nint countPassableNeighborsEx(int x, int y, int excludeDir) {\n int cnt = 0;\n for (int d = 0; d < 4; ++d) {\n if (d == excludeDir) continue;\n int nx = x + dirX[d], ny = y + dirY[d];\n if (passable(nx, ny)) ++cnt;\n }\n return cnt;\n}\n\nint dirIndex(int x, int y, int tx, int ty) {\n if (tx == x-1) return 0;\n if (tx == x+1) return 1;\n if (ty == y-1) return 2;\n if (ty == y+1) return 3;\n return -1;\n}\n\nbool isCorner(int x, int y) {\n return (x <= 2 || x >= SZ-1) && (y <= 2 || y >= SZ-1);\n}\n\nvoid assignZones() {\n vector> cand = {\n {1,1}, {1,SZ}, {SZ,1}, {SZ,SZ},\n {1,SZ/2}, {SZ,SZ/2}, {SZ/2,1}, {SZ/2,SZ},\n {2,2}, {2,SZ-1}, {SZ-1,2}, {SZ-1,SZ-1},\n {1,3}, {3,1}, {SZ,3}, {SZ-2,1},\n {1,SZ-2}, {3,SZ}, {SZ,SZ-2}, {SZ-2,SZ}\n };\n \n vector> used;\n \n for (size_t i = 0; i < hums.size(); ++i) {\n int bestIdx = -1;\n int bestScore = -1;\n \n for (size_t j = 0; j < cand.size(); ++j) {\n bool taken = false;\n for (auto u : used)\n if (u == cand[j]) { taken = true; break; }\n if (taken) continue;\n \n int safety = distToNearestPet(cand[j].first, cand[j].second);\n int corner = isCorner(cand[j].first, cand[j].second) ? 10 : 0;\n int score = safety + corner;\n \n if (score > bestScore) {\n bestScore = score;\n bestIdx = j;\n }\n }\n \n if (bestIdx >= 0) {\n hums[i].hx = cand[bestIdx].first;\n hums[i].hy = cand[bestIdx].second;\n used.push_back(cand[bestIdx]);\n } else {\n for (int x = 1; x <= SZ; ++x) {\n bool ok = true;\n for (auto u : used)\n if (abs(u.first - x) < 5) { ok = false; break; }\n if (ok) {\n hums[i].hx = x;\n hums[i].hy = SZ/2;\n used.push_back({x, SZ/2});\n break;\n }\n }\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n pets.resize(N);\n for (int i = 0; i < N; ++i) cin >> pets[i].x >> pets[i].y >> pets[i].type;\n\n int M;\n cin >> M;\n hums.resize(M);\n for (int i = 0; i < M; ++i) cin >> hums[i].x >> hums[i].y;\n\n for (int x = 1; x <= SZ; ++x)\n for (int y = 1; y <= SZ; ++y)\n wall[x][y] = false;\n\n for (int i = 0; i < N; ++i) petAt[pets[i].x][pets[i].y] = true;\n\n assignZones();\n\n for (int turn = 1; turn <= 300; ++turn) {\n vector actDir(M, -1);\n vector actWall(M, false);\n pair wallTargets[10];\n bool hasTarget[10] = {false};\n\n for (int i = 0; i < M; ++i) {\n Human &h = hums[i];\n \n if (h.phase == 0 && h.x == h.hx && h.y == h.hy) {\n h.phase = 1;\n }\n \n if (h.phase == 0) {\n int sx = sgn(h.hx - h.x);\n int sy = sgn(h.hy - h.y);\n \n bool moved = false;\n \n if (sx != 0) {\n for (int d = 0; d < 4; ++d) {\n if (dirX[d] == sx && dirY[d] == 0) {\n if (canMoveDir(h.x, h.y, d)) {\n actDir[i] = d;\n moved = true;\n break;\n }\n }\n }\n }\n if (!moved && sy != 0) {\n for (int d = 0; d < 4; ++d) {\n if (dirX[d] == 0 && dirY[d] == sy) {\n if (canMoveDir(h.x, h.y, d)) {\n actDir[i] = d;\n moved = true;\n break;\n }\n }\n }\n }\n \n if (!moved) {\n for (int d = 0; d < 4; ++d) {\n if (canMoveDir(h.x, h.y, d)) {\n actDir[i] = d;\n break;\n }\n }\n }\n } else {\n int distPet = distToNearestPet(h.x, h.y);\n bool inDanger = (distPet <= 1 && countAdjacentPets(h.x, h.y) > 0);\n \n if (inDanger) {\n int bestDir = -1;\n int bestDist = -1;\n for (int d = 0; d < 4; ++d) {\n if (!canMoveDir(h.x, h.y, d)) continue;\n int nx = h.x + dirX[d], ny = h.y + dirY[d];\n int newDist = distToNearestPet(nx, ny);\n if (newDist > bestDist) {\n bestDist = newDist;\n bestDir = d;\n }\n }\n if (bestDir != -1) actDir[i] = bestDir;\n } else if (h.walls < MAX_WALLS) {\n vector, int>> options;\n \n for (int d = 0; d < 4; ++d) {\n int nx = h.x + dirX[d], ny = h.y + dirY[d];\n if (!canWallAt(nx, ny)) continue;\n \n int escape = countPassableNeighborsEx(h.x, h.y, d);\n if (escape < 1) continue;\n \n int score = 0;\n score += countAdjacentPets(nx, ny) * 20;\n \n int perimeter = 0;\n for (int pd = 0; pd < 4; ++pd) {\n int px = nx + dirX[pd], py = ny + dirY[pd];\n if (inside(px, py) && wall[px][py]) ++perimeter;\n }\n score += perimeter * 8;\n \n if ((nx == 1 || nx == SZ) && (ny == 1 || ny == SZ)) score += 12;\n else if (nx == 1 || nx == SZ || ny == 1 || ny == SZ) score += 6;\n \n if (escape >= 2 && perimeter >= 2) score += 8;\n \n int distCenter = abs(nx - h.hx) + abs(ny - h.hy);\n if (distCenter <= 2) score += 5;\n \n options.push_back({{nx, ny}, score});\n }\n \n if (!options.empty()) {\n sort(options.begin(), options.end(),\n [](auto &a, auto &b) { return a.second > b.second; });\n \n actWall[i] = true;\n wallTargets[i] = options[0].first;\n hasTarget[i] = true;\n actDir[i] = dirIndex(h.x, h.y, options[0].first.first, options[0].first.second);\n ++h.walls;\n } else {\n int bestDir = -1;\n int bestDist = -1;\n for (int d = 0; d < 4; ++d) {\n if (!canMoveDir(h.x, h.y, d)) continue;\n int nx = h.x + dirX[d], ny = h.y + dirY[d];\n int newDist = distToNearestPet(nx, ny);\n if (newDist > bestDist) {\n bestDist = newDist;\n bestDir = d;\n }\n }\n if (bestDir != -1) actDir[i] = bestDir;\n }\n }\n }\n }\n\n for (int i = 0; i < M; ++i) {\n if (!actWall[i]) continue;\n for (int j = i + 1; j < M; ++j) {\n if (!actWall[j]) continue;\n if (wallTargets[i] == wallTargets[j]) {\n if (hums[i].walls > hums[j].walls) {\n actWall[j] = false;\n hasTarget[j] = false;\n int tdx = wallTargets[i].first - hums[j].x;\n int tdy = wallTargets[i].second - hums[j].y;\n for (int d = 0; d < 4; ++d) {\n if (dirX[d] == -sgn(tdx) && dirY[d] == -sgn(tdy)) {\n if (canMoveDir(hums[j].x, hums[j].y, d)) {\n actDir[j] = d;\n break;\n }\n }\n }\n } else {\n actWall[i] = false;\n hasTarget[i] = false;\n }\n }\n }\n }\n\n bool willWall[SZ + 1][SZ + 1] = {false};\n bool willMove[SZ + 1][SZ + 1] = {false};\n\n for (int i = 0; i < M; ++i) {\n if (actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (inside(nx, ny)) willWall[nx][ny] = true;\n }\n if (actDir[i] != -1 && !actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (inside(nx, ny)) willMove[nx][ny] = true;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n if (actDir[i] != -1 && !actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (willWall[nx][ny]) {\n actDir[i] = -1;\n willMove[nx][ny] = false;\n }\n }\n if (actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (willMove[nx][ny]) {\n actWall[i] = false;\n actDir[i] = -1;\n }\n }\n }\n\n string out;\n out.reserve(M);\n for (int i = 0; i < M; ++i) {\n if (actDir[i] == -1) out.push_back('.');\n else if (actWall[i]) out.push_back(wCh[actDir[i]]);\n else out.push_back(mCh[actDir[i]]);\n }\n cout << out << '\\n' << flush;\n\n for (int i = 0; i < M; ++i) {\n if (actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (inside(nx, ny) && !wall[nx][ny]) wall[nx][ny] = true;\n } else if (actDir[i] != -1) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (inside(nx, ny) && passable(nx, ny)) {\n hums[i].x = nx;\n hums[i].y = ny;\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (char c : s) {\n int dir = -1;\n if (c == 'U') dir = 0;\n else if (c == 'D') dir = 1;\n else if (c == 'L') dir = 2;\n else if (c == 'R') dir = 3;\n else continue;\n int nx = pets[i].x + dirX[dir];\n int ny = pets[i].y + dirY[dir];\n if (inside(nx, ny) && passable(nx, ny)) {\n pets[i].x = nx;\n pets[i].y = ny;\n }\n }\n }\n\n for (int x = 1; x <= SZ; ++x)\n for (int y = 1; y <= SZ; ++y)\n petAt[x][y] = false;\n for (const Pet &p : pets) petAt[p.x][p.y] = true;\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int si, sj, ti, tj;\n double p;\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n const int N = 20;\n vector h(N); // horizontal walls, size 20 \u00d7 19\n for (int i = 0; i < N; ++i) cin >> h[i];\n vector v(N - 1); // vertical walls, size 19 \u00d7 20\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n\n // directions: 0=U, 1=D, 2=L, 3=R\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dch[4] = {'U', 'D', 'L', 'R'};\n\n auto can_move = [&](int i, int j, int dir) -> bool {\n if (dir == 0) { // up\n if (i == 0) return false;\n return v[i - 1][j] == '0';\n } else if (dir == 1) { // down\n if (i == N - 1) return false;\n return v[i][j] == '0';\n } else if (dir == 2) { // left\n if (j == 0) return false;\n return h[i][j - 1] == '0';\n } else { // right\n if (j == N - 1) return false;\n return h[i][j] == '0';\n }\n };\n\n // BFS\n vector> dist(N, vector(N, -1));\n vector>> prev(N, vector>(N, {-1,-1}));\n vector> pred_dir(N, vector(N, 0));\n\n queue> q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break; // reached destination\n for (int dir = 0; dir < 4; ++dir) {\n if (!can_move(i, j, dir)) continue;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (dist[ni][nj] != -1) continue;\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n pred_dir[ni][nj] = dch[dir];\n q.emplace(ni, nj);\n }\n }\n\n // reconstruct shortest path\n string path;\n int ci = ti, cj = tj;\n while (!(ci == si && cj == sj)) {\n path.push_back(pred_dir[ci][cj]);\n auto pr = prev[ci][cj];\n ci = pr.first; cj = pr.second;\n }\n reverse(path.begin(), path.end());\n\n int d = (int)path.size();\n string ans;\n\n if (d == 0) { // start equals office\n cout << \"\\n\";\n return 0;\n }\n\n if (d <= 200) {\n ans.reserve(200);\n for (int i = 0; i < 200; ++i) ans.push_back(path[i % d]);\n } else { // distance larger than 200 \u2192 impossible to succeed\n ans = path.substr(0, 200); // any 200 characters are fine\n }\n\n cout << ans << '\\n';\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30, W = 30, N = H * W;\n\n/* directions: 0 left, 1 up, 2 right, 3 down */\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\ninline int neighbor_id(int idx, int dir) {\n int i = idx / W, j = idx % W;\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) return -1;\n return ni * W + nj;\n}\n\n/* --------------------------------------------------------------- */\n/* pre\u2011computed neighbour lists for every tile and every rotation */\nvector>> neigh;\n\n/* --------------------------------------------------------------- */\nvector> adj;\n\n/* ----- component handling -------------------------------------- */\nvector compId;\nvector> compNodes;\nvector compEdge;\n\nstruct Cmp {\n bool operator()(const pair& a, const pair& b) const {\n if (a.first != b.first) return a.first < b.first;\n return a.second < b.second;\n }\n};\nmultiset, Cmp> compSet;\n\n/* --------------------------------------------------------------- */\ninline int get_score() {\n if (compSet.empty()) return 0;\n auto it = compSet.begin();\n int L1 = -it->first;\n ++it;\n int L2 = (it == compSet.end()) ? 0 : -it->first;\n return L1 * L2;\n}\n\n/* --------------------------------------------------------------- */\ninline void addAdj(int u, int v) {\n adj[u].push_back(v);\n adj[v].push_back(u);\n}\n\n/* --------------------------------------------------------------- */\nvoid addEdge(int u, int v) {\n for (int nb : adj[u]) if (nb == v) return;\n adj[u].push_back(v);\n adj[v].push_back(u);\n\n int cu = compId[u];\n int cv = compId[v];\n if (cu == cv) {\n int oldc = compEdge[cu];\n compEdge[cu] = oldc + 1;\n compSet.erase({-oldc, cu});\n compSet.insert({-(oldc + 1), cu});\n } else {\n int oldcU = compEdge[cu];\n int oldcV = compEdge[cv];\n compSet.erase({-oldcU, cu});\n compSet.erase({-oldcV, cv});\n\n int target = (compNodes[cu].size() >= compNodes[cv].size()) ? cu : cv;\n int source = (target == cu) ? cv : cu;\n\n int newc = oldcU + oldcV + 1;\n for (int node : compNodes[source]) {\n compId[node] = target;\n compNodes[target].push_back(node);\n }\n compNodes[source].clear();\n compEdge[target] = newc;\n compSet.insert({-newc, target});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid removeEdge(int u, int v) {\n auto &vecU = adj[u];\n for (size_t i = 0; i < vecU.size(); ++i) {\n if (vecU[i] == v) { vecU[i] = vecU.back(); vecU.pop_back(); break; }\n }\n auto &vecV = adj[v];\n for (size_t i = 0; i < vecV.size(); ++i) {\n if (vecV[i] == u) { vecV[i] = vecV.back(); vecV.pop_back(); break; }\n }\n\n int cid = compId[u];\n int oldc = compEdge[cid];\n compSet.erase({-oldc, cid});\n\n vector vis(N, 0);\n vector partA;\n queue q;\n q.push(u); vis[u] = 1;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n partA.push_back(x);\n for (int nb : adj[x]) if (!vis[nb]) { vis[nb] = 1; q.push(nb); }\n }\n\n if (!vis[v]) {\n vector partB;\n for (int node : compNodes[cid]) if (!vis[node]) partB.push_back(node);\n \n long long sA = 0, sB = 0;\n for (int n : partA) sA += adj[n].size();\n for (int n : partB) sB += adj[n].size();\n int cntA = int(sA / 2), cntB = int(sB / 2);\n \n compNodes[cid] = partA;\n int newId = (int)compNodes.size();\n compNodes.push_back(partB);\n compEdge.push_back(cntB);\n for (int n : partB) compId[n] = newId;\n \n compSet.insert({-cntA, cid});\n compSet.insert({-cntB, newId});\n } else {\n compEdge[cid] = oldc - 1;\n compSet.insert({-(oldc - 1), cid});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid build_components() {\n compId.assign(N, -1);\n compNodes.clear();\n compEdge.clear();\n compSet.clear();\n\n vector vis(N, 0);\n for (int v = 0; v < N; ++v) if (!vis[v]) {\n vector nodes;\n queue q;\n q.push(v); vis[v] = 1;\n long long sumDeg = 0;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n nodes.push_back(x);\n sumDeg += adj[x].size();\n for (int nb : adj[x]) if (!vis[nb]) { vis[nb] = 1; q.push(nb); }\n }\n int cid = (int)compNodes.size();\n compNodes.push_back(nodes);\n compEdge.push_back(int(sumDeg / 2));\n for (int n : nodes) compId[n] = cid;\n compSet.insert({-compEdge[cid], cid});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid init_adj(const vector& rot) {\n adj.assign(N, vector());\n for (int idx = 0; idx < N; ++idx) {\n int r = rot[idx];\n for (int nb : neigh[idx][r]) {\n if (nb != -1) addAdj(idx, nb);\n }\n }\n}\n\n/* --------------------------------------------------------------- */\nint apply_move(int idx, int new_rot, vector& rot) {\n int old_rot = rot[idx];\n if (old_rot == new_rot) return get_score();\n\n const vector& old_nb = neigh[idx][old_rot];\n const vector& new_nb = neigh[idx][new_rot];\n\n for (int nb : old_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : new_nb) if (x == nb) { exists = true; break; }\n if (!exists) removeEdge(idx, nb);\n }\n for (int nb : new_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : old_nb) if (x == nb) { exists = true; break; }\n if (!exists) addEdge(idx, nb);\n }\n\n rot[idx] = new_rot;\n return get_score();\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector type(N);\n for (int i = 0; i < H; ++i) {\n string line;\n cin >> line;\n for (int j = 0; j < W; ++j) {\n type[i * W + j] = line[j] - '0';\n }\n }\n\n const vector> base[8] = {\n {{0,1}}, {{0,3}}, {{2,3}}, {{1,2}},\n {{0,1},{2,3}}, {{0,3},{1,2}},\n {{0,2}}, {{1,3}}\n };\n\n neigh.assign(N, vector>(4));\n for (int idx = 0; idx < N; ++idx) {\n int t = type[idx];\n for (int r = 0; r < 4; ++r) {\n vector cur;\n for (auto [a,b] : base[t]) {\n int s1 = (a + 3 * r) % 4;\n int s2 = (b + 3 * r) % 4;\n int nb1 = neighbor_id(idx, s1);\n int nb2 = neighbor_id(idx, s2);\n cur.push_back(nb1);\n cur.push_back(nb2);\n }\n neigh[idx][r] = cur;\n }\n }\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n\n int best_score = 0;\n vector answer_rot(N);\n\n const int RESTARTS = 12;\n const int STEPS = 3000;\n\n for (int trial = 0; trial < RESTARTS; ++trial) {\n vector cur_rot(N);\n \n // Strategy based on trial\n int strategy = trial % 5;\n \n if (strategy == 0) {\n // Maximize edges (greedy)\n for (int idx = 0; idx < N; ++idx) {\n int best = 0, bestCnt = -1;\n for (int r = 0; r < 4; ++r) {\n int cnt = 0;\n for (int nb : neigh[idx][r]) if (nb != -1) ++cnt;\n if (cnt > bestCnt) { bestCnt = cnt; best = r; }\n }\n cur_rot[idx] = best;\n }\n } else if (strategy == 1) {\n // Prefer straight lines (types 6,7) to be vertical/horizontal\n for (int idx = 0; idx < N; ++idx) {\n int t = type[idx];\n if (t == 6) cur_rot[idx] = (rng() % 2 == 0) ? 0 : 2;\n else if (t == 7) cur_rot[idx] = (rng() % 2 == 0) ? 1 : 3;\n else cur_rot[idx] = rng() % 4;\n }\n } else if (strategy == 2) {\n // Zigzag pattern for corners\n for (int idx = 0; idx < N; ++idx) {\n int i = idx / W, j = idx % W;\n int t = type[idx];\n if (t <= 3) {\n cur_rot[idx] = ((i + j) % 2 == 0) ? 0 : 1;\n } else {\n cur_rot[idx] = rng() % 4;\n }\n }\n } else if (strategy == 3) {\n // Try to align corners horizontally\n for (int idx = 0; idx < N; ++idx) {\n int i = idx / W, j = idx % W;\n int t = type[idx];\n if (t == 0) cur_rot[idx] = (j % 2 == 0) ? 0 : 3;\n else if (t == 1) cur_rot[idx] = (j % 2 == 0) ? 0 : 1;\n else if (t == 2) cur_rot[idx] = (j % 2 == 0) ? 1 : 2;\n else if (t == 3) cur_rot[idx] = (j % 2 == 0) ? 2 : 3;\n else cur_rot[idx] = rng() % 4;\n }\n } else {\n // Random\n for (int idx = 0; idx < N; ++idx) {\n cur_rot[idx] = rng() % 4;\n }\n }\n \n // Random perturbations\n int perturb = 150 + trial * 30;\n for (int i = 0; i < perturb; ++i) {\n cur_rot[rng() % N] = rng() % 4;\n }\n\n init_adj(cur_rot);\n build_components();\n int cur_score = get_score();\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n\n // Fast hill climbing with targeted moves\n for (int step = 0; step < STEPS; ++step) {\n // Select cell: mostly random, occasionally from largest components\n int idx;\n if (step % 7 == 0 && !compSet.empty()) {\n auto it = compSet.begin();\n int cid = it->second;\n if (!compNodes[cid].empty()) {\n idx = compNodes[cid][rng() % compNodes[cid].size()];\n } else {\n idx = rng() % N;\n }\n } else {\n idx = rng() % N;\n }\n \n int old_r = cur_rot[idx];\n int best_rot_here = old_r;\n int best_score_here = cur_score;\n \n // Try all rotations\n for (int cand = 0; cand < 4; ++cand) {\n if (cand == old_r) continue;\n int new_score = apply_move(idx, cand, cur_rot);\n if (new_score > best_score_here) {\n best_score_here = new_score;\n best_rot_here = cand;\n } else {\n apply_move(idx, old_r, cur_rot);\n }\n }\n \n if (best_rot_here != old_r) {\n cur_score = best_score_here;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n }\n \n // Periodic targeted moves: try cells at component boundaries\n if (step % 100 == 0 && !compSet.empty()) {\n // Get top 2 components\n vector topCids;\n for (auto it = compSet.begin(); it != compSet.end() && topCids.size() < 2; ++it) {\n topCids.push_back(it->second);\n }\n \n // Find boundary cells between top components\n if (topCids.size() >= 2) {\n vector boundary;\n for (int v : compNodes[topCids[0]]) {\n for (int nb : adj[v]) {\n if (compId[nb] == topCids[1]) {\n boundary.push_back(v);\n break;\n }\n }\n }\n \n // Also check reverse\n for (int v : compNodes[topCids[1]]) {\n for (int nb : adj[v]) {\n if (compId[nb] == topCids[0]) {\n boundary.push_back(v);\n break;\n }\n }\n }\n \n // Try all boundary cells\n for (int b : boundary) {\n int old = cur_rot[b];\n for (int r = 0; r < 4; ++r) {\n if (r == old) continue;\n int sc = apply_move(b, r, cur_rot);\n if (sc > cur_score) {\n cur_score = sc;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n break;\n } else {\n apply_move(b, old, cur_rot);\n }\n }\n }\n }\n }\n }\n \n // If score is still low, try a few more aggressive merges\n if (cur_score < 30) {\n for (int attempt = 0; attempt < 500; ++attempt) {\n int idx = rng() % N;\n int old_r = cur_rot[idx];\n int best_rot_here = old_r;\n int best_score_here = cur_score;\n \n for (int cand = 0; cand < 4; ++cand) {\n if (cand == old_r) continue;\n int new_score = apply_move(idx, cand, cur_rot);\n if (new_score > best_score_here) {\n best_score_here = new_score;\n best_rot_here = cand;\n } else {\n apply_move(idx, old_r, cur_rot);\n }\n }\n \n if (best_rot_here != old_r) {\n cur_score = best_score_here;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n }\n }\n }\n }\n\n string out;\n out.reserve(N);\n for (int i = 0; i < N; ++i) out.push_back(char('0' + answer_rot[i]));\n cout << out << '\\n';\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nconst int BIT_LEFT = 1;\nconst int BIT_UP = 2;\nconst int BIT_RIGHT = 4;\nconst int BIT_DOWN = 8;\n\nconst int DI[4] = {-1, 1, 0, 0};\nconst int DJ[4] = {0, 0, -1, 1};\n\nint sgn(int x) { return (x > 0) - (x < 0); }\n\nstruct HopcroftKarp {\n int nL, nR;\n vector> adj;\n vector dist, pairL, pairR;\n \n HopcroftKarp(int L, int R) : nL(L), nR(R) {\n adj.assign(nL, {});\n pairL.assign(nL, -1);\n pairR.assign(nR, -1);\n dist.resize(nL);\n }\n void addEdge(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 (pairL[u] == -1) {\n dist[u] = 0;\n q.push(u);\n } else dist[u] = -1;\n }\n bool found = false;\n while (!q.empty()) {\n int u = q.front(); q.pop();\n for (int v : adj[u]) {\n int u2 = pairR[v];\n if (u2 != -1 && dist[u2] == -1) {\n dist[u2] = dist[u] + 1;\n q.push(u2);\n }\n if (u2 == -1) found = true;\n }\n }\n return found;\n }\n bool dfs(int u) {\n for (int v : adj[u]) {\n int u2 = pairR[v];\n if (u2 == -1 || (dist[u2] == dist[u] + 1 && dfs(u2))) {\n pairL[u] = v;\n pairR[v] = u;\n return true;\n }\n }\n dist[u] = -1;\n return false;\n }\n \n int maxMatching() {\n int matching = 0;\n while (bfs()) {\n for (int u = 0; u < nL; ++u)\n if (pairL[u] == -1 && dfs(u))\n ++matching;\n }\n return matching;\n }\n};\n\n// Generate tree using DFS from random start\nvoid generateTreeDFS(int N, const vector>& board,\n vector,pair>>& edges,\n vector>& visited,\n mt19937& rng) {\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n visited[i][j] = false;\n edges.clear();\n \n // Find all non-empty cells and pick random start\n vector> cells;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1)\n cells.push_back({i,j});\n if (cells.empty()) return;\n \n shuffle(cells.begin(), cells.end(), rng);\n auto [sr, sc] = cells[0];\n \n stack> st;\n st.emplace(sr, sc);\n visited[sr][sc] = true;\n \n while (!st.empty()) {\n auto [r, c] = st.top(); st.pop();\n array dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int nr = r + DI[d];\n int nc = c + DJ[d];\n if (nr<0||nr>=N||nc<0||nc>=N) continue;\n if (board[nr][nc]==-1) continue;\n if (visited[nr][nc]) continue;\n visited[nr][nc] = true;\n st.emplace(nr, nc);\n edges.push_back({{r,c},{nr,nc}});\n }\n }\n}\n\n// Generate tree using Prim's algorithm\nvoid generateTreePrim(int N, const vector>& board,\n vector,pair>>& edges,\n vector>& visited,\n mt19937& rng) {\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n visited[i][j] = false;\n edges.clear();\n \n vector> cells;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1)\n cells.push_back({i,j});\n if (cells.empty()) return;\n \n shuffle(cells.begin(), cells.end(), rng);\n auto [sr, sc] = cells[0];\n \n visited[sr][sc] = true;\n vector> candidates;\n \n auto addNeighbors = [&](int r, int c) {\n array dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int nr = r + DI[d];\n int nc = c + DJ[d];\n if (nr<0||nr>=N||nc<0||nc>=N) continue;\n if (board[nr][nc]==-1) continue;\n if (visited[nr][nc]) continue;\n candidates.emplace_back(r, c, nr, nc);\n }\n };\n \n addNeighbors(sr, sc);\n \n while (!candidates.empty()) {\n int idx = uniform_int_distribution(0, (int)candidates.size()-1)(rng);\n auto [r1, c1, r2, c2] = candidates[idx];\n candidates[idx] = candidates.back();\n candidates.pop_back();\n \n if (visited[r2][c2]) continue;\n \n visited[r2][c2] = true;\n edges.push_back({{r1,c1},{r2,c2}});\n addNeighbors(r2, c2);\n }\n}\n\n// Generate tree using randomized Kruskal\nvoid generateTreeKruskal(int N, const vector>& board,\n vector,pair>>& edges,\n mt19937& rng) {\n edges.clear();\n vector> cells;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1)\n cells.push_back({i,j});\n int V = cells.size();\n \n unordered_map idx;\n for (int i = 0; i < V; ++i) {\n long long key = ((long long)cells[i].first << 32) | cells[i].second;\n idx[key] = i;\n }\n \n vector parent(V);\n iota(parent.begin(), parent.end(), 0);\n function find = [&](int x) {\n return parent[x] == x ? x : parent[x] = find(parent[x]);\n };\n \n vector> allEdges;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j]==-1) continue;\n if (i+1 < N && board[i+1][j]!=-1) {\n allEdges.push_back({i,j,i+1,j});\n }\n if (j+1 < N && board[i][j+1]!=-1) {\n allEdges.push_back({i,j,i,j+1});\n }\n }\n }\n shuffle(allEdges.begin(), allEdges.end(), rng);\n \n for (auto& e : allEdges) {\n int r1,c1,r2,c2;\n tie(r1,c1,r2,c2) = e;\n long long key1 = ((long long)r1 << 32) | c1;\n long long key2 = ((long long)r2 << 32) | c2;\n int id1 = idx[key1];\n int id2 = idx[key2];\n if (find(id1) != find(id2)) {\n parent[find(id1)] = find(id2);\n edges.push_back({{r1,c1},{r2,c2}});\n }\n if ((int)edges.size() == V-1) break;\n }\n}\n\n// Generate snake-like tree (deterministic but good properties)\nvoid generateTreeSnake(int N, const vector>& board,\n vector,pair>>& edges,\n vector>& visited) {\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n visited[i][j] = false;\n edges.clear();\n \n vector> cells;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1)\n cells.push_back({i,j});\n if (cells.empty()) return;\n \n // Sort cells in snake order\n sort(cells.begin(), cells.end(), [](const auto& a, const auto& b) {\n if (a.first != b.first) return a.first < b.first;\n if (a.first % 2 == 0) return a.second < b.second;\n else return a.second > b.second;\n });\n \n // Build tree by connecting consecutive cells\n for (size_t i = 1; i < cells.size(); ++i) {\n edges.push_back({cells[i-1], cells[i]});\n visited[cells[i-1].first][cells[i-1].second] = true;\n visited[cells[i].first][cells[i].second] = true;\n }\n}\n\nint estimateMoves(int M, const vector>& tilePos,\n const vector>& targetPos) {\n long long total = 0;\n for (int i = 0; i < M; ++i) {\n total += abs(tilePos[i].first - targetPos[i].first);\n total += abs(tilePos[i].second - targetPos[i].second);\n }\n return (int)min(2 * total, INT_MAX);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n if (!(cin >> N >> T)) return 0;\n vector raw(N);\n for (int i = 0; i < N; ++i) cin >> raw[i];\n\n int M = N * N - 1;\n vector tileMask(M);\n vector> tilePos(M);\n vector> board(N, vector(N, -1));\n vector> cellIndex(N, vector(N, -1));\n vector> cellCoord;\n pair emptyPos;\n int tileId = 0;\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c = raw[i][j];\n int mask = (c >= '0' && c <= '9') ? (c - '0') : (10 + c - 'a');\n if (mask == 0) {\n emptyPos = {i, j};\n board[i][j] = -1;\n } else {\n board[i][j] = tileId;\n tileMask[tileId] = mask;\n tilePos[tileId] = {i, j};\n cellIndex[i][j] = tileId;\n cellCoord.push_back({i, j});\n ++tileId;\n }\n }\n }\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n \n const int MAX_TRIES = 12000;\n bool ok = false;\n vector> visited(N, vector(N, false));\n \n // Track best solution by movement cost\n long long bestMovementCost = LLONG_MAX;\n vector> bestTarget(M);\n \n for (int attempt = 0; attempt < MAX_TRIES && !ok; ++attempt) {\n vector,pair>> edges;\n \n int method = attempt % 5;\n if (method == 0) {\n generateTreeDFS(N, board, edges, visited, rng);\n } else if (method == 1) {\n generateTreePrim(N, board, edges, visited, rng);\n } else if (method == 2) {\n generateTreeKruskal(N, board, edges, rng);\n } else if (method == 3) {\n generateTreePrim(N, board, edges, visited, rng);\n } else {\n generateTreeKruskal(N, board, edges, rng);\n }\n \n int cnt = 0;\n for (int i=0;i> reqMask(N, vector(N, 0));\n for (auto &e : edges) {\n int r1=e.first.first, c1=e.first.second;\n int r2=e.second.first, c2=e.second.second;\n int dr=r2-r1, dc=c2-c1;\n if (dr==1) { reqMask[r1][c1]|=BIT_DOWN; reqMask[r2][c2]|=BIT_UP; }\n else if (dr==-1) { reqMask[r1][c1]|=BIT_UP; reqMask[r2][c2]|=BIT_DOWN; }\n else if (dc==1) { reqMask[r1][c1]|=BIT_RIGHT; reqMask[r2][c2]|=BIT_LEFT; }\n else { reqMask[r1][c1]|=BIT_LEFT; reqMask[r2][c2]|=BIT_RIGHT; }\n }\n \n vector requiredMask(M);\n for (int i=0;i> fullTarget(M);\n for (int cid = 0; cid < M; ++cid) {\n int tid = hk.pairL[cid];\n fullTarget[tid] = cellCoord[cid];\n }\n \n // Calculate movement cost\n long long cost = 0;\n for (int i = 0; i < M; ++i) {\n cost += abs(tilePos[i].first - fullTarget[i].first);\n cost += abs(tilePos[i].second - fullTarget[i].second);\n }\n \n if (estimateMoves(M, tilePos, fullTarget) <= T) {\n if (cost < bestMovementCost) {\n bestMovementCost = cost;\n bestTarget = fullTarget;\n }\n ok = true;\n break;\n }\n }\n }\n\n // If no perfect solution, find partial solution\n if (!ok) {\n // Already have bestMovementCost = LLONG_MAX, bestTarget initialized\n // Try to find best partial solution\n for (int attempt = 0; attempt < 5000; ++attempt) {\n vector,pair>> edges;\n \n if (attempt % 3 == 0) {\n generateTreeDFS(N, board, edges, visited, rng);\n } else if (attempt % 3 == 1) {\n generateTreePrim(N, board, edges, visited, rng);\n } else {\n generateTreeKruskal(N, board, edges, rng);\n }\n \n int cnt = 0;\n for (int i=0;i> reqMask(N, vector(N, 0));\n for (auto &e : edges) {\n int r1=e.first.first, c1=e.first.second;\n int r2=e.second.first, c2=e.second.second;\n int dr=r2-r1, dc=c2-c1;\n if (dr==1) { reqMask[r1][c1]|=BIT_DOWN; reqMask[r2][c2]|=BIT_UP; }\n else if (dr==-1) { reqMask[r1][c1]|=BIT_UP; reqMask[r2][c2]|=BIT_DOWN; }\n else if (dc==1) { reqMask[r1][c1]|=BIT_RIGHT; reqMask[r2][c2]|=BIT_LEFT; }\n else { reqMask[r1][c1]|=BIT_LEFT; reqMask[r2][c2]|=BIT_RIGHT; }\n }\n \n vector requiredMask(M);\n for (int i=0;i 0) {\n vector> partialTarget(M);\n for (int t = 0; t < M; ++t) partialTarget[t] = tilePos[t];\n \n for (int cid = 0; cid < M; ++cid) {\n int tid = hk.pairL[cid];\n if (tid != -1) {\n partialTarget[tid] = cellCoord[cid];\n }\n }\n \n long long cost = 0;\n for (int i = 0; i < M; ++i) {\n cost += abs(tilePos[i].first - partialTarget[i].first);\n cost += abs(tilePos[i].second - partialTarget[i].second);\n }\n \n if (cost < bestMovementCost && estimateMoves(M, tilePos, partialTarget) <= T) {\n bestMovementCost = cost;\n bestTarget = partialTarget;\n ok = true;\n }\n }\n }\n }\n\n // Use best solution found\n vector> targetPos = bestTarget;\n\n // Moving phase\n vector moves;\n moves.reserve(T);\n \n auto applyMove = [&](char dir) {\n if ((int)moves.size() >= T) return false;\n int ex = emptyPos.first, ey = emptyPos.second;\n int nx = ex, ny = ey;\n if (dir == 'U') nx--;\n else if (dir == 'D') nx++;\n else if (dir == 'L') ny--;\n else if (dir == 'R') ny++;\n int tile = board[nx][ny];\n board[ex][ey] = tile;\n board[nx][ny] = -1;\n if (tile != -1) tilePos[tile] = {nx, ny};\n emptyPos = {nx, ny};\n moves.push_back(dir);\n return true;\n };\n \n auto moveEmptyTo = [&](int tr, int tc) {\n while (emptyPos.first > tr) { if (!applyMove('U')) return false; }\n while (emptyPos.first < tr) { if (!applyMove('D')) return false; }\n while (emptyPos.second > tc) { if (!applyMove('L')) return false; }\n while (emptyPos.second < tc) { if (!applyMove('R')) return false; }\n return true;\n };\n \n while ((int)moves.size() < T) {\n bool all_done = true;\n for (int t = 0; t < M; ++t) {\n if (tilePos[t] != targetPos[t]) {\n all_done = false;\n break;\n }\n }\n if (all_done) break;\n \n int bestTile = -1;\n int bestCost = INT_MAX;\n int needX = -1, needY = -1;\n int stepX = 0, stepY = 0;\n \n for (int t = 0; t < M; ++t) {\n auto cur = tilePos[t];\n auto tgt = targetPos[t];\n if (cur == tgt) continue;\n \n int dx = tgt.first - cur.first;\n int dy = tgt.second - cur.second;\n \n if (dx != 0) {\n int step = sgn(dx);\n int nx = cur.first + step;\n int ny = cur.second;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = t;\n needX = nx; needY = ny;\n stepX = step; stepY = 0;\n }\n }\n if (dy != 0) {\n int step = sgn(dy);\n int nx = cur.first;\n int ny = cur.second + step;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = t;\n needX = nx; needY = ny;\n stepX = 0; stepY = step;\n }\n }\n }\n \n if (bestTile == -1) break;\n \n if (!moveEmptyTo(needX, needY)) break;\n \n char cmd = (stepX != 0) ? ((stepX == -1) ? 'D' : 'U')\n : ((stepY == -1) ? 'R' : 'L');\n if (!applyMove(cmd)) break;\n tilePos[bestTile].first += stepX;\n tilePos[bestTile].second += stepY;\n }\n \n cout << string(moves.begin(), moves.end()) << \"\\n\";\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\n\nconst int64 R = 10000; // radius of the cake\n\n/* --------------------------------------------------------------- */\nstruct Point {\n int64 x, y;\n};\n\nstruct Line {\n Point p1, p2; // two integer points on the line\n int64 dx, dy; // p2 - p1\n};\n\n/* create a line from two points, but only if the points are different */\nbool try_make_line(int64 x1, int64 y1, int64 x2, int64 y2, Line& L) {\n if (x1 == x2 && y1 == y2) return false;\n L.p1 = {x1, y1};\n L.p2 = {x2, y2};\n L.dx = x2 - x1;\n L.dy = y2 - y1;\n return true;\n}\n\n/* create a unique hash key for a line (for duplicate detection) */\nuint64_t line_key(const Line& L) {\n // Normalize the direction\n int64 g = std::gcd(std::abs(L.dx), std::abs(L.dy));\n int64 ndx = L.dx / g;\n int64 ndy = L.dy / g;\n \n // Use cross product with a fixed point to get the offset\n int64 offset = L.dx * (-L.p1.y) - L.dy * (-L.p1.x);\n \n // Combine into a hash\n uint64_t h1 = (uint64_t)(ndx + 20000) * 40001ULL + (uint64_t)(ndy + 20000);\n uint64_t h2 = (uint64_t)(offset + 4e8);\n return h1 * 1000003ULL + h2;\n}\n\n/* --------------------------------------------------------------- */\n/* evaluate a set of lines, return \u03a3 min(ad, bd) */\nint evaluate(const vector& lines,\n const vector& pts,\n const array& a)\n{\n int n = pts.size();\n int m = lines.size();\n \n vector hashes(n);\n for (int i = 0; i < n; ++i) {\n uint64_t h = 0;\n for (const auto& L : lines) {\n int side = (L.dx * (pts[i].y - L.p1.y) - L.dy * (pts[i].x - L.p1.x) > 0);\n h = h * 2 + side;\n }\n hashes[i] = h;\n }\n \n sort(hashes.begin(), hashes.end());\n \n int b[11] = {0};\n int i = 0;\n while (i < n) {\n int j = i + 1;\n while (j < n && hashes[j] == hashes[i]) ++j;\n int cnt = j - i;\n if (1 <= cnt && cnt <= 10) ++b[cnt];\n i = j;\n }\n \n int sumMin = 0;\n for (int d = 1; d <= 10; ++d) sumMin += min(a[d], b[d]);\n return sumMin;\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n if (!(cin >> N >> K)) return 0;\n array a{};\n for (int d = 1; d <= 10; ++d) cin >> a[d];\n vector pts(N);\n for (int i = 0; i < N; ++i) cin >> pts[i].x >> pts[i].y;\n\n mt19937_64 rng(random_device{}());\n\n vector bestLines;\n int bestScore = -1;\n int totalA = 0;\n for (int d = 1; d <= 10; ++d) totalA += a[d];\n\n uniform_int_distribution distSmall(-R + 1, R - 1);\n uniform_int_distribution distLarge(-2 * R, 2 * R);\n uniform_int_distribution distXLarge(-3 * R, 3 * R);\n\n /* ================================================================\n Strategy 1: Pure random lines - focus on diversity\n ================================================================ */\n const int MAX_TRIES_RANDOM = 350;\n for (int iter = 0; iter < MAX_TRIES_RANDOM; ++iter) {\n int k = uniform_int_distribution(max(30, K/2), K)(rng);\n \n vector cur;\n cur.reserve(k);\n unordered_set usedKeys;\n \n for (int i = 0; i < k; ++i) {\n int64 x1, y1, x2, y2;\n int coordType = rng() % 3;\n \n if (coordType == 0) {\n x1 = distSmall(rng);\n y1 = distSmall(rng);\n x2 = distSmall(rng);\n y2 = distSmall(rng);\n } else if (coordType == 1) {\n x1 = distLarge(rng);\n y1 = distLarge(rng);\n x2 = distLarge(rng);\n y2 = distLarge(rng);\n } else {\n x1 = distXLarge(rng);\n y1 = distXLarge(rng);\n x2 = distXLarge(rng);\n y2 = distXLarge(rng);\n }\n \n if (x1 == x2 && y1 == y2) continue;\n \n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (const auto& p : pts) {\n int64 cross = dx * (p.y - y1) - dy * (p.x - x1);\n if (cross == 0) {\n ok = false;\n break;\n }\n }\n if (!ok) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n \n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n\n /* ================================================================\n Strategy 2: Grid-based lines with varied spacings\n ================================================================ */\n vector spacings = {300, 400, 500, 600, 800, 1000, 1200, 1500, 2000};\n for (int spacing : spacings) {\n for (int offset = 0; offset < spacing; offset += max(1, spacing/2)) {\n vector cur;\n cur.reserve(K);\n unordered_set usedKeys;\n \n // Vertical lines\n for (int64 x = -R + offset; x < R && (int)cur.size() < K; x += spacing) {\n Line L;\n if (!try_make_line(x, -R, x, R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Horizontal lines\n for (int64 y = -R + offset; y < R && (int)cur.size() < K; y += spacing) {\n Line L;\n if (!try_make_line(-R, y, R, y, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Diagonal lines (x+y=c)\n for (int64 d = -2*R; d <= 2*R && (int)cur.size() < K; d += spacing) {\n int64 x1 = -R;\n int64 y1 = d - x1;\n int64 x2 = -R + spacing/2;\n int64 y2 = d - x2;\n \n if (y1 < -R || y1 > R || y2 < -R || y2 > R) continue;\n if (y1 == y2) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Diagonal lines (x-y=c)\n for (int64 d = -2*R; d <= 2*R && (int)cur.size() < K; d += spacing) {\n int64 x1 = -R;\n int64 y1 = x1 - d;\n int64 x2 = -R + spacing/2;\n int64 y2 = x2 - d;\n \n if (y1 < -R || y1 > R || y2 < -R || y2 > R) continue;\n if (y1 == y2) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n if (bestScore == totalA) break;\n }\n\n /* ================================================================\n Strategy 3: Random grids with flexible type distribution\n ================================================================ */\n const int MAX_TRIES_GRID = 200;\n for (int iter = 0; iter < MAX_TRIES_GRID; ++iter) {\n int k = uniform_int_distribution(max(30, K/2), K)(rng);\n \n vector cur;\n cur.reserve(k);\n unordered_set usedKeys;\n \n // Random distribution of line types\n int nVert = uniform_int_distribution(0, k/2 + 1)(rng);\n int nHoriz = uniform_int_distribution(0, k/2 + 1)(rng);\n int nDiag1 = uniform_int_distribution(0, k/2 + 1)(rng);\n int nDiag2 = uniform_int_distribution(0, k/2 + 1)(rng);\n int nRandom = k - nVert - nHoriz - nDiag1 - nDiag2;\n if (nRandom < 0) nRandom = 0;\n \n // Vertical lines\n vector usedX;\n for (int i = 0; i < nVert; ++i) {\n int64 x = uniform_int_distribution(-R + 50, R - 50)(rng);\n bool dup = false;\n for (int64 v : usedX) if (v == x) { dup = true; break; }\n if (dup) continue;\n usedX.push_back(x);\n Line L;\n if (!try_make_line(x, -R, x, R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Horizontal lines\n vector usedY;\n for (int i = 0; i < nHoriz; ++i) {\n int64 y = uniform_int_distribution(-R + 50, R - 50)(rng);\n bool dup = false;\n for (int64 v : usedY) if (v == y) { dup = true; break; }\n if (dup) continue;\n usedY.push_back(y);\n Line L;\n if (!try_make_line(-R, y, R, y, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Diagonal lines (x+y=c)\n vector usedS1;\n for (int i = 0; i < nDiag1; ++i) {\n int64 c = uniform_int_distribution(-R, R)(rng);\n bool dup = false;\n for (int64 v : usedS1) if (v == c) { dup = true; break; }\n if (dup) continue;\n usedS1.push_back(c);\n Line L;\n if (!try_make_line(-R, c + R, c + R, -R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Diagonal lines (x-y=c)\n vector usedS2;\n for (int i = 0; i < nDiag2; ++i) {\n int64 c = uniform_int_distribution(-R, R)(rng);\n bool dup = false;\n for (int64 v : usedS2) if (v == c) { dup = true; break; }\n if (dup) continue;\n usedS2.push_back(c);\n Line L;\n if (!try_make_line(-R, -c - R, -c - R, -R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Add random lines if needed\n while ((int)cur.size() < k) {\n int64 x1 = distLarge(rng);\n int64 y1 = distLarge(rng);\n int64 x2 = distLarge(rng);\n int64 y2 = distLarge(rng);\n \n if (x1 == x2 && y1 == y2) continue;\n \n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (const auto& p : pts) {\n int64 cross = dx * (p.y - y1) - dy * (p.x - x1);\n if (cross == 0) {\n ok = false;\n break;\n }\n }\n if (!ok) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n\n /* ================================================================\n Strategy 4: Prime-based spacing grids (good for diverse cells)\n ================================================================ */\n vector primes = {2, 3, 5, 7, 11, 13, 17, 19, 23};\n for (int p : primes) {\n int spacing = p * 100;\n if (spacing < 200) continue;\n \n for (int offset = 0; offset < spacing; offset += max(1, spacing/3)) {\n vector cur;\n cur.reserve(K);\n unordered_set usedKeys;\n \n // Vertical lines\n for (int64 x = -R + offset; x < R && (int)cur.size() < K; x += spacing) {\n Line L;\n if (!try_make_line(x, -R, x, R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Horizontal lines\n for (int64 y = -R + offset; y < R && (int)cur.size() < K; y += spacing) {\n Line L;\n if (!try_make_line(-R, y, R, y, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n if (bestScore == totalA) break;\n }\n\n /* ================================================================\n Strategy 5: Mixed strategies - vertical/horizontal only\n ================================================================ */\n for (int spacing = 400; spacing <= 1200; spacing += 200) {\n vector cur;\n cur.reserve(K);\n unordered_set usedKeys;\n \n // Vertical lines\n for (int64 x = -R + 1; x < R && (int)cur.size() < K; x += spacing) {\n Line L;\n if (!try_make_line(x, -R, x, R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Horizontal lines\n for (int64 y = -R + 1; y < R && (int)cur.size() < K; y += spacing) {\n Line L;\n if (!try_make_line(-R, y, R, y, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n\n /* ================================================================\n Strategy 6: Fine-grained hill climbing\n ================================================================ */\n for (int iter = 0; iter < 80 && bestScore < totalA; ++iter) {\n vector cur = bestLines;\n \n // Try adding a few new random lines\n for (int add_attempt = 0; add_attempt < 15; ++add_attempt) {\n if ((int)cur.size() >= K) break;\n \n int coordType = rng() % 2;\n int64 x1, y1, x2, y2;\n \n if (coordType == 0) {\n x1 = distSmall(rng);\n y1 = distSmall(rng);\n x2 = distSmall(rng);\n y2 = distSmall(rng);\n } else {\n x1 = distLarge(rng);\n y1 = distLarge(rng);\n x2 = distLarge(rng);\n y2 = distLarge(rng);\n }\n \n if (x1 == x2 && y1 == y2) continue;\n \n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (const auto& p : pts) {\n int64 cross = dx * (p.y - y1) - dy * (p.x - x1);\n if (cross == 0) {\n ok = false;\n break;\n }\n }\n if (!ok) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n \n bool dup = false;\n for (const auto& existing : cur) {\n if (line_key(existing) == key) {\n dup = true;\n break;\n }\n }\n if (!dup) {\n cur.push_back(L);\n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n } else {\n cur.pop_back(); // Revert\n }\n }\n }\n }\n\n /* ----------------------------------------------------------- */\n cout << (int)bestLines.size() << '\\n';\n for (const auto& L : bestLines) {\n cout << L.p1.x << ' ' << L.p1.y << ' '\n << L.p2.x << ' ' << L.p2.y << '\\n';\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2, x3, y3, x4, y4;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n if (!(cin >> N >> M)) return 0;\n\n vector> dot(N, vector(N, 0));\n vector> init;\n for (int i = 0; i < M; ++i) {\n int x, y; cin >> x >> y;\n dot[x][y] = 1;\n init.emplace_back(x, y);\n }\n\n // Row/column dot lists\n vector> rowDots(N), colDots(N);\n for (auto &p : init) {\n int x = p.first, y = p.second;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n }\n\n // Center and weight calculation\n double c = (N - 1) / 2.0;\n auto weight = [&](int x, int y) -> double {\n double dx = x - c, dy = y - c;\n return dx * dx + dy * dy + 1;\n };\n\n vector bestAnswer;\n long long bestScore = 0;\n\n const int NUM_TRIALS = 10;\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n for (int trial = 0; trial < NUM_TRIALS; trial++) {\n // Reset state\n vector> dot = vector>(N, vector(N, 0));\n vector> hor(N, vector(N, 0));\n vector> ver(N, vector(N, 0));\n vector>> diagUR(N, vector>(N));\n vector>> diagDR(N, vector>(N));\n vector> rowDots(N), colDots(N);\n for (auto &p : init) {\n int x = p.first, y = p.second;\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n }\n\n // Empty points\n vector> empty;\n for (int x = 0; x < N; ++x)\n for (int y = 0; y < N; ++y)\n if (!dot[x][y]) empty.emplace_back(x, y);\n\n vector answer;\n\n // =============== Axis-aligned helpers ===============\n auto sidesEmptyAxis = [&](int x, int y, int x2, int y2) -> bool {\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y]) return false;\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x][yi]) return false;\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x2][yi]) return false;\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y2]) return false;\n return true;\n };\n\n auto addEdgeAxis = [&](int xa, int ya, int xb, int yb) {\n if (xa == xb) {\n int x = xa, ylo = min(ya, yb), yhi = max(ya, yb);\n for (int y = ylo; y < yhi; ++y) ver[x][y]++;\n } else {\n int y = ya, xlo = min(xa, xb), xhi = max(xa, xb);\n for (int x = xlo; x < xhi; ++x) hor[x][y]++;\n }\n };\n\n auto edgeFreeAxis = [&](int xa, int ya, int xb, int yb) -> bool {\n if (xa == xb) {\n int x = xa, ylo = min(ya, yb), yhi = max(ya, yb);\n for (int y = ylo; y < yhi; ++y) if (ver[x][y]) return false;\n } else {\n int y = ya, xlo = min(xa, xb), xhi = max(xa, xb);\n for (int x = xlo; x < xhi; ++x) if (hor[x][y]) return false;\n }\n return true;\n };\n\n auto edgesFreeAxis = [&](int x, int y, int x2, int y2) -> bool {\n if (!edgeFreeAxis(x, y, x2, y)) return false;\n if (!edgeFreeAxis(x2, y, x2, y2)) return false;\n if (!edgeFreeAxis(x2, y2, x, y2)) return false;\n if (!edgeFreeAxis(x, y2, x, y)) return false;\n return true;\n };\n\n auto addEdgesAxis = [&](int x, int y, int x2, int y2) {\n addEdgeAxis(x, y, x2, y);\n addEdgeAxis(x2, y, x2, y2);\n addEdgeAxis(x2, y2, x, y2);\n addEdgeAxis(x, y2, x, y);\n };\n\n // =============== 45-degree helpers ===============\n auto checkSide45 = [&](int xa, int ya, int xb, int yb) -> bool {\n int dx = xb - xa, dy = yb - ya;\n int steps = abs(dx);\n if (steps == 0) return true;\n int sx = (dx > 0) ? 1 : (dx < 0 ? -1 : 0);\n int sy = (dy > 0) ? 1 : (dy < 0 ? -1 : 0);\n for (int i = 1; i < steps; ++i) {\n int xi = xa + i * sx;\n int yi = ya + i * sy;\n if (dot[xi][yi]) return false;\n }\n return true;\n };\n\n auto addEdgeDiag = [&](int xa, int ya, int xb, int yb) {\n int dx = xb - xa, dy = yb - ya;\n int steps = abs(dx);\n int sx = (dx > 0) ? 1 : (dx < 0 ? -1 : 0);\n int sy = (dy > 0) ? 1 : (dy < 0 ? -1 : 0);\n for (int i = 0; i < steps; ++i) {\n int xs = xa + i * sx;\n int ys = ya + i * sy;\n if (sx == 1 && sy == 1) {\n diagUR[xs][ys][0]++;\n if (xs + 1 < N && ys + 1 < N) diagUR[xs + 1][ys + 1][0]++;\n } else if (sx == 1 && sy == -1) {\n diagDR[xs][ys][1]++;\n if (xs + 1 < N && ys - 1 >= 0) diagDR[xs + 1][ys - 1][1]++;\n } else if (sx == -1 && sy == 1) {\n diagDR[xs - 1][ys + 1][1]++;\n if (xs < N && ys < N) diagDR[xs][ys][1]++;\n } else if (sx == -1 && sy == -1) {\n diagUR[xs - 1][ys - 1][0]++;\n if (xs < N && ys < N) diagUR[xs][ys][0]++;\n }\n }\n };\n\n auto edgeFreeDiag = [&](int xa, int ya, int xb, int yb) -> bool {\n int dx = xb - xa, dy = yb - ya;\n int steps = abs(dx);\n int sx = (dx > 0) ? 1 : (dx < 0 ? -1 : 0);\n int sy = (dy > 0) ? 1 : (dy < 0 ? -1 : 0);\n for (int i = 0; i < steps; ++i) {\n int xs = xa + i * sx;\n int ys = ya + i * sy;\n if (sx == 1 && sy == 1) {\n if (diagUR[xs][ys][0]) return false;\n } else if (sx == 1 && sy == -1) {\n if (diagDR[xs][ys][1]) return false;\n } else if (sx == -1 && sy == 1) {\n if (diagDR[xs - 1][ys + 1][1]) return false;\n } else if (sx == -1 && sy == -1) {\n if (diagUR[xs - 1][ys - 1][0]) return false;\n }\n }\n return true;\n };\n\n auto edgesFree45 = [&](int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) -> bool {\n if (!edgeFreeDiag(x1, y1, x2, y2)) return false;\n if (!edgeFreeDiag(x2, y2, x3, y3)) return false;\n if (!edgeFreeDiag(x3, y3, x4, y4)) return false;\n if (!edgeFreeDiag(x4, y4, x1, y1)) return false;\n return true;\n };\n\n auto addEdges45 = [&](int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {\n addEdgeDiag(x1, y1, x2, y2);\n addEdgeDiag(x2, y2, x3, y3);\n addEdgeDiag(x3, y3, x4, y4);\n addEdgeDiag(x4, y4, x1, y1);\n };\n\n // Main greedy loop\n while (true) {\n bool progress = false;\n shuffle(empty.begin(), empty.end(), rng);\n \n for (size_t i = 0; i < empty.size(); ++i) {\n int x = empty[i].first, y = empty[i].second;\n \n // Try axis-aligned (prefer smaller rectangles)\n const vector &cols = rowDots[y];\n const vector &rows = colDots[x];\n int bestW = INT_MAX, bestH = INT_MAX;\n pair bestX2Y2 = {-1, -1};\n \n for (int x2 : cols) {\n if (x2 == x) continue;\n for (int y2 : rows) {\n if (y2 == y) continue;\n if (!dot[x2][y2]) continue;\n if (!sidesEmptyAxis(x, y, x2, y2)) continue;\n if (!edgesFreeAxis(x, y, x2, y2)) continue;\n \n int w = abs(x2 - x), h = abs(y2 - y);\n if (w < bestW || (w == bestW && h < bestH)) {\n bestW = w;\n bestH = h;\n bestX2Y2 = {x2, y2};\n }\n }\n }\n \n if (bestX2Y2.first != -1) {\n int x2 = bestX2Y2.first, y2 = bestX2Y2.second;\n Rect r{ x, y, x2, y, x2, y2, x, y2 };\n answer.push_back(r);\n addEdgesAxis(x, y, x2, y2);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n break;\n }\n \n // Try 45-degree (prefer smaller d)\n bool found45 = false;\n \n // Case A: top vertex\n int d_max = min({y / 2, x, N - 1 - x});\n for (int d = 1; d <= d_max; ++d) {\n int x2 = x + d, y2 = y - d;\n int x3 = x, y3 = y - 2 * d;\n int x4 = x - d, y4 = y - d;\n if (!dot[x2][y2] || !dot[x3][y3] || !dot[x4][y4]) continue;\n if (!checkSide45(x, y, x2, y2)) continue;\n if (!checkSide45(x2, y2, x3, y3)) continue;\n if (!checkSide45(x3, y3, x4, y4)) continue;\n if (!checkSide45(x4, y4, x, y)) continue;\n if (!edgesFree45(x, y, x2, y2, x3, y3, x4, y4)) continue;\n \n Rect r{ x, y, x2, y2, x3, y3, x4, y4 };\n answer.push_back(r);\n addEdges45(x, y, x2, y2, x3, y3, x4, y4);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n found45 = true;\n break;\n }\n if (found45) break;\n \n // Case B: bottom vertex\n d_max = min({x, (N - 1 - y) / 2, N - 1 - x});\n for (int d = 1; d <= d_max; ++d) {\n int x2 = x + d, y2 = y + d;\n int x3 = x, y3 = y + 2 * d;\n int x4 = x - d, y4 = y + d;\n if (!dot[x2][y2] || !dot[x3][y3] || !dot[x4][y4]) continue;\n if (!checkSide45(x, y, x2, y2)) continue;\n if (!checkSide45(x2, y2, x3, y3)) continue;\n if (!checkSide45(x3, y3, x4, y4)) continue;\n if (!checkSide45(x4, y4, x, y)) continue;\n if (!edgesFree45(x, y, x2, y2, x3, y3, x4, y4)) continue;\n \n Rect r{ x, y, x2, y2, x3, y3, x4, y4 };\n answer.push_back(r);\n addEdges45(x, y, x2, y2, x3, y3, x4, y4);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n found45 = true;\n break;\n }\n if (found45) break;\n \n // Case C: right vertex\n d_max = min({(N - 1 - x) / 2, N - 1 - y, y});\n for (int d = 1; d <= d_max; ++d) {\n int x2 = x + d, y2 = y + d;\n int x3 = x + 2 * d, y3 = y;\n int x4 = x + d, y4 = y - d;\n if (!dot[x2][y2] || !dot[x3][y3] || !dot[x4][y4]) continue;\n if (!checkSide45(x, y, x2, y2)) continue;\n if (!checkSide45(x2, y2, x3, y3)) continue;\n if (!checkSide45(x3, y3, x4, y4)) continue;\n if (!checkSide45(x4, y4, x, y)) continue;\n if (!edgesFree45(x, y, x2, y2, x3, y3, x4, y4)) continue;\n \n Rect r{ x, y, x2, y2, x3, y3, x4, y4 };\n answer.push_back(r);\n addEdges45(x, y, x2, y2, x3, y3, x4, y4);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n found45 = true;\n break;\n }\n if (found45) break;\n \n // Case D: left vertex\n d_max = min({x / 2, N - 1 - y, y});\n for (int d = 1; d <= d_max; ++d) {\n int x2 = x - d, y2 = y + d;\n int x3 = x - 2 * d, y3 = y;\n int x4 = x - d, y4 = y - d;\n if (!dot[x2][y2] || !dot[x3][y3] || !dot[x4][y4]) continue;\n if (!checkSide45(x, y, x2, y2)) continue;\n if (!checkSide45(x2, y2, x3, y3)) continue;\n if (!checkSide45(x3, y3, x4, y4)) continue;\n if (!checkSide45(x4, y4, x, y)) continue;\n if (!edgesFree45(x, y, x2, y2, x3, y3, x4, y4)) continue;\n \n Rect r{ x, y, x2, y2, x3, y3, x4, y4 };\n answer.push_back(r);\n addEdges45(x, y, x2, y2, x3, y3, x4, y4);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n found45 = true;\n break;\n }\n }\n \n if (!progress) break;\n }\n\n // Calculate approximate score for this trial\n long long score = 0;\n for (int x = 0; x < N; ++x)\n for (int y = 0; y < N; ++y)\n if (dot[x][y])\n score += (long long)(weight(x, y));\n\n if (score > bestScore) {\n bestScore = score;\n bestAnswer = answer;\n }\n }\n\n // Output best result\n cout << bestAnswer.size() << '\\n';\n for (const auto &r : bestAnswer) {\n cout << r.x1 << ' ' << r.y1 << ' '\n << r.x2 << ' ' << r.y2 << ' '\n << r.x3 << ' ' << r.y3 << ' '\n << r.x4 << ' ' << r.y4 << '\\n';\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nconstexpr int H = 10;\nconstexpr int W = 10;\nconstexpr int MAXC = 100;\n\nint flavor[MAXC + 1];\n\nvoid copyBoard(const int src[H][W], int dst[H][W]) {\n for (int i = 0; i < H; ++i)\n for (int j = 0; j < W; ++j)\n dst[i][j] = src[i][j];\n}\n\nvoid tiltBoard(int a[H][W], char dir) {\n if (dir == 'F') {\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = 0; r < H; ++r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[i][c] = buf[i];\n }\n } else if (dir == 'B') {\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = H - 1; r >= 0; --r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[H - 1 - i][c] = buf[i];\n }\n } else if (dir == 'L') {\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = 0; c < W; ++c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][i] = buf[i];\n }\n } else if (dir == 'R') {\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = W - 1; c >= 0; --c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][W - 1 - i] = buf[i];\n }\n }\n}\n\nstruct Eval {\n int sumSq;\n int maxSize;\n int compCnt;\n};\n\nEval evaluate(const int a[H][W]) {\n bool vis[H][W] = {false};\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n\n Eval res{0, 0, 0};\n for (int r = 0; r < H; ++r) {\n for (int c = 0; c < W; ++c) {\n if (a[r][c] && !vis[r][c]) {\n int fl = a[r][c];\n int sz = 0;\n queue> q;\n q.emplace(r, c);\n vis[r][c] = true;\n while (!q.empty()) {\n auto [cr, cc] = q.front(); q.pop();\n ++sz;\n for (int d = 0; d < 4; ++d) {\n int nr = cr + dr[d];\n int nc = cc + dc[d];\n if (nr >= 0 && nr < H && nc >= 0 && nc < W &&\n !vis[nr][nc] && a[nr][nc] == fl) {\n vis[nr][nc] = true;\n q.emplace(nr, nc);\n }\n }\n }\n res.sumSq += sz * sz;\n res.maxSize = max(res.maxSize, sz);\n ++res.compCnt;\n }\n }\n }\n return res;\n}\n\nstatic const char DIRS[4] = {'F', 'B', 'L', 'R'};\n\nchar oppositeDir(char d) {\n if (d == 'F') return 'B';\n if (d == 'B') return 'F';\n if (d == 'L') return 'R';\n return 'L';\n}\n\nchar bestDirOneStep(const int board[H][W]) {\n char bestDir = 'R';\n Eval best{-1, -1, INT_MAX};\n for (char d : DIRS) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n Eval ev = evaluate(tmp);\n if (ev.sumSq > best.sumSq ||\n (ev.sumSq == best.sumSq && ev.maxSize > best.maxSize) ||\n (ev.sumSq == best.sumSq && ev.maxSize == best.maxSize && ev.compCnt < best.compCnt)) {\n best = ev;\n bestDir = d;\n }\n }\n return bestDir;\n}\n\nvector> getEmpty(const int board[H][W]) {\n vector> v;\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n if (board[r][c] == 0) v.emplace_back(r, c);\n return v;\n}\n\n// Depth-2 look-ahead with full enumeration (stable version)\ndouble expectedAfterTwoSteps(const int board[H][W], int curStep) {\n int nextStep = curStep + 1;\n if (nextStep > MAXC) return evaluate(board).sumSq;\n\n vector> empties = getEmpty(board);\n int cnt = (int)empties.size();\n if (cnt == 0) return evaluate(board).sumSq;\n\n double total = 0.0;\n int flNext = flavor[nextStep];\n \n // For each possible position of the next candy\n for (auto &ec : empties) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tmp[ec.first][ec.second] = flNext; // place next candy\n \n // Find greedy best direction after placement\n char d1 = bestDirOneStep(tmp);\n tiltBoard(tmp, d1);\n \n total += evaluate(tmp).sumSq;\n }\n return total / cnt;\n}\n\n// More sophisticated depth-2 with better evaluation\ndouble expectedAfterTwoStepsV2(const int board[H][W], int curStep) {\n int nextStep = curStep + 1;\n if (nextStep > MAXC) {\n Eval e = evaluate(board);\n return e.sumSq * 1.0; // final score\n }\n\n vector> empties = getEmpty(board);\n int cnt = (int)empties.size();\n if (cnt == 0) {\n Eval e = evaluate(board);\n return e.sumSq * 1.0;\n }\n\n // Early steps: use smaller lookahead\n if (curStep < 10) {\n // For early steps, just evaluate the immediate sumSq after greedy tilt\n char d = bestDirOneStep(board);\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n Eval e = evaluate(tmp);\n return e.sumSq * 1.0;\n }\n\n double total = 0.0;\n int flNext = flavor[nextStep];\n \n for (auto &ec : empties) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tmp[ec.first][ec.second] = flNext;\n \n // Try all 4 directions and pick the best one\n char bestDir = 'F';\n Eval bestEval{-1, -1, INT_MAX};\n \n for (char d : DIRS) {\n int tmp2[H][W];\n copyBoard(tmp, tmp2);\n tiltBoard(tmp2, d);\n Eval ev = evaluate(tmp2);\n \n // Use weighted score: sumSq + 0.5*maxSize - 2*compCnt\n double score = ev.sumSq + 0.5 * ev.maxSize - 2.0 * ev.compCnt;\n double bestScore = bestEval.sumSq + 0.5 * bestEval.maxSize - 2.0 * bestEval.compCnt;\n \n if (score > bestScore) {\n bestScore = score;\n bestDir = d;\n bestEval = ev;\n }\n }\n \n // Apply best direction\n tiltBoard(tmp, bestDir);\n Eval finalEval = evaluate(tmp);\n total += finalEval.sumSq;\n }\n return total / cnt;\n}\n\nchar chooseDirection(const int board[H][W], int curStep) {\n double bestScore = -1.0;\n char bestDir = 'R';\n \n for (char d : DIRS) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n double expScore = expectedAfterTwoStepsV2(tmp, curStep);\n if (expScore > bestScore + 1e-9) {\n bestScore = expScore;\n bestDir = d;\n }\n }\n return bestDir;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n for (int i = 1; i <= MAXC; ++i) {\n if (!(cin >> flavor[i])) return 0;\n }\n\n int board[H][W] = {0};\n\n vector> empties;\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n empties.emplace_back(r, c);\n\n for (int step = 1; step <= MAXC; ++step) {\n int p;\n cin >> p;\n auto cell = empties[p - 1];\n board[cell.first][cell.second] = flavor[step];\n empties.erase(empties.begin() + (p - 1));\n\n char dir;\n if (step == MAXC) {\n dir = bestDirOneStep(board);\n } else {\n dir = chooseDirection(board, step);\n }\n\n cout << dir << '\\n' << std::flush;\n tiltBoard(board, dir);\n\n empties.clear();\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n if (board[r][c] == 0) empties.emplace_back(r, c);\n }\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int M;\n long double eps;\n if (!(cin >> M >> eps)) return 0;\n\n const int MAX_E = 4950; // N = 100 \u2192 E = 4950\n vector lfac(MAX_E + 1);\n lfac[0] = 0;\n for (int i = 1; i <= MAX_E; ++i) lfac[i] = lfac[i - 1] + logl((long double)i);\n\n // smallest N such that N(N\u20111)/2 \u2265 M\u20111\n int minN = 4;\n while (minN * (minN - 1) / 2 < M - 1) ++minN;\n\n int bestN = minN;\n long double bestScore = -1.0L;\n\n // epsilon = 0 \u2192 perfect recovery, choose smallest N\n if (fabsl(eps) < 1e-12L) {\n bestN = minN;\n } else {\n const long double oneMinus2eps = 1.0L - 2.0L * eps;\n\n for (int N = minN; N <= 100; ++N) {\n int E = N * (N - 1) / 2;\n\n // edge counts mi\n vector mi(M);\n for (int i = 0; i < M; ++i) {\n mi[i] = (int)floor((long double)i * E / (M - 1));\n }\n\n // log probabilities for every hypothesis\n vector logp(M), log1mp(M);\n for (int i = 0; i < M; ++i) {\n long double p = eps + oneMinus2eps * (long double)mi[i] / (long double)E;\n logp[i] = logl(p);\n log1mp[i] = log1pl(-p); // log(1-p)\n }\n\n // log binomial coefficients for this E\n vector logBinomE(E + 1);\n for (int x = 0; x <= E; ++x) {\n logBinomE[x] = lfac[E] - lfac[x] - lfac[E - x];\n }\n\n // total_correct = \u03a3_x max_i Pr[ X = x | mi ]\n long double total_correct = 0.0L;\n for (int x = 0; x <= E; ++x) {\n long double log_common = logBinomE[x];\n long double max_val = -numeric_limits::infinity();\n for (int i = 0; i < M; ++i) {\n // cur = log_common + x*logp[i] + (E-x)*log1mp[i]\n long double cur = log_common + (long double)x * logp[i] +\n (long double)(E - x) * log1mp[i];\n if (cur > max_val) max_val = cur;\n }\n total_correct += expl(max_val);\n }\n\n long double p_err = 1.0L - total_correct / (long double)M;\n if (p_err < 0) p_err = 0;\n\n long double factor = powl(1.0L - 0.1L * p_err, 100);\n long double score = 1e9L * factor / (long double)N;\n\n if (score > bestScore) {\n bestScore = score;\n bestN = N;\n }\n }\n }\n\n // ----- produce output with the chosen N -----\n int N = bestN;\n int E = N * (N - 1) / 2;\n\n // recompute mi for the chosen N\n vector mi(M);\n for (int i = 0; i < M; ++i) {\n mi[i] = (int)floor((long double)i * E / (M - 1));\n }\n\n cout << N << \"\\n\";\n string edgeStr(E, '0');\n for (int idx = 0; idx < M; ++idx) {\n int ones = mi[idx];\n fill(edgeStr.begin(), edgeStr.end(), '0');\n for (int j = 0; j < ones; ++j) edgeStr[j] = '1';\n cout << edgeStr << \"\\n\";\n }\n cout.flush(); // required after the graphs\n\n // pre\u2011compute log\u2011probabilities for decoding\n vector logp(M), log1mp(M);\n const long double oneMinus2eps = 1.0L - 2.0L * eps;\n for (int i = 0; i < M; ++i) {\n long double p = eps + oneMinus2eps * (long double)mi[i] / (long double)E;\n logp[i] = logl(p);\n log1mp[i] = log1pl(-p);\n }\n\n // ----- answer the 100 queries -----\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n int x = 0;\n for (char c : H) if (c == '1') ++x;\n\n int answer;\n if (fabsl(eps) < 1e-12L) { // \u03b5 = 0 \u2192 exact edge count\n answer = (int)(lower_bound(mi.begin(), mi.end(), x) - mi.begin());\n } else {\n long double bestVal = -numeric_limits::infinity();\n answer = 0;\n for (int i = 0; i < M; ++i) {\n long double cur = (long double)x * logp[i] +\n (long double)(E - x) * log1mp[i];\n if (cur > bestVal) {\n bestVal = cur;\n answer = i;\n }\n }\n }\n cout << answer << \"\\n\";\n cout.flush();\n }\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n int w;\n};\n\nint N, M, D, K;\nvector edges;\nvector>> adj;\nvector> edge_adj;\nvector> day_edges;\nvector day_cnt;\nvector day_of_edge;\nvector removed;\nvector visited;\nvector q;\n\n// ---------------------------------------------------------------\nbool safe(int day, int cand) {\n if (day_cnt[day] == 0) return true;\n \n for (int e : day_edges[day]) removed[e] = 1;\n removed[cand] = 1;\n \n fill(visited.begin(), visited.end(), 0);\n int qs = 0, qe = 0;\n visited[0] = 1;\n q[qe++] = 0;\n while (qs < qe) {\n int v = q[qs++];\n for (auto [to, eid] : adj[v]) {\n if (removed[eid]) continue;\n if (!visited[to]) {\n visited[to] = 1;\n q[qe++] = to;\n }\n }\n }\n \n for (int e : day_edges[day]) removed[e] = 0;\n removed[cand] = 0;\n \n for (int i = 0; i < N; ++i) if (!visited[i]) return false;\n return true;\n}\n\n// ---------------------------------------------------------------\nint compute_metric() {\n int met = 0;\n for (int e = 0; e < M; ++e) {\n int d = day_of_edge[e];\n for (int nb : edge_adj[e]) {\n if (day_of_edge[nb] == d && nb < e) ++met;\n }\n }\n return met;\n}\n\n// ---------------------------------------------------------------\nbool is_valid_schedule() {\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] > K) return false;\n }\n for (int e = 0; e < M; ++e) {\n if (day_of_edge[e] < 0 || day_of_edge[e] >= D) return false;\n }\n return true;\n}\n\n// ---------------------------------------------------------------\nvoid greedy_build(const vector& order) {\n for (int d = 0; d < D; ++d) {\n day_edges[d].clear();\n day_cnt[d] = 0;\n }\n fill(day_of_edge.begin(), day_of_edge.end(), -1);\n \n vector score(D, 0);\n \n for (int eid : order) {\n fill(score.begin(), score.end(), 0);\n for (int nb : edge_adj[eid]) {\n int d = day_of_edge[nb];\n if (d != -1) ++score[d];\n }\n \n int best_score = -1;\n vector cand;\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] >= K) continue;\n if (score[d] > best_score) {\n best_score = score[d];\n cand.clear();\n cand.push_back(d);\n } else if (score[d] == best_score) {\n cand.push_back(d);\n }\n }\n \n if (cand.empty()) {\n // Find any day with space\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K) {\n cand.push_back(d);\n break;\n }\n }\n }\n \n if (cand.empty()) continue; // Should not happen with valid K\n \n int chosen = cand[0];\n for (int d : cand) {\n if (day_cnt[d] < day_cnt[chosen]) chosen = d;\n }\n \n // Safety check\n if (day_cnt[chosen] > 0 && !safe(chosen, eid)) {\n bool found = false;\n for (int d : cand) {\n if (d == chosen) continue;\n if (day_cnt[d] == 0 || safe(d, eid)) {\n chosen = d;\n found = true;\n break;\n }\n }\n if (!found) {\n // Try any day with space\n for (int d = 0; d < D; ++d) {\n if (d != chosen && day_cnt[d] < K && (day_cnt[d] == 0 || safe(d, eid))) {\n chosen = d;\n found = true;\n break;\n }\n }\n }\n if (!found) {\n // Last resort: put in day with fewest edges\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K) {\n chosen = d;\n break;\n }\n }\n }\n }\n \n day_of_edge[eid] = chosen;\n ++day_cnt[chosen];\n day_edges[chosen].push_back(eid);\n }\n}\n\n// ---------------------------------------------------------------\nvoid local_search_fast(int max_moves = 300) {\n mt19937 rng(random_device{}());\n \n for (int iter = 0; iter < max_moves; ++iter) {\n int eid = rng() % M;\n int old_day = day_of_edge[eid];\n \n int old_adj = 0;\n for (int nb : edge_adj[eid]) {\n if (day_of_edge[nb] == old_day && nb < eid) ++old_adj;\n }\n \n int best_delta = -1000;\n int best_day = -1;\n \n for (int d = 0; d < D; ++d) {\n if (d == old_day || day_cnt[d] >= K) continue;\n if (day_cnt[d] > 0 && !safe(d, eid)) continue;\n \n int new_adj = 0;\n for (int nb : edge_adj[eid]) {\n if (day_of_edge[nb] == d) ++new_adj;\n }\n \n int delta = new_adj - old_adj;\n if (delta > best_delta) {\n best_delta = delta;\n best_day = d;\n }\n }\n \n if (best_delta > 0 && best_day != -1) {\n auto &vec = day_edges[old_day];\n for (size_t i = 0; i < vec.size(); ++i) {\n if (vec[i] == eid) {\n vec[i] = vec.back();\n vec.pop_back();\n break;\n }\n }\n --day_cnt[old_day];\n \n day_of_edge[eid] = best_day;\n ++day_cnt[best_day];\n day_edges[best_day].push_back(eid);\n }\n }\n}\n\n// ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n if (!(cin >> N >> M >> D >> K)) return 0;\n edges.resize(M);\n adj.assign(N, {});\n vector> vertex_edges[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 adj[u].push_back({v, i});\n adj[v].push_back({u, i});\n vertex_edges[u].push_back({v, i});\n vertex_edges[v].push_back({u, i});\n }\n \n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n \n // Build line-graph adjacency\n edge_adj.assign(M, {});\n for (int v = 0; v < N; ++v) {\n for (size_t a = 0; a < vertex_edges[v].size(); ++a) {\n int e1 = vertex_edges[v][a].second;\n for (size_t b = a + 1; b < vertex_edges[v].size(); ++b) {\n int e2 = vertex_edges[v][b].second;\n edge_adj[e1].push_back(e2);\n edge_adj[e2].push_back(e1);\n }\n }\n }\n \n day_edges.assign(D, {});\n day_cnt.assign(D, 0);\n day_of_edge.assign(M, -1);\n removed.assign(M, 0);\n visited.assign(N, 0);\n q.resize(N);\n \n const int ITERATIONS = 20;\n int best_metric = -1;\n vector best_assignment;\n \n for (int it = 0; it < ITERATIONS; ++it) {\n vector order(M);\n iota(order.begin(), order.end(), 0);\n \n if (it % 3 == 0) {\n shuffle(order.begin(), order.end(), mt19937{random_device{}()});\n } else if (it % 3 == 1) {\n sort(order.begin(), order.end(), [&](int a, int b) {\n return edge_adj[a].size() > edge_adj[b].size();\n });\n for (int i = 0; i < 100; ++i) {\n int a = rand() % M, b = rand() % M;\n swap(order[a], order[b]);\n }\n } else {\n sort(order.begin(), order.end(), [&](int a, int b) {\n return edges[a].w < edges[b].w;\n });\n for (int i = 0; i < 100; ++i) {\n int a = rand() % M, b = rand() % M;\n swap(order[a], order[b]);\n }\n }\n \n greedy_build(order);\n \n // Verify all edges assigned\n for (int e = 0; e < M; ++e) {\n if (day_of_edge[e] == -1) {\n // Assign to first available day\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K) {\n day_of_edge[e] = d;\n ++day_cnt[d];\n day_edges[d].push_back(e);\n break;\n }\n }\n }\n }\n \n local_search_fast(400);\n \n // Final verification\n if (!is_valid_schedule()) {\n continue;\n }\n \n int met = compute_metric();\n if (met > best_metric) {\n best_metric = met;\n best_assignment = day_of_edge;\n }\n }\n \n // Fallback if no valid schedule found\n if (best_assignment.empty()) {\n best_assignment.assign(M, 0);\n for (int e = 0; e < M; ++e) {\n best_assignment[e] = e % D;\n }\n }\n \n // Verify final assignment\n for (int e = 0; e < M; ++e) {\n if (best_assignment[e] < 0 || best_assignment[e] >= D) {\n best_assignment[e] = 0;\n }\n }\n vector final_cnt(D, 0);\n for (int e = 0; e < M; ++e) {\n final_cnt[best_assignment[e]]++;\n }\n for (int d = 0; d < D; ++d) {\n while (final_cnt[d] > K) {\n // Move one edge to another day\n for (int e = 0; e < M; ++e) {\n if (best_assignment[e] == d) {\n for (int d2 = 0; d2 < D; ++d2) {\n if (d2 != d && final_cnt[d2] < K) {\n best_assignment[e] = d2;\n final_cnt[d]--;\n final_cnt[d2]++;\n break;\n }\n }\n break;\n }\n }\n }\n }\n \n for (int i = 0; i < M; ++i) {\n if (i) cout << ' ';\n cout << (best_assignment[i] + 1);\n }\n cout << '\\n';\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n cin >> D;\n vector f1(D), r1(D), f2(D), r2(D);\n for (int i = 0; i < D; i++) cin >> f1[i];\n for (int i = 0; i < D; i++) cin >> r1[i];\n for (int i = 0; i < D; i++) cin >> f2[i];\n for (int i = 0; i < D; i++) cin >> r2[i];\n \n vector O1(D, vector(D, vector(D, 0)));\n vector O2(D, vector(D, vector(D, 0)));\n \n auto min_edge_cover = [&](const vector& F, const vector& R,\n auto& O, int z) {\n int nF = F.size(), nR = R.size();\n if (nF == 0 || nR == 0) return;\n \n if (nF >= nR) {\n for (int i = 0; i < nR; i++) O[F[i]][R[i]][z] = 1;\n for (int i = nR; i < nF; i++) O[F[i]][R[0]][z] = 1;\n } else {\n for (int i = 0; i < nF; i++) O[F[i]][R[i]][z] = 1;\n for (int i = nF; i < nR; i++) O[F[0]][R[i]][z] = 1;\n }\n };\n \n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f1[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r1[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O1, z);\n }\n \n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f2[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r2[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O2, z);\n }\n \n const int dx[6] = {1,-1,0,0,0,0}, dy[6] = {0,0,1,-1,0,0}, dz[6] = {0,0,0,0,1,-1};\n \n // Find connected components in O1\n vector comp1(D * D * D, -1);\n vector>> comps1;\n vector>> cells1_per_comp;\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n int idx = x * D * D + y * D + z;\n if (O1[x][y][z] && comp1[idx] == -1) {\n vector> cells;\n queue q;\n q.push(idx);\n comp1[idx] = comps1.size();\n \n while (!q.empty()) {\n int cur = q.front(); q.pop();\n int cx = cur / (D * D);\n int cy = (cur / D) % D;\n int cz = cur % D;\n cells.emplace_back(cx, cy, cz);\n \n for (int d = 0; d < 6; d++) {\n int nx = cx + dx[d], ny = cy + dy[d], nz = cz + dz[d];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D || nz < 0 || nz >= D) continue;\n int nidx = nx * D * D + ny * D + nz;\n if (O1[nx][ny][nz] && comp1[nidx] == -1) {\n comp1[nidx] = comps1.size();\n q.push(nidx);\n }\n }\n }\n comps1.push_back(cells);\n }\n }\n }\n }\n \n // Find connected components in O2\n vector comp2(D * D * D, -1);\n vector>> comps2;\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n int idx = x * D * D + y * D + z;\n if (O2[x][y][z] && comp2[idx] == -1) {\n vector> cells;\n queue q;\n q.push(idx);\n comp2[idx] = comps2.size();\n \n while (!q.empty()) {\n int cur = q.front(); q.pop();\n int cx = cur / (D * D);\n int cy = (cur / D) % D;\n int cz = cur % D;\n cells.emplace_back(cx, cy, cz);\n \n for (int d = 0; d < 6; d++) {\n int nx = cx + dx[d], ny = cy + dy[d], nz = cz + dz[d];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D || nz < 0 || nz >= D) continue;\n int nidx = nx * D * D + ny * D + nz;\n if (O2[nx][ny][nz] && comp2[nidx] == -1) {\n comp2[nidx] = comps2.size();\n q.push(nidx);\n }\n }\n }\n comps2.push_back(cells);\n }\n }\n }\n }\n \n // Normalize shape\n auto normalize = [&](const vector>& s) {\n if (s.empty()) return vector>();\n int minx = get<0>(s[0]), miny = get<1>(s[0]), minz = get<2>(s[0]);\n for (auto& p : s) {\n minx = min(minx, get<0>(p));\n miny = min(miny, get<1>(p));\n minz = min(minz, get<2>(p));\n }\n vector> ns;\n for (auto& p : s) {\n ns.emplace_back(get<0>(p)-minx, get<1>(p)-miny, get<2>(p)-minz);\n }\n sort(ns.begin(), ns.end());\n return ns;\n };\n \n // Check if two shapes match under rotation\n auto shapes_match = [&](const vector>& s1,\n const vector>& s2) -> bool {\n if (s1.size() != s2.size()) return false;\n if (s1.empty()) return true;\n \n vector> ns1 = normalize(s1);\n \n for (int axis = 0; axis < 3; axis++) {\n for (int layer = 0; layer < 4; layer++) {\n vector> ns2;\n for (auto& p : s2) {\n int x = get<0>(p), y = get<1>(p), z = get<2>(p);\n int nx, ny, nz;\n if (axis == 0) {\n if (layer == 0) { nx=x; ny=y; nz=z; }\n else if (layer == 1) { nx=x; ny=-z; nz=y; }\n else if (layer == 2) { nx=x; ny=-y; nz=-z; }\n else { nx=x; ny=z; nz=-y; }\n } else if (axis == 1) {\n if (layer == 0) { nx=x; ny=y; nz=z; }\n else if (layer == 1) { nx=z; ny=y; nz=-x; }\n else if (layer == 2) { nx=-x; ny=y; nz=-z; }\n else { nx=-z; ny=y; nz=x; }\n } else {\n if (layer == 0) { nx=x; ny=y; nz=z; }\n else if (layer == 1) { nx=-y; ny=x; nz=z; }\n else if (layer == 2) { nx=-x; ny=-y; nz=z; }\n else { nx=y; ny=-x; nz=z; }\n }\n ns2.emplace_back(nx, ny, nz);\n }\n ns2 = normalize(ns2);\n if (ns1 == ns2) return true;\n }\n }\n return false;\n };\n \n // Build lookup: for each comp1, find matching comp2\n vector match1(comps1.size(), -1), match2(comps2.size(), -1);\n \n for (int i = 0; i < (int)comps1.size(); i++) {\n for (int j = 0; j < (int)comps2.size(); j++) {\n if (match2[j] >= 0) continue;\n if (shapes_match(comps1[i], comps2[j])) {\n match1[i] = j;\n match2[j] = i;\n break;\n }\n }\n }\n \n // Build blocks: first merged (used in both), then unmerged from O1, then unmerged from O2\n vector>> blocks;\n vector block_idx1(comps1.size(), -1), block_idx2(comps2.size(), -1);\n int idx = 1;\n \n // Merged blocks\n for (int i = 0; i < (int)comps1.size(); i++) {\n if (match1[i] >= 0) {\n // Combine cells from both\n vector> merged = comps1[i];\n merged.insert(merged.end(), comps2[match1[i]].begin(), comps2[match1[i]].end());\n blocks.push_back(merged);\n block_idx1[i] = idx;\n block_idx2[match1[i]] = idx;\n idx++;\n }\n }\n \n // Unmerged from O1\n for (int i = 0; i < (int)comps1.size(); i++) {\n if (match1[i] < 0) {\n blocks.push_back(comps1[i]);\n block_idx1[i] = idx;\n idx++;\n }\n }\n \n // Unmerged from O2\n for (int j = 0; j < (int)comps2.size(); j++) {\n if (match2[j] < 0) {\n blocks.push_back(comps2[j]);\n block_idx2[j] = idx;\n idx++;\n }\n }\n \n int n = blocks.size();\n \n // Create idx arrays for output\n vector>> out1(D, vector>(D, vector(D, 0)));\n vector>> out2(D, vector>(D, vector(D, 0)));\n \n for (int i = 0; i < (int)comps1.size(); i++) {\n for (auto& p : comps1[i]) {\n int x, y, z;\n tie(x, y, z) = p;\n out1[x][y][z] = block_idx1[i];\n }\n }\n \n for (int j = 0; j < (int)comps2.size(); j++) {\n for (auto& p : comps2[j]) {\n int x, y, z;\n tie(x, y, z) = p;\n out2[x][y][z] = block_idx2[j];\n }\n }\n \n cout << n << \"\\n\";\n \n // Output b1\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O1[x][y][z]) cout << out1[x][y][z];\n else cout << 0;\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n // Output b2\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O2[x][y][z]) cout << out2[x][y][z];\n else cout << 0;\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n return 0;\n}","ahc020":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n long long w;\n int idx;\n};\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n r.assign(n, 0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nint N, M, K;\nvector> vertex; // (x,y)\nvector> resident; // (a,b)\nvector edges; // original order\nvector edgesSorted; // sorted by weight\nvector> dist2; // N x K\nvector>> cand; // per resident, stations within 5000, sorted\n\n// ---------------------------------------------------------------\n// price of a set 'sel' (sel[i]==1 <=> station i is reachable)\nconst long long INF = (1LL<<60);\n\nlong long price_of(const vector& sel) {\n // ----- edge cost (MST on induced subgraph) -----\n long long edgeCost = 0;\n DSU dsu(N);\n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v))\n edgeCost += e.w;\n }\n }\n\n // ----- radii -----\n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n bool ok = false;\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (sel[i]) {\n long long d2 = pr.second;\n if (maxDistSq[i] < d2) maxDistSq[i] = d2;\n ok = true;\n break; // nearest selected station\n }\n }\n if (!ok) return INF; // resident not covered\n }\n\n long long sumP2 = 0;\n for (int i = 0; i < N; ++i) {\n if (!sel[i]) continue;\n long long md2 = maxDistSq[i];\n long long P;\n if (md2 < 0) {\n P = 0;\n } else {\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n P = r;\n }\n sumP2 += P * P;\n }\n return edgeCost + sumP2;\n}\n\n// ---------------------------------------------------------------\n// MST edges for a given set, returns vector B (size M)\nvector mst_edges(const vector& sel) {\n vector B(M, 0);\n DSU dsu(N);\n int need = 0;\n for (int i = 0; i < N; ++i) if (sel[i]) ++need;\n if (need <= 1) return B;\n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v)) {\n B[e.idx] = 1;\n if (--need == 1) break;\n }\n }\n }\n return B;\n}\n\n// ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n // ----- read input -----\n if (!(cin >> N >> M >> K)) return 0;\n vertex.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> vertex[i].first >> vertex[i].second;\n }\n edges.resize(M);\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, j};\n }\n resident.resize(K);\n for (int k = 0; k < K; ++k) {\n cin >> resident[k].first >> resident[k].second;\n }\n\n // ----- preprocessing -----\n dist2.assign(N, vector(K, 0));\n const long long R2 = 5000LL * 5000LL;\n cand.assign(K, {});\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n long long dx = vertex[i].first - resident[k].first;\n long long dy = vertex[i].second - resident[k].second;\n long long d2 = dx*dx + dy*dy;\n dist2[i][k] = d2;\n if (d2 <= R2) cand[k].push_back({i, d2});\n }\n }\n for (int k = 0; k < K; ++k)\n sort(cand[k].begin(), cand[k].end(),\n [](const auto& a, const auto& b){ return a.second < b.second; });\n\n edgesSorted = edges;\n sort(edgesSorted.begin(), edgesSorted.end(),\n [](const Edge& a, const Edge& b){ return a.w < b.w; });\n\n // ----- initial solution (all vertices) -----\n vector sel(N, 1);\n sel[0] = 1; // station 1 is always reachable\n long long curCost = price_of(sel);\n\n // ---------- greedy removal ----------\n bool changed = true;\n while (changed) {\n changed = false;\n long long bestGain = 0;\n int bestV = -1;\n for (int v = 1; v < N; ++v) {\n if (!sel[v]) continue;\n // coverage test without v\n bool ok = true;\n for (int k = 0; k < K && ok; ++k) {\n bool any = false;\n for (auto &pr : cand[k]) {\n if (sel[pr.first] && pr.first != v) { any = true; break; }\n }\n if (!any) ok = false;\n }\n if (!ok) continue;\n\n sel[v] = 0;\n long long newCost = price_of(sel);\n sel[v] = 1;\n if (newCost < curCost && curCost - newCost > bestGain) {\n bestGain = curCost - newCost;\n bestV = v;\n }\n }\n if (bestV != -1) {\n sel[bestV] = 0;\n curCost -= bestGain;\n changed = true;\n }\n }\n\n // ---------- greedy addition ----------\n changed = true;\n while (changed) {\n changed = false;\n long long bestGain = 0;\n int bestV = -1;\n for (int v = 1; v < N; ++v) {\n if (sel[v]) continue;\n sel[v] = 1;\n long long newCost = price_of(sel);\n sel[v] = 0;\n if (newCost < curCost && curCost - newCost > bestGain) {\n bestGain = curCost - newCost;\n bestV = v;\n }\n }\n if (bestV != -1) {\n sel[bestV] = 1;\n curCost -= bestGain;\n changed = true;\n }\n }\n\n // ----- final radii (for output) -----\n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (sel[i]) {\n if (maxDistSq[i] < pr.second) maxDistSq[i] = pr.second;\n break; // nearest selected\n }\n }\n }\n vector P(N, 0);\n for (int i = 0; i < N; ++i) {\n if (!sel[i]) { P[i] = 0; continue; }\n long long md2 = maxDistSq[i];\n if (md2 < 0) { P[i] = 0; continue; }\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n P[i] = r;\n }\n\n // ----- edges that are ON -----\n vector B = mst_edges(sel);\n\n // ----- output -----\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << P[i];\n }\n cout << '\\n';\n for (int j = 0; j < M; ++j) {\n if (j) cout << ' ';\n cout << B[j];\n }\n cout << '\\n';\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconst int N = 30;\nconst int TOTAL = N * (N + 1) / 2;\n\n/* --------------------------------------------------------------- */\n/* data structures */\nstruct Op { int x1, y1, x2, y2; };\n\nint start_val[N][N];\n\n/* --------------------------------------------------------------- */\n/* auxiliary functions */\ninline bool inside(int x, int y) { return (0 <= x && x < N && 0 <= y && y <= x); }\n\ninline int child1_val(const int val[N][N], int x, int y) { return val[x + 1][y]; }\ninline int child2_val(const int val[N][N], int x, int y) { return val[x + 1][y + 1]; }\ninline int smaller_child_val(const int val[N][N], int x, int y) {\n return min(child1_val(val, x, y), child2_val(val, x, y));\n}\n\n/* --------------------------------------------------------------- */\n/* 1) bottom\u2011up heapify */\nvector build_bottom_up(const int src[N][N]) {\n int val[N][N];\n memcpy(val, src, sizeof(val));\n vector ops;\n\n auto do_swap = [&](int x1, int y1, int x2, int y2) {\n ops.push_back({x1, y1, x2, y2});\n swap(val[x1][y1], val[x2][y2]);\n };\n\n function sift_down = [&](int x, int y) {\n while (true) {\n if (x == N - 1) break;\n int c1v = val[x + 1][y];\n int c2v = val[x + 1][y + 1];\n int smaller_cx = c1v <= c2v ? x + 1 : x + 1;\n int smaller_cy = c1v <= c2v ? y : y + 1;\n int smaller_val = min(c1v, c2v);\n if (val[x][y] <= smaller_val) break;\n do_swap(x, y, smaller_cx, smaller_cy);\n x = smaller_cx; y = smaller_cy;\n }\n };\n\n for (int x = N - 2; x >= 0; --x)\n for (int y = 0; y <= x; ++y)\n sift_down(x, y);\n\n return ops;\n}\n\n/* --------------------------------------------------------------- */\n/* 2) hill climbing with focus on large misplaced elements */\nvector build_hill_climbing(const int src[N][N]) {\n int val[N][N];\n memcpy(val, src, sizeof(val));\n vector ops;\n const int MAX_OPS = 10000;\n\n auto do_swap = [&](int x1, int y1, int x2, int y2) -> bool {\n if ((int)ops.size() >= MAX_OPS) return false;\n ops.push_back({x1, y1, x2, y2});\n swap(val[x1][y1], val[x2][y2]);\n return true;\n };\n\n // Count violations at each node\n int violation_count[N][N] = {0};\n auto count_violations = [&](void) -> int {\n int total = 0;\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n if (val[x][y] > smaller_child_val(val, x, y))\n ++total;\n return total;\n };\n\n auto update_violations = [&](int px, int py) {\n for (int dx = -1; dx <= 1; ++dx)\n for (int dy = -1; dy <= 1; ++dy) {\n int nx = px + dx, ny = py + dy;\n if (!inside(nx, ny)) continue;\n bool was_viol = (nx < N - 1 && val[nx][ny] > smaller_child_val(val, nx, ny));\n violation_count[nx][ny] = was_viol ? 1 : 0;\n }\n };\n\n // Initialize violation counts\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n if (val[x][y] > smaller_child_val(val, x, y))\n violation_count[x][y] = 1;\n\n // Priority: (1) has violation, (2) node value (larger is better to move down)\n struct Candidate {\n int x, y; // parent position\n int child_cx, child_cy; // child to swap with\n int priority; // higher = better\n };\n\n auto get_best_swap = [&](void) -> Candidate {\n int best_priority = -1;\n Candidate best = {-1, -1, -1, -1, -1};\n \n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (x == N - 1) continue;\n if (val[x][y] <= smaller_child_val(val, x, y)) continue;\n \n int c1v = val[x + 1][y];\n int c2v = val[x + 1][y + 1];\n \n // Try swapping with the smaller child\n if (c1v < c2v && c1v < val[x][y]) {\n int priority = val[x][y] * 100 + (N - 1 - x); // value * 100 + depth\n if (priority > best_priority) {\n best_priority = priority;\n best = {x, y, x + 1, y, priority};\n }\n }\n if (c2v < c1v && c2v < val[x][y]) {\n int priority = val[x][y] * 100 + (N - 1 - x);\n if (priority > best_priority) {\n best_priority = priority;\n best = {x, y, x + 1, y + 1, priority};\n }\n }\n }\n }\n return best;\n };\n\n // Main hill climbing loop\n while (true) {\n Candidate c = get_best_swap();\n if (c.x == -1) break; // No more violations\n \n if (!do_swap(c.x, c.y, c.child_cx, c.child_cy)) break;\n \n // Update violations around affected positions\n update_violations(c.x, c.y);\n update_violations(c.child_cx, c.child_cy);\n }\n\n return ops;\n}\n\n/* --------------------------------------------------------------- */\n/* 3) improved greedy: prioritize large values at shallow depth */\nvector build_improved_greedy(const int src[N][N]) {\n int val[N][N];\n memcpy(val, src, sizeof(val));\n vector ops;\n const int MAX_OPS = 10000;\n\n bool in_queue[N][N] = {false};\n struct Node {\n int score; // higher = more important to fix\n int x, y;\n bool operator<(Node const& other) const {\n return score < other.score; // max-heap\n }\n };\n priority_queue pq;\n\n auto push_if_viol = [&](int x, int y) {\n if (x >= N - 1) return;\n int smaller = smaller_child_val(val, x, y);\n if (val[x][y] > smaller) {\n // Score = value * depth_factor + violation_size\n int depth = N - 1 - x;\n int violation_size = val[x][y] - smaller;\n int score = val[x][y] * 50 + violation_size * 10 + depth;\n pq.push({score, x, y});\n in_queue[x][y] = true;\n }\n };\n\n // Initial scan\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n push_if_viol(x, y);\n\n auto do_swap = [&](int x1, int y1, int x2, int y2) -> bool {\n if ((int)ops.size() >= MAX_OPS) return false;\n ops.push_back({x1, y1, x2, y2});\n swap(val[x1][y1], val[x2][y2]);\n return true;\n };\n\n while (!pq.empty() && (int)ops.size() < MAX_OPS) {\n Node cur = pq.top(); pq.pop();\n int x = cur.x, y = cur.y;\n if (!in_queue[x][y]) continue;\n \n // Re-check if still a violation\n if (x >= N - 1) { in_queue[x][y] = false; continue; }\n int smaller = smaller_child_val(val, x, y);\n if (val[x][y] <= smaller) { in_queue[x][y] = false; continue; }\n \n // Choose the child with smaller value\n int c1v = val[x + 1][y];\n int c2v = val[x + 1][y + 1];\n int cx = x + 1, cy = y;\n if (c2v < c1v) cy = y + 1;\n \n if (!do_swap(x, y, cx, cy)) break;\n in_queue[x][y] = false;\n\n // Mark affected positions for re-evaluation\n auto try_push = [&](int px, int py) {\n if (inside(px, py) && !in_queue[px][py])\n push_if_viol(px, py);\n };\n\n // Parent position\n try_push(x, y);\n // Child position\n try_push(cx, cy);\n // Other parent of child\n if (cy == y) { // left child\n if (y > 0) try_push(x, y - 1);\n } else { // right child\n if (y + 1 <= x) try_push(x, y + 1);\n }\n // Other parent of parent\n if (x > 0) {\n if (y > 0) try_push(x - 1, y - 1);\n if (y <= x - 1) try_push(x - 1, y);\n }\n }\n\n return ops;\n}\n\n/* --------------------------------------------------------------- */\n/* verify heap */\nbool is_heap(const int v[N][N]) {\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n if (v[x][y] > smaller_child_val(v, x, y))\n return false;\n return true;\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n for (int x = 0; x < N; ++x)\n for (int y = 0; y <= x; ++y)\n cin >> start_val[x][y];\n\n vector best_ops;\n int best_size = INT_MAX;\n\n // Try all methods and keep the smallest valid one\n vector> candidates = {\n build_bottom_up(start_val),\n build_hill_climbing(start_val),\n build_improved_greedy(start_val)\n };\n\n for (auto& ops : candidates) {\n int cur[N][N];\n memcpy(cur, start_val, sizeof(cur));\n for (auto const& op : ops)\n swap(cur[op.x1][op.y1], cur[op.x2][op.y2]);\n \n if (is_heap(cur) && (int)ops.size() <= 10000 && (int)ops.size() < best_size) {\n best_ops = ops;\n best_size = ops.size();\n }\n }\n\n cout << best_ops.size() << '\\n';\n for (auto const& op : best_ops)\n cout << op.x1 << ' ' << op.y1 << ' ' << op.x2 << ' ' << op.y2 << '\\n';\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int D, N;\n if (!(cin >> D >> N)) return 0;\n bool obstacle[9][9] = {};\n\n for (int k = 0; k < N; ++k) {\n int ri, rj; cin >> ri >> rj;\n obstacle[ri][rj] = true;\n }\n\n const int er = 0, ec = (D - 1) / 2;\n const int ENTRANCE_ID = D * D;\n const int TOTAL_NODES = D * D + 1;\n\n // BFS distances (ignoring containers)\n int dist[9][9];\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n dist[i][j] = -1;\n\n queue> q;\n dist[er][ec] = 0;\n q.emplace(er, ec);\n const int dr[4] = {-1,1,0,0};\n const int dc[4] = {0,0,-1,1};\n\n while (!q.empty()) {\n auto [r,c] = q.front(); q.pop();\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (dist[nr][nc] == -1) {\n dist[nr][nc] = dist[r][c] + 1;\n q.emplace(nr,nc);\n }\n }\n }\n\n // List of squares that may contain containers\n vector cells;\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n if (!obstacle[i][j] && !(i == er && j == ec))\n cells.push_back(i * D + j);\n\n const int M = (int)cells.size();\n\n // Sorted list of distances (the \"ideal\" distances)\n vector sortedDist;\n sortedDist.reserve(M);\n for (int id : cells) sortedDist.push_back(dist[id / D][id % D]);\n sort(sortedDist.begin(), sortedDist.end());\n\n // Occupied squares and assigned containers\n vector occupied(TOTAL_NODES, 0);\n vector assigned(M, -1);\n\n // ---------- data for articulation point search ----------\n auto buildNeighbours = [&](int node, vector& out) {\n out.clear();\n if (node == ENTRANCE_ID) {\n int r = er, c = ec;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (occupied[nr * D + nc]) continue; // Skip occupied squares\n int nid = nr * D + nc;\n out.push_back(nid);\n }\n } else {\n int r = node / D, c = node % D;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (occupied[nr * D + nc]) continue; // Skip occupied squares\n if (nr == er && nc == ec) out.push_back(ENTRANCE_ID);\n else out.push_back(nr * D + nc);\n }\n }\n };\n\n vector disc(TOTAL_NODES), low(TOTAL_NODES);\n vector visited(TOTAL_NODES, 0), isArt(TOTAL_NODES, 0);\n int timer = 0;\n\n function dfs = [&](int u, int parent) {\n visited[u] = 1;\n disc[u] = low[u] = ++timer;\n int children = 0;\n vector neigh;\n buildNeighbours(u, neigh);\n for (int v : neigh) {\n if (!visited[v]) {\n ++children;\n dfs(v, u);\n low[u] = min(low[u], low[v]);\n if (parent != -1 && low[v] >= disc[u]) isArt[u] = 1;\n } else if (v != parent) {\n low[u] = min(low[u], disc[v]);\n }\n }\n if (parent == -1 && children > 1) isArt[u] = 1;\n };\n\n auto getRemovable = [&]() -> vector {\n fill(visited.begin(), visited.end(), 0);\n fill(disc.begin(), disc.end(), 0);\n fill(low.begin(), low.end(), 0);\n fill(isArt.begin(), isArt.end(), 0);\n timer = 0;\n dfs(ENTRANCE_ID, -1);\n vector removable;\n for (int id : cells) {\n if (occupied[id]) continue; // Skip already occupied\n if (!isArt[id]) removable.push_back(id);\n }\n return removable;\n };\n\n // ---------- online placement ----------\n for (int step = 0; step < M; ++step) {\n int t; cin >> t;\n int targetDist = sortedDist[t];\n vector cand = getRemovable();\n int best = -1, bestDiff = INT_MAX, bestDist = -1;\n for (int id : cand) {\n int d = dist[id / D][id % D];\n int diff = abs(d - targetDist);\n if (diff < bestDiff || (diff == bestDiff && d > bestDist)) {\n bestDiff = diff;\n bestDist = d;\n best = id;\n }\n }\n // Safety: if no removable square found, pick any empty square\n if (best == -1) {\n for (int id : cells) if (!occupied[id]) { best = id; break; }\n }\n occupied[best] = 1;\n assigned[t] = best;\n cout << (best / D) << ' ' << (best % D) << \"\\n\" << flush;\n }\n\n // ---------- removal order (greedy, smallest reachable) ----------\n vector removalOrder;\n removalOrder.reserve(M);\n vector removed(M, 0);\n vector emptySquare(TOTAL_NODES, 0);\n emptySquare[ENTRANCE_ID] = 1; // entrance is empty\n\n for (int step = 0; step < M; ++step) {\n int chosen = -1;\n for (int num = 0; num < M; ++num) if (!removed[num]) {\n int id = assigned[num];\n int r = id / D, c = id % D;\n bool ok = false;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n int nid = (nr == er && nc == ec) ? ENTRANCE_ID : nr * D + nc;\n if (emptySquare[nid]) { ok = true; break; }\n }\n if (ok) { chosen = num; break; }\n }\n // Must exist\n removalOrder.push_back(chosen);\n removed[chosen] = 1;\n int id = assigned[chosen];\n emptySquare[id] = 1;\n }\n\n // ---------- output removal order ----------\n for (int num : removalOrder) {\n int id = assigned[num];\n cout << (id / D) << ' ' << (id % D) << \"\\n\" << flush;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> a(n, vector(n));\n for (int i = 0; i < n; ++i)\n for (int j = 0; j < n; ++j)\n cin >> a[i][j];\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << a[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nusing ll = long long;\nconst ll INF = (ll)4e18;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, D, Q;\n if (!(cin >> N >> D >> Q)) return 0;\n\n // ---------- 1. create list of all unordered pairs ----------\n vector> allPairs;\n allPairs.reserve(N*(N-1)/2);\n for (int i = 0; i < N; ++i)\n for (int j = i+1; j < N; ++j)\n allPairs.emplace_back(i,j);\n // random shuffle \u2013 we do not need a truly strong RNG\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n shuffle(allPairs.begin(), allPairs.end(), rng);\n\n // ---------- 2. answer Q questions ----------\n // direction cache: key = (min<<32) | max value: 1 = leftright, 0 = equal\n unordered_map dir;\n dir.reserve(Q*2);\n vector> adj(N);\n vector indeg(N,0);\n vector heavierCnt(N,0); // how many items are known heavier than this one\n size_t pairIdx = 0;\n for (int q = 0; q < Q; ++q) {\n pair p;\n if (pairIdx < allPairs.size())\n p = allPairs[pairIdx++];\n else\n p = {0,1}; // dummy pair, result will be ignored later\n\n cout << 1 << ' ' << 1 << ' ' << p.first << ' ' << p.second << '\\n' << std::flush;\n\n char c; cin >> c; // '<' , '>' or '='\n\n long long key = ( ( (long long)min(p.first,p.second) ) << 32 )\n | (long long)max(p.first,p.second);\n if (dir.find(key) != dir.end()) continue; // already known, ignore duplicate\n dir[key] = (c=='<') ? 1 : (c=='>') ? -1 : 0;\n\n if (c == '<') {\n int light = p.first, heavy = p.second;\n adj[light].push_back(heavy);\n ++indeg[heavy];\n ++heavierCnt[heavy];\n } else if (c == '>') {\n int light = p.second, heavy = p.first;\n adj[light].push_back(heavy);\n ++indeg[heavy];\n ++heavierCnt[heavy];\n } // '=' : nothing to store\n }\n\n // ---------- 3. topological order (light -> heavy) ----------\n vector indeg_cur = indeg;\n queue q0;\n for (int i = 0; i < N; ++i)\n if (indeg_cur[i] == 0) q0.push(i);\n vector topo;\n topo.reserve(N);\n while (!q0.empty()) {\n int v = q0.front(); q0.pop();\n topo.push_back(v);\n for (int to : adj[v]) {\n if (--indeg_cur[to] == 0) q0.push(to);\n }\n }\n // In the (unlikely) case of a cycle we just append remaining vertices\n if ((int)topo.size() < N) {\n vector rest;\n for (int i = 0; i < N; ++i)\n if (find(topo.begin(), topo.end(), i) == topo.end()) rest.push_back(i);\n topo.insert(topo.end(), rest.begin(), rest.end());\n }\n\n // ---------- 4. proxy weights (position + 1) ----------\n vector weight(N);\n for (int pos = 0; pos < N; ++pos) {\n int item = topo[pos];\n weight[item] = (ll)pos + 1; // 1 \u2026 N\n }\n\n // ---------- 5. DP for contiguous blocks ----------\n // prefix sums of weight in topological order\n vector pref(N+1,0);\n for (int i = 0; i < N; ++i) pref[i+1] = pref[i] + weight[topo[i]];\n\n vector> dp(D+1, vector(N+1, INF));\n vector> split(D+1, vector(N+1, -1));\n dp[0][0] = 0;\n for (int g = 1; g <= D; ++g) {\n for (int i = g; i <= N; ++i) { // we need at least g items for g groups\n ll best = INF;\n int bestj = -1;\n for (int j = g-1; j < i; ++j) {\n ll sum = pref[i] - pref[j];\n ll cand = dp[g-1][j] + sum*sum;\n if (cand < best) {\n best = cand;\n bestj = j;\n }\n }\n dp[g][i] = best;\n split[g][i] = bestj;\n }\n }\n\n // ---------- 6. reconstruct groups ----------\n vector groupOfPos(N, -1); // position in topo -> group id\n int curIdx = N;\n for (int g = D; g >= 1; --g) {\n int j = split[g][curIdx];\n for (int k = j; k < curIdx; ++k) groupOfPos[k] = g-1;\n curIdx = j;\n }\n\n // translate back to original item indices\n vector answer(N, -1);\n for (int pos = 0; pos < N; ++pos) {\n int item = topo[pos];\n answer[item] = groupOfPos[pos];\n }\n\n // ---------- 7. output ----------\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << answer[i];\n }\n cout << '\\n';\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n const int per = n / m;\n vector> st(m);\n vector> pos(n + 1);\n \n for (int i = 0; i < m; ++i) {\n st[i].reserve(per);\n for (int j = 0; j < per; ++j) {\n int x; cin >> x;\n st[i].push_back(x);\n pos[x] = {i, (int)st[i].size() - 1};\n }\n }\n\n vector> ops;\n \n for (int v = 1; v <= n; ++v) {\n int s = pos[v].first;\n \n // Move all boxes above v together in ONE operation\n while (!st[s].empty() && st[s].back() != v) {\n int posV = pos[v].second;\n int numAbove = st[s].size() - posV - 1;\n \n if (numAbove == 0) break;\n \n // The box just above v (lowest in the suffix)\n int boxToMove = st[s][posV + 1];\n \n // Choose destination: prefer stack with LARGEST top > boxToMove\n int dest = -1;\n int bestTop = -1; // Changed: prefer LARGEST top\n \n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty()) {\n int top = st[i].back();\n if (top > boxToMove && top > bestTop) {\n bestTop = top;\n dest = i;\n }\n }\n }\n \n // Fallback: empty stack\n if (dest == -1) {\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (st[i].empty()) {\n dest = i;\n break;\n }\n }\n }\n \n // Fallback: any stack with largest top\n if (dest == -1) {\n int maxTop = -1;\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty() && st[i].back() > maxTop) {\n maxTop = st[i].back();\n dest = i;\n }\n }\n }\n \n if (dest == -1) dest = s;\n \n // Perform move operation\n ops.emplace_back(boxToMove, dest + 1);\n \n // Update stacks\n int oldSize = st[s].size();\n st[s].resize(posV + 1);\n for (int i = posV + 1; i < oldSize; ++i) {\n int box = st[s][i];\n st[dest].push_back(box);\n pos[box] = {dest, (int)st[dest].size() - 1};\n }\n pos[v] = {s, (int)st[s].size() - 1};\n }\n \n // Carry out v\n ops.emplace_back(v, 0);\n if (!st[s].empty() && st[s].back() == v) {\n st[s].pop_back();\n }\n }\n \n for (auto &p : ops) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n \n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) { p.resize(n); r.assign(n, 0); iota(p.begin(), p.end(), 0); }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n if (!(cin >> N)) return 0;\n const int M = N * N;\n vector h(N - 1), v(N);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n for (int i = 0; i < N; ++i) cin >> v[i];\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> d[i][j];\n\n auto id = [&](int i, int j) { return i * N + j; };\n auto coord = [&](int id_) { return pair(id_/N, id_%N); };\n\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n auto opposite = [&](char c)->char{\n if (c=='U') return 'D';\n if (c=='D') return 'U';\n if (c=='L') return 'R';\n return 'L';\n };\n\n auto moveChar = [&](int from, int to)->char{\n auto [fi,fj] = coord(from);\n auto [ti,tj] = coord(to);\n if (ti == fi+1) return 'D';\n if (ti == fi-1) return 'U';\n if (tj == fj+1) return 'R';\n return 'L'; // tj == fj-1\n };\n\n /* ---------- 1. build list of usable edges ---------- */\n struct Edge {int u,v,w;};\n vector edges;\n edges.reserve(5000);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i,j);\n // down\n if (i+1 < N && h[i][j] == '0') {\n int v = id(i+1,j);\n edges.push_back({u,v, d[i][j] + d[i+1][j]});\n }\n // right\n if (j+1 < N && v[i][j] == '0') {\n int v = id(i,j+1);\n edges.push_back({u,v, d[i][j] + d[i][j+1]});\n }\n }\n }\n\n /* ---------- 2. maximum spanning tree (Kruskal) ---------- */\n sort(edges.begin(), edges.end(),\n [](const Edge& a, const Edge& b){ return a.w > b.w; });\n DSU dsu(M);\n vector> treeAdj(M);\n int added = 0;\n for (auto &e: edges) {\n if (dsu.unite(e.u, e.v)) {\n treeAdj[e.u].push_back(e.v);\n treeAdj[e.v].push_back(e.u);\n ++added;\n if (added == M-1) break;\n }\n }\n\n /* ---------- 3. covering walk (DFS on the tree) ---------- */\n const int root = id(0,0);\n vector coverMoves;\n coverMoves.reserve(2*(M-1));\n\n function dfs = [&](int v, int p) {\n for (int to: treeAdj[v]) if (to != p) {\n coverMoves.push_back(moveChar(v,to));\n dfs(to, v);\n coverMoves.push_back(moveChar(to,v));\n }\n };\n dfs(root, -1);\n int coverLen = (int)coverMoves.size(); // = 2\u00b7(M\u20111)\n\n /* ---------- 4. BFS from (0,0) on the original grid ---------- */\n const int INF = 1e9;\n vector dist(M, INF), parent(M, -1);\n vector parDir(M); // direction from parent to this node\n queue q;\n dist[root] = 0;\n q.push(root);\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n auto [ci,cj] = coord(cur);\n for (int dir = 0; dir < 4; ++dir) {\n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n // check wall\n if (dir == 0 && h[ci][cj] == '1') continue; // up\n if (dir == 1 && (ci+1 < N && h[ci][cj] == '1')) continue; // down\n if (dir == 2 && v[ci][cj-1] == '1') continue; // left (j-1 valid because j>=1)\n if (dir == 3 && v[ci][cj] == '1') continue; // right\n int nb = id(ni,nj);\n if (dist[nb] == INF) {\n dist[nb] = dist[cur] + 1;\n parent[nb] = cur;\n parDir[nb] = dirChar[dir];\n q.push(nb);\n }\n }\n }\n\n /* ---------- 5. best adjacent pair ---------- */\n int bestU = -1, bestV = -1;\n int bestSum = -1;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i,j);\n // down neighbour\n if (i+1 < N && h[i][j] == '0') {\n int v = id(i+1,j);\n int s = d[i][j] + d[i+1][j];\n if (s > bestSum) { bestSum = s; bestU = u; bestV = v; }\n }\n // right neighbour\n if (j+1 < N && v[i][j] == '0') {\n int v = id(i,j+1);\n int s = d[i][j] + d[i][j+1];\n if (s > bestSum) { bestSum = s; bestU = u; bestV = v; }\n }\n }\n }\n\n // choose the endpoint of the best pair that is closer to (0,0)\n int s = (dist[bestU] <= dist[bestV]) ? bestU : bestV;\n int t = (s == bestU) ? bestV : bestU;\n int distS = dist[s];\n\n /* ---------- 6. how many bounce cycles are possible ---------- */\n const int LMAX = 100000;\n long long remain = LMAX - coverLen - 2LL * distS;\n if (remain < 0) remain = 0;\n int k = (int)(remain / 2); // number of full back\u2011and\u2011forth cycles\n\n /* ---------- 7. build the whole route ---------- */\n string answer;\n answer.reserve(LMAX);\n // covering walk\n answer.append(coverMoves.begin(), coverMoves.end());\n\n // path from (0,0) to s\n vector pathToS;\n {\n int cur = s;\n while (cur != root) {\n char d = parDir[cur]; // direction parent -> cur\n pathToS.push_back(opposite(d));\n cur = parent[cur];\n }\n reverse(pathToS.begin(), pathToS.end());\n answer.append(pathToS.begin(), pathToS.end());\n }\n\n // bounce between s and t\n char dirST = moveChar(s, t);\n char dirTS = opposite(dirST);\n for (int i = 0; i < k; ++i) {\n answer.push_back(dirST);\n answer.push_back(dirTS);\n }\n\n // path back from s to (0,0)\n {\n int cur = s;\n while (cur != root) {\n char d = parDir[cur];\n answer.push_back(opposite(d));\n cur = parent[cur];\n }\n }\n\n // safety \u2013 should never happen\n if ((int)answer.size() > LMAX) answer.resize(LMAX);\n\n cout << answer << '\\n';\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nconst int INF = 1e9;\n\n/* ---------- overlap of two words (both length 5) ---------- */\nint overlap(const string &a, const string &b) {\n // longest k (0..4) such that suffix of a (len k) == prefix of b (len k)\n int maxk = min(4, (int)b.size());\n for (int k = maxk; k >= 0; --k) {\n bool ok = true;\n for (int i = 0; i < k; ++i) {\n if (a[a.size() - k + i] != b[i]) { ok = false; break; }\n }\n if (ok) return k;\n }\n return 0;\n}\n\n/* --------------------- main --------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n if (!(cin >> N >> M)) return 0;\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 word(M);\n for (int i = 0; i < M; ++i) cin >> word[i];\n\n const int V = N * N; // 225\n // position list for each letter\n vector> cells(V);\n vector> pos(26);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int id = i * N + j;\n cells[id] = {i, j};\n int c = grid[i][j] - 'A';\n pos[c].push_back(id);\n }\n\n // Manhattan distance between any two squares\n vector> dist(V, vector(V));\n for (int i = 0; i < V; ++i) {\n auto [xi, yi] = cells[i];\n for (int j = 0; j < V; ++j) {\n auto [xj, yj] = cells[j];\n dist[i][j] = abs(xi - xj) + abs(yi - yj);\n }\n }\n\n int startIdx = si * N + sj;\n\n /* ---- build a short super\u2011string (try all start words) ---- */\n string bestSuper;\n int bestLen = INT_MAX;\n for (int start = 0; start < M; ++start) {\n vector used(M, false);\n string cur = word[start];\n used[start] = true;\n while (true) {\n int bestIdx = -1;\n bool bestDir = false; // false = append, true = prepend\n int bestAdd = 1000;\n int bestOv = 0;\n for (int i = 0; i < M; ++i) if (!used[i]) {\n const string &s = word[i];\n // try append\n int ov = overlap(cur, s);\n int add = 5 - ov;\n if (add < bestAdd || (add == bestAdd && ov > bestOv)) {\n bestAdd = add; bestIdx = i; bestDir = false; bestOv = ov;\n }\n // try prepend\n int ov2 = overlap(s, cur);\n int add2 = 5 - ov2;\n if (add2 < bestAdd || (add2 == bestAdd && ov2 > bestOv)) {\n bestAdd = add2; bestIdx = i; bestDir = true; bestOv = ov2;\n }\n }\n if (bestIdx == -1) break;\n const string &s = word[bestIdx];\n if (!bestDir) cur += s.substr(bestOv);\n else cur = s + cur.substr(bestOv);\n used[bestIdx] = true;\n }\n if ((int)cur.size() < bestLen) {\n bestLen = cur.size();\n bestSuper = cur;\n }\n }\n\n const string &S = bestSuper; // final super\u2011string\n const int L = (int)S.size();\n\n /* ---- DP for optimal finger walk ---- */\n vector dpPrev(V, INF), dpCurr(V, INF);\n // predecessor matrix: (step, square) \u2192 previous square (short, -1 = none)\n vector pred(L * V, -1);\n auto setPred = [&](int step, int p, short prev) {\n pred[step * V + p] = prev;\n };\n auto getPred = [&](int step, int p) -> short {\n return pred[step * V + p];\n };\n\n // first character\n int firstChar = S[0] - 'A';\n vector activePrev;\n for (int p : pos[firstChar]) {\n int d = dist[startIdx][p];\n dpPrev[p] = d + 1; // distance + typing cost\n setPred(0, p, -1);\n activePrev.push_back(p);\n }\n\n // following characters\n for (int i = 1; i < L; ++i) {\n vector activeCurr;\n int ch = S[i] - 'A';\n for (int p : pos[ch]) {\n int best = INF;\n short bestPrev = -1;\n for (int q : activePrev) {\n int cand = dpPrev[q] + dist[q][p] + 1;\n if (cand < best) {\n best = cand;\n bestPrev = (short)q;\n }\n }\n if (best != INF) {\n dpCurr[p] = best;\n setPred(i, p, bestPrev);\n activeCurr.push_back(p);\n }\n }\n // prepare for next step\n fill(dpPrev.begin(), dpPrev.end(), INF);\n dpPrev.swap(dpCurr);\n fill(dpCurr.begin(), dpCurr.end(), INF);\n activePrev = move(activeCurr);\n }\n\n // find the best final square\n int minCost = INF;\n int lastPos = -1;\n for (int p = 0; p < V; ++p) {\n if (dpPrev[p] < minCost) {\n minCost = dpPrev[p];\n lastPos = p;\n }\n }\n\n // reconstruct the whole walk\n vector path(L);\n int cur = lastPos;\n for (int i = L - 1; i >= 0; --i) {\n path[i] = cur;\n cur = getPred(i, cur);\n }\n\n // output the coordinates\n for (int idx : path) {\n int ii = idx / N;\n int jj = idx % N;\n cout << ii << ' ' << jj << '\\n';\n }\n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\n\nstatic vector solve_wls(\n const vector>& queries,\n const vector& weight,\n const vector& z,\n int V)\n{\n Eigen::MatrixXd L = Eigen::MatrixXd::Zero(V, V);\n Eigen::VectorXd r = Eigen::VectorXd::Zero(V);\n\n int Q = queries.size();\n for (int q = 0; q < Q; ++q) {\n double w = weight[q];\n const auto& cells = queries[q];\n for (int i : cells) {\n L(i, i) += w;\n r(i) += w * z[q];\n }\n for (size_t a = 0; a < cells.size(); ++a) {\n for (size_t b = a + 1; b < cells.size(); ++b) {\n L(cells[a], cells[b]) += w;\n L(cells[b], cells[a]) += w;\n }\n }\n }\n L += 1e-6 * Eigen::MatrixXd::Identity(V, V);\n Eigen::VectorXd t = L.ldlt().solve(r);\n vector res(V);\n for (int i = 0; i < V; ++i)\n res[i] = max(0.0, min(1.0, t(i)));\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n if (!(cin >> N >> M >> eps)) return 0;\n const int V = N * N;\n\n for (int k = 0; k < M; ++k) {\n int d; cin >> d;\n for (int i = 0; i < d; ++i) {\n int a, b; cin >> a >> b;\n }\n }\n\n const int Q = V - 20; // Leave room for 20 drills\n const double epsFactor = 1.0 - 2.0 * eps;\n\n vector> queries(Q);\n vector weight(Q);\n vector z_val(Q);\n vector> cell_to_queries(V);\n\n mt19937 rng(123456789);\n\n for (int qq = 0; qq < Q; ++qq) {\n vector idxs;\n idxs.reserve(V);\n for (int i = 0; i < V; ++i) if (rng() & 1) idxs.push_back(i);\n if (idxs.size() < 2) {\n if (idxs.empty()) { idxs.push_back(0); idxs.push_back(1); }\n else idxs.push_back((idxs[0] + 1) % V);\n }\n\n queries[qq] = idxs;\n for (int id : idxs) cell_to_queries[id].push_back(qq);\n\n cout << \"q \" << idxs.size();\n for (int id : idxs) cout << ' ' << id / N << ' ' << id % N;\n cout << \"\\n\";\n cout.flush();\n\n int y; cin >> y;\n double k = (double)idxs.size();\n double z = ((double)y - eps * k) / epsFactor;\n z_val[qq] = z;\n double var = k * eps * (1.0 - eps) / (epsFactor * epsFactor);\n weight[qq] = 1.0 / var;\n }\n\n // Solve full system\n vector t_full = solve_wls(queries, weight, z_val, V);\n\n // Track drilled cells\n vector drilled(V, 0);\n vector oil_val(V, 0);\n\n // Drill top 20 high-probability cells\n int D = 20;\n vector> cells_by_prob;\n for (int i = 0; i < V; ++i)\n cells_by_prob.emplace_back(t_full[i], i);\n sort(cells_by_prob.begin(), cells_by_prob.end(), greater<>());\n\n for (int i = 0; i < D; ++i) {\n int cell = cells_by_prob[i].second;\n cout << \"q 1 \" << cell / N << ' ' << cell % N << \"\\n\";\n cout.flush();\n int val; cin >> val;\n drilled[cell] = 1;\n oil_val[cell] = val;\n }\n\n // Build reduced system\n vector unknown_ids;\n vector orig_to_new(V, -1);\n for (int i = 0; i < V; ++i) {\n if (!drilled[i]) {\n orig_to_new[i] = (int)unknown_ids.size();\n unknown_ids.push_back(i);\n }\n }\n int V2 = (int)unknown_ids.size();\n\n vector> unknown_queries(Q);\n vector adj_z(Q, 0.0);\n for (int q = 0; q < Q; ++q) {\n double known_sum = 0.0;\n for (int id : queries[q]) {\n if (drilled[id]) known_sum += oil_val[id];\n }\n adj_z[q] = z_val[q] - known_sum;\n for (int id : queries[q]) {\n if (!drilled[id]) unknown_queries[q].push_back(orig_to_new[id]);\n }\n }\n\n vector> unknown_cell_to_queries(V2);\n for (int q = 0; q < Q; ++q) {\n for (int new_id : unknown_queries[q])\n unknown_cell_to_queries[new_id].push_back(q);\n }\n\n // Solve reduced system\n vector t_unknown = solve_wls(unknown_queries, weight, adj_z, V2);\n\n // Order unknown cells by decreasing t\n vector order_unknown(V2);\n iota(order_unknown.begin(), order_unknown.end(), 0);\n sort(order_unknown.begin(), order_unknown.end(),\n [&](int a, int b){ return t_unknown[a] > t_unknown[b]; });\n\n // Estimate K from sum of t values\n double sum_t = 0.0;\n for (double v : t_unknown) sum_t += v;\n int K_sum = max(0, min(V2, (int)round(sum_t)));\n\n // Estimate K from the observation: E[adj_z] = true_sum / query_size avg\n // For each query, adj_z is approximately the number of oil cells in that query\n double total_z = 0.0;\n int valid_queries = 0;\n for (int q = 0; q < Q; ++q) {\n if (!unknown_queries[q].empty()) {\n total_z += adj_z[q];\n valid_queries++;\n }\n }\n double avg_oil_per_cell = total_z / max(1, valid_queries);\n int K_z = max(0, min(V2, (int)round(avg_oil_per_cell * (double)V2 / (double)Q)));\n\n // Use residual minimization for small range around candidates\n vector pred_sum(Q, 0.0);\n double cur_err = 0.0;\n for (int q = 0; q < Q; ++q) {\n if (!unknown_queries[q].empty()) {\n double diff = -adj_z[q];\n cur_err += weight[q] * diff * diff;\n }\n }\n\n // Search K from max(K_sum, K_z) - 10 to max(K_sum, K_z) + 10\n int K_start = max(0, max(K_sum, K_z) - 10);\n int K_end = min(V2, max(K_sum, K_z) + 10);\n\n double best_err = cur_err;\n int best_K = 0;\n int reached_K = K_start;\n\n // First pass: compute errors for all K\n for (int K = 1; K <= V2; ++K) {\n int cell = order_unknown[K-1];\n for (int q : unknown_cell_to_queries[cell]) {\n if (q < Q && !unknown_queries[q].empty()) {\n double old_diff = pred_sum[q] - adj_z[q];\n pred_sum[q] += 1.0;\n double new_diff = pred_sum[q] - adj_z[q];\n cur_err += weight[q] * (new_diff * new_diff - old_diff * old_diff);\n }\n }\n if (K >= K_start && K <= K_end && cur_err < best_err) {\n best_err = cur_err;\n best_K = K;\n }\n }\n\n // If best_K is 0, use K_sum\n if (best_K == 0) best_K = max(1, K_sum);\n\n // First guess\n vector answer;\n for (int i = 0; i < V; ++i)\n if (drilled[i] && oil_val[i] > 0) answer.push_back(i);\n for (int i = 0; i < best_K; ++i)\n answer.push_back(unknown_ids[order_unknown[i]]);\n\n cout << \"a \" << answer.size();\n for (int id : answer) cout << ' ' << id / N << ' ' << id % N;\n cout << \"\\n\";\n cout.flush();\n\n int ok; cin >> ok;\n if (ok == 1) return 0;\n\n // Fallback: drill all remaining and answer\n for (int i = 0; i < V; ++i) {\n if (!drilled[i]) {\n cout << \"q 1 \" << i / N << ' ' << i % N << \"\\n\";\n cout.flush();\n int val; cin >> val;\n drilled[i] = 1;\n oil_val[i] = val;\n }\n }\n\n answer.clear();\n for (int i = 0; i < V; ++i)\n if (oil_val[i] > 0) answer.push_back(i);\n\n cout << \"a \" << answer.size();\n for (int id : answer) cout << ' ' << id / N << ' ' << id % N;\n cout << \"\\n\";\n cout.flush();\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nconst int W_fixed = 1000; // the problem always uses W = 1000\n\nstruct Rect {\n int x, y, w, h; // left\u2011bottom corner (x,y), size w \u00d7 h\n};\n\nint W; // actual W (will be 1000)\n\n/*---------------------------------------------------------------*/\n/* add a new free rectangle, removing any that it contains */\nvoid addFreeRect(vector& L, const Rect& r) {\n if (r.w <= 0 || r.h <= 0) return;\n for (const Rect& f : L) {\n if (f.x <= r.x && f.y <= r.y &&\n f.x + f.w >= r.x + r.w &&\n f.y + f.h >= r.y + r.h)\n return; // r is already contained\n }\n vector nxt;\n for (const Rect& f : L) {\n if (!(r.x <= f.x && r.y <= f.y &&\n r.x + r.w >= f.x + f.w &&\n r.y + r.h >= f.y + f.h))\n nxt.push_back(f); // f is not inside r\n }\n nxt.push_back(r);\n L.swap(nxt);\n}\n\n/*---------------------------------------------------------------*/\n/* minimal rectangle (w,h) for a demand a */\nvoid minimalRect(int a, int& w, int& h) {\n int bestW = W, bestH = W, bestArea = W * W, bestMax = W;\n for (int hi = 1; hi <= W; ++hi) {\n int wi = (a + hi - 1) / hi; // ceil(a/hi)\n if (wi > W) continue;\n int area = wi * hi;\n int mx = max(wi, hi);\n if (area < bestArea || (area == bestArea && mx < bestMax)) {\n bestArea = area;\n bestW = wi;\n bestH = hi;\n bestMax = mx;\n }\n }\n w = bestW; h = bestH;\n}\n\n/*---------------------------------------------------------------*/\n/* pack all reservations of one day.\n initialFree : free rectangles from previous day\n items : reservation rectangles (id , w , h)\n placed : output \u2013 rectangle for each reservation id\n freeOut : free rectangles after placing (empty rooms)\n*/\nvoid pack_day(const vector& initialFree,\n const vector>& items, // (id,w,h)\n vector& placed,\n vector& freeOut)\n{\n // items are already sorted by decreasing area outside\n vector freeRects = initialFree;\n int N = (int)items.size();\n placed.assign(N, {0,0,0,0});\n\n for (auto [id, w0, h0] : items) {\n int demand = w0 * h0; // minimal area, may be larger\n // ----- try to take a whole free rectangle -----------------\n int bestSurplus = INT_MAX, bestIdx = -1;\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n int area = f.w * f.h;\n if (area >= demand) {\n int surplus = area - demand;\n if (surplus < bestSurplus) {\n bestSurplus = surplus;\n bestIdx = i;\n }\n }\n }\n if (bestIdx != -1) {\n // use the whole free rectangle, no new walls\n Rect fr = freeRects[bestIdx];\n placed[id] = fr; // exact size of the free room\n freeRects.erase(freeRects.begin() + bestIdx);\n continue;\n }\n\n // ----- need to split a free rectangle ----------------------\n int bestScore = INT_MAX, idx = -1, px = -1, py = -1, pw = -1, ph = -1;\n for (int rot = 0; rot < 2; ++rot) {\n int w = rot ? h0 : w0;\n int h = rot ? w0 : h0;\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n if (f.w >= w && f.h >= h) {\n int score = (f.w - w) + (f.h - h);\n if (score < bestScore) {\n bestScore = score;\n idx = i;\n px = f.x;\n py = f.y;\n pw = w;\n ph = h;\n }\n }\n }\n if (idx != -1) break; // we already have a candidate\n }\n // idx must be valid (the whole grid is a free rectangle)\n Rect used = freeRects[idx];\n placed[id] = {px, py, pw, ph};\n freeRects.erase(freeRects.begin() + idx);\n\n // right remainder\n if (used.w - pw > 0) {\n Rect r = {px + pw, py, used.w - pw, used.h};\n addFreeRect(freeRects, r);\n }\n // bottom remainder\n if (used.h - ph > 0) {\n Rect r = {px, py + ph, pw, used.h - ph};\n addFreeRect(freeRects, r);\n }\n }\n freeOut.swap(freeRects);\n}\n\n/*---------------------------------------------------------------*/\n/* build interior edge tables from a list of rooms */\nvoid buildEdges(const vector& rooms,\n vector& H, vector& V)\n{\n fill(H.begin(), H.end(), 0);\n fill(V.begin(), V.end(), 0);\n for (const Rect& r : rooms) {\n int x0 = r.x, y0 = r.y;\n int x1 = x0 + r.w, y1 = y0 + r.h;\n\n // top edge (y0 > 0)\n if (y0 > 0) {\n int i = y0;\n for (int x = x0; x < x1; ++x) H[i * W + x] = 1;\n }\n // bottom edge (y1 < W)\n if (y1 < W) {\n int i = y1;\n for (int x = x0; x < x1; ++x) H[i * W + x] = 1;\n }\n // left edge (x0 > 0)\n if (x0 > 0) {\n int i = x0;\n for (int y = y0; y < y1; ++y) V[i * W + y] = 1;\n }\n // right edge (x1 < W)\n if (x1 < W) {\n int i = x1;\n for (int y = y0; y < y1; ++y) V[i * W + y] = 1;\n }\n }\n}\n\n/*---------------------------------------------------------------*/\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int D, N;\n if (!(cin >> W >> D >> N)) return 0;\n vector> a(D, vector(N));\n for (int d = 0; d < D; ++d)\n for (int k = 0; k < N; ++k)\n cin >> a[d][k];\n\n // edge tables\n vector Hcur(W * W, 0), Vcur(W * W, 0);\n vector Hprev(W * W, 0), Vprev(W * W, 0);\n\n // answer storage\n vector> answer(D, vector(N));\n\n // free rectangles coming from previous day (day 0 starts with whole hall)\n vector prevFree = { {0, 0, W, W} };\n\n long long totalCost = 0;\n\n for (int day = 0; day < D; ++day) {\n // build items (id, minimal rectangle size)\n vector> items; // (id, w, h)\n items.reserve(N);\n for (int k = 0; k < N; ++k) {\n int w, h;\n minimalRect(a[day][k], w, h);\n items.emplace_back(k, w, h);\n }\n // sort by decreasing area (helps keeping big rooms)\n sort(items.begin(), items.end(),\n [](const auto& A, const auto& B) {\n int areaA = get<1>(A) * get<2>(A);\n int areaB = get<1>(B) * get<2>(B);\n return areaA > areaB;\n });\n\n // pack\n vector placed, freeRects;\n pack_day(prevFree, items, placed, freeRects);\n\n // remember placed rectangles for output (convert to i0,j0,i1,j1)\n for (int k = 0; k < N; ++k) {\n const Rect& r = placed[k];\n answer[day][k] = { r.y, r.x, r.y + r.h, r.x + r.w };\n }\n\n // all rooms (reservation + empty)\n vector allRooms = placed;\n allRooms.insert(allRooms.end(), freeRects.begin(), freeRects.end());\n\n // build edge tables for this day\n buildEdges(allRooms, Hcur, Vcur);\n\n if (day > 0) {\n long long diff = 0;\n for (int i = 1; i < W; ++i)\n for (int j = 0; j < W; ++j)\n if (Hcur[i * W + j] != Hprev[i * W + j]) ++diff;\n for (int i = 0; i < W; ++i)\n for (int j = 1; j < W; ++j)\n if (Vcur[i * W + j] != Vprev[i * W + j]) ++diff;\n totalCost += diff;\n }\n\n // prepare for next day\n Hprev.swap(Hcur);\n Vprev.swap(Vcur);\n prevFree = move(allRooms); // rooms of today become free tomorrow\n }\n\n // (totalCost is not required to be printed, only the layout)\n\n // output\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n const Rect& r = answer[d][k];\n cout << r.x << ' ' << r.y << ' ' << r.w << ' ' << r.h << \"\\n\";\n // note: we stored (i0,j0,i1,j1) as (r.x,r.y,r.w,r.h)\n // but output expects (i0,j0,i1,j1) -> we already stored that way\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nconst long long MOD = 998244353LL;\n\nstruct Placement {\n int stamp;\n int p, q;\n int cell[9];\n int inc[9];\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n const int CELLS = N * N;\n vector a(CELLS);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n long long x; cin >> x;\n a[i * N + j] = int(x % MOD);\n }\n vector>> stamp(M, vector>(3, vector(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 long long x; cin >> x;\n stamp[m][i][j] = int(x % MOD);\n }\n\n vector PL;\n for (int m = 0; m < M; ++m) {\n for (int p = 0; p <= N - 3; ++p) {\n for (int q = 0; q <= N - 3; ++q) {\n Placement pl;\n pl.stamp = m;\n pl.p = p; pl.q = q;\n int pos = 0;\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) {\n pl.cell[pos] = (p + i) * N + (q + j);\n pl.inc[pos] = stamp[m][i][j];\n ++pos;\n }\n PL.push_back(pl);\n }\n }\n }\n const int PLsize = (int)PL.size();\n\n auto deltaAdd = [&](const Placement& pl, const vector& add) -> long long {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] + inc) % MOD;\n delta += nw - old;\n }\n return delta;\n };\n\n auto deltaRemove = [&](const Placement& pl, const vector& add) -> long long {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] - inc) % MOD;\n if (nw < 0) nw += MOD;\n delta += nw - old;\n }\n return delta;\n };\n\n auto deltaReplace = [&](const Placement& oldPl, const Placement& newPl, const vector& add) -> long long {\n long long deltaArr[81] = {0};\n for (int t = 0; t < 9; ++t) deltaArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) deltaArr[newPl.cell[t]] += newPl.inc[t];\n \n long long delta = 0;\n for (int c = 0; c < 81; ++c) if (deltaArr[c] != 0) {\n long long oldR = (a[c] + add[c]) % MOD;\n long long newR = (a[c] + add[c] + deltaArr[c]) % MOD;\n delta += newR - oldR;\n }\n return delta;\n };\n\n auto applyAdd = [&](int idx, vector& add, vector& sol) {\n const Placement& pl = PL[idx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n sol.push_back(idx);\n };\n\n auto applyRemove = [&](int pos, vector& add, vector& sol) {\n const Placement& pl = PL[sol[pos]];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] -= pl.inc[t];\n sol.erase(sol.begin() + pos);\n };\n\n auto applyReplace = [&](int pos, int newIdx, vector& add, vector& sol) {\n const Placement& oldPl = PL[sol[pos]];\n const Placement& newPl = PL[newIdx];\n long long deltaArr[81] = {0};\n for (int t = 0; t < 9; ++t) deltaArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) deltaArr[newPl.cell[t]] += newPl.inc[t];\n for (int c = 0; c < 81; ++c) if (deltaArr[c] != 0) add[c] += deltaArr[c];\n sol[pos] = newIdx;\n };\n\n auto computeScore = [&](const vector& add) -> long long {\n long long sc = 0;\n for (int i = 0; i < CELLS; ++i) sc += (a[i] + add[i]) % MOD;\n return sc;\n };\n\n long long bestScore = 0;\n vector bestSolution;\n\n auto runFromInit = [&](vector initSol) {\n vector add(CELLS, 0);\n vector sol = initSol;\n for (int idx : sol) {\n const Placement& pl = PL[idx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n }\n long long curScore = computeScore(add);\n\n // Iterative greedy improvement\n for (int iter = 0; iter < 3; ++iter) {\n bool changed = true;\n while (changed && (int)sol.size() < K) {\n changed = false;\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long delta = deltaAdd(PL[idx], add);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0) {\n applyAdd(bestIdx, add, sol);\n curScore += bestDelta;\n changed = true;\n }\n }\n\n changed = true;\n while (changed && !sol.empty()) {\n changed = false;\n long long bestDelta = 0;\n int bestPos = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n long long delta = deltaRemove(PL[sol[pos]], add);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestPos = pos;\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += deltaRemove(PL[sol[bestPos]], add);\n applyRemove(bestPos, add, sol);\n changed = true;\n }\n }\n\n changed = true;\n while (changed) {\n changed = false;\n long long bestDelta = 0;\n int bestPos = -1, bestNewIdx = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n for (int newIdx = 0; newIdx < PLsize; ++newIdx) {\n if (sol[pos] == newIdx) continue;\n long long delta = deltaReplace(PL[sol[pos]], PL[newIdx], add);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestPos = pos;\n bestNewIdx = newIdx;\n }\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += deltaReplace(PL[sol[bestPos]], PL[bestNewIdx], add);\n applyReplace(bestPos, bestNewIdx, add, sol);\n changed = true;\n }\n }\n }\n\n // Simulated Annealing\n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution realProb(0.0, 1.0);\n uniform_int_distribution intProb(0, PLsize - 1);\n\n const int maxIter = 150000;\n const double Tstart = 5e5;\n const double Tend = 0.3;\n\n for (int it = 0; it < maxIter; ++it) {\n double progress = (double)it / maxIter;\n double T = Tstart * pow(Tend / Tstart, progress);\n \n double r = realProb(rng);\n long long delta = 0;\n bool moved = false;\n\n double addProb = (int)sol.size() < K ? 0.3 : 0.0;\n double removeProb = !sol.empty() ? 0.25 : 0.0;\n double replaceProb = !sol.empty() ? 0.45 : 0.0;\n\n if (r < addProb && (int)sol.size() < K) {\n int bestAddIdx = -1;\n long long bestAddDelta = LLONG_MIN;\n for (int tries = 0; tries < 50; ++tries) {\n int idx = intProb(rng);\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestAddDelta) {\n bestAddDelta = d;\n bestAddIdx = idx;\n }\n }\n if (bestAddIdx != -1 && bestAddDelta > 0) {\n delta = bestAddDelta;\n if (delta > 0 || exp((double)delta / T) > realProb(rng)) {\n applyAdd(bestAddIdx, add, sol);\n curScore += delta;\n moved = true;\n }\n }\n } else if (r < addProb + removeProb && !sol.empty()) {\n int pos = uniform_int_distribution(0, (int)sol.size() - 1)(rng);\n delta = deltaRemove(PL[sol[pos]], add);\n if (delta > 0 || exp((double)delta / T) > realProb(rng)) {\n curScore += delta;\n applyRemove(pos, add, sol);\n moved = true;\n }\n } else if (!sol.empty()) {\n int pos = uniform_int_distribution(0, (int)sol.size() - 1)(rng);\n int oldIdx = sol[pos];\n \n int bestReplaceIdx = -1;\n long long bestReplaceDelta = LLONG_MIN;\n for (int tries = 0; tries < 30; ++tries) {\n int newIdx = intProb(rng);\n if (newIdx == oldIdx) continue;\n long long d = deltaReplace(PL[oldIdx], PL[newIdx], add);\n if (d > bestReplaceDelta) {\n bestReplaceDelta = d;\n bestReplaceIdx = newIdx;\n }\n }\n if (bestReplaceIdx != -1) {\n delta = bestReplaceDelta;\n if (delta > 0 || exp((double)delta / T) > realProb(rng)) {\n curScore += delta;\n applyReplace(pos, bestReplaceIdx, add, sol);\n moved = true;\n }\n }\n }\n\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n\n if (it % 5000 == 0 && it > 0) {\n for (int ls = 0; ls < 10; ++ls) {\n if ((int)sol.size() < K) {\n long long bestAddDelta = 0;\n int bestAddIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestAddDelta) {\n bestAddDelta = d;\n bestAddIdx = idx;\n }\n }\n if (bestAddIdx != -1 && bestAddDelta > 0) {\n applyAdd(bestAddIdx, add, sol);\n curScore += bestAddDelta;\n }\n }\n if (!sol.empty()) {\n long long bestRemDelta = 0;\n int bestRemPos = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n long long d = deltaRemove(PL[sol[pos]], add);\n if (d > bestRemDelta) {\n bestRemDelta = d;\n bestRemPos = pos;\n }\n }\n if (bestRemPos != -1 && bestRemDelta > 0) {\n curScore += bestRemDelta;\n applyRemove(bestRemPos, add, sol);\n }\n }\n }\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n }\n }\n\n // Final local search\n for (int iter = 0; iter < 5; ++iter) {\n bool changed = false;\n if ((int)sol.size() < K) {\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0) {\n applyAdd(bestIdx, add, sol);\n curScore += bestDelta;\n changed = true;\n }\n }\n if (!sol.empty()) {\n long long bestDelta = 0;\n int bestPos = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n long long d = deltaRemove(PL[sol[pos]], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestPos = pos;\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += bestDelta;\n applyRemove(bestPos, add, sol);\n changed = true;\n }\n }\n if (!changed) break;\n }\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n };\n\n // Initial greedy solution\n vector initSol;\n vector addInit(CELLS, 0);\n for (int iter = 0; iter < 2; ++iter) {\n for (int idx = 0; idx < PLsize && (int)initSol.size() < K; ++idx) {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = PL[idx].cell[t];\n int inc = PL[idx].inc[t];\n long long old = (a[c] + addInit[c]) % MOD;\n long long nw = (a[c] + addInit[c] + inc) % MOD;\n delta += nw - old;\n }\n if (delta > 0) {\n for (int t = 0; t < 9; ++t) addInit[PL[idx].cell[t]] += PL[idx].inc[t];\n initSol.push_back(idx);\n }\n }\n }\n\n runFromInit(initSol);\n\n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\n for (int restart = 0; restart < 2; ++restart) {\n vector randomSol;\n vector addRand(CELLS, 0);\n for (int i = 0; i < K; ++i) {\n int idx = uniform_int_distribution(0, PLsize - 1)(rng);\n randomSol.push_back(idx);\n for (int t = 0; t < 9; ++t) addRand[PL[idx].cell[t]] += PL[idx].inc[t];\n }\n runFromInit(randomSol);\n }\n\n // Final greedy refinement on best solution\n {\n vector add = vector(CELLS, 0);\n vector sol = bestSolution;\n for (int idx : sol) {\n for (int t = 0; t < 9; ++t) add[PL[idx].cell[t]] += PL[idx].inc[t];\n }\n for (int iter = 0; iter < 10; ++iter) {\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0 && (int)sol.size() < K) {\n applyAdd(bestIdx, add, sol);\n } else break;\n }\n long long finalScore = computeScore(add);\n if (finalScore > bestScore) {\n bestScore = finalScore;\n bestSolution = sol;\n }\n }\n\n cout << (int)bestSolution.size() << '\\n';\n for (int idx : bestSolution) {\n const Placement& pl = PL[idx];\n cout << pl.stamp << ' ' << pl.p << ' ' << pl.q << '\\n';\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Pos { int r, c; };\n\n// direction towards target (one step)\nchar moveTowards(const Pos& cur, const Pos& tar) {\n if (cur.r < tar.r) return 'D';\n if (cur.r > tar.r) return 'U';\n if (cur.c < tar.c) return 'R';\n if (cur.c > tar.c) return 'L';\n return '.';\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int N = 5;\n const int TOT = N * N; // 25 containers\n vector> A(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> A[i][j];\n\n // source row of each container, destination row of each container\n int srcRow[TOT], dstRow[TOT];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int b = A[i][j];\n srcRow[b] = i;\n dstRow[b] = b / N;\n }\n\n // state of the large crane\n Pos crane{0, 0};\n int carrying = -1; // container number or -1\n\n // per\u2011row state of receiving gates\n int nextIdx[N] = {0}; // next container to appear\n bool gateHas[N] = {false};\n int gateCont[N]; // valid only if gateHas==true\n\n // actions strings, one per crane (0 = large, 1..4 = small)\n vector act(N);\n int delivered = 0; // number of dispatched containers\n const int MAX_TURNS = 10000;\n\n for (int turn = 1; turn <= MAX_TURNS && delivered < TOT; ++turn) {\n /* ---------- step 1 : arrivals ---------- */\n for (int i = 0; i < N; ++i) {\n if (!gateHas[i] && nextIdx[i] < N &&\n !(crane.r == i && crane.c == 0)) {\n int b = A[i][nextIdx[i]];\n gateHas[i] = true;\n gateCont[i] = b;\n ++nextIdx[i];\n }\n }\n\n /* ---------- step 2 : crane actions ---------- */\n char actLarge = '.';\n\n if (carrying != -1) { // carrying a container\n int tr = dstRow[carrying];\n int tc = N - 1;\n if (crane.r == tr && crane.c == tc) {\n actLarge = 'Q'; // release & dispatch\n ++delivered;\n carrying = -1;\n } else {\n actLarge = moveTowards(crane, {tr, tc});\n // update position\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else { // empty crane\n // choose the waiting container with minimal (travel) cost\n int bestRow = -1;\n int bestCost = INT_MAX;\n for (int i = 0; i < N; ++i) if (gateHas[i]) {\n int b = gateCont[i];\n // distance crane -> source\n int dist1 = abs(crane.r - i) + crane.c; // column diff = crane.c - 0\n // distance source -> dispatch\n int dist2 = abs(i - dstRow[b]) + (N - 1); // column diff = N-1\n int cost = dist1 + dist2;\n if (cost < bestCost) {\n bestCost = cost;\n bestRow = i;\n }\n }\n if (bestRow != -1) {\n if (crane.r == bestRow && crane.c == 0) {\n // already on the gate, pick it up\n actLarge = 'P';\n carrying = gateCont[bestRow];\n gateHas[bestRow] = false;\n } else {\n // move towards the gate\n actLarge = moveTowards(crane, {bestRow, 0});\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else {\n // nothing to do, wait\n actLarge = '.';\n }\n }\n\n act[0].push_back(actLarge); // large crane\n\n // small cranes: bomb on turn 1, otherwise nothing\n for (int i = 1; i < N; ++i) {\n if (turn == 1) act[i].push_back('B');\n else act[i].push_back('.');\n }\n }\n\n // pad all strings to the same length (they already are)\n size_t maxLen = 0;\n for (int i = 0; i < N; ++i) maxLen = max(maxLen, act[i].size());\n for (int i = 0; i < N; ++i) {\n if (act[i].size() < maxLen) act[i].append(maxLen - act[i].size(), '.');\n }\n\n for (int i = 0; i < N; ++i) cout << act[i] << '\\n';\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int x, y; // coordinates\n int rem; // remaining amount (>0)\n bool pos; // true: originally positive\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector> h(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> h[i][j];\n\n vector pos, neg;\n long long totalSupply = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (h[i][j] > 0) {\n pos.push_back({i, j, h[i][j], true});\n totalSupply += h[i][j];\n } else if (h[i][j] < 0) {\n neg.push_back({i, j, -h[i][j], false});\n }\n }\n\n // Current position\n int cx = 0, cy = 0;\n long long load = 0;\n\n // Keep load bounded - original heuristic worked well\n long long Lmax = max(1LL, totalSupply / 20);\n\n vector ops;\n\n auto move_to = [&](int tx, int ty) {\n while (cx < tx) { ops.emplace_back(\"D\"); ++cx; }\n while (cx > tx) { ops.emplace_back(\"U\"); --cx; }\n while (cy < ty) { ops.emplace_back(\"R\"); ++cy; }\n while (cy > ty) { ops.emplace_back(\"L\"); --cy; }\n };\n\n // Index vectors for remaining cells (swap-and-pop friendly)\n vector remPos(pos.size()), remNeg(neg.size());\n iota(remPos.begin(), remPos.end(), 0);\n iota(remNeg.begin(), remNeg.end(), 0);\n\n while (!remPos.empty() || !remNeg.empty()) {\n if (!remPos.empty() && load < Lmax) {\n // Choose positive cell with simple heuristic:\n // prefer cells with larger remaining when distances are close\n int bestIdx = -1;\n int bestDist = INT_MAX;\n int bestRem = -1;\n for (int pi : remPos) {\n int d = abs(cx - pos[pi].x) + abs(cy - pos[pi].y);\n // Accept if closer, OR same distance but more remaining\n if (d < bestDist || (d == bestDist && pos[pi].rem > bestRem)) {\n bestDist = d;\n bestRem = pos[pi].rem;\n bestIdx = pi;\n }\n }\n Cell &c = pos[bestIdx];\n move_to(c.x, c.y);\n int take = (int)min(Lmax - load, c.rem);\n load += take;\n c.rem -= take;\n ops.emplace_back(\"+\" + to_string(take));\n if (c.rem == 0) {\n auto it = find(remPos.begin(), remPos.end(), bestIdx);\n *it = remPos.back();\n remPos.pop_back();\n }\n } else if (!remNeg.empty() && load > 0) {\n // Choose negative cell with same heuristic\n int bestIdx = -1;\n int bestDist = INT_MAX;\n int bestRem = -1;\n for (int ni : remNeg) {\n int d = abs(cx - neg[ni].x) + abs(cy - neg[ni].y);\n if (d < bestDist || (d == bestDist && neg[ni].rem > bestRem)) {\n bestDist = d;\n bestRem = neg[ni].rem;\n bestIdx = ni;\n }\n }\n Cell &c = neg[bestIdx];\n move_to(c.x, c.y);\n int give = (int)min(load, c.rem);\n load -= give;\n c.rem -= give;\n ops.emplace_back(\"-\" + to_string(give));\n if (c.rem == 0) {\n auto it = find(remNeg.begin(), remNeg.end(), bestIdx);\n *it = remNeg.back();\n remNeg.pop_back();\n }\n } else if (!remPos.empty()) {\n // Load is full: nearest positive\n int bestIdx = -1;\n int bestDist = INT_MAX;\n for (int pi : remPos) {\n int d = abs(cx - pos[pi].x) + abs(cy - pos[pi].y);\n if (d < bestDist) {\n bestDist = d;\n bestIdx = pi;\n }\n }\n Cell &c = pos[bestIdx];\n move_to(c.x, c.y);\n int take = (int)min(Lmax - load, c.rem);\n load += take;\n c.rem -= take;\n ops.emplace_back(\"+\" + to_string(take));\n if (c.rem == 0) {\n auto it = find(remPos.begin(), remPos.end(), bestIdx);\n *it = remPos.back();\n remPos.pop_back();\n }\n } else {\n // No positives: nearest negative\n int bestIdx = -1;\n int bestDist = INT_MAX;\n for (int ni : remNeg) {\n int d = abs(cx - neg[ni].x) + abs(cy - neg[ni].y);\n if (d < bestDist) {\n bestDist = d;\n bestIdx = ni;\n }\n }\n Cell &c = neg[bestIdx];\n move_to(c.x, c.y);\n int give = (int)min(load, c.rem);\n load -= give;\n c.rem -= give;\n ops.emplace_back(\"-\" + to_string(give));\n if (c.rem == 0) {\n auto it = find(remNeg.begin(), remNeg.end(), bestIdx);\n *it = remNeg.back();\n remNeg.pop_back();\n }\n }\n }\n\n for (const string &s : ops) cout << s << '\\n';\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nstruct Solver {\n int N, M, T;\n int S;\n int CELLS;\n vector> seed;\n vector> w;\n vector> neigh;\n mutable mt19937 rng;\n\n void compute_w() {\n w.assign(S, vector(S, 0));\n for (int i = 0; i < S; ++i)\n for (int j = i; j < S; ++j) {\n int val = 0;\n for (int l = 0; l < M; ++l)\n val += max(seed[i][l], seed[j][l]);\n w[i][j] = w[j][i] = val;\n }\n }\n\n int sumSeed(int id) const {\n int s = 0;\n for (int v : seed[id]) s += v;\n return s;\n }\n\n vector greedyCoverSelection() const {\n const int need = CELLS;\n vector curMax(M, -1);\n vector used(S, 0);\n vector chosen;\n chosen.reserve(need);\n for (int taken = 0; taken < need; ++taken) {\n int bestId = -1;\n int bestGain = -1;\n int bestSum = -1;\n for (int id = 0; id < S; ++id) if (!used[id]) {\n int gain = 0;\n for (int l = 0; l < M; ++l)\n if (seed[id][l] > curMax[l]) gain += seed[id][l] - curMax[l];\n if (gain > bestGain ||\n (gain == bestGain && sumSeed(id) > bestSum)) {\n bestGain = gain;\n bestId = id;\n bestSum = sumSeed(id);\n }\n }\n used[bestId] = 1;\n chosen.push_back(bestId);\n for (int l = 0; l < M; ++l)\n curMax[l] = max(curMax[l], seed[bestId][l]);\n }\n return chosen;\n }\n\n vector topValueSelection() const {\n vector idx(S);\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(),\n [&](int a, int b){ return sumSeed(a) > sumSeed(b); });\n return vector(idx.begin(), idx.begin() + CELLS);\n }\n\n vector linearAssignment(const vector& seeds) const {\n vector sortedSeeds = seeds;\n sort(sortedSeeds.begin(), sortedSeeds.end(),\n [&](int a, int b){ return sumSeed(a) > sumSeed(b); });\n\n vector cells(CELLS);\n iota(cells.begin(), cells.end(), 0);\n sort(cells.begin(), cells.end(),\n [&](int a, int b){\n return neigh[a].size() > neigh[b].size();\n });\n\n vector assign(CELLS, -1);\n for (int i = 0; i < CELLS; ++i) assign[cells[i]] = sortedSeeds[i];\n return assign;\n }\n\n vector randomAssignment(const vector& seeds) const {\n vector shuffled = seeds;\n shuffle(shuffled.begin(), shuffled.end(), rng);\n\n vector cells(CELLS);\n iota(cells.begin(), cells.end(), 0);\n sort(cells.begin(), cells.end(),\n [&](int a, int b){\n return neigh[a].size() > neigh[b].size();\n });\n\n vector assign(CELLS, -1);\n for (int i = 0; i < CELLS; ++i) assign[cells[i]] = shuffled[i];\n return assign;\n }\n\n int totalW(const vector& assign) const {\n long long tot = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int idx = r * N + c;\n if (c + 1 < N) tot += w[assign[idx]][assign[idx + 1]];\n if (r + 1 < N) tot += w[assign[idx]][assign[idx + N]];\n }\n }\n return static_cast(tot);\n }\n\n void improve(vector& assign) const {\n vector used(S, 0);\n for (int id : assign) used[id] = 1;\n\n while (true) {\n vector> sumW(CELLS, vector(S, 0));\n for (int p = 0; p < CELLS; ++p) {\n for (int nb : neigh[p]) {\n int seed_nb = assign[nb];\n for (int s = 0; s < S; ++s) {\n sumW[p][s] += w[s][seed_nb];\n }\n }\n }\n\n int bestDelta = 0;\n int bestType = 0;\n int bestP = -1, bestQ = -1, bestS = -1;\n\n for (int p = 0; p < CELLS; ++p) {\n int cur = assign[p];\n for (int s = 0; s < S; ++s) if (!used[s]) {\n int delta = sumW[p][s] - sumW[p][cur];\n if (delta > bestDelta) {\n bestDelta = delta;\n bestType = 1;\n bestP = p;\n bestS = s;\n }\n }\n }\n\n for (int p = 0; p < CELLS; ++p) {\n for (int q = p + 1; q < CELLS; ++q) {\n if (assign[p] == assign[q]) continue;\n int delta = (sumW[p][assign[q]] - sumW[p][assign[p]]) +\n (sumW[q][assign[p]] - sumW[q][assign[q]]);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestType = 2;\n bestP = p;\n bestQ = q;\n }\n }\n }\n\n if (bestDelta <= 0) break;\n\n if (bestType == 1) {\n int old = assign[bestP];\n assign[bestP] = bestS;\n used[old] = 0;\n used[bestS] = 1;\n } else {\n swap(assign[bestP], assign[bestQ]);\n }\n }\n }\n\n void kickAndImprove(vector& assign, int kicks) const {\n for (int k = 0; k < kicks; ++k) {\n vector used(S, 0);\n for (int id : assign) used[id] = 1;\n \n if (rng() % 2 == 0) {\n int p = uniform_int_distribution(0, CELLS - 1)(rng);\n int q = uniform_int_distribution(0, CELLS - 1)(rng);\n swap(assign[p], assign[q]);\n } else {\n int p = uniform_int_distribution(0, CELLS - 1)(rng);\n vector unused;\n for (int s = 0; s < S; ++s) if (!used[s]) unused.push_back(s);\n if (!unused.empty()) {\n int newSeed = unused[uniform_int_distribution(0, unused.size() - 1)(rng)];\n assign[p] = newSeed;\n }\n }\n improve(assign);\n }\n }\n\n void solveOneTurn() {\n compute_w();\n\n vector greedySeeds = greedyCoverSelection();\n vector topSeeds = topValueSelection();\n\n vector, vector>> candidates;\n candidates.emplace_back(greedySeeds, linearAssignment(greedySeeds));\n candidates.emplace_back(greedySeeds, randomAssignment(greedySeeds));\n candidates.emplace_back(topSeeds, linearAssignment(topSeeds));\n candidates.emplace_back(topSeeds, randomAssignment(topSeeds));\n\n int bestW = -1;\n vector bestAssign;\n\n for (auto& cand : candidates) {\n vector cur = cand.second;\n improve(cur);\n kickAndImprove(cur, 5);\n improve(cur);\n \n int curW = totalW(cur);\n if (curW > bestW) {\n bestW = curW;\n bestAssign = cur;\n }\n }\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (c) cout << ' ';\n cout << bestAssign[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n }\n\n void run() {\n seed.assign(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n\n neigh.assign(CELLS, {});\n auto addNeighbour = [&](int r, int c, int nr, int nc) {\n if (0 <= nr && nr < N && 0 <= nc && nc < N) {\n neigh[r * N + c].push_back(nr * N + nc);\n }\n };\n for (int r = 0; r < N; ++r)\n for (int c = 0; c < N; ++c) {\n addNeighbour(r, c, r - 1, c);\n addNeighbour(r, c, r + 1, c);\n addNeighbour(r, c, r, c - 1);\n addNeighbour(r, c, r, c + 1);\n }\n\n rng.seed(chrono::steady_clock::now().time_since_epoch().count());\n\n for (int turn = 0; turn < T; ++turn) {\n solveOneTurn();\n seed.assign(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n }\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, T;\n if (!(cin >> N >> M >> T)) return 0;\n Solver solver;\n solver.N = N;\n solver.M = M;\n solver.T = T;\n solver.S = 2 * N * (N - 1);\n solver.CELLS = N * N;\n solver.run();\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, Vlimit;\n if (!(cin >> N >> Vlimit >> M)) return 0;\n \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 // Arm design (root + one leaf)\n cout << 2 << \"\\n\";\n cout << 0 << ' ' << 1 << \"\\n\";\n cout << 0 << ' ' << 0 << \"\\n\";\n\n // Collect sources and targets\n vector> src, tgt;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (s[i][j] == '1') src.emplace_back(i, j);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (t[i][j] == '1') tgt.emplace_back(i, j);\n\n // Mark targets (to find already-correct positions)\n vector> occupied(N, vector(N, 0));\n for (auto &p : tgt) occupied[p.first][p.second] = 1;\n\n // Separate sources: already at target vs need to move\n vector srcIdx;\n for (int i = 0; i < (int)src.size(); ++i) {\n if (occupied[src[i].first][src[i].second]) {\n occupied[src[i].first][src[i].second] = 2; // already correct\n } else {\n srcIdx.push_back(i);\n }\n }\n\n // Remaining targets that need a takoyaki\n vector tgtIdx;\n for (int i = 0; i < (int)tgt.size(); ++i) {\n if (occupied[tgt[i].first][tgt[i].second] == 1) {\n tgtIdx.push_back(i);\n }\n }\n\n // Simple greedy matching (O(n^2))\n int n = srcIdx.size();\n vector matchSrc(n, -1), matchTgt(n, -1);\n vector srcUsed(n, 0), tgtUsed(n, 0);\n \n for (int i = 0; i < n; ++i) {\n int bestS = -1, bestT = -1, bestDist = INT_MAX;\n for (int si = 0; si < n; ++si) {\n if (srcUsed[si]) continue;\n for (int ti = 0; ti < n; ++ti) {\n if (tgtUsed[ti]) continue;\n int d = abs(src[srcIdx[si]].first - tgt[tgtIdx[ti]].first)\n + abs(src[srcIdx[si]].second - tgt[tgtIdx[ti]].second);\n if (d < bestDist) {\n bestDist = d;\n bestS = si;\n bestT = ti;\n }\n }\n }\n if (bestS >= 0) {\n matchSrc[bestS] = bestT;\n matchTgt[bestT] = bestS;\n srcUsed[bestS] = 1;\n tgtUsed[bestT] = 1;\n }\n }\n\n // Simulation state\n int rx = 0, ry = 0;\n int leafDir = 0; // 0=E,1=S,2=W,3=N\n bool holding = false;\n \n const int DX[4] = {0, 1, 0, -1};\n const int DY[4] = {1, 0, -1, 0};\n\n // Output buffer\n string output;\n output.reserve(100000 * 4 + 1000);\n\n auto addTurn = [&](char mv, char rot, char leafAct) {\n output += mv;\n output += rot;\n output += '.';\n output += leafAct;\n output += '\\n';\n };\n\n auto moveRoot = [&](int gx, int gy) {\n while (rx != gx || ry != gy) {\n char mv;\n if (rx < gx) { mv = 'D'; ++rx; }\n else if (rx > gx) { mv = 'U'; --rx; }\n else if (ry < gy) { mv = 'R'; ++ry; }\n else { mv = 'L'; --ry; }\n addTurn(mv, '.', '.');\n }\n };\n\n auto rotateLeaf = [&](char rot) {\n if (rot != '.') {\n if (rot == 'R') leafDir = (leafDir + 1) & 3;\n else leafDir = (leafDir + 3) & 3;\n }\n addTurn('.', rot, '.');\n };\n\n auto rotateLeafTo = [&](int dir) {\n while (leafDir != dir) {\n int diff = (dir - leafDir + 4) & 3;\n if (diff == 2) {\n rotateLeaf('R'); rotateLeaf('R');\n } else if (diff == 1) {\n rotateLeaf('R');\n } else {\n rotateLeaf('L');\n }\n }\n };\n\n // Find empty neighbor of a position\n auto findEmptyNeighbor = [&](int x, int y) -> pair {\n for (int d = 0; d < 4; ++d) {\n int nx = x - DX[d], ny = y - DY[d];\n if (nx >= 0 && nx < N && ny >= 0 && ny < N && !occupied[nx][ny]) {\n return {ny, d}; // return (position, direction to square)\n }\n }\n return {-1, -1}; // no empty neighbor\n };\n\n // Process each matched pair\n for (int si = 0; si < n; ++si) {\n if (matchSrc[si] < 0) continue;\n int ti = matchSrc[si];\n int sx = src[srcIdx[si]].first, sy = src[srcIdx[si]].second;\n int tx = tgt[tgtIdx[ti]].first, ty = tgt[tgtIdx[ti]].second;\n\n // Find empty neighbor for source\n auto nbS = findEmptyNeighbor(sx, sy);\n if (nbS.first < 0) continue; // shouldn't happen\n \n // Find empty neighbor for target\n auto nbT = findEmptyNeighbor(tx, ty);\n if (nbT.first < 0) continue;\n\n int rxS = sx - DX[nbS.second], ryS = sy - DY[nbS.second];\n int rxT = tx - DX[nbT.second], ryT = ty - DY[nbT.second];\n\n // Go to source\n moveRoot(rxS, ryS);\n rotateLeafTo(nbS.second);\n addTurn('.', '.', 'P');\n occupied[sx][sy] = 0;\n holding = true;\n\n // Go to target\n moveRoot(rxT, ryT);\n rotateLeafTo(nbT.second);\n addTurn('.', '.', 'P');\n occupied[tx][ty] = 1;\n holding = false;\n }\n\n cout << output;\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n int sign;\n};\n\nconst int MAXCOORD = 100000;\nconst int CELL_SIZE = 400;\n\nconst int MAXC = 260;\nint cell[MAXC][MAXC];\nint pref[MAXC + 1][MAXC + 1];\n\n// O(1) query on cell grid\ninline int grid_sum(int x1, int y1, int x2, int y2, int C) {\n if (x1 > x2 || y1 > y2) return INT_MIN;\n return pref[x2 + 1][y2 + 1] - pref[x1][y2 + 1] - pref[x2 + 1][y1] + pref[x1][y1];\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n if (!(cin >> N)) return 0;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n int x, y;\n cin >> x >> y;\n points[i] = {x, y, (i < N) ? 1 : -1};\n }\n\n const int C = MAXCOORD / CELL_SIZE + 1; // 251\n\n // Build cell grid\n for (int i = 0; i < C; ++i)\n for (int j = 0; j < C; ++j)\n cell[i][j] = 0;\n\n for (auto &p : points) {\n int cx = p.x / CELL_SIZE;\n int cy = p.y / CELL_SIZE;\n cell[cx][cy] += p.sign;\n }\n\n // Build prefix sum\n for (int i = 0; i < C; ++i) {\n for (int j = 0; j < C; ++j) {\n pref[i + 1][j + 1] = pref[i][j + 1] + pref[i + 1][j] - pref[i][j] + cell[i][j];\n }\n }\n\n // ===== Maximum sum sub-matrix O(C\u00b3) = 16M operations =====\n int bestSum = INT_MIN;\n int bTop = 0, bBottom = 0, bLeft = 0, bRight = 0;\n\n for (int top = 0; top < C; ++top) {\n int colSum[MAXC] = {0};\n for (int bottom = top; bottom < C; ++bottom) {\n for (int col = 0; col < C; ++col) colSum[col] += cell[bottom][col];\n \n int curSum = 0, maxHere = INT_MIN, start = 0;\n for (int i = 0; i < C; ++i) {\n curSum += colSum[i];\n if (curSum > maxHere) {\n maxHere = curSum;\n bLeft = start;\n bRight = i;\n }\n if (curSum < 0) {\n curSum = 0;\n start = i + 1;\n }\n }\n \n if (maxHere > bestSum) {\n bestSum = maxHere;\n bTop = top;\n bBottom = bottom;\n }\n }\n }\n\n // Convert to coordinate rectangle\n int leftX = bLeft * CELL_SIZE;\n int rightX = min((bRight + 1) * CELL_SIZE - 1, MAXCOORD);\n int bottomY = bTop * CELL_SIZE;\n int topY = min((bBottom + 1) * CELL_SIZE - 1, MAXCOORD);\n\n int bestA = 0, bestB = 0;\n for (auto &p : points) {\n if (p.x >= leftX && p.x <= rightX && p.y >= bottomY && p.y <= topY) {\n if (p.sign == 1) ++bestA;\n else ++bestB;\n }\n }\n\n int bestL = leftX, bestR = rightX, bestBtm = bottomY, bestT = topY;\n\n // ===== Expand search: 4x4 expansion =====\n for (int dl = 0; dl <= 3; ++dl) {\n for (int dr = 0; dr <= 3; ++dr) {\n for (int db = 0; db <= 3; ++db) {\n for (int dt = 0; dt <= 3; ++dt) {\n int lx = max(0, bLeft - dl) * CELL_SIZE;\n int rx = min(MAXCOORD, (bRight + dr + 1) * CELL_SIZE - 1);\n int by = max(0, bTop - db) * CELL_SIZE;\n int ty = min(MAXCOORD, (bBottom + dt + 1) * CELL_SIZE - 1);\n \n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= lx && p.x <= rx && p.y >= by && p.y <= ty) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = lx; bestR = rx; bestBtm = by; bestT = ty;\n }\n }\n }\n }\n }\n\n // ===== Random sampling with O(1) prefix sum queries =====\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> coord_dist(0, MAXCOORD);\n uniform_int_distribution<> size_dist(100, 3000);\n\n const int NUM_SAMPLES = 5000;\n for (int iter = 0; iter < NUM_SAMPLES; ++iter) {\n int lx = coord_dist(gen);\n int rx = lx + size_dist(gen);\n if (rx > MAXCOORD) rx = MAXCOORD;\n int by = coord_dist(gen);\n int ty = by + size_dist(gen);\n if (ty > MAXCOORD) ty = MAXCOORD;\n\n // O(1) query on cell grid\n int c1 = lx / CELL_SIZE, c2 = rx / CELL_SIZE;\n int r1 = by / CELL_SIZE, r2 = ty / CELL_SIZE;\n int sum = grid_sum(c1, r1, c2, r2, C);\n \n // Only do exact check if promising\n if (sum > bestA - bestB) {\n int el = c1 * CELL_SIZE;\n int er = min((c2 + 1) * CELL_SIZE - 1, MAXCOORD);\n int eb = r1 * CELL_SIZE;\n int et = min((r2 + 1) * CELL_SIZE - 1, MAXCOORD);\n \n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= el && p.x <= er && p.y >= eb && p.y <= et) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = el; bestR = er; bestBtm = eb; bestT = et;\n }\n }\n }\n\n // ===== Search around mackerels =====\n vector mackerels;\n for (auto &p : points) if (p.sign == 1) mackerels.push_back(p);\n \n shuffle(mackerels.begin(), mackerels.end(), gen);\n \n const int MAX_MAC_SEARCH = 500;\n const int radii[] = {50, 100, 200, 300, 500, 800, 1200, 1800, 2500, 4000};\n const int NUM_RADII = 10;\n \n for (int mi = 0; mi < min((int)mackerels.size(), MAX_MAC_SEARCH); ++mi) {\n auto &m = mackerels[mi];\n for (int ri = 0; ri < NUM_RADII; ++ri) {\n int r = radii[ri];\n int lx = max(0, m.x - r);\n int rx = min(MAXCOORD, m.x + r);\n int by = max(0, m.y - r);\n int ty = min(MAXCOORD, m.y + r);\n \n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= lx && p.x <= rx && p.y >= by && p.y <= ty) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = lx; bestR = rx; bestBtm = by; bestT = ty;\n }\n }\n }\n\n // ===== Try rectangles based on mackerel pairs =====\n const int MAX_PAIRS = 100;\n for (int i = 0; i < min((int)mackerels.size(), MAX_PAIRS); ++i) {\n for (int j = i + 1; j < min((int)mackerels.size(), MAX_PAIRS); ++j) {\n auto &m1 = mackerels[i];\n auto &m2 = mackerels[j];\n int lx = min(m1.x, m2.x);\n int rx = max(m1.x, m2.x);\n int by = min(m1.y, m2.y);\n int ty = max(m1.y, m2.y);\n \n // Expand by 20%\n int w = rx - lx, h = ty - by;\n lx = max(0, lx - w / 5);\n rx = min(MAXCOORD, rx + w / 5);\n by = max(0, by - h / 5);\n ty = min(MAXCOORD, ty + h / 5);\n \n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= lx && p.x <= rx && p.y >= by && p.y <= ty) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = lx; bestR = rx; bestBtm = by; bestT = ty;\n }\n }\n }\n\n // ===== Tighten rectangle =====\n if (bestA + bestB > 0) {\n int minX = MAXCOORD, maxX = 0, minY = MAXCOORD, maxY = 0;\n for (auto &p : points) {\n if (p.x >= bestL && p.x <= bestR && p.y >= bestBtm && p.y <= bestT) {\n minX = min(minX, p.x);\n maxX = max(maxX, p.x);\n minY = min(minY, p.y);\n maxY = max(maxY, p.y);\n }\n }\n bestL = minX;\n bestR = maxX;\n bestBtm = minY;\n bestT = maxY;\n }\n\n // Ensure positive area\n if (bestL == bestR) {\n if (bestL > 0) bestL--;\n else bestR++;\n }\n if (bestBtm == bestT) {\n if (bestBtm > 0) bestBtm--;\n else bestT++;\n }\n\n // Perimeter check\n long long perimeter = 2LL * ((long long)bestR - bestL + bestT - bestBtm);\n if (perimeter > 400000) {\n int width = bestR - bestL;\n int height = bestT - bestBtm;\n int maxDim = 200000;\n \n if (width > maxDim) {\n int diff = width - maxDim;\n bestL += diff / 2;\n bestR -= (diff - diff / 2);\n }\n if (height > maxDim) {\n int diff = height - maxDim;\n bestBtm += diff / 2;\n bestT -= (diff - diff / 2);\n }\n }\n\n // Final clamp\n bestL = max(0, min(MAXCOORD, bestL));\n bestR = max(0, min(MAXCOORD, bestR));\n bestBtm = max(0, min(MAXCOORD, bestBtm));\n bestT = max(0, min(MAXCOORD, bestT));\n\n // Output rectangle\n cout << 4 << '\\n';\n cout << bestL << ' ' << bestBtm << '\\n';\n cout << bestR << ' ' << bestBtm << '\\n';\n cout << bestR << ' ' << bestT << '\\n';\n cout << bestL << ' ' << bestT << '\\n';\n\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n long long sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n \n vector w_obs(N), h_obs(N);\n for (int i = 0; i < N; ++i) cin >> w_obs[i] >> h_obs[i];\n \n const long long INF = (1LL<<62);\n \n // Candidate heights\n vector cand;\n for (int i = 0; i < N; ++i) {\n cand.push_back(w_obs[i]);\n cand.push_back(h_obs[i]);\n }\n sort(cand.begin(), cand.end());\n cand.erase(unique(cand.begin(), cand.end()), cand.end());\n \n // Find all feasible solutions\n struct Sol { long long H; long long sumW; vector rot; long long cost; };\n vector all_sols;\n \n for (long long H : cand) {\n long long sumW = 0;\n bool ok = true;\n vector rot(N, 0);\n \n for (int i = 0; i < N; ++i) {\n if (h_obs[i] <= H && w_obs[i] <= H) {\n if (w_obs[i] <= h_obs[i]) {\n sumW += w_obs[i];\n rot[i] = 0;\n } else {\n sumW += h_obs[i];\n rot[i] = 1;\n }\n } else if (h_obs[i] <= H) {\n sumW += w_obs[i];\n rot[i] = 0;\n } else if (w_obs[i] <= H) {\n sumW += h_obs[i];\n rot[i] = 1;\n } else {\n ok = false;\n break;\n }\n }\n \n if (ok) {\n all_sols.push_back({H, sumW, rot, sumW + H});\n }\n }\n \n // Sort by cost\n sort(all_sols.begin(), all_sols.end(), [](const Sol& a, const Sol& b) {\n return a.cost < b.cost;\n });\n \n // For ties, prefer solutions with smaller max dimension (more \"compact\")\n vector best_sols;\n if (!all_sols.empty()) {\n long long min_cost = all_sols[0].cost;\n for (const auto& s : all_sols) {\n if (s.cost == min_cost) {\n best_sols.push_back(s);\n } else {\n break;\n }\n }\n }\n \n // Track best based on feedback\n long long best_feedback = INF;\n int best_idx = 0;\n \n for (int turn = 0; turn < T; ++turn) {\n int sol_idx;\n if (turn < (int)best_sols.size()) {\n sol_idx = turn; // Try tied best solutions first\n } else if (turn < (int)all_sols.size()) {\n sol_idx = turn; // Try next best solutions\n } else {\n sol_idx = best_idx; // Use best known\n }\n \n const Sol& sol = all_sols[sol_idx];\n \n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n cout << i << ' ' << (sol.rot[i] ? 1 : 0) << ' ' << 'U' << ' '\n << (i == 0 ? -1 : i-1) << \"\\n\";\n }\n cout << flush;\n \n long long W_measured, H_measured;\n cin >> W_measured >> H_measured;\n \n long long fb = W_measured + H_measured;\n if (fb < best_feedback) {\n best_feedback = fb;\n best_idx = sol_idx;\n }\n }\n \n return 0;\n}","ahc041":"#include \nusing namespace std;\n\n// Fast xorshift32 RNG\nstruct XorShift {\n uint32_t x;\n XorShift(uint32_t seed = 2463534242U) : x(seed) {}\n uint32_t next() {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n }\n int nextInt(int mod) { return next() % mod; }\n int nextInt(int L, int R) { return L + next() % (R - L + 1); }\n void shuffle(vector& v) {\n for (int i = (int)v.size() - 1; i > 0; --i) {\n swap(v[i], v[nextInt(i + 1)]);\n }\n }\n} rng;\n\nconst int INF_NEG = -1e9;\n\n/*------------------------------------------------------------*/\n/* Build a random spanning tree */\n/*------------------------------------------------------------*/\nvoid build_random_tree(int N, int M, const vector>& adj,\n const vector& A,\n vector>& tree, int root,\n XorShift& rng, int method) {\n vector parent(N, -2);\n tree.assign(N, {});\n \n if (method == 0) { // Random DFS\n vector stack;\n stack.push_back(root);\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n rng.shuffle(nbr);\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n } else if (method == 1) { // Random BFS\n queue q;\n q.push(root);\n parent[root] = -1;\n while (!q.empty()) {\n int v = q.front(); q.pop();\n vector nbr = adj[v];\n rng.shuffle(nbr);\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n q.push(u);\n }\n }\n }\n } else if (method == 2) { // Random Prim\n vector inTree(N, 0);\n inTree[root] = 1;\n vector vertices = {root};\n while ((int)vertices.size() < N) {\n int v = vertices[rng.nextInt((int)vertices.size())];\n vector nbr = adj[v];\n rng.shuffle(nbr);\n for (int u : nbr) {\n if (!inTree[u]) {\n inTree[u] = 1;\n tree[v].push_back(u);\n tree[u].push_back(v);\n vertices.push_back(u);\n break;\n }\n }\n }\n } else if (method == 3) { // Random Kruskal\n vector p(N);\n iota(p.begin(), p.end(), 0);\n vector> edges;\n edges.reserve(M);\n for (int v = 0; v < N; ++v) {\n for (int u : adj[v]) {\n if (v < u) edges.emplace_back(rng.next(), v, u);\n }\n }\n sort(edges.begin(), edges.end(),\n [](const auto& a, const auto& b) { return get<0>(a) < get<0>(b); });\n for (auto& e : edges) {\n int _, v, u;\n tie(_, v, u) = e;\n function find = [&](int x) -> int {\n return p[x] == x ? x : p[x] = find(p[x]);\n };\n int pv = find(v), pu = find(u);\n if (pv != pu) {\n p[pv] = pu;\n tree[v].push_back(u);\n tree[u].push_back(v);\n }\n }\n } else if (method == 4) { // Greedy DFS - prefer high beauty neighbors\n vector stack = {root};\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n sort(nbr.begin(), nbr.end(),\n [&](int a, int b) { return A[a] > A[b]; });\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n } else if (method == 5) { // Inverse greedy - prefer low beauty\n vector stack = {root};\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n sort(nbr.begin(), nbr.end(),\n [&](int a, int b) { return A[a] < A[b]; });\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n } else if (method == 6) { // Beauty chain - prefer decreasing beauty\n vector stack = {root};\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n sort(nbr.begin(), nbr.end(),\n [&](int a, int b) {\n int diffA = A[a] - A[v];\n int diffB = A[b] - A[v];\n if ((diffA <= 0) != (diffB <= 0))\n return diffA <= 0;\n if (diffA <= 0 && diffB <= 0)\n return A[a] < A[b];\n return A[a] > A[b];\n });\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n } else if (method == 7) { // Start from low beauty, prefer high beauty\n vector> beautyIdx(N);\n for (int i = 0; i < N; ++i) beautyIdx[i] = {A[i], i};\n sort(beautyIdx.begin(), beautyIdx.end());\n int start = beautyIdx[rng.nextInt(min(20, N))].second;\n \n vector stack = {start};\n parent[start] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n sort(nbr.begin(), nbr.end(),\n [&](int a, int b) { return A[a] > A[b]; });\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n } else if (method == 8) { // Prefer high degree (shallower trees, more height available)\n vector stack = {root};\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n sort(nbr.begin(), nbr.end(),\n [&](int a, int b) { return (int)adj[a].size() > (int)adj[b].size(); });\n rng.shuffle(nbr); // shuffle equal degree vertices\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n } else { // method == 9: Start from random vertex, prefer similar beauty (clustering)\n vector stack = {root};\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n sort(nbr.begin(), nbr.end(),\n [&](int a, int b) {\n int diffA = abs(A[a] - A[v]);\n int diffB = abs(A[b] - A[v]);\n if (diffA != diffB) return diffA < diffB;\n return A[a] > A[b];\n });\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n }\n}\n\n/*------------------------------------------------------------*/\n/* Solve the forest problem on a rooted tree (optimized DP) */\n/*------------------------------------------------------------*/\nint solve_tree_fast(const vector>& tree, int root,\n const vector& A, int H,\n vector& outParent) {\n const int N = A.size();\n \n // Build children list\n static vector> children;\n children.assign(N, {});\n static vector bfs_order;\n bfs_order.clear();\n bfs_order.reserve(N);\n \n queue q;\n q.push(root);\n vector par(N, -2);\n par[root] = -1;\n \n while (!q.empty()) {\n int v = q.front(); q.pop();\n bfs_order.push_back(v);\n for (int u : tree[v]) {\n if (par[u] == -2) {\n par[u] = v;\n children[v].push_back(u);\n q.push(u);\n }\n }\n }\n \n // DP: bottom-up using bfs_order reversed\n static int dp[1000][11];\n static char keep[1000][11][20];\n \n for (int idx = (int)bfs_order.size() - 1; idx >= 0; --idx) {\n int v = bfs_order[idx];\n int deg = children[v].size();\n for (int d = 0; d <= H; ++d) {\n int cur = (d + 1) * A[v];\n for (int i = 0; i < deg; ++i) {\n int u = children[v][i];\n int keepEdge = (d < H) ? dp[u][d + 1] : INF_NEG;\n int cutEdge = dp[u][0];\n if (keepEdge > cutEdge) {\n cur += keepEdge;\n keep[v][d][i] = 1;\n } else {\n cur += cutEdge;\n keep[v][d][i] = 0;\n }\n }\n dp[v][d] = cur;\n }\n }\n \n int bestVal = dp[root][0];\n \n // Reconstruct parent array\n outParent.assign(N, -1);\n static vector> stk;\n stk.clear();\n stk.emplace_back(root, 0);\n \n while (!stk.empty()) {\n auto [v, depth] = stk.back();\n stk.pop_back();\n int deg = children[v].size();\n for (int i = 0; i < deg; ++i) {\n int u = children[v][i];\n if (keep[v][depth][i]) {\n outParent[u] = v;\n stk.emplace_back(u, depth + 1);\n } else {\n outParent[u] = -1;\n stk.emplace_back(u, 0);\n }\n }\n }\n \n return bestVal;\n}\n\n/*------------------------------------------------------------*/\n/* Main */\n/*------------------------------------------------------------*/\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n \n vector A(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n \n vector> adj(N);\n for (int i = 0; i < M; ++i) {\n int u, v; cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n // Read coordinates (not used)\n for (int i = 0; i < N; ++i) {\n long long x, y; cin >> x >> y;\n }\n \n // Precompute vertex statistics\n int minBeautyIdx = 0, maxBeautyIdx = 0;\n vector> beautyIdx(N);\n for (int i = 0; i < N; ++i) {\n beautyIdx[i] = {A[i], i};\n if (A[i] < A[minBeautyIdx]) minBeautyIdx = i;\n if (A[i] > A[maxBeautyIdx]) maxBeautyIdx = i;\n }\n sort(beautyIdx.begin(), beautyIdx.end());\n \n // Candidates for smart rooting\n vector lowBeautyCand, highBeautyCand;\n for (int i = 0; i < min(20, N); ++i) lowBeautyCand.push_back(beautyIdx[i].second);\n for (int i = N - 1; i >= max(0, N - 20); --i) highBeautyCand.push_back(beautyIdx[i].second);\n \n const int ITER = 5500; // increased iterations\n const int ROOTS_PER_TREE = 2; // fewer roots to keep total solve calls manageable\n \n int bestScore = INF_NEG;\n vector bestParent;\n \n for (int it = 0; it < ITER; ++it) {\n // Pick a random tree generation method (0-9)\n int method = rng.nextInt(10);\n \n // Build random spanning tree\n vector> tree;\n int treeRoot = rng.nextInt(N);\n build_random_tree(N, M, adj, A, tree, treeRoot, rng, method);\n \n // Try multiple roots\n vector roots;\n roots.reserve(ROOTS_PER_TREE);\n roots.push_back(minBeautyIdx); // always try min beauty as root\n if (ROOTS_PER_TREE >= 2) {\n roots.push_back(lowBeautyCand[rng.nextInt((int)lowBeautyCand.size())]); // random low beauty\n }\n \n for (int r : roots) {\n vector parent;\n int score = solve_tree_fast(tree, r, A, H, parent);\n if (score > bestScore) {\n bestScore = score;\n bestParent = parent;\n }\n }\n }\n \n // Output result\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << bestParent[i];\n }\n cout << '\\n';\n \n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector board(N);\n for (int i = 0; i < N; ++i) cin >> board[i];\n\n struct Oni {\n int r, c; // position\n int up, down, left, right; // distances to the four borders\n bool canU, canD, canL, canR; // is the direction allowed ?\n };\n\n vector onis;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] == 'x')\n onis.push_back({i, j, i, N - 1 - i, j, N - 1 - j,\n false, false, false, false});\n\n // decide which directions are allowed for every Oni\n for (auto &o : onis) {\n bool f;\n f = true;\n for (int r = 0; r < o.r; ++r)\n if (board[r][o.c] == 'o') { f = false; break; }\n o.canU = f;\n\n f = true;\n for (int r = o.r + 1; r < N; ++r)\n if (board[r][o.c] == 'o') { f = false; break; }\n o.canD = f;\n\n f = true;\n for (int c = 0; c < o.c; ++c)\n if (board[o.r][c] == 'o') { f = false; break; }\n o.canL = f;\n\n f = true;\n for (int c = o.c + 1; c < N; ++c)\n if (board[o.r][c] == 'o') { f = false; break; }\n o.canR = f;\n }\n\n vector> ops; // result sequence\n\n for (const auto &o : onis) {\n int bestDist = INT_MAX;\n char bestDir = '?';\n int param = -1; // row or column index\n\n if (o.canU && o.up < bestDist) {\n bestDist = o.up; bestDir = 'U'; param = o.c;\n }\n if (o.canD && o.down < bestDist) {\n bestDist = o.down; bestDir = 'D'; param = o.c;\n }\n if (o.canL && o.left < bestDist) {\n bestDist = o.left; bestDir = 'L'; param = o.r;\n }\n if (o.canR && o.right < bestDist) {\n bestDist = o.right; bestDir = 'R'; param = o.r;\n }\n\n int cnt = bestDist + 1; // distance + 1\n char opp = (bestDir == 'U' ? 'D' :\n bestDir == 'D' ? 'U' :\n bestDir == 'L' ? 'R' : 'L');\n\n for (int k = 0; k < cnt; ++k) ops.emplace_back(bestDir, param);\n for (int k = 0; k < cnt; ++k) ops.emplace_back(opp, param);\n }\n\n // The problem guarantees that the total number of moves never exceeds 4\u00b7N\u00b2.\n for (auto [d, p] : ops) {\n cout << d << ' ' << p << '\\n';\n }\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nusing ll = long long;\n\nint N = 100;\nconst ll L = 500000LL;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector T(N);\n for (int i = 0; i < N; ++i) cin >> T[i];\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n // Simple random initial plan (known to work)\n auto buildPlan = [&](mt19937& r) {\n vector a(N), b(N);\n for (int i = 0; i < N; ++i) {\n a[i] = r() % N;\n b[i] = r() % N;\n }\n return tuple, vector>(a, b);\n };\n \n // Fast simulation\n auto simulate = [&](const vector& a, const vector& b) {\n vector cnt(N, 0);\n int cur = 0;\n cnt[cur]++;\n for (ll week = 2; week <= L; ++week) {\n if (cnt[cur] & 1) cur = a[cur];\n else cur = b[cur];\n ++cnt[cur];\n }\n return cnt;\n };\n \n // Calculate error\n auto calcError = [&](const vector& cnt) {\n ll err = 0;\n for (int i = 0; i < N; ++i) err += llabs((ll)cnt[i] - T[i]);\n return err;\n };\n \n // Optimize using random neighbor sampling\n auto optimize = [&](vector a, vector b, int maxIter) {\n vector cnt = simulate(a, b);\n ll curErr = calcError(cnt);\n \n for (int iter = 0; iter < maxIter; ++iter) {\n // Pick random source\n int src = uniform_int_distribution(0, N-1)(rng);\n int sOdd = (cnt[src] + 1) / 2;\n int sEven = cnt[src] / 2;\n bool didImprove = false;\n \n // Try swapping a[src] and b[src] if cnt[src] is odd\n if (cnt[src] & 1) {\n int oldOdd = a[src], oldEven = b[src];\n ll delta = \n - llabs((ll)cnt[oldOdd] - T[oldOdd]) - llabs((ll)cnt[oldEven] - T[oldEven])\n + llabs((ll)cnt[oldOdd] - 1 - T[oldOdd]) + llabs((ll)cnt[oldEven] + 1 - T[oldEven]);\n if (delta < 0) {\n swap(a[src], b[src]);\n cnt[oldOdd] -= 1;\n cnt[oldEven] += 1;\n curErr += delta;\n didImprove = true;\n }\n }\n \n // Try moving odd edge\n if (!didImprove) {\n for (int attempt = 0; attempt < 5; ++attempt) {\n int newTarget = uniform_int_distribution(0, N-1)(rng);\n if (newTarget == a[src]) continue;\n \n int oldTarget = a[src];\n ll delta = \n - llabs((ll)cnt[oldTarget] - T[oldTarget]) - llabs((ll)cnt[newTarget] - T[newTarget])\n + llabs((ll)cnt[oldTarget] - sOdd - T[oldTarget]) + llabs((ll)cnt[newTarget] + sOdd - T[newTarget]);\n \n if (delta < 0) {\n a[src] = newTarget;\n cnt[oldTarget] -= sOdd;\n cnt[newTarget] += sOdd;\n curErr += delta;\n didImprove = true;\n break;\n }\n }\n }\n \n // Try moving even edge\n if (!didImprove) {\n for (int attempt = 0; attempt < 5; ++attempt) {\n int newTarget = uniform_int_distribution(0, N-1)(rng);\n if (newTarget == b[src]) continue;\n \n int oldTarget = b[src];\n ll delta = \n - llabs((ll)cnt[oldTarget] - T[oldTarget]) - llabs((ll)cnt[newTarget] - T[newTarget])\n + llabs((ll)cnt[oldTarget] - sEven - T[oldTarget]) + llabs((ll)cnt[newTarget] + sEven - T[newTarget]);\n \n if (delta < 0) {\n b[src] = newTarget;\n cnt[oldTarget] -= sEven;\n cnt[newTarget] += sEven;\n curErr += delta;\n didImprove = true;\n break;\n }\n }\n }\n \n // Occasional full resimulation to correct drift\n if (iter % 1000 == 0) {\n cnt = simulate(a, b);\n curErr = calcError(cnt);\n }\n }\n \n return tuple, vector, ll>(a, b, curErr);\n };\n \n ll bestError = (1LL<<60);\n vector bestA(N), bestB(N);\n \n const int RESTARTS = 100;\n const int ITER_PER_RESTART = 5000;\n \n for (int r = 0; r < RESTARTS; ++r) {\n mt19937 r2(r * 12345 + 6789);\n auto [initA, initB] = buildPlan(r2);\n auto [a, b, err] = optimize(initA, initB, ITER_PER_RESTART);\n \n if (err < bestError) {\n bestError = err;\n bestA = a;\n bestB = b;\n if (bestError == 0) break;\n }\n }\n \n for (int i = 0; i < N; ++i) {\n cout << bestA[i] << ' ' << bestB[i] << '\\n';\n }\n \n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; ++i) {\n cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n /* -----------------------------------------------------------\n 1. grouping : sort by rectangle centre\n ----------------------------------------------------------- */\n vector cx(N), cy(N);\n for (int i = 0; i < N; ++i) {\n cx[i] = (lx[i] + rx[i]) * 0.5;\n cy[i] = (ly[i] + ry[i]) * 0.5;\n }\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b) {\n if (cx[a] != cx[b]) return cx[a] < cx[b];\n return cy[a] < cy[b];\n });\n\n vector> groups(M);\n int pos = 0;\n for (int g = 0; g < M; ++g) {\n for (int cnt = 0; cnt < G[g]; ++cnt) {\n groups[g].push_back(order[pos++]);\n }\n }\n\n /* -----------------------------------------------------------\n 2. helper: perform one query\n ----------------------------------------------------------- */\n auto do_query = [&](const vector& verts) -> vector> {\n int L = (int)verts.size();\n cout << \"? \" << L;\n for (int v : verts) cout << ' ' << v;\n cout << \"\\n\";\n cout.flush();\n vector> edges;\n edges.reserve(L-1);\n for (int i = 0; i < L-1; ++i) {\n int a,b; cin >> a >> b;\n edges.emplace_back(a,b);\n }\n return edges;\n };\n\n /* -----------------------------------------------------------\n 3. ask queries for every group, store the received edges\n ----------------------------------------------------------- */\n vector>> groupEdges(M);\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n if (sz <= 1) continue; // no road needed\n if (sz <= L) {\n auto e = do_query(grp);\n groupEdges[g] = move(e);\n } else {\n int start = 0;\n while (start + 1 < sz) { // at least two vertices left\n int end = min(start + L, sz);\n vector win(grp.begin() + start, grp.begin() + end);\n auto e = do_query(win);\n groupEdges[g].insert(groupEdges[g].end(),\n e.begin(), e.end());\n start = end - 1; // overlap = 1 vertex\n }\n }\n }\n\n /* -----------------------------------------------------------\n 4. output the answer\n ----------------------------------------------------------- */\n cout << \"!\\n\";\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n // list of cities\n for (int i = 0; i < sz; ++i) {\n if (i) cout << ' ';\n cout << grp[i];\n }\n cout << \"\\n\";\n if (sz <= 1) continue; // no edges\n\n // map global id -> local index (0 \u2026 sz-1)\n vector id2loc(N, -1);\n for (int i = 0; i < sz; ++i) id2loc[grp[i]] = i;\n\n // adjacency list of the collected edges\n vector> adj(sz);\n for (auto &e : groupEdges[g]) {\n int u = e.first, v = e.second;\n int ui = id2loc[u];\n int vi = id2loc[v];\n if (ui >= 0 && vi >= 0) {\n adj[ui].push_back(vi);\n adj[vi].push_back(ui);\n }\n }\n\n // DFS to obtain a spanning tree\n vector parent(sz, -1);\n vector visited(sz, 0);\n vector st = {0};\n visited[0] = 1;\n while (!st.empty()) {\n int u = st.back(); st.pop_back();\n for (int v : adj[u]) if (!visited[v]) {\n visited[v] = 1;\n parent[v] = u;\n st.push_back(v);\n }\n }\n // (the graph is connected by Lemma\u202f1, but be safe)\n for (int i = 0; i < sz; ++i) if (!visited[i]) {\n parent[i] = 0; // connect arbitrarily\n }\n\n // output the tree edges\n for (int i = 1; i < sz; ++i) {\n int a = grp[i];\n int b = grp[parent[i]];\n if (a > b) swap(a,b);\n cout << a << ' ' << b << \"\\n\";\n }\n }\n cout.flush();\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M; // N=20, M=40\n\n vector> pts(M);\n for (int i = 0; i < M; ++i) cin >> pts[i].first >> pts[i].second;\n\n // Directions: index 0=Up,1=Down,2=Left,3=Right\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n auto nodeId = [&](int r, int c) { return r * N + c; };\n auto slideDest = [&](int r, int c, int d) {\n int nr = r, nc = c;\n if (d == 0) nr = 0; // Up\n else if (d == 1) nr = N-1; // Down\n else if (d == 2) nc = 0; // Left\n else if (d == 3) nc = N-1; // Right\n return make_pair(nr, nc);\n };\n\n vector answer;\n answer.reserve(2000);\n\n int cr = pts[0].first;\n int cc = pts[0].second;\n\n for (int idx = 1; idx < M; ++idx) {\n int tr = pts[idx].first;\n int tc = pts[idx].second;\n\n // BFS from (cr,cc) to (tr,tc)\n const int SRC = nodeId(cr, cc);\n const int DST = nodeId(tr, tc);\n\n vector dist(N*N, -1);\n vector parent(N*N, -1);\n vector> act(N*N, {'?', '?'}); // action type and direction\n\n queue q;\n q.push(SRC);\n dist[SRC] = 0;\n\n while (!q.empty() && dist[DST] == -1) {\n int u = q.front(); q.pop();\n int ur = u / N, uc = u % N;\n\n // Try moves and slides\n for (int d = 0; d < 4; ++d) {\n // Move\n int mr = ur + dr[d];\n int mc = uc + dc[d];\n if (mr >= 0 && mr < N && mc >= 0 && mc < N) {\n int v = nodeId(mr, mc);\n if (dist[v] == -1) {\n dist[v] = dist[u] + 1;\n parent[v] = u;\n act[v] = {'M', dirChar[d]};\n q.push(v);\n }\n }\n // Slide\n auto p = slideDest(ur, uc, d);\n int sr = p.first, sc = p.second;\n int v = nodeId(sr, sc);\n if (v != u && dist[v] == -1) {\n dist[v] = dist[u] + 1;\n parent[v] = u;\n act[v] = {'S', dirChar[d]};\n q.push(v);\n }\n }\n }\n\n // Reconstruct path from DST to SRC\n vector segment;\n int cur = DST;\n while (cur != SRC) {\n int p = parent[cur];\n char a = act[cur].first;\n char d = act[cur].second;\n segment.emplace_back(string(1, a) + \" \" + d);\n cur = p;\n }\n reverse(segment.begin(), segment.end());\n for (auto &s : segment) answer.push_back(s);\n\n // Update current position\n cr = tr;\n cc = tc;\n }\n\n // Output\n for (auto &s : answer) cout << s << '\\n';\n return 0;\n}"},"16":{"ahc001":"#include \nusing namespace std;\n\nint n;\nvector X, Y;\nvector R;\nvector bestA, bestB, bestC, bestD;\ndouble bestTotalScore = -1;\n\nstruct Point {\n int x, y;\n long long r;\n int id;\n};\n\nstatic inline double penaltyVal(long long area, long long desired) {\n if (area <= 0 || desired <= 0) return 1.0;\n double ratio = (double)min(area, desired) / (double)max(area, desired);\n double t = 1.0 - ratio;\n return t * t;\n}\n\nstatic inline double satisfactionVal(long long area, long long desired) {\n return 1.0 - penaltyVal(area, desired);\n}\n\ndouble calcTotalScore(const vector& A, const vector& B,\n const vector& C, const vector& D) {\n double total = 0;\n for (int i = 0; i < n; ++i) {\n long long area = 1LL * (C[i] - A[i]) * (D[i] - B[i]);\n total += satisfactionVal(area, R[i]);\n }\n return total;\n}\n\n// Strategy 1: Proportional allocation with actual penalty evaluation\nvoid partitionProportional(vector pts, vector& A, vector& B,\n vector& C, vector& D,\n int x1, int x2, int y1, int y2) {\n if (pts.empty()) return;\n if (pts.size() == 1) {\n int id = pts[0].id;\n A[id] = x1;\n B[id] = y1;\n C[id] = x2;\n D[id] = y2;\n return;\n }\n \n long long totalR = 0;\n for (auto& p : pts) totalR += p.r;\n \n int width = x2 - x1;\n int height = y2 - y1;\n long long area = 1LL * width * height;\n \n if (width <= 0 || height <= 0) return;\n \n int minX = 10000, maxX = 0, minY = 10000, maxY = 0;\n for (auto& p : pts) {\n minX = min(minX, p.x);\n maxX = max(maxX, p.x);\n minY = min(minY, p.y);\n maxY = max(maxY, p.y);\n }\n \n bool splitVertical = (width > height);\n if (abs(maxX - minX - (maxY - minY)) > 100) {\n splitVertical = (maxX - minX > maxY - minY);\n }\n \n if (splitVertical) {\n sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) {\n return a.x < b.x;\n });\n \n vector> cutCandidates;\n long long cumR = 0;\n for (size_t i = 0; i < pts.size(); ++i) {\n cumR += pts[i].r;\n if (i + 1 < pts.size() && pts[i+1].x != pts[i].x) {\n cutCandidates.emplace_back(pts[i].x + 1, cumR);\n }\n }\n \n if (cutCandidates.empty()) {\n splitVertical = false;\n } else {\n double bestPenalty = 1e100;\n int bestCut = cutCandidates[0].first;\n \n for (auto& [cutX, leftR] : cutCandidates) {\n if (cutX <= x1 || cutX >= x2) continue;\n \n long long leftArea = 1LL * (cutX - x1) * height;\n long long rightArea = area - leftArea;\n \n // Evaluate actual penalties for each sub-board\n double leftPenalty = 0, rightPenalty = 0;\n for (auto& p : pts) {\n if (p.x < cutX) {\n // Estimate each point gets proportional area\n long long propArea = (p.r * leftArea) / totalR;\n // But cannot exceed sub-board area\n propArea = min(propArea, leftArea);\n leftPenalty += penaltyVal(propArea, p.r);\n } else {\n long long propArea = (p.r * rightArea) / totalR;\n propArea = min(propArea, rightArea);\n rightPenalty += penaltyVal(propArea, p.r);\n }\n }\n \n double totalPenalty = leftPenalty + rightPenalty;\n if (totalPenalty < bestPenalty) {\n bestPenalty = totalPenalty;\n bestCut = cutX;\n }\n }\n \n vector left, right;\n for (auto& p : pts) {\n if (p.x < bestCut) left.push_back(p);\n else right.push_back(p);\n }\n \n if (left.empty()) left.push_back(pts[0]);\n if (right.empty()) right.push_back(pts.back());\n \n partitionProportional(left, A, B, C, D, x1, bestCut, y1, y2);\n partitionProportional(right, A, B, C, D, bestCut, x2, y1, y2);\n return;\n }\n }\n \n if (!splitVertical) {\n sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) {\n return a.y < b.y;\n });\n \n vector> cutCandidates;\n long long cumR = 0;\n for (size_t i = 0; i < pts.size(); ++i) {\n cumR += pts[i].r;\n if (i + 1 < pts.size() && pts[i+1].y != pts[i].y) {\n cutCandidates.emplace_back(pts[i].y + 1, cumR);\n }\n }\n \n if (cutCandidates.empty()) {\n int id = pts[0].id;\n A[id] = x1;\n B[id] = y1;\n C[id] = x2;\n D[id] = y2;\n return;\n }\n \n double bestPenalty = 1e100;\n int bestCut = cutCandidates[0].first;\n \n for (auto& [cutY, bottomR] : cutCandidates) {\n if (cutY <= y1 || cutY >= y2) continue;\n \n long long bottomArea = 1LL * width * (cutY - y1);\n long long topArea = area - bottomArea;\n \n double bottomPenalty = 0, topPenalty = 0;\n for (auto& p : pts) {\n if (p.y < cutY) {\n long long propArea = (p.r * bottomArea) / totalR;\n propArea = min(propArea, bottomArea);\n bottomPenalty += penaltyVal(propArea, p.r);\n } else {\n long long propArea = (p.r * topArea) / totalR;\n propArea = min(propArea, topArea);\n topPenalty += penaltyVal(propArea, p.r);\n }\n }\n \n double totalPenalty = bottomPenalty + topPenalty;\n if (totalPenalty < bestPenalty) {\n bestPenalty = totalPenalty;\n bestCut = cutY;\n }\n }\n \n vector bottom, top;\n for (auto& p : pts) {\n if (p.y < bestCut) bottom.push_back(p);\n else top.push_back(p);\n }\n \n if (bottom.empty()) bottom.push_back(pts[0]);\n if (top.empty()) top.push_back(pts.back());\n \n partitionProportional(bottom, A, B, C, D, x1, x2, y1, bestCut);\n partitionProportional(top, A, B, C, D, x1, x2, bestCut, y2);\n }\n}\n\n// Strategy 2: R_i weighted split - prioritize splitting by R_i distribution\nvoid partitionByRI(vector pts, vector& A, vector& B,\n vector& C, vector& D,\n int x1, int x2, int y1, int y2) {\n if (pts.empty()) return;\n if (pts.size() == 1) {\n int id = pts[0].id;\n A[id] = x1;\n B[id] = y1;\n C[id] = x2;\n D[id] = y2;\n return;\n }\n \n long long totalR = 0;\n for (auto& p : pts) totalR += p.r;\n \n int width = x2 - x1;\n int height = y2 - y1;\n long long area = 1LL * width * height;\n \n if (width <= 0 || height <= 0) return;\n \n int minX = 10000, maxX = 0, minY = 10000, maxY = 0;\n for (auto& p : pts) {\n minX = min(minX, p.x);\n maxX = max(maxX, p.x);\n minY = min(minY, p.y);\n maxY = max(maxY, p.y);\n }\n \n // Choose split direction based on R_i distribution\n bool splitVertical = true;\n \n // Sort by x and calculate cumulative R_i\n vector byX = pts;\n sort(byX.begin(), byX.end(), [](const Point& a, const Point& b) {\n return a.x < b.x;\n });\n \n vector cumRX(byX.size() + 1, 0);\n for (size_t i = 0; i < byX.size(); ++i) {\n cumRX[i + 1] = cumRX[i] + byX[i].r;\n }\n \n // Sort by y and calculate cumulative R_i\n vector byY = pts;\n sort(byY.begin(), byY.end(), [](const Point& a, const Point& b) {\n return a.y < b.y;\n });\n \n vector cumRY(byY.size() + 1, 0);\n for (size_t i = 0; i < byY.size(); ++i) {\n cumRY[i + 1] = cumRY[i] + byY[i].r;\n }\n \n // Find best vertical cut\n double bestV = 1e100;\n int bestVCut = byX[byX.size()/2].x + 1;\n for (size_t i = 1; i < byX.size(); ++i) {\n if (byX[i].x == byX[i-1].x) continue;\n int cutX = byX[i].x;\n if (cutX <= x1 || cutX >= x2) continue;\n \n long long leftArea = 1LL * (cutX - x1) * height;\n long long rightArea = area - leftArea;\n \n // Calculate penalty\n double pen = 0;\n for (auto& p : byX) {\n long long propArea = (p.r * (p.x < cutX ? leftArea : rightArea)) / totalR;\n pen += penaltyVal(propArea, p.r);\n }\n \n if (pen < bestV) {\n bestV = pen;\n bestVCut = cutX;\n }\n }\n \n // Find best horizontal cut\n double bestH = 1e100;\n int bestHCut = byY[byY.size()/2].y + 1;\n for (size_t i = 1; i < byY.size(); ++i) {\n if (byY[i].y == byY[i-1].y) continue;\n int cutY = byY[i].y;\n if (cutY <= y1 || cutY >= y2) continue;\n \n long long bottomArea = 1LL * width * (cutY - y1);\n long long topArea = area - bottomArea;\n \n double pen = 0;\n for (auto& p : byY) {\n long long propArea = (p.r * (p.y < cutY ? bottomArea : topArea)) / totalR;\n pen += penaltyVal(propArea, p.r);\n }\n \n if (pen < bestH) {\n bestH = pen;\n bestHCut = cutY;\n }\n }\n \n if (bestV <= bestH && bestVCut > x1 && bestVCut < x2) {\n vector left, right;\n for (auto& p : pts) {\n if (p.x < bestVCut) left.push_back(p);\n else right.push_back(p);\n }\n if (left.empty()) left.push_back(pts[0]);\n if (right.empty()) right.push_back(pts.back());\n \n partitionByRI(left, A, B, C, D, x1, bestVCut, y1, y2);\n partitionByRI(right, A, B, C, D, bestVCut, x2, y1, y2);\n } else if (bestHCut > y1 && bestHCut < y2) {\n vector bottom, top;\n for (auto& p : pts) {\n if (p.y < bestHCut) bottom.push_back(p);\n else top.push_back(p);\n }\n if (bottom.empty()) bottom.push_back(pts[0]);\n if (top.empty()) top.push_back(pts.back());\n \n partitionByRI(bottom, A, B, C, D, x1, x2, y1, bestHCut);\n partitionByRI(top, A, B, C, D, x1, x2, bestHCut, y2);\n } else {\n // Fallback: split at midpoint\n if (width >= height) {\n int cutX = (x1 + x2) / 2;\n vector left, right;\n for (auto& p : pts) {\n if (p.x < cutX) left.push_back(p);\n else right.push_back(p);\n }\n if (left.empty()) left.push_back(pts[0]);\n if (right.empty()) right.push_back(pts.back());\n \n partitionByRI(left, A, B, C, D, x1, cutX, y1, y2);\n partitionByRI(right, A, B, C, D, cutX, x2, y1, y2);\n } else {\n int cutY = (y1 + y2) / 2;\n vector bottom, top;\n for (auto& p : pts) {\n if (p.y < cutY) bottom.push_back(p);\n else top.push_back(p);\n }\n if (bottom.empty()) bottom.push_back(pts[0]);\n if (top.empty()) top.push_back(pts.back());\n \n partitionByRI(bottom, A, B, C, D, x1, x2, y1, cutY);\n partitionByRI(top, A, B, C, D, x1, x2, cutY, y2);\n }\n }\n}\n\n// Strategy 3: Balanced split\nvoid partitionBalanced(vector pts, vector& A, vector& B,\n vector& C, vector& D,\n int x1, int x2, int y1, int y2) {\n if (pts.empty()) return;\n if (pts.size() == 1) {\n int id = pts[0].id;\n A[id] = x1;\n B[id] = y1;\n C[id] = x2;\n D[id] = y2;\n return;\n }\n \n int width = x2 - x1;\n int height = y2 - y1;\n \n bool splitVertical = (width > height);\n \n if (splitVertical) {\n sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) {\n return a.x < b.x;\n });\n \n size_t mid = pts.size() / 2;\n int cutX = pts[mid].x;\n cutX = max(cutX + 1, x1 + 1);\n cutX = min(cutX, x2 - 1);\n \n vector left, right;\n for (auto& p : pts) {\n if (p.x < cutX) left.push_back(p);\n else right.push_back(p);\n }\n \n if (left.empty()) left.push_back(pts[0]);\n if (right.empty()) right.push_back(pts.back());\n \n partitionBalanced(left, A, B, C, D, x1, cutX, y1, y2);\n partitionBalanced(right, A, B, C, D, cutX, x2, y1, y2);\n } else {\n sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) {\n return a.y < b.y;\n });\n \n size_t mid = pts.size() / 2;\n int cutY = pts[mid].y;\n cutY = max(cutY + 1, y1 + 1);\n cutY = min(cutY, y2 - 1);\n \n vector bottom, top;\n for (auto& p : pts) {\n if (p.y < cutY) bottom.push_back(p);\n else top.push_back(p);\n }\n \n if (bottom.empty()) bottom.push_back(pts[0]);\n if (top.empty()) top.push_back(pts.back());\n \n partitionBalanced(bottom, A, B, C, D, x1, x2, y1, cutY);\n partitionBalanced(top, A, B, C, D, x1, x2, cutY, y2);\n }\n}\n\n// Strategy 4: Sort by R_i descending and allocate greedily\nvoid partitionGreedyRI(vector pts, vector& A, vector& B,\n vector& C, vector& D,\n int x1, int x2, int y1, int y2) {\n if (pts.empty()) return;\n if (pts.size() == 1) {\n int id = pts[0].id;\n A[id] = x1;\n B[id] = y1;\n C[id] = x2;\n D[id] = y2;\n return;\n }\n \n long long totalR = 0;\n for (auto& p : pts) totalR += p.r;\n \n int width = x2 - x1;\n int height = y2 - y1;\n long long area = 1LL * width * height;\n \n int minX = 10000, maxX = 0, minY = 10000, maxY = 0;\n for (auto& p : pts) {\n minX = min(minX, p.x);\n maxX = max(maxX, p.x);\n minY = min(minY, p.y);\n maxY = max(maxY, p.y);\n }\n \n bool splitVertical = (width > height);\n if (abs(maxX - minX - (maxY - minY)) > 100) {\n splitVertical = (maxX - minX > maxY - minY);\n }\n \n if (splitVertical) {\n sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) {\n return a.x < b.x;\n });\n \n long long cumR = 0;\n vector> cutCandidates;\n for (size_t i = 0; i < pts.size(); ++i) {\n cumR += pts[i].r;\n if (i + 1 < pts.size() && pts[i+1].x != pts[i].x) {\n cutCandidates.emplace_back(pts[i].x + 1, cumR);\n }\n }\n \n if (cutCandidates.empty()) {\n splitVertical = false;\n } else {\n long long idealLeftR = totalR / 2;\n int bestCut = cutCandidates[0].first;\n long long bestDiff = llabs(cutCandidates[0].second - idealLeftR);\n \n for (auto& [cutX, leftR] : cutCandidates) {\n long long diff = llabs(leftR - idealLeftR);\n if (diff < bestDiff) {\n bestDiff = diff;\n bestCut = cutX;\n }\n }\n \n vector left, right;\n for (auto& p : pts) {\n if (p.x < bestCut) left.push_back(p);\n else right.push_back(p);\n }\n \n if (left.empty()) left.push_back(pts[0]);\n if (right.empty()) right.push_back(pts.back());\n \n partitionGreedyRI(left, A, B, C, D, x1, bestCut, y1, y2);\n partitionGreedyRI(right, A, B, C, D, bestCut, x2, y1, y2);\n return;\n }\n }\n \n if (!splitVertical) {\n sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) {\n return a.y < b.y;\n });\n \n long long cumR = 0;\n vector> cutCandidates;\n for (size_t i = 0; i < pts.size(); ++i) {\n cumR += pts[i].r;\n if (i + 1 < pts.size() && pts[i+1].y != pts[i].y) {\n cutCandidates.emplace_back(pts[i].y + 1, cumR);\n }\n }\n \n if (cutCandidates.empty()) {\n int id = pts[0].id;\n A[id] = x1;\n B[id] = y1;\n C[id] = x2;\n D[id] = y2;\n return;\n }\n \n long long idealBottomR = totalR / 2;\n int bestCut = cutCandidates[0].first;\n long long bestDiff = llabs(cutCandidates[0].second - idealBottomR);\n \n for (auto& [cutY, bottomR] : cutCandidates) {\n long long diff = llabs(bottomR - idealBottomR);\n if (diff < bestDiff) {\n bestDiff = diff;\n bestCut = cutY;\n }\n }\n \n vector bottom, top;\n for (auto& p : pts) {\n if (p.y < bestCut) bottom.push_back(p);\n else top.push_back(p);\n }\n \n if (bottom.empty()) bottom.push_back(pts[0]);\n if (top.empty()) top.push_back(pts.back());\n \n partitionGreedyRI(bottom, A, B, C, D, x1, x2, y1, bestCut);\n partitionGreedyRI(top, A, B, C, D, x1, x2, bestCut, y2);\n }\n}\n\nvoid tryStrategy(int strategy) {\n vector A(n), B(n), C(n), D(n);\n vector pts(n);\n for (int i = 0; i < n; ++i) {\n pts[i] = {X[i], Y[i], R[i], i};\n }\n \n if (strategy == 0) {\n partitionProportional(pts, A, B, C, D, 0, 10000, 0, 10000);\n } else if (strategy == 1) {\n partitionByRI(pts, A, B, C, D, 0, 10000, 0, 10000);\n } else if (strategy == 2) {\n partitionBalanced(pts, A, B, C, D, 0, 10000, 0, 10000);\n } else {\n partitionGreedyRI(pts, A, B, C, D, 0, 10000, 0, 10000);\n }\n \n // Ensure rectangles contain points\n for (int i = 0; i < n; ++i) {\n if (A[i] > X[i]) A[i] = X[i];\n if (C[i] <= X[i]) C[i] = X[i] + 1;\n if (B[i] > Y[i]) B[i] = Y[i];\n if (D[i] <= Y[i]) D[i] = Y[i] + 1;\n \n A[i] = max(0, min(A[i], 9999));\n C[i] = max(A[i] + 1, min(C[i], 10000));\n B[i] = max(0, min(B[i], 9999));\n D[i] = max(B[i] + 1, min(D[i], 10000));\n }\n \n double score = calcTotalScore(A, B, C, D);\n \n if (score > bestTotalScore) {\n bestTotalScore = score;\n bestA = A;\n bestB = B;\n bestC = C;\n bestD = D;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n if (!(cin >> n)) return 0;\n X.resize(n);\n Y.resize(n);\n R.resize(n);\n \n for (int i = 0; i < n; ++i) {\n cin >> X[i] >> Y[i] >> R[i];\n }\n \n bestTotalScore = -1;\n \n // Try multiple strategies\n for (int s = 0; s < 4; ++s) {\n tryStrategy(s);\n }\n \n // Output best result\n for (int i = 0; i < n; ++i) {\n cout << bestA[i] << ' ' << bestB[i] << ' ' << bestC[i] << ' ' << bestD[i] << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \nusing namespace std;\nusing namespace std::chrono;\n\nint N = 50;\nint startI, startJ;\nint tileId[50][50];\nint val[50][50];\nint M = 0;\nvector> adj;\nint totalMaxWeight = 0;\nvector tileWeight;\n\nvector visitedTile;\nint visitedCnt = 0;\nint sumVisitedMax = 0;\nint curSum = 0;\nstring curMoves;\nint bestSum = 0;\nstring bestMoves;\nbool foundAll = false;\ndouble timeLimit = 1.78;\nsteady_clock::time_point startTime;\n\ninline bool outOfTime() {\n return (steady_clock::now() - startTime).count() * 1e-9 > timeLimit;\n}\n\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U','D','L','R'};\n\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\nvoid dfs(int ci, int cj, int depth = 0) {\n if (outOfTime() || foundAll) return;\n if (depth > 2500) return;\n\n if (curSum > bestSum) {\n bestSum = curSum;\n bestMoves = curMoves;\n }\n\n if (visitedCnt == M) {\n foundAll = true;\n bestSum = curSum;\n bestMoves = curMoves;\n return;\n }\n\n int remainingMax = totalMaxWeight - sumVisitedMax;\n if (curSum + remainingMax <= bestSum) return;\n\n for (int d = 0; d < 4; ++d) {\n if (outOfTime()) return;\n \n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int nt = tileId[ni][nj];\n if (visitedTile[nt]) continue;\n \n visitedTile[nt] = 1;\n ++visitedCnt;\n sumVisitedMax += tileWeight[nt];\n curSum += val[ni][nj];\n curMoves.push_back(dirChar[d]);\n\n dfs(ni, nj, depth + 1);\n\n curMoves.pop_back();\n curSum -= val[ni][nj];\n sumVisitedMax -= tileWeight[nt];\n --visitedCnt;\n visitedTile[nt] = 0;\n \n if (foundAll) return;\n }\n}\n\nvoid runSearch() {\n fill(visitedTile.begin(), visitedTile.end(), 0);\n visitedTile[tileId[startI][startJ]] = 1;\n visitedCnt = 1;\n sumVisitedMax = tileWeight[tileId[startI][startJ]];\n curSum = val[startI][startJ];\n curMoves.clear();\n foundAll = false;\n \n dfs(startI, startJ, 0);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n if (!(cin >> startI >> startJ)) return 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> tileId[i][j];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> val[i][j];\n\n int maxTileId = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n maxTileId = max(maxTileId, tileId[i][j]);\n M = maxTileId + 1;\n\n adj.assign(M, {});\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int a = tileId[i][j];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d];\n int nj = j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int b = tileId[ni][nj];\n if (a != b) adj[a].push_back(b);\n }\n }\n }\n for (int i = 0; i < M; ++i) {\n sort(adj[i].begin(), adj[i].end());\n adj[i].erase(unique(adj[i].begin(), adj[i].end()), adj[i].end());\n }\n\n tileWeight.assign(M, 0);\n for (int id = 0; id < M; ++id) {\n int w = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (tileId[i][j] == id)\n w = max(w, val[i][j]);\n tileWeight[id] = w;\n totalMaxWeight += w;\n }\n\n visitedTile.assign(M, 0);\n startTime = steady_clock::now();\n \n runSearch();\n \n // Many restarts with different seeds\n for (int r = 0; r < 10 && !outOfTime(); ++r) {\n rng.seed(rng() + r * 9876543 + r * r * 54321);\n runSearch();\n }\n\n cout << bestMoves << '\\n';\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nconstexpr int N = 30;\nconstexpr int NH = N * (N - 1);\nconstexpr int NV = (N - 1) * N;\nconstexpr int E_total = NH + NV;\n\nconstexpr double SIGMA0 = 5000.0;\nconstexpr double VAR_FACTOR = 0.00333333333333;\nconstexpr double VAR_ROUND = 1.0 / 12.0;\nconstexpr double MIN_W = 100.0;\nconstexpr double MAX_W = 20000.0;\nconstexpr double MIN_VAR = 1.0;\nconstexpr double INIT_VAR = SIGMA0 * SIGMA0;\n\nint idxH[N][N - 1];\nint idxV[N - 1][N];\n\ninline int edgeIdx(int u, int v) {\n int ur = u / N, uc = u % N;\n int vr = v / N, vc = v % N;\n if (ur == vr) {\n return idxH[ur][min(uc, vc)];\n } else {\n return idxV[min(ur, vr)][uc];\n }\n}\n\ninline double getWeight(int e, const vector &w) { return w[e]; }\n\nvector dijkstra_path(int sr, int sc, int tr, int tc,\n const vector &weight,\n bool randomFlag,\n mt19937 &rng) {\n const int V = N * N;\n const int start = sr * N + sc;\n const int target = tr * N + tc;\n const double INF = 1e100;\n const double EPS = 1e-12;\n\n vector dist(V, INF);\n vector parent(V, -1);\n dist[start] = 0.0;\n\n using PDI = pair;\n priority_queue, greater> pq;\n pq.emplace(0.0, start);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u] + EPS) continue;\n if (u == target) break;\n\n int ur = u / N, uc = u % N;\n int nxt[4] = {ur > 0 ? (ur - 1) * N + uc : -1,\n ur + 1 < N ? (ur + 1) * N + uc : -1,\n uc > 0 ? ur * N + (uc - 1) : -1,\n uc + 1 < N ? ur * N + (uc + 1) : -1};\n\n for (int k = 0; k < 4; ++k) {\n int v = nxt[k];\n if (v < 0) continue;\n double w = getWeight(edgeIdx(u, v), weight);\n double nd = d + w;\n if (nd + EPS < dist[v]) {\n dist[v] = nd;\n parent[v] = u;\n pq.emplace(nd, v);\n } else if (fabs(nd - dist[v]) < EPS && randomFlag) {\n if (uniform_int_distribution(0, 1)(rng) == 0) {\n parent[v] = u;\n }\n }\n }\n }\n\n vector path;\n if (dist[target] == INF) return path;\n for (int cur = target; cur != -1; cur = parent[cur]) {\n path.push_back(cur);\n if (cur == start) break;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// Better exploration: find all shortest paths and pick one with max variance\nvector dijkstra_explore(int sr, int sc, int tr, int tc,\n const vector &weight,\n const vector &variance,\n mt19937 &rng) {\n const int V = N * N;\n const int start = sr * N + sc;\n const int target = tr * N + tc;\n const double INF = 1e100;\n const double EPS = 1e-12;\n\n vector dist(V, INF);\n vector parent(V, -1);\n dist[start] = 0.0;\n\n using PDI = pair;\n priority_queue, greater> pq;\n pq.emplace(0.0, start);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u] + EPS) continue;\n if (u == target) break;\n\n int ur = u / N, uc = u % N;\n int nxt[4] = {ur > 0 ? (ur - 1) * N + uc : -1,\n ur + 1 < N ? (ur + 1) * N + uc : -1,\n uc > 0 ? ur * N + (uc - 1) : -1,\n uc + 1 < N ? ur * N + (uc + 1) : -1};\n\n for (int k = 0; k < 4; ++k) {\n int v = nxt[k];\n if (v < 0) continue;\n double w = getWeight(edgeIdx(u, v), weight);\n double nd = d + w;\n if (nd + EPS < dist[v]) {\n dist[v] = nd;\n parent[v] = u;\n pq.emplace(nd, v);\n }\n }\n }\n\n if (dist[target] == INF) return {};\n\n // Collect all shortest paths using BFS from target\n vector> paths;\n vector> stack;\n stack.push_back({target});\n\n while (!stack.empty()) {\n vector cur = stack.back();\n stack.pop_back();\n int v = cur.back();\n if (v == start) {\n paths.push_back(cur);\n continue;\n }\n int p = parent[v];\n if (p == -1) continue;\n cur.push_back(p);\n stack.push_back(cur);\n }\n\n if (paths.empty()) return {};\n\n // Pick path with maximum total variance (explore uncertain edges)\n vector bestPath;\n double bestVar = -1.0;\n for (auto &p : paths) {\n double totalVar = 0.0;\n for (size_t i = 0; i + 1 < p.size(); ++i) {\n int e = edgeIdx(p[i], p[i + 1]);\n totalVar += variance[e];\n }\n if (totalVar > bestVar) {\n bestVar = totalVar;\n bestPath = p;\n }\n }\n reverse(bestPath.begin(), bestPath.end());\n return bestPath;\n}\n\nstring pathToString(const vector &verts) {\n string out;\n if (verts.empty()) return out;\n out.reserve(verts.size() - 1);\n for (size_t i = 0; i + 1 < verts.size(); ++i) {\n int ur = verts[i] / N, uc = verts[i] % N;\n int vr = verts[i + 1] / N, vc = verts[i + 1] % N;\n if (vr == ur + 1) out.push_back('D');\n else if (vr == ur - 1) out.push_back('U');\n else if (vc == uc + 1) out.push_back('R');\n else if (vc == uc - 1) out.push_back('L');\n }\n return out;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int eid = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N - 1; ++j)\n idxH[i][j] = eid++;\n for (int i = 0; i < N - 1; ++i)\n for (int j = 0; j < N; ++j)\n idxV[i][j] = eid++;\n\n vector x(E_total, 5000.0);\n vector var(E_total, INIT_VAR);\n\n mt19937 rng(1234567);\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) return 0;\n\n bool exploration = (q < 200);\n\n vector verts;\n if (exploration) {\n // Use variance-guided exploration\n verts = dijkstra_explore(si, sj, ti, tj, x, var, rng);\n if (verts.empty()) {\n verts = dijkstra_path(si, sj, ti, tj, x, false, rng);\n }\n } else {\n verts = dijkstra_path(si, sj, ti, tj, x, false, rng);\n }\n\n string out = pathToString(verts);\n cout << out << '\\n';\n cout.flush();\n\n long long observed;\n cin >> observed;\n\n if (verts.size() <= 1) continue;\n\n int L = (int)verts.size() - 1;\n vector edges;\n edges.reserve(L);\n double sumX = 0.0;\n double sumVar = 0.0;\n\n for (int i = 0; i < L; ++i) {\n int e = edgeIdx(verts[i], verts[i + 1]);\n edges.push_back(e);\n sumX += x[e];\n sumVar += var[e];\n }\n\n double R = VAR_FACTOR * sumX * sumX + VAR_ROUND;\n double S = sumVar + R;\n double residual = (double)observed - sumX;\n\n for (int e : edges) {\n double K = var[e] / S;\n x[e] += K * residual;\n if (x[e] < MIN_W) x[e] = MIN_W;\n if (x[e] > MAX_W) x[e] = MAX_W;\n var[e] *= (1.0 - K);\n if (var[e] < MIN_VAR) var[e] = MIN_VAR;\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int N = 20;\n\nint M;\nvector strs;\nvector slen;\n\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\nint countCoverage(const vector &mat) {\n int cnt = 0;\n for (int sid = 0; sid < M; ++sid) {\n const string &s = strs[sid];\n int L = slen[sid];\n bool ok = false;\n for (int r = 0; r < N && !ok; ++r) {\n for (int start = 0; start < N && !ok; ++start) {\n ok = true;\n for (int p = 0; p < L; ++p) {\n if (mat[r * N + (start + p) % N] != s[p]) { ok = false; break; }\n }\n }\n }\n if (!ok) {\n for (int c = 0; c < N && !ok; ++c) {\n for (int start = 0; start < N && !ok; ++start) {\n ok = true;\n for (int p = 0; p < L; ++p) {\n if (mat[((start + p) % N) * N + c] != s[p]) { ok = false; break; }\n }\n }\n }\n }\n if (ok) ++cnt;\n }\n return cnt;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int Ninput;\n if (!(cin >> Ninput >> M)) return 0;\n \n strs.resize(M);\n for (int i = 0; i < M; ++i) cin >> strs[i];\n \n slen.resize(M);\n for (int i = 0; i < M; ++i) slen[i] = (int)strs[i].size();\n \n vector bestMatrix(N * N, '.');\n int bestCoverage = 0;\n \n const int RESTARTS = 30;\n \n for (int restart = 0; restart < RESTARTS; ++restart) {\n vector mat(N * N, '.');\n \n // Build order and shuffle\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n \n // Greedy placement\n for (int idx : order) {\n const string &s = strs[idx];\n int L = slen[idx];\n bool placed = false;\n \n for (int attempt = 0; attempt < 500 && !placed; ++attempt) {\n int ori = rng() % 2;\n int line = rng() % N;\n int start = rng() % N;\n \n bool conflict = false;\n for (int p = 0; p < L; ++p) {\n int rr = ori == 0 ? line : (start + p) % N;\n int cc = ori == 0 ? (start + p) % N : line;\n if (mat[rr * N + cc] != '.' && mat[rr * N + cc] != s[p]) {\n conflict = true; break;\n }\n }\n if (conflict) continue;\n \n for (int p = 0; p < L; ++p) {\n int rr = ori == 0 ? line : (start + p) % N;\n int cc = ori == 0 ? (start + p) % N : line;\n mat[rr * N + cc] = s[p];\n }\n placed = true;\n }\n }\n \n // Aggressive mutation with random strings\n for (int iter = 0; iter < 25000; ++iter) {\n int sid = rng() % M;\n const string &s = strs[sid];\n int L = slen[sid];\n \n for (int attempt = 0; attempt < 150; ++attempt) {\n int ori = rng() % 2;\n int line = rng() % N;\n int start = rng() % N;\n \n bool conflict = false;\n for (int p = 0; p < L; ++p) {\n int rr = ori == 0 ? line : (start + p) % N;\n int cc = ori == 0 ? (start + p) % N : line;\n if (mat[rr * N + cc] != '.' && mat[rr * N + cc] != s[p]) {\n conflict = true; break;\n }\n }\n if (conflict) continue;\n \n for (int p = 0; p < L; ++p) {\n int rr = ori == 0 ? line : (start + p) % N;\n int cc = ori == 0 ? (start + p) % N : line;\n mat[rr * N + cc] = s[p];\n }\n break;\n }\n }\n \n int cov = countCoverage(mat);\n if (cov > bestCoverage) {\n bestCoverage = cov;\n bestMatrix = mat;\n if (bestCoverage == M) break;\n }\n }\n \n // Deletion phase\n if (bestCoverage == M) {\n for (int iter = 0; iter < 40000; ++iter) {\n vector occ;\n for (int i = 0; i < N * N; ++i)\n if (bestMatrix[i] != '.') occ.push_back(i);\n if (occ.empty()) break;\n \n int cellId = occ[rng() % occ.size()];\n char saved = bestMatrix[cellId];\n bestMatrix[cellId] = '.';\n \n if (countCoverage(bestMatrix) != M) {\n bestMatrix[cellId] = saved;\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j)\n cout << bestMatrix[i * N + j];\n cout << '\\n';\n }\n \n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector g(N);\n for (int i = 0; i < N; ++i) cin >> g[i];\n\n // ----- 1. vertex mapping ------------------------------------------------\n vector> id(N, vector(N, -1));\n vector weight; // weight of each vertex\n vector row, col; // coordinates\n int V = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (g[i][j] != '#') {\n id[i][j] = V++;\n weight.push_back(g[i][j] - '0');\n row.push_back(i);\n col.push_back(j);\n }\n\n // ----- 2. directed adjacency (cost = weight of destination) -------------\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n vector>> adj(V);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (id[i][j] != -1) {\n int u = id[i][j];\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int v = id[ni][nj];\n if (v == -1) continue;\n adj[u].push_back({v, weight[v]}); // cost = weight of v\n }\n }\n\n // start vertex id\n int start = id[si][sj];\n\n // ----- 3. all\u2011pairs shortest directed distances + predecessors ----------\n const int INF = 1e9;\n vector> dist(V, vector(V, INF));\n vector> parent(V, vector(V, -1));\n\n for (int s = 0; s < V; ++s) {\n priority_queue, vector>, greater>> pq;\n dist[s][s] = 0;\n pq.emplace(0, s);\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[s][u]) continue;\n for (auto [v, w] : adj[u]) {\n if (dist[s][v] > d + w) {\n dist[s][v] = d + w;\n parent[s][v] = u;\n pq.emplace(dist[s][v], v);\n }\n }\n }\n }\n\n // ----- 4. nearest\u2011neighbour tour (ATSP) --------------------------------\n vector tour;\n tour.reserve(V);\n vector visited(V, 0);\n tour.push_back(start);\n visited[start] = 1;\n int cur = start;\n while ((int)tour.size() < V) {\n int best = -1;\n int bestDist = INF;\n for (int v = 0; v < V; ++v) if (!visited[v]) {\n int d = dist[cur][v];\n if (d < bestDist) {\n bestDist = d;\n best = v;\n }\n }\n if (best == -1) break; // should never happen (graph is connected)\n visited[best] = 1;\n tour.push_back(best);\n cur = best;\n }\n\n // ----- 5. 2\u2011opt improvement --------------------------------------------\n bool improved = true;\n while (improved) {\n improved = false;\n int n = (int)tour.size();\n for (int i = 0; i < n - 1; ++i) {\n int u = tour[i];\n int v = tour[i + 1];\n for (int j = i + 2; j < n; ++j) {\n int x = tour[j];\n int y = (j + 1 == n ? tour[0] : tour[j + 1]);\n long long delta = (long long)dist[u][x] + dist[v][y]\n - ((long long)dist[u][v] + dist[x][y]);\n if (delta < 0) {\n reverse(tour.begin() + i + 1, tour.begin() + j + 1);\n improved = true;\n }\n }\n }\n }\n\n // ----- 6. reconstruct the actual walk ---------------------------------\n string moves;\n moves.reserve(200000); // enough for typical cases\n int n = (int)tour.size();\n for (int i = 0; i < n; ++i) {\n int src = tour[i];\n int dst = (i + 1 == n) ? tour[0] : tour[i + 1];\n // build shortest path src -> dst using predecessor table\n vector path;\n int curNode = dst;\n while (curNode != src) {\n path.push_back(curNode);\n curNode = parent[src][curNode];\n }\n path.push_back(src);\n reverse(path.begin(), path.end());\n for (size_t k = 0; k + 1 < path.size(); ++k) {\n int a = path[k];\n int b = path[k + 1];\n int dr = row[b] - row[a];\n int dc = col[b] - col[a];\n if (dr == -1) moves.push_back('U');\n else if (dr == 1) moves.push_back('D');\n else if (dc == -1) moves.push_back('L');\n else if (dc == 1) moves.push_back('R');\n // else: never happens (grid neighbours only)\n }\n }\n\n cout << moves << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint N, M, K;\nvector> d;\nvector> LB;\nvector> UB;\nvector> pred_cache;\nvector speed;\nvector> succ;\nvector topo;\nvector indeg;\n\ninline int get_pred(int w, int task) {\n int& cached = pred_cache[w][task];\n if (cached > 0) return cached;\n \n double exp_def = 0.0;\n for (int k = 0; k < K; ++k) {\n int req = d[task][k];\n int L = LB[w][k];\n int U = UB[w][k];\n if (req > L) {\n if (req >= U) {\n exp_def += req - (L + U) * 0.5;\n } else {\n double diff = req - L;\n exp_def += diff * diff / (2.0 * (U - L));\n }\n }\n }\n cached = max(1, (int)ceil(exp_def * speed[w]) + 1);\n return cached;\n}\n\n// Compute task difficulty (sum of required skills)\ninline int task_difficulty(int task) {\n int sum = 0;\n for (int k = 0; k < K; ++k) sum += d[task][k];\n return sum;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n if (!(cin >> N >> M >> K)) return 0;\n int R;\n cin >> R;\n \n d.assign(N, vector(K));\n for (int i = 0; i < N; ++i)\n for (int k = 0; k < K; ++k)\n cin >> d[i][k];\n \n succ.assign(N, {});\n indeg.assign(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n succ[u].push_back(v);\n ++indeg[v];\n }\n \n vector maxReq(K, 0);\n for (int i = 0; i < N; ++i)\n for (int k = 0; k < K; ++k)\n maxReq[k] = max(maxReq[k], d[i][k]);\n \n topo.clear();\n {\n vector indeg_copy = indeg;\n queue q;\n for (int i = 0; i < N; ++i)\n if (indeg_copy[i] == 0) q.push(i);\n while (!q.empty()) {\n int v = q.front(); q.pop();\n topo.push_back(v);\n for (int nxt : succ[v])\n if (--indeg_copy[nxt] == 0) q.push(nxt);\n }\n }\n \n vector indeg_rem = indeg;\n vector status(N, 0);\n vector assigned_task(M, -1);\n vector start_day(M, -1);\n vector cur_pred(M, 0);\n \n LB.assign(M, vector(K, 0));\n UB.assign(M, vector(K));\n for (int j = 0; j < M; ++j) UB[j] = maxReq;\n \n pred_cache.assign(M, vector(N, 0));\n \n speed.assign(M, 1.0);\n vector real_time(M, 0), pred_time(M, 0);\n vector completed_count(M, 0);\n \n vector ready;\n for (int i = 0; i < N; ++i)\n if (indeg[i] == 0) ready.push_back(i);\n \n vector height(N, 1);\n {\n vector best_dur(N, 1);\n for (int idx = (int)topo.size() - 1; idx >= 0; --idx) {\n int v = topo[idx];\n int max_succ = 0;\n for (int nxt : succ[v]) max_succ = max(max_succ, height[nxt]);\n height[v] = best_dur[v] + max_succ;\n }\n }\n \n auto update_bounds = [&](int w, int task, int duration) {\n int U_est = duration + 3;\n \n for (int k = 0; k < K; ++k) {\n int req = d[task][k];\n if (U_est == 0) {\n LB[w][k] = max(LB[w][k], req);\n } else {\n LB[w][k] = max(LB[w][k], max(0, req - U_est));\n }\n }\n fill(pred_cache[w].begin(), pred_cache[w].end(), 0);\n \n if (cur_pred[w] > 0) {\n real_time[w] += duration;\n pred_time[w] += cur_pred[w];\n if (pred_time[w] > 0) {\n speed[w] = (double)real_time[w] / pred_time[w];\n if (speed[w] < 0.1) speed[w] = 0.1;\n if (speed[w] > 10.0) speed[w] = 10.0;\n }\n }\n completed_count[w]++;\n };\n \n int day = 0;\n while (true) {\n ++day;\n \n vector idle;\n for (int w = 0; w < M; ++w)\n if (assigned_task[w] == -1) idle.push_back(w);\n \n vector ready_tasks;\n for (int t : ready)\n if (status[t] == 0) ready_tasks.push_back(t);\n \n vector> assign;\n \n if (!idle.empty() && !ready_tasks.empty()) {\n // Sort workers: less experienced first for early exploration\n sort(idle.begin(), idle.end(), [&](int a, int b) {\n return real_time[a] < real_time[b];\n });\n \n vector used(N, 0);\n \n for (int w : idle) {\n int best_task = -1;\n int best_score = INT_MIN;\n int best_dur = INT_MAX;\n \n // Find best task based on score\n for (int t : ready_tasks) {\n if (used[t]) continue;\n int dur = get_pred(w, t);\n int score = height[t] * 100 - dur;\n \n // Adaptive noise: more noise for less experienced workers\n // and more noise for harder tasks\n int worker_exp = completed_count[w];\n int task_diff = task_difficulty(t);\n int noise_range = 20 - min(15, worker_exp / 2);\n noise_range += task_diff / 50; // More noise for harder tasks\n int noise = (rand() % (noise_range * 2 + 1)) - noise_range;\n score += noise;\n \n if (score > best_score || (score == best_score && dur < best_dur)) {\n best_score = score;\n best_task = t;\n best_dur = dur;\n }\n }\n \n if (best_task >= 0) {\n used[best_task] = 1;\n assign.emplace_back(w + 1, best_task + 1);\n assigned_task[w] = best_task;\n start_day[w] = day;\n cur_pred[w] = get_pred(w, best_task);\n status[best_task] = 1;\n }\n }\n }\n \n if (assign.empty()) {\n cout << 0 << \"\\n\";\n } else {\n cout << assign.size();\n for (auto &p : assign) cout << ' ' << p.first << ' ' << p.second;\n cout << \"\\n\";\n }\n cout.flush();\n \n int n_finish;\n cin >> n_finish;\n if (n_finish == -1) break;\n \n for (int i = 0; i < n_finish; ++i) {\n int w; cin >> w; --w;\n int tsk = assigned_task[w];\n if (tsk == -1) continue;\n \n int duration = day - start_day[w] + 1;\n update_bounds(w, tsk, duration);\n \n status[tsk] = 2;\n assigned_task[w] = -1;\n start_day[w] = -1;\n cur_pred[w] = 0;\n \n for (int nxt : succ[tsk]) {\n --indeg_rem[nxt];\n if (indeg_rem[nxt] == 0 && status[nxt] == 0) {\n ready.push_back(nxt);\n }\n }\n }\n \n if (day >= 2000) break;\n }\n \n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nconst int BASE = 0;\nint NPOINTS;\nvector X, Y;\nint pickNode[1000];\nint delvNode[1000];\nbool isPick[2001];\nint orderOf[2001];\n\ninline int manhattan(int a, int b) {\n return abs(X[a] - X[b]) + abs(Y[a] - Y[b]);\n}\n\ninline int idxAfterRem(int p, int removed) {\n return (p < removed) ? p : p + 1;\n}\n\nlong long tourLength(const vector& tour) {\n if (tour.empty()) return 0;\n long long len = manhattan(BASE, tour[0]) + manhattan(tour.back(), BASE);\n for (int i = 0; i + 1 < (int)tour.size(); ++i)\n len += manhattan(tour[i], tour[i + 1]);\n return len;\n}\n\nvector buildInitialTour(const vector& orders) {\n vector pickups, deliveries;\n pickups.reserve(orders.size());\n deliveries.reserve(orders.size());\n for (int o : orders) {\n pickups.push_back(pickNode[o]);\n deliveries.push_back(delvNode[o]);\n }\n\n vector tour;\n int cur = BASE;\n int m = (int)pickups.size();\n vector used(m, 0);\n while ((int)tour.size() < m) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < m; ++i) if (!used[i]) {\n int d = manhattan(cur, pickups[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n used[best] = 1;\n tour.push_back(pickups[best]);\n cur = pickups[best];\n }\n\n int dsz = (int)deliveries.size();\n vector usedD(dsz, 0);\n while ((int)tour.size() < m + dsz) {\n int best = -1, bestDist = INT_MAX;\n for (int i = 0; i < dsz; ++i) if (!usedD[i]) {\n int d = manhattan(cur, deliveries[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n usedD[best] = 1;\n tour.push_back(deliveries[best]);\n cur = deliveries[best];\n }\n return tour;\n}\n\n// Relocate with given window size\nvoid relocateImprove(vector& tour, const vector& selected, int WINDOW) {\n int n = (int)tour.size();\n vector pos(NPOINTS, -1);\n auto updatePos = [&]() {\n fill(pos.begin(), pos.end(), -1);\n for (int i = 0; i < n; ++i) pos[tour[i]] = i;\n };\n updatePos();\n\n auto feasibleRelocate = [&](int node, int a, int newPos) -> bool {\n int oid = orderOf[node];\n int other = isPick[node] ? delvNode[oid] : pickNode[oid];\n int otherPos = pos[other];\n if (otherPos == -1) return true;\n\n int otherPosR = (otherPos > a) ? otherPos - 1 : otherPos;\n int b2 = (newPos > a) ? newPos - 1 : newPos;\n int finalPosNode = b2;\n int finalPosOther = otherPosR;\n if (finalPosOther >= b2) ++finalPosOther;\n\n if (isPick[node]) return finalPosNode < finalPosOther;\n return finalPosOther < finalPosNode;\n };\n\n bool progress = true;\n while (progress) {\n progress = false;\n int bestNode = -1, bestNewPos = -1;\n long long bestDelta = 0;\n\n for (int i = 0; i < n; ++i) {\n int node = tour[i];\n int start = max(0, i - WINDOW);\n int end = min(n, i + WINDOW);\n for (int np = start; np <= end; ++np) {\n if (np == i) continue;\n if (!feasibleRelocate(node, i, np)) continue;\n\n int L = (i == 0) ? BASE : tour[i - 1];\n int R = (i == n - 1) ? BASE : tour[i + 1];\n long long delta = manhattan(L, R) - manhattan(L, node) - manhattan(node, R);\n\n int b2 = (np > i) ? np - 1 : np;\n int L2 = (b2 == 0) ? BASE : tour[idxAfterRem(b2 - 1, i)];\n int R2 = (b2 == n - 1) ? BASE : tour[idxAfterRem(b2, i)];\n delta += manhattan(L2, node) + manhattan(node, R2) - manhattan(L2, R2);\n\n if (delta < bestDelta) {\n bestDelta = delta;\n bestNode = node;\n bestNewPos = np;\n progress = true;\n }\n }\n }\n if (bestDelta < 0) {\n int a = -1;\n for (int k = 0; k < n; ++k) if (tour[k] == bestNode) { a = k; break; }\n tour.erase(tour.begin() + a);\n int b2 = (bestNewPos > a) ? bestNewPos - 1 : bestNewPos;\n tour.insert(tour.begin() + b2, bestNode);\n n = (int)tour.size();\n updatePos();\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int ORD = 1000;\n vector> orders(ORD);\n for (int i = 0; i < ORD; ++i) {\n cin >> orders[i][0] >> orders[i][1] >> orders[i][2] >> orders[i][3];\n }\n\n NPOINTS = 1 + 2 * ORD;\n X.resize(NPOINTS);\n Y.resize(NPOINTS);\n X[BASE] = 400; Y[BASE] = 400;\n for (int i = 0; i < ORD; ++i) {\n int pi = 2 * i + 1;\n int di = 2 * i + 2;\n X[pi] = orders[i][0]; Y[pi] = orders[i][1];\n X[di] = orders[i][2]; Y[di] = orders[i][3];\n pickNode[i] = pi;\n delvNode[i] = di;\n isPick[pi] = true; isPick[di] = false;\n orderOf[pi] = orderOf[di] = i;\n }\n\n vector greedyIdx(ORD);\n iota(greedyIdx.begin(), greedyIdx.end(), 0);\n vector cost(ORD);\n for (int i = 0; i < ORD; ++i) {\n cost[i] = manhattan(BASE, pickNode[i])\n + manhattan(pickNode[i], delvNode[i])\n + manhattan(delvNode[i], BASE);\n }\n sort(greedyIdx.begin(), greedyIdx.end(),\n [&](int a, int b){ return cost[a] < cost[b]; });\n\n vector bestSubset;\n vector bestTour;\n long long bestLength = (1LL<<60);\n\n auto trySubset = [&](const vector& sub) {\n vector tour = buildInitialTour(sub);\n relocateImprove(tour, sub, 3);\n relocateImprove(tour, sub, 4);\n relocateImprove(tour, sub, 5);\n long long L = tourLength(tour);\n if (L < bestLength) {\n bestLength = L;\n bestTour = tour;\n bestSubset = sub;\n }\n };\n\n // Try greedy subset\n vector firstSubset(greedyIdx.begin(), greedyIdx.begin() + 50);\n trySubset(firstSubset);\n\n // Try greedy variants with different offsets\n for (int offset = 0; offset < 20; ++offset) {\n vector sub;\n for (int k = 0; k < 50; ++k) {\n sub.push_back(greedyIdx[(offset + k) % ORD]);\n }\n trySubset(sub);\n }\n\n // Try many random subsets\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n int trial = 0;\n const int MAX_TRIAL = 50;\n auto start = chrono::steady_clock::now();\n while (trial < MAX_TRIAL) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > 1.55) break;\n\n vector ids(ORD);\n iota(ids.begin(), ids.end(), 0);\n shuffle(ids.begin(), ids.end(), rng);\n vector sub(ids.begin(), ids.begin() + 50);\n trySubset(sub);\n ++trial;\n }\n\n // Extra improvement on best\n for (int r = 0; r < 8; ++r) {\n if (bestTour.empty()) break;\n relocateImprove(bestTour, bestSubset, 3);\n relocateImprove(bestTour, bestSubset, 4);\n relocateImprove(bestTour, bestSubset, 5);\n }\n\n cout << 50;\n for (int x : bestSubset) cout << ' ' << (x + 1);\n cout << '\\n';\n\n cout << (int)bestTour.size() + 2;\n cout << \" 400 400\";\n for (int v : bestTour) cout << ' ' << X[v] << ' ' << Y[v];\n cout << \" 400 400\\n\";\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\n/*** Disjoint Set Union ********************************************/\nstruct DSU {\n vector parent, rank_;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n parent.resize(n);\n rank_.assign(n, 0);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int x) {\n return parent[x] == x ? x : parent[x] = find(parent[x]);\n }\n bool unite(int a, int b) {\n a = find(a);\n b = find(b);\n if (a == b) return false;\n if (rank_[a] < rank_[b]) swap(a, b);\n parent[b] = a;\n if (rank_[a] == rank_[b]) ++rank_[a];\n return true;\n }\n};\n/******************************************************************/\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int N = 400;\n const int M = 1995;\n\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) cin >> X[i] >> Y[i];\n\n vector U(M), V(M);\n for (int i = 0; i < M; ++i) cin >> U[i] >> V[i];\n\n vector d(M);\n for (int i = 0; i < M; ++i) {\n long long dx = (long long)X[U[i]] - X[V[i]];\n long long dy = (long long)Y[U[i]] - Y[V[i]];\n double dist = sqrt((double)dx * dx + (double)dy * dy);\n d[i] = (int)llround(dist);\n }\n\n vector inTree(M, 0);\n vector order(M);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b) {\n if (d[a] != d[b]) return d[a] < d[b];\n return a < b;\n });\n\n DSU dsu_mst(N);\n int taken = 0;\n for (int id : order) {\n if (dsu_mst.unite(U[id], V[id])) {\n inTree[id] = 1;\n ++taken;\n if (taken == N - 1) break;\n }\n }\n\n vector>> adj(N);\n for (int i = 0; i < M; ++i) {\n if (inTree[i]) {\n adj[U[i]].push_back({V[i], i});\n adj[V[i]].push_back({U[i], i});\n }\n }\n\n vector depth(N, 0), parent(N, -1), parentEdge(N, -1);\n function dfs = [&](int v, int p) {\n for (auto [to, eidx] : adj[v]) {\n if (to == p) continue;\n depth[to] = depth[v] + 1;\n parent[to] = v;\n parentEdge[to] = eidx;\n dfs(to, v);\n }\n };\n dfs(0, -1);\n\n auto maxOnPath = [&](int u, int v) {\n int mx = 0;\n while (depth[u] > depth[v]) {\n mx = max(mx, d[parentEdge[u]]);\n u = parent[u];\n }\n while (depth[v] > depth[u]) {\n mx = max(mx, d[parentEdge[v]]);\n v = parent[v];\n }\n while (u != v) {\n mx = max(mx, d[parentEdge[u]]);\n mx = max(mx, d[parentEdge[v]]);\n u = parent[u];\n v = parent[v];\n }\n return mx;\n };\n\n vector dmax(M);\n for (int i = 0; i < M; ++i) {\n if (inTree[i]) {\n dmax[i] = d[i];\n } else {\n dmax[i] = maxOnPath(U[i], V[i]);\n }\n }\n\n DSU dsu(N);\n for (int i = 0; i < M; ++i) {\n int L;\n cin >> L;\n\n int decision = 0;\n if (dsu.find(U[i]) != dsu.find(V[i])) {\n // More selective: use 1.35 = 27/20\n if (inTree[i] || L * 20 <= 27 * dmax[i]) { // L <= 1.35 * dmax\n decision = 1;\n dsu.unite(U[i], V[i]);\n }\n }\n cout << decision << '\\n' << flush;\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nconst int SZ = 30;\nconst int MAX_WALLS = 150;\n\nstruct Pet {\n int x, y, type;\n};\n\nstruct Human {\n int x, y;\n int hx, hy;\n int walls = 0;\n int phase = 0;\n int stuckTurns = 0;\n};\n\nint sgn(int a) { return (a > 0) - (a < 0); }\n\nint dirX[4] = {-1, 1, 0, 0};\nint dirY[4] = { 0, 0,-1, 1};\nchar wCh[4] = {'u','d','l','r'};\nchar mCh[4] = {'U','D','L','R'};\n\ninline bool inside(int x, int y) { return x >= 1 && x <= SZ && y >= 1 && y <= SZ; }\n\nbool wall[SZ + 1][SZ + 1];\nbool petAt[SZ + 1][SZ + 1];\n\ninline bool passable(int x, int y) { return inside(x, y) && !wall[x][y]; }\n\nvector pets;\nvector hums;\n\nbool petOn(int x, int y) { return petAt[x][y]; }\n\nbool humanOn(int x, int y) {\n for (const Human &h : hums)\n if (h.x == x && h.y == y) return true;\n return false;\n}\n\nbool adjacentPet(int x, int y) {\n for (int d = 0; d < 4; ++d) {\n int nx = x + dirX[d], ny = y + dirY[d];\n if (inside(nx, ny) && petAt[nx][ny]) return true;\n }\n return false;\n}\n\nint countAdjacentPets(int x, int y) {\n int cnt = 0;\n for (int d = 0; d < 4; ++d) {\n int nx = x + dirX[d], ny = y + dirY[d];\n if (inside(nx, ny) && petAt[nx][ny]) ++cnt;\n }\n return cnt;\n}\n\nint distToNearestPet(int x, int y) {\n int best = 1000;\n for (const Pet &p : pets)\n best = min(best, abs(p.x - x) + abs(p.y - y));\n return best;\n}\n\nbool canWallAt(int x, int y) {\n if (!inside(x, y)) return false;\n if (wall[x][y]) return false;\n if (petOn(x, y) || humanOn(x, y)) return false;\n if (adjacentPet(x, y)) return false;\n return true;\n}\n\nbool canMoveDir(int x, int y, int dir) {\n int nx = x + dirX[dir], ny = y + dirY[dir];\n return inside(nx, ny) && passable(nx, ny);\n}\n\nint countPassableNeighborsEx(int x, int y, int excludeDir) {\n int cnt = 0;\n for (int d = 0; d < 4; ++d) {\n if (d == excludeDir) continue;\n int nx = x + dirX[d], ny = y + dirY[d];\n if (passable(nx, ny)) ++cnt;\n }\n return cnt;\n}\n\nint dirIndex(int x, int y, int tx, int ty) {\n if (tx == x-1) return 0;\n if (tx == x+1) return 1;\n if (ty == y-1) return 2;\n if (ty == y+1) return 3;\n return -1;\n}\n\nbool isCorner(int x, int y) {\n return (x <= 2 || x >= SZ-1) && (y <= 2 || y >= SZ-1);\n}\n\n// Check if a path exists from (sx,sy) to (tx,ty) avoiding pets and walls\nbool pathExists(int sx, int sy, int tx, int ty) {\n if (sx == tx && sy == ty) return true;\n bool vis[SZ+1][SZ+1] = {false};\n queue> q;\n q.push({sx, sy});\n vis[sx][sy] = true;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n for (int d = 0; d < 4; ++d) {\n int nx = x + dirX[d], ny = y + dirY[d];\n if (!inside(nx, ny) || !passable(nx, ny) || vis[nx][ny]) continue;\n // Avoid squares with pets for pathfinding\n if (petAt[nx][ny]) continue;\n if (nx == tx && ny == ty) return true;\n vis[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n return false;\n}\n\nvoid assignZones() {\n vector> cand = {\n {1,1}, {1,SZ}, {SZ,1}, {SZ,SZ},\n {1,SZ/2}, {SZ,SZ/2}, {SZ/2,1}, {SZ/2,SZ},\n {2,2}, {2,SZ-1}, {SZ-1,2}, {SZ-1,SZ-1},\n {1,3}, {3,1}, {SZ,3}, {SZ-2,1},\n {1,SZ-2}, {3,SZ}, {SZ,SZ-2}, {SZ-2,SZ}\n };\n \n vector> used;\n \n for (size_t i = 0; i < hums.size(); ++i) {\n int bestIdx = -1;\n int bestScore = -1;\n \n for (size_t j = 0; j < cand.size(); ++j) {\n bool taken = false;\n for (auto u : used)\n if (u == cand[j]) { taken = true; break; }\n if (taken) continue;\n \n // Check if we can actually reach this corner\n if (!pathExists(hums[i].x, hums[i].y, cand[j].first, cand[j].second)) continue;\n \n int safety = distToNearestPet(cand[j].first, cand[j].second);\n int corner = isCorner(cand[j].first, cand[j].second) ? 10 : 0;\n int score = safety + corner;\n \n if (score > bestScore) {\n bestScore = score;\n bestIdx = j;\n }\n }\n \n // If no reachable corner, pick any safe-looking one\n if (bestIdx < 0) {\n for (size_t j = 0; j < cand.size(); ++j) {\n bool taken = false;\n for (auto u : used)\n if (u == cand[j]) { taken = true; break; }\n if (taken) continue;\n \n int safety = distToNearestPet(cand[j].first, cand[j].second);\n int corner = isCorner(cand[j].first, cand[j].second) ? 10 : 0;\n int score = safety + corner;\n \n if (score > bestScore) {\n bestScore = score;\n bestIdx = j;\n }\n }\n }\n \n if (bestIdx >= 0) {\n hums[i].hx = cand[bestIdx].first;\n hums[i].hy = cand[bestIdx].second;\n used.push_back(cand[bestIdx]);\n }\n }\n}\n\n// Try to find a new reachable zone for a blocked human\nbool findNewZone(Human& h) {\n vector> cand = {\n {1,1}, {1,SZ}, {SZ,1}, {SZ,SZ},\n {2,2}, {2,SZ-1}, {SZ-1,2}, {SZ-1,SZ-1},\n {1,SZ/2}, {SZ,SZ/2}, {SZ/2,1}, {SZ/2,SZ}\n };\n \n int bestIdx = -1;\n int bestScore = -1;\n \n for (size_t j = 0; j < cand.size(); ++j) {\n if (cand[j].first == h.hx && cand[j].second == h.hy) continue;\n if (!pathExists(h.x, h.y, cand[j].first, cand[j].second)) continue;\n \n int safety = distToNearestPet(cand[j].first, cand[j].second);\n int corner = isCorner(cand[j].first, cand[j].second) ? 10 : 0;\n int score = safety + corner;\n \n if (score > bestScore) {\n bestScore = score;\n bestIdx = j;\n }\n }\n \n if (bestIdx >= 0) {\n h.hx = cand[bestIdx].first;\n h.hy = cand[bestIdx].second;\n h.stuckTurns = 0;\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;\n if (!(cin >> N)) return 0;\n pets.resize(N);\n for (int i = 0; i < N; ++i) cin >> pets[i].x >> pets[i].y >> pets[i].type;\n\n int M;\n cin >> M;\n hums.resize(M);\n for (int i = 0; i < M; ++i) cin >> hums[i].x >> hums[i].y;\n\n for (int x = 1; x <= SZ; ++x)\n for (int y = 1; y <= SZ; ++y)\n wall[x][y] = false;\n\n for (int i = 0; i < N; ++i) petAt[pets[i].x][pets[i].y] = true;\n\n assignZones();\n\n for (int turn = 1; turn <= 300; ++turn) {\n vector actDir(M, -1);\n vector actWall(M, false);\n pair wallTargets[10];\n bool hasTarget[10] = {false};\n\n for (int i = 0; i < M; ++i) {\n Human &h = hums[i];\n \n if (h.phase == 0 && h.x == h.hx && h.y == h.hy) {\n h.phase = 1;\n }\n \n if (h.phase == 0) {\n int sx = sgn(h.hx - h.x);\n int sy = sgn(h.hy - h.y);\n \n bool moved = false;\n \n if (sx != 0) {\n for (int d = 0; d < 4; ++d) {\n if (dirX[d] == sx && dirY[d] == 0) {\n if (canMoveDir(h.x, h.y, d)) {\n actDir[i] = d;\n moved = true;\n h.stuckTurns = 0;\n break;\n }\n }\n }\n }\n if (!moved && sy != 0) {\n for (int d = 0; d < 4; ++d) {\n if (dirX[d] == 0 && dirY[d] == sy) {\n if (canMoveDir(h.x, h.y, d)) {\n actDir[i] = d;\n moved = true;\n h.stuckTurns = 0;\n break;\n }\n }\n }\n }\n \n if (!moved) {\n // Check if path to zone is blocked by pets\n bool blocked = !pathExists(h.x, h.y, h.hx, h.hy);\n \n if (blocked) {\n h.stuckTurns++;\n // Try to find new zone after being stuck for a few turns\n if (h.stuckTurns > 3 && findNewZone(h)) {\n // New zone found, try to move toward it\n int nsx = sgn(h.hx - h.x);\n int nsy = sgn(h.hy - h.y);\n for (int d = 0; d < 4; ++d) {\n if (dirX[d] == nsx && dirY[d] == nsy && canMoveDir(h.x, h.y, d)) {\n actDir[i] = d;\n moved = true;\n break;\n }\n }\n }\n }\n \n // Try any direction\n if (!moved) {\n for (int d = 0; d < 4; ++d) {\n if (canMoveDir(h.x, h.y, d)) {\n actDir[i] = d;\n break;\n }\n }\n }\n }\n } else {\n int distPet = distToNearestPet(h.x, h.y);\n bool inDanger = (distPet <= 1 && countAdjacentPets(h.x, h.y) > 0);\n \n if (inDanger) {\n int bestDir = -1;\n int bestDist = -1;\n for (int d = 0; d < 4; ++d) {\n if (!canMoveDir(h.x, h.y, d)) continue;\n int nx = h.x + dirX[d], ny = h.y + dirY[d];\n int newDist = distToNearestPet(nx, ny);\n if (newDist > bestDist) {\n bestDist = newDist;\n bestDir = d;\n }\n }\n if (bestDir != -1) actDir[i] = bestDir;\n } else if (h.walls < MAX_WALLS) {\n vector, int>> options;\n \n for (int d = 0; d < 4; ++d) {\n int nx = h.x + dirX[d], ny = h.y + dirY[d];\n if (!canWallAt(nx, ny)) continue;\n \n int escape = countPassableNeighborsEx(h.x, h.y, d);\n if (escape < 1 && h.walls > 0) continue;\n \n int score = 0;\n \n score += countAdjacentPets(nx, ny) * 20;\n \n int perimeter = 0;\n for (int pd = 0; pd < 4; ++pd) {\n int px = nx + dirX[pd], py = ny + dirY[pd];\n if (inside(px, py) && wall[px][py]) ++perimeter;\n }\n score += perimeter * 8;\n \n if ((nx == 1 || nx == SZ) && (ny == 1 || ny == SZ)) score += 12;\n else if (nx == 1 || nx == SZ || ny == 1 || ny == SZ) score += 6;\n \n if (escape >= 2 && perimeter >= 2) score += 8;\n \n options.push_back({{nx, ny}, score});\n }\n \n if (!options.empty()) {\n sort(options.begin(), options.end(),\n [](auto &a, auto &b) { return a.second > b.second; });\n \n actWall[i] = true;\n wallTargets[i] = options[0].first;\n hasTarget[i] = true;\n actDir[i] = dirIndex(h.x, h.y, options[0].first.first, options[0].first.second);\n ++h.walls;\n } else {\n int bestDir = -1;\n int bestDist = -1;\n for (int d = 0; d < 4; ++d) {\n if (!canMoveDir(h.x, h.y, d)) continue;\n int nx = h.x + dirX[d], ny = h.y + dirY[d];\n int newDist = distToNearestPet(nx, ny);\n if (newDist > bestDist) {\n bestDist = newDist;\n bestDir = d;\n }\n }\n if (bestDir != -1) actDir[i] = bestDir;\n }\n }\n }\n }\n\n for (int i = 0; i < M; ++i) {\n if (!actWall[i]) continue;\n for (int j = i + 1; j < M; ++j) {\n if (!actWall[j]) continue;\n if (wallTargets[i] == wallTargets[j]) {\n if (hums[i].walls > hums[j].walls) {\n actWall[j] = false;\n hasTarget[j] = false;\n int tdx = wallTargets[i].first - hums[j].x;\n int tdy = wallTargets[i].second - hums[j].y;\n for (int d = 0; d < 4; ++d) {\n if (dirX[d] == -sgn(tdx) && dirY[d] == -sgn(tdy)) {\n if (canMoveDir(hums[j].x, hums[j].y, d)) {\n actDir[j] = d;\n break;\n }\n }\n }\n } else {\n actWall[i] = false;\n hasTarget[i] = false;\n }\n }\n }\n }\n\n bool willWall[SZ + 1][SZ + 1] = {false};\n bool willMove[SZ + 1][SZ + 1] = {false};\n\n for (int i = 0; i < M; ++i) {\n if (actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (inside(nx, ny)) willWall[nx][ny] = true;\n }\n if (actDir[i] != -1 && !actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (inside(nx, ny)) willMove[nx][ny] = true;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n if (actDir[i] != -1 && !actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (willWall[nx][ny]) {\n actDir[i] = -1;\n willMove[nx][ny] = false;\n }\n }\n if (actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (willMove[nx][ny]) {\n actWall[i] = false;\n actDir[i] = -1;\n }\n }\n }\n\n string out;\n out.reserve(M);\n for (int i = 0; i < M; ++i) {\n if (actDir[i] == -1) out.push_back('.');\n else if (actWall[i]) out.push_back(wCh[actDir[i]]);\n else out.push_back(mCh[actDir[i]]);\n }\n cout << out << '\\n' << flush;\n\n for (int i = 0; i < M; ++i) {\n if (actWall[i]) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (inside(nx, ny) && !wall[nx][ny]) wall[nx][ny] = true;\n } else if (actDir[i] != -1) {\n int nx = hums[i].x + dirX[actDir[i]];\n int ny = hums[i].y + dirY[actDir[i]];\n if (inside(nx, ny) && passable(nx, ny)) {\n hums[i].x = nx;\n hums[i].y = ny;\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (char c : s) {\n int dir = -1;\n if (c == 'U') dir = 0;\n else if (c == 'D') dir = 1;\n else if (c == 'L') dir = 2;\n else if (c == 'R') dir = 3;\n else continue;\n int nx = pets[i].x + dirX[dir];\n int ny = pets[i].y + dirY[dir];\n if (inside(nx, ny) && passable(nx, ny)) {\n pets[i].x = nx;\n pets[i].y = ny;\n }\n }\n }\n\n for (int x = 1; x <= SZ; ++x)\n for (int y = 1; y <= SZ; ++y)\n petAt[x][y] = false;\n for (const Pet &p : pets) petAt[p.x][p.y] = true;\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int si, sj, ti, tj;\n double p;\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n const int N = 20;\n vector h(N); // horizontal walls, size 20 \u00d7 19\n for (int i = 0; i < N; ++i) cin >> h[i];\n vector v(N - 1); // vertical walls, size 19 \u00d7 20\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n\n // directions: 0=U, 1=D, 2=L, 3=R\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dch[4] = {'U', 'D', 'L', 'R'};\n\n auto can_move = [&](int i, int j, int dir) -> bool {\n if (dir == 0) { // up\n if (i == 0) return false;\n return v[i - 1][j] == '0';\n } else if (dir == 1) { // down\n if (i == N - 1) return false;\n return v[i][j] == '0';\n } else if (dir == 2) { // left\n if (j == 0) return false;\n return h[i][j - 1] == '0';\n } else { // right\n if (j == N - 1) return false;\n return h[i][j] == '0';\n }\n };\n\n // BFS\n vector> dist(N, vector(N, -1));\n vector>> prev(N, vector>(N, {-1,-1}));\n vector> pred_dir(N, vector(N, 0));\n\n queue> q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break; // reached destination\n for (int dir = 0; dir < 4; ++dir) {\n if (!can_move(i, j, dir)) continue;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (dist[ni][nj] != -1) continue;\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n pred_dir[ni][nj] = dch[dir];\n q.emplace(ni, nj);\n }\n }\n\n // reconstruct shortest path\n string path;\n int ci = ti, cj = tj;\n while (!(ci == si && cj == sj)) {\n path.push_back(pred_dir[ci][cj]);\n auto pr = prev[ci][cj];\n ci = pr.first; cj = pr.second;\n }\n reverse(path.begin(), path.end());\n\n int d = (int)path.size();\n string ans;\n\n if (d == 0) { // start equals office\n cout << \"\\n\";\n return 0;\n }\n\n if (d <= 200) {\n ans.reserve(200);\n for (int i = 0; i < 200; ++i) ans.push_back(path[i % d]);\n } else { // distance larger than 200 \u2192 impossible to succeed\n ans = path.substr(0, 200); // any 200 characters are fine\n }\n\n cout << ans << '\\n';\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30, W = 30, N = H * W;\n\n/* directions: 0 left, 1 up, 2 right, 3 down */\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\ninline int neighbor_id(int idx, int dir) {\n int i = idx / W, j = idx % W;\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) return -1;\n return ni * W + nj;\n}\n\n/* --------------------------------------------------------------- */\n/* pre\u2011computed neighbour lists for every tile and every rotation */\nvector>> neigh;\n\n/* --------------------------------------------------------------- */\nvector> adj;\n\n/* ----- component handling -------------------------------------- */\nvector compId;\nvector> compNodes;\nvector compEdge;\n\nstruct Cmp {\n bool operator()(const pair& a, const pair& b) const {\n if (a.first != b.first) return a.first < b.first;\n return a.second < b.second;\n }\n};\nmultiset, Cmp> compSet;\n\n/* --------------------------------------------------------------- */\ninline int get_score() {\n if (compSet.empty()) return 0;\n auto it = compSet.begin();\n int L1 = -it->first;\n ++it;\n int L2 = (it == compSet.end()) ? 0 : -it->first;\n return L1 * L2;\n}\n\n/* --------------------------------------------------------------- */\ninline void addAdj(int u, int v) {\n adj[u].push_back(v);\n adj[v].push_back(u);\n}\n\n/* --------------------------------------------------------------- */\nvoid addEdge(int u, int v) {\n for (int nb : adj[u]) if (nb == v) return;\n adj[u].push_back(v);\n adj[v].push_back(u);\n\n int cu = compId[u];\n int cv = compId[v];\n if (cu == cv) {\n int oldc = compEdge[cu];\n compEdge[cu] = oldc + 1;\n compSet.erase({-oldc, cu});\n compSet.insert({-(oldc + 1), cu});\n } else {\n int oldcU = compEdge[cu];\n int oldcV = compEdge[cv];\n compSet.erase({-oldcU, cu});\n compSet.erase({-oldcV, cv});\n\n int target = (compNodes[cu].size() >= compNodes[cv].size()) ? cu : cv;\n int source = (target == cu) ? cv : cu;\n\n int newc = oldcU + oldcV + 1;\n for (int node : compNodes[source]) {\n compId[node] = target;\n compNodes[target].push_back(node);\n }\n compNodes[source].clear();\n compEdge[target] = newc;\n compSet.insert({-newc, target});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid removeEdge(int u, int v) {\n auto &vecU = adj[u];\n for (size_t i = 0; i < vecU.size(); ++i) {\n if (vecU[i] == v) { vecU[i] = vecU.back(); vecU.pop_back(); break; }\n }\n auto &vecV = adj[v];\n for (size_t i = 0; i < vecV.size(); ++i) {\n if (vecV[i] == u) { vecV[i] = vecV.back(); vecV.pop_back(); break; }\n }\n\n int cid = compId[u];\n int oldc = compEdge[cid];\n compSet.erase({-oldc, cid});\n\n vector vis(N, 0);\n vector partA;\n queue q;\n q.push(u); vis[u] = 1;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n partA.push_back(x);\n for (int nb : adj[x]) if (!vis[nb]) { vis[nb] = 1; q.push(nb); }\n }\n\n if (!vis[v]) {\n vector partB;\n for (int node : compNodes[cid]) if (!vis[node]) partB.push_back(node);\n \n long long sA = 0, sB = 0;\n for (int n : partA) sA += adj[n].size();\n for (int n : partB) sB += adj[n].size();\n int cntA = int(sA / 2), cntB = int(sB / 2);\n \n compNodes[cid] = partA;\n int newId = (int)compNodes.size();\n compNodes.push_back(partB);\n compEdge.push_back(cntB);\n for (int n : partB) compId[n] = newId;\n \n compSet.insert({-cntA, cid});\n compSet.insert({-cntB, newId});\n } else {\n compEdge[cid] = oldc - 1;\n compSet.insert({-(oldc - 1), cid});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid build_components() {\n compId.assign(N, -1);\n compNodes.clear();\n compEdge.clear();\n compSet.clear();\n\n vector vis(N, 0);\n for (int v = 0; v < N; ++v) if (!vis[v]) {\n vector nodes;\n queue q;\n q.push(v); vis[v] = 1;\n long long sumDeg = 0;\n while (!q.empty()) {\n int x = q.front(); q.pop();\n nodes.push_back(x);\n sumDeg += adj[x].size();\n for (int nb : adj[x]) if (!vis[nb]) { vis[nb] = 1; q.push(nb); }\n }\n int cid = (int)compNodes.size();\n compNodes.push_back(nodes);\n compEdge.push_back(int(sumDeg / 2));\n for (int n : nodes) compId[n] = cid;\n compSet.insert({-compEdge[cid], cid});\n }\n}\n\n/* --------------------------------------------------------------- */\nvoid init_adj(const vector& rot) {\n adj.assign(N, vector());\n for (int idx = 0; idx < N; ++idx) {\n int r = rot[idx];\n for (int nb : neigh[idx][r]) {\n if (nb != -1) addAdj(idx, nb);\n }\n }\n}\n\n/* --------------------------------------------------------------- */\nint apply_move(int idx, int new_rot, vector& rot) {\n int old_rot = rot[idx];\n if (old_rot == new_rot) return get_score();\n\n const vector& old_nb = neigh[idx][old_rot];\n const vector& new_nb = neigh[idx][new_rot];\n\n for (int nb : old_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : new_nb) if (x == nb) { exists = true; break; }\n if (!exists) removeEdge(idx, nb);\n }\n for (int nb : new_nb) {\n if (nb == -1) continue;\n bool exists = false;\n for (int x : old_nb) if (x == nb) { exists = true; break; }\n if (!exists) addEdge(idx, nb);\n }\n\n rot[idx] = new_rot;\n return get_score();\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector type(N);\n for (int i = 0; i < H; ++i) {\n string line;\n cin >> line;\n for (int j = 0; j < W; ++j) {\n type[i * W + j] = line[j] - '0';\n }\n }\n\n const vector> base[8] = {\n {{0,1}}, {{0,3}}, {{2,3}}, {{1,2}},\n {{0,1},{2,3}}, {{0,3},{1,2}},\n {{0,2}}, {{1,3}}\n };\n\n neigh.assign(N, vector>(4));\n for (int idx = 0; idx < N; ++idx) {\n int t = type[idx];\n for (int r = 0; r < 4; ++r) {\n vector cur;\n for (auto [a,b] : base[t]) {\n int s1 = (a + 3 * r) % 4;\n int s2 = (b + 3 * r) % 4;\n int nb1 = neighbor_id(idx, s1);\n int nb2 = neighbor_id(idx, s2);\n cur.push_back(nb1);\n cur.push_back(nb2);\n }\n neigh[idx][r] = cur;\n }\n }\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n\n int best_score = 0;\n vector answer_rot(N);\n\n const int RESTARTS = 12;\n const int STEPS = 3000;\n\n for (int trial = 0; trial < RESTARTS; ++trial) {\n vector cur_rot(N);\n \n // Strategy based on trial\n int strategy = trial % 5;\n \n if (strategy == 0) {\n // Maximize edges (greedy)\n for (int idx = 0; idx < N; ++idx) {\n int best = 0, bestCnt = -1;\n for (int r = 0; r < 4; ++r) {\n int cnt = 0;\n for (int nb : neigh[idx][r]) if (nb != -1) ++cnt;\n if (cnt > bestCnt) { bestCnt = cnt; best = r; }\n }\n cur_rot[idx] = best;\n }\n } else if (strategy == 1) {\n // Prefer straight lines (types 6,7) to be vertical/horizontal\n for (int idx = 0; idx < N; ++idx) {\n int t = type[idx];\n if (t == 6) cur_rot[idx] = (rng() % 2 == 0) ? 0 : 2;\n else if (t == 7) cur_rot[idx] = (rng() % 2 == 0) ? 1 : 3;\n else cur_rot[idx] = rng() % 4;\n }\n } else if (strategy == 2) {\n // Zigzag pattern for corners\n for (int idx = 0; idx < N; ++idx) {\n int i = idx / W, j = idx % W;\n int t = type[idx];\n if (t <= 3) {\n cur_rot[idx] = ((i + j) % 2 == 0) ? 0 : 1;\n } else {\n cur_rot[idx] = rng() % 4;\n }\n }\n } else if (strategy == 3) {\n // Try to align corners horizontally\n for (int idx = 0; idx < N; ++idx) {\n int i = idx / W, j = idx % W;\n int t = type[idx];\n if (t == 0) cur_rot[idx] = (j % 2 == 0) ? 0 : 3;\n else if (t == 1) cur_rot[idx] = (j % 2 == 0) ? 0 : 1;\n else if (t == 2) cur_rot[idx] = (j % 2 == 0) ? 1 : 2;\n else if (t == 3) cur_rot[idx] = (j % 2 == 0) ? 2 : 3;\n else cur_rot[idx] = rng() % 4;\n }\n } else {\n // Random\n for (int idx = 0; idx < N; ++idx) {\n cur_rot[idx] = rng() % 4;\n }\n }\n \n // Random perturbations\n int perturb = 150 + trial * 30;\n for (int i = 0; i < perturb; ++i) {\n cur_rot[rng() % N] = rng() % 4;\n }\n\n init_adj(cur_rot);\n build_components();\n int cur_score = get_score();\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n\n // Fast hill climbing with targeted moves\n for (int step = 0; step < STEPS; ++step) {\n // Select cell: mostly random, occasionally from largest components\n int idx;\n if (step % 7 == 0 && !compSet.empty()) {\n auto it = compSet.begin();\n int cid = it->second;\n if (!compNodes[cid].empty()) {\n idx = compNodes[cid][rng() % compNodes[cid].size()];\n } else {\n idx = rng() % N;\n }\n } else {\n idx = rng() % N;\n }\n \n int old_r = cur_rot[idx];\n int best_rot_here = old_r;\n int best_score_here = cur_score;\n \n // Try all rotations\n for (int cand = 0; cand < 4; ++cand) {\n if (cand == old_r) continue;\n int new_score = apply_move(idx, cand, cur_rot);\n if (new_score > best_score_here) {\n best_score_here = new_score;\n best_rot_here = cand;\n } else {\n apply_move(idx, old_r, cur_rot);\n }\n }\n \n if (best_rot_here != old_r) {\n cur_score = best_score_here;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n }\n \n // Periodic targeted moves: try cells at component boundaries\n if (step % 100 == 0 && !compSet.empty()) {\n // Get top 2 components\n vector topCids;\n for (auto it = compSet.begin(); it != compSet.end() && topCids.size() < 2; ++it) {\n topCids.push_back(it->second);\n }\n \n // Find boundary cells between top components\n if (topCids.size() >= 2) {\n vector boundary;\n for (int v : compNodes[topCids[0]]) {\n for (int nb : adj[v]) {\n if (compId[nb] == topCids[1]) {\n boundary.push_back(v);\n break;\n }\n }\n }\n \n // Also check reverse\n for (int v : compNodes[topCids[1]]) {\n for (int nb : adj[v]) {\n if (compId[nb] == topCids[0]) {\n boundary.push_back(v);\n break;\n }\n }\n }\n \n // Try all boundary cells\n for (int b : boundary) {\n int old = cur_rot[b];\n for (int r = 0; r < 4; ++r) {\n if (r == old) continue;\n int sc = apply_move(b, r, cur_rot);\n if (sc > cur_score) {\n cur_score = sc;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n break;\n } else {\n apply_move(b, old, cur_rot);\n }\n }\n }\n }\n }\n }\n \n // If score is still low, try a few more aggressive merges\n if (cur_score < 30) {\n for (int attempt = 0; attempt < 500; ++attempt) {\n int idx = rng() % N;\n int old_r = cur_rot[idx];\n int best_rot_here = old_r;\n int best_score_here = cur_score;\n \n for (int cand = 0; cand < 4; ++cand) {\n if (cand == old_r) continue;\n int new_score = apply_move(idx, cand, cur_rot);\n if (new_score > best_score_here) {\n best_score_here = new_score;\n best_rot_here = cand;\n } else {\n apply_move(idx, old_r, cur_rot);\n }\n }\n \n if (best_rot_here != old_r) {\n cur_score = best_score_here;\n if (cur_score > best_score) {\n best_score = cur_score;\n answer_rot = cur_rot;\n }\n }\n }\n }\n }\n\n string out;\n out.reserve(N);\n for (int i = 0; i < N; ++i) out.push_back(char('0' + answer_rot[i]));\n cout << out << '\\n';\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nconst int BIT_LEFT = 1;\nconst int BIT_UP = 2;\nconst int BIT_RIGHT = 4;\nconst int BIT_DOWN = 8;\n\nconst int DI[4] = {-1, 1, 0, 0};\nconst int DJ[4] = {0, 0, -1, 1};\n\nint sgn(int x) { return (x > 0) - (x < 0); }\n\nstruct HopcroftKarp {\n int nL, nR;\n vector> adj;\n vector dist, pairL, pairR;\n \n HopcroftKarp(int L, int R) : nL(L), nR(R) {\n adj.assign(nL, {});\n pairL.assign(nL, -1);\n pairR.assign(nR, -1);\n dist.resize(nL);\n }\n void addEdge(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 (pairL[u] == -1) {\n dist[u] = 0;\n q.push(u);\n } else dist[u] = -1;\n }\n bool found = false;\n while (!q.empty()) {\n int u = q.front(); q.pop();\n for (int v : adj[u]) {\n int u2 = pairR[v];\n if (u2 != -1 && dist[u2] == -1) {\n dist[u2] = dist[u] + 1;\n q.push(u2);\n }\n if (u2 == -1) found = true;\n }\n }\n return found;\n }\n bool dfs(int u) {\n for (int v : adj[u]) {\n int u2 = pairR[v];\n if (u2 == -1 || (dist[u2] == dist[u] + 1 && dfs(u2))) {\n pairL[u] = v;\n pairR[v] = u;\n return true;\n }\n }\n dist[u] = -1;\n return false;\n }\n \n int maxMatching() {\n int matching = 0;\n while (bfs()) {\n for (int u = 0; u < nL; ++u)\n if (pairL[u] == -1 && dfs(u))\n ++matching;\n }\n return matching;\n }\n};\n\n// Generate tree using DFS from random start\nvoid generateTreeDFS(int N, const vector>& board,\n vector,pair>>& edges,\n vector>& visited,\n mt19937& rng) {\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n visited[i][j] = false;\n edges.clear();\n \n // Find all non-empty cells and pick random start\n vector> cells;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1)\n cells.push_back({i,j});\n if (cells.empty()) return;\n \n shuffle(cells.begin(), cells.end(), rng);\n auto [sr, sc] = cells[0];\n \n stack> st;\n st.emplace(sr, sc);\n visited[sr][sc] = true;\n \n while (!st.empty()) {\n auto [r, c] = st.top(); st.pop();\n array dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int nr = r + DI[d];\n int nc = c + DJ[d];\n if (nr<0||nr>=N||nc<0||nc>=N) continue;\n if (board[nr][nc]==-1) continue;\n if (visited[nr][nc]) continue;\n visited[nr][nc] = true;\n st.emplace(nr, nc);\n edges.push_back({{r,c},{nr,nc}});\n }\n }\n}\n\n// Generate tree using Prim's algorithm\nvoid generateTreePrim(int N, const vector>& board,\n vector,pair>>& edges,\n vector>& visited,\n mt19937& rng) {\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n visited[i][j] = false;\n edges.clear();\n \n vector> cells;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1)\n cells.push_back({i,j});\n if (cells.empty()) return;\n \n shuffle(cells.begin(), cells.end(), rng);\n auto [sr, sc] = cells[0];\n \n visited[sr][sc] = true;\n vector> candidates;\n \n auto addNeighbors = [&](int r, int c) {\n array dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int nr = r + DI[d];\n int nc = c + DJ[d];\n if (nr<0||nr>=N||nc<0||nc>=N) continue;\n if (board[nr][nc]==-1) continue;\n if (visited[nr][nc]) continue;\n candidates.emplace_back(r, c, nr, nc);\n }\n };\n \n addNeighbors(sr, sc);\n \n while (!candidates.empty()) {\n int idx = uniform_int_distribution(0, (int)candidates.size()-1)(rng);\n auto [r1, c1, r2, c2] = candidates[idx];\n candidates[idx] = candidates.back();\n candidates.pop_back();\n \n if (visited[r2][c2]) continue;\n \n visited[r2][c2] = true;\n edges.push_back({{r1,c1},{r2,c2}});\n addNeighbors(r2, c2);\n }\n}\n\n// Generate tree using randomized Kruskal\nvoid generateTreeKruskal(int N, const vector>& board,\n vector,pair>>& edges,\n mt19937& rng) {\n edges.clear();\n vector> cells;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1)\n cells.push_back({i,j});\n int V = cells.size();\n \n unordered_map idx;\n for (int i = 0; i < V; ++i) {\n long long key = ((long long)cells[i].first << 32) | cells[i].second;\n idx[key] = i;\n }\n \n vector parent(V);\n iota(parent.begin(), parent.end(), 0);\n function find = [&](int x) {\n return parent[x] == x ? x : parent[x] = find(parent[x]);\n };\n \n vector> allEdges;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j]==-1) continue;\n if (i+1 < N && board[i+1][j]!=-1) {\n allEdges.push_back({i,j,i+1,j});\n }\n if (j+1 < N && board[i][j+1]!=-1) {\n allEdges.push_back({i,j,i,j+1});\n }\n }\n }\n shuffle(allEdges.begin(), allEdges.end(), rng);\n \n for (auto& e : allEdges) {\n int r1,c1,r2,c2;\n tie(r1,c1,r2,c2) = e;\n long long key1 = ((long long)r1 << 32) | c1;\n long long key2 = ((long long)r2 << 32) | c2;\n int id1 = idx[key1];\n int id2 = idx[key2];\n if (find(id1) != find(id2)) {\n parent[find(id1)] = find(id2);\n edges.push_back({{r1,c1},{r2,c2}});\n }\n if ((int)edges.size() == V-1) break;\n }\n}\n\n// Generate snake-like tree (deterministic but good properties)\nvoid generateTreeSnake(int N, const vector>& board,\n vector,pair>>& edges,\n vector>& visited) {\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n visited[i][j] = false;\n edges.clear();\n \n vector> cells;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] != -1)\n cells.push_back({i,j});\n if (cells.empty()) return;\n \n // Sort cells in snake order\n sort(cells.begin(), cells.end(), [](const auto& a, const auto& b) {\n if (a.first != b.first) return a.first < b.first;\n if (a.first % 2 == 0) return a.second < b.second;\n else return a.second > b.second;\n });\n \n // Build tree by connecting consecutive cells\n for (size_t i = 1; i < cells.size(); ++i) {\n edges.push_back({cells[i-1], cells[i]});\n visited[cells[i-1].first][cells[i-1].second] = true;\n visited[cells[i].first][cells[i].second] = true;\n }\n}\n\nint estimateMoves(int M, const vector>& tilePos,\n const vector>& targetPos) {\n long long total = 0;\n for (int i = 0; i < M; ++i) {\n total += abs(tilePos[i].first - targetPos[i].first);\n total += abs(tilePos[i].second - targetPos[i].second);\n }\n return (int)min(2 * total, INT_MAX);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n if (!(cin >> N >> T)) return 0;\n vector raw(N);\n for (int i = 0; i < N; ++i) cin >> raw[i];\n\n int M = N * N - 1;\n vector tileMask(M);\n vector> tilePos(M);\n vector> board(N, vector(N, -1));\n vector> cellIndex(N, vector(N, -1));\n vector> cellCoord;\n pair emptyPos;\n int tileId = 0;\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c = raw[i][j];\n int mask = (c >= '0' && c <= '9') ? (c - '0') : (10 + c - 'a');\n if (mask == 0) {\n emptyPos = {i, j};\n board[i][j] = -1;\n } else {\n board[i][j] = tileId;\n tileMask[tileId] = mask;\n tilePos[tileId] = {i, j};\n cellIndex[i][j] = tileId;\n cellCoord.push_back({i, j});\n ++tileId;\n }\n }\n }\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n \n const int MAX_TRIES = 12000;\n bool ok = false;\n vector> visited(N, vector(N, false));\n \n // Track best solution by movement cost\n long long bestMovementCost = LLONG_MAX;\n vector> bestTarget(M);\n \n for (int attempt = 0; attempt < MAX_TRIES && !ok; ++attempt) {\n vector,pair>> edges;\n \n int method = attempt % 5;\n if (method == 0) {\n generateTreeDFS(N, board, edges, visited, rng);\n } else if (method == 1) {\n generateTreePrim(N, board, edges, visited, rng);\n } else if (method == 2) {\n generateTreeKruskal(N, board, edges, rng);\n } else if (method == 3) {\n generateTreePrim(N, board, edges, visited, rng);\n } else {\n generateTreeKruskal(N, board, edges, rng);\n }\n \n int cnt = 0;\n for (int i=0;i> reqMask(N, vector(N, 0));\n for (auto &e : edges) {\n int r1=e.first.first, c1=e.first.second;\n int r2=e.second.first, c2=e.second.second;\n int dr=r2-r1, dc=c2-c1;\n if (dr==1) { reqMask[r1][c1]|=BIT_DOWN; reqMask[r2][c2]|=BIT_UP; }\n else if (dr==-1) { reqMask[r1][c1]|=BIT_UP; reqMask[r2][c2]|=BIT_DOWN; }\n else if (dc==1) { reqMask[r1][c1]|=BIT_RIGHT; reqMask[r2][c2]|=BIT_LEFT; }\n else { reqMask[r1][c1]|=BIT_LEFT; reqMask[r2][c2]|=BIT_RIGHT; }\n }\n \n vector requiredMask(M);\n for (int i=0;i> fullTarget(M);\n for (int cid = 0; cid < M; ++cid) {\n int tid = hk.pairL[cid];\n fullTarget[tid] = cellCoord[cid];\n }\n \n // Calculate movement cost\n long long cost = 0;\n for (int i = 0; i < M; ++i) {\n cost += abs(tilePos[i].first - fullTarget[i].first);\n cost += abs(tilePos[i].second - fullTarget[i].second);\n }\n \n if (estimateMoves(M, tilePos, fullTarget) <= T) {\n if (cost < bestMovementCost) {\n bestMovementCost = cost;\n bestTarget = fullTarget;\n }\n ok = true;\n break;\n }\n }\n }\n\n // If no perfect solution, find partial solution\n if (!ok) {\n // Already have bestMovementCost = LLONG_MAX, bestTarget initialized\n // Try to find best partial solution\n for (int attempt = 0; attempt < 5000; ++attempt) {\n vector,pair>> edges;\n \n if (attempt % 3 == 0) {\n generateTreeDFS(N, board, edges, visited, rng);\n } else if (attempt % 3 == 1) {\n generateTreePrim(N, board, edges, visited, rng);\n } else {\n generateTreeKruskal(N, board, edges, rng);\n }\n \n int cnt = 0;\n for (int i=0;i> reqMask(N, vector(N, 0));\n for (auto &e : edges) {\n int r1=e.first.first, c1=e.first.second;\n int r2=e.second.first, c2=e.second.second;\n int dr=r2-r1, dc=c2-c1;\n if (dr==1) { reqMask[r1][c1]|=BIT_DOWN; reqMask[r2][c2]|=BIT_UP; }\n else if (dr==-1) { reqMask[r1][c1]|=BIT_UP; reqMask[r2][c2]|=BIT_DOWN; }\n else if (dc==1) { reqMask[r1][c1]|=BIT_RIGHT; reqMask[r2][c2]|=BIT_LEFT; }\n else { reqMask[r1][c1]|=BIT_LEFT; reqMask[r2][c2]|=BIT_RIGHT; }\n }\n \n vector requiredMask(M);\n for (int i=0;i 0) {\n vector> partialTarget(M);\n for (int t = 0; t < M; ++t) partialTarget[t] = tilePos[t];\n \n for (int cid = 0; cid < M; ++cid) {\n int tid = hk.pairL[cid];\n if (tid != -1) {\n partialTarget[tid] = cellCoord[cid];\n }\n }\n \n long long cost = 0;\n for (int i = 0; i < M; ++i) {\n cost += abs(tilePos[i].first - partialTarget[i].first);\n cost += abs(tilePos[i].second - partialTarget[i].second);\n }\n \n if (cost < bestMovementCost && estimateMoves(M, tilePos, partialTarget) <= T) {\n bestMovementCost = cost;\n bestTarget = partialTarget;\n ok = true;\n }\n }\n }\n }\n\n // Use best solution found\n vector> targetPos = bestTarget;\n\n // Moving phase\n vector moves;\n moves.reserve(T);\n \n auto applyMove = [&](char dir) {\n if ((int)moves.size() >= T) return false;\n int ex = emptyPos.first, ey = emptyPos.second;\n int nx = ex, ny = ey;\n if (dir == 'U') nx--;\n else if (dir == 'D') nx++;\n else if (dir == 'L') ny--;\n else if (dir == 'R') ny++;\n int tile = board[nx][ny];\n board[ex][ey] = tile;\n board[nx][ny] = -1;\n if (tile != -1) tilePos[tile] = {nx, ny};\n emptyPos = {nx, ny};\n moves.push_back(dir);\n return true;\n };\n \n auto moveEmptyTo = [&](int tr, int tc) {\n while (emptyPos.first > tr) { if (!applyMove('U')) return false; }\n while (emptyPos.first < tr) { if (!applyMove('D')) return false; }\n while (emptyPos.second > tc) { if (!applyMove('L')) return false; }\n while (emptyPos.second < tc) { if (!applyMove('R')) return false; }\n return true;\n };\n \n while ((int)moves.size() < T) {\n bool all_done = true;\n for (int t = 0; t < M; ++t) {\n if (tilePos[t] != targetPos[t]) {\n all_done = false;\n break;\n }\n }\n if (all_done) break;\n \n int bestTile = -1;\n int bestCost = INT_MAX;\n int needX = -1, needY = -1;\n int stepX = 0, stepY = 0;\n \n for (int t = 0; t < M; ++t) {\n auto cur = tilePos[t];\n auto tgt = targetPos[t];\n if (cur == tgt) continue;\n \n int dx = tgt.first - cur.first;\n int dy = tgt.second - cur.second;\n \n if (dx != 0) {\n int step = sgn(dx);\n int nx = cur.first + step;\n int ny = cur.second;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = t;\n needX = nx; needY = ny;\n stepX = step; stepY = 0;\n }\n }\n if (dy != 0) {\n int step = sgn(dy);\n int nx = cur.first;\n int ny = cur.second + step;\n int distEmpty = abs(emptyPos.first - nx) + abs(emptyPos.second - ny);\n int cost = distEmpty + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestTile = t;\n needX = nx; needY = ny;\n stepX = 0; stepY = step;\n }\n }\n }\n \n if (bestTile == -1) break;\n \n if (!moveEmptyTo(needX, needY)) break;\n \n char cmd = (stepX != 0) ? ((stepX == -1) ? 'D' : 'U')\n : ((stepY == -1) ? 'R' : 'L');\n if (!applyMove(cmd)) break;\n tilePos[bestTile].first += stepX;\n tilePos[bestTile].second += stepY;\n }\n \n cout << string(moves.begin(), moves.end()) << \"\\n\";\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nusing int64 = long long;\n\nconst int64 R = 10000; // radius of the cake\n\n/* --------------------------------------------------------------- */\nstruct Point {\n int64 x, y;\n};\n\nstruct Line {\n Point p1, p2;\n int64 dx, dy;\n};\n\nbool try_make_line(int64 x1, int64 y1, int64 x2, int64 y2, Line& L) {\n if (x1 == x2 && y1 == y2) return false;\n L.p1 = {x1, y1};\n L.p2 = {x2, y2};\n L.dx = x2 - x1;\n L.dy = y2 - y1;\n return true;\n}\n\nuint64_t line_key(const Line& L) {\n int64 g = std::gcd(std::abs(L.dx), std::abs(L.dy));\n int64 ndx = L.dx / g;\n int64 ndy = L.dy / g;\n int64 offset = L.dx * (-L.p1.y) - L.dy * (-L.p1.x);\n uint64_t h1 = (uint64_t)(ndx + 20000) * 40001ULL + (uint64_t)(ndy + 20000);\n uint64_t h2 = (uint64_t)(offset + 4e8);\n return h1 * 1000003ULL + h2;\n}\n\nint evaluate(const vector& lines,\n const vector& pts,\n const array& a)\n{\n int n = pts.size();\n int m = lines.size();\n \n vector hashes(n);\n for (int i = 0; i < n; ++i) {\n uint64_t h = 0;\n for (const auto& L : lines) {\n int side = (L.dx * (pts[i].y - L.p1.y) - L.dy * (pts[i].x - L.p1.x) > 0);\n h = h * 2 + side;\n }\n hashes[i] = h;\n }\n \n sort(hashes.begin(), hashes.end());\n \n int b[11] = {0};\n int i = 0;\n while (i < n) {\n int j = i + 1;\n while (j < n && hashes[j] == hashes[i]) ++j;\n int cnt = j - i;\n if (1 <= cnt && cnt <= 10) ++b[cnt];\n i = j;\n }\n \n int sumMin = 0;\n for (int d = 1; d <= 10; ++d) sumMin += min(a[d], b[d]);\n return sumMin;\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n if (!(cin >> N >> K)) return 0;\n array a{};\n for (int d = 1; d <= 10; ++d) cin >> a[d];\n vector pts(N);\n for (int i = 0; i < N; ++i) cin >> pts[i].x >> pts[i].y;\n\n mt19937_64 rng(random_device{}());\n\n vector bestLines;\n int bestScore = -1;\n int totalA = 0;\n for (int d = 1; d <= 10; ++d) totalA += a[d];\n\n uniform_int_distribution distSmall(-R + 1, R - 1);\n uniform_int_distribution distLarge(-2 * R, 2 * R);\n uniform_int_distribution distXLarge(-3 * R, 3 * R);\n\n /* ================================================================\n Strategy 1: Pure random lines - many iterations\n ================================================================ */\n const int MAX_TRIES_RANDOM = 600;\n for (int iter = 0; iter < MAX_TRIES_RANDOM; ++iter) {\n int k = K;\n \n vector cur;\n cur.reserve(k);\n unordered_set usedKeys;\n \n for (int i = 0; i < k; ++i) {\n int64 x1, y1, x2, y2;\n int coordType = rng() % 3;\n \n if (coordType == 0) {\n x1 = distSmall(rng); y1 = distSmall(rng);\n x2 = distSmall(rng); y2 = distSmall(rng);\n } else if (coordType == 1) {\n x1 = distLarge(rng); y1 = distLarge(rng);\n x2 = distLarge(rng); y2 = distLarge(rng);\n } else {\n x1 = distXLarge(rng); y1 = distXLarge(rng);\n x2 = distXLarge(rng); y2 = distXLarge(rng);\n }\n \n if (x1 == x2 && y1 == y2) continue;\n \n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (const auto& p : pts) {\n int64 cross = dx * (p.y - y1) - dy * (p.x - x1);\n if (cross == 0) { ok = false; break; }\n }\n if (!ok) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n \n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n\n /* ================================================================\n Strategy 2: Grid-based lines with varied spacings\n ================================================================ */\n vector spacings = {100, 150, 200, 250, 300, 350, 400, 500, 600, 700, 800, 1000, 1200, 1500, 2000};\n for (int spacing : spacings) {\n for (int offset = 0; offset < spacing; offset += max(1, spacing/2)) {\n vector cur;\n cur.reserve(K);\n unordered_set usedKeys;\n \n // Vertical lines\n for (int64 x = -R + offset; x < R && (int)cur.size() < K; x += spacing) {\n Line L;\n if (!try_make_line(x, -R, x, R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Horizontal lines\n for (int64 y = -R + offset; y < R && (int)cur.size() < K; y += spacing) {\n Line L;\n if (!try_make_line(-R, y, R, y, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Diagonal lines (x+y=c)\n for (int64 d = -2*R; d <= 2*R && (int)cur.size() < K; d += spacing) {\n int64 x1 = -R;\n int64 y1 = d - x1;\n int64 x2 = -R + spacing/2;\n int64 y2 = d - x2;\n \n if (y1 < -R || y1 > R || y2 < -R || y2 > R) continue;\n if (y1 == y2) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Diagonal lines (x-y=c)\n for (int64 d = -2*R; d <= 2*R && (int)cur.size() < K; d += spacing) {\n int64 x1 = -R;\n int64 y1 = x1 - d;\n int64 x2 = -R + spacing/2;\n int64 y2 = x2 - d;\n \n if (y1 < -R || y1 > R || y2 < -R || y2 > R) continue;\n if (y1 == y2) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n if (bestScore == totalA) break;\n }\n\n /* ================================================================\n Strategy 3: Random grids\n ================================================================ */\n const int MAX_TRIES_GRID = 350;\n for (int iter = 0; iter < MAX_TRIES_GRID; ++iter) {\n int k = K;\n \n vector cur;\n cur.reserve(k);\n unordered_set usedKeys;\n \n int nVert = uniform_int_distribution(0, k/2 + 1)(rng);\n int nHoriz = uniform_int_distribution(0, k/2 + 1)(rng);\n int nDiag1 = uniform_int_distribution(0, k/2 + 1)(rng);\n int nDiag2 = uniform_int_distribution(0, k/2 + 1)(rng);\n int nRandom = k - nVert - nHoriz - nDiag1 - nDiag2;\n if (nRandom < 0) nRandom = 0;\n \n // Vertical lines\n vector usedX;\n for (int i = 0; i < nVert; ++i) {\n int64 x = uniform_int_distribution(-R + 50, R - 50)(rng);\n bool dup = false;\n for (int64 v : usedX) if (v == x) { dup = true; break; }\n if (dup) continue;\n usedX.push_back(x);\n Line L;\n if (!try_make_line(x, -R, x, R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Horizontal lines\n vector usedY;\n for (int i = 0; i < nHoriz; ++i) {\n int64 y = uniform_int_distribution(-R + 50, R - 50)(rng);\n bool dup = false;\n for (int64 v : usedY) if (v == y) { dup = true; break; }\n if (dup) continue;\n usedY.push_back(y);\n Line L;\n if (!try_make_line(-R, y, R, y, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Diagonal lines (x+y=c)\n vector usedS1;\n for (int i = 0; i < nDiag1; ++i) {\n int64 c = uniform_int_distribution(-R, R)(rng);\n bool dup = false;\n for (int64 v : usedS1) if (v == c) { dup = true; break; }\n if (dup) continue;\n usedS1.push_back(c);\n Line L;\n if (!try_make_line(-R, c + R, c + R, -R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Diagonal lines (x-y=c)\n vector usedS2;\n for (int i = 0; i < nDiag2; ++i) {\n int64 c = uniform_int_distribution(-R, R)(rng);\n bool dup = false;\n for (int64 v : usedS2) if (v == c) { dup = true; break; }\n if (dup) continue;\n usedS2.push_back(c);\n Line L;\n if (!try_make_line(-R, -c - R, -c - R, -R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Add random lines if needed\n while ((int)cur.size() < k) {\n int64 x1 = distLarge(rng);\n int64 y1 = distLarge(rng);\n int64 x2 = distLarge(rng);\n int64 y2 = distLarge(rng);\n \n if (x1 == x2 && y1 == y2) continue;\n \n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (const auto& p : pts) {\n int64 cross = dx * (p.y - y1) - dy * (p.x - x1);\n if (cross == 0) { ok = false; break; }\n }\n if (!ok) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n\n /* ================================================================\n Strategy 4: Prime-based spacing grids\n ================================================================ */\n vector primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41};\n for (int p : primes) {\n int spacing = p * 100;\n if (spacing < 200) continue;\n \n for (int offset = 0; offset < spacing; offset += max(1, spacing/3)) {\n vector cur;\n cur.reserve(K);\n unordered_set usedKeys;\n \n // Vertical lines\n for (int64 x = -R + offset; x < R && (int)cur.size() < K; x += spacing) {\n Line L;\n if (!try_make_line(x, -R, x, R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n // Horizontal lines\n for (int64 y = -R + offset; y < R && (int)cur.size() < K; y += spacing) {\n Line L;\n if (!try_make_line(-R, y, R, y, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n if (bestScore == totalA) break;\n }\n\n /* ================================================================\n Strategy 5: Fine-grained grids\n ================================================================ */\n for (int spacing = 75; spacing <= 1000; spacing += 25) {\n for (int offset = 0; offset < spacing; offset += max(1, spacing/3)) {\n vector cur;\n cur.reserve(K);\n unordered_set usedKeys;\n \n for (int64 x = -R + offset; x < R && (int)cur.size() < K; x += spacing) {\n Line L;\n if (!try_make_line(x, -R, x, R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n for (int64 y = -R + offset; y < R && (int)cur.size() < K; y += spacing) {\n Line L;\n if (!try_make_line(-R, y, R, y, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n if (bestScore == totalA) break;\n }\n\n /* ================================================================\n Strategy 6: Dense grid patterns\n ================================================================ */\n for (int spacing = 75; spacing <= 300; spacing += 25) {\n vector cur;\n cur.reserve(K);\n unordered_set usedKeys;\n \n for (int64 x = -R + 1; x < R && (int)cur.size() < K; x += spacing) {\n Line L;\n if (!try_make_line(x, -R, x, R, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n for (int64 y = -R + 1; y < R && (int)cur.size() < K; y += spacing) {\n Line L;\n if (!try_make_line(-R, y, R, y, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() < 20) continue;\n \n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n\n /* ================================================================\n Strategy 7: Hill climbing\n ================================================================ */\n for (int iter = 0; iter < 150 && bestScore < totalA; ++iter) {\n vector cur = bestLines;\n bool improved = false;\n \n // Try removing one line\n for (size_t i = 0; i < cur.size(); ++i) {\n vector temp = cur;\n temp.erase(temp.begin() + i);\n if ((int)temp.size() < 20) continue;\n \n int sc = evaluate(temp, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = temp;\n improved = true;\n if (bestScore == totalA) break;\n }\n }\n \n // Try adding new random lines\n for (int add_attempt = 0; add_attempt < 30; ++add_attempt) {\n if ((int)cur.size() >= K) break;\n \n int coordType = rng() % 3;\n int64 x1, y1, x2, y2;\n \n if (coordType == 0) {\n x1 = distSmall(rng); y1 = distSmall(rng);\n x2 = distSmall(rng); y2 = distSmall(rng);\n } else if (coordType == 1) {\n x1 = distLarge(rng); y1 = distLarge(rng);\n x2 = distLarge(rng); y2 = distLarge(rng);\n } else {\n x1 = distXLarge(rng); y1 = distXLarge(rng);\n x2 = distXLarge(rng); y2 = distXLarge(rng);\n }\n \n if (x1 == x2 && y1 == y2) continue;\n \n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (const auto& p : pts) {\n int64 cross = dx * (p.y - y1) - dy * (p.x - x1);\n if (cross == 0) { ok = false; break; }\n }\n if (!ok) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n \n bool dup = false;\n for (const auto& existing : cur) {\n if (line_key(existing) == key) { dup = true; break; }\n }\n if (!dup) {\n cur.push_back(L);\n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n improved = true;\n } else {\n cur.pop_back();\n }\n }\n }\n \n if (!improved) break;\n }\n\n /* ================================================================\n Strategy 8: Simulated annealing style\n ================================================================ */\n for (int iter = 0; iter < 120 && bestScore < totalA; ++iter) {\n vector cur = bestLines;\n \n for (int replace_attempt = 0; replace_attempt < 25; ++replace_attempt) {\n if ((int)cur.size() == 0) break;\n \n int idx = uniform_int_distribution(0, (int)cur.size() - 1)(rng);\n Line removed = cur[idx];\n \n int coordType = rng() % 3;\n int64 x1, y1, x2, y2;\n \n if (coordType == 0) {\n x1 = distSmall(rng); y1 = distSmall(rng);\n x2 = distSmall(rng); y2 = distSmall(rng);\n } else if (coordType == 1) {\n x1 = distLarge(rng); y1 = distLarge(rng);\n x2 = distLarge(rng); y2 = distLarge(rng);\n } else {\n x1 = distXLarge(rng); y1 = distXLarge(rng);\n x2 = distXLarge(rng); y2 = distXLarge(rng);\n }\n \n if (x1 == x2 && y1 == y2) continue;\n \n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (const auto& p : pts) {\n int64 cross = dx * (p.y - y1) - dy * (p.x - x1);\n if (cross == 0) { ok = false; break; }\n }\n if (!ok) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n \n bool dup = false;\n for (size_t i = 0; i < cur.size(); ++i) {\n if (i != idx && line_key(cur[i]) == key) { dup = true; break; }\n }\n if (!dup) {\n cur[idx] = L;\n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n } else {\n cur[idx] = removed;\n }\n }\n }\n }\n\n /* ================================================================\n Strategy 9: More grid patterns\n ================================================================ */\n for (int spacing = 150; spacing <= 800; spacing += 50) {\n // Pure vertical/horizontal\n {\n vector cur;\n cur.reserve(K);\n unordered_set usedKeys;\n \n for (int64 x = -R + 1; x < R && (int)cur.size() < K; x += spacing) {\n Line L;\n if (try_make_line(x, -R, x, R, L)) {\n uint64_t key = line_key(L);\n if (usedKeys.find(key) == usedKeys.end()) {\n usedKeys.insert(key);\n cur.push_back(L);\n }\n }\n }\n for (int64 y = -R + 1; y < R && (int)cur.size() < K; y += spacing) {\n Line L;\n if (try_make_line(-R, y, R, y, L)) {\n uint64_t key = line_key(L);\n if (usedKeys.find(key) == usedKeys.end()) {\n usedKeys.insert(key);\n cur.push_back(L);\n }\n }\n }\n \n if ((int)cur.size() >= 20) {\n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n }\n }\n }\n \n // With diagonals\n {\n vector cur;\n cur.reserve(K);\n unordered_set usedKeys;\n \n for (int64 x = -R + 1; x < R && (int)cur.size() < K/2; x += spacing) {\n Line L;\n if (try_make_line(x, -R, x, R, L)) {\n uint64_t key = line_key(L);\n if (usedKeys.find(key) == usedKeys.end()) {\n usedKeys.insert(key);\n cur.push_back(L);\n }\n }\n }\n for (int64 y = -R + 1; y < R && (int)cur.size() < K*2/3; y += spacing) {\n Line L;\n if (try_make_line(-R, y, R, y, L)) {\n uint64_t key = line_key(L);\n if (usedKeys.find(key) == usedKeys.end()) {\n usedKeys.insert(key);\n cur.push_back(L);\n }\n }\n }\n for (int64 d = -2*R; d <= 2*R && (int)cur.size() < K; d += spacing*2) {\n Line L;\n if (try_make_line(-R, d + R, d + R, -R, L)) {\n uint64_t key = line_key(L);\n if (usedKeys.find(key) == usedKeys.end()) {\n usedKeys.insert(key);\n cur.push_back(L);\n }\n }\n }\n \n if ((int)cur.size() >= 20) {\n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n }\n }\n }\n }\n\n /* ================================================================\n Strategy 10: More random exploration\n ================================================================ */\n for (int extra = 0; extra < 100; ++extra) {\n int k = K;\n \n vector cur;\n cur.reserve(k);\n unordered_set usedKeys;\n \n // Focus on grid-like but random positions\n int nGrid = uniform_int_distribution(k/2, k)(rng);\n int nRandom = k - nGrid;\n \n // Grid lines with random positions\n for (int i = 0; i < nGrid; ++i) {\n int type = rng() % 4;\n int64 val;\n \n if (type == 0) {\n val = uniform_int_distribution(-R + 50, R - 50)(rng);\n Line L;\n if (try_make_line(val, -R, val, R, L)) {\n uint64_t key = line_key(L);\n if (usedKeys.find(key) == usedKeys.end()) {\n usedKeys.insert(key);\n cur.push_back(L);\n }\n }\n } else if (type == 1) {\n val = uniform_int_distribution(-R + 50, R - 50)(rng);\n Line L;\n if (try_make_line(-R, val, R, val, L)) {\n uint64_t key = line_key(L);\n if (usedKeys.find(key) == usedKeys.end()) {\n usedKeys.insert(key);\n cur.push_back(L);\n }\n }\n } else if (type == 2) {\n val = uniform_int_distribution(-R, R)(rng);\n Line L;\n if (try_make_line(-R, val + R, val + R, -R, L)) {\n uint64_t key = line_key(L);\n if (usedKeys.find(key) == usedKeys.end()) {\n usedKeys.insert(key);\n cur.push_back(L);\n }\n }\n } else {\n val = uniform_int_distribution(-R, R)(rng);\n Line L;\n if (try_make_line(-R, -val - R, -val - R, -R, L)) {\n uint64_t key = line_key(L);\n if (usedKeys.find(key) == usedKeys.end()) {\n usedKeys.insert(key);\n cur.push_back(L);\n }\n }\n }\n }\n \n // Random lines\n for (int i = 0; i < nRandom && (int)cur.size() < k; ++i) {\n int64 x1 = distLarge(rng);\n int64 y1 = distLarge(rng);\n int64 x2 = distLarge(rng);\n int64 y2 = distLarge(rng);\n \n if (x1 == x2 && y1 == y2) continue;\n \n int64 dx = x2 - x1;\n int64 dy = y2 - y1;\n bool ok = true;\n for (const auto& p : pts) {\n int64 cross = dx * (p.y - y1) - dy * (p.x - x1);\n if (cross == 0) { ok = false; break; }\n }\n if (!ok) continue;\n \n Line L;\n if (!try_make_line(x1, y1, x2, y2, L)) continue;\n uint64_t key = line_key(L);\n if (usedKeys.find(key) != usedKeys.end()) continue;\n usedKeys.insert(key);\n cur.push_back(L);\n }\n \n if ((int)cur.size() >= 20) {\n int sc = evaluate(cur, pts, a);\n if (sc > bestScore) {\n bestScore = sc;\n bestLines = cur;\n if (bestScore == totalA) break;\n }\n }\n }\n\n /* ----------------------------------------------------------- */\n cout << (int)bestLines.size() << '\\n';\n for (const auto& L : bestLines) {\n cout << L.p1.x << ' ' << L.p1.y << ' '\n << L.p2.x << ' ' << L.p2.y << '\\n';\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2, x3, y3, x4, y4;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n if (!(cin >> N >> M)) return 0;\n\n vector> dot(N, vector(N, 0));\n vector> init;\n for (int i = 0; i < M; ++i) {\n int x, y; cin >> x >> y;\n dot[x][y] = 1;\n init.emplace_back(x, y);\n }\n\n // Row/column dot lists\n vector> rowDots(N), colDots(N);\n for (auto &p : init) {\n int x = p.first, y = p.second;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n }\n\n // Center and weight calculation\n double c = (N - 1) / 2.0;\n auto weight = [&](int x, int y) -> double {\n double dx = x - c, dy = y - c;\n return dx * dx + dy * dy + 1;\n };\n\n vector bestAnswer;\n long long bestScore = 0;\n\n const int NUM_TRIALS = 150;\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n for (int trial = 0; trial < NUM_TRIALS; trial++) {\n // Reset state\n vector> dot = vector>(N, vector(N, 0));\n vector> hor(N, vector(N, 0));\n vector> ver(N, vector(N, 0));\n vector>> diagUR(N, vector>(N));\n vector>> diagDR(N, vector>(N));\n vector> rowDots(N), colDots(N);\n for (auto &p : init) {\n int x = p.first, y = p.second;\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n }\n\n // Empty points with weights\n vector> emptyWeighted;\n for (int x = 0; x < N; ++x)\n for (int y = 0; y < N; ++y)\n if (!dot[x][y]) emptyWeighted.emplace_back(weight(x, y), x, y);\n\n // Sort by weight (descending)\n sort(emptyWeighted.begin(), emptyWeighted.end(), \n [](auto &a, auto &b) { return get<0>(a) > get<0>(b); });\n\n vector> empty;\n for (auto &wp : emptyWeighted) empty.emplace_back(get<1>(wp), get<2>(wp));\n\n vector answer;\n\n // =============== Axis-aligned helpers ===============\n auto sidesEmptyAxis = [&](int x, int y, int x2, int y2) -> bool {\n int xlo = min(x, x2), xhi = max(x, x2);\n int ylo = min(y, y2), yhi = max(y, y2);\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y]) return false;\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x][yi]) return false;\n for (int yi = ylo + 1; yi < yhi; ++yi)\n if (dot[x2][yi]) return false;\n for (int xi = xlo + 1; xi < xhi; ++xi)\n if (dot[xi][y2]) return false;\n return true;\n };\n\n auto addEdgeAxis = [&](int xa, int ya, int xb, int yb) {\n if (xa == xb) {\n int x = xa, ylo = min(ya, yb), yhi = max(ya, yb);\n for (int y = ylo; y < yhi; ++y) ver[x][y]++;\n } else {\n int y = ya, xlo = min(xa, xb), xhi = max(xa, xb);\n for (int x = xlo; x < xhi; ++x) hor[x][y]++;\n }\n };\n\n auto edgeFreeAxis = [&](int xa, int ya, int xb, int yb) -> bool {\n if (xa == xb) {\n int x = xa, ylo = min(ya, yb), yhi = max(ya, yb);\n for (int y = ylo; y < yhi; ++y) if (ver[x][y]) return false;\n } else {\n int y = ya, xlo = min(xa, xb), xhi = max(xa, xb);\n for (int x = xlo; x < xhi; ++x) if (hor[x][y]) return false;\n }\n return true;\n };\n\n auto edgesFreeAxis = [&](int x, int y, int x2, int y2) -> bool {\n if (!edgeFreeAxis(x, y, x2, y)) return false;\n if (!edgeFreeAxis(x2, y, x2, y2)) return false;\n if (!edgeFreeAxis(x2, y2, x, y2)) return false;\n if (!edgeFreeAxis(x, y2, x, y)) return false;\n return true;\n };\n\n auto addEdgesAxis = [&](int x, int y, int x2, int y2) {\n addEdgeAxis(x, y, x2, y);\n addEdgeAxis(x2, y, x2, y2);\n addEdgeAxis(x2, y2, x, y2);\n addEdgeAxis(x, y2, x, y);\n };\n\n // =============== 45-degree helpers ===============\n auto checkSide45 = [&](int xa, int ya, int xb, int yb) -> bool {\n int dx = xb - xa, dy = yb - ya;\n int steps = abs(dx);\n if (steps == 0) return true;\n int sx = (dx > 0) ? 1 : (dx < 0 ? -1 : 0);\n int sy = (dy > 0) ? 1 : (dy < 0 ? -1 : 0);\n for (int i = 1; i < steps; ++i) {\n int xi = xa + i * sx;\n int yi = ya + i * sy;\n if (dot[xi][yi]) return false;\n }\n return true;\n };\n\n auto addEdgeDiag = [&](int xa, int ya, int xb, int yb) {\n int dx = xb - xa, dy = yb - ya;\n int steps = abs(dx);\n int sx = (dx > 0) ? 1 : (dx < 0 ? -1 : 0);\n int sy = (dy > 0) ? 1 : (dy < 0 ? -1 : 0);\n for (int i = 0; i < steps; ++i) {\n int xs = xa + i * sx;\n int ys = ya + i * sy;\n if (sx == 1 && sy == 1) {\n diagUR[xs][ys][0]++;\n if (xs + 1 < N && ys + 1 < N) diagUR[xs + 1][ys + 1][0]++;\n } else if (sx == 1 && sy == -1) {\n diagDR[xs][ys][1]++;\n if (xs + 1 < N && ys - 1 >= 0) diagDR[xs + 1][ys - 1][1]++;\n } else if (sx == -1 && sy == 1) {\n diagDR[xs - 1][ys + 1][1]++;\n if (xs < N && ys < N) diagDR[xs][ys][1]++;\n } else if (sx == -1 && sy == -1) {\n diagUR[xs - 1][ys - 1][0]++;\n if (xs < N && ys < N) diagUR[xs][ys][0]++;\n }\n }\n };\n\n auto edgeFreeDiag = [&](int xa, int ya, int xb, int yb) -> bool {\n int dx = xb - xa, dy = yb - ya;\n int steps = abs(dx);\n int sx = (dx > 0) ? 1 : (dx < 0 ? -1 : 0);\n int sy = (dy > 0) ? 1 : (dy < 0 ? -1 : 0);\n for (int i = 0; i < steps; ++i) {\n int xs = xa + i * sx;\n int ys = ya + i * sy;\n if (sx == 1 && sy == 1) {\n if (diagUR[xs][ys][0]) return false;\n } else if (sx == 1 && sy == -1) {\n if (diagDR[xs][ys][1]) return false;\n } else if (sx == -1 && sy == 1) {\n if (diagDR[xs - 1][ys + 1][1]) return false;\n } else if (sx == -1 && sy == -1) {\n if (diagUR[xs - 1][ys - 1][0]) return false;\n }\n }\n return true;\n };\n\n auto edgesFree45 = [&](int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) -> bool {\n if (!edgeFreeDiag(x1, y1, x2, y2)) return false;\n if (!edgeFreeDiag(x2, y2, x3, y3)) return false;\n if (!edgeFreeDiag(x3, y3, x4, y4)) return false;\n if (!edgeFreeDiag(x4, y4, x1, y1)) return false;\n return true;\n };\n\n auto addEdges45 = [&](int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {\n addEdgeDiag(x1, y1, x2, y2);\n addEdgeDiag(x2, y2, x3, y3);\n addEdgeDiag(x3, y3, x4, y4);\n addEdgeDiag(x4, y4, x1, y1);\n };\n\n // Main greedy loop\n while (true) {\n bool progress = false;\n shuffle(empty.begin(), empty.end(), rng);\n \n for (size_t i = 0; i < empty.size(); ++i) {\n int x = empty[i].first, y = empty[i].second;\n \n // Try axis-aligned (prefer smaller rectangles)\n const vector &cols = rowDots[y];\n const vector &rows = colDots[x];\n int bestW = INT_MAX, bestH = INT_MAX;\n pair bestX2Y2 = {-1, -1};\n \n for (int x2 : cols) {\n if (x2 == x) continue;\n for (int y2 : rows) {\n if (y2 == y) continue;\n if (!dot[x2][y2]) continue;\n if (!sidesEmptyAxis(x, y, x2, y2)) continue;\n if (!edgesFreeAxis(x, y, x2, y2)) continue;\n \n int w = abs(x2 - x), h = abs(y2 - y);\n if (w < bestW || (w == bestW && h < bestH)) {\n bestW = w;\n bestH = h;\n bestX2Y2 = {x2, y2};\n }\n }\n }\n \n if (bestX2Y2.first != -1) {\n int x2 = bestX2Y2.first, y2 = bestX2Y2.second;\n Rect r{ x, y, x2, y, x2, y2, x, y2 };\n answer.push_back(r);\n addEdgesAxis(x, y, x2, y2);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n break;\n }\n \n // Try 45-degree (prefer smaller d)\n bool found45 = false;\n \n // Case A: top vertex\n int d_max = min({y / 2, x, N - 1 - x});\n for (int d = 1; d <= d_max; ++d) {\n int x2 = x + d, y2 = y - d;\n int x3 = x, y3 = y - 2 * d;\n int x4 = x - d, y4 = y - d;\n if (!dot[x2][y2] || !dot[x3][y3] || !dot[x4][y4]) continue;\n if (!checkSide45(x, y, x2, y2)) continue;\n if (!checkSide45(x2, y2, x3, y3)) continue;\n if (!checkSide45(x3, y3, x4, y4)) continue;\n if (!checkSide45(x4, y4, x, y)) continue;\n if (!edgesFree45(x, y, x2, y2, x3, y3, x4, y4)) continue;\n \n Rect r{ x, y, x2, y2, x3, y3, x4, y4 };\n answer.push_back(r);\n addEdges45(x, y, x2, y2, x3, y3, x4, y4);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n found45 = true;\n break;\n }\n if (found45) break;\n \n // Case B: bottom vertex\n d_max = min({x, (N - 1 - y) / 2, N - 1 - x});\n for (int d = 1; d <= d_max; ++d) {\n int x2 = x + d, y2 = y + d;\n int x3 = x, y3 = y + 2 * d;\n int x4 = x - d, y4 = y + d;\n if (!dot[x2][y2] || !dot[x3][y3] || !dot[x4][y4]) continue;\n if (!checkSide45(x, y, x2, y2)) continue;\n if (!checkSide45(x2, y2, x3, y3)) continue;\n if (!checkSide45(x3, y3, x4, y4)) continue;\n if (!checkSide45(x4, y4, x, y)) continue;\n if (!edgesFree45(x, y, x2, y2, x3, y3, x4, y4)) continue;\n \n Rect r{ x, y, x2, y2, x3, y3, x4, y4 };\n answer.push_back(r);\n addEdges45(x, y, x2, y2, x3, y3, x4, y4);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n found45 = true;\n break;\n }\n if (found45) break;\n \n // Case C: right vertex\n d_max = min({(N - 1 - x) / 2, N - 1 - y, y});\n for (int d = 1; d <= d_max; ++d) {\n int x2 = x + d, y2 = y + d;\n int x3 = x + 2 * d, y3 = y;\n int x4 = x + d, y4 = y - d;\n if (!dot[x2][y2] || !dot[x3][y3] || !dot[x4][y4]) continue;\n if (!checkSide45(x, y, x2, y2)) continue;\n if (!checkSide45(x2, y2, x3, y3)) continue;\n if (!checkSide45(x3, y3, x4, y4)) continue;\n if (!checkSide45(x4, y4, x, y)) continue;\n if (!edgesFree45(x, y, x2, y2, x3, y3, x4, y4)) continue;\n \n Rect r{ x, y, x2, y2, x3, y3, x4, y4 };\n answer.push_back(r);\n addEdges45(x, y, x2, y2, x3, y3, x4, y4);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n found45 = true;\n break;\n }\n if (found45) break;\n \n // Case D: left vertex\n d_max = min({x / 2, N - 1 - y, y});\n for (int d = 1; d <= d_max; ++d) {\n int x2 = x - d, y2 = y + d;\n int x3 = x - 2 * d, y3 = y;\n int x4 = x - d, y4 = y - d;\n if (!dot[x2][y2] || !dot[x3][y3] || !dot[x4][y4]) continue;\n if (!checkSide45(x, y, x2, y2)) continue;\n if (!checkSide45(x2, y2, x3, y3)) continue;\n if (!checkSide45(x3, y3, x4, y4)) continue;\n if (!checkSide45(x4, y4, x, y)) continue;\n if (!edgesFree45(x, y, x2, y2, x3, y3, x4, y4)) continue;\n \n Rect r{ x, y, x2, y2, x3, y3, x4, y4 };\n answer.push_back(r);\n addEdges45(x, y, x2, y2, x3, y3, x4, y4);\n dot[x][y] = 1;\n rowDots[y].push_back(x);\n colDots[x].push_back(y);\n empty[i] = empty.back();\n empty.pop_back();\n progress = true;\n found45 = true;\n break;\n }\n }\n \n if (!progress) break;\n }\n\n // Calculate approximate score for this trial\n long long score = 0;\n for (int x = 0; x < N; ++x)\n for (int y = 0; y < N; ++y)\n if (dot[x][y])\n score += (long long)(weight(x, y));\n\n if (score > bestScore) {\n bestScore = score;\n bestAnswer = answer;\n }\n }\n\n // Output best result\n cout << bestAnswer.size() << '\\n';\n for (const auto &r : bestAnswer) {\n cout << r.x1 << ' ' << r.y1 << ' '\n << r.x2 << ' ' << r.y2 << ' '\n << r.x3 << ' ' << r.y3 << ' '\n << r.x4 << ' ' << r.y4 << '\\n';\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nconstexpr int H = 10;\nconstexpr int W = 10;\nconstexpr int MAXC = 100;\n\nint flavor[MAXC + 1];\n\nvoid copyBoard(const int src[H][W], int dst[H][W]) {\n for (int i = 0; i < H; ++i)\n for (int j = 0; j < W; ++j)\n dst[i][j] = src[i][j];\n}\n\nvoid tiltBoard(int a[H][W], char dir) {\n if (dir == 'F') {\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = 0; r < H; ++r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[i][c] = buf[i];\n }\n } else if (dir == 'B') {\n for (int c = 0; c < W; ++c) {\n int buf[H];\n int sz = 0;\n for (int r = H - 1; r >= 0; --r)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int r = 0; r < H; ++r) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[H - 1 - i][c] = buf[i];\n }\n } else if (dir == 'L') {\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = 0; c < W; ++c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][i] = buf[i];\n }\n } else if (dir == 'R') {\n for (int r = 0; r < H; ++r) {\n int buf[W];\n int sz = 0;\n for (int c = W - 1; c >= 0; --c)\n if (a[r][c] != 0) buf[sz++] = a[r][c];\n for (int c = 0; c < W; ++c) a[r][c] = 0;\n for (int i = 0; i < sz; ++i) a[r][W - 1 - i] = buf[i];\n }\n }\n}\n\nstruct Eval {\n int sumSq;\n int maxSize;\n int compCnt;\n};\n\nEval evaluate(const int a[H][W]) {\n bool vis[H][W] = {false};\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n\n Eval res{0, 0, 0};\n for (int r = 0; r < H; ++r) {\n for (int c = 0; c < W; ++c) {\n if (a[r][c] && !vis[r][c]) {\n int fl = a[r][c];\n int sz = 0;\n queue> q;\n q.emplace(r, c);\n vis[r][c] = true;\n while (!q.empty()) {\n auto [cr, cc] = q.front(); q.pop();\n ++sz;\n for (int d = 0; d < 4; ++d) {\n int nr = cr + dr[d];\n int nc = cc + dc[d];\n if (nr >= 0 && nr < H && nc >= 0 && nc < W &&\n !vis[nr][nc] && a[nr][nc] == fl) {\n vis[nr][nc] = true;\n q.emplace(nr, nc);\n }\n }\n }\n res.sumSq += sz * sz;\n res.maxSize = max(res.maxSize, sz);\n ++res.compCnt;\n }\n }\n }\n return res;\n}\n\nstatic const char DIRS[4] = {'F', 'B', 'L', 'R'};\n\nchar oppositeDir(char d) {\n if (d == 'F') return 'B';\n if (d == 'B') return 'F';\n if (d == 'L') return 'R';\n return 'L';\n}\n\nchar bestDirOneStep(const int board[H][W]) {\n char bestDir = 'R';\n Eval best{-1, -1, INT_MAX};\n for (char d : DIRS) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n Eval ev = evaluate(tmp);\n if (ev.sumSq > best.sumSq ||\n (ev.sumSq == best.sumSq && ev.maxSize > best.maxSize) ||\n (ev.sumSq == best.sumSq && ev.maxSize == best.maxSize && ev.compCnt < best.compCnt)) {\n best = ev;\n bestDir = d;\n }\n }\n return bestDir;\n}\n\nvector> getEmpty(const int board[H][W]) {\n vector> v;\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n if (board[r][c] == 0) v.emplace_back(r, c);\n return v;\n}\n\n// Depth-2 look-ahead with full enumeration (stable version)\ndouble expectedAfterTwoSteps(const int board[H][W], int curStep) {\n int nextStep = curStep + 1;\n if (nextStep > MAXC) return evaluate(board).sumSq;\n\n vector> empties = getEmpty(board);\n int cnt = (int)empties.size();\n if (cnt == 0) return evaluate(board).sumSq;\n\n double total = 0.0;\n int flNext = flavor[nextStep];\n \n // For each possible position of the next candy\n for (auto &ec : empties) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tmp[ec.first][ec.second] = flNext; // place next candy\n \n // Find greedy best direction after placement\n char d1 = bestDirOneStep(tmp);\n tiltBoard(tmp, d1);\n \n total += evaluate(tmp).sumSq;\n }\n return total / cnt;\n}\n\n// More sophisticated depth-2 with better evaluation\ndouble expectedAfterTwoStepsV2(const int board[H][W], int curStep) {\n int nextStep = curStep + 1;\n if (nextStep > MAXC) {\n Eval e = evaluate(board);\n return e.sumSq * 1.0; // final score\n }\n\n vector> empties = getEmpty(board);\n int cnt = (int)empties.size();\n if (cnt == 0) {\n Eval e = evaluate(board);\n return e.sumSq * 1.0;\n }\n\n // Early steps: use smaller lookahead\n if (curStep < 10) {\n // For early steps, just evaluate the immediate sumSq after greedy tilt\n char d = bestDirOneStep(board);\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n Eval e = evaluate(tmp);\n return e.sumSq * 1.0;\n }\n\n double total = 0.0;\n int flNext = flavor[nextStep];\n \n for (auto &ec : empties) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tmp[ec.first][ec.second] = flNext;\n \n // Try all 4 directions and pick the best one\n char bestDir = 'F';\n Eval bestEval{-1, -1, INT_MAX};\n \n for (char d : DIRS) {\n int tmp2[H][W];\n copyBoard(tmp, tmp2);\n tiltBoard(tmp2, d);\n Eval ev = evaluate(tmp2);\n \n // Use weighted score: sumSq + 0.5*maxSize - 2*compCnt\n double score = ev.sumSq + 0.5 * ev.maxSize - 2.0 * ev.compCnt;\n double bestScore = bestEval.sumSq + 0.5 * bestEval.maxSize - 2.0 * bestEval.compCnt;\n \n if (score > bestScore) {\n bestScore = score;\n bestDir = d;\n bestEval = ev;\n }\n }\n \n // Apply best direction\n tiltBoard(tmp, bestDir);\n Eval finalEval = evaluate(tmp);\n total += finalEval.sumSq;\n }\n return total / cnt;\n}\n\nchar chooseDirection(const int board[H][W], int curStep) {\n double bestScore = -1.0;\n char bestDir = 'R';\n \n for (char d : DIRS) {\n int tmp[H][W];\n copyBoard(board, tmp);\n tiltBoard(tmp, d);\n double expScore = expectedAfterTwoStepsV2(tmp, curStep);\n if (expScore > bestScore + 1e-9) {\n bestScore = expScore;\n bestDir = d;\n }\n }\n return bestDir;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n for (int i = 1; i <= MAXC; ++i) {\n if (!(cin >> flavor[i])) return 0;\n }\n\n int board[H][W] = {0};\n\n vector> empties;\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n empties.emplace_back(r, c);\n\n for (int step = 1; step <= MAXC; ++step) {\n int p;\n cin >> p;\n auto cell = empties[p - 1];\n board[cell.first][cell.second] = flavor[step];\n empties.erase(empties.begin() + (p - 1));\n\n char dir;\n if (step == MAXC) {\n dir = bestDirOneStep(board);\n } else {\n dir = chooseDirection(board, step);\n }\n\n cout << dir << '\\n' << std::flush;\n tiltBoard(board, dir);\n\n empties.clear();\n for (int r = 0; r < H; ++r)\n for (int c = 0; c < W; ++c)\n if (board[r][c] == 0) empties.emplace_back(r, c);\n }\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nconst int MAX_E = 4950; // N = 100 \u2192 E = 4950\n\n/* ------------------------------------------------------------------ */\n/* Build codebook: uniform spacing with floor */\nvoid build_codebook_floor(int N, int M, vector &mi) {\n int E = N * (N - 1) / 2;\n long double step = (long double)E / (long double)(M - 1);\n mi.resize(M);\n for (int i = 0; i < M; ++i) {\n mi[i] = (int)floor((long double)i * step);\n }\n sort(mi.begin(), mi.end());\n // ensure strictly increasing\n for (int i = 1; i < M; ++i) {\n if (mi[i] <= mi[i - 1]) mi[i] = mi[i - 1] + 1;\n }\n if (mi.back() > E) mi.back() = E;\n}\n\n/* ------------------------------------------------------------------ */\n/* Build codebook: uniform spacing with rounding */\nvoid build_codebook_round(int N, int M, vector &mi) {\n int E = N * (N - 1) / 2;\n long double step = (long double)E / (long double)(M - 1);\n mi.resize(M);\n for (int i = 0; i < M; ++i) {\n mi[i] = (int)llround((long double)i * step);\n if (mi[i] < 0) mi[i] = 0;\n if (mi[i] > E) mi[i] = E;\n }\n sort(mi.begin(), mi.end());\n // ensure strictly increasing\n for (int i = 1; i < M; ++i) {\n if (mi[i] <= mi[i - 1]) mi[i] = mi[i - 1] + 1;\n }\n if (mi.back() > E) mi.back() = E;\n}\n\n/* ------------------------------------------------------------------ */\n/* Compute p_err exactly for a given codebook */\nlong double compute_p_err(int N, int M, long double eps, const vector &mi) {\n int E = N * (N - 1) / 2;\n long double oneMinus2eps = 1.0L - 2.0L * eps;\n \n // log probabilities for each hypothesis\n vector logp(M), log1mp(M);\n for (int i = 0; i < M; ++i) {\n long double p = eps + oneMinus2eps * (long double)mi[i] / (long double)E;\n logp[i] = logl(p);\n log1mp[i] = log1pl(-p); // log(1-p)\n }\n \n // precompute factorial logs up to MAX_E\n static vector lfac;\n if (lfac.empty()) {\n lfac.resize(MAX_E + 1);\n lfac[0] = 0;\n for (int i = 1; i <= MAX_E; ++i) lfac[i] = lfac[i - 1] + logl((long double)i);\n }\n \n // log binomial coefficients for this E\n vector logBinomE(E + 1);\n for (int x = 0; x <= E; ++x) {\n logBinomE[x] = lfac[E] - lfac[x] - lfac[E - x];\n }\n \n long double total_correct = 0.0L;\n for (int x = 0; x <= E; ++x) {\n long double log_common = logBinomE[x];\n long double best = -numeric_limits::infinity();\n for (int i = 0; i < M; ++i) {\n long double cur = log_common +\n (long double)x * logp[i] +\n (long double)(E - x) * log1mp[i];\n if (cur > best) best = cur;\n }\n total_correct += expl(best);\n }\n \n long double p_err = 1.0L - total_correct / (long double)M;\n if (p_err < 0) p_err = 0;\n if (p_err > 1) p_err = 1;\n return p_err;\n}\n\n/* ------------------------------------------------------------------ */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n long double eps;\n if (!(cin >> M >> eps)) return 0;\n \n /* smallest N that can encode M different edge counts */\n int minN = 4;\n while (minN * (minN - 1) / 2 < M - 1) ++minN;\n \n int bestN = minN;\n long double bestScore = -1.0L;\n vector best_mi;\n \n if (fabsl(eps) < 1e-12L) {\n /* perfect noiseless case \u2013 smallest N is optimal */\n bestN = minN;\n build_codebook_floor(bestN, M, best_mi);\n } else {\n /* Search over all possible N values */\n for (int N = minN; N <= 100; ++N) {\n // Build floor codebook\n vector mi_floor;\n build_codebook_floor(N, M, mi_floor);\n \n // Compute exact error probability\n long double p_err = compute_p_err(N, M, eps, mi_floor);\n \n // Compute expected score\n long double factor = powl(1.0L - 0.1L * p_err, 100);\n long double score = 1e9L * factor / (long double)N;\n \n if (score > bestScore) {\n bestScore = score;\n bestN = N;\n best_mi = mi_floor;\n }\n \n // Also try round codebook (only if different)\n vector mi_round;\n build_codebook_round(N, M, mi_round);\n if (mi_round != mi_floor) {\n p_err = compute_p_err(N, M, eps, mi_round);\n factor = powl(1.0L - 0.1L * p_err, 100);\n long double score_round = 1e9L * factor / (long double)N;\n \n // Only prefer round if it's significantly better (by 0.1%)\n if (score_round > bestScore * 1.001L) {\n bestScore = score_round;\n bestN = N;\n best_mi = mi_round;\n }\n }\n }\n }\n \n /* ------------------------------------------------------------------ */\n /* Build the final codebook for the chosen N */\n if (best_mi.empty()) {\n build_codebook_floor(bestN, M, best_mi);\n }\n int N = bestN;\n int E = N * (N - 1) / 2;\n \n /* ------------------------------------------------------------------ */\n /* Output the graphs */\n cout << N << \"\\n\";\n string edgeStr(E, '0');\n for (int idx = 0; idx < M; ++idx) {\n int ones = best_mi[idx];\n fill(edgeStr.begin(), edgeStr.end(), '0');\n for (int j = 0; j < ones; ++j) edgeStr[j] = '1';\n cout << edgeStr << \"\\n\";\n }\n cout.flush();\n \n /* ------------------------------------------------------------------ */\n /* Pre\u2011compute decoding tables for the final N */\n long double oneMinus2eps = 1.0L - 2.0L * eps;\n vector logp(M), log1mp(M);\n for (int i = 0; i < M; ++i) {\n long double p = eps + oneMinus2eps * (long double)best_mi[i] / (long double)E;\n logp[i] = logl(p);\n log1mp[i] = log1pl(-p); // log(1-p)\n }\n \n /* ------------------------------------------------------------------ */\n /* Answer the 100 queries */\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n int x = 0;\n for (char c : H) if (c == '1') ++x;\n \n int answer;\n if (fabsl(eps) < 1e-12L) {\n // \u03b5 = 0 \u2192 exact edge count\n answer = (int)(lower_bound(best_mi.begin(), best_mi.end(), x) - best_mi.begin());\n } else {\n long double bestVal = -numeric_limits::infinity();\n answer = 0;\n for (int i = 0; i < M; ++i) {\n long double cur = (long double)x * logp[i] +\n (long double)(E - x) * log1mp[i];\n if (cur > bestVal) {\n bestVal = cur;\n answer = i;\n }\n }\n }\n cout << answer << \"\\n\";\n cout.flush();\n }\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n int w;\n};\n\nint N, M, D, K;\nvector edges;\nvector>> adj;\nvector> edge_adj;\nvector> day_edges;\nvector day_cnt;\nvector day_of_edge;\nvector removed;\nvector visited;\nvector q;\n\n// ---------------------------------------------------------------\nbool safe(int day, int cand) {\n if (day_cnt[day] == 0) return true;\n \n for (int e : day_edges[day]) removed[e] = 1;\n removed[cand] = 1;\n \n fill(visited.begin(), visited.end(), 0);\n int qs = 0, qe = 0;\n visited[0] = 1;\n q[qe++] = 0;\n while (qs < qe) {\n int v = q[qs++];\n for (auto [to, eid] : adj[v]) {\n if (removed[eid]) continue;\n if (!visited[to]) {\n visited[to] = 1;\n q[qe++] = to;\n }\n }\n }\n \n for (int e : day_edges[day]) removed[e] = 0;\n removed[cand] = 0;\n \n for (int i = 0; i < N; ++i) if (!visited[i]) return false;\n return true;\n}\n\n// ---------------------------------------------------------------\nint compute_metric() {\n int met = 0;\n for (int e = 0; e < M; ++e) {\n int d = day_of_edge[e];\n for (int nb : edge_adj[e]) {\n if (day_of_edge[nb] == d && nb < e) ++met;\n }\n }\n return met;\n}\n\n// ---------------------------------------------------------------\nbool is_valid_schedule() {\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] > K) return false;\n }\n for (int e = 0; e < M; ++e) {\n if (day_of_edge[e] < 0 || day_of_edge[e] >= D) return false;\n }\n return true;\n}\n\n// ---------------------------------------------------------------\nvoid greedy_build(const vector& order) {\n for (int d = 0; d < D; ++d) {\n day_edges[d].clear();\n day_cnt[d] = 0;\n }\n fill(day_of_edge.begin(), day_of_edge.end(), -1);\n \n vector score(D, 0);\n \n for (int eid : order) {\n fill(score.begin(), score.end(), 0);\n for (int nb : edge_adj[eid]) {\n int d = day_of_edge[nb];\n if (d != -1) ++score[d];\n }\n \n int best_score = -1;\n vector cand;\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] >= K) continue;\n if (score[d] > best_score) {\n best_score = score[d];\n cand.clear();\n cand.push_back(d);\n } else if (score[d] == best_score) {\n cand.push_back(d);\n }\n }\n \n if (cand.empty()) {\n // Find any day with space\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K) {\n cand.push_back(d);\n break;\n }\n }\n }\n \n if (cand.empty()) continue; // Should not happen with valid K\n \n int chosen = cand[0];\n for (int d : cand) {\n if (day_cnt[d] < day_cnt[chosen]) chosen = d;\n }\n \n // Safety check\n if (day_cnt[chosen] > 0 && !safe(chosen, eid)) {\n bool found = false;\n for (int d : cand) {\n if (d == chosen) continue;\n if (day_cnt[d] == 0 || safe(d, eid)) {\n chosen = d;\n found = true;\n break;\n }\n }\n if (!found) {\n // Try any day with space\n for (int d = 0; d < D; ++d) {\n if (d != chosen && day_cnt[d] < K && (day_cnt[d] == 0 || safe(d, eid))) {\n chosen = d;\n found = true;\n break;\n }\n }\n }\n if (!found) {\n // Last resort: put in day with fewest edges\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K) {\n chosen = d;\n break;\n }\n }\n }\n }\n \n day_of_edge[eid] = chosen;\n ++day_cnt[chosen];\n day_edges[chosen].push_back(eid);\n }\n}\n\n// ---------------------------------------------------------------\nvoid local_search_fast(int max_moves = 300) {\n mt19937 rng(random_device{}());\n \n for (int iter = 0; iter < max_moves; ++iter) {\n int eid = rng() % M;\n int old_day = day_of_edge[eid];\n \n int old_adj = 0;\n for (int nb : edge_adj[eid]) {\n if (day_of_edge[nb] == old_day && nb < eid) ++old_adj;\n }\n \n int best_delta = -1000;\n int best_day = -1;\n \n for (int d = 0; d < D; ++d) {\n if (d == old_day || day_cnt[d] >= K) continue;\n if (day_cnt[d] > 0 && !safe(d, eid)) continue;\n \n int new_adj = 0;\n for (int nb : edge_adj[eid]) {\n if (day_of_edge[nb] == d) ++new_adj;\n }\n \n int delta = new_adj - old_adj;\n if (delta > best_delta) {\n best_delta = delta;\n best_day = d;\n }\n }\n \n if (best_delta > 0 && best_day != -1) {\n auto &vec = day_edges[old_day];\n for (size_t i = 0; i < vec.size(); ++i) {\n if (vec[i] == eid) {\n vec[i] = vec.back();\n vec.pop_back();\n break;\n }\n }\n --day_cnt[old_day];\n \n day_of_edge[eid] = best_day;\n ++day_cnt[best_day];\n day_edges[best_day].push_back(eid);\n }\n }\n}\n\n// ---------------------------------------------------------------\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n if (!(cin >> N >> M >> D >> K)) return 0;\n edges.resize(M);\n adj.assign(N, {});\n vector> vertex_edges[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 adj[u].push_back({v, i});\n adj[v].push_back({u, i});\n vertex_edges[u].push_back({v, i});\n vertex_edges[v].push_back({u, i});\n }\n \n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n \n // Build line-graph adjacency\n edge_adj.assign(M, {});\n for (int v = 0; v < N; ++v) {\n for (size_t a = 0; a < vertex_edges[v].size(); ++a) {\n int e1 = vertex_edges[v][a].second;\n for (size_t b = a + 1; b < vertex_edges[v].size(); ++b) {\n int e2 = vertex_edges[v][b].second;\n edge_adj[e1].push_back(e2);\n edge_adj[e2].push_back(e1);\n }\n }\n }\n \n day_edges.assign(D, {});\n day_cnt.assign(D, 0);\n day_of_edge.assign(M, -1);\n removed.assign(M, 0);\n visited.assign(N, 0);\n q.resize(N);\n \n const int ITERATIONS = 20;\n int best_metric = -1;\n vector best_assignment;\n \n for (int it = 0; it < ITERATIONS; ++it) {\n vector order(M);\n iota(order.begin(), order.end(), 0);\n \n if (it % 3 == 0) {\n shuffle(order.begin(), order.end(), mt19937{random_device{}()});\n } else if (it % 3 == 1) {\n sort(order.begin(), order.end(), [&](int a, int b) {\n return edge_adj[a].size() > edge_adj[b].size();\n });\n for (int i = 0; i < 100; ++i) {\n int a = rand() % M, b = rand() % M;\n swap(order[a], order[b]);\n }\n } else {\n sort(order.begin(), order.end(), [&](int a, int b) {\n return edges[a].w < edges[b].w;\n });\n for (int i = 0; i < 100; ++i) {\n int a = rand() % M, b = rand() % M;\n swap(order[a], order[b]);\n }\n }\n \n greedy_build(order);\n \n // Verify all edges assigned\n for (int e = 0; e < M; ++e) {\n if (day_of_edge[e] == -1) {\n // Assign to first available day\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K) {\n day_of_edge[e] = d;\n ++day_cnt[d];\n day_edges[d].push_back(e);\n break;\n }\n }\n }\n }\n \n local_search_fast(400);\n \n // Final verification\n if (!is_valid_schedule()) {\n continue;\n }\n \n int met = compute_metric();\n if (met > best_metric) {\n best_metric = met;\n best_assignment = day_of_edge;\n }\n }\n \n // Fallback if no valid schedule found\n if (best_assignment.empty()) {\n best_assignment.assign(M, 0);\n for (int e = 0; e < M; ++e) {\n best_assignment[e] = e % D;\n }\n }\n \n // Verify final assignment\n for (int e = 0; e < M; ++e) {\n if (best_assignment[e] < 0 || best_assignment[e] >= D) {\n best_assignment[e] = 0;\n }\n }\n vector final_cnt(D, 0);\n for (int e = 0; e < M; ++e) {\n final_cnt[best_assignment[e]]++;\n }\n for (int d = 0; d < D; ++d) {\n while (final_cnt[d] > K) {\n // Move one edge to another day\n for (int e = 0; e < M; ++e) {\n if (best_assignment[e] == d) {\n for (int d2 = 0; d2 < D; ++d2) {\n if (d2 != d && final_cnt[d2] < K) {\n best_assignment[e] = d2;\n final_cnt[d]--;\n final_cnt[d2]++;\n break;\n }\n }\n break;\n }\n }\n }\n }\n \n for (int i = 0; i < M; ++i) {\n if (i) cout << ' ';\n cout << (best_assignment[i] + 1);\n }\n cout << '\\n';\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n cin >> D;\n vector f1(D), r1(D), f2(D), r2(D);\n for (int i = 0; i < D; i++) cin >> f1[i];\n for (int i = 0; i < D; i++) cin >> r1[i];\n for (int i = 0; i < D; i++) cin >> f2[i];\n for (int i = 0; i < D; i++) cin >> r2[i];\n \n vector O1(D, vector(D, vector(D, 0)));\n vector O2(D, vector(D, vector(D, 0)));\n \n auto min_edge_cover = [&](const vector& F, const vector& R,\n auto& O, int z) {\n int nF = F.size(), nR = R.size();\n if (nF == 0 || nR == 0) return;\n \n if (nF >= nR) {\n for (int i = 0; i < nR; i++) O[F[i]][R[i]][z] = 1;\n for (int i = nR; i < nF; i++) O[F[i]][R[0]][z] = 1;\n } else {\n for (int i = 0; i < nF; i++) O[F[i]][R[i]][z] = 1;\n for (int i = nF; i < nR; i++) O[F[0]][R[i]][z] = 1;\n }\n };\n \n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f1[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r1[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O1, z);\n }\n \n for (int z = 0; z < D; z++) {\n vector F, R;\n for (int x = 0; x < D; x++) if (f2[z][x] == '1') F.push_back(x);\n for (int y = 0; y < D; y++) if (r2[z][y] == '1') R.push_back(y);\n min_edge_cover(F, R, O2, z);\n }\n \n const int dx[6] = {1,-1,0,0,0,0}, dy[6] = {0,0,1,-1,0,0}, dz[6] = {0,0,0,0,1,-1};\n \n // Find connected components in O1\n vector comp1(D * D * D, -1);\n vector>> comps1;\n vector>> cells1_per_comp;\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n int idx = x * D * D + y * D + z;\n if (O1[x][y][z] && comp1[idx] == -1) {\n vector> cells;\n queue q;\n q.push(idx);\n comp1[idx] = comps1.size();\n \n while (!q.empty()) {\n int cur = q.front(); q.pop();\n int cx = cur / (D * D);\n int cy = (cur / D) % D;\n int cz = cur % D;\n cells.emplace_back(cx, cy, cz);\n \n for (int d = 0; d < 6; d++) {\n int nx = cx + dx[d], ny = cy + dy[d], nz = cz + dz[d];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D || nz < 0 || nz >= D) continue;\n int nidx = nx * D * D + ny * D + nz;\n if (O1[nx][ny][nz] && comp1[nidx] == -1) {\n comp1[nidx] = comps1.size();\n q.push(nidx);\n }\n }\n }\n comps1.push_back(cells);\n }\n }\n }\n }\n \n // Find connected components in O2\n vector comp2(D * D * D, -1);\n vector>> comps2;\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n int idx = x * D * D + y * D + z;\n if (O2[x][y][z] && comp2[idx] == -1) {\n vector> cells;\n queue q;\n q.push(idx);\n comp2[idx] = comps2.size();\n \n while (!q.empty()) {\n int cur = q.front(); q.pop();\n int cx = cur / (D * D);\n int cy = (cur / D) % D;\n int cz = cur % D;\n cells.emplace_back(cx, cy, cz);\n \n for (int d = 0; d < 6; d++) {\n int nx = cx + dx[d], ny = cy + dy[d], nz = cz + dz[d];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D || nz < 0 || nz >= D) continue;\n int nidx = nx * D * D + ny * D + nz;\n if (O2[nx][ny][nz] && comp2[nidx] == -1) {\n comp2[nidx] = comps2.size();\n q.push(nidx);\n }\n }\n }\n comps2.push_back(cells);\n }\n }\n }\n }\n \n // Normalize shape\n auto normalize = [&](const vector>& s) {\n if (s.empty()) return vector>();\n int minx = get<0>(s[0]), miny = get<1>(s[0]), minz = get<2>(s[0]);\n for (auto& p : s) {\n minx = min(minx, get<0>(p));\n miny = min(miny, get<1>(p));\n minz = min(minz, get<2>(p));\n }\n vector> ns;\n for (auto& p : s) {\n ns.emplace_back(get<0>(p)-minx, get<1>(p)-miny, get<2>(p)-minz);\n }\n sort(ns.begin(), ns.end());\n return ns;\n };\n \n // Check if two shapes match under rotation\n auto shapes_match = [&](const vector>& s1,\n const vector>& s2) -> bool {\n if (s1.size() != s2.size()) return false;\n if (s1.empty()) return true;\n \n vector> ns1 = normalize(s1);\n \n for (int axis = 0; axis < 3; axis++) {\n for (int layer = 0; layer < 4; layer++) {\n vector> ns2;\n for (auto& p : s2) {\n int x = get<0>(p), y = get<1>(p), z = get<2>(p);\n int nx, ny, nz;\n if (axis == 0) {\n if (layer == 0) { nx=x; ny=y; nz=z; }\n else if (layer == 1) { nx=x; ny=-z; nz=y; }\n else if (layer == 2) { nx=x; ny=-y; nz=-z; }\n else { nx=x; ny=z; nz=-y; }\n } else if (axis == 1) {\n if (layer == 0) { nx=x; ny=y; nz=z; }\n else if (layer == 1) { nx=z; ny=y; nz=-x; }\n else if (layer == 2) { nx=-x; ny=y; nz=-z; }\n else { nx=-z; ny=y; nz=x; }\n } else {\n if (layer == 0) { nx=x; ny=y; nz=z; }\n else if (layer == 1) { nx=-y; ny=x; nz=z; }\n else if (layer == 2) { nx=-x; ny=-y; nz=z; }\n else { nx=y; ny=-x; nz=z; }\n }\n ns2.emplace_back(nx, ny, nz);\n }\n ns2 = normalize(ns2);\n if (ns1 == ns2) return true;\n }\n }\n return false;\n };\n \n // Build lookup: for each comp1, find matching comp2\n vector match1(comps1.size(), -1), match2(comps2.size(), -1);\n \n for (int i = 0; i < (int)comps1.size(); i++) {\n for (int j = 0; j < (int)comps2.size(); j++) {\n if (match2[j] >= 0) continue;\n if (shapes_match(comps1[i], comps2[j])) {\n match1[i] = j;\n match2[j] = i;\n break;\n }\n }\n }\n \n // Build blocks: first merged (used in both), then unmerged from O1, then unmerged from O2\n vector>> blocks;\n vector block_idx1(comps1.size(), -1), block_idx2(comps2.size(), -1);\n int idx = 1;\n \n // Merged blocks\n for (int i = 0; i < (int)comps1.size(); i++) {\n if (match1[i] >= 0) {\n // Combine cells from both\n vector> merged = comps1[i];\n merged.insert(merged.end(), comps2[match1[i]].begin(), comps2[match1[i]].end());\n blocks.push_back(merged);\n block_idx1[i] = idx;\n block_idx2[match1[i]] = idx;\n idx++;\n }\n }\n \n // Unmerged from O1\n for (int i = 0; i < (int)comps1.size(); i++) {\n if (match1[i] < 0) {\n blocks.push_back(comps1[i]);\n block_idx1[i] = idx;\n idx++;\n }\n }\n \n // Unmerged from O2\n for (int j = 0; j < (int)comps2.size(); j++) {\n if (match2[j] < 0) {\n blocks.push_back(comps2[j]);\n block_idx2[j] = idx;\n idx++;\n }\n }\n \n int n = blocks.size();\n \n // Create idx arrays for output\n vector>> out1(D, vector>(D, vector(D, 0)));\n vector>> out2(D, vector>(D, vector(D, 0)));\n \n for (int i = 0; i < (int)comps1.size(); i++) {\n for (auto& p : comps1[i]) {\n int x, y, z;\n tie(x, y, z) = p;\n out1[x][y][z] = block_idx1[i];\n }\n }\n \n for (int j = 0; j < (int)comps2.size(); j++) {\n for (auto& p : comps2[j]) {\n int x, y, z;\n tie(x, y, z) = p;\n out2[x][y][z] = block_idx2[j];\n }\n }\n \n cout << n << \"\\n\";\n \n // Output b1\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O1[x][y][z]) cout << out1[x][y][z];\n else cout << 0;\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n // Output b2\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (O2[x][y][z]) cout << out2[x][y][z];\n else cout << 0;\n if (x == D-1 && y == D-1 && z == D-1) cout << \"\\n\";\n else cout << \" \";\n }\n }\n }\n \n return 0;\n}","ahc020":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n long long w;\n int idx;\n};\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n r.assign(n, 0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nint N, M, K;\nvector> vertex;\nvector> resident;\nvector edges;\nvector edgesSorted;\nvector> dist2;\nvector>> cand;\n\nconst long long INF = (1LL<<60);\nconst long long R2 = 5000LL * 5000LL;\n\nbool can_cover_all(const vector& sel) {\n for (int k = 0; k < K; ++k) {\n bool ok = false;\n for (auto &pr : cand[k]) {\n if (sel[pr.first]) {\n ok = true;\n break;\n }\n }\n if (!ok) return false;\n }\n return true;\n}\n\nlong long price_of(const vector& sel) {\n if (!can_cover_all(sel)) return INF;\n \n long long edgeCost = 0;\n DSU dsu(N);\n int components = 0;\n for (int i = 0; i < N; ++i) if (sel[i]) ++components;\n \n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v)) {\n edgeCost += e.w;\n if (--components == 1) break;\n }\n }\n }\n \n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (sel[i]) {\n if (maxDistSq[i] < pr.second) maxDistSq[i] = pr.second;\n break;\n }\n }\n }\n \n long long sumP2 = 0;\n for (int i = 0; i < N; ++i) {\n if (!sel[i]) continue;\n long long md2 = maxDistSq[i];\n if (md2 < 0) continue;\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n sumP2 += r * r;\n }\n \n return edgeCost + sumP2;\n}\n\nvector find_critical(const vector& sel) {\n vector critical(N, 0);\n vector tmp = sel;\n for (int v = 1; v < N; ++v) {\n if (!tmp[v]) continue;\n tmp[v] = 0;\n if (!can_cover_all(tmp)) {\n critical[v] = 1;\n }\n tmp[v] = 1;\n }\n \n // Mark adjacent vertices as semi-critical (level 2)\n for (int v = 1; v < N; ++v) {\n if (critical[v]) {\n for (auto &e : edges) {\n int u = e.u, wv = e.v;\n if (u == v) {\n if (!critical[wv]) critical[wv] = 2;\n } else if (wv == v) {\n if (!critical[u]) critical[u] = 2;\n }\n }\n }\n }\n \n // Mark vertices two hops away as level 3\n for (int v = 1; v < N; ++v) {\n if (critical[v] == 2) {\n for (auto &e : edges) {\n int u = e.u, wv = e.v;\n if (u == v) {\n if (!critical[wv]) critical[wv] = 3;\n } else if (wv == v) {\n if (!critical[u]) critical[u] = 3;\n }\n }\n }\n }\n \n return critical;\n}\n\nvector mst_edges(const vector& sel) {\n vector B(M, 0);\n DSU dsu(N);\n int need = 0;\n for (int i = 0; i < N; ++i) if (sel[i]) ++need;\n if (need <= 1) return B;\n for (const Edge& e : edgesSorted) {\n if (sel[e.u] && sel[e.v]) {\n if (dsu.unite(e.u, e.v)) {\n B[e.idx] = 1;\n if (--need == 1) break;\n }\n }\n }\n return B;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n if (!(cin >> N >> M >> K)) return 0;\n vertex.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> vertex[i].first >> vertex[i].second;\n }\n edges.resize(M);\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, j};\n }\n resident.resize(K);\n for (int k = 0; k < K; ++k) {\n cin >> resident[k].first >> resident[k].second;\n }\n \n dist2.assign(N, vector(K, 0));\n cand.assign(K, {});\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n long long dx = vertex[i].first - resident[k].first;\n long long dy = vertex[i].second - resident[k].second;\n long long d2 = dx*dx + dy*dy;\n dist2[i][k] = d2;\n if (d2 <= R2) cand[k].push_back({i, d2});\n }\n }\n for (int k = 0; k < K; ++k)\n sort(cand[k].begin(), cand[k].end(),\n [](const auto& a, const auto& b){ return a.second < b.second; });\n \n edgesSorted = edges;\n sort(edgesSorted.begin(), edgesSorted.end(),\n [](const Edge& a, const Edge& b){ return a.w < b.w; });\n \n vector bestSel(N, 1);\n bestSel[0] = 1;\n long long bestCost = price_of(bestSel);\n \n // Phase 1: Conservative removal (only remove vertices with critical == 0)\n bool changed = true;\n while (changed) {\n changed = false;\n vector critical = find_critical(bestSel);\n \n long long bestGain = 0;\n int bestV = -1;\n \n for (int v = 1; v < N; ++v) {\n if (!bestSel[v] || critical[v] >= 1) continue;\n \n bestSel[v] = 0;\n if (!can_cover_all(bestSel)) {\n bestSel[v] = 1;\n continue;\n }\n \n long long newCost = price_of(bestSel);\n bestSel[v] = 1;\n \n if (newCost < bestCost && bestCost - newCost > bestGain) {\n bestGain = bestCost - newCost;\n bestV = v;\n }\n }\n \n if (bestV != -1) {\n bestSel[bestV] = 0;\n bestCost -= bestGain;\n changed = true;\n }\n }\n \n // Phase 2: Greedy addition\n changed = true;\n while (changed) {\n changed = false;\n long long bestGain = 0;\n int bestV = -1;\n \n for (int v = 1; v < N; ++v) {\n if (bestSel[v]) continue;\n bestSel[v] = 1;\n long long newCost = price_of(bestSel);\n bestSel[v] = 0;\n \n if (newCost < bestCost && bestCost - newCost > bestGain) {\n bestGain = bestCost - newCost;\n bestV = v;\n }\n }\n \n if (bestV != -1) {\n bestSel[bestV] = 1;\n bestCost -= bestGain;\n changed = true;\n }\n }\n \n // Phase 3: Final conservative removal\n changed = true;\n while (changed) {\n changed = false;\n vector critical = find_critical(bestSel);\n \n long long bestGain = 0;\n int bestV = -1;\n \n for (int v = 1; v < N; ++v) {\n if (!bestSel[v] || critical[v] >= 1) continue;\n \n bestSel[v] = 0;\n if (!can_cover_all(bestSel)) {\n bestSel[v] = 1;\n continue;\n }\n \n long long newCost = price_of(bestSel);\n bestSel[v] = 1;\n \n if (newCost < bestCost && bestCost - newCost > bestGain) {\n bestGain = bestCost - newCost;\n bestV = v;\n }\n }\n \n if (bestV != -1) {\n bestSel[bestV] = 0;\n bestCost -= bestGain;\n changed = true;\n }\n }\n \n // Ensure full coverage\n if (!can_cover_all(bestSel)) {\n bestSel.assign(N, 1);\n bestCost = price_of(bestSel);\n }\n \n if (!can_cover_all(bestSel)) {\n bestSel.assign(N, 1);\n }\n \n vector maxDistSq(N, -1);\n for (int k = 0; k < K; ++k) {\n for (auto &pr : cand[k]) {\n int i = pr.first;\n if (bestSel[i]) {\n if (maxDistSq[i] < pr.second) maxDistSq[i] = pr.second;\n break;\n }\n }\n }\n \n vector P(N, 0);\n for (int i = 0; i < N; ++i) {\n if (!bestSel[i]) continue;\n long long md2 = maxDistSq[i];\n if (md2 < 0) continue;\n long long r = (long long) sqrt((long double) md2);\n while (r * r < md2) ++r;\n while (r > 0 && (r - 1) * (r - 1) >= md2) --r;\n P[i] = r;\n }\n \n vector B = mst_edges(bestSel);\n \n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << P[i];\n }\n cout << '\\n';\n for (int j = 0; j < M; ++j) {\n if (j) cout << ' ';\n cout << B[j];\n }\n cout << '\\n';\n \n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconst int N = 30;\nconst int TOTAL = N * (N + 1) / 2;\n\nstruct Op { int x1, y1, x2, y2; };\nint start_val[N][N];\n\n/* --------------------------------------------------------------- */\ninline bool inside(int x, int y) { return (0 <= x && x < N && 0 <= y && y <= x); }\ninline int smaller_child(const int val[N][N], int x, int y) {\n if (x >= N - 1) return INT_MAX;\n return min(val[x + 1][y], val[x + 1][y + 1]);\n}\ninline bool violates(const int val[N][N], int x, int y) {\n if (x >= N - 1) return false;\n return val[x][y] > min(val[x + 1][y], val[x + 1][y + 1]);\n}\n\n/* --------------------------------------------------------------- */\n/* bottom-up heapify */\nvector build_bottom_up(const int src[N][N]) {\n int val[N][N];\n memcpy(val, src, sizeof(val));\n vector ops;\n\n auto do_swap = [&](int x1, int y1, int x2, int y2) {\n ops.push_back({x1, y1, x2, y2});\n swap(val[x1][y1], val[x2][y2]);\n };\n\n function sift_down = [&](int x, int y) {\n while (x < N - 1) {\n int c1v = val[x + 1][y];\n int c2v = val[x + 1][y + 1];\n if (val[x][y] <= min(c1v, c2v)) break;\n int cx = x + 1, cy = (c2v < c1v) ? y + 1 : y;\n do_swap(x, y, cx, cy);\n x = cx; y = cy;\n }\n };\n\n for (int x = N - 2; x >= 0; --x)\n for (int y = 0; y <= x; ++y)\n sift_down(x, y);\n return ops;\n}\n\n/* --------------------------------------------------------------- */\n/* greedy with configurable weights */\nvector build_greedy(const int src[N][N], int diff_weight, int depth_weight, int value_weight) {\n int val[N][N];\n memcpy(val, src, sizeof(val));\n vector ops;\n const int MAX_OPS = 10000;\n\n auto do_swap = [&](int x1, int y1, int x2, int y2) -> bool {\n if ((int)ops.size() >= MAX_OPS) return false;\n ops.push_back({x1, y1, x2, y2});\n swap(val[x1][y1], val[x2][y2]);\n return true;\n };\n\n auto count_violations = [&]() -> int {\n int cnt = 0;\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n if (violates(val, x, y)) ++cnt;\n return cnt;\n };\n\n while (count_violations() > 0 && (int)ops.size() < MAX_OPS) {\n int best_score = INT_MIN, best_x = -1, best_y = -1;\n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (violates(val, x, y)) {\n int diff = val[x][y] - smaller_child(val, x, y);\n int depth = N - 1 - x;\n int v = val[x][y];\n int score = diff * diff_weight + depth * depth_weight + v * value_weight;\n if (score > best_score) {\n best_score = score;\n best_x = x; best_y = y;\n }\n }\n }\n }\n if (best_x < 0) break;\n\n int c1v = val[best_x + 1][best_y];\n int c2v = val[best_x + 1][best_y + 1];\n int cx = best_x + 1, cy = (c2v < c1v) ? best_y + 1 : best_y;\n if (!do_swap(best_x, best_y, cx, cy)) break;\n }\n\n function sift = [&](int x, int y) {\n while (x < N - 1) {\n int c1v = val[x + 1][y];\n int c2v = val[x + 1][y + 1];\n if (val[x][y] <= min(c1v, c2v)) break;\n int cx = x + 1, cy = (c2v < c1v) ? y + 1 : y;\n if (!do_swap(x, y, cx, cy)) break;\n x = cx; y = cy;\n }\n };\n\n for (int x = N - 2; x >= 0; --x)\n for (int y = 0; y <= x; ++y)\n sift(x, y);\n\n return ops;\n}\n\n/* --------------------------------------------------------------- */\n/* verify heap */\nbool is_heap(const int v[N][N]) {\n for (int x = 0; x < N - 1; ++x)\n for (int y = 0; y <= x; ++y)\n if (v[x][y] > min(v[x + 1][y], v[x + 1][y + 1]))\n return false;\n return true;\n}\n\n/* --------------------------------------------------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n for (int x = 0; x < N; ++x)\n for (int y = 0; y <= x; ++y)\n cin >> start_val[x][y];\n\n vector best_ops;\n int best_size = INT_MAX;\n\n // Try multiple weight combinations\n vector> weights = {\n {1000, 1, 0}, // diff * 1000 + depth\n {1000, -1, 0}, // diff * 1000 - depth (favor shallow)\n {500, 1, 0}, // diff * 500 + depth\n {500, -1, 0}, // diff * 500 - depth\n {1000, -2, 0}, // diff * 1000 - 2*depth\n {1000, -5, 0}, // diff * 1000 - 5*depth\n {2000, -1, 0}, // diff * 2000 - depth\n {100, 0, 1}, // diff * 100 + value\n {100, 0, -1}, // diff * 100 - value\n {500, -1, 1}, // diff * 500 - depth + value\n {1000, -1, 1}, // diff * 1000 - depth + value\n {1000, -1, -1}, // diff * 1000 - depth - value\n };\n\n vector> candidates;\n candidates.push_back(build_bottom_up(start_val));\n for (auto [dw, dpw, vw] : weights) {\n candidates.push_back(build_greedy(start_val, dw, dpw, vw));\n }\n\n for (auto& ops : candidates) {\n int cur[N][N];\n memcpy(cur, start_val, sizeof(cur));\n for (auto const& op : ops)\n swap(cur[op.x1][op.y1], cur[op.x2][op.y2]);\n \n if (is_heap(cur) && (int)ops.size() <= 10000 && (int)ops.size() < best_size) {\n best_ops = ops;\n best_size = ops.size();\n }\n }\n\n cout << best_ops.size() << '\\n';\n for (auto const& op : best_ops)\n cout << op.x1 << ' ' << op.y1 << ' ' << op.x2 << ' ' << op.y2 << '\\n';\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int D, N;\n if (!(cin >> D >> N)) return 0;\n bool obstacle[9][9] = {};\n\n for (int k = 0; k < N; ++k) {\n int ri, rj; cin >> ri >> rj;\n obstacle[ri][rj] = true;\n }\n\n const int er = 0, ec = (D - 1) / 2;\n const int ENTRANCE_ID = D * D;\n const int TOTAL_NODES = D * D + 1;\n\n // BFS distances (ignoring containers)\n int dist[9][9];\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n dist[i][j] = -1;\n\n queue> q;\n dist[er][ec] = 0;\n q.emplace(er, ec);\n const int dr[4] = {-1,1,0,0};\n const int dc[4] = {0,0,-1,1};\n\n while (!q.empty()) {\n auto [r,c] = q.front(); q.pop();\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (dist[nr][nc] == -1) {\n dist[nr][nc] = dist[r][c] + 1;\n q.emplace(nr,nc);\n }\n }\n }\n\n // List of squares that may contain containers\n vector cells;\n for (int i = 0; i < D; ++i)\n for (int j = 0; j < D; ++j)\n if (!obstacle[i][j] && !(i == er && j == ec))\n cells.push_back(i * D + j);\n\n const int M = (int)cells.size();\n\n // Sorted list of distances\n vector sortedDist;\n sortedDist.reserve(M);\n for (int id : cells) sortedDist.push_back(dist[id / D][id % D]);\n sort(sortedDist.begin(), sortedDist.end());\n\n // Occupied squares and assigned containers\n vector occupied(TOTAL_NODES, 0);\n vector assigned(M, -1);\n\n // ---------- data for articulation point and bridge search ----------\n auto buildNeighbours = [&](int node, vector& out) {\n out.clear();\n if (node == ENTRANCE_ID) {\n int r = er, c = ec;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (occupied[nr * D + nc]) continue;\n int nid = nr * D + nc;\n out.push_back(nid);\n }\n } else {\n int r = node / D, c = node % D;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n if (obstacle[nr][nc]) continue;\n if (occupied[nr * D + nc]) continue;\n if (nr == er && nc == ec) out.push_back(ENTRANCE_ID);\n else out.push_back(nr * D + nc);\n }\n }\n };\n\n vector disc(TOTAL_NODES), low(TOTAL_NODES), parent(TOTAL_NODES);\n vector visited(TOTAL_NODES, 0), isArt(TOTAL_NODES, 0);\n vector> bridges;\n int timer = 0;\n\n function dfs = [&](int u) {\n visited[u] = 1;\n disc[u] = low[u] = ++timer;\n int children = 0;\n vector neigh;\n buildNeighbours(u, neigh);\n for (int v : neigh) {\n if (!visited[v]) {\n ++children;\n parent[v] = u;\n dfs(v);\n low[u] = min(low[u], low[v]);\n if (low[v] > disc[u]) {\n // (u, v) is a bridge\n bridges.emplace_back(u, v);\n }\n if (parent[u] != -1 && low[v] >= disc[u]) isArt[u] = 1;\n } else if (v != parent[u]) {\n low[u] = min(low[u], disc[v]);\n }\n }\n if (parent[u] == -1 && children > 1) isArt[u] = 1;\n };\n\n auto getRemovable = [&]() -> vector {\n fill(visited.begin(), visited.end(), 0);\n fill(disc.begin(), disc.end(), 0);\n fill(low.begin(), low.end(), 0);\n fill(isArt.begin(), isArt.end(), 0);\n fill(parent.begin(), parent.end(), -1);\n bridges.clear();\n timer = 0;\n dfs(ENTRANCE_ID);\n \n vector removable;\n for (int id : cells) {\n if (occupied[id]) continue;\n if (!isArt[id]) {\n // Check if this square is part of a bridge edge\n bool isBridgeNode = false;\n for (auto [a, b] : bridges) {\n if (a == id || b == id) {\n isBridgeNode = true;\n break;\n }\n }\n // Prefer non-bridge nodes for placement\n removable.push_back(id | (isBridgeNode ? (1 << 20) : 0));\n }\n }\n // Sort to prioritize non-bridge nodes\n sort(removable.begin(), removable.end());\n for (int& x : removable) x &= ((1 << 20) - 1);\n return removable;\n };\n\n // ---------- online placement ----------\n for (int step = 0; step < M; ++step) {\n int t; cin >> t;\n int targetDist = sortedDist[t];\n vector cand = getRemovable();\n \n int best = -1;\n int bestDiff = INT_MAX;\n int bestDist = -1;\n \n for (int id : cand) {\n int d = dist[id / D][id % D];\n int diff = abs(d - targetDist);\n if (diff < bestDiff || (diff == bestDiff && d > bestDist)) {\n bestDiff = diff;\n bestDist = d;\n best = id;\n }\n }\n \n // Safety fallback\n if (best == -1) {\n for (int id : cells) if (!occupied[id]) {\n int d = dist[id / D][id % D];\n int diff = abs(d - targetDist);\n if (diff < bestDiff || (diff == bestDiff && d > bestDist)) {\n bestDiff = diff;\n bestDist = d;\n best = id;\n }\n }\n }\n \n occupied[best] = 1;\n assigned[t] = best;\n cout << (best / D) << ' ' << (best % D) << \"\\n\" << flush;\n }\n\n // ---------- removal order (greedy, smallest reachable) ----------\n vector removalOrder;\n removalOrder.reserve(M);\n vector removed(M, 0);\n vector emptySquare(TOTAL_NODES, 0);\n emptySquare[ENTRANCE_ID] = 1;\n\n for (int step = 0; step < M; ++step) {\n int chosen = -1;\n for (int num = 0; num < M; ++num) if (!removed[num]) {\n int id = assigned[num];\n int r = id / D, c = id % D;\n bool ok = false;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr < 0 || nr >= D || nc < 0 || nc >= D) continue;\n int nid = (nr == er && nc == ec) ? ENTRANCE_ID : nr * D + nc;\n if (emptySquare[nid]) { ok = true; break; }\n }\n if (ok) { chosen = num; break; }\n }\n removalOrder.push_back(chosen);\n removed[chosen] = 1;\n int id = assigned[chosen];\n emptySquare[id] = 1;\n }\n\n // ---------- output removal order ----------\n for (int num : removalOrder) {\n int id = assigned[num];\n cout << (id / D) << ' ' << (id % D) << \"\\n\" << flush;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> a(n, vector(n));\n for (int i = 0; i < n; ++i)\n for (int j = 0; j < n; ++j)\n cin >> a[i][j];\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << a[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, D, Q;\n if (!(cin >> N >> D >> Q)) return 0;\n \n int all_pairs = N * (N - 1) / 2;\n vector win(N, 0), loss(N, 0);\n vector> known(N, vector(N, 0));\n \n int q_used = 0;\n \n // Strategy 1: If we have enough queries, compare all pairs\n if (Q >= all_pairs) {\n for (int i = 0; i < N && q_used < Q; i++) {\n for (int j = i + 1; j < N && q_used < Q; j++) {\n cout << 1 << ' ' << 1 << ' ' << i << ' ' << j << '\\n' << flush;\n char c; cin >> c; q_used++;\n if (c == '<') { win[i]++; loss[j]++; known[i][j] = 1; known[j][i] = 2; }\n else if (c == '>') { win[j]++; loss[i]++; known[i][j] = 2; known[j][i] = 1; }\n }\n }\n } else {\n // Strategy 2: Limited queries - tournament + refinement\n // Phase 1: Compare items with distant indices to establish rough order\n vector> selected;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n selected.push_back({i, j});\n }\n }\n shuffle(selected.begin(), selected.end(), mt19937(42));\n \n // Use available queries\n for (int k = 0; k < (int)selected.size() && q_used < Q; k++) {\n int i = selected[k].first, j = selected[k].second;\n cout << 1 << ' ' << 1 << ' ' << i << ' ' << j << '\\n' << flush;\n char c; cin >> c; q_used++;\n if (c == '<') { win[i]++; loss[j]++; known[i][j] = 1; known[j][i] = 2; }\n else if (c == '>') { win[j]++; loss[i]++; known[i][j] = 2; known[j][i] = 1; }\n }\n }\n \n // Sort by win count, tie-break by loss\n vector sorted(N);\n iota(sorted.begin(), sorted.end(), 0);\n sort(sorted.begin(), sorted.end(), [&](int a, int b) {\n if (win[a] != win[b]) return win[a] > win[b];\n return loss[a] < loss[b];\n });\n \n // Estimate weights\n vector est_wt(N);\n mt19937 rng(12345);\n \n // Refine by comparing items with close win counts\n vector> close_pairs;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (abs(win[sorted[i]] - win[sorted[j]]) <= 3) {\n close_pairs.push_back({sorted[i], sorted[j]});\n }\n }\n }\n shuffle(close_pairs.begin(), close_pairs.end(), rng);\n \n vector adjust(N, 0.0);\n for (auto& p : close_pairs) {\n if (q_used >= Q) break;\n int a = p.first, b = p.second;\n cout << 1 << ' ' << 1 << ' ' << a << ' ' << b << '\\n' << flush;\n char c; cin >> c; q_used++;\n if (c == '<') { adjust[a] -= 0.5; adjust[b] += 0.5; }\n else if (c == '>') { adjust[a] += 0.5; adjust[b] -= 0.5; }\n }\n \n // Base weight from sorted position\n for (int i = 0; i < N; i++) {\n est_wt[sorted[i]] = (i + 1) + adjust[sorted[i]];\n }\n \n // Normalize\n double total_w = 0;\n for (int i = 0; i < N; i++) total_w += est_wt[i];\n double scale = (N * (N + 1) / 2.0) / total_w;\n for (int i = 0; i < N; i++) est_wt[i] *= scale;\n \n // Prefix sums\n vector pref(N + 1, 0);\n for (int i = 0; i < N; i++) pref[i + 1] = pref[i] + est_wt[sorted[i]];\n \n // DP for partitioning\n vector> dp(D + 1, vector(N + 1, 1e100));\n vector> split(D + 1, vector(N + 1, 0));\n dp[0][0] = 0;\n \n for (int g = 1; g <= D; g++) {\n for (int i = g; i <= N; i++) {\n for (int j = g - 1; j < i; j++) {\n double sum = pref[i] - pref[j];\n double val = dp[g - 1][j] + sum * sum;\n if (val < dp[g][i]) { dp[g][i] = val; split[g][i] = j; }\n }\n }\n }\n \n // Reconstruct groups\n vector group_of_pos(N, 0);\n int idx = N;\n for (int g = D; g >= 1; g--) {\n int j = split[g][idx];\n for (int k = j; k < idx; k++) group_of_pos[k] = g - 1;\n idx = j;\n }\n \n vector assign(N, 0);\n for (int p = 0; p < N; p++) assign[sorted[p]] = group_of_pos[p];\n for (int i = 0; i < N; i++) {\n if (assign[i] < 0) assign[i] = 0;\n if (assign[i] >= D) assign[i] = D - 1;\n }\n \n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << assign[i];\n }\n cout << '\\n';\n \n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m;\n if (!(cin >> n >> m)) return 0;\n const int per = n / m;\n vector> st(m);\n vector> pos(n + 1);\n \n for (int i = 0; i < m; ++i) {\n st[i].reserve(per);\n for (int j = 0; j < per; ++j) {\n int x; cin >> x;\n st[i].push_back(x);\n pos[x] = {i, (int)st[i].size() - 1};\n }\n }\n\n vector> ops;\n \n for (int v = 1; v <= n; ++v) {\n int s = pos[v].first;\n \n // Move all boxes above v together in ONE operation\n while (!st[s].empty() && st[s].back() != v) {\n int posV = pos[v].second;\n int numAbove = st[s].size() - posV - 1;\n \n if (numAbove == 0) break;\n \n // The box just above v (lowest in the suffix)\n int boxToMove = st[s][posV + 1];\n \n // Choose destination: prefer stack with LARGEST top > boxToMove\n int dest = -1;\n int bestTop = -1; // Changed: prefer LARGEST top\n \n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty()) {\n int top = st[i].back();\n if (top > boxToMove && top > bestTop) {\n bestTop = top;\n dest = i;\n }\n }\n }\n \n // Fallback: empty stack\n if (dest == -1) {\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (st[i].empty()) {\n dest = i;\n break;\n }\n }\n }\n \n // Fallback: any stack with largest top\n if (dest == -1) {\n int maxTop = -1;\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (!st[i].empty() && st[i].back() > maxTop) {\n maxTop = st[i].back();\n dest = i;\n }\n }\n }\n \n if (dest == -1) dest = s;\n \n // Perform move operation\n ops.emplace_back(boxToMove, dest + 1);\n \n // Update stacks\n int oldSize = st[s].size();\n st[s].resize(posV + 1);\n for (int i = posV + 1; i < oldSize; ++i) {\n int box = st[s][i];\n st[dest].push_back(box);\n pos[box] = {dest, (int)st[dest].size() - 1};\n }\n pos[v] = {s, (int)st[s].size() - 1};\n }\n \n // Carry out v\n ops.emplace_back(v, 0);\n if (!st[s].empty() && st[s].back() == v) {\n st[s].pop_back();\n }\n }\n \n for (auto &p : ops) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n \n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstruct DSU {\n vector p, r;\n DSU(int n = 0) { init(n); }\n void init(int n) {\n p.resize(n);\n r.assign(n, 0);\n iota(p.begin(), p.end(), 0);\n }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n bool unite(int a, int b) {\n a = find(a); b = find(b);\n if (a == b) return false;\n if (r[a] < r[b]) swap(a, b);\n p[b] = a;\n if (r[a] == r[b]) ++r[a];\n return true;\n }\n};\n\nstruct Edge {\n int u, v, w;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int LMAX = 100000;\n const int INF = 1e9;\n\n int N;\n if (!(cin >> N)) return 0;\n const int M = N * N;\n\n // walls\n vector hWall(N - 1), vWall(N);\n for (int i = 0; i < N - 1; ++i) cin >> hWall[i];\n for (int i = 0; i < N; ++i) cin >> vWall[i];\n\n // susceptibility\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> d[i][j];\n\n auto id = [&](int i, int j) { return i * N + j; };\n auto coord = [&](int id_) { return pair(id_/N, id_%N); };\n\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n auto opposite = [&](char c)->char {\n if (c == 'U') return 'D';\n if (c == 'D') return 'U';\n if (c == 'L') return 'R';\n return 'L';\n };\n\n auto moveChar = [&](int from, int to)->char {\n auto [fi, fj] = coord(from);\n auto [ti, tj] = coord(to);\n if (ti == fi + 1) return 'D';\n if (ti == fi - 1) return 'U';\n if (tj == fj + 1) return 'R';\n return 'L';\n };\n\n /* ---------- 1. build all usable edges ---------- */\n vector edges;\n edges.reserve(5000);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i, j);\n if (i + 1 < N && hWall[i][j] == '0') {\n int v = id(i + 1, j);\n edges.push_back({u, v, d[i][j] + d[i + 1][j]});\n }\n if (j + 1 < N && vWall[i][j] == '0') {\n int v = id(i, j + 1);\n edges.push_back({u, v, d[i][j] + d[i][j + 1]});\n }\n }\n }\n\n /* ---------- 2. maximum\u2011weight spanning tree (Kruskal) ---------- */\n sort(edges.begin(), edges.end(),\n [](const Edge& a, const Edge& b) { return a.w > b.w; });\n DSU dsu(M);\n vector> treeAdj(M);\n int added = 0;\n for (auto &e : edges) {\n if (dsu.unite(e.u, e.v)) {\n treeAdj[e.u].push_back(e.v);\n treeAdj[e.v].push_back(e.u);\n ++added;\n if (added == M - 1) break;\n }\n }\n\n /* ---------- 3. covering walk (DFS on the tree) ---------- */\n const int root = id(0, 0);\n string coverMoves;\n coverMoves.reserve(2 * (M - 1));\n\n function dfs = [&](int v, int parent) {\n for (int to : treeAdj[v]) if (to != parent) {\n coverMoves.push_back(moveChar(v, to));\n dfs(to, v);\n coverMoves.push_back(moveChar(to, v));\n }\n };\n dfs(root, -1);\n int coverLen = static_cast(coverMoves.size());\n\n /* ---------- 4. BFS from (0,0) on the original grid ---------- */\n vector dist(M, INF), parent(M, -1);\n vector parDir(M);\n queue q;\n dist[root] = 0;\n q.push(root);\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n auto [ci, cj] = coord(cur);\n // up\n if (ci > 0 && hWall[ci - 1][cj] == '0') {\n int nb = id(ci - 1, cj);\n if (dist[nb] == INF) {\n dist[nb] = dist[cur] + 1;\n parent[nb] = cur;\n parDir[nb] = 'U';\n q.push(nb);\n }\n }\n // down\n if (ci + 1 < N && hWall[ci][cj] == '0') {\n int nb = id(ci + 1, cj);\n if (dist[nb] == INF) {\n dist[nb] = dist[cur] + 1;\n parent[nb] = cur;\n parDir[nb] = 'D';\n q.push(nb);\n }\n }\n // left\n if (cj > 0 && vWall[ci][cj - 1] == '0') {\n int nb = id(ci, cj - 1);\n if (dist[nb] == INF) {\n dist[nb] = dist[cur] + 1;\n parent[nb] = cur;\n parDir[nb] = 'L';\n q.push(nb);\n }\n }\n // right\n if (cj + 1 < N && vWall[ci][cj] == '0') {\n int nb = id(ci, cj + 1);\n if (dist[nb] == INF) {\n dist[nb] = dist[cur] + 1;\n parent[nb] = cur;\n parDir[nb] = 'R';\n q.push(nb);\n }\n }\n }\n\n /* ---------- 5. best adjacent pair ---------- */\n int bestU = -1, bestV = -1, bestSum = -1;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = id(i, j);\n if (i + 1 < N && hWall[i][j] == '0') {\n int v = id(i + 1, j);\n int s = d[i][j] + d[i + 1][j];\n if (s > bestSum) {\n bestSum = s; bestU = u; bestV = v;\n }\n }\n if (j + 1 < N && vWall[i][j] == '0') {\n int v = id(i, j + 1);\n int s = d[i][j] + d[i][j + 1];\n if (s > bestSum) {\n bestSum = s; bestU = u; bestV = v;\n }\n }\n }\n }\n\n int s = (dist[bestU] <= dist[bestV]) ? bestU : bestV;\n int t = (s == bestU) ? bestV : bestU;\n int distS = dist[s];\n\n /* ---------- 6. how many bounce steps are possible ---------- */\n long long remain = (long long)LMAX - coverLen - 2LL * distS;\n if (remain < 0) remain = 0;\n int k = static_cast(remain / 2);\n\n /* ---------- 7. build the whole route ---------- */\n string answer;\n answer.reserve(LMAX);\n answer.append(coverMoves);\n\n // path from root to s (use parent pointers)\n {\n vector pathToS;\n int cur = s;\n while (cur != root) {\n char d = parDir[cur]; // direction from parent to cur\n pathToS.push_back(d);\n cur = parent[cur];\n }\n reverse(pathToS.begin(), pathToS.end());\n answer.append(pathToS.begin(), pathToS.end());\n }\n\n // bounce between s and t\n char dirST = moveChar(s, t);\n char dirTS = opposite(dirST);\n for (int i = 0; i < k; ++i) {\n answer.push_back(dirST);\n answer.push_back(dirTS);\n }\n\n // return from s to root\n {\n int cur = s;\n while (cur != root) {\n char d = parDir[cur];\n answer.push_back(opposite(d));\n cur = parent[cur];\n }\n }\n\n if ((int)answer.size() > LMAX) answer.resize(LMAX);\n\n cout << answer << '\\n';\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nconst int INF = 1e9;\n\n/* ---------- overlap of two words (both length 5) ---------- */\nint overlap(const string &a, const string &b) {\n // longest k (0..4) such that suffix of a (len k) == prefix of b (len k)\n int maxk = min(4, (int)b.size());\n for (int k = maxk; k >= 0; --k) {\n bool ok = true;\n for (int i = 0; i < k; ++i) {\n if (a[a.size() - k + i] != b[i]) { ok = false; break; }\n }\n if (ok) return k;\n }\n return 0;\n}\n\n/* --------------------- main --------------------- */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n if (!(cin >> N >> M)) return 0;\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 word(M);\n for (int i = 0; i < M; ++i) cin >> word[i];\n\n const int V = N * N; // 225\n // position list for each letter\n vector> cells(V);\n vector> pos(26);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int id = i * N + j;\n cells[id] = {i, j};\n int c = grid[i][j] - 'A';\n pos[c].push_back(id);\n }\n\n // Manhattan distance between any two squares\n vector> dist(V, vector(V));\n for (int i = 0; i < V; ++i) {\n auto [xi, yi] = cells[i];\n for (int j = 0; j < V; ++j) {\n auto [xj, yj] = cells[j];\n dist[i][j] = abs(xi - xj) + abs(yi - yj);\n }\n }\n\n int startIdx = si * N + sj;\n\n /* ---- build a short super\u2011string (try all start words) ---- */\n string bestSuper;\n int bestLen = INT_MAX;\n for (int start = 0; start < M; ++start) {\n vector used(M, false);\n string cur = word[start];\n used[start] = true;\n while (true) {\n int bestIdx = -1;\n bool bestDir = false; // false = append, true = prepend\n int bestAdd = 1000;\n int bestOv = 0;\n for (int i = 0; i < M; ++i) if (!used[i]) {\n const string &s = word[i];\n // try append\n int ov = overlap(cur, s);\n int add = 5 - ov;\n if (add < bestAdd || (add == bestAdd && ov > bestOv)) {\n bestAdd = add; bestIdx = i; bestDir = false; bestOv = ov;\n }\n // try prepend\n int ov2 = overlap(s, cur);\n int add2 = 5 - ov2;\n if (add2 < bestAdd || (add2 == bestAdd && ov2 > bestOv)) {\n bestAdd = add2; bestIdx = i; bestDir = true; bestOv = ov2;\n }\n }\n if (bestIdx == -1) break;\n const string &s = word[bestIdx];\n if (!bestDir) cur += s.substr(bestOv);\n else cur = s + cur.substr(bestOv);\n used[bestIdx] = true;\n }\n if ((int)cur.size() < bestLen) {\n bestLen = cur.size();\n bestSuper = cur;\n }\n }\n\n const string &S = bestSuper; // final super\u2011string\n const int L = (int)S.size();\n\n /* ---- DP for optimal finger walk ---- */\n vector dpPrev(V, INF), dpCurr(V, INF);\n // predecessor matrix: (step, square) \u2192 previous square (short, -1 = none)\n vector pred(L * V, -1);\n auto setPred = [&](int step, int p, short prev) {\n pred[step * V + p] = prev;\n };\n auto getPred = [&](int step, int p) -> short {\n return pred[step * V + p];\n };\n\n // first character\n int firstChar = S[0] - 'A';\n vector activePrev;\n for (int p : pos[firstChar]) {\n int d = dist[startIdx][p];\n dpPrev[p] = d + 1; // distance + typing cost\n setPred(0, p, -1);\n activePrev.push_back(p);\n }\n\n // following characters\n for (int i = 1; i < L; ++i) {\n vector activeCurr;\n int ch = S[i] - 'A';\n for (int p : pos[ch]) {\n int best = INF;\n short bestPrev = -1;\n for (int q : activePrev) {\n int cand = dpPrev[q] + dist[q][p] + 1;\n if (cand < best) {\n best = cand;\n bestPrev = (short)q;\n }\n }\n if (best != INF) {\n dpCurr[p] = best;\n setPred(i, p, bestPrev);\n activeCurr.push_back(p);\n }\n }\n // prepare for next step\n fill(dpPrev.begin(), dpPrev.end(), INF);\n dpPrev.swap(dpCurr);\n fill(dpCurr.begin(), dpCurr.end(), INF);\n activePrev = move(activeCurr);\n }\n\n // find the best final square\n int minCost = INF;\n int lastPos = -1;\n for (int p = 0; p < V; ++p) {\n if (dpPrev[p] < minCost) {\n minCost = dpPrev[p];\n lastPos = p;\n }\n }\n\n // reconstruct the whole walk\n vector path(L);\n int cur = lastPos;\n for (int i = L - 1; i >= 0; --i) {\n path[i] = cur;\n cur = getPred(i, cur);\n }\n\n // output the coordinates\n for (int idx : path) {\n int ii = idx / N;\n int jj = idx % N;\n cout << ii << ' ' << jj << '\\n';\n }\n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\n\nstatic vector solve_wls(\n const vector>& queries,\n const vector& weight,\n const vector& z,\n int V)\n{\n Eigen::MatrixXd L = Eigen::MatrixXd::Zero(V, V);\n Eigen::VectorXd r = Eigen::VectorXd::Zero(V);\n\n int Q = queries.size();\n for (int q = 0; q < Q; ++q) {\n double w = weight[q];\n const auto& cells = queries[q];\n for (int i : cells) {\n L(i, i) += w;\n r(i) += w * z[q];\n }\n for (size_t a = 0; a < cells.size(); ++a) {\n for (size_t b = a + 1; b < cells.size(); ++b) {\n L(cells[a], cells[b]) += w;\n L(cells[b], cells[a]) += w;\n }\n }\n }\n L += 1e-6 * Eigen::MatrixXd::Identity(V, V);\n Eigen::VectorXd t = L.ldlt().solve(r);\n vector res(V);\n for (int i = 0; i < V; ++i)\n res[i] = max(0.0, min(1.0, t(i)));\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n if (!(cin >> N >> M >> eps)) return 0;\n const int V = N * N;\n\n for (int k = 0; k < M; ++k) {\n int d; cin >> d;\n for (int i = 0; i < d; ++i) {\n int a, b; cin >> a >> b;\n }\n }\n\n // D = 35 drills, Q = V - D - 2\n const int D = 35;\n const int Q = V - D - 2;\n const double epsFactor = 1.0 - 2.0 * eps;\n\n vector> queries(Q);\n vector weight(Q);\n vector z_val(Q);\n vector> cell_to_queries(V);\n\n mt19937 rng(123456789);\n\n for (int qq = 0; qq < Q; ++qq) {\n vector idxs;\n idxs.reserve(V);\n for (int i = 0; i < V; ++i) if (rng() & 1) idxs.push_back(i);\n if (idxs.size() < 2) {\n if (idxs.empty()) { idxs.push_back(0); idxs.push_back(1); }\n else idxs.push_back((idxs[0] + 1) % V);\n }\n\n queries[qq] = idxs;\n for (int id : idxs) cell_to_queries[id].push_back(qq);\n\n cout << \"q \" << idxs.size();\n for (int id : idxs) cout << ' ' << id / N << ' ' << id % N;\n cout << \"\\n\";\n cout.flush();\n\n int y; cin >> y;\n double k = (double)idxs.size();\n double z = ((double)y - eps * k) / epsFactor;\n z_val[qq] = z;\n double var = k * eps * (1.0 - eps) / (epsFactor * epsFactor);\n weight[qq] = 1.0 / var;\n }\n\n // Solve full system\n vector t_full = solve_wls(queries, weight, z_val, V);\n\n // Track drilled cells\n vector drilled(V, 0);\n vector oil_val(V, 0);\n\n // Drill top D high-probability cells\n vector> cells_by_prob;\n for (int i = 0; i < V; ++i)\n cells_by_prob.emplace_back(t_full[i], i);\n sort(cells_by_prob.begin(), cells_by_prob.end(), greater<>());\n\n for (int i = 0; i < D; ++i) {\n int cell = cells_by_prob[i].second;\n cout << \"q 1 \" << cell / N << ' ' << cell % N << \"\\n\";\n cout.flush();\n int val; cin >> val;\n drilled[cell] = 1;\n oil_val[cell] = val;\n }\n\n // Build reduced system\n vector unknown_ids;\n vector orig_to_new(V, -1);\n for (int i = 0; i < V; ++i) {\n if (!drilled[i]) {\n orig_to_new[i] = (int)unknown_ids.size();\n unknown_ids.push_back(i);\n }\n }\n int V2 = (int)unknown_ids.size();\n\n vector> unknown_queries(Q);\n vector adj_z(Q, 0.0);\n for (int q = 0; q < Q; ++q) {\n double known_sum = 0.0;\n for (int id : queries[q]) {\n if (drilled[id]) known_sum += oil_val[id];\n }\n adj_z[q] = z_val[q] - known_sum;\n for (int id : queries[q]) {\n if (!drilled[id]) unknown_queries[q].push_back(orig_to_new[id]);\n }\n }\n\n vector> unknown_cell_to_queries(V2);\n for (int q = 0; q < Q; ++q) {\n for (int new_id : unknown_queries[q])\n unknown_cell_to_queries[new_id].push_back(q);\n }\n\n // Solve reduced system\n vector t_unknown = solve_wls(unknown_queries, weight, adj_z, V2);\n\n // Order unknown cells by decreasing t\n vector order_unknown(V2);\n iota(order_unknown.begin(), order_unknown.end(), 0);\n sort(order_unknown.begin(), order_unknown.end(),\n [&](int a, int b){ return t_unknown[a] > t_unknown[b]; });\n\n // Estimate K from sum of t values\n double sum_t = 0.0;\n for (double v : t_unknown) sum_t += v;\n int K_sum = max(0, min(V2, (int)round(sum_t)));\n\n // Try different correction factors and pick best by residual\n double best_corr = 0.8;\n double best_res = 1e100;\n\n for (double corr = 0.5; corr <= 1.0; corr += 0.05) {\n int K_corr = max(0, min(V2, (int)round(sum_t * corr)));\n if (K_corr == 0) K_corr = 1;\n\n // Compute residual\n vector pred_sum(Q, 0.0);\n double err = 0.0;\n for (int q = 0; q < Q; ++q) {\n if (!unknown_queries[q].empty()) {\n pred_sum[q] = -adj_z[q];\n }\n }\n for (int i = 0; i < K_corr; ++i) {\n int cell = order_unknown[i];\n for (int q : unknown_cell_to_queries[cell]) {\n if (q < Q && !unknown_queries[q].empty()) {\n double old = pred_sum[q];\n pred_sum[q] += 1.0;\n double old_diff = old - adj_z[q];\n double new_diff = pred_sum[q] - adj_z[q];\n err += weight[q] * (new_diff * new_diff - old_diff * old_diff);\n }\n }\n }\n\n if (err < best_res) {\n best_res = err;\n best_corr = corr;\n }\n }\n\n int final_K = max(0, min(V2, (int)round(sum_t * best_corr)));\n if (final_K == 0) final_K = 1;\n\n // Ensure we include high-prob cells\n int high_prob_count = 0;\n for (int i = 0; i < V2 && t_unknown[order_unknown[i]] > 0.15; ++i) {\n high_prob_count++;\n }\n final_K = max(final_K, high_prob_count);\n\n // First guess\n vector answer;\n for (int i = 0; i < V; ++i)\n if (drilled[i] && oil_val[i] > 0) answer.push_back(i);\n for (int i = 0; i < final_K; ++i)\n answer.push_back(unknown_ids[order_unknown[i]]);\n\n cout << \"a \" << answer.size();\n for (int id : answer) cout << ' ' << id / N << ' ' << id % N;\n cout << \"\\n\";\n cout.flush();\n\n int ok; cin >> ok;\n if (ok == 1) return 0;\n\n // Fallback: drill all remaining and answer\n for (int i = 0; i < V; ++i) {\n if (!drilled[i]) {\n cout << \"q 1 \" << i / N << ' ' << i % N << \"\\n\";\n cout.flush();\n int val; cin >> val;\n drilled[i] = 1;\n oil_val[i] = val;\n }\n }\n\n answer.clear();\n for (int i = 0; i < V; ++i)\n if (oil_val[i] > 0) answer.push_back(i);\n\n cout << \"a \" << answer.size();\n for (int id : answer) cout << ' ' << id / N << ' ' << id % N;\n cout << \"\\n\";\n cout.flush();\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nconst int W = 1000;\n\nstruct Rect {\n int x, y, w, h;\n bool valid() const {\n return x >= 0 && y >= 0 && w > 0 && h > 0 &&\n x <= W && y <= W && x + w <= W && y + h <= W;\n }\n};\n\nvoid minimalRect(int a, int& w, int& h) {\n int bestW = W, bestH = W;\n int bestArea = W * W, bestMax = W;\n for (int hi = 1; hi <= W; ++hi) {\n int wi = (a + hi - 1) / hi;\n if (wi > W) continue;\n int area = wi * hi;\n int mx = max(wi, hi);\n if (area < bestArea || (area == bestArea && mx < bestMax)) {\n bestArea = area;\n bestW = wi;\n bestH = hi;\n bestMax = mx;\n }\n }\n w = bestW;\n h = bestH;\n}\n\nvector pack_day(const vector>& items) {\n int N = (int)items.size();\n vector placed(N);\n vector freeRects = {{0, 0, W, W}};\n\n for (auto [id, demand] : items) {\n int w0, h0;\n minimalRect(demand, w0, h0);\n\n int bestIdx = -1;\n int bestW = -1, bestH = -1;\n int bestScore = INT_MAX;\n\n // First try exact fit with minimal waste\n for (int rot = 0; rot < 2; ++rot) {\n int cw = rot ? h0 : w0;\n int ch = rot ? w0 : h0;\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n if (f.w >= cw && f.h >= ch) {\n int score = (f.w - cw) + (f.h - ch);\n if (score < bestScore) {\n bestScore = score;\n bestIdx = i;\n bestW = cw;\n bestH = ch;\n }\n }\n }\n if (bestIdx != -1) break;\n }\n\n // If no exact fit, find a free rectangle that can fit the demand\n if (bestIdx == -1) {\n for (int i = 0; i < (int)freeRects.size(); ++i) {\n const Rect& f = freeRects[i];\n if (f.w * f.h >= demand) {\n bestIdx = i;\n break;\n }\n }\n }\n\n if (bestIdx == -1 && !freeRects.empty()) {\n bestIdx = 0;\n }\n\n if (bestIdx == -1) {\n continue;\n }\n\n Rect f = freeRects[bestIdx];\n\n // If we don't have exact dimensions yet, find the best fit\n if (bestW == -1) {\n int bestFitW = -1, bestFitH = -1, bestExcess = INT_MAX;\n for (int testW = 1; testW <= f.w; ++testW) {\n int testH = (demand + testW - 1) / testW;\n if (testH > f.h) continue;\n int excess = testW * testH - demand;\n if (excess < bestExcess) {\n bestExcess = excess;\n bestFitW = testW;\n bestFitH = testH;\n }\n }\n if (bestFitW != -1) {\n bestW = bestFitW;\n bestH = bestFitH;\n } else {\n bestW = f.w;\n bestH = f.h;\n }\n }\n\n // Ensure the rectangle fits within bounds\n if (f.x + bestW > W) bestW = W - f.x;\n if (f.y + bestH > W) bestH = W - f.y;\n\n Rect r = {f.x, f.y, bestW, bestH};\n if (!r.valid()) {\n // Fallback: shouldn't happen\n continue;\n }\n\n placed[id] = r;\n\n freeRects.erase(freeRects.begin() + bestIdx);\n\n if (f.w > bestW) {\n freeRects.push_back({f.x + bestW, f.y, f.w - bestW, f.h});\n }\n if (f.h > bestH) {\n freeRects.push_back({f.x, f.y + bestH, bestW, f.h - bestH});\n }\n }\n\n return placed;\n}\n\nvoid buildEdges(const vector& rects,\n vector& H, vector& V) {\n fill(H.begin(), H.end(), 0);\n fill(V.begin(), V.end(), 0);\n for (const Rect& r : rects) {\n int x0 = r.x, y0 = r.y;\n int x1 = x0 + r.w, y1 = y0 + r.h;\n\n if (y0 > 0) {\n for (int x = x0; x < x1; ++x) H[y0 * W + x] = 1;\n }\n if (y1 < W) {\n for (int x = x0; x < x1; ++x) H[y1 * W + x] = 1;\n }\n if (x0 > 0) {\n for (int y = y0; y < y1; ++y) V[x0 * W + y] = 1;\n }\n if (x1 < W) {\n for (int y = y0; y < y1; ++y) V[x1 * W + y] = 1;\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int dummyW, D, N;\n cin >> dummyW >> D >> N;\n\n vector> a(D, vector(N));\n for (int d = 0; d < D; ++d)\n for (int k = 0; k < N; ++k)\n cin >> a[d][k];\n\n int edgeSize = (W + 1) * W;\n vector Hprev(edgeSize, 0), Vprev(edgeSize, 0);\n vector Hcur(edgeSize, 0), Vcur(edgeSize, 0);\n\n vector> answer(D, vector(N));\n\n for (int day = 0; day < D; ++day) {\n vector> items;\n items.reserve(N);\n for (int k = 0; k < N; ++k) {\n items.emplace_back(k, a[day][k]);\n }\n sort(items.begin(), items.end(),\n [](const auto& A, const auto& B) {\n return get<1>(A) > get<1>(B);\n });\n\n vector placed = pack_day(items);\n answer[day] = placed;\n\n buildEdges(placed, Hcur, Vcur);\n\n Hprev = Hcur;\n Vprev = Vcur;\n }\n\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n const Rect& r = answer[d][k];\n // Convert (x, y, w, h) to (i0, j0, i1, j1)\n // Internal: x=column (j), y=row (i)\n // Output: i0=row of top-left, j0=column of top-left, i1=row of bottom-right, j1=column of bottom-right\n int i0 = r.y;\n int j0 = r.x;\n int i1 = r.y + r.h;\n int j1 = r.x + r.w;\n\n // Validate output coordinates\n if (i0 < 0 || j0 < 0 || i1 <= i0 || j1 <= j0 || i1 > W || j1 > W) {\n // This should not happen with valid packing\n i0 = max(0, min(W-1, r.y));\n j0 = max(0, min(W-1, r.x));\n i1 = max(i0 + 1, min(W, r.y + r.h));\n j1 = max(j0 + 1, min(W, r.x + r.w));\n }\n\n cout << i0 << ' ' << j0 << ' ' << i1 << ' ' << j1 << \"\\n\";\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nconst long long MOD = 998244353LL;\n\nstruct Placement {\n int stamp;\n int p, q;\n int cell[9];\n int inc[9];\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n const int CELLS = N * N;\n vector a(CELLS);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n long long x; cin >> x;\n a[i * N + j] = int(x % MOD);\n }\n vector>> stamp(M, vector>(3, vector(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 long long x; cin >> x;\n stamp[m][i][j] = int(x % MOD);\n }\n\n vector PL;\n for (int m = 0; m < M; ++m) {\n for (int p = 0; p <= N - 3; ++p) {\n for (int q = 0; q <= N - 3; ++q) {\n Placement pl;\n pl.stamp = m;\n pl.p = p; pl.q = q;\n int pos = 0;\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) {\n pl.cell[pos] = (p + i) * N + (q + j);\n pl.inc[pos] = stamp[m][i][j];\n ++pos;\n }\n PL.push_back(pl);\n }\n }\n }\n const int PLsize = (int)PL.size();\n\n auto deltaAdd = [&](const Placement& pl, const vector& add) -> long long {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] + inc) % MOD;\n delta += nw - old;\n }\n return delta;\n };\n\n auto deltaRemove = [&](const Placement& pl, const vector& add) -> long long {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = pl.cell[t];\n int inc = pl.inc[t];\n long long old = (a[c] + add[c]) % MOD;\n long long nw = (a[c] + add[c] - inc) % MOD;\n if (nw < 0) nw += MOD;\n delta += nw - old;\n }\n return delta;\n };\n\n auto deltaReplace = [&](const Placement& oldPl, const Placement& newPl, const vector& add) -> long long {\n long long deltaArr[81] = {0};\n for (int t = 0; t < 9; ++t) deltaArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) deltaArr[newPl.cell[t]] += newPl.inc[t];\n \n long long delta = 0;\n for (int c = 0; c < 81; ++c) if (deltaArr[c] != 0) {\n long long oldR = (a[c] + add[c]) % MOD;\n long long newR = (a[c] + add[c] + deltaArr[c]) % MOD;\n delta += newR - oldR;\n }\n return delta;\n };\n\n auto applyAdd = [&](int idx, vector& add, vector& sol) {\n const Placement& pl = PL[idx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n sol.push_back(idx);\n };\n\n auto applyRemove = [&](int pos, vector& add, vector& sol) {\n const Placement& pl = PL[sol[pos]];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] -= pl.inc[t];\n sol[pos] = sol.back();\n sol.pop_back();\n };\n\n auto applyReplace = [&](int pos, int newIdx, vector& add, vector& sol) {\n const Placement& oldPl = PL[sol[pos]];\n const Placement& newPl = PL[newIdx];\n long long deltaArr[81] = {0};\n for (int t = 0; t < 9; ++t) deltaArr[oldPl.cell[t]] -= oldPl.inc[t];\n for (int t = 0; t < 9; ++t) deltaArr[newPl.cell[t]] += newPl.inc[t];\n for (int c = 0; c < 81; ++c) if (deltaArr[c] != 0) add[c] += deltaArr[c];\n sol[pos] = newIdx;\n };\n\n auto computeScore = [&](const vector& add) -> long long {\n long long sc = 0;\n for (int i = 0; i < CELLS; ++i) sc += (a[i] + add[i]) % MOD;\n return sc;\n };\n\n long long bestScore = 0;\n vector bestSolution;\n\n auto run = [&](vector initSol, uint64_t seed, int maxIter) {\n vector add(CELLS, 0);\n vector sol = initSol;\n for (int idx : sol) {\n const Placement& pl = PL[idx];\n for (int t = 0; t < 9; ++t) add[pl.cell[t]] += pl.inc[t];\n }\n long long curScore = computeScore(add);\n\n // Iterative greedy improvement\n for (int iter = 0; iter < 5; ++iter) {\n bool changed = false;\n \n if ((int)sol.size() < K) {\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long delta = deltaAdd(PL[idx], add);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0) {\n applyAdd(bestIdx, add, sol);\n curScore += bestDelta;\n changed = true;\n }\n }\n\n if (!sol.empty()) {\n long long bestDelta = 0;\n int bestPos = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n long long delta = deltaRemove(PL[sol[pos]], add);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestPos = pos;\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += deltaRemove(PL[sol[bestPos]], add);\n applyRemove(bestPos, add, sol);\n changed = true;\n }\n }\n\n if (!sol.empty()) {\n long long bestDelta = 0;\n int bestPos = -1, bestNewIdx = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n for (int newIdx = 0; newIdx < PLsize; ++newIdx) {\n if (sol[pos] == newIdx) continue;\n long long delta = deltaReplace(PL[sol[pos]], PL[newIdx], add);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestPos = pos;\n bestNewIdx = newIdx;\n }\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += deltaReplace(PL[sol[bestPos]], PL[bestNewIdx], add);\n applyReplace(bestPos, bestNewIdx, add, sol);\n changed = true;\n }\n }\n\n if (!changed) break;\n }\n\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n\n // Simulated Annealing\n mt19937_64 rng(seed);\n uniform_real_distribution realProb(0.0, 1.0);\n uniform_int_distribution intProb(0, PLsize - 1);\n\n const double Tstart = 6e5;\n const double Tend = 0.2;\n\n for (int it = 0; it < maxIter; ++it) {\n double progress = (double)it / maxIter;\n double T = Tstart * pow(Tend / Tstart, progress);\n \n double r = realProb(rng);\n long long delta = 0;\n\n if ((int)sol.size() < K && r < 0.3) {\n int bestIdx = -1;\n long long bestDelta = LLONG_MIN;\n for (int tries = 0; tries < 65; ++tries) {\n int idx = intProb(rng);\n long long d = deltaAdd(PL[idx], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1) {\n delta = bestDelta;\n if (delta > 0 || exp((double)delta / T) > realProb(rng)) {\n applyAdd(bestIdx, add, sol);\n curScore += delta;\n }\n }\n } else if (!sol.empty() && r < 0.55) {\n int pos = uniform_int_distribution(0, (int)sol.size() - 1)(rng);\n delta = deltaRemove(PL[sol[pos]], add);\n if (delta > 0 || exp((double)delta / T) > realProb(rng)) {\n curScore += delta;\n applyRemove(pos, add, sol);\n }\n } else if (!sol.empty()) {\n int pos = uniform_int_distribution(0, (int)sol.size() - 1)(rng);\n int oldIdx = sol[pos];\n \n int bestIdx = -1;\n long long bestDelta = LLONG_MIN;\n for (int tries = 0; tries < 55; ++tries) {\n int newIdx = intProb(rng);\n if (newIdx == oldIdx) continue;\n long long d = deltaReplace(PL[oldIdx], PL[newIdx], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestIdx = newIdx;\n }\n }\n if (bestIdx != -1) {\n delta = bestDelta;\n if (delta > 0 || exp((double)delta / T) > realProb(rng)) {\n applyReplace(pos, bestIdx, add, sol);\n curScore += delta;\n }\n }\n }\n\n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n\n if (it > 0 && it % 5000 == 0) {\n for (int ls = 0; ls < 4; ++ls) {\n bool anyChange = false;\n \n if ((int)sol.size() < K) {\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0) {\n applyAdd(bestIdx, add, sol);\n curScore += bestDelta;\n anyChange = true;\n }\n }\n \n if (!sol.empty()) {\n long long bestDelta = 0;\n int bestPos = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n long long d = deltaRemove(PL[sol[pos]], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestPos = pos;\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += deltaRemove(PL[sol[bestPos]], add);\n applyRemove(bestPos, add, sol);\n anyChange = true;\n }\n }\n \n if (!anyChange) break;\n }\n \n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n }\n }\n\n for (int iter = 0; iter < 3; ++iter) {\n bool changed = false;\n \n if ((int)sol.size() < K) {\n long long bestDelta = 0;\n int bestIdx = -1;\n for (int idx = 0; idx < PLsize; ++idx) {\n if (find(sol.begin(), sol.end(), idx) != sol.end()) continue;\n long long d = deltaAdd(PL[idx], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestIdx = idx;\n }\n }\n if (bestIdx != -1 && bestDelta > 0) {\n applyAdd(bestIdx, add, sol);\n curScore += bestDelta;\n changed = true;\n }\n }\n \n if (!sol.empty()) {\n long long bestDelta = 0;\n int bestPos = -1;\n for (int pos = 0; pos < (int)sol.size(); ++pos) {\n long long d = deltaRemove(PL[sol[pos]], add);\n if (d > bestDelta) {\n bestDelta = d;\n bestPos = pos;\n }\n }\n if (bestPos != -1 && bestDelta > 0) {\n curScore += deltaRemove(PL[sol[bestPos]], add);\n applyRemove(bestPos, add, sol);\n changed = true;\n }\n }\n \n if (!changed) break;\n }\n \n if (curScore > bestScore) {\n bestScore = curScore;\n bestSolution = sol;\n }\n };\n\n // Greedy initial solution\n vector initSol;\n vector addInit(CELLS, 0);\n for (int pass = 0; pass < 4; ++pass) {\n for (int idx = 0; idx < PLsize && (int)initSol.size() < K; ++idx) {\n long long delta = 0;\n for (int t = 0; t < 9; ++t) {\n int c = PL[idx].cell[t];\n int inc = PL[idx].inc[t];\n long long old = (a[c] + addInit[c]) % MOD;\n long long nw = (a[c] + addInit[c] + inc) % MOD;\n delta += nw - old;\n }\n if (delta > 0) {\n for (int t = 0; t < 9; ++t) addInit[PL[idx].cell[t]] += PL[idx].inc[t];\n initSol.push_back(idx);\n }\n }\n }\n\n // Main run with more iterations\n run(initSol, chrono::steady_clock::now().time_since_epoch().count(), 100000);\n\n // Four restarts with fewer iterations\n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\n for (int r = 0; r < 4; ++r) {\n vector randomSol;\n vector addRand(CELLS, 0);\n for (int i = 0; i < K; ++i) {\n int idx = uniform_int_distribution(0, PLsize - 1)(rng);\n randomSol.push_back(idx);\n for (int t = 0; t < 9; ++t) addRand[PL[idx].cell[t]] += PL[idx].inc[t];\n }\n run(randomSol, chrono::steady_clock::now().time_since_epoch().count() + r * 789012, 50000);\n }\n\n cout << (int)bestSolution.size() << '\\n';\n for (int idx : bestSolution) {\n const Placement& pl = PL[idx];\n cout << pl.stamp << ' ' << pl.p << ' ' << pl.q << '\\n';\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Pos { int r, c; };\n\n// direction towards target (one step)\nchar moveTowards(const Pos& cur, const Pos& tar) {\n if (cur.r < tar.r) return 'D';\n if (cur.r > tar.r) return 'U';\n if (cur.c < tar.c) return 'R';\n if (cur.c > tar.c) return 'L';\n return '.';\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int N = 5;\n const int TOT = N * N; // 25 containers\n vector> A(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> A[i][j];\n\n // source row of each container, destination row of each container\n int srcRow[TOT], dstRow[TOT];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int b = A[i][j];\n srcRow[b] = i;\n dstRow[b] = b / N;\n }\n\n // state of the large crane\n Pos crane{0, 0};\n int carrying = -1; // container number or -1\n\n // per\u2011row state of receiving gates\n int nextIdx[N] = {0}; // next container to appear\n bool gateHas[N] = {false};\n int gateCont[N]; // valid only if gateHas==true\n\n // actions strings, one per crane (0 = large, 1..4 = small)\n vector act(N);\n int delivered = 0; // number of dispatched containers\n const int MAX_TURNS = 10000;\n\n for (int turn = 1; turn <= MAX_TURNS && delivered < TOT; ++turn) {\n /* ---------- step 1 : arrivals ---------- */\n for (int i = 0; i < N; ++i) {\n if (!gateHas[i] && nextIdx[i] < N &&\n !(crane.r == i && crane.c == 0)) {\n int b = A[i][nextIdx[i]];\n gateHas[i] = true;\n gateCont[i] = b;\n ++nextIdx[i];\n }\n }\n\n /* ---------- step 2 : crane actions ---------- */\n char actLarge = '.';\n\n if (carrying != -1) { // carrying a container\n int tr = dstRow[carrying];\n int tc = N - 1;\n if (crane.r == tr && crane.c == tc) {\n actLarge = 'Q'; // release & dispatch\n ++delivered;\n carrying = -1;\n } else {\n actLarge = moveTowards(crane, {tr, tc});\n // update position\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else { // empty crane\n // choose the waiting container with minimal (travel) cost\n int bestRow = -1;\n int bestCost = INT_MAX;\n for (int i = 0; i < N; ++i) if (gateHas[i]) {\n int b = gateCont[i];\n // distance crane -> source\n int dist1 = abs(crane.r - i) + crane.c; // column diff = crane.c - 0\n // distance source -> dispatch\n int dist2 = abs(i - dstRow[b]) + (N - 1); // column diff = N-1\n int cost = dist1 + dist2;\n if (cost < bestCost) {\n bestCost = cost;\n bestRow = i;\n }\n }\n if (bestRow != -1) {\n if (crane.r == bestRow && crane.c == 0) {\n // already on the gate, pick it up\n actLarge = 'P';\n carrying = gateCont[bestRow];\n gateHas[bestRow] = false;\n } else {\n // move towards the gate\n actLarge = moveTowards(crane, {bestRow, 0});\n if (actLarge == 'U') --crane.r;\n else if (actLarge == 'D') ++crane.r;\n else if (actLarge == 'L') --crane.c;\n else if (actLarge == 'R') ++crane.c;\n }\n } else {\n // nothing to do, wait\n actLarge = '.';\n }\n }\n\n act[0].push_back(actLarge); // large crane\n\n // small cranes: bomb on turn 1, otherwise nothing\n for (int i = 1; i < N; ++i) {\n if (turn == 1) act[i].push_back('B');\n else act[i].push_back('.');\n }\n }\n\n // pad all strings to the same length (they already are)\n size_t maxLen = 0;\n for (int i = 0; i < N; ++i) maxLen = max(maxLen, act[i].size());\n for (int i = 0; i < N; ++i) {\n if (act[i].size() < maxLen) act[i].append(maxLen - act[i].size(), '.');\n }\n\n for (int i = 0; i < N; ++i) cout << act[i] << '\\n';\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int x, y;\n int rem;\n bool pos;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector> h(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> h[i][j];\n\n vector pos, neg;\n long long totalSupply = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (h[i][j] > 0) {\n pos.push_back({i, j, h[i][j], true});\n totalSupply += h[i][j];\n } else if (h[i][j] < 0) {\n neg.push_back({i, j, -h[i][j], false});\n }\n }\n\n int P = pos.size(), Q = neg.size();\n\n // Precompute distances\n vector> distPosNeg(P, vector(Q));\n vector> distNegPos(Q, vector(P));\n\n for (int i = 0; i < P; ++i) {\n for (int j = 0; j < Q; ++j) {\n distPosNeg[i][j] = abs(pos[i].x - neg[j].x) + abs(pos[i].y - neg[j].y);\n distNegPos[j][i] = distPosNeg[i][j];\n }\n }\n\n vector nearestNegDist(P);\n for (int i = 0; i < P; ++i) {\n nearestNegDist[i] = INT_MAX;\n for (int j = 0; j < Q; ++j)\n nearestNegDist[i] = min(nearestNegDist[i], distPosNeg[i][j]);\n }\n\n vector nearestPosDist(Q);\n for (int i = 0; i < Q; ++i) {\n nearestPosDist[i] = INT_MAX;\n for (int j = 0; j < P; ++j)\n nearestPosDist[i] = min(nearestPosDist[i], distNegPos[i][j]);\n }\n\n int cx = 0, cy = 0;\n long long load = 0;\n // Even smaller Lmax\n long long Lmax = max(1LL, totalSupply / 30);\n\n vector ops;\n\n auto move_to = [&](int tx, int ty) {\n while (cx < tx) { ops.emplace_back(\"D\"); ++cx; }\n while (cx > tx) { ops.emplace_back(\"U\"); --cx; }\n while (cy < ty) { ops.emplace_back(\"R\"); ++cy; }\n while (cy > ty) { ops.emplace_back(\"L\"); --cy; }\n };\n\n vector remPos(pos.size()), remNeg(neg.size());\n iota(remPos.begin(), remPos.end(), 0);\n iota(remNeg.begin(), remNeg.end(), 0);\n\n const int TIE_STRENGTH = 100;\n\n while (!remPos.empty() || !remNeg.empty()) {\n if (!remPos.empty() && load < Lmax) {\n int bestIdx = -1;\n int bestDist = INT_MAX;\n int bestScore = INT_MIN;\n for (int pi : remPos) {\n int d = abs(cx - pos[pi].x) + abs(cy - pos[pi].y);\n int score = TIE_STRENGTH * pos[pi].rem - nearestNegDist[pi];\n if (d < bestDist || (d == bestDist && score > bestScore)) {\n bestDist = d;\n bestScore = score;\n bestIdx = pi;\n }\n }\n Cell &c = pos[bestIdx];\n move_to(c.x, c.y);\n int take = (int)min(Lmax - load, c.rem);\n load += take;\n c.rem -= take;\n ops.emplace_back(\"+\" + to_string(take));\n if (c.rem == 0) {\n auto it = find(remPos.begin(), remPos.end(), bestIdx);\n *it = remPos.back();\n remPos.pop_back();\n }\n } else if (!remNeg.empty() && load > 0) {\n int bestIdx = -1;\n int bestDist = INT_MAX;\n int bestScore = INT_MIN;\n for (int ni : remNeg) {\n int d = abs(cx - neg[ni].x) + abs(cy - neg[ni].y);\n int score = TIE_STRENGTH * neg[ni].rem - nearestPosDist[ni];\n if (d < bestDist || (d == bestDist && score > bestScore)) {\n bestDist = d;\n bestScore = score;\n bestIdx = ni;\n }\n }\n Cell &c = neg[bestIdx];\n move_to(c.x, c.y);\n int give = (int)min(load, c.rem);\n load -= give;\n c.rem -= give;\n ops.emplace_back(\"-\" + to_string(give));\n if (c.rem == 0) {\n auto it = find(remNeg.begin(), remNeg.end(), bestIdx);\n *it = remNeg.back();\n remNeg.pop_back();\n }\n } else if (!remPos.empty()) {\n int bestIdx = -1;\n int bestDist = INT_MAX;\n for (int pi : remPos) {\n int d = abs(cx - pos[pi].x) + abs(cy - pos[pi].y);\n if (d < bestDist) {\n bestDist = d;\n bestIdx = pi;\n }\n }\n Cell &c = pos[bestIdx];\n move_to(c.x, c.y);\n int take = (int)min(Lmax - load, c.rem);\n load += take;\n c.rem -= take;\n ops.emplace_back(\"+\" + to_string(take));\n if (c.rem == 0) {\n auto it = find(remPos.begin(), remPos.end(), bestIdx);\n *it = remPos.back();\n remPos.pop_back();\n }\n } else {\n int bestIdx = -1;\n int bestDist = INT_MAX;\n for (int ni : remNeg) {\n int d = abs(cx - neg[ni].x) + abs(cy - neg[ni].y);\n if (d < bestDist) {\n bestDist = d;\n bestIdx = ni;\n }\n }\n Cell &c = neg[bestIdx];\n move_to(c.x, c.y);\n int give = (int)min(load, c.rem);\n load -= give;\n c.rem -= give;\n ops.emplace_back(\"-\" + to_string(give));\n if (c.rem == 0) {\n auto it = find(remNeg.begin(), remNeg.end(), bestIdx);\n *it = remNeg.back();\n remNeg.pop_back();\n }\n }\n }\n\n for (const string &s : ops) cout << s << '\\n';\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nstruct Solver {\n int N, M, T;\n int S;\n int CELLS;\n vector> seed;\n vector> w;\n vector> neigh;\n mutable mt19937 rng;\n\n void compute_w() {\n w.assign(S, vector(S, 0));\n for (int i = 0; i < S; ++i)\n for (int j = i; j < S; ++j) {\n int val = 0;\n for (int l = 0; l < M; ++l)\n val += max(seed[i][l], seed[j][l]);\n w[i][j] = w[j][i] = val;\n }\n }\n\n int sumSeed(int id) const {\n int s = 0;\n for (int v : seed[id]) s += v;\n return s;\n }\n\n vector greedyCoverSelection() const {\n const int need = CELLS;\n vector curMax(M, -1);\n vector used(S, 0);\n vector chosen;\n chosen.reserve(need);\n for (int taken = 0; taken < need; ++taken) {\n int bestId = -1;\n int bestGain = -1;\n int bestSum = -1;\n for (int id = 0; id < S; ++id) if (!used[id]) {\n int gain = 0;\n for (int l = 0; l < M; ++l)\n if (seed[id][l] > curMax[l]) gain += seed[id][l] - curMax[l];\n if (gain > bestGain ||\n (gain == bestGain && sumSeed(id) > bestSum)) {\n bestGain = gain;\n bestId = id;\n bestSum = sumSeed(id);\n }\n }\n used[bestId] = 1;\n chosen.push_back(bestId);\n for (int l = 0; l < M; ++l)\n curMax[l] = max(curMax[l], seed[bestId][l]);\n }\n return chosen;\n }\n\n vector topValueSelection() const {\n vector idx(S);\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(),\n [&](int a, int b){ return sumSeed(a) > sumSeed(b); });\n return vector(idx.begin(), idx.begin() + CELLS);\n }\n\n vector linearAssignment(const vector& seeds) const {\n vector sortedSeeds = seeds;\n sort(sortedSeeds.begin(), sortedSeeds.end(),\n [&](int a, int b){ return sumSeed(a) > sumSeed(b); });\n\n vector cells(CELLS);\n iota(cells.begin(), cells.end(), 0);\n sort(cells.begin(), cells.end(),\n [&](int a, int b){\n return neigh[a].size() > neigh[b].size();\n });\n\n vector assign(CELLS, -1);\n for (int i = 0; i < CELLS; ++i) assign[cells[i]] = sortedSeeds[i];\n return assign;\n }\n\n vector randomAssignment(const vector& seeds) const {\n vector shuffled = seeds;\n shuffle(shuffled.begin(), shuffled.end(), rng);\n\n vector cells(CELLS);\n iota(cells.begin(), cells.end(), 0);\n sort(cells.begin(), cells.end(),\n [&](int a, int b){\n return neigh[a].size() > neigh[b].size();\n });\n\n vector assign(CELLS, -1);\n for (int i = 0; i < CELLS; ++i) assign[cells[i]] = shuffled[i];\n return assign;\n }\n\n vector randomAssignmentFully(const vector& seeds) const {\n vector shuffled = seeds;\n shuffle(shuffled.begin(), shuffled.end(), rng);\n vector assign(CELLS, -1);\n for (int i = 0; i < CELLS; ++i) assign[i] = shuffled[i];\n return assign;\n }\n\n int totalW(const vector& assign) const {\n long long tot = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int idx = r * N + c;\n if (c + 1 < N) tot += w[assign[idx]][assign[idx + 1]];\n if (r + 1 < N) tot += w[assign[idx]][assign[idx + N]];\n }\n }\n return static_cast(tot);\n }\n\n void improve(vector& assign) const {\n vector used(S, 0);\n for (int id : assign) used[id] = 1;\n\n while (true) {\n vector> sumW(CELLS, vector(S, 0));\n for (int p = 0; p < CELLS; ++p) {\n for (int nb : neigh[p]) {\n int seed_nb = assign[nb];\n for (int s = 0; s < S; ++s) {\n sumW[p][s] += w[s][seed_nb];\n }\n }\n }\n\n int bestDelta = 0;\n int bestType = 0;\n int bestP = -1, bestQ = -1, bestS = -1;\n\n for (int p = 0; p < CELLS; ++p) {\n int cur = assign[p];\n for (int s = 0; s < S; ++s) if (!used[s]) {\n int delta = sumW[p][s] - sumW[p][cur];\n if (delta > bestDelta) {\n bestDelta = delta;\n bestType = 1;\n bestP = p;\n bestS = s;\n }\n }\n }\n\n for (int p = 0; p < CELLS; ++p) {\n for (int q = p + 1; q < CELLS; ++q) {\n if (assign[p] == assign[q]) continue;\n int delta = (sumW[p][assign[q]] - sumW[p][assign[p]]) +\n (sumW[q][assign[p]] - sumW[q][assign[q]]);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestType = 2;\n bestP = p;\n bestQ = q;\n }\n }\n }\n\n if (bestDelta <= 0) break;\n\n if (bestType == 1) {\n int old = assign[bestP];\n assign[bestP] = bestS;\n used[old] = 0;\n used[bestS] = 1;\n } else {\n swap(assign[bestP], assign[bestQ]);\n }\n }\n }\n\n void kickAndImprove(vector& assign, int kicks) const {\n for (int k = 0; k < kicks; ++k) {\n vector used(S, 0);\n for (int id : assign) used[id] = 1;\n \n if (rng() % 2 == 0) {\n int p = uniform_int_distribution(0, CELLS - 1)(rng);\n int q = uniform_int_distribution(0, CELLS - 1)(rng);\n swap(assign[p], assign[q]);\n } else {\n int p = uniform_int_distribution(0, CELLS - 1)(rng);\n vector unused;\n for (int s = 0; s < S; ++s) if (!used[s]) unused.push_back(s);\n if (!unused.empty()) {\n int newSeed = unused[uniform_int_distribution(0, unused.size() - 1)(rng)];\n assign[p] = newSeed;\n }\n }\n improve(assign);\n }\n }\n\n void solveOneTurn() {\n compute_w();\n\n vector greedySeeds = greedyCoverSelection();\n vector topSeeds = topValueSelection();\n\n vector, vector>> candidates;\n \n // Greedy with multiple random placements\n candidates.emplace_back(greedySeeds, linearAssignment(greedySeeds));\n for (int i = 0; i < 5; ++i)\n candidates.emplace_back(greedySeeds, randomAssignment(greedySeeds));\n for (int i = 0; i < 3; ++i)\n candidates.emplace_back(greedySeeds, randomAssignmentFully(greedySeeds));\n \n // Top with placements\n candidates.emplace_back(topSeeds, linearAssignment(topSeeds));\n for (int i = 0; i < 3; ++i)\n candidates.emplace_back(topSeeds, randomAssignment(topSeeds));\n\n int bestW = -1;\n vector bestAssign;\n\n for (auto& cand : candidates) {\n vector cur = cand.second;\n \n improve(cur);\n for (int round = 0; round < 5; ++round) {\n kickAndImprove(cur, 3);\n improve(cur);\n }\n \n int curW = totalW(cur);\n if (curW > bestW) {\n bestW = curW;\n bestAssign = cur;\n }\n }\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (c) cout << ' ';\n cout << bestAssign[r * N + c];\n }\n cout << '\\n';\n }\n cout.flush();\n }\n\n void run() {\n seed.assign(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n\n neigh.assign(CELLS, {});\n auto addNeighbour = [&](int r, int c, int nr, int nc) {\n if (0 <= nr && nr < N && 0 <= nc && nc < N) {\n neigh[r * N + c].push_back(nr * N + nc);\n }\n };\n for (int r = 0; r < N; ++r)\n for (int c = 0; c < N; ++c) {\n addNeighbour(r, c, r - 1, c);\n addNeighbour(r, c, r + 1, c);\n addNeighbour(r, c, r, c - 1);\n addNeighbour(r, c, r, c + 1);\n }\n\n rng.seed(chrono::steady_clock::now().time_since_epoch().count());\n\n for (int turn = 0; turn < T; ++turn) {\n solveOneTurn();\n seed.assign(S, vector(M));\n for (int i = 0; i < S; ++i)\n for (int j = 0; j < M; ++j) cin >> seed[i][j];\n }\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, T;\n if (!(cin >> N >> M >> T)) return 0;\n Solver solver;\n solver.N = N;\n solver.M = M;\n solver.T = T;\n solver.S = 2 * N * (N - 1);\n solver.CELLS = N * N;\n solver.run();\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Nb { int x, y, d; };\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, Vlimit;\n if (!(cin >> N >> M >> Vlimit)) return 0;\n \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 // Arm design (root + one leaf, length 4)\n const int Vprime = 2;\n const int EDGE_LEN = 4;\n cout << Vprime << \"\\n\";\n cout << 0 << ' ' << EDGE_LEN << \"\\n\";\n cout << 0 << ' ' << 0 << \"\\n\";\n\n // Collect sources and targets\n vector> src, tgt;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (s[i][j] == '1') src.emplace_back(i, j);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (t[i][j] == '1') tgt.emplace_back(i, j);\n\n const int DX[4] = {0, 1, 0, -1};\n const int DY[4] = {1, 0, -1, 0};\n\n // Occupied: 0=empty, 1=target\n vector> occ(N, vector(N, 0));\n for (auto &p : tgt) occ[p.first][p.second] = 1;\n\n vector srcIdx, tgtIdx;\n for (int i = 0; i < (int)src.size(); ++i) {\n int x = src[i].first, y = src[i].second;\n if (occ[x][y] == 1) {\n occ[x][y] = 0;\n } else {\n occ[x][y] = 2;\n srcIdx.push_back(i);\n }\n }\n for (int i = 0; i < (int)tgt.size(); ++i) {\n int x = tgt[i].first, y = tgt[i].second;\n if (occ[x][y] == 1) {\n tgtIdx.push_back(i);\n }\n }\n\n // Precompute valid root positions for each source and target\n vector> srcNb(srcIdx.size()), tgtNb(tgtIdx.size());\n \n for (int si = 0; si < (int)srcIdx.size(); ++si) {\n int x = src[srcIdx[si]].first, y = src[srcIdx[si]].second;\n for (int d = 0; d < 4; ++d) {\n int nx = x - EDGE_LEN * DX[d];\n int ny = y - EDGE_LEN * DY[d];\n if (nx >= 0 && nx < N && ny >= 0 && ny < N) {\n srcNb[si].push_back({nx, ny, d});\n }\n }\n }\n for (int ti = 0; ti < (int)tgtIdx.size(); ++ti) {\n int x = tgt[tgtIdx[ti]].first, y = tgt[tgtIdx[ti]].second;\n for (int d = 0; d < 4; ++d) {\n int nx = x - EDGE_LEN * DX[d];\n int ny = y - EDGE_LEN * DY[d];\n if (nx >= 0 && nx < N && ny >= 0 && ny < N) {\n tgtNb[ti].push_back({nx, ny, d});\n }\n }\n }\n\n // Greedy matching by closest distance\n int n = srcIdx.size();\n vector pairSrc(n, -1), pairTgt(n, -1);\n vector srcUsed(n, 0), tgtUsed(n, 0);\n \n for (int iter = 0; iter < n; ++iter) {\n int bestS = -1, bestT = -1, bestDist = INT_MAX;\n \n for (int si = 0; si < n; ++si) {\n if (srcUsed[si]) continue;\n bool hasEmptyS = false;\n for (auto &nb : srcNb[si]) {\n if (occ[nb.x][nb.y] == 0) {\n hasEmptyS = true;\n break;\n }\n }\n if (!hasEmptyS) continue;\n \n for (int ti = 0; ti < n; ++ti) {\n if (tgtUsed[ti]) continue;\n bool hasEmptyT = false;\n for (auto &nb : tgtNb[ti]) {\n if (occ[nb.x][nb.y] == 0) {\n hasEmptyT = true;\n break;\n }\n }\n if (!hasEmptyT) continue;\n \n int d = abs(src[srcIdx[si]].first - tgt[tgtIdx[ti]].first)\n + abs(src[srcIdx[si]].second - tgt[tgtIdx[ti]].second);\n if (d < bestDist) {\n bestDist = d;\n bestS = si;\n bestT = ti;\n }\n }\n }\n \n if (bestS >= 0 && bestT >= 0) {\n pairSrc[bestS] = bestT;\n pairTgt[bestT] = bestS;\n srcUsed[bestS] = 1;\n tgtUsed[bestT] = 1;\n }\n }\n\n // Simulation\n int rx = 0, ry = 0;\n int leafDir = 0;\n bool holding = false;\n \n string output;\n output.reserve(200000 * (2 * Vprime + 10));\n\n auto addTurn = [&](char mv, char rot, char leafAct) {\n string str(2 * Vprime, '.');\n str[0] = mv;\n str[1] = rot;\n str[Vprime] = '.';\n str[Vprime + 1] = leafAct;\n output += str;\n output += '\\n';\n };\n\n auto moveRoot = [&](int gx, int gy) {\n while (rx != gx || ry != gy) {\n char mv;\n if (rx < gx) { mv = 'D'; ++rx; }\n else if (rx > gx) { mv = 'U'; --rx; }\n else if (ry < gy) { mv = 'R'; ++ry; }\n else { mv = 'L'; --ry; }\n addTurn(mv, '.', '.');\n }\n };\n\n auto rotateLeaf = [&](char rot) {\n if (rot != '.') {\n if (rot == 'R') leafDir = (leafDir + 1) & 3;\n else leafDir = (leafDir + 3) & 3;\n }\n addTurn('.', rot, '.');\n };\n\n auto rotateLeafTo = [&](int dir) {\n while (leafDir != dir) {\n int diff = (dir - leafDir + 4) & 3;\n if (diff == 2) {\n rotateLeaf('R'); rotateLeaf('R');\n } else if (diff == 1) {\n rotateLeaf('R');\n } else {\n rotateLeaf('L');\n }\n }\n };\n\n // Process each matched pair\n for (int si = 0; si < n; ++si) {\n if (pairSrc[si] < 0) continue;\n int ti = pairSrc[si];\n int sx = src[srcIdx[si]].first, sy = src[srcIdx[si]].second;\n int tx = tgt[tgtIdx[ti]].first, ty = tgt[tgtIdx[ti]].second;\n\n // Find closest empty root position for source\n int bestRxS = -1, bestRyS = -1, bestDirS = -1;\n int minDistS = INT_MAX;\n for (auto &nb : srcNb[si]) {\n if (occ[nb.x][nb.y] != 0) continue;\n int d = abs(rx - nb.x) + abs(ry - nb.y);\n if (d < minDistS) {\n minDistS = d;\n bestRxS = nb.x; bestRyS = nb.y; bestDirS = nb.d;\n }\n }\n\n // Find closest empty root position for target\n int bestRxT = -1, bestRyT = -1, bestDirT = -1;\n int minDistT = INT_MAX;\n for (auto &nb : tgtNb[ti]) {\n if (occ[nb.x][nb.y] != 0) continue;\n int d = abs(rx - nb.x) + abs(ry - nb.y);\n if (d < minDistT) {\n minDistT = d;\n bestRxT = nb.x; bestRyT = nb.y; bestDirT = nb.d;\n }\n }\n\n if (bestRxS >= 0 && bestRxT >= 0) {\n moveRoot(bestRxS, bestRyS);\n rotateLeafTo(bestDirS);\n addTurn('.', '.', 'P');\n occ[sx][sy] = 0;\n holding = true;\n\n moveRoot(bestRxT, bestRyT);\n rotateLeafTo(bestDirT);\n addTurn('.', '.', 'P');\n occ[tx][ty] = 1;\n holding = false;\n }\n }\n\n cout << output;\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n int sign;\n};\n\nconst int MAXCOORD = 100000;\nconst int CELL_SIZE = 300; // Finer grid\n\nconst int MAXC = 340;\nint cell[MAXC][MAXC];\nint pref[MAXC + 1][MAXC + 1];\n\n// O(1) query on cell grid\ninline int grid_sum(int x1, int y1, int x2, int y2, int C) {\n if (x1 > x2 || y1 > y2) return INT_MIN;\n return pref[x2 + 1][y2 + 1] - pref[x1][y2 + 1] - pref[x2 + 1][y1] + pref[x1][y1];\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n if (!(cin >> N)) return 0;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n int x, y;\n cin >> x >> y;\n points[i] = {x, y, (i < N) ? 1 : -1};\n }\n\n const int C = MAXCOORD / CELL_SIZE + 1; // 334\n\n // Build cell grid\n for (int i = 0; i < C; ++i)\n for (int j = 0; j < C; ++j)\n cell[i][j] = 0;\n\n for (auto &p : points) {\n int cx = p.x / CELL_SIZE;\n int cy = p.y / CELL_SIZE;\n cell[cx][cy] += p.sign;\n }\n\n // Build prefix sum\n for (int i = 0; i < C; ++i) {\n for (int j = 0; j < C; ++j) {\n pref[i + 1][j + 1] = pref[i][j + 1] + pref[i + 1][j] - pref[i][j] + cell[i][j];\n }\n }\n\n // ===== Maximum sum sub-matrix O(C\u00b3) = 37M operations =====\n int bestSum = INT_MIN;\n int bTop = 0, bBottom = 0, bLeft = 0, bRight = 0;\n\n for (int top = 0; top < C; ++top) {\n int colSum[MAXC] = {0};\n for (int bottom = top; bottom < C; ++bottom) {\n for (int col = 0; col < C; ++col) colSum[col] += cell[bottom][col];\n \n int curSum = 0, maxHere = INT_MIN, start = 0;\n for (int i = 0; i < C; ++i) {\n curSum += colSum[i];\n if (curSum > maxHere) {\n maxHere = curSum;\n bLeft = start;\n bRight = i;\n }\n if (curSum < 0) {\n curSum = 0;\n start = i + 1;\n }\n }\n \n if (maxHere > bestSum) {\n bestSum = maxHere;\n bTop = top;\n bBottom = bottom;\n }\n }\n }\n\n // Convert to coordinate rectangle\n int leftX = bLeft * CELL_SIZE;\n int rightX = min((bRight + 1) * CELL_SIZE - 1, MAXCOORD);\n int bottomY = bTop * CELL_SIZE;\n int topY = min((bBottom + 1) * CELL_SIZE - 1, MAXCOORD);\n\n int bestA = 0, bestB = 0;\n for (auto &p : points) {\n if (p.x >= leftX && p.x <= rightX && p.y >= bottomY && p.y <= topY) {\n if (p.sign == 1) ++bestA;\n else ++bestB;\n }\n }\n\n int bestL = leftX, bestR = rightX, bestBtm = bottomY, bestT = topY;\n\n // ===== Expand search =====\n for (int dl = 0; dl <= 5; ++dl) {\n for (int dr = 0; dr <= 5; ++dr) {\n for (int db = 0; db <= 5; ++db) {\n for (int dt = 0; dt <= 5; ++dt) {\n int lx = max(0, bLeft - dl) * CELL_SIZE;\n int rx = min(MAXCOORD, (bRight + dr + 1) * CELL_SIZE - 1);\n int by = max(0, bTop - db) * CELL_SIZE;\n int ty = min(MAXCOORD, (bBottom + dt + 1) * CELL_SIZE - 1);\n \n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= lx && p.x <= rx && p.y >= by && p.y <= ty) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = lx; bestR = rx; bestBtm = by; bestT = ty;\n }\n }\n }\n }\n }\n\n // ===== Random sampling =====\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> coord_dist(0, MAXCOORD);\n uniform_int_distribution<> size_dist(50, 8000);\n\n const int NUM_SAMPLES = 25000;\n for (int iter = 0; iter < NUM_SAMPLES; ++iter) {\n int lx = coord_dist(gen);\n int rx = lx + size_dist(gen);\n if (rx > MAXCOORD) rx = MAXCOORD;\n int by = coord_dist(gen);\n int ty = by + size_dist(gen);\n if (ty > MAXCOORD) ty = MAXCOORD;\n\n int c1 = lx / CELL_SIZE, c2 = rx / CELL_SIZE;\n int r1 = by / CELL_SIZE, r2 = ty / CELL_SIZE;\n int sum = grid_sum(c1, r1, c2, r2, C);\n \n if (sum > bestA - bestB) {\n int el = c1 * CELL_SIZE;\n int er = min((c2 + 1) * CELL_SIZE - 1, MAXCOORD);\n int eb = r1 * CELL_SIZE;\n int et = min((r2 + 1) * CELL_SIZE - 1, MAXCOORD);\n \n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= el && p.x <= er && p.y >= eb && p.y <= et) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = el; bestR = er; bestBtm = eb; bestT = et;\n }\n }\n }\n\n // ===== Local optimization =====\n for (int step = 0; step < 20; ++step) {\n int delta = step * 60;\n for (int dx = -delta; dx <= delta; dx += 80) {\n for (int dy = -delta; dy <= delta; dy += 80) {\n int lx = max(0, min(MAXCOORD, bestL + dx));\n int rx = max(0, min(MAXCOORD, bestR + dx));\n int by = max(0, min(MAXCOORD, bestBtm + dy));\n int ty = max(0, min(MAXCOORD, bestT + dy));\n \n if (lx > rx || by > ty) continue;\n \n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= lx && p.x <= rx && p.y >= by && p.y <= ty) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = lx; bestR = rx; bestBtm = by; bestT = ty;\n }\n }\n }\n }\n\n // ===== Search around mackerels =====\n vector mackerels;\n for (auto &p : points) if (p.sign == 1) mackerels.push_back(p);\n \n shuffle(mackerels.begin(), mackerels.end(), gen);\n \n const int MAX_MAC_SEARCH = 600;\n const int radii[] = {20, 40, 80, 120, 200, 300, 500, 700, 1000, 1500, 2200, 3500, 5000, 7000, 10000};\n const int NUM_RADII = 15;\n \n for (int mi = 0; mi < min((int)mackerels.size(), MAX_MAC_SEARCH); ++mi) {\n auto &m = mackerels[mi];\n for (int ri = 0; ri < NUM_RADII; ++ri) {\n int r = radii[ri];\n int lx = max(0, m.x - r);\n int rx = min(MAXCOORD, m.x + r);\n int by = max(0, m.y - r);\n int ty = min(MAXCOORD, m.y + r);\n \n int c1 = lx / CELL_SIZE, c2 = rx / CELL_SIZE;\n int r1 = by / CELL_SIZE, r2 = ty / CELL_SIZE;\n int sum = grid_sum(c1, r1, c2, r2, C);\n \n if (sum > bestA - bestB) {\n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= lx && p.x <= rx && p.y >= by && p.y <= ty) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = lx; bestR = rx; bestBtm = by; bestT = ty;\n }\n }\n }\n }\n\n // ===== Try rectangles based on mackerel pairs =====\n const int MAX_PAIRS = 250;\n for (int i = 0; i < min((int)mackerels.size(), MAX_PAIRS); ++i) {\n for (int j = i + 1; j < min((int)mackerels.size(), MAX_PAIRS); ++j) {\n auto &m1 = mackerels[i];\n auto &m2 = mackerels[j];\n int lx = min(m1.x, m2.x);\n int rx = max(m1.x, m2.x);\n int by = min(m1.y, m2.y);\n int ty = max(m1.y, m2.y);\n \n for (int exp = 1; exp <= 6; ++exp) {\n int w = max(1, rx - lx), h = max(1, ty - by);\n int nlx = max(0, lx - exp * w / 4);\n int nrx = min(MAXCOORD, rx + exp * w / 4);\n int nby = max(0, by - exp * h / 4);\n int nty = min(MAXCOORD, ty + exp * h / 4);\n \n int c1 = nlx / CELL_SIZE, c2 = nrx / CELL_SIZE;\n int r1 = nby / CELL_SIZE, r2 = nty / CELL_SIZE;\n int sum = grid_sum(c1, r1, c2, r2, C);\n \n if (sum > bestA - bestB) {\n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= nlx && p.x <= nrx && p.y >= nby && p.y <= nty) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = nlx; bestR = nrx; bestBtm = nby; bestT = nty;\n }\n }\n }\n }\n }\n\n // ===== Sardine avoidance search =====\n vector sardines;\n for (auto &p : points) if (p.sign == -1) sardines.push_back(p);\n \n int sarMinX = MAXCOORD, sarMaxX = 0, sarMinY = MAXCOORD, sarMaxY = 0;\n for (auto &s : sardines) {\n sarMinX = min(sarMinX, s.x);\n sarMaxX = max(sarMaxX, s.x);\n sarMinY = min(sarMinY, s.y);\n sarMaxY = max(sarMaxY, s.y);\n }\n \n const int EDGE_OFFSETS[] = {500, 1000, 2000, 4000, 8000, 15000};\n for (int off : EDGE_OFFSETS) {\n // Try on all 4 edges\n for (int edge = 0; edge < 4; ++edge) {\n int lx, rx, by, ty;\n if (edge == 0) { // Top\n lx = max(0, sarMinX - off);\n rx = min(MAXCOORD, sarMaxX + off);\n by = max(0, sarMinY - off);\n ty = sarMinY + 3000;\n } else if (edge == 1) { // Bottom\n lx = max(0, sarMinX - off);\n rx = min(MAXCOORD, sarMaxX + off);\n by = sarMaxY;\n ty = min(MAXCOORD, sarMaxY + off);\n } else if (edge == 2) { // Left\n lx = max(0, sarMinX - off);\n rx = sarMinX + 3000;\n by = max(0, sarMinY - off);\n ty = min(MAXCOORD, sarMaxY + off);\n } else { // Right\n lx = sarMaxX;\n rx = min(MAXCOORD, sarMaxX + off);\n by = max(0, sarMinY - off);\n ty = min(MAXCOORD, sarMaxY + off);\n }\n \n int a = 0, b = 0;\n for (auto &p : points) {\n if (p.x >= lx && p.x <= rx && p.y >= by && p.y <= ty) {\n if (p.sign == 1) ++a;\n else ++b;\n }\n }\n if (a - b > bestA - bestB) {\n bestA = a; bestB = b;\n bestL = lx; bestR = rx; bestBtm = by; bestT = ty;\n }\n }\n }\n\n // ===== Tighten rectangle =====\n if (bestA + bestB > 0) {\n int minX = MAXCOORD, maxX = 0, minY = MAXCOORD, maxY = 0;\n for (auto &p : points) {\n if (p.x >= bestL && p.x <= bestR && p.y >= bestBtm && p.y <= bestT) {\n minX = min(minX, p.x);\n maxX = max(maxX, p.x);\n minY = min(minY, p.y);\n maxY = max(maxY, p.y);\n }\n }\n bestL = minX;\n bestR = maxX;\n bestBtm = minY;\n bestT = maxY;\n }\n\n // Ensure positive area\n if (bestL == bestR) {\n if (bestL > 0) bestL--;\n else bestR++;\n }\n if (bestBtm == bestT) {\n if (bestBtm > 0) bestBtm--;\n else bestT++;\n }\n\n // Perimeter check\n long long perimeter = 2LL * ((long long)bestR - bestL + bestT - bestBtm);\n if (perimeter > 400000) {\n int width = bestR - bestL;\n int height = bestT - bestBtm;\n int maxDim = 200000;\n \n if (width > maxDim) {\n int diff = width - maxDim;\n bestL += diff / 2;\n bestR -= (diff - diff / 2);\n }\n if (height > maxDim) {\n int diff = height - maxDim;\n bestBtm += diff / 2;\n bestT -= (diff - diff / 2);\n }\n }\n\n // Final clamp\n bestL = max(0, min(MAXCOORD, bestL));\n bestR = max(0, min(MAXCOORD, bestR));\n bestBtm = max(0, min(MAXCOORD, bestBtm));\n bestT = max(0, min(MAXCOORD, bestT));\n\n // Output rectangle\n cout << 4 << '\\n';\n cout << bestL << ' ' << bestBtm << '\\n';\n cout << bestR << ' ' << bestBtm << '\\n';\n cout << bestR << ' ' << bestT << '\\n';\n cout << bestL << ' ' << bestT << '\\n';\n\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, T;\n long long sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n \n vector w_obs(N), h_obs(N);\n for (int i = 0; i < N; ++i) cin >> w_obs[i] >> h_obs[i];\n \n const long long INF = (1LL<<62);\n \n // Helper: find best single-row placement for a subset\n auto best_single_row = [&](const vector& rects,\n vector& rot) -> tuple {\n if (rects.empty()) return {0, 0, 0};\n \n vector cand;\n for (int i : rects) {\n cand.push_back(w_obs[i]);\n cand.push_back(h_obs[i]);\n }\n sort(cand.begin(), cand.end());\n cand.erase(unique(cand.begin(), cand.end()), cand.end());\n \n long long bestCost = INF, bestH = 0, bestSumW = 0;\n rot.assign(N, 0);\n \n for (long long H : cand) {\n long long sumW = 0;\n bool ok = true;\n vector rotTmp(N, 0);\n \n for (int i : rects) {\n if (h_obs[i] <= H && w_obs[i] <= H) {\n if (w_obs[i] <= h_obs[i]) {\n sumW += w_obs[i];\n } else {\n sumW += h_obs[i];\n rotTmp[i] = 1;\n }\n } else if (h_obs[i] <= H) {\n sumW += w_obs[i];\n } else if (w_obs[i] <= H) {\n sumW += h_obs[i];\n rotTmp[i] = 1;\n } else {\n ok = false;\n break;\n }\n }\n \n if (ok && sumW + H < bestCost) {\n bestCost = sumW + H;\n bestH = H;\n bestSumW = sumW;\n rot = rotTmp;\n }\n }\n return {bestSumW, bestH, bestCost};\n };\n \n // Try single row first\n vector bestRot(N, 0);\n long long bestScore = INF;\n vector> placement; // (index, direction) for output\n \n {\n vector rot;\n auto [sumW, H, cost] = best_single_row(vector(N), rot);\n if (cost < bestScore) {\n bestScore = cost;\n bestRot = rot;\n placement.clear();\n for (int i = 0; i < N; ++i) {\n placement.push_back({i, 'U'}); // All U for single row\n }\n }\n }\n \n // Try two rows\n vector sorted_by_h(N);\n iota(sorted_by_h.begin(), sorted_by_h.end(), 0);\n sort(sorted_by_h.begin(), sorted_by_h.end(), [&](int a, int b) {\n return h_obs[a] > h_obs[b];\n });\n \n for (int split = N/4; split <= 3*N/4; split += max(1, N/10)) {\n vector row1(sorted_by_h.begin() + split, sorted_by_h.end());\n vector row2(sorted_by_h.begin(), sorted_by_h.begin() + split);\n \n vector rot1, rot2;\n auto [sumW1, H1, cost1] = best_single_row(row1, rot1);\n auto [sumW2, H2, cost2] = best_single_row(row2, rot2);\n \n if (cost1 == INF || cost2 == INF) continue;\n \n long long totalW = max(sumW1, sumW2);\n long long totalH = H1 + H2;\n long long totalScore = totalW + totalH;\n \n if (totalScore < bestScore) {\n bestScore = totalScore;\n bestRot = rot1;\n for (int i : row2) bestRot[i] = rot2[i];\n \n // Create placement: rectangles in ascending index order\n // Row2 goes below row1\n placement.clear();\n \n // For two rows, we need to specify which row each rectangle goes to\n // Row1 uses U, Row2 uses L to go below\n vector is_row2(N, 0);\n for (int i : row2) is_row2[i] = 1;\n \n // Output in ascending index order\n for (int i = 0; i < N; ++i) {\n placement.push_back({i, is_row2[i] ? 'L' : 'U'});\n }\n }\n }\n \n // Precompute placement operations\n vector ref_idx(N, -1);\n for (size_t i = 0; i < placement.size(); ++i) {\n int idx = placement[i].first;\n char dir = placement[i].second;\n if (dir == 'U') {\n // Reference previous in list\n int prev = -1;\n for (int j = 0; j < i; ++j) {\n if (placement[j].first < idx) {\n prev = placement[j].first;\n }\n }\n ref_idx[idx] = prev;\n } else { // L\n // Find reference rectangle (last from row1)\n int ref = -1;\n for (int j = 0; j < N; ++j) {\n if (placement[j].second == 'U' && placement[j].first < idx) {\n ref = placement[j].first;\n }\n }\n ref_idx[idx] = ref;\n }\n }\n \n // Output\n for (int turn = 0; turn < T; ++turn) {\n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n char dir = placement[i].second;\n cout << i << ' ' << (bestRot[i] ? 1 : 0) << ' ' << dir << ' ' << ref_idx[i] << \"\\n\";\n }\n cout << flush;\n \n long long W_measured, H_measured;\n cin >> W_measured >> H_measured;\n }\n \n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nstruct XorShift {\n uint32_t x;\n XorShift(uint32_t seed = 2463534242U) : x(seed) {}\n uint32_t next() {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n }\n int nextInt(int mod) { return next() % mod; }\n int nextInt(int L, int R) { return L + next() % (R - L + 1); }\n void shuffle(vector& v) {\n for (int i = (int)v.size() - 1; i > 0; --i) {\n swap(v[i], v[nextInt(i + 1)]);\n }\n }\n} rng;\n\nconst int INF_NEG = -1e9;\n\n/*------------------------------------------------------------*/\n/* Build a random spanning tree */\n/*------------------------------------------------------------*/\nvoid build_random_tree(int N, const vector>& adj,\n const vector& A,\n vector>& tree, int root,\n XorShift& rng, int method) {\n vector parent(N, -2);\n tree.assign(N, {});\n \n if (method == 0) { // Random DFS\n vector stack;\n stack.push_back(root);\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n rng.shuffle(nbr);\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n } else if (method == 1) { // Random BFS\n queue q;\n q.push(root);\n parent[root] = -1;\n while (!q.empty()) {\n int v = q.front(); q.pop();\n vector nbr = adj[v];\n rng.shuffle(nbr);\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n q.push(u);\n }\n }\n }\n } else if (method == 2) { // Random Prim\n vector inTree(N, 0);\n inTree[root] = 1;\n vector vertices = {root};\n while ((int)vertices.size() < N) {\n int v = vertices[rng.nextInt((int)vertices.size())];\n vector nbr = adj[v];\n rng.shuffle(nbr);\n for (int u : nbr) {\n if (!inTree[u]) {\n inTree[u] = 1;\n tree[v].push_back(u);\n tree[u].push_back(v);\n vertices.push_back(u);\n break;\n }\n }\n }\n } else if (method == 3) { // Random Kruskal\n vector p(N);\n iota(p.begin(), p.end(), 0);\n vector>> edges;\n for (int v = 0; v < N; ++v) {\n for (int u : adj[v]) {\n if (v < u) edges.push_back({rng.nextInt(1<<30), {v, u}});\n }\n }\n sort(edges.begin(), edges.end());\n for (auto& e : edges) {\n int v = e.second.first;\n int u = e.second.second;\n function find = [&](int x) -> int {\n return p[x] == x ? x : p[x] = find(p[x]);\n };\n int pv = find(v), pu = find(u);\n if (pv != pu) {\n p[pv] = pu;\n tree[v].push_back(u);\n tree[u].push_back(v);\n }\n }\n } else if (method == 4) { // Greedy DFS - prefer high beauty\n vector stack;\n stack.push_back(root);\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n sort(nbr.begin(), nbr.end(),\n [&](int a, int b) { return A[a] > A[b]; });\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n } else { // method == 5: Inverse greedy - prefer low beauty\n vector stack;\n stack.push_back(root);\n parent[root] = -1;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n vector nbr = adj[v];\n sort(nbr.begin(), nbr.end(),\n [&](int a, int b) { return A[a] < A[b]; });\n for (int u : nbr) {\n if (parent[u] == -2) {\n parent[u] = v;\n tree[v].push_back(u);\n tree[u].push_back(v);\n stack.push_back(u);\n }\n }\n }\n }\n}\n\n/*------------------------------------------------------------*/\n/* Solve the forest problem - using static arrays */\n/*------------------------------------------------------------*/\nint solve_tree_fast(const vector>& tree, int root,\n const vector& A, int H,\n vector& outParent) {\n const int N = A.size();\n \n // Build children list\n static vector> children;\n children.assign(N, {});\n static vector bfs_order;\n bfs_order.clear();\n bfs_order.reserve(N);\n \n queue q;\n q.push(root);\n vector par(N, -2);\n par[root] = -1;\n \n while (!q.empty()) {\n int v = q.front(); q.pop();\n bfs_order.push_back(v);\n for (int u : tree[v]) {\n if (par[u] == -2) {\n par[u] = v;\n children[v].push_back(u);\n q.push(u);\n }\n }\n }\n \n // DP: bottom-up using bfs_order reversed\n static int dp[1000][11];\n // Static decision storage\n static unsigned char keepDec[1000][100]; // [v][child_index * 11 + d]\n \n for (int idx = (int)bfs_order.size() - 1; idx >= 0; --idx) {\n int v = bfs_order[idx];\n int deg = (int)children[v].size();\n for (int d = 0; d <= H; ++d) {\n int cur = (d + 1) * A[v];\n for (int i = 0; i < deg; ++i) {\n int u = children[v][i];\n int keepEdge = (d < H) ? dp[u][d + 1] : INF_NEG;\n int cutEdge = dp[u][0];\n if (keepEdge > cutEdge) {\n cur += keepEdge;\n keepDec[v][i * 11 + d] = 1;\n } else {\n cur += cutEdge;\n keepDec[v][i * 11 + d] = 0;\n }\n }\n dp[v][d] = cur;\n }\n }\n \n int bestVal = dp[root][0];\n \n // Reconstruct parent array\n outParent.assign(N, -1);\n static vector> stk;\n stk.clear();\n stk.emplace_back(root, 0);\n \n while (!stk.empty()) {\n auto [v, depth] = stk.back();\n stk.pop_back();\n int deg = (int)children[v].size();\n for (int i = 0; i < deg; ++i) {\n int u = children[v][i];\n if (keepDec[v][i * 11 + depth]) {\n outParent[u] = v;\n stk.emplace_back(u, depth + 1);\n } else {\n outParent[u] = -1;\n stk.emplace_back(u, 0);\n }\n }\n }\n \n return bestVal;\n}\n\n/*------------------------------------------------------------*/\n/* Main */\n/*------------------------------------------------------------*/\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n \n vector A(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n \n vector> adj(N);\n for (int i = 0; i < M; ++i) {\n int u, v; cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n // Read coordinates (not used)\n for (int i = 0; i < N; ++i) {\n long long x, y; cin >> x >> y;\n }\n \n // Find minimum beauty vertices for smart rooting\n vector> beautyIdx(N);\n for (int i = 0; i < N; ++i) beautyIdx[i] = {A[i], i};\n sort(beautyIdx.begin(), beautyIdx.end());\n int minBeautyIdx = beautyIdx[0].second;\n \n // Collect low beauty candidates (top 30)\n vector lowBeautyCand;\n for (int i = 0; i < min(30, N); ++i) {\n lowBeautyCand.push_back(beautyIdx[i].second);\n }\n \n const int ITER = 5000; // Back to safe level\n const int ROOTS_PER_TREE = 2;\n \n int bestScore = INF_NEG;\n vector bestParent;\n \n for (int it = 0; it < ITER; ++it) {\n int method = rng.nextInt(6);\n \n vector> tree;\n int treeRoot = rng.nextInt(N);\n build_random_tree(N, adj, A, tree, treeRoot, rng, method);\n \n vector roots;\n roots.reserve(ROOTS_PER_TREE);\n roots.push_back(minBeautyIdx);\n if (ROOTS_PER_TREE >= 2) {\n roots.push_back(lowBeautyCand[rng.nextInt((int)lowBeautyCand.size())]);\n }\n \n for (int r : roots) {\n vector parent;\n int score = solve_tree_fast(tree, r, A, H, parent);\n if (score > bestScore) {\n bestScore = score;\n bestParent = parent;\n }\n }\n }\n \n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << bestParent[i];\n }\n cout << '\\n';\n \n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> N)) return 0;\n vector board(N);\n for (int i = 0; i < N; ++i) cin >> board[i];\n\n vector> ops;\n\n // Phase 1: Batch remove Oni from rows without Fukunokami\n // Each L shift removes the leftmost piece. If there's no Fukunokami in the row,\n // we can safely shift until all Oni are gone.\n for (int iteration = 0; iteration < N * N; ++iteration) {\n bool madeProgress = false;\n \n for (int i = 0; i < N; ++i) {\n bool hasFuku = false;\n for (int j = 0; j < N; ++j)\n if (board[i][j] == 'o') { hasFuku = true; break; }\n if (hasFuku) continue;\n \n int leftmostOni = -1;\n for (int j = 0; j < N; ++j)\n if (board[i][j] == 'x') { leftmostOni = j; break; }\n if (leftmostOni == -1) continue;\n \n // One L shift removes the leftmost piece\n ops.emplace_back('L', i);\n \n // Simulate: shift row left\n for (int c = 0; c < N - 1; ++c)\n board[i][c] = board[i][c + 1];\n board[i][N - 1] = '.';\n \n madeProgress = true;\n }\n \n if (!madeProgress) break;\n }\n\n // Phase 2: Batch remove Oni from columns without Fukunokami\n for (int iteration = 0; iteration < N * N; ++iteration) {\n bool madeProgress = false;\n \n for (int j = 0; j < N; ++j) {\n bool hasFuku = false;\n for (int i = 0; i < N; ++i)\n if (board[i][j] == 'o') { hasFuku = true; break; }\n if (hasFuku) continue;\n \n int topmostOni = -1;\n for (int i = 0; i < N; ++i)\n if (board[i][j] == 'x') { topmostOni = i; break; }\n if (topmostOni == -1) continue;\n \n // One U shift removes the topmost piece\n ops.emplace_back('U', j);\n \n // Simulate: shift column up\n for (int r = 0; r < N - 1; ++r)\n board[r][j] = board[r + 1][j];\n board[N - 1][j] = '.';\n \n madeProgress = true;\n }\n \n if (!madeProgress) break;\n }\n\n // Phase 3: For remaining Oni, use standard forward+backward approach\n // with correct board state tracking\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] != 'x') continue;\n \n // Determine allowed directions based on current board state\n bool canU = true, canD = true, canL = true, canR = true;\n for (int r = 0; r < i; ++r)\n if (board[r][j] == 'o') { canU = false; break; }\n for (int r = i + 1; r < N; ++r)\n if (board[r][j] == 'o') { canD = false; break; }\n for (int c = 0; c < j; ++c)\n if (board[i][c] == 'o') { canL = false; break; }\n for (int c = j + 1; c < N; ++c)\n if (board[i][c] == 'o') { canR = false; break; }\n \n int bestDist = INT_MAX;\n char bestDir = '?';\n int param = -1;\n \n if (canU && i < bestDist) { bestDist = i; bestDir = 'U'; param = j; }\n if (canD && N - 1 - i < bestDist) { bestDist = N - 1 - i; bestDir = 'D'; param = j; }\n if (canL && j < bestDist) { bestDist = j; bestDir = 'L'; param = i; }\n if (canR && N - 1 - j < bestDist) { bestDist = N - 1 - j; bestDir = 'R'; param = i; }\n \n int cnt = bestDist + 1;\n char opp = (bestDir == 'U' ? 'D' : bestDir == 'D' ? 'U' :\n bestDir == 'L' ? 'R' : 'L');\n \n // Forward shift\n for (int k = 0; k < cnt; ++k) ops.emplace_back(bestDir, param);\n \n // Simulate forward shift to update board\n if (bestDir == 'U') {\n // Remove topmost piece in column param\n for (int r = 0; r < N - 1; ++r) board[r][param] = board[r + 1][param];\n board[N - 1][param] = '.';\n } else if (bestDir == 'D') {\n for (int r = N - 1; r > 0; --r) board[r][param] = board[r - 1][param];\n board[0][param] = '.';\n } else if (bestDir == 'L') {\n for (int c = 0; c < N - 1; ++c) board[param][c] = board[param][c + 1];\n board[param][N - 1] = '.';\n } else if (bestDir == 'R') {\n for (int c = N - 1; c > 0; --c) board[param][c] = board[param][c - 1];\n board[param][0] = '.';\n }\n \n // Backward shift (restore board)\n for (int k = 0; k < cnt; ++k) ops.emplace_back(opp, param);\n \n // Simulate backward shift to restore board\n if (opp == 'U') {\n for (int r = 0; r < N - 1; ++r) board[r][param] = board[r + 1][param];\n board[N - 1][param] = '.';\n } else if (opp == 'D') {\n for (int r = N - 1; r > 0; --r) board[r][param] = board[r - 1][param];\n board[0][param] = '.';\n } else if (opp == 'L') {\n for (int c = 0; c < N - 1; ++c) board[param][c] = board[param][c + 1];\n board[param][N - 1] = '.';\n } else if (opp == 'R') {\n for (int c = N - 1; c > 0; --c) board[param][c] = board[param][c - 1];\n board[param][0] = '.';\n }\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\nusing ll = long long;\n\nint N = 100;\nconst ll L = 500000LL;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector T(N);\n for (int i = 0; i < N; ++i) cin >> T[i];\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n // Simple random initial plan (known to work)\n auto buildPlan = [&](mt19937& r) {\n vector a(N), b(N);\n for (int i = 0; i < N; ++i) {\n a[i] = r() % N;\n b[i] = r() % N;\n }\n return tuple, vector>(a, b);\n };\n \n // Fast simulation\n auto simulate = [&](const vector& a, const vector& b) {\n vector cnt(N, 0);\n int cur = 0;\n cnt[cur]++;\n for (ll week = 2; week <= L; ++week) {\n if (cnt[cur] & 1) cur = a[cur];\n else cur = b[cur];\n ++cnt[cur];\n }\n return cnt;\n };\n \n // Calculate error\n auto calcError = [&](const vector& cnt) {\n ll err = 0;\n for (int i = 0; i < N; ++i) err += llabs((ll)cnt[i] - T[i]);\n return err;\n };\n \n // Optimize using random neighbor sampling\n auto optimize = [&](vector a, vector b, int maxIter) {\n vector cnt = simulate(a, b);\n ll curErr = calcError(cnt);\n ll bestErr = curErr;\n \n for (int iter = 0; iter < maxIter; ++iter) {\n // Pick random source\n int src = uniform_int_distribution(0, N-1)(rng);\n int sOdd = (cnt[src] + 1) / 2;\n int sEven = cnt[src] / 2;\n bool didImprove = false;\n \n // Try swapping a[src] and b[src] if cnt[src] is odd\n if (cnt[src] & 1) {\n int oldOdd = a[src], oldEven = b[src];\n ll delta = \n - llabs((ll)cnt[oldOdd] - T[oldOdd]) - llabs((ll)cnt[oldEven] - T[oldEven])\n + llabs((ll)cnt[oldOdd] - 1 - T[oldOdd]) + llabs((ll)cnt[oldEven] + 1 - T[oldEven]);\n if (delta < 0) {\n swap(a[src], b[src]);\n cnt[oldOdd] -= 1;\n cnt[oldEven] += 1;\n curErr += delta;\n didImprove = true;\n }\n }\n \n // Try moving odd edge\n if (!didImprove) {\n for (int attempt = 0; attempt < 8; ++attempt) {\n int newTarget = uniform_int_distribution(0, N-1)(rng);\n if (newTarget == a[src]) continue;\n \n int oldTarget = a[src];\n ll delta = \n - llabs((ll)cnt[oldTarget] - T[oldTarget]) - llabs((ll)cnt[newTarget] - T[newTarget])\n + llabs((ll)cnt[oldTarget] - sOdd - T[oldTarget]) + llabs((ll)cnt[newTarget] + sOdd - T[newTarget]);\n \n if (delta < 0) {\n a[src] = newTarget;\n cnt[oldTarget] -= sOdd;\n cnt[newTarget] += sOdd;\n curErr += delta;\n didImprove = true;\n break;\n }\n }\n }\n \n // Try moving even edge\n if (!didImprove) {\n for (int attempt = 0; attempt < 8; ++attempt) {\n int newTarget = uniform_int_distribution(0, N-1)(rng);\n if (newTarget == b[src]) continue;\n \n int oldTarget = b[src];\n ll delta = \n - llabs((ll)cnt[oldTarget] - T[oldTarget]) - llabs((ll)cnt[newTarget] - T[newTarget])\n + llabs((ll)cnt[oldTarget] - sEven - T[oldTarget]) + llabs((ll)cnt[newTarget] + sEven - T[newTarget]);\n \n if (delta < 0) {\n b[src] = newTarget;\n cnt[oldTarget] -= sEven;\n cnt[newTarget] += sEven;\n curErr += delta;\n didImprove = true;\n break;\n }\n }\n }\n \n if (curErr < bestErr) bestErr = curErr;\n \n // Occasional full resimulation to correct drift\n if (iter % 1000 == 0) {\n cnt = simulate(a, b);\n curErr = calcError(cnt);\n }\n }\n \n return tuple, vector, ll>(a, b, bestErr);\n };\n \n ll bestError = (1LL<<60);\n vector bestA(N), bestB(N);\n \n const int RESTARTS = 150;\n const int ITER_PER_RESTART = 5000;\n \n for (int r = 0; r < RESTARTS; ++r) {\n mt19937 r2(r * 12345 + 6789);\n auto [initA, initB] = buildPlan(r2);\n auto [a, b, err] = optimize(initA, initB, ITER_PER_RESTART);\n \n if (err < bestError) {\n bestError = err;\n bestA = a;\n bestB = b;\n if (bestError == 0) break;\n }\n }\n \n for (int i = 0; i < N; ++i) {\n cout << bestA[i] << ' ' << bestB[i] << '\\n';\n }\n \n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; ++i) {\n cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n\n /* -----------------------------------------------------------\n 1. grouping : sort by rectangle centre\n ----------------------------------------------------------- */\n vector cx(N), cy(N);\n for (int i = 0; i < N; ++i) {\n cx[i] = (lx[i] + rx[i]) * 0.5;\n cy[i] = (ly[i] + ry[i]) * 0.5;\n }\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(),\n [&](int a, int b) {\n if (cx[a] != cx[b]) return cx[a] < cx[b];\n return cy[a] < cy[b];\n });\n\n vector> groups(M);\n int pos = 0;\n for (int g = 0; g < M; ++g) {\n for (int cnt = 0; cnt < G[g]; ++cnt) {\n groups[g].push_back(order[pos++]);\n }\n }\n\n /* -----------------------------------------------------------\n 2. helper: perform one query\n ----------------------------------------------------------- */\n auto do_query = [&](const vector& verts) -> vector> {\n int L = (int)verts.size();\n cout << \"? \" << L;\n for (int v : verts) cout << ' ' << v;\n cout << \"\\n\";\n cout.flush();\n vector> edges;\n edges.reserve(L-1);\n for (int i = 0; i < L-1; ++i) {\n int a,b; cin >> a >> b;\n edges.emplace_back(a,b);\n }\n return edges;\n };\n\n /* -----------------------------------------------------------\n 3. ask queries for every group, store the received edges\n ----------------------------------------------------------- */\n vector>> groupEdges(M);\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n if (sz <= 1) continue; // no road needed\n if (sz <= L) {\n auto e = do_query(grp);\n groupEdges[g] = move(e);\n } else {\n int start = 0;\n while (start + 1 < sz) { // at least two vertices left\n int end = min(start + L, sz);\n vector win(grp.begin() + start, grp.begin() + end);\n auto e = do_query(win);\n groupEdges[g].insert(groupEdges[g].end(),\n e.begin(), e.end());\n start = end - 1; // overlap = 1 vertex\n }\n }\n }\n\n /* -----------------------------------------------------------\n 4. output the answer\n ----------------------------------------------------------- */\n cout << \"!\\n\";\n for (int g = 0; g < M; ++g) {\n const vector& grp = groups[g];\n int sz = (int)grp.size();\n // list of cities\n for (int i = 0; i < sz; ++i) {\n if (i) cout << ' ';\n cout << grp[i];\n }\n cout << \"\\n\";\n if (sz <= 1) continue; // no edges\n\n // map global id -> local index (0 \u2026 sz-1)\n vector id2loc(N, -1);\n for (int i = 0; i < sz; ++i) id2loc[grp[i]] = i;\n\n // adjacency list of the collected edges\n vector> adj(sz);\n for (auto &e : groupEdges[g]) {\n int u = e.first, v = e.second;\n int ui = id2loc[u];\n int vi = id2loc[v];\n if (ui >= 0 && vi >= 0) {\n adj[ui].push_back(vi);\n adj[vi].push_back(ui);\n }\n }\n\n // DFS to obtain a spanning tree\n vector parent(sz, -1);\n vector visited(sz, 0);\n vector st = {0};\n visited[0] = 1;\n while (!st.empty()) {\n int u = st.back(); st.pop_back();\n for (int v : adj[u]) if (!visited[v]) {\n visited[v] = 1;\n parent[v] = u;\n st.push_back(v);\n }\n }\n // (the graph is connected by Lemma\u202f1, but be safe)\n for (int i = 0; i < sz; ++i) if (!visited[i]) {\n parent[i] = 0; // connect arbitrarily\n }\n\n // output the tree edges\n for (int i = 1; i < sz; ++i) {\n int a = grp[i];\n int b = grp[parent[i]];\n if (a > b) swap(a,b);\n cout << a << ' ' << b << \"\\n\";\n }\n }\n cout.flush();\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M; // N=20, M=40\n\n vector> pts(M);\n for (int i = 0; i < M; ++i) cin >> pts[i].first >> pts[i].second;\n\n // Directions: index 0=Up,1=Down,2=Left,3=Right\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n auto nodeId = [&](int r, int c) { return r * N + c; };\n auto slideDest = [&](int r, int c, int d) {\n int nr = r, nc = c;\n if (d == 0) nr = 0; // Up\n else if (d == 1) nr = N-1; // Down\n else if (d == 2) nc = 0; // Left\n else if (d == 3) nc = N-1; // Right\n return make_pair(nr, nc);\n };\n\n vector answer;\n answer.reserve(2000);\n\n int cr = pts[0].first;\n int cc = pts[0].second;\n\n for (int idx = 1; idx < M; ++idx) {\n int tr = pts[idx].first;\n int tc = pts[idx].second;\n\n // BFS from (cr,cc) to (tr,tc)\n const int SRC = nodeId(cr, cc);\n const int DST = nodeId(tr, tc);\n\n vector dist(N*N, -1);\n vector parent(N*N, -1);\n vector> act(N*N, {'?', '?'}); // action type and direction\n\n queue q;\n q.push(SRC);\n dist[SRC] = 0;\n\n while (!q.empty() && dist[DST] == -1) {\n int u = q.front(); q.pop();\n int ur = u / N, uc = u % N;\n\n // Try moves and slides\n for (int d = 0; d < 4; ++d) {\n // Move\n int mr = ur + dr[d];\n int mc = uc + dc[d];\n if (mr >= 0 && mr < N && mc >= 0 && mc < N) {\n int v = nodeId(mr, mc);\n if (dist[v] == -1) {\n dist[v] = dist[u] + 1;\n parent[v] = u;\n act[v] = {'M', dirChar[d]};\n q.push(v);\n }\n }\n // Slide\n auto p = slideDest(ur, uc, d);\n int sr = p.first, sc = p.second;\n int v = nodeId(sr, sc);\n if (v != u && dist[v] == -1) {\n dist[v] = dist[u] + 1;\n parent[v] = u;\n act[v] = {'S', dirChar[d]};\n q.push(v);\n }\n }\n }\n\n // Reconstruct path from DST to SRC\n vector segment;\n int cur = DST;\n while (cur != SRC) {\n int p = parent[cur];\n char a = act[cur].first;\n char d = act[cur].second;\n segment.emplace_back(string(1, a) + \" \" + d);\n cur = p;\n }\n reverse(segment.begin(), segment.end());\n for (auto &s : segment) answer.push_back(s);\n\n // Update current position\n cr = tr;\n cc = tc;\n }\n\n // Output\n for (auto &s : answer) cout << s << '\\n';\n return 0;\n}"}}}