{"model_name":"gpt-5.2-codex-xhigh","codes":{"1":{"ahc001":"#include \nusing namespace std;\n\nstruct Rect {\n int l, r, b, t;\n};\n\ndouble calc_score(long long r, long long s) {\n double rr = (double)r;\n double ss = (double)s;\n double mn = min(rr, ss);\n double mx = max(rr, ss);\n double ratio = mn / mx;\n double diff = 1.0 - ratio;\n return 1.0 - diff * diff;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n;\n cin >> n;\n vector x(n), y(n);\n vector r(n);\n for (int i = 0; i < n; ++i) {\n cin >> x[i] >> y[i] >> r[i];\n }\n\n const int MAXC = 10000;\n vector rect(n);\n vector area(n);\n vector score(n);\n\n for (int i = 0; i < n; ++i) {\n rect[i] = {x[i], x[i] + 1, y[i], y[i] + 1};\n area[i] = 1;\n score[i] = calc_score(r[i], area[i]);\n }\n\n vector order(n);\n iota(order.begin(), order.end(), 0);\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n\n vector steps = {256, 128, 64, 32, 16, 8, 4, 2, 1};\n\n for (int step : steps) {\n bool changed = true;\n while (changed) {\n changed = false;\n shuffle(order.begin(), order.end(), rng);\n\n for (int idx : order) {\n Rect bestRect = rect[idx];\n double bestScore = score[idx];\n long long curArea = area[idx];\n\n int width = rect[idx].r - rect[idx].l;\n int height = rect[idx].t - rect[idx].b;\n\n for (int dir = 0; dir < 4; ++dir) {\n Rect cand = rect[idx];\n if (dir == 0) cand.l -= step;\n else if (dir == 1) cand.r += step;\n else if (dir == 2) cand.b -= step;\n else cand.t += step;\n\n if (cand.l < 0 || cand.b < 0 || cand.r > MAXC || cand.t > MAXC) continue;\n\n bool ok = true;\n for (int j = 0; j < n; ++j) if (j != idx) {\n if (cand.l < rect[j].r && cand.r > rect[j].l &&\n cand.b < rect[j].t && cand.t > rect[j].b) {\n ok = false;\n break;\n }\n }\n if (!ok) continue;\n\n long long newArea;\n if (dir <= 1) newArea = 1LL * (width + step) * height;\n else newArea = 1LL * width * (height + step);\n\n // Avoid large overshoot at coarse scales\n if (step > 1 && curArea < r[idx] && newArea > r[idx]) continue;\n\n double newScore = calc_score(r[idx], newArea);\n if (newScore > bestScore + 1e-12) {\n bestScore = newScore;\n bestRect = cand;\n }\n }\n\n if (bestScore > score[idx] + 1e-12) {\n rect[idx] = bestRect;\n area[idx] = 1LL * (bestRect.r - bestRect.l) * (bestRect.t - bestRect.b);\n score[idx] = bestScore;\n changed = true;\n }\n }\n }\n }\n\n for (int i = 0; i < n; ++i) {\n cout << rect[i].l << \" \" << rect[i].b << \" \"\n << rect[i].r << \" \" << rect[i].t << \"\\n\";\n }\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x;\n XorShift(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n inline uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline double nextDouble() {\n return (next() >> 11) * (1.0 / 9007199254740992.0); // 2^53\n }\n};\n\nstruct Params {\n double alpha, beta, noise;\n};\n\nstruct Path {\n vector nodes;\n int score;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int N = 50;\n const int V = N * N;\n\n int si, sj;\n if (!(cin >> si >> sj)) return 0;\n\n vector tile(V), val(V);\n int maxTile = -1;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int x;\n cin >> x;\n tile[i * N + j] = x;\n maxTile = max(maxTile, x);\n }\n }\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int x;\n cin >> x;\n val[i * N + j] = x;\n }\n }\n\n int M = maxTile + 1;\n\n vector> adj(V);\n vector adjCnt(V, 0);\n int dirs[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int id = i * N + j;\n for (auto &d : dirs) {\n int ni = i + d[0], nj = j + d[1];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int id2 = ni * N + nj;\n if (tile[id2] == tile[id]) continue; // same tile not allowed\n adj[id][adjCnt[id]++] = id2;\n }\n }\n }\n\n XorShift rng(chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto randomParams = [&](double progress) {\n Params p;\n p.alpha = 10.0 + rng.nextDouble() * 10.0; // 10-20\n p.beta = rng.nextDouble() * 0.4; // 0-0.4\n double baseNoise = 2.0 + rng.nextDouble() * 3.0; // 2-5\n p.noise = baseNoise * (1.0 - progress);\n return p;\n };\n\n auto extend = [&](int start, vector& visited, const Params& param,\n vector& out, int &addScore) {\n out.clear();\n addScore = 0;\n int cur = start;\n\n while (true) {\n int candIdx[4], candDeg[4], candMax[4], cnt = 0;\n bool hasPos = false;\n\n for (int k = 0; k < adjCnt[cur]; ++k) {\n int nb = adj[cur][k];\n if (visited[tile[nb]]) continue;\n\n int d = 0, mx = 0;\n for (int k2 = 0; k2 < adjCnt[nb]; ++k2) {\n int nb2 = adj[nb][k2];\n if (visited[tile[nb2]]) continue;\n d++;\n mx = max(mx, val[nb2]);\n }\n if (d > 0) hasPos = true;\n\n candIdx[cnt] = nb;\n candDeg[cnt] = d;\n candMax[cnt] = mx;\n cnt++;\n }\n\n if (cnt == 0) break;\n\n int best = -1;\n double bestScore = -1e18;\n for (int i = 0; i < cnt; ++i) {\n if (hasPos && candDeg[i] == 0) continue;\n double eval = val[candIdx[i]] + param.alpha * candDeg[i] + param.beta * candMax[i];\n if (param.noise > 0) eval += (rng.nextDouble() * 2.0 - 1.0) * param.noise;\n if (eval > bestScore) {\n bestScore = eval;\n best = candIdx[i];\n }\n }\n if (best == -1) best = candIdx[0];\n\n visited[tile[best]] = 1;\n out.push_back(best);\n addScore += val[best];\n cur = best;\n }\n };\n\n int start = si * N + sj;\n Path best; best.score = -1;\n vector ext; ext.reserve(V);\n\n int initTries = 15;\n for (int t = 0; t < initTries; ++t) {\n Params p = (t == 0) ? Params{15.0, 0.2, 0.0} : randomParams(0.0);\n vector visited(M, 0);\n visited[tile[start]] = 1;\n\n vector nodes; nodes.reserve(V);\n nodes.push_back(start);\n int score = val[start];\n\n int add;\n extend(start, visited, p, ext, add);\n nodes.insert(nodes.end(), ext.begin(), ext.end());\n score += add;\n\n if (score > best.score) {\n best.nodes = nodes;\n best.score = score;\n }\n }\n\n Path current = best;\n\n auto t0 = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 1.9;\n\n while (true) {\n double elapsed = chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n if (elapsed > TIME_LIMIT) break;\n\n int len = current.nodes.size();\n if (len <= 1) break;\n\n int range = len - 1;\n int pos;\n if (range == 1) pos = 0;\n else {\n double r = rng.nextDouble(), r2 = rng.nextDouble();\n if (r < 0.5) pos = range - 1 - (int)(r2 * r2 * range);\n else pos = (int)(r2 * r2 * range);\n pos = max(0, min(pos, range - 1));\n }\n\n vector visited(M, 0);\n int prefixScore = 0;\n for (int i = 0; i <= pos; ++i) {\n int node = current.nodes[i];\n visited[tile[node]] = 1;\n prefixScore += val[node];\n }\n\n Params p = randomParams(elapsed / TIME_LIMIT);\n int add;\n extend(current.nodes[pos], visited, p, ext, add);\n\n int newScore = prefixScore + add;\n bool accept = (newScore >= current.score);\n if (!accept) {\n double prob = 0.1 * (1.0 - elapsed / TIME_LIMIT);\n if (rng.nextDouble() < prob) accept = true;\n }\n bool updateBest = newScore > best.score;\n\n if (accept || updateBest) {\n vector newNodes;\n newNodes.reserve(pos + 1 + ext.size());\n newNodes.insert(newNodes.end(), current.nodes.begin(), current.nodes.begin() + pos + 1);\n newNodes.insert(newNodes.end(), ext.begin(), ext.end());\n\n if (updateBest) {\n best.nodes = newNodes;\n best.score = newScore;\n }\n if (accept) {\n current.nodes = move(newNodes);\n current.score = newScore;\n }\n }\n }\n\n string out;\n for (size_t i = 1; i < best.nodes.size(); ++i) {\n int diff = best.nodes[i] - best.nodes[i-1];\n if (diff == 1) out.push_back('R');\n else if (diff == -1) out.push_back('L');\n else if (diff == N) out.push_back('D');\n else if (diff == -N) out.push_back('U');\n }\n cout << out << \"\\n\";\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int N = 30;\n const double INIT = 5000.0;\n const double BASE_LR = 0.4;\n const double K = 5.0; // blending strength\n const double PRIOR = 1.0; // weight for unobserved edges\n const double EPS0 = 0.05; // exploration noise\n const double MIN_W = 500.0;\n const double MAX_W = 9500.0;\n\n static double h[N][N-1], v[N-1][N];\n static int hc[N][N-1], vc[N-1][N];\n static double wh[N][N-1], wv[N-1][N];\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N-1; ++j)\n h[i][j] = INIT, hc[i][j] = 0;\n for (int i = 0; i < N-1; ++i)\n for (int j = 0; j < N; ++j)\n v[i][j] = INIT, vc[i][j] = 0;\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\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 // compute row/column means (weighted)\n double row_mean[N], col_mean[N];\n for (int i = 0; i < N; ++i) {\n double sum = 0.0, wsum = 0.0;\n for (int j = 0; j < N-1; ++j) {\n double w = hc[i][j] + PRIOR;\n sum += h[i][j] * w;\n wsum += w;\n }\n row_mean[i] = sum / wsum;\n }\n for (int j = 0; j < N; ++j) {\n double sum = 0.0, wsum = 0.0;\n for (int i = 0; i < N-1; ++i) {\n double w = vc[i][j] + PRIOR;\n sum += v[i][j] * w;\n wsum += w;\n }\n col_mean[j] = sum / wsum;\n }\n\n double eps = EPS0 * (1.0 - (double)q / 1000.0);\n uniform_real_distribution noise_dist(-eps, eps);\n\n // effective weights for this query (blend + noise)\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N-1; ++j) {\n double alpha = hc[i][j] / (hc[i][j] + K);\n double base = row_mean[i] * (1.0 - alpha) + h[i][j] * alpha;\n double noise = (eps > 0.0 ? noise_dist(rng) : 0.0);\n wh[i][j] = base * (1.0 + noise);\n }\n }\n for (int i = 0; i < N-1; ++i) {\n for (int j = 0; j < N; ++j) {\n double alpha = vc[i][j] / (vc[i][j] + K);\n double base = col_mean[j] * (1.0 - alpha) + v[i][j] * alpha;\n double noise = (eps > 0.0 ? noise_dist(rng) : 0.0);\n wv[i][j] = base * (1.0 + noise);\n }\n }\n\n // Dijkstra\n const double INF = 1e18;\n vector dist(N*N, INF);\n vector prev(N*N, -1);\n vector prev_dir(N*N);\n\n auto idx = [&](int x, int y){ return x * N + y; };\n int s = idx(si, sj);\n int t = idx(ti, tj);\n\n priority_queue, vector>,\n greater>> pq;\n dist[s] = 0.0;\n pq.push({0.0, s});\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u]) continue;\n if (u == t) break;\n int x = u / N, y = u % N;\n\n // up\n if (x > 0) {\n int vtx = idx(x-1, y);\n double w = wv[x-1][y];\n if (d + w < dist[vtx]) {\n dist[vtx] = d + w;\n prev[vtx] = u;\n prev_dir[vtx] = 'U';\n pq.push({dist[vtx], vtx});\n }\n }\n // down\n if (x + 1 < N) {\n int vtx = idx(x+1, y);\n double w = wv[x][y];\n if (d + w < dist[vtx]) {\n dist[vtx] = d + w;\n prev[vtx] = u;\n prev_dir[vtx] = 'D';\n pq.push({dist[vtx], vtx});\n }\n }\n // left\n if (y > 0) {\n int vtx = idx(x, y-1);\n double w = wh[x][y-1];\n if (d + w < dist[vtx]) {\n dist[vtx] = d + w;\n prev[vtx] = u;\n prev_dir[vtx] = 'L';\n pq.push({dist[vtx], vtx});\n }\n }\n // right\n if (y + 1 < N) {\n int vtx = idx(x, y+1);\n double w = wh[x][y];\n if (d + w < dist[vtx]) {\n dist[vtx] = d + w;\n prev[vtx] = u;\n prev_dir[vtx] = 'R';\n pq.push({dist[vtx], vtx});\n }\n }\n }\n\n // reconstruct path\n string path;\n int cur = t;\n while (cur != s) {\n char d = prev_dir[cur];\n path.push_back(d);\n cur = prev[cur];\n }\n reverse(path.begin(), path.end());\n\n cout << path << endl; // flush\n\n int observed;\n if (!(cin >> observed)) return 0;\n\n // gather edges and predicted length\n struct Edge { bool horiz; int i, j; };\n vector edges;\n edges.reserve(path.size());\n double S = 0.0;\n int cx = si, cy = sj;\n for (char d : path) {\n if (d == 'U') {\n edges.push_back({false, cx-1, cy});\n S += v[cx-1][cy];\n cx--;\n } else if (d == 'D') {\n edges.push_back({false, cx, cy});\n S += v[cx][cy];\n cx++;\n } else if (d == 'L') {\n edges.push_back({true, cx, cy-1});\n S += h[cx][cy-1];\n cy--;\n } else if (d == 'R') {\n edges.push_back({true, cx, cy});\n S += h[cx][cy];\n cy++;\n }\n }\n if (S <= 0.0) continue;\n\n double ratio = observed / S;\n\n // update edges\n for (auto &e : edges) {\n if (e.horiz) {\n int &cnt = hc[e.i][e.j];\n double lr = BASE_LR / sqrt(cnt + 1.0);\n double factor = 1.0 + lr * (ratio - 1.0);\n h[e.i][e.j] *= factor;\n h[e.i][e.j] = min(max(h[e.i][e.j], MIN_W), MAX_W);\n cnt++;\n } else {\n int &cnt = vc[e.i][e.j];\n double lr = BASE_LR / sqrt(cnt + 1.0);\n double factor = 1.0 + lr * (ratio - 1.0);\n v[e.i][e.j] *= factor;\n v[e.i][e.j] = min(max(v[e.i][e.j], MIN_W), MAX_W);\n cnt++;\n }\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n inline uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline int next_int(int mod) {\n return (int)(next() % mod);\n }\n inline double next_double() {\n return (next() >> 11) * (1.0 / (1ULL << 53));\n }\n};\n\nstruct Solver {\n int N, M;\n int maxLen = 0;\n static constexpr int DOT = 8;\n\n struct UString {\n int len;\n array c;\n int freq;\n int occ;\n };\n\n vector us;\n unordered_map id_of;\n vector lens;\n bool usedLen[13]{};\n uint64_t len_prefix[13];\n vector row_base;\n\n vector grid, best_grid;\n int satisfied = 0, best_satisfied = 0;\n RNG rng;\n\n Solver() : rng((uint64_t)chrono::steady_clock::now().time_since_epoch().count()) {}\n\n uint64_t encode(const string &s) {\n uint64_t code = 0;\n for (char ch : s) code = (code << 3) | (uint64_t)(ch - 'A');\n return ((uint64_t)s.size() << 36) | code;\n }\n\n void read_input() {\n cin >> N >> M;\n id_of.reserve(M * 2 + 1);\n id_of.max_load_factor(0.7);\n\n for (int i = 0; i < M; i++) {\n string s;\n cin >> s;\n maxLen = max(maxLen, (int)s.size());\n usedLen[s.size()] = true;\n uint64_t key = encode(s);\n auto it = id_of.find(key);\n if (it == id_of.end()) {\n int id = (int)us.size();\n id_of[key] = id;\n UString u;\n u.len = (int)s.size();\n u.freq = 1;\n u.occ = 0;\n u.c.fill(0);\n for (int k = 0; k < u.len; k++) u.c[k] = (uint8_t)(s[k] - 'A');\n us.push_back(u);\n } else {\n us[it->second].freq++;\n }\n }\n\n for (int len = 2; len <= 12; len++) if (usedLen[len]) lens.push_back(len);\n for (int len = 0; len <= 12; len++) len_prefix[len] = (uint64_t)len << 36;\n\n row_base.resize(N);\n for (int i = 0; i < N; i++) row_base[i] = i * N;\n\n grid.assign(N * N, 0);\n best_grid.assign(N * N, 0);\n }\n\n inline void add_occ(int id, int delta) {\n int before = us[id].occ;\n int after = before + delta;\n us[id].occ = after;\n if (before == 0 && after > 0) satisfied += us[id].freq;\n else if (before > 0 && after == 0) satisfied -= us[id].freq;\n }\n\n inline void update_row(int row, int pos, int delta) {\n int base = row_base[row];\n for (int len : lens) {\n for (int t = 0; t < len; t++) {\n int start = pos - t;\n if (start < 0) start += N;\n uint64_t code = 0;\n int idx = start;\n bool valid = true;\n for (int k = 0; k < len; k++) {\n uint8_t v = grid[base + idx];\n if (v >= DOT) { valid = false; break; }\n code = (code << 3) | v;\n idx++;\n if (idx == N) idx = 0;\n }\n if (!valid) continue;\n uint64_t key = len_prefix[len] | code;\n auto it = id_of.find(key);\n if (it != id_of.end()) add_occ(it->second, delta);\n }\n }\n }\n\n inline void update_col(int col, int pos, int delta) {\n for (int len : lens) {\n for (int t = 0; t < len; t++) {\n int start = pos - t;\n if (start < 0) start += N;\n uint64_t code = 0;\n int idx = start;\n bool valid = true;\n for (int k = 0; k < len; k++) {\n uint8_t v = grid[idx * N + col];\n if (v >= DOT) { valid = false; break; }\n code = (code << 3) | v;\n idx++;\n if (idx == N) idx = 0;\n }\n if (!valid) continue;\n uint64_t key = len_prefix[len] | code;\n auto it = id_of.find(key);\n if (it != id_of.end()) add_occ(it->second, delta);\n }\n }\n }\n\n inline void change_cell(int row, int col, uint8_t newVal) {\n int idx = row_base[row] + col;\n uint8_t oldVal = grid[idx];\n if (oldVal == newVal) return;\n update_row(row, col, -1);\n update_col(col, row, -1);\n grid[idx] = newVal;\n update_row(row, col, +1);\n update_col(col, row, +1);\n }\n\n void recompute_counts() {\n for (auto &u : us) u.occ = 0;\n satisfied = 0;\n\n for (int row = 0; row < N; row++) {\n int base = row_base[row];\n for (int start = 0; start < N; start++) {\n uint64_t code = 0;\n int idx = start;\n for (int len = 1; len <= maxLen; len++) {\n uint8_t v = grid[base + idx];\n if (v >= DOT) break;\n code = (code << 3) | v;\n idx++;\n if (idx == N) idx = 0;\n if (len >= 2 && usedLen[len]) {\n uint64_t key = len_prefix[len] | code;\n auto it = id_of.find(key);\n if (it != id_of.end()) add_occ(it->second, +1);\n }\n }\n }\n }\n\n for (int col = 0; col < N; col++) {\n for (int start = 0; start < N; start++) {\n uint64_t code = 0;\n int idx = start;\n for (int len = 1; len <= maxLen; len++) {\n uint8_t v = grid[idx * N + col];\n if (v >= DOT) break;\n code = (code << 3) | v;\n idx++;\n if (idx == N) idx = 0;\n if (len >= 2 && usedLen[len]) {\n uint64_t key = len_prefix[len] | code;\n auto it = id_of.find(key);\n if (it != id_of.end()) add_occ(it->second, +1);\n }\n }\n }\n }\n }\n\n void random_init() {\n for (int i = 0; i < N * N; i++) grid[i] = rng.next_int(8);\n }\n\n void greedy_init() {\n vector cells(N * N);\n iota(cells.begin(), cells.end(), 0);\n for (int i = (int)cells.size() - 1; i > 0; --i) {\n int j = rng.next_int(i + 1);\n swap(cells[i], cells[j]);\n }\n for (int idx : cells) {\n int row = idx / N, col = idx % N;\n uint8_t cur = grid[idx];\n int bestScore = satisfied;\n uint8_t bestVal = cur;\n for (uint8_t v = 0; v < 8; v++) {\n if (v == cur) continue;\n change_cell(row, col, v);\n if (satisfied > bestScore) {\n bestScore = satisfied;\n bestVal = v;\n }\n change_cell(row, col, cur);\n }\n if (bestVal != cur) change_cell(row, col, bestVal);\n }\n }\n\n int pick_string() {\n int id = rng.next_int((int)us.size());\n for (int t = 0; t < 5; t++) {\n int cand = rng.next_int((int)us.size());\n if (us[cand].occ == 0) return cand;\n id = cand;\n }\n return id;\n }\n\n void simulated_annealing(double time_limit) {\n best_grid = grid;\n best_satisfied = satisfied;\n\n const double T0 = 5.0, T1 = 0.1;\n auto start_time = chrono::steady_clock::now();\n double temp = T0;\n double macro_prob = 0.3;\n int iter = 0;\n\n while (true) {\n if ((iter & 1023) == 0) {\n double elapsed = chrono::duration(chrono::steady_clock::now() - start_time).count();\n if (elapsed > time_limit) break;\n double t = elapsed / time_limit;\n temp = T0 + (T1 - T0) * t;\n if (temp < 1e-9) temp = 1e-9;\n macro_prob = 0.3 * (1.0 - t);\n }\n iter++;\n\n if (rng.next_double() < macro_prob) {\n int id = pick_string();\n int L = us[id].len;\n int sr = rng.next_int(N);\n int sc = rng.next_int(N);\n bool vertical = rng.next_int(2);\n int prev = satisfied;\n\n uint8_t oldvals[12];\n int rs[12], cs[12];\n for (int p = 0; p < L; p++) {\n int r = vertical ? (sr + p) % N : sr;\n int c = vertical ? sc : (sc + p) % N;\n rs[p] = r; cs[p] = c;\n int idx = row_base[r] + c;\n oldvals[p] = grid[idx];\n uint8_t desired = us[id].c[p];\n if (oldvals[p] != desired) change_cell(r, c, desired);\n }\n\n int delta = satisfied - prev;\n bool accept = (delta >= 0) || (rng.next_double() < exp(delta / temp));\n if (!accept) {\n for (int p = 0; p < L; p++) {\n int r = rs[p], c = cs[p];\n int idx = row_base[r] + c;\n if (grid[idx] != oldvals[p]) change_cell(r, c, oldvals[p]);\n }\n }\n } else {\n int idx = rng.next_int(N * N);\n int row = idx / N, col = idx % N;\n uint8_t oldVal = grid[idx];\n uint8_t newVal = rng.next_int(8);\n if (newVal == oldVal) continue;\n int prev = satisfied;\n change_cell(row, col, newVal);\n int delta = satisfied - prev;\n if (delta < 0 && rng.next_double() >= exp(delta / temp)) {\n change_cell(row, col, oldVal);\n }\n }\n\n if (satisfied > best_satisfied) {\n best_satisfied = satisfied;\n best_grid = grid;\n }\n }\n }\n\n void remove_cells() {\n vector cells(N * N);\n iota(cells.begin(), cells.end(), 0);\n bool changed = true;\n while (changed) {\n changed = false;\n for (int i = (int)cells.size() - 1; i > 0; --i) {\n int j = rng.next_int(i + 1);\n swap(cells[i], cells[j]);\n }\n for (int idx : cells) {\n if (grid[idx] == DOT) continue;\n int row = idx / N, col = idx % N;\n uint8_t oldVal = grid[idx];\n change_cell(row, col, DOT);\n if (satisfied == M) {\n changed = true;\n } else {\n change_cell(row, col, oldVal);\n }\n }\n }\n best_grid = grid;\n }\n\n void output_grid(const vector &g) {\n for (int i = 0; i < N; i++) {\n string line;\n line.reserve(N);\n for (int j = 0; j < N; j++) {\n uint8_t v = g[i * N + j];\n if (v == DOT) line.push_back('.');\n else line.push_back(char('A' + v));\n }\n cout << line << '\\n';\n }\n }\n\n void solve() {\n random_init();\n recompute_counts();\n greedy_init();\n simulated_annealing(2.7); // time budget\n\n grid = best_grid;\n recompute_counts();\n if (satisfied == M) {\n remove_cells();\n }\n\n output_grid(best_grid);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Solver solver;\n solver.read_input();\n solver.solve();\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n\n // Map road cells to indices\n vector> id(N, vector(N, -1));\n vector> pos;\n vector weight;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n int idx = (int)pos.size();\n id[i][j] = idx;\n pos.push_back({i, j});\n weight.push_back(grid[i][j] - '0');\n }\n }\n }\n int R = (int)pos.size();\n int startId = id[si][sj];\n\n // Neighbor list\n vector> neigh(R);\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n for (int u = 0; u < R; u++) {\n auto [x, y] = pos[u];\n for (int d = 0; d < 4; d++) {\n int nx = x + di[d], ny = y + dj[d];\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n int v = id[nx][ny];\n if (v != -1) neigh[u].push_back(v);\n }\n }\n\n // Row segments\n vector rowSegOf(R), colSegOf(R);\n vector> rowSegCells, colSegCells;\n\n for (int i = 0; i < N; i++) {\n int j = 0;\n while (j < N) {\n if (grid[i][j] == '#') { j++; continue; }\n int seg = (int)rowSegCells.size();\n rowSegCells.push_back({});\n while (j < N && grid[i][j] != '#') {\n int cid = id[i][j];\n rowSegOf[cid] = seg;\n rowSegCells[seg].push_back(cid);\n j++;\n }\n }\n }\n\n // Column segments\n for (int j = 0; j < N; j++) {\n int i = 0;\n while (i < N) {\n if (grid[i][j] == '#') { i++; continue; }\n int seg = (int)colSegCells.size();\n colSegCells.push_back({});\n while (i < N && grid[i][j] != '#') {\n int cid = id[i][j];\n colSegOf[cid] = seg;\n colSegCells[seg].push_back(cid);\n i++;\n }\n }\n }\n\n // Greedy coverage\n vector rowRemain(rowSegCells.size()), colRemain(colSegCells.size());\n for (int s = 0; s < (int)rowSegCells.size(); s++) rowRemain[s] = rowSegCells[s].size();\n for (int s = 0; s < (int)colSegCells.size(); s++) colRemain[s] = colSegCells[s].size();\n\n vector covered(R, false);\n int uncovered = R;\n vector selected;\n\n while (uncovered > 0) {\n int bestId = -1, bestGain = -1;\n for (int cid = 0; cid < R; cid++) {\n int gain = rowRemain[rowSegOf[cid]] + colRemain[colSegOf[cid]];\n if (!covered[cid]) gain -= 1;\n if (gain > bestGain) {\n bestGain = gain;\n bestId = cid;\n }\n }\n if (bestGain <= 0 || bestId == -1) break;\n\n selected.push_back(bestId);\n\n int rs = rowSegOf[bestId];\n for (int cid : rowSegCells[rs]) {\n if (!covered[cid]) {\n covered[cid] = true;\n uncovered--;\n rowRemain[rowSegOf[cid]]--;\n colRemain[colSegOf[cid]]--;\n }\n }\n int cs = colSegOf[bestId];\n for (int cid : colSegCells[cs]) {\n if (!covered[cid]) {\n covered[cid] = true;\n uncovered--;\n rowRemain[rowSegOf[cid]]--;\n colRemain[colSegOf[cid]]--;\n }\n }\n }\n\n // Targets: start + selected\n vector targets;\n vector isTarget(R, false);\n targets.push_back(startId);\n isTarget[startId] = true;\n for (int cid : selected) {\n if (!isTarget[cid]) {\n targets.push_back(cid);\n isTarget[cid] = true;\n }\n }\n\n int K = (int)targets.size();\n const int INF = 1e9;\n\n auto dijkstra_dist = [&](int start) {\n vector dist(R, INF);\n using P = pair;\n priority_queue, greater

> pq;\n dist[start] = 0;\n pq.push({0, start});\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n for (int v : neigh[u]) {\n int nd = d + weight[v];\n if (nd < dist[v]) {\n dist[v] = nd;\n pq.push({nd, v});\n }\n }\n }\n return dist;\n };\n\n // Distance matrix\n vector> distMat(K, vector(K, INF));\n for (int i = 0; i < K; i++) {\n auto dist = dijkstra_dist(targets[i]);\n for (int j = 0; j < K; j++) distMat[i][j] = dist[targets[j]];\n }\n\n // MST (Prim)\n vector parent(K, -1), minc(K, INF);\n vector used(K, false);\n minc[0] = 0;\n for (int iter = 0; iter < K; iter++) {\n int u = -1, best = INF;\n for (int i = 0; i < K; i++) if (!used[i] && minc[i] < best) {\n best = minc[i];\n u = i;\n }\n if (u == -1) break;\n used[u] = true;\n for (int v = 0; v < K; v++) {\n if (!used[v] && distMat[u][v] < minc[v]) {\n minc[v] = distMat[u][v];\n parent[v] = u;\n }\n }\n }\n\n vector> tree(K);\n for (int v = 1; v < K; v++) {\n int p = parent[v];\n if (p >= 0) {\n tree[p].push_back(v);\n tree[v].push_back(p);\n }\n }\n\n // DFS order\n vector order;\n order.push_back(0);\n function dfs = [&](int u, int p) {\n for (int v : tree[u]) if (v != p) {\n order.push_back(v);\n dfs(v, u);\n order.push_back(u);\n }\n };\n dfs(0, -1);\n\n auto dijkstra_path = [&](int start, int goal) {\n vector dist(R, INF), prev(R, -1);\n using P = pair;\n priority_queue, greater

> pq;\n dist[start] = 0;\n pq.push({0, start});\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n if (u == goal) break;\n for (int v : neigh[u]) {\n int nd = d + weight[v];\n if (nd < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.push({nd, v});\n }\n }\n }\n vector path;\n if (start == goal) { path.push_back(start); return path; }\n if (prev[goal] == -1) { path.push_back(start); return path; }\n int cur = goal;\n while (cur != start) {\n path.push_back(cur);\n cur = prev[cur];\n }\n path.push_back(start);\n reverse(path.begin(), path.end());\n return path;\n };\n\n // Build final route\n string ans;\n ans.reserve(200000);\n for (size_t i = 0; i + 1 < order.size(); i++) {\n int src = targets[order[i]];\n int dst = targets[order[i+1]];\n if (src == dst) continue;\n auto path = dijkstra_path(src, dst);\n for (size_t k = 0; k + 1 < path.size(); k++) {\n auto [x1, y1] = pos[path[k]];\n auto [x2, y2] = pos[path[k+1]];\n if (x2 == x1 - 1) ans.push_back('U');\n else if (x2 == x1 + 1) ans.push_back('D');\n else if (y2 == y1 - 1) ans.push_back('L');\n else if (y2 == y1 + 1) ans.push_back('R');\n }\n }\n\n cout << ans << \"\\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) cin >> d[i][k];\n }\n\n vector> out(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 out[u].push_back(v);\n indeg[v]++;\n }\n\n // difficulty (sum of requirements)\n vector difficulty(N, 0);\n vector avg(K, 0.0);\n for (int i = 0; i < N; ++i) {\n int sum = 0;\n for (int k = 0; k < K; ++k) {\n sum += d[i][k];\n avg[k] += d[i][k];\n }\n difficulty[i] = sum;\n }\n for (int k = 0; k < K; ++k) avg[k] /= N;\n\n // critical path length (depth)\n vector depth(N, 1);\n for (int i = N - 1; i >= 0; --i) {\n int mx = 0;\n for (int v : out[i]) mx = max(mx, depth[v]);\n depth[i] = mx + 1;\n }\n\n // skill estimation\n vector> skill(M, vector(K));\n double init_factor = 0.8;\n for (int j = 0; j < M; ++j) {\n for (int k = 0; k < K; ++k) skill[j][k] = avg[k] * init_factor;\n }\n\n vector state(N, -1); // -1: not started, 0: in progress, 1: done\n vector rem = indeg;\n\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector done_cnt(M, 0);\n\n auto predict_time = [&](int w, int task) -> double {\n double wsum = 0.0;\n for (int k = 0; k < K; ++k) {\n double diff = d[task][k] - skill[w][k];\n if (diff > 0) wsum += diff;\n }\n return max(1.0, wsum);\n };\n\n auto update_skill = [&](int w, int task, int actual_time) {\n auto &s = skill[w];\n vector diff(K);\n double w_hat = 0.0;\n for (int k = 0; k < K; ++k) {\n diff[k] = d[task][k] - s[k];\n if (diff[k] > 0) w_hat += diff[k];\n }\n\n double target = (actual_time == 1 ? 0.0 : (double)actual_time);\n double e = w_hat - target;\n\n int cnt = ++done_cnt[w];\n double base_lr = 1.0;\n double lr = base_lr / sqrt((double)cnt);\n\n double tau = 2.0;\n double sumW = 0.0;\n vector weight(K);\n for (int k = 0; k < K; ++k) {\n double wgt = 1.0 / (1.0 + exp(-diff[k] / tau));\n weight[k] = wgt;\n sumW += wgt;\n }\n if (sumW < 1e-6) sumW = 1e-6;\n\n double coeff = lr * e / sumW;\n double max_skill = 100.0;\n for (int k = 0; k < K; ++k) {\n s[k] += coeff * weight[k];\n s[k] = max(0.0, min(max_skill, s[k]));\n }\n };\n\n auto cmp = [&](int a, int b) {\n if (depth[a] != depth[b]) return depth[a] > depth[b];\n if (difficulty[a] != difficulty[b]) return difficulty[a] > difficulty[b];\n return a < b;\n };\n\n int day = 1;\n while (true) {\n // available tasks\n vector available;\n for (int i = 0; i < N; ++i) {\n if (state[i] == -1 && rem[i] == 0) available.push_back(i);\n }\n\n // free workers\n vector free_workers;\n for (int j = 0; j < M; ++j) {\n if (current_task[j] == -1) free_workers.push_back(j);\n }\n\n vector> assign;\n if (!available.empty() && !free_workers.empty()) {\n sort(available.begin(), available.end(), cmp);\n\n for (int task : available) {\n if (free_workers.empty()) break;\n int best_idx = -1;\n double best_time = 1e18;\n for (int i = 0; i < (int)free_workers.size(); ++i) {\n int w = free_workers[i];\n double t = predict_time(w, task);\n if (t < best_time) {\n best_time = t;\n best_idx = i;\n }\n }\n int w = free_workers[best_idx];\n assign.emplace_back(w, task);\n\n free_workers[best_idx] = free_workers.back();\n free_workers.pop_back();\n\n current_task[w] = task;\n start_day[w] = day;\n state[task] = 0;\n }\n }\n\n // output\n cout << assign.size();\n for (auto &p : assign) {\n cout << \" \" << p.first + 1 << \" \" << p.second + 1;\n }\n cout << \"\\n\" << flush;\n\n int n;\n if (!(cin >> n)) return 0;\n if (n == -1) break;\n\n for (int i = 0; i < n; ++i) {\n int w; cin >> w; --w;\n int task = current_task[w];\n int duration = day - start_day[w] + 1;\n\n update_skill(w, task, duration);\n\n current_task[w] = -1;\n state[task] = 1;\n for (int v : out[task]) rem[v]--;\n }\n\n day++;\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int ax, ay, cx, cy, id;\n};\n\nstruct Node {\n int idx;\n bool pickup; // true = restaurant, false = destination\n};\n\nstruct RNG {\n uint32_t x;\n RNG(uint32_t seed = 123456789u) : x(seed) {}\n uint32_t next() {\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n }\n int randint(int l, int r) { return l + (next() % (r - l + 1)); }\n double randdouble() { return (double)next() / 4294967296.0; }\n};\n\nstatic const int OFFICE_X = 400;\nstatic const int OFFICE_Y = 400;\n\nvector px, py, dx, dy;\n\ninline int manhattan(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nlong long calcCost(const vector& seq) {\n int x = OFFICE_X, y = OFFICE_Y;\n long long cost = 0;\n for (const auto& node : seq) {\n int nx = node.pickup ? px[node.idx] : dx[node.idx];\n int ny = node.pickup ? py[node.idx] : dy[node.idx];\n cost += abs(x - nx) + abs(y - ny);\n x = nx; y = ny;\n }\n cost += abs(x - OFFICE_X) + abs(y - OFFICE_Y);\n return cost;\n}\n\nvector nearestPickup(int M) {\n vector order; order.reserve(M);\n vector used(M, false);\n int x = OFFICE_X, y = OFFICE_Y;\n for (int step = 0; step < M; ++step) {\n int best = -1, bestDist = 1e9;\n for (int i = 0; i < M; ++i) if (!used[i]) {\n int d = abs(x - px[i]) + abs(y - py[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n used[best] = true;\n order.push_back(best);\n x = px[best]; y = py[best];\n }\n return order;\n}\n\nvector nearestDelivery(int M, int sx, int sy) {\n vector order; order.reserve(M);\n vector used(M, false);\n int x = sx, y = sy;\n for (int step = 0; step < M; ++step) {\n int best = -1, bestDist = 1e9;\n for (int i = 0; i < M; ++i) if (!used[i]) {\n int d = abs(x - dx[i]) + abs(y - dy[i]);\n if (d < bestDist) { bestDist = d; best = i; }\n }\n used[best] = true;\n order.push_back(best);\n x = dx[best]; y = dy[best];\n }\n return order;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector orders(1000);\n for (int i = 0; i < 1000; ++i) {\n if (!(cin >> orders[i].ax >> orders[i].ay >> orders[i].cx >> orders[i].cy)) return 0;\n orders[i].id = i + 1;\n }\n\n // Select 50 orders with smallest estimated single-order cost\n vector cost(1000);\n for (int i = 0; i < 1000; ++i) {\n cost[i] = manhattan(OFFICE_X, OFFICE_Y, orders[i].ax, orders[i].ay)\n + manhattan(orders[i].ax, orders[i].ay, orders[i].cx, orders[i].cy)\n + manhattan(orders[i].cx, orders[i].cy, OFFICE_X, OFFICE_Y);\n }\n vector idx(1000);\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(), [&](int a, int b) {\n if (cost[a] != cost[b]) return cost[a] < cost[b];\n return a < b;\n });\n\n vector sel;\n sel.reserve(50);\n for (int i = 0; i < 50; ++i) sel.push_back(orders[idx[i]]);\n int M = (int)sel.size();\n\n px.resize(M); py.resize(M); dx.resize(M); dy.resize(M);\n for (int i = 0; i < M; ++i) {\n px[i] = sel[i].ax; py[i] = sel[i].ay;\n dx[i] = sel[i].cx; dy[i] = sel[i].cy;\n }\n\n vector pickOrder = nearestPickup(M);\n int lastIdx = pickOrder.back();\n vector delOrder = nearestDelivery(M, px[lastIdx], py[lastIdx]);\n\n vector seq; seq.reserve(2 * M);\n for (int id : pickOrder) seq.push_back({id, true});\n for (int id : delOrder) seq.push_back({id, false});\n\n // Position arrays\n vector posPick(M), posDel(M);\n for (int i = 0; i < 2 * M; ++i) {\n if (seq[i].pickup) posPick[seq[i].idx] = i;\n else posDel[seq[i].idx] = i;\n }\n\n long long currCost = calcCost(seq);\n long long bestCost = currCost;\n vector bestSeq = seq;\n\n RNG rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());\n int ITER = 100000;\n double T0 = 1000.0, T1 = 1.0;\n\n vector newSeq;\n newSeq.reserve(seq.size());\n\n for (int iter = 0; iter < ITER; ++iter) {\n double t = (double)iter / ITER;\n double T = T0 + (T1 - T0) * t;\n\n int i = rng.randint(0, 2 * M - 1);\n Node node = seq[i];\n int order = node.idx;\n\n int minPos, maxPos;\n if (node.pickup) {\n int dpos = posDel[order];\n int dpos2 = dpos - 1;\n minPos = 0;\n maxPos = dpos2;\n } else {\n int ppos = posPick[order];\n minPos = ppos + 1;\n maxPos = 2 * M - 1;\n }\n if (minPos > maxPos) continue;\n\n int j = rng.randint(minPos, maxPos);\n if (j == i) continue;\n\n newSeq = seq;\n Node tmp = newSeq[i];\n newSeq.erase(newSeq.begin() + i);\n newSeq.insert(newSeq.begin() + j, tmp);\n\n long long newCost = calcCost(newSeq);\n long long delta = newCost - currCost;\n\n bool accept = false;\n if (delta <= 0) accept = true;\n else if (exp(-(double)delta / T) > rng.randdouble()) accept = true;\n\n if (accept) {\n seq.swap(newSeq);\n currCost = newCost;\n for (int k = 0; k < 2 * M; ++k) {\n if (seq[k].pickup) posPick[seq[k].idx] = k;\n else posDel[seq[k].idx] = k;\n }\n if (currCost < bestCost) {\n bestCost = currCost;\n bestSeq = seq;\n }\n }\n }\n\n // Output\n cout << M;\n for (int i = 0; i < M; ++i) cout << \" \" << sel[i].id;\n cout << \"\\n\";\n\n int n = (int)bestSeq.size() + 2;\n cout << n << \" \" << OFFICE_X << \" \" << OFFICE_Y;\n for (const auto& node : bestSeq) {\n int x = node.pickup ? px[node.idx] : dx[node.idx];\n int y = node.pickup ? py[node.idx] : dy[node.idx];\n cout << \" \" << x << \" \" << y;\n }\n cout << \" \" << OFFICE_X << \" \" << OFFICE_Y << \"\\n\";\n\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct DSU {\n vector p, sz;\n int comp;\n DSU(int n=0){ init(n); }\n void init(int n){\n p.assign(n, -1);\n sz.assign(n, 1);\n comp = n;\n }\n int find(int x){\n if(p[x]==-1) return x;\n return p[x]=find(p[x]);\n }\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(sz[a] x(N), y(N);\n for(int i=0;i>x[i]>>y[i])) return 0;\n }\n vector u(M), v(M);\n for(int i=0;i>u[i]>>v[i];\n\n // compute d_i\n vector d(M);\n for(int i=0;i ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a,int b){\n if(d[a]!=d[b]) return d[a] in_mst(M,false);\n int cnt=0;\n for(int id: ord){\n if(mst.unite(u[id], v[id])){\n in_mst[id]=true;\n if(++cnt==N-1) break;\n }\n }\n\n DSU dsu(N);\n\n // heuristic params\n const double ALPHA = 0.30;\n const double MIN_ADJ = 0.8;\n const double MAX_ADJ = 1.25;\n const double MST_FACTOR = 1.10;\n\n for(int i=0;i>l)) break;\n int decision = 0;\n\n if(dsu.comp==1){\n decision = 0;\n } else {\n int ru = dsu.find(u[i]);\n int rv = dsu.find(v[i]);\n if(ru==rv){\n decision = 0;\n } else {\n // build root array and component IDs\n vector root(N);\n for(int vtx=0; vtx comp_id(N, -1);\n int C=0;\n for(int vtx=0; vtx1.0) base_p=1.0;\n double r_base = 1.0 + 2.0 * base_p;\n\n double mean_d = (double)sum_d / remain;\n double adj = pow(mean_d / (double)d[i], ALPHA);\n if(adjMAX_ADJ) adj=MAX_ADJ;\n\n double r_th = r_base * adj;\n if(in_mst[i]) r_th *= MST_FACTOR;\n if(r_th<1.0) r_th = 1.0;\n if(r_th>3.0) r_th = 3.0;\n\n if((double)l <= r_th * (double)d[i]){\n decision = 1;\n dsu.unite(ru, rv);\n } else {\n decision = 0;\n }\n }\n }\n }\n\n cout << decision << \"\\n\" << flush;\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nstruct Wall {\n int wx, wy; // wall cell\n int bx, by; // inside adjacent cell\n char act; // lowercase: block direction from inside\n bool gate;\n};\n\nconst int H = 30, W = 30;\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char moveChar[4] = {'U', 'D', 'L', 'R'};\n\nchar bfs_move(int sx, int sy, int tx, int ty,\n const bool blocked[30][30],\n const bool will_block[30][30]) {\n if (sx == tx && sy == ty) return '.';\n if (blocked[tx][ty] || will_block[tx][ty]) return '.';\n\n static int dist[30][30];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) dist[i][j] = -1;\n\n queue> q;\n dist[tx][ty] = 0;\n q.push({tx, ty});\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 + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= H || ny < 0 || ny >= W) continue;\n if (blocked[nx][ny] || will_block[nx][ny]) continue;\n if (dist[nx][ny] == -1) {\n dist[nx][ny] = dist[x][y] + 1;\n q.push({nx, ny});\n }\n }\n }\n if (dist[sx][sy] == -1) return '.';\n\n int bestDir = -1;\n int bestDist = dist[sx][sy];\n for (int d = 0; d < 4; d++) {\n int nx = sx + dx[d], ny = sy + dy[d];\n if (nx < 0 || nx >= H || ny < 0 || ny >= W) continue;\n if (dist[nx][ny] != -1 && dist[nx][ny] < bestDist) {\n bestDist = dist[nx][ny];\n bestDir = d;\n }\n }\n if (bestDir == -1) return '.';\n return moveChar[bestDir];\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 px(N), py(N), pt(N);\n for (int i = 0; i < N; i++) {\n cin >> px[i] >> py[i] >> pt[i];\n px[i]--; py[i]--;\n }\n int M; cin >> M;\n vector hx(M), hy(M);\n for (int i = 0; i < M; i++) {\n cin >> hx[i] >> hy[i];\n hx[i]--; hy[i]--;\n }\n\n // Choose best corner region\n int bestS = 8, bestCorner = 0;\n double bestScore = -1.0;\n int Smin = 8, Smax = 20;\n\n for (int S = Smin; S <= Smax; S++) {\n for (int corner = 0; corner < 4; corner++) {\n int x1, x2, y1, y2;\n if (corner == 0) { x1 = 0; x2 = S-1; y1 = 0; y2 = S-1; }\n if (corner == 1) { x1 = 0; x2 = S-1; y1 = 30-S; y2 = 29; }\n if (corner == 2) { x1 = 30-S; x2 = 29; y1 = 0; y2 = S-1; }\n if (corner == 3) { x1 = 30-S; x2 = 29; y1 = 30-S; y2 = 29; }\n\n int cnt = 0;\n for (int i = 0; i < N; i++) {\n if (x1 <= px[i] && px[i] <= x2 && y1 <= py[i] && py[i] <= y2)\n cnt++;\n }\n double val = (double)(S*S) / 900.0 * pow(0.5, cnt);\n if (val > bestScore) {\n bestScore = val;\n bestS = S;\n bestCorner = corner;\n }\n }\n }\n\n // define region\n int x1, x2, y1, y2;\n if (bestCorner == 0) { x1 = 0; x2 = bestS-1; y1 = 0; y2 = bestS-1; }\n if (bestCorner == 1) { x1 = 0; x2 = bestS-1; y1 = 30-bestS; y2 = 29; }\n if (bestCorner == 2) { x1 = 30-bestS; x2 = 29; y1 = 0; y2 = bestS-1; }\n if (bestCorner == 3) { x1 = 30-bestS; x2 = 29; y1 = 30-bestS; y2 = 29; }\n\n auto inside = [&](int x, int y) {\n return x1 <= x && x <= x2 && y1 <= y && y <= y2;\n };\n int cx = (x1 + x2) / 2;\n int cy = (y1 + y2) / 2;\n\n // Build wall list\n vector walls;\n auto add_wall = [&](int wx, int wy, int bx, int by, char act) {\n walls.push_back({wx, wy, bx, by, act, false});\n };\n\n if (x1 == 0) {\n int row = x2 + 1;\n for (int y = y1; y <= y2; y++) add_wall(row, y, x2, y, 'd');\n } else {\n int row = x1 - 1;\n for (int y = y1; y <= y2; y++) add_wall(row, y, x1, y, 'u');\n }\n if (y1 == 0) {\n int col = y2 + 1;\n for (int x = x1; x <= x2; x++) add_wall(x, col, x, y2, 'r');\n } else {\n int col = y1 - 1;\n for (int x = x1; x <= x2; x++) add_wall(x, col, x, y1, 'l');\n }\n\n // Choose gate farthest from pets\n if (!walls.empty()) {\n int gate_idx = 0;\n int bestDist = -1;\n for (int i = 0; i < (int)walls.size(); i++) {\n int mind = 1e9;\n for (int j = 0; j < N; j++) {\n mind = min(mind, abs(walls[i].wx - px[j]) + abs(walls[i].wy - py[j]));\n }\n if (mind > bestDist) {\n bestDist = mind;\n gate_idx = i;\n }\n }\n walls[gate_idx].gate = true;\n }\n\n static bool blocked[30][30] = {};\n vector target(M, -1);\n\n for (int turn = 0; turn < 300; turn++) {\n bool pet_at[30][30] = {};\n bool pet_adj[30][30] = {};\n bool human_at[30][30] = {};\n\n for (int i = 0; i < N; i++) pet_at[px[i]][py[i]] = true;\n for (int i = 0; i < N; i++) {\n for (int d = 0; d < 4; d++) {\n int nx = px[i] + dx[d], ny = py[i] + dy[d];\n if (0 <= nx && nx < 30 && 0 <= ny && ny < 30)\n pet_adj[nx][ny] = true;\n }\n }\n for (int i = 0; i < M; i++) human_at[hx[i]][hy[i]] = true;\n\n bool all_inside = true;\n for (int i = 0; i < M; i++) if (!inside(hx[i], hy[i])) all_inside = false;\n bool allow_gate = all_inside;\n\n auto can_block = [&](const Wall &w) {\n if (blocked[w.wx][w.wy]) return false;\n if (pet_at[w.wx][w.wy] || human_at[w.wx][w.wy]) return false;\n if (pet_adj[w.wx][w.wy]) return false;\n return true;\n };\n\n for (int i = 0; i < M; i++) {\n if (!inside(hx[i], hy[i])) {\n target[i] = -1;\n continue;\n }\n if (target[i] != -1) {\n if (blocked[walls[target[i]].wx][walls[target[i]].wy]) target[i] = -1;\n else if (walls[target[i]].gate && !allow_gate) target[i] = -1;\n }\n }\n\n vector candidates;\n for (int i = 0; i < (int)walls.size(); i++) {\n if (blocked[walls[i].wx][walls[i].wy]) continue;\n if (walls[i].gate && !allow_gate) continue;\n candidates.push_back(i);\n }\n\n vector used(walls.size(), false);\n for (int i = 0; i < M; i++) if (target[i] != -1) used[target[i]] = true;\n\n for (int i = 0; i < M; i++) {\n if (!inside(hx[i], hy[i]) || target[i] != -1) continue;\n int best = -1, bestDist = 1e9;\n for (int idx : candidates) {\n if (used[idx]) continue;\n int d = abs(hx[i] - walls[idx].bx) + abs(hy[i] - walls[idx].by);\n if (d < bestDist) {\n bestDist = d;\n best = idx;\n }\n }\n if (best != -1) {\n target[i] = best;\n used[best] = true;\n }\n }\n\n vector action(M, '.');\n bool will_block[30][30] = {};\n\n for (int i = 0; i < M; i++) {\n if (target[i] == -1 || !inside(hx[i], hy[i])) continue;\n Wall &w = walls[target[i]];\n if (hx[i] == w.bx && hy[i] == w.by) {\n if (can_block(w)) {\n action[i] = w.act;\n will_block[w.wx][w.wy] = true;\n }\n }\n }\n\n for (int i = 0; i < M; i++) {\n if (action[i] != '.') continue;\n int tx = cx, ty = cy;\n if (inside(hx[i], hy[i]) && target[i] != -1) {\n tx = walls[target[i]].bx;\n ty = walls[target[i]].by;\n }\n char mv = bfs_move(hx[i], hy[i], tx, ty, blocked, will_block);\n action[i] = mv;\n }\n\n string out(M, '.');\n for (int i = 0; i < M; i++) out[i] = action[i];\n cout << out << \"\\n\" << flush;\n\n vector moves(N);\n for (int i = 0; i < N; i++) {\n if (!(cin >> moves[i])) return 0;\n }\n\n for (int i = 0; i < M; i++) {\n char a = action[i];\n if (a == 'U') hx[i]--;\n else if (a == 'D') hx[i]++;\n else if (a == 'L') hy[i]--;\n else if (a == 'R') hy[i]++;\n }\n\n for (int i = 0; i < 30; i++) for (int j = 0; j < 30; j++) {\n if (will_block[i][j]) blocked[i][j] = true;\n }\n\n for (int i = 0; i < N; i++) {\n for (char c : moves[i]) {\n if (c == '.') break;\n if (c == 'U') px[i]--;\n else if (c == 'D') px[i]++;\n else if (c == 'L') py[i]--;\n else if (c == 'R') py[i]++;\n }\n }\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nconstexpr int N = 20;\nconstexpr int V = N * N;\nconstexpr int L = 200;\nconstexpr int BEAM_WIDTH = 100;\n\nstruct BeamState {\n array prob;\n double g;\n};\n\nstruct Node {\n array prob;\n double g, f;\n int parent;\n char act;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n\n vector h(N);\n for (int i = 0; i < N; i++) cin >> h[i];\n vector v(N - 1);\n for (int i = 0; i < N - 1; i++) cin >> v[i];\n\n int start = si * N + sj;\n int target = ti * N + tj;\n double q = 1.0 - p;\n\n // Precompute neighbors\n int nxt[4][V];\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int id = i * N + j;\n // U\n if (i == 0 || v[i - 1][j] == '1') nxt[0][id] = id;\n else nxt[0][id] = id - N;\n // D\n if (i == N - 1 || v[i][j] == '1') nxt[1][id] = id;\n else nxt[1][id] = id + N;\n // L\n if (j == 0 || h[i][j - 1] == '1') nxt[2][id] = id;\n else nxt[2][id] = id - 1;\n // R\n if (j == N - 1 || h[i][j] == '1') nxt[3][id] = id;\n else nxt[3][id] = id + 1;\n }\n }\n\n array reward;\n for (int t = 1; t <= L; t++) reward[t] = 401.0 - t;\n\n // DP for fully-observable optimal value\n vector> Vval(L + 2);\n Vval[L + 1].fill(0.0);\n\n for (int t = L; t >= 1; --t) {\n auto &Vt = Vval[t];\n auto &Vn = Vval[t + 1];\n for (int id = 0; id < V; ++id) {\n if (id == target) {\n Vt[id] = 0.0;\n continue;\n }\n double best = -1e100;\n for (int a = 0; a < 4; ++a) {\n int id2 = nxt[a][id];\n double val = p * Vn[id];\n if (id2 == target) val += q * reward[t];\n else val += q * Vn[id2];\n best = max(best, val);\n }\n Vt[id] = best;\n }\n }\n\n // Beam search\n vector beam;\n beam.reserve(BEAM_WIDTH);\n BeamState init;\n init.prob.fill(0.0);\n init.prob[start] = 1.0;\n init.g = 0.0;\n beam.push_back(init);\n\n vector> parent(L + 1);\n vector> act(L + 1);\n\n const char DIR[4] = {'U', 'D', 'L', 'R'};\n double w = 1.0 - p / 2.0;\n\n for (int t = 1; t <= L; ++t) {\n vector best;\n best.reserve(BEAM_WIDTH);\n\n int min_idx = -1;\n double min_f = 0.0;\n\n for (int i = 0; i < (int)beam.size(); ++i) {\n const auto &state = beam[i];\n for (int a = 0; a < 4; ++a) {\n Node node;\n node.parent = i;\n node.act = DIR[a];\n node.prob.fill(0.0);\n double reward_add = 0.0;\n\n for (int id = 0; id < V; ++id) {\n double prob = state.prob[id];\n if (prob == 0.0) continue;\n node.prob[id] += prob * p;\n int id2 = nxt[a][id];\n double move = prob * q;\n if (id2 == target) reward_add += move * reward[t];\n else node.prob[id2] += move;\n }\n\n node.g = state.g + reward_add;\n\n double hval = 0.0;\n const auto &Vn = Vval[t + 1];\n for (int id = 0; id < V; ++id) {\n double prob = node.prob[id];\n if (prob != 0.0) hval += prob * Vn[id];\n }\n node.f = node.g + w * hval;\n\n if ((int)best.size() < BEAM_WIDTH) {\n best.push_back(node);\n if (min_idx == -1 || node.f < min_f) {\n min_f = node.f;\n min_idx = (int)best.size() - 1;\n }\n } else if (node.f > min_f) {\n best[min_idx] = node;\n min_f = best[0].f;\n min_idx = 0;\n for (int k = 1; k < BEAM_WIDTH; ++k) {\n if (best[k].f < min_f) {\n min_f = best[k].f;\n min_idx = k;\n }\n }\n }\n }\n }\n\n beam.clear();\n beam.reserve(best.size());\n for (int i = 0; i < (int)best.size(); ++i) {\n BeamState bs;\n bs.prob = best[i].prob;\n bs.g = best[i].g;\n beam.push_back(std::move(bs));\n parent[t][i] = best[i].parent;\n act[t][i] = best[i].act;\n }\n }\n\n // Pick best final candidate\n int best_idx = 0;\n double best_g = beam[0].g;\n for (int i = 1; i < (int)beam.size(); ++i) {\n if (beam[i].g > best_g) {\n best_g = beam[i].g;\n best_idx = i;\n }\n }\n\n // Reconstruct answer\n string answer(L, 'U');\n int idx = best_idx;\n for (int t = L; t >= 1; --t) {\n answer[t - 1] = act[t][idx];\n idx = parent[t][idx];\n }\n\n cout << answer << \"\\n\";\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconstexpr int N = 30;\nconstexpr int di[4] = {0, -1, 0, 1};\nconstexpr int dj[4] = {-1, 0, 1, 0};\n\n// to[t][d] : direction to go if a train enters tile t from direction d\nint toDir[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\nint baseTile[N][N];\nint rotType[8][4];\nbool hasEdge[8][4];\n\nint curType[N][N];\nint rotCnt[N][N];\nint bestRot[N][N];\n\nstruct Score {\n long long eval;\n long long actual;\n};\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) { x = seed; }\n uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n int nextInt(int mod) { return (int)(next() % mod); }\n double nextDouble() { return (next() >> 11) * (1.0 / (1ULL << 53)); }\n};\n\nint boundaryPenalty(int i, int j, int type) {\n int p = 0;\n if (i == 0 && hasEdge[type][1]) p--;\n if (i == N - 1 && hasEdge[type][3]) p--;\n if (j == 0 && hasEdge[type][0]) p--;\n if (j == N - 1 && hasEdge[type][2]) p--;\n return p;\n}\n\nint initScore(int i, int j, int type) {\n int score = boundaryPenalty(i, j, type);\n if (i > 0 && hasEdge[type][1] && hasEdge[curType[i - 1][j]][3]) score++;\n if (j > 0 && hasEdge[type][0] && hasEdge[curType[i][j - 1]][2]) score++;\n return score;\n}\n\nint localScore(int i, int j, int type) {\n int score = boundaryPenalty(i, j, type);\n if (i > 0 && hasEdge[type][1] && hasEdge[curType[i - 1][j]][3]) score++;\n if (i + 1 < N && hasEdge[type][3] && hasEdge[curType[i + 1][j]][1]) score++;\n if (j > 0 && hasEdge[type][0] && hasEdge[curType[i][j - 1]][2]) score++;\n if (j + 1 < N && hasEdge[type][2] && hasEdge[curType[i][j + 1]][0]) score++;\n return score;\n}\n\nScore evaluate() {\n int conn = 0;\n // Count connected edges\n for (int i = 0; i < N; i++)\n for (int j = 0; j + 1 < N; j++)\n if (hasEdge[curType[i][j]][2] && hasEdge[curType[i][j + 1]][0]) conn++;\n\n for (int i = 0; i + 1 < N; i++)\n for (int j = 0; j < N; j++)\n if (hasEdge[curType[i][j]][3] && hasEdge[curType[i + 1][j]][1]) conn++;\n\n static bool vis[N][N][4];\n memset(vis, 0, sizeof(vis));\n\n int L1 = 0, L2 = 0, loopCount = 0;\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int d = 0; d < 4; d++) {\n if (vis[i][j][d]) continue;\n int ni = i + di[d], nj = j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (!hasEdge[curType[i][j]][d]) continue;\n if (!hasEdge[curType[ni][nj]][(d + 2) % 4]) continue;\n\n int incoming = toDir[curType[i][j]][d];\n if (incoming == -1) continue;\n\n int ci = i, cj = j, cd = incoming;\n int len = 0;\n bool loop = true;\n\n while (true) {\n int t = curType[ci][cj];\n int d2 = toDir[t][cd];\n if (d2 == -1) { loop = false; break; }\n int ni2 = ci + di[d2], nj2 = cj + dj[d2];\n if (ni2 < 0 || ni2 >= N || nj2 < 0 || nj2 >= N) {\n loop = false; break;\n }\n vis[ci][cj][d2] = true;\n vis[ni2][nj2][(d2 + 2) % 4] = true;\n len++;\n ci = ni2; cj = nj2; cd = (d2 + 2) % 4;\n if (ci == i && cj == j && cd == incoming) break;\n }\n\n if (loop && ci == i && cj == j && cd == incoming) {\n loopCount++;\n if (len > L1) { L2 = L1; L1 = len; }\n else if (len > L2) { L2 = len; }\n }\n }\n }\n }\n\n long long actual = (loopCount >= 2 ? 1LL * L1 * L2 : 0);\n long long evalLoop = (loopCount >= 2 ? 1LL * L1 * L2 : 1LL * L1);\n\n const int W = 20;\n long long eval = evalLoop + 1LL * conn * W;\n\n return {eval, actual};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n for (int i = 0; i < N; i++) {\n string s;\n if (!(cin >> s)) return 0;\n for (int j = 0; j < N; j++) baseTile[i][j] = s[j] - '0';\n }\n\n // Rotation table\n int rot1[8] = {1, 2, 3, 0, 5, 4, 7, 6};\n for (int t = 0; t < 8; t++) {\n rotType[t][0] = t;\n for (int r = 1; r < 4; r++) rotType[t][r] = rot1[rotType[t][r - 1]];\n }\n\n for (int t = 0; t < 8; t++)\n for (int d = 0; d < 4; d++)\n hasEdge[t][d] = (toDir[t][d] != -1);\n\n RNG rng((uint64_t)chrono::steady_clock::now().time_since_epoch().count());\n\n // Greedy initialization\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int bestR = 0;\n int bestScore = -1000000000;\n for (int r = 0; r < 4; r++) {\n int type = rotType[baseTile[i][j]][r];\n int score = initScore(i, j, type);\n if (score > bestScore || (score == bestScore && rng.nextInt(2) == 0)) {\n bestScore = score;\n bestR = r;\n }\n }\n rotCnt[i][j] = bestR;\n curType[i][j] = rotType[baseTile[i][j]][bestR];\n }\n }\n\n // Local improvement\n for (int it = 0; it < 2; it++) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int bestR = rotCnt[i][j];\n int bestScore = localScore(i, j, curType[i][j]);\n for (int r = 0; r < 4; r++) {\n int type = rotType[baseTile[i][j]][r];\n int score = localScore(i, j, type);\n if (score > bestScore || (score == bestScore && rng.nextInt(2) == 0)) {\n bestScore = score;\n bestR = r;\n }\n }\n if (bestR != rotCnt[i][j]) {\n rotCnt[i][j] = bestR;\n curType[i][j] = rotType[baseTile[i][j]][bestR];\n }\n }\n }\n }\n\n Score curScore = evaluate();\n long long bestActual = curScore.actual;\n memcpy(bestRot, rotCnt, sizeof(rotCnt));\n\n auto start = chrono::steady_clock::now();\n const double timeLimit = 1.9;\n const double startTemp = 10000.0;\n const double endTemp = 1.0;\n double temp = startTemp;\n\n for (long long iter = 0;; iter++) {\n if ((iter & 255) == 0) {\n double elapsed = chrono::duration(chrono::steady_clock::now() - start).count();\n if (elapsed >= timeLimit) break;\n double t = elapsed / timeLimit;\n temp = startTemp + (endTemp - startTemp) * t;\n }\n\n int i = rng.nextInt(N);\n int j = rng.nextInt(N);\n int oldR = rotCnt[i][j];\n int oldType = curType[i][j];\n int newR = (oldR + 1 + rng.nextInt(3)) & 3;\n\n rotCnt[i][j] = newR;\n curType[i][j] = rotType[baseTile[i][j]][newR];\n\n Score newScore = evaluate();\n\n if (newScore.actual > bestActual) {\n bestActual = newScore.actual;\n memcpy(bestRot, rotCnt, sizeof(rotCnt));\n }\n\n long long delta = newScore.eval - curScore.eval;\n if (delta >= 0) {\n curScore = newScore;\n } else {\n double prob = exp((double)delta / temp);\n if (rng.nextDouble() < prob) {\n curScore = newScore;\n } else {\n rotCnt[i][j] = oldR;\n curType[i][j] = oldType;\n }\n }\n }\n\n string out;\n out.reserve(N * N);\n for (int i = 0; i < N; i++)\n for (int j = 0; j < N; j++)\n out.push_back(char('0' + bestRot[i][j]));\n\n cout << out << '\\n';\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint N, T, NN;\nint neigh[100][4];\nconst int bitOut[4] = {2, 4, 8, 1}; // U,R,D,L\nconst int bitIn [4] = {8, 1, 2, 4}; // opposite\nconst char dirChar[4] = {'U','R','D','L'};\n\nstruct Eval {\n int largest;\n int treeTotal;\n int edgesTotal;\n int score;\n};\n\nEval evaluate(const array& board) {\n uint8_t visited[100];\n memset(visited, 0, sizeof(visited));\n int largest = 0;\n int treeTotal = 0;\n int edgesTotal = 0;\n\n for (int idx = 0; idx < NN; ++idx) {\n if (board[idx] == 0 || visited[idx]) continue;\n int stack[100], sp = 0;\n stack[sp++] = idx;\n visited[idx] = 1;\n int V = 0, E = 0;\n\n while (sp) {\n int u = stack[--sp];\n V++;\n uint8_t tile = board[u];\n for (int dir = 0; dir < 4; ++dir) {\n if (!(tile & bitOut[dir])) continue;\n int v = neigh[u][dir];\n if (v < 0) continue;\n uint8_t t2 = board[v];\n if (t2 == 0 || !(t2 & bitIn[dir])) continue;\n if (u < v) E++;\n if (!visited[v]) {\n visited[v] = 1;\n stack[sp++] = v;\n }\n }\n }\n edgesTotal += E;\n if (E == V - 1) {\n treeTotal += V;\n largest = max(largest, V);\n }\n }\n int score = largest * 10000 + treeTotal * 100 + edgesTotal * 10;\n return {largest, treeTotal, edgesTotal, score};\n}\n\nstruct State {\n array board;\n uint8_t empty;\n int score;\n int largest;\n int depth;\n int parent;\n uint8_t lastDir; // 0..3, 4 for none\n char move;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n if (!(cin >> N >> T)) return 0;\n NN = N * N;\n array board;\n board.fill(0);\n int empty = -1;\n\n for (int i = 0; i < N; ++i) {\n string s; cin >> s;\n for (int j = 0; j < N; ++j) {\n char c = s[j];\n int v = (c <= '9') ? c - '0' : c - 'a' + 10;\n board[i*N+j] = v;\n if (v == 0) empty = i*N+j;\n }\n }\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n int idx = i*N+j;\n neigh[idx][0] = (i > 0) ? idx - N : -1;\n neigh[idx][1] = (j + 1 < N) ? idx + 1 : -1;\n neigh[idx][2] = (i + 1 < N) ? idx + N : -1;\n neigh[idx][3] = (j > 0) ? idx - 1 : -1;\n }\n\n int maxTiles = NN - 1;\n\n int B;\n if (T <= 600) B = 120;\n else if (T <= 1000) B = 100;\n else if (T <= 1500) B = 90;\n else B = 80;\n\n vector pool;\n pool.reserve((long long)B * 4 * T + 10);\n\n Eval rootEval = evaluate(board);\n State root{board, (uint8_t)empty, rootEval.score, rootEval.largest, 0, -1, 4, 0};\n pool.push_back(root);\n\n int bestIdx = 0;\n int bestS = root.largest;\n int bestScore = root.score;\n int bestDepth = 0;\n\n vector beam = {0};\n vector cand;\n cand.reserve(B * 4 + 10);\n\n for (int depth = 0; depth < T; ++depth) {\n cand.clear();\n for (int idx : beam) {\n const State &st = pool[idx];\n for (int dir = 0; dir < 4; ++dir) {\n if (st.lastDir != 4 && dir == (st.lastDir ^ 2)) continue;\n int nb = neigh[st.empty][dir];\n if (nb < 0) continue;\n\n State child;\n child.board = st.board;\n swap(child.board[st.empty], child.board[nb]);\n child.empty = nb;\n child.depth = st.depth + 1;\n child.parent = idx;\n child.lastDir = dir;\n child.move = dirChar[dir];\n\n Eval ev = evaluate(child.board);\n child.largest = ev.largest;\n child.score = ev.score;\n\n int childIdx = pool.size();\n pool.push_back(child);\n cand.push_back(childIdx);\n\n if (child.largest > bestS) {\n bestS = child.largest;\n bestScore = child.score;\n bestDepth = child.depth;\n bestIdx = childIdx;\n } else if (child.largest == bestS) {\n if (child.largest == maxTiles) {\n if (child.depth < bestDepth) {\n bestScore = child.score;\n bestDepth = child.depth;\n bestIdx = childIdx;\n }\n } else if (child.score > bestScore ||\n (child.score == bestScore && child.depth < bestDepth)) {\n bestScore = child.score;\n bestDepth = child.depth;\n bestIdx = childIdx;\n }\n }\n }\n }\n\n if (cand.empty()) break;\n\n auto cmp = [&](int a, int b) {\n return pool[a].score > pool[b].score;\n };\n\n if ((int)cand.size() > B) {\n nth_element(cand.begin(), cand.begin() + B, cand.end(), cmp);\n cand.resize(B);\n }\n beam = cand;\n\n if (bestS == maxTiles) break;\n }\n\n string ans;\n int idx = bestIdx;\n while (pool[idx].parent != -1) {\n ans.push_back(pool[idx].move);\n idx = pool[idx].parent;\n }\n reverse(ans.begin(), ans.end());\n cout << ans << \"\\n\";\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nstruct Point {\n long long x, y;\n};\n\nstruct NormalData {\n long long a, b;\n vector proj;\n vector sorted;\n unordered_set setv;\n};\n\nstruct BestSolution {\n int score = -1;\n int V = 0, H = 0;\n long long a1 = 1, b1 = 0;\n long long a2 = 0, b2 = 1;\n vector cuts1, cuts2;\n};\n\nlong long extgcd(long long a, long long b, long long &x, long long &y) {\n if (b == 0) {\n x = 1; y = 0;\n return a;\n }\n long long x1, y1;\n long long g = extgcd(b, a % b, x1, y1);\n x = y1;\n y = x1 - (a / b) * y1;\n return g;\n}\n\npair linePoints(long long a, long long b, long long c) {\n long long aa = llabs(a), bb = llabs(b);\n long long x, y;\n long long g = extgcd(aa, bb, x, y);\n if (a < 0) x = -x;\n if (b < 0) y = -y;\n long long mul = c / g;\n x *= mul; y *= mul;\n long long dx = b / g;\n long long dy = -a / g;\n return { {x, y}, {x + dx, y + dy} };\n}\n\nNormalData buildNormalData(long long a, long long b, const vector& pts) {\n NormalData nd;\n nd.a = a; nd.b = b;\n int n = (int)pts.size();\n nd.proj.resize(n);\n for (int i = 0; i < n; ++i) {\n nd.proj[i] = a * pts[i].x + b * pts[i].y;\n }\n nd.sorted = nd.proj;\n sort(nd.sorted.begin(), nd.sorted.end());\n nd.setv.reserve(n * 2);\n for (auto v : nd.proj) nd.setv.insert(v);\n return nd;\n}\n\nvector computeCuts(const NormalData& nd, int numCuts) {\n vector cuts;\n if (numCuts <= 0) return cuts;\n cuts.reserve(numCuts);\n long long prev = LLONG_MIN / 4;\n int n = (int)nd.sorted.size();\n\n for (int j = 1; j <= numCuts; ++j) {\n long long idx = (long long)j * n / (numCuts + 1) - 1;\n if (idx < 0) idx = 0;\n if (idx >= n) idx = n - 1;\n long long base = nd.sorted[idx];\n long long c = base + 1;\n while (nd.setv.count(c)) ++c;\n if (c <= prev) {\n c = prev + 1;\n while (nd.setv.count(c)) ++c;\n }\n cuts.push_back(c);\n prev = c;\n }\n return cuts;\n}\n\nint evaluate(const NormalData& n1, const NormalData& n2, int V, int H,\n const array& need,\n vector& cuts1, vector& cuts2) {\n cuts1 = computeCuts(n1, V);\n cuts2 = computeCuts(n2, H);\n\n int cells = (V + 1) * (H + 1);\n vector cell(cells, 0);\n\n for (int i = 0; i < (int)n1.proj.size(); ++i) {\n long long s1 = n1.proj[i];\n long long s2 = n2.proj[i];\n int idx1 = lower_bound(cuts1.begin(), cuts1.end(), s1) - cuts1.begin();\n int idx2 = lower_bound(cuts2.begin(), cuts2.end(), s2) - cuts2.begin();\n cell[idx1 * (H + 1) + idx2]++;\n }\n\n int b[11] = {};\n for (int cnt : cell) {\n if (1 <= cnt && cnt <= 10) b[cnt]++;\n }\n\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n score += min(need[d], b[d]);\n }\n return score;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n cin >> N >> K;\n array need = {};\n for (int d = 1; d <= 10; ++d) cin >> need[d];\n\n vector pts(N);\n for (int i = 0; i < N; ++i) cin >> pts[i].x >> pts[i].y;\n\n // Candidate base normals; second normal is perpendicular\n vector> baseNormals = {\n {1,0}, {1,1}, {2,1}, {3,1}, {3,2}, {1,2}\n };\n\n int step = 3; // coarse step for V/H\n BestSolution globalBest;\n\n for (auto [na, nb] : baseNormals) {\n NormalData n1 = buildNormalData(na, nb, pts);\n NormalData n2 = buildNormalData(-nb, na, pts);\n\n int bestScore = -1;\n int bestV = 0, bestH = 0;\n vector bestCuts1, bestCuts2;\n\n // coarse search\n for (int V = 0; V <= K; V += step) {\n for (int H = 0; H <= K - V; H += step) {\n vector c1, c2;\n int score = evaluate(n1, n2, V, H, need, c1, c2);\n if (score > bestScore) {\n bestScore = score;\n bestV = V; bestH = H;\n bestCuts1 = move(c1);\n bestCuts2 = move(c2);\n }\n }\n }\n\n // refine around best\n for (int V = max(0, bestV - 3); V <= min(K, bestV + 3); ++V) {\n for (int H = max(0, bestH - 3); H <= min(K - V, bestH + 3); ++H) {\n vector c1, c2;\n int score = evaluate(n1, n2, V, H, need, c1, c2);\n if (score > bestScore) {\n bestScore = score;\n bestV = V; bestH = H;\n bestCuts1 = move(c1);\n bestCuts2 = move(c2);\n }\n }\n }\n\n if (bestScore > globalBest.score) {\n globalBest.score = bestScore;\n globalBest.V = bestV;\n globalBest.H = bestH;\n globalBest.a1 = na; globalBest.b1 = nb;\n globalBest.a2 = -nb; globalBest.b2 = na;\n globalBest.cuts1 = move(bestCuts1);\n globalBest.cuts2 = move(bestCuts2);\n }\n }\n\n int k = globalBest.V + globalBest.H;\n cout << k << \"\\n\";\n for (long long c : globalBest.cuts1) {\n auto pq = linePoints(globalBest.a1, globalBest.b1, c);\n cout << pq.first.x << \" \" << pq.first.y << \" \"\n << pq.second.x << \" \" << pq.second.y << \"\\n\";\n }\n for (long long c : globalBest.cuts2) {\n auto pq = linePoints(globalBest.a2, globalBest.b2, c);\n cout << pq.first.x << \" \" << pq.first.y << \" \"\n << pq.second.x << \" \" << pq.second.y << \"\\n\";\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct Operation {\n int x1, y1, x2, y2, x3, y3, x4, y4;\n};\n\nstruct Coord {\n int x, y, w;\n uint32_t rnd;\n};\n\nstruct Candidate {\n bool found = false;\n bool diag = false;\n int perim = 1e9;\n int x2, y2, x3, y3, x4, y4;\n};\n\nclass Solver {\n int N, M;\n int c;\n vector> dot;\n vector> usedH, usedV, usedD1, usedD2;\n vector ops;\n vector> order;\n chrono::steady_clock::time_point start;\n const double TIME_LIMIT = 4.8;\n\npublic:\n void run() {\n read();\n init();\n solve();\n output();\n }\n\nprivate:\n void read() {\n cin >> N >> M;\n dot.assign(N, vector(N, 0));\n for (int i = 0; i < M; i++) {\n int x, y;\n cin >> x >> y;\n dot[x][y] = 1;\n }\n }\n\n void init() {\n c = (N - 1) / 2;\n usedH.assign(N, vector(N, 0));\n usedV.assign(N, vector(N, 0));\n usedD1.assign(N, vector(N, 0));\n usedD2.assign(N, vector(N, 0));\n\n mt19937 rng(1);\n vector coords;\n coords.reserve(N * N);\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n int w = (x - c) * (x - c) + (y - c) * (y - c) + 1;\n coords.push_back({x, y, w, rng()});\n }\n }\n sort(coords.begin(), coords.end(), [](const Coord& a, const Coord& b) {\n if (a.w != b.w) return a.w > b.w;\n return a.rnd < b.rnd;\n });\n order.clear();\n for (auto &co : coords) order.emplace_back(co.x, co.y);\n }\n\n bool timeExceeded() const {\n double t = chrono::duration(chrono::steady_clock::now() - start).count();\n return t > TIME_LIMIT;\n }\n\n bool clearAxis(int x1, int y1, int x2, int y2) {\n int xl = min(x1, x2), xr = max(x1, x2);\n int yl = min(y1, y2), yr = max(y1, y2);\n for (int x = xl + 1; x < xr; x++) {\n if (dot[x][y1]) return false;\n if (dot[x][y2]) return false;\n }\n for (int y = yl + 1; y < yr; y++) {\n if (dot[x1][y]) return false;\n if (dot[x2][y]) return false;\n }\n return true;\n }\n\n bool clearAxisSeg(int x1, int y1, int x2, int y2) {\n int xl = min(x1, x2), xr = max(x1, x2);\n int yl = min(y1, y2), yr = max(y1, y2);\n for (int x = xl; x < xr; x++) {\n if (usedH[x][y1] || usedH[x][y2]) return false;\n }\n for (int y = yl; y < yr; y++) {\n if (usedV[x1][y] || usedV[x2][y]) return false;\n }\n return true;\n }\n\n void markAxis(int x1, int y1, int x2, int y2) {\n int xl = min(x1, x2), xr = max(x1, x2);\n int yl = min(y1, y2), yr = max(y1, y2);\n for (int x = xl; x < xr; x++) {\n usedH[x][y1] = 1;\n usedH[x][y2] = 1;\n }\n for (int y = yl; y < yr; y++) {\n usedV[x1][y] = 1;\n usedV[x2][y] = 1;\n }\n }\n\n bool checkDiagEdge(int xa, int ya, int xb, int yb) {\n int dx = (xb > xa) ? 1 : -1;\n int dy = (yb > ya) ? 1 : -1;\n int len = abs(xb - xa);\n\n // dots\n for (int i = 1; i < len; i++) {\n int x = xa + dx * i;\n int y = ya + dy * i;\n if (dot[x][y]) return false;\n }\n // segments\n for (int i = 0; i < len; i++) {\n int x = xa + dx * i;\n int y = ya + dy * i;\n int x0 = min(x, x + dx);\n if (dy == dx) {\n int y0 = min(y, y + dy);\n if (usedD1[x0][y0]) return false;\n } else {\n int y0 = max(y, y + dy);\n if (usedD2[x0][y0]) return false;\n }\n }\n return true;\n }\n\n void markDiagEdge(int xa, int ya, int xb, int yb) {\n int dx = (xb > xa) ? 1 : -1;\n int dy = (yb > ya) ? 1 : -1;\n int len = abs(xb - xa);\n for (int i = 0; i < len; i++) {\n int x = xa + dx * i;\n int y = ya + dy * i;\n int x0 = min(x, x + dx);\n if (dy == dx) {\n int y0 = min(y, y + dy);\n usedD1[x0][y0] = 1;\n } else {\n int y0 = max(y, y + dy);\n usedD2[x0][y0] = 1;\n }\n }\n }\n\n Candidate findBest(int x1, int y1) {\n Candidate best;\n\n // Axis-aligned\n for (int x2 = 0; x2 < N; x2++) {\n if (x2 == x1 || !dot[x2][y1]) continue;\n for (int y2 = 0; y2 < N; y2++) {\n if (y2 == y1 || !dot[x1][y2]) continue;\n if (!dot[x2][y2]) continue;\n if (!clearAxis(x1, y1, x2, y2)) continue;\n if (!clearAxisSeg(x1, y1, x2, y2)) continue;\n int per = abs(x2 - x1) + abs(y2 - y1);\n if (per < best.perim) {\n best.found = true;\n best.diag = false;\n best.perim = per;\n best.x2 = x2; best.y2 = y1;\n best.x3 = x2; best.y3 = y2;\n best.x4 = x1; best.y4 = y2;\n }\n }\n }\n\n // Diagonal (45\u00b0)\n int u1 = x1 + y1;\n int v1 = x1 - y1;\n vector> diagV, diagU;\n int xStart = max(0, v1);\n int xEnd = min(N - 1, N - 1 + v1);\n for (int x = xStart; x <= xEnd; x++) {\n int y = x - v1;\n if (dot[x][y] && !(x == x1 && y == y1)) diagV.push_back({x,y});\n }\n int xStartU = max(0, u1 - (N - 1));\n int xEndU = min(N - 1, u1);\n for (int x = xStartU; x <= xEndU; x++) {\n int y = u1 - x;\n if (dot[x][y] && !(x == x1 && y == y1)) diagU.push_back({x,y});\n }\n\n for (auto [x2,y2] : diagV) {\n int len1 = abs(x2 - x1);\n if (len1 == 0) continue;\n int u2 = x2 + y2;\n for (auto [x4,y4] : diagU) {\n int len2 = abs(x4 - x1);\n if (len2 == 0) continue;\n int v2 = x4 - y4;\n int s = u2 + v2;\n if (s & 1) continue;\n int x3 = s / 2;\n int y3 = (u2 - v2) / 2;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (!dot[x3][y3]) continue;\n if (!checkDiagEdge(x1,y1,x2,y2)) continue;\n if (!checkDiagEdge(x2,y2,x3,y3)) continue;\n if (!checkDiagEdge(x3,y3,x4,y4)) continue;\n if (!checkDiagEdge(x4,y4,x1,y1)) continue;\n int per = len1 + len2;\n if (per < best.perim) {\n best.found = true;\n best.diag = true;\n best.perim = per;\n best.x2 = x2; best.y2 = y2;\n best.x3 = x3; best.y3 = y3;\n best.x4 = x4; best.y4 = y4;\n }\n }\n }\n\n return best;\n }\n\n void solve() {\n start = chrono::steady_clock::now();\n bool changed = true;\n while (changed && !timeExceeded()) {\n changed = false;\n for (auto [x1, y1] : order) {\n if (timeExceeded()) break;\n if (dot[x1][y1]) continue;\n Candidate cand = findBest(x1, y1);\n if (cand.found) {\n dot[x1][y1] = 1;\n if (cand.diag) {\n markDiagEdge(x1,y1,cand.x2,cand.y2);\n markDiagEdge(cand.x2,cand.y2,cand.x3,cand.y3);\n markDiagEdge(cand.x3,cand.y3,cand.x4,cand.y4);\n markDiagEdge(cand.x4,cand.y4,x1,y1);\n } else {\n markAxis(x1,y1,cand.x3,cand.y3);\n }\n ops.push_back({x1,y1,cand.x2,cand.y2,cand.x3,cand.y3,cand.x4,cand.y4});\n changed = true;\n }\n }\n }\n }\n\n void output() {\n cout << ops.size() << \"\\n\";\n for (auto &op : ops) {\n cout << op.x1 << ' ' << op.y1 << ' '\n << op.x2 << ' ' << op.y2 << ' '\n << op.x3 << ' ' << op.y3 << ' '\n << op.x4 << ' ' << op.y4 << \"\\n\";\n }\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n Solver s;\n s.run();\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nconstexpr int N = 10;\nconstexpr int SZ = 100;\nconst char DIR_CHARS[4] = {'F','B','L','R'};\n\nstruct State {\n array b;\n array path;\n int len = 0;\n int score = 0;\n};\n\nvoid place_candy(array& b, int p, uint8_t flavor) {\n int cnt = 0;\n for(int i=0;i& b, int dir){\n uint8_t tmp[N];\n if(dir==0){ // F: up\n for(int c=0;c=0;r--){\n uint8_t v=b[r*N+c];\n if(v) tmp[idx++]=v;\n }\n int k=0;\n for(int r=N-1;r>=0;r--){\n b[r*N+c]=(k=0;c--){\n uint8_t v=b[r*N+c];\n if(v) tmp[idx++]=v;\n }\n int k=0;\n for(int c=N-1;c>=0;c--){\n b[r*N+c]=(k& b, const array& rem){\n bool vis[SZ]={false};\n int sum_sq=0;\n int max_size[4]={0,0,0,0};\n int q[SZ];\n\n for(int i=0;i0){u=v-N; if(!vis[u] && b[u]==f){vis[u]=true; q[tail++]=u;}}\n if(r+10){u=v-1; if(!vis[u] && b[u]==f){vis[u]=true; q[tail++]=u;}}\n if(c+1& b){\n bool vis[SZ]={false};\n int sum_sq=0;\n int q[SZ];\n\n for(int i=0;i0){u=v-N; if(!vis[u] && b[u]==f){vis[u]=true; q[tail++]=u;}}\n if(r+10){u=v-1; if(!vis[u] && b[u]==f){vis[u]=true; q[tail++]=u;}}\n if(c+1 f(100), p(100);\n for(int i=0;i<100;i++){\n if(!(cin>>f[i])) return 0;\n }\n for(int i=0;i<100;i++){\n if(!(cin>>p[i])) return 0;\n }\n\n array total={0,0,0,0};\n for(int x: f) total[x]++;\n\n vector> rem(101);\n array pref={0,0,0,0};\n rem[0]=total;\n for(int t=1;t<=100;t++){\n pref[f[t-1]]++;\n array r={0,0,0,0};\n for(int i=1;i<=3;i++) r[i]=total[i]-pref[i];\n rem[t]=r;\n }\n\n const int WIDTH = 200;\n vector beam;\n State init;\n init.b.fill(0);\n init.path.fill(0);\n init.len=0;\n init.score=0;\n beam.push_back(init);\n\n for(int t=0;t<100;t++){\n vector next;\n next.reserve(beam.size()*4);\n for(const State& st: beam){\n array b2 = st.b;\n place_candy(b2, p[t], static_cast(f[t]));\n for(int dir=0; dir<4; dir++){\n array b3 = b2;\n tilt(b3, dir);\n\n State child;\n child.b = b3;\n child.path = st.path;\n child.path[st.len] = DIR_CHARS[dir];\n child.len = st.len + 1;\n child.score = evaluate(b3, rem[t+1]);\n next.push_back(child);\n }\n }\n\n auto cmp = [](const State& a, const State& b){ return a.score > b.score; };\n if((int)next.size() > WIDTH){\n nth_element(next.begin(), next.begin()+WIDTH, next.end(), cmp);\n next.resize(WIDTH);\n }\n sort(next.begin(), next.end(), cmp);\n beam.swap(next);\n }\n\n int bestScore=-1;\n int bestIdx=0;\n for(int i=0;i<(int)beam.size();i++){\n int s = calc_sum_sq(beam[i].b);\n if(s > bestScore){\n bestScore=s;\n bestIdx=i;\n }\n }\n\n const State& best = beam[bestIdx];\n for(int i=0;i\nusing namespace std;\n\nstruct Candidate {\n vector sizes; // clique sizes (sorted)\n vector deg; // sorted degree sequence\n vector exp_deg; // expected degrees after noise\n double exp_tri; // expected triangle count after noise\n long long edges; // #edges in original graph\n};\n\nstatic const double INF = 1e100;\n\nint choose_N(int M, double eps) {\n int N = 30 + int(100 * eps) + (M - 10) / 3;\n if (N < 4) N = 4;\n if (N > 100) N = 100;\n return N;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int M;\n double eps;\n if (!(cin >> M >> eps)) return 0;\n\n int N = choose_N(M, eps);\n int L = N * (N - 1) / 2;\n\n double base = eps * (N - 1);\n double slope = 1.0 - 2.0 * eps;\n double a = 1.0 - eps;\n double p3 = a * a * a;\n double p1 = a * eps * eps;\n double p0 = eps * eps * eps;\n\n long long total_tri = 1LL * N * (N - 1) * (N - 2) / 6;\n\n // RNG with deterministic seed\n int seed = 1234567 + M * 1000 + int(eps * 100 + 0.5);\n mt19937 rng(seed);\n\n vector cand;\n unordered_set seen;\n\n auto add_candidate = [&](const vector& input_sizes) {\n vector sizes = input_sizes;\n sort(sizes.begin(), sizes.end());\n string key;\n key.reserve(sizes.size() * 3);\n for (int v : sizes) {\n key += to_string(v);\n key.push_back(',');\n }\n if (seen.count(key)) return;\n seen.insert(key);\n\n Candidate c;\n c.sizes = sizes;\n c.deg.reserve(N);\n long long sum_deg = 0;\n for (int g : sizes) {\n for (int i = 0; i < g; ++i) {\n c.deg.push_back(g - 1);\n sum_deg += g - 1;\n }\n }\n c.edges = sum_deg / 2;\n\n c.exp_deg.resize(N);\n for (int i = 0; i < N; ++i) {\n c.exp_deg[i] = base + slope * c.deg[i];\n }\n\n long long c3 = 0, c1 = 0;\n for (int g : sizes) {\n if (g >= 3) c3 += 1LL * g * (g - 1) * (g - 2) / 6;\n if (g >= 2) c1 += 1LL * g * (g - 1) / 2 * (N - g);\n }\n long long c0 = total_tri - c3 - c1;\n c.exp_tri = c3 * p3 + c1 * p1 + c0 * p0;\n\n cand.push_back(move(c));\n };\n\n // Add some deterministic partitions\n add_candidate(vector{N}); // complete graph\n add_candidate(vector(N, 1)); // empty graph\n for (int k = 1; k <= min(N - 1, 10); ++k) {\n add_candidate(vector{k, N - k});\n }\n\n auto random_partition = [&](int N) {\n vector parts;\n int rem = N;\n while (rem > 0) {\n int s;\n int mode = rng() % 4;\n if (mode == 0) s = 1 + rng() % min(rem, 3);\n else if (mode == 1) s = 1 + rng() % min(rem, 7);\n else if (mode == 2) s = 1 + rng() % min(rem, 15);\n else {\n int min_s = max(1, rem / 2);\n s = min_s + rng() % (rem - min_s + 1);\n }\n parts.push_back(s);\n rem -= s;\n }\n sort(parts.begin(), parts.end());\n return parts;\n };\n\n int Ctarget = max(2000, M * 30);\n while ((int)cand.size() < Ctarget) {\n auto parts = random_partition(N);\n add_candidate(parts);\n }\n\n auto dist_deg = [&](const Candidate& a, const Candidate& b) {\n double s = 0;\n for (int i = 0; i < N; ++i) {\n double d = double(a.deg[i]) - double(b.deg[i]);\n s += d * d;\n }\n return s;\n };\n\n // Greedy farthest-point selection\n int C = cand.size();\n vector idx(C);\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(), [&](int i, int j) {\n return cand[i].edges < cand[j].edges;\n });\n int start = idx[C / 2];\n\n vector bestDist(C, INF);\n vector chosen(C, false);\n vector selected;\n chosen[start] = true;\n selected.push_back(start);\n for (int i = 0; i < C; ++i) if (!chosen[i]) bestDist[i] = dist_deg(cand[i], cand[start]);\n\n while ((int)selected.size() < M) {\n int best = -1;\n double bestVal = -1;\n for (int i = 0; i < C; ++i) {\n if (!chosen[i] && bestDist[i] > bestVal) {\n bestVal = bestDist[i];\n best = i;\n }\n }\n if (best == -1) break;\n chosen[best] = true;\n selected.push_back(best);\n for (int i = 0; i < C; ++i) {\n if (!chosen[i]) {\n double d = dist_deg(cand[i], cand[best]);\n if (d < bestDist[i]) bestDist[i] = d;\n }\n }\n }\n\n // Fallback if somehow not enough\n for (int i = 0; (int)selected.size() < M && i < C; ++i) {\n if (!chosen[i]) {\n chosen[i] = true;\n selected.push_back(i);\n }\n }\n\n // Build final codes\n struct Code {\n vector sizes;\n vector exp_deg;\n double exp_tri;\n string graph_str;\n };\n vector codes;\n codes.reserve(M);\n\n auto build_graph_string = [&](const vector& sizes) {\n vector group(N);\n int idxv = 0, gid = 0;\n for (int s : sizes) {\n for (int i = 0; i < s; ++i) group[idxv++] = gid;\n ++gid;\n }\n string g;\n g.reserve(L);\n for (int i = 0; i < N; ++i) {\n for (int j = i + 1; j < N; ++j) {\n g.push_back(group[i] == group[j] ? '1' : '0');\n }\n }\n return g;\n };\n\n for (int id : selected) {\n Code code;\n code.sizes = cand[id].sizes;\n code.exp_deg = cand[id].exp_deg;\n code.exp_tri = cand[id].exp_tri;\n code.graph_str = build_graph_string(code.sizes);\n codes.push_back(move(code));\n }\n\n // Output graphs\n cout << N << \"\\n\";\n for (int i = 0; i < M; ++i) {\n cout << codes[i].graph_str << \"\\n\";\n }\n cout.flush();\n\n // Precompute weights\n double var_deg = (N - 1) * eps * (1 - eps);\n if (var_deg < 1e-6) var_deg = 1e-6;\n double w_deg = 1.0 / var_deg;\n double w_tri = 4.0 / max(1LL, total_tri); // approx 1/(0.25*total_tri)\n\n // Answer queries\n for (int q = 0; q < 100; ++q) {\n string H;\n if (!(cin >> H)) break;\n\n vector deg(N, 0);\n vector> adj(N, vector(N, 0));\n\n int ptr = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = i + 1; j < N; ++j) {\n char c = H[ptr++];\n if (c == '1') {\n deg[i]++; deg[j]++;\n adj[i][j] = adj[j][i] = 1;\n }\n }\n }\n\n vector deg_sorted = deg;\n sort(deg_sorted.begin(), deg_sorted.end());\n\n long long tri = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = i + 1; j < N; ++j) {\n if (!adj[i][j]) continue;\n for (int k = j + 1; k < N; ++k) {\n if (adj[i][k] && adj[j][k]) tri++;\n }\n }\n }\n\n int bestIdx = 0;\n double bestScore = INF;\n for (int i = 0; i < M; ++i) {\n const auto &code = codes[i];\n double dist = 0.0;\n for (int k = 0; k < N; ++k) {\n double diff = deg_sorted[k] - code.exp_deg[k];\n dist += diff * diff;\n }\n dist *= w_deg;\n double diff_tri = tri - code.exp_tri;\n dist += w_tri * diff_tri * diff_tri;\n\n if (dist < bestScore) {\n bestScore = dist;\n bestIdx = i;\n }\n }\n\n cout << bestIdx << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc017":"#include \nusing namespace std;\n\nstruct Edge {\n int to, id, w;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n auto globalStart = chrono::steady_clock::now();\n\n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n\n vector U(M), V(M), W(M);\n vector> g(N);\n\n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n U[i] = u; V[i] = v; W[i] = w;\n g[u].push_back({v, i, w});\n g[v].push_back({u, i, w});\n }\n // read coordinates (unused)\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n\n // degrees\n vector deg(N, 0);\n for (int i = 0; i < M; i++) {\n deg[U[i]]++;\n deg[V[i]]++;\n }\n\n // vertex penalty factors (low degree => heavier penalty)\n vector vFactor(N, 1.0);\n for (int v = 0; v < N; v++) {\n if (deg[v] == 2) vFactor[v] = 6.0;\n else if (deg[v] == 3) vFactor[v] = 3.0;\n }\n\n // ---- Brandes algorithm for edge betweenness ----\n vector bet(M, 0.0);\n const long long INF = (1LL << 60);\n\n vector dist(N);\n vector sigma(N), delta(N);\n vector>> pred(N);\n vector order;\n order.reserve(N);\n\n for (int s = 0; s < N; s++) {\n fill(dist.begin(), dist.end(), INF);\n fill(sigma.begin(), sigma.end(), 0.0);\n for (int v = 0; v < N; v++) pred[v].clear();\n\n dist[s] = 0;\n sigma[s] = 1.0;\n\n priority_queue, vector>, greater>> pq;\n pq.push({0, s});\n order.clear();\n\n while (!pq.empty()) {\n auto [d, v] = pq.top(); pq.pop();\n if (d != dist[v]) continue;\n order.push_back(v);\n\n for (auto &e : g[v]) {\n long long nd = d + e.w;\n int to = e.to;\n if (nd < dist[to]) {\n dist[to] = nd;\n pq.push({nd, to});\n sigma[to] = sigma[v];\n pred[to].clear();\n pred[to].push_back({v, e.id});\n } else if (nd == dist[to]) {\n sigma[to] += sigma[v];\n pred[to].push_back({v, e.id});\n }\n }\n }\n\n fill(delta.begin(), delta.end(), 0.0);\n\n for (int idx = (int)order.size() - 1; idx >= 0; --idx) {\n int v = order[idx];\n for (auto &pr : pred[v]) {\n int p = pr.first;\n int id = pr.second;\n if (sigma[v] == 0) continue;\n double c = (sigma[p] / sigma[v]) * (1.0 + delta[v]);\n bet[id] += c;\n delta[p] += c;\n }\n }\n }\n\n // importance = betweenness * weight\n vector imp(M);\n double sumImp = 0.0;\n for (int i = 0; i < M; i++) {\n imp[i] = bet[i] * W[i];\n sumImp += imp[i];\n }\n if (sumImp <= 0) {\n sumImp = M;\n for (int i = 0; i < M; i++) imp[i] = 1.0;\n }\n double avgImp = sumImp / M;\n vector normImp(M);\n for (int i = 0; i < M; i++) normImp[i] = imp[i] / avgImp;\n\n // sort edges by importance descending\n vector idxs(M);\n iota(idxs.begin(), idxs.end(), 0);\n sort(idxs.begin(), idxs.end(), [&](int a, int b){\n if (normImp[a] == normImp[b]) return a < b;\n return normImp[a] > normImp[b];\n });\n\n // target counts per day (balanced)\n int base = M / D;\n int rem = M % D;\n vector target(D, base);\n for (int d = 0; d < rem; d++) target[d]++;\n\n vector day(M, -1);\n vector countDay(D, 0);\n vector weightSum(D, 0.0);\n vector> incCount(N, vector(D, 0));\n\n double lambda1 = 10.0;\n\n // greedy assignment\n for (int id : idxs) {\n int u = U[id], v = V[id];\n double bestCost = 1e100;\n int bestDay = -1;\n for (int d = 0; d < D; d++) {\n if (countDay[d] >= target[d]) continue;\n if (deg[u] == 2 && incCount[u][d] >= 1) continue;\n if (deg[v] == 2 && incCount[v][d] >= 1) continue;\n\n double cost = weightSum[d]\n + lambda1 * (vFactor[u] * incCount[u][d] + vFactor[v] * incCount[v][d]);\n if (cost < bestCost) {\n bestCost = cost;\n bestDay = d;\n }\n }\n if (bestDay == -1) {\n // fallback (should not happen)\n for (int d = 0; d < D; d++) if (countDay[d] < target[d]) {\n bestDay = d; break;\n }\n }\n day[id] = bestDay;\n countDay[bestDay]++;\n weightSum[bestDay] += normImp[id];\n incCount[u][bestDay]++;\n incCount[v][bestDay]++;\n }\n\n // local search\n auto comb = [](int x)->long long {\n return 1LL * x * (x - 1) / 2;\n };\n\n double lambda2 = 50.0;\n double adj = 0.0;\n for (int v = 0; v < N; v++)\n for (int d = 0; d < D; d++)\n adj += comb(incCount[v][d]) * vFactor[v];\n\n double obj = 0.0;\n for (int d = 0; d < D; d++) obj += weightSum[d] * weightSum[d];\n obj += lambda2 * adj;\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution uni(0.0, 1.0);\n\n const double timeLimit = 5.8;\n const double T0 = 50.0, T1 = 1.0;\n double temp = T0;\n\n for (long long iter = 0;; ++iter) {\n if ((iter & 1023) == 0) {\n double elapsed = chrono::duration(\n chrono::steady_clock::now() - globalStart).count();\n if (elapsed > timeLimit) break;\n double progress = elapsed / timeLimit;\n temp = T0 + (T1 - T0) * progress;\n }\n\n int e1 = rng() % M;\n int e2 = rng() % M;\n if (e1 == e2) continue;\n int d1 = day[e1], d2 = day[e2];\n if (d1 == d2) continue;\n\n double w1 = normImp[e1], w2 = normImp[e2];\n double old1 = weightSum[d1], old2 = weightSum[d2];\n double new1 = old1 - w1 + w2;\n double new2 = old2 - w2 + w1;\n double deltaWeight = new1*new1 + new2*new2 - old1*old1 - old2*old2;\n\n struct Change {int v,d,delta;};\n Change changes[8];\n int csz = 0;\n auto addDelta = [&](int v, int d, int dd){\n for (int i = 0; i < csz; i++) {\n if (changes[i].v == v && changes[i].d == d) {\n changes[i].delta += dd;\n return;\n }\n }\n changes[csz++] = {v,d,dd};\n };\n\n int u1 = U[e1], v1 = V[e1];\n int u2 = U[e2], v2 = V[e2];\n addDelta(u1,d1,-1); addDelta(u1,d2,+1);\n addDelta(v1,d1,-1); addDelta(v1,d2,+1);\n addDelta(u2,d2,-1); addDelta(u2,d1,+1);\n addDelta(v2,d2,-1); addDelta(v2,d1,+1);\n\n // degree-2 vertices must not get 2 edges same day\n bool ok = true;\n for (int i = 0; i < csz; i++) {\n int v = changes[i].v;\n int d = changes[i].d;\n int dd = changes[i].delta;\n if (deg[v] == 2) {\n int nc = incCount[v][d] + dd;\n if (nc > 1) { ok = false; break; }\n }\n }\n if (!ok) continue;\n\n double deltaAdj = 0.0;\n for (int i = 0; i < csz; i++) {\n int v = changes[i].v;\n int d = changes[i].d;\n int dd = changes[i].delta;\n if (dd == 0) continue;\n int c = incCount[v][d];\n int nc = c + dd;\n deltaAdj += (comb(nc) - comb(c)) * vFactor[v];\n }\n\n double delta = deltaWeight + lambda2 * deltaAdj;\n\n if (delta < 0 || exp(-delta / temp) > uni(rng)) {\n // accept swap\n day[e1] = d2;\n day[e2] = d1;\n weightSum[d1] = new1;\n weightSum[d2] = new2;\n for (int i = 0; i < csz; i++) {\n int v = changes[i].v;\n int d = changes[i].d;\n int dd = changes[i].delta;\n if (dd != 0) incCount[v][d] += dd;\n }\n adj += deltaAdj;\n obj += delta;\n }\n }\n\n // output\n for (int i = 0; i < M; i++) {\n cout << (day[i] + 1) << (i + 1 == M ? '\\n' : ' ');\n }\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstruct Block {\n int x, y, z0, len;\n};\n\nstatic const int NEG = -1000000000;\n\n// Build blocks (columns) for one object\nvector build_blocks(const vector& f, const vector& r, int D) {\n vector occ(D * D * D, 0);\n vector> prev(D, vector(D, 0));\n\n for (int z = 0; z < D; ++z) {\n vector X, Y;\n for (int x = 0; x < D; ++x) if (f[z][x] == '1') X.push_back(x);\n for (int y = 0; y < D; ++y) if (r[z][y] == '1') Y.push_back(y);\n\n bool L_is_X = (X.size() >= Y.size());\n vector L = L_is_X ? X : Y;\n vector S = L_is_X ? Y : X;\n int n = L.size(), m = S.size();\n\n // weight matrix: 1 if pair existed in previous layer\n vector> w(n, vector(m, 0));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < m; ++j) {\n int x, y;\n if (L_is_X) { x = L[i]; y = S[j]; }\n else { x = S[j]; y = L[i]; }\n if (prev[x][y]) w[i][j] = 1;\n }\n }\n\n vector assign(n, 0);\n\n if (m == 1) {\n fill(assign.begin(), assign.end(), 0);\n } else {\n int M = 1 << m;\n vector dp(M, NEG), ndp(M, NEG);\n vector> par_mask(n, vector(M, -1));\n vector> par_choice(n, vector(M, -1));\n\n dp[0] = 0;\n for (int i = 0; i < n; ++i) {\n fill(ndp.begin(), ndp.end(), NEG);\n for (int mask = 0; mask < M; ++mask) if (dp[mask] > NEG/2) {\n for (int j = 0; j < m; ++j) {\n int nm = mask | (1 << j);\n int val = dp[mask] + w[i][j];\n if (val > ndp[nm]) {\n ndp[nm] = val;\n par_mask[i][nm] = mask;\n par_choice[i][nm] = j;\n }\n }\n }\n dp.swap(ndp);\n }\n\n int mask = M - 1;\n if (dp[mask] <= NEG/2) {\n for (int i = 0; i < n; ++i) assign[i] = i % m;\n } else {\n for (int i = n - 1; i >= 0; --i) {\n int j = par_choice[i][mask];\n if (j < 0) j = 0;\n assign[i] = j;\n mask = par_mask[i][mask];\n }\n }\n }\n\n vector> curr(D, vector(D, 0));\n for (int i = 0; i < n; ++i) {\n int j = assign[i];\n int x, y;\n if (L_is_X) { x = L[i]; y = S[j]; }\n else { x = S[j]; y = L[i]; }\n curr[x][y] = 1;\n occ[x * D * D + y * D + z] = 1;\n }\n prev.swap(curr);\n }\n\n // Extract vertical columns as blocks\n vector blocks;\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n int z = 0;\n while (z < D) {\n if (occ[x * D * D + y * D + z]) {\n int start = z;\n while (z + 1 < D && occ[x * D * D + y * D + (z + 1)]) ++z;\n int len = z - start + 1;\n blocks.push_back({x, y, start, len});\n ++z;\n } else ++z;\n }\n }\n }\n return blocks;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D;\n cin >> D;\n vector f[2], r[2];\n for (int i = 0; i < 2; ++i) {\n f[i].resize(D);\n r[i].resize(D);\n for (int z = 0; z < D; ++z) cin >> f[i][z];\n for (int z = 0; z < D; ++z) cin >> r[i][z];\n }\n\n vector blocks1 = build_blocks(f[0], r[0], D);\n vector blocks2 = build_blocks(f[1], r[1], D);\n\n vector> grp1(D + 1), grp2(D + 1);\n for (int i = 0; i < (int)blocks1.size(); ++i) grp1[blocks1[i].len].push_back(i);\n for (int i = 0; i < (int)blocks2.size(); ++i) grp2[blocks2[i].len].push_back(i);\n\n vector id1(blocks1.size()), id2(blocks2.size());\n int id = 1;\n for (int len = 1; len <= D; ++len) {\n auto &g1 = grp1[len], &g2 = grp2[len];\n int k = min(g1.size(), g2.size());\n for (int i = 0; i < k; ++i) {\n id1[g1[i]] = id;\n id2[g2[i]] = id;\n ++id;\n }\n for (int i = k; i < (int)g1.size(); ++i) id1[g1[i]] = id++;\n for (int i = k; i < (int)g2.size(); ++i) id2[g2[i]] = id++;\n }\n\n int nBlocks = id - 1;\n vector b1(D * D * D, 0), b2(D * D * D, 0);\n\n for (int i = 0; i < (int)blocks1.size(); ++i) {\n const auto &b = blocks1[i];\n int idv = id1[i];\n for (int z = b.z0; z < b.z0 + b.len; ++z)\n b1[b.x * D * D + b.y * D + z] = idv;\n }\n\n for (int i = 0; i < (int)blocks2.size(); ++i) {\n const auto &b = blocks2[i];\n int idv = id2[i];\n for (int z = b.z0; z < b.z0 + b.len; ++z)\n b2[b.x * D * D + b.y * D + z] = idv;\n }\n\n cout << nBlocks << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n if (i) cout << ' ';\n cout << b1[i];\n }\n cout << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n if (i) cout << ' ';\n cout << b2[i];\n }\n cout << \"\\n\";\n return 0;\n}","ahc020":"#include \nusing namespace std;\n\nstruct Edge {\n int to;\n long long w;\n int idx;\n};\n\nconst long long INF = (1LL<<60);\n\n// integer ceil(sqrt(x))\nint ceil_sqrt(long long x) {\n long long r = (long long)std::sqrt((double)x);\n while (r*r < x) ++r;\n while ((r-1)*(r-1) >= x) --r;\n return (int)r;\n}\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K;\n cin >> N >> M >> K;\n\n vector x(N), y(N);\n for(int i=0;i> x[i] >> y[i];\n\n vector u(M), v(M);\n vector w(M);\n vector> g(N);\n for(int i=0;i> u[i] >> v[i] >> w[i];\n --u[i]; --v[i];\n g[u[i]].push_back({v[i], w[i], i});\n g[v[i]].push_back({u[i], w[i], i});\n }\n\n vector a(K), b(K);\n for(int k=0;k> a[k] >> b[k];\n\n // Distances station -> resident (ceil)\n vector> distSR(N, vector(K));\n vector> coverList(N);\n vector coverCount(K, 0);\n\n for(int i=0;i> order(K, vector(N));\n for(int k=0;k ord(N);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int i,int j){\n int di = distSR[i][k], dj = distSR[j][k];\n if(di != dj) return di < dj;\n return i < j;\n });\n order[k] = move(ord);\n }\n\n // all-pairs shortest paths between stations\n vector> distAll(N, vector(N, INF));\n vector> prevNodeAll(N, vector(N, -1));\n vector> prevEdgeAll(N, vector(N, -1));\n\n for(int s=0; s dist(N, INF);\n vector prevV(N, -1), prevE(N, -1);\n dist[s]=0;\n priority_queue, vector>, greater>> pq;\n pq.push({0,s});\n while(!pq.empty()){\n auto [d,vtx]=pq.top(); pq.pop();\n if(d != dist[vtx]) continue;\n for(auto &e: g[vtx]){\n long long nd = d + e.w;\n if(nd < dist[e.to]){\n dist[e.to] = nd;\n prevV[e.to] = vtx;\n prevE[e.to] = e.idx;\n pq.push({nd, e.to});\n }\n }\n }\n distAll[s] = dist;\n prevNodeAll[s] = prevV;\n prevEdgeAll[s] = prevE;\n }\n\n // MST + union cost (actual cable cost)\n auto calc_edge_cost = [&](const vector& nodes,\n vector>* mstEdges = nullptr)->long long {\n int m = nodes.size();\n if(m <= 1){\n if(mstEdges) mstEdges->clear();\n return 0;\n }\n vector minDist(m, INF);\n vector parent(m, -1);\n vector used(m, false);\n minDist[0]=0;\n for(int it=0; it> edges;\n edges.reserve(m-1);\n for(int i=1;i usedEdge(M,false);\n long long cost=0;\n for(auto [u,v]: edges){\n int cur=v;\n while(cur != u){\n int e = prevEdgeAll[u][cur];\n if(e < 0) break;\n if(!usedEdge[e]){\n usedEdge[e]=true;\n cost += w[e];\n }\n cur = prevNodeAll[u][cur];\n }\n }\n return cost;\n };\n\n // Selected stations\n vector selected(N, true);\n\n // Assignment structures\n vector assignedStation(K, -1);\n vector> assignedResidents(N);\n vector radius(N, 0);\n\n // initial assignment (all stations)\n for(int k=0;k allNodes;\n allNodes.reserve(N);\n allNodes.push_back(0);\n for(int i=1;iint{\n for(int s: order[k]){\n if(!selected[s]) continue;\n if(s==removed) continue;\n return s;\n }\n return -1;\n };\n\n // Greedy removal loop\n while(true){\n long long bestCost = totalCost;\n long long bestRadiusCost = radiusCost;\n long long bestEdgeCost = edgeCost;\n int bestRemove = -1;\n\n for(int i=0;i add_max(N, 0);\n for(int k: assignedResidents[i]){\n int alt = nearest_station(k, i);\n if(alt < 0){ ok=false; break; }\n add_max[alt] = max(add_max[alt], distSR[alt][k]);\n }\n if(!ok) continue;\n\n long long newRadiusCost = radiusCost - 1LL*radius[i]*radius[i];\n for(int j=0;j radius[j]){\n newRadiusCost += 1LL*add_max[j]*add_max[j]\n - 1LL*radius[j]*radius[j];\n }\n }\n\n // compute new edge cost\n vector nodes;\n nodes.reserve(N);\n nodes.push_back(0);\n for(int j=1;j totalCost) break;\n\n // apply removal\n int rem = bestRemove;\n selected[rem]=false;\n for(int k: coverList[rem]) coverCount[k]--;\n\n for(int k: assignedResidents[rem]){\n int alt = nearest_station(k, -1);\n assignedStation[k] = alt;\n assignedResidents[alt].push_back(k);\n radius[alt] = max(radius[alt], distSR[alt][k]);\n }\n assignedResidents[rem].clear();\n radius[rem]=0;\n\n radiusCost = bestRadiusCost;\n edgeCost = bestEdgeCost;\n totalCost = bestCost;\n }\n\n // Recompute assignments and radii for final selected set\n for(int i=0;i selNodes;\n selNodes.push_back(0);\n for(int i=1;i> mstEdges;\n calc_edge_cost(selNodes, &mstEdges);\n\n vector B(M,0);\n for(auto [u,v]: mstEdges){\n int cur=v;\n while(cur != u){\n int e = prevEdgeAll[u][cur];\n if(e < 0) break;\n B[e]=1;\n cur = prevNodeAll[u][cur];\n }\n }\n\n // output\n for(int i=0;i 5000) p = 5000;\n cout << p << (i+1==N?'\\n':' ');\n }\n for(int j=0;j\nusing namespace std;\n\nstruct Move {\n int x1, y1, x2, y2;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int N = 30;\n const int LIMIT = 10000;\n\n vector> a(N);\n for (int x = 0; x < N; x++) {\n a[x].resize(x + 1);\n for (int y = 0; y <= x; y++) {\n if (!(cin >> a[x][y])) return 0;\n }\n }\n\n vector> inq(N, vector(N, 0));\n vector> st;\n vector ops;\n\n auto push_node = [&](int x, int y) {\n if (x < 0 || x >= N - 1) return;\n if (!inq[x][y]) {\n inq[x][y] = 1;\n st.emplace_back(x, y);\n }\n };\n\n // Initialize all internal nodes\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n push_node(x, y);\n }\n }\n\n auto push_parents = [&](int x, int y) {\n if (x == 0) return;\n if (y > 0) push_node(x - 1, y - 1);\n if (y <= x - 1) push_node(x - 1, y);\n };\n\n auto sift_down = [&](int x, int y) {\n while (x < N - 1 && ops.size() < LIMIT) {\n int cx1 = x + 1, cy1 = y;\n int cx2 = x + 1, cy2 = y + 1;\n int childx, childy;\n if (a[cx1][cy1] < a[cx2][cy2]) {\n childx = cx1; childy = cy1;\n } else {\n childx = cx2; childy = cy2;\n }\n if (a[x][y] <= a[childx][childy]) break;\n\n swap(a[x][y], a[childx][childy]);\n ops.push_back({x, y, childx, childy});\n\n // Value at (x,y) decreased -> parents may violate\n push_parents(x, y);\n\n x = childx; y = childy;\n }\n };\n\n while (!st.empty() && ops.size() < LIMIT) {\n auto [x, y] = st.back();\n st.pop_back();\n inq[x][y] = 0;\n\n if (a[x][y] > min(a[x+1][y], a[x+1][y+1])) {\n sift_down(x, y);\n }\n }\n\n cout << ops.size() << \"\\n\";\n for (auto &m : ops) {\n cout << m.x1 << \" \" << m.y1 << \" \" << m.x2 << \" \" << m.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nconst int OBST = -2;\nconst int ENTR = -1;\nconst int EMPTY = -3;\n\nint D;\nint entranceId;\nvector state;\nvector> neigh;\n\n// Count reachable empty cells after excluding one candidate (for safety check)\nint bfsCountExclude(int excludeId) {\n vector vis(D * D, 0);\n queue q;\n vis[entranceId] = 1;\n q.push(entranceId);\n int count = 0;\n\n while (!q.empty()) {\n int id = q.front(); q.pop();\n for (int nid : neigh[id]) {\n if (vis[nid]) continue;\n if (nid == excludeId) continue;\n if (state[nid] == OBST || state[nid] >= 0) continue;\n vis[nid] = 1;\n q.push(nid);\n if (state[nid] == EMPTY) count++;\n }\n }\n return count;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if (!(cin >> D >> N)) return 0;\n\n entranceId = 0 * D + (D - 1) / 2;\n\n state.assign(D * D, EMPTY);\n\n // Read obstacles\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n state[r * D + c] = OBST;\n }\n state[entranceId] = ENTR;\n\n // Precompute neighbors\n neigh.assign(D * D, {});\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n int id = i * D + j;\n if (i > 0) neigh[id].push_back((i - 1) * D + j);\n if (i + 1 < D) neigh[id].push_back((i + 1) * D + j);\n if (j > 0) neigh[id].push_back(i * D + (j - 1));\n if (j + 1 < D) neigh[id].push_back(i * D + (j + 1));\n }\n }\n\n // BFS distance from entrance (obstacles only)\n const int INF = 1e9;\n vector dist(D * D, INF);\n queue q;\n dist[entranceId] = 0;\n q.push(entranceId);\n while (!q.empty()) {\n int id = q.front(); q.pop();\n for (int nid : neigh[id]) {\n if (state[nid] == OBST) continue;\n if (dist[nid] != INF) continue;\n dist[nid] = dist[id] + 1;\n q.push(nid);\n }\n }\n\n // Priority order of cells\n vector priority;\n for (int id = 0; id < D * D; id++) {\n if (id == entranceId) continue;\n if (state[id] == OBST) continue;\n priority.push_back(id);\n }\n sort(priority.begin(), priority.end(), [&](int a, int b) {\n if (dist[a] != dist[b]) return dist[a] < dist[b];\n return a < b;\n });\n\n int M = D * D - 1 - N;\n vector used(M, 0);\n\n // Placement phase\n for (int step = 0; step < M; step++) {\n int t;\n cin >> t;\n\n // Rank among remaining labels\n int rem_smaller = 0;\n for (int x = 0; x < t; x++) if (!used[x]) rem_smaller++;\n int r = rem_smaller + 1;\n\n // Available cells in priority order\n vector avail;\n for (int id : priority) if (state[id] == EMPTY) avail.push_back(id);\n int L = avail.size();\n\n vector idxMap(D * D, -1);\n for (int i = 0; i < L; i++) idxMap[avail[i]] = i;\n\n int target = r - 1;\n\n int bestId = -1, bestDiff = 1e9, bestIdx = -1;\n for (int id : avail) {\n int cnt = bfsCountExclude(id);\n if (cnt != L - 1) continue; // unsafe\n\n int idx = idxMap[id];\n int diff = abs(idx - target);\n bool better = false;\n if (bestId == -1 || diff < bestDiff) better = true;\n else if (diff == bestDiff) {\n if (r <= L / 2) better = (idx < bestIdx);\n else better = (idx > bestIdx);\n }\n if (better) {\n bestId = id;\n bestDiff = diff;\n bestIdx = idx;\n }\n }\n\n if (bestId == -1) bestId = avail[0]; // fallback\n\n int pi = bestId / D;\n int pj = bestId % D;\n cout << pi << ' ' << pj << '\\n' << flush;\n\n state[bestId] = t;\n used[t] = 1;\n }\n\n // Retrieval phase\n vector> order;\n int remaining = M;\n while (remaining--) {\n vector vis(D * D, 0);\n queue q2;\n vis[entranceId] = 1;\n q2.push(entranceId);\n\n while (!q2.empty()) {\n int id = q2.front(); q2.pop();\n for (int nid : neigh[id]) {\n if (vis[nid]) continue;\n if (state[nid] == OBST || state[nid] >= 0) continue;\n vis[nid] = 1;\n q2.push(nid);\n }\n }\n\n int bestId = -1, bestLabel = INT_MAX;\n for (int id = 0; id < D * D; id++) {\n if (state[id] >= 0) {\n bool accessible = false;\n for (int nid : neigh[id]) {\n if (vis[nid]) { accessible = true; break; }\n }\n if (accessible && state[id] < bestLabel) {\n bestLabel = state[id];\n bestId = id;\n }\n }\n }\n if (bestId == -1) {\n for (int id = 0; id < D * D; id++) {\n if (state[id] >= 0) { bestId = id; break; }\n }\n }\n\n state[bestId] = EMPTY;\n order.emplace_back(bestId / D, bestId % D);\n }\n\n for (auto &p : order) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n cout.flush();\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint n, m;\nvector> original;\nvector> cnt_orig;\nvector cells_orig;\nvector> adj_orig;\nvector is_boundary;\n\nint vis[50][50];\nint qx[2500], qy[2500];\nint vis_id = 1;\n\nint dx[4] = {-1, 1, 0, 0};\nint dy[4] = {0, 0, -1, 1};\n\nbool connected_after_removal(const vector> &g,\n const vector &cells,\n int rx, int ry, int c) {\n if (cells[c] <= 1) return false;\n\n int sx = -1, sy = -1;\n for (int i = 0; i < n && sx == -1; i++) {\n for (int j = 0; j < n; j++) {\n if (i == rx && j == ry) continue;\n if (g[i][j] == c) {\n sx = i; sy = j;\n break;\n }\n }\n }\n if (sx == -1) return false;\n\n vis_id++;\n int head = 0, tail = 0;\n qx[tail] = sx; qy[tail] = sy; tail++;\n vis[sx][sy] = vis_id;\n int cnt = 1;\n\n while (head < tail) {\n int x = qx[head], y = qy[head]; head++;\n for (int dir = 0; dir < 4; dir++) {\n int nx = x + dx[dir], ny = y + dy[dir];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;\n if (nx == rx && ny == ry) continue;\n if (g[nx][ny] != c) continue;\n if (vis[nx][ny] == vis_id) continue;\n vis[nx][ny] = vis_id;\n qx[tail] = nx; qy[tail] = ny; tail++;\n cnt++;\n }\n }\n return cnt == cells[c] - 1;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> n >> m;\n original.assign(n, vector(n));\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++)\n cin >> original[i][j];\n\n // Compute initial adjacency counts\n cnt_orig.assign(m + 1, vector(m + 1, 0));\n cells_orig.assign(m + 1, 0);\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = original[i][j];\n cells_orig[c]++;\n if (i + 1 < n) {\n int d = original[i + 1][j];\n if (c != d) {\n cnt_orig[c][d]++; cnt_orig[d][c]++;\n }\n }\n if (j + 1 < n) {\n int d = original[i][j + 1];\n if (c != d) {\n cnt_orig[c][d]++; cnt_orig[d][c]++;\n }\n }\n if (i == 0) { cnt_orig[c][0]++; cnt_orig[0][c]++; }\n if (i == n - 1) { cnt_orig[c][0]++; cnt_orig[0][c]++; }\n if (j == 0) { cnt_orig[c][0]++; cnt_orig[0][c]++; }\n if (j == n - 1) { cnt_orig[c][0]++; cnt_orig[0][c]++; }\n }\n }\n\n // Original adjacency graph\n adj_orig.assign(m + 1, vector(m + 1, 0));\n for (int c = 0; c <= m; c++)\n for (int d = 0; d <= m; d++)\n if (cnt_orig[c][d] > 0) adj_orig[c][d] = 1;\n\n is_boundary.assign(m + 1, 0);\n for (int c = 1; c <= m; c++)\n if (adj_orig[c][0]) is_boundary[c] = 1;\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n vector> best = original;\n int best_zero = -1;\n\n auto start = chrono::steady_clock::now();\n const double TIME_LIMIT = 1.8;\n int iter = 0;\n\n while (true) {\n double elapsed = chrono::duration(chrono::steady_clock::now() - start).count();\n if (iter > 0 && elapsed > TIME_LIMIT) break;\n iter++;\n\n auto g = original;\n auto cnt = cnt_orig;\n auto cells = cells_orig;\n\n vector order(n * n);\n iota(order.begin(), order.end(), 0);\n\n auto adjacent_to_0 = [&](int x, int y) {\n if (x == 0 || x == n - 1 || y == 0 || y == n - 1) return true;\n for (int dir = 0; dir < 4; dir++) {\n int nx = x + dx[dir], ny = y + dy[dir];\n if (g[nx][ny] == 0) return true;\n }\n return false;\n };\n\n auto can_remove = [&](int x, int y) {\n int c = g[x][y];\n if (c == 0 || !is_boundary[c]) return false;\n if (!adjacent_to_0(x, y)) return false;\n\n int removed_to0 = 0, added_to0 = 0;\n int colors[4], decs[4], dec_sz = 0;\n\n for (int dir = 0; dir < 4; dir++) {\n int nx = x + dx[dir], ny = y + dy[dir];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n) {\n removed_to0++; continue;\n }\n int d = g[nx][ny];\n if (d == 0) removed_to0++;\n else if (d == c) added_to0++;\n else {\n if (!is_boundary[d]) return false; // would expose interior\n bool found = false;\n for (int k = 0; k < dec_sz; k++) {\n if (colors[k] == d) { decs[k]++; found = true; break; }\n }\n if (!found) { colors[dec_sz] = d; decs[dec_sz] = 1; dec_sz++; }\n }\n }\n\n for (int k = 0; k < dec_sz; k++) {\n int d = colors[k], dec = decs[k];\n if (adj_orig[c][d] && cnt[c][d] - dec <= 0) return false;\n }\n\n int new_cnt0 = cnt[c][0] - removed_to0 + added_to0;\n if (adj_orig[c][0] && new_cnt0 <= 0) return false;\n\n if (!connected_after_removal(g, cells, x, y, c)) return false;\n\n return true;\n };\n\n auto remove_cell = [&](int x, int y) {\n int c = g[x][y];\n g[x][y] = 0;\n cells[c]--;\n\n for (int dir = 0; dir < 4; dir++) {\n int nx = x + dx[dir], ny = y + dy[dir];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n) {\n cnt[c][0]--; cnt[0][c]--;\n } else {\n int d = g[nx][ny];\n if (d == 0) {\n cnt[c][0]--; cnt[0][c]--;\n } else if (d == c) {\n cnt[c][0]++; cnt[0][c]++;\n } else {\n cnt[c][d]--; cnt[d][c]--;\n cnt[d][0]++; cnt[0][d]++;\n }\n }\n }\n };\n\n bool changed = true;\n while (changed) {\n changed = false;\n shuffle(order.begin(), order.end(), rng);\n for (int idx : order) {\n int x = idx / n, y = idx % n;\n if (g[x][y] == 0) continue;\n if (can_remove(x, y)) {\n remove_cell(x, y);\n changed = true;\n }\n }\n if (chrono::duration(chrono::steady_clock::now() - start).count() > TIME_LIMIT) break;\n }\n\n int zeros = 0;\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++)\n if (g[i][j] == 0) zeros++;\n\n if (zeros > best_zero) {\n best_zero = zeros;\n best = g;\n }\n if (chrono::duration(chrono::steady_clock::now() - start).count() > TIME_LIMIT) break;\n }\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j) cout << ' ';\n cout << best[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nstruct Solver {\n int N, D, Q;\n int used = 0;\n mt19937 rng;\n vector order;\n vector est_w;\n vector assign;\n vector> bins;\n vector bin_sum;\n\n char ask(int a, int b) {\n // compare item a vs item b\n cout << 1 << \" \" << 1 << \" \" << a << \" \" << b << \"\\n\";\n cout.flush();\n string s;\n if (!(cin >> s)) exit(0);\n used++;\n return s[0];\n }\n\n void build_order() {\n int t = max(1, Q / N); // max comparisons per insertion\n vector items(N);\n iota(items.begin(), items.end(), 0);\n shuffle(items.begin(), items.end(), rng);\n\n order.clear();\n order.reserve(N);\n\n for (int x : items) {\n if (order.empty()) {\n order.push_back(x);\n continue;\n }\n int low = 0, high = (int)order.size();\n int steps = 0;\n while (low < high && steps < t && used < Q) {\n int mid = (low + high) / 2;\n char res = ask(x, order[mid]);\n steps++;\n if (res == '>') {\n high = mid;\n } else {\n low = mid + 1;\n }\n }\n int pos = (low + high) / 2;\n order.insert(order.begin() + pos, x);\n }\n }\n\n void refine_order() {\n int remaining = Q - used;\n if (N < 2) {\n // not expected due to constraints, but just in case\n for (int i = 0; i < remaining; i++) ask(0, 1);\n return;\n }\n for (int k = 0; k < remaining; k++) {\n int idx = (int)(rng() % (N - 1));\n char res = ask(order[idx], order[idx + 1]);\n if (res == '<') { // wrong order, swap\n swap(order[idx], order[idx + 1]);\n }\n }\n }\n\n void estimate_weights() {\n const double lambda = 1e-5;\n vector H(N + 1, 0.0);\n for (int i = 1; i <= N; i++) H[i] = H[i - 1] + 1.0 / i;\n\n est_w.assign(N, 0.0);\n for (int r = 0; r < N; r++) {\n int idx = order[r];\n est_w[idx] = (H[N] - H[r]) / lambda;\n }\n }\n\n void initial_partition() {\n bins.assign(D, {});\n bin_sum.assign(D, 0.0);\n assign.assign(N, 0);\n\n for (int idx : order) {\n int best = 0;\n for (int d = 1; d < D; d++) {\n if (bin_sum[d] < bin_sum[best]) best = d;\n }\n bins[best].push_back(idx);\n assign[idx] = best;\n bin_sum[best] += est_w[idx];\n }\n }\n\n void improve() {\n double total = 0;\n for (double s : bin_sum) total += s;\n double mean = total / D;\n\n for (int iter = 0; iter < 1000; iter++) {\n int heavy = max_element(bin_sum.begin(), bin_sum.end()) - bin_sum.begin();\n int light = min_element(bin_sum.begin(), bin_sum.end()) - bin_sum.begin();\n if (heavy == light) break;\n if (bin_sum[heavy] - bin_sum[light] <= 1e-9) break;\n\n int best_item = -1;\n double best_delta = 0.0;\n\n for (int item : bins[heavy]) {\n double w = est_w[item];\n double newA = bin_sum[heavy] - w;\n double newB = bin_sum[light] + w;\n double delta =\n (newA - mean) * (newA - mean) + (newB - mean) * (newB - mean) -\n (bin_sum[heavy] - mean) * (bin_sum[heavy] - mean) -\n (bin_sum[light] - mean) * (bin_sum[light] - mean);\n if (delta < best_delta) {\n best_delta = delta;\n best_item = item;\n }\n }\n\n if (best_item == -1) break;\n\n auto &bh = bins[heavy];\n bh.erase(find(bh.begin(), bh.end(), best_item));\n bins[light].push_back(best_item);\n assign[best_item] = light;\n bin_sum[heavy] -= est_w[best_item];\n bin_sum[light] += est_w[best_item];\n }\n }\n\n void output_answer() {\n for (int i = 0; i < N; i++) {\n if (i) cout << \" \";\n cout << assign[i];\n }\n cout << \"\\n\";\n cout.flush();\n }\n\n void solve() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n if (!(cin >> N >> D >> Q)) return;\n rng.seed(712367 + N * 10007 + D * 1009 + Q);\n\n build_order();\n refine_order(); // consumes remaining queries\n\n estimate_weights();\n initial_partition();\n improve();\n\n output_answer();\n }\n};\n\nint main() {\n Solver s;\n s.solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\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 h = n / m;\n\n vector> stacks(m);\n for (int i = 0; i < m; i++) {\n stacks[i].resize(h);\n for (int j = 0; j < h; j++) cin >> stacks[i][j];\n }\n\n vector> ops;\n const int INF = 1e9;\n\n for (int v = 1; v <= n; v++) {\n int s = -1, pos = -1;\n for (int i = 0; i < m && s == -1; i++) {\n for (int j = 0; j < (int)stacks[i].size(); j++) {\n if (stacks[i][j] == v) {\n s = i;\n pos = j;\n break;\n }\n }\n }\n\n if (s == -1) return 0; // should never happen\n\n if (pos == (int)stacks[s].size() - 1) {\n // already on top\n ops.emplace_back(v, 0);\n stacks[s].pop_back();\n } else {\n int segStart = pos + 1;\n vector seg(stacks[s].begin() + segStart, stacks[s].end());\n\n int maxS = -1;\n for (int x : seg) maxS = max(maxS, x);\n\n // min value in each stack\n vector minVal(m, INF);\n for (int i = 0; i < m; i++) {\n if (!stacks[i].empty()) {\n int mn = INF;\n for (int x : stacks[i]) mn = min(mn, x);\n minVal[i] = mn;\n }\n }\n\n int dest = -1;\n\n // Safe stack search (minVal > maxS), best fit\n int bestSafeMin = INF, bestSafeHeight = INF;\n for (int i = 0; i < m; i++) {\n if (i == s) continue;\n if (minVal[i] > maxS) {\n if (minVal[i] < bestSafeMin ||\n (minVal[i] == bestSafeMin && (int)stacks[i].size() < bestSafeHeight)) {\n bestSafeMin = minVal[i];\n bestSafeHeight = stacks[i].size();\n dest = i;\n }\n }\n }\n\n // No safe stack -> choose largest minimum\n if (dest == -1) {\n int bestMin = -1, bestHeight = INF;\n for (int i = 0; i < m; i++) {\n if (i == s) continue;\n if (minVal[i] > bestMin ||\n (minVal[i] == bestMin && (int)stacks[i].size() < bestHeight)) {\n bestMin = minVal[i];\n bestHeight = stacks[i].size();\n dest = i;\n }\n }\n }\n\n if (dest == -1) dest = (s + 1) % m;\n\n int moveBox = stacks[s][segStart];\n ops.emplace_back(moveBox, dest + 1);\n\n stacks[dest].insert(stacks[dest].end(), seg.begin(), seg.end());\n stacks[s].erase(stacks[s].begin() + segStart, stacks[s].end());\n\n // now v is on top\n ops.emplace_back(v, 0);\n stacks[s].pop_back();\n }\n }\n\n for (auto &op : ops) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nstruct Neighbor {\n int to;\n char dir;\n};\n\nint N, N2;\nvector dval;\nvector> adj;\nvector base_moves;\nvector visited;\nvector> occ;\nvector bounce_dir;\nvector sorted_ids;\nvector w_sqrt;\nint L0;\n\nchar opposite(char c) {\n if (c == 'U') return 'D';\n if (c == 'D') return 'U';\n if (c == 'L') return 'R';\n return 'L';\n}\n\nint move_id(int id, char dir) {\n int i = id / N;\n int j = id % N;\n if (dir == 'U') --i;\n else if (dir == 'D') ++i;\n else if (dir == 'L') --j;\n else if (dir == 'R') ++j;\n return i * N + j;\n}\n\n// DFS base tour\nvoid dfs(int id) {\n visited[id] = 1;\n for (auto &nb : adj[id]) {\n if (!visited[nb.to]) {\n base_moves.push_back(nb.dir);\n dfs(nb.to);\n base_moves.push_back(opposite(nb.dir));\n }\n }\n}\n\n// Evaluate average dirtiness\nlong double evaluate(const vector& route) {\n int L = route.size();\n vector first(N2, -1), last(N2, -1);\n long long total = 0;\n int cur = 0;\n for (int t = 0; t < L; ++t) {\n int id = cur;\n if (first[id] == -1) {\n first[id] = last[id] = t;\n } else {\n int interval = t - last[id];\n total += (long long)dval[id] * interval * (interval - 1) / 2;\n last[id] = t;\n }\n if (t < L - 1) cur = move_id(cur, route[t]);\n }\n for (int id = 0; id < N2; ++id) {\n if (first[id] == -1) continue;\n int interval = L - last[id] + first[id];\n total += (long long)dval[id] * interval * (interval - 1) / 2;\n }\n return (long double)total / (long double)L;\n}\n\n// Build route with B bounces\nvector build_route(int B, bool useSqrt, int K) {\n vector loops_cell(N2, 0);\n if (B > 0) {\n int K2 = min(K, N2);\n long double w_sum = 0.0;\n vector selected;\n selected.reserve(K2);\n for (int i = 0; i < K2; ++i) {\n int id = sorted_ids[i];\n selected.push_back(id);\n w_sum += useSqrt ? w_sqrt[id] : (long double)dval[id];\n }\n vector> fracs;\n long long used = 0;\n for (int id : selected) {\n long double w = useSqrt ? w_sqrt[id] : (long double)dval[id];\n long double exact = (long double)B * w / w_sum;\n int b = (int)floor(exact);\n loops_cell[id] = b;\n used += b;\n fracs.push_back({exact - b, id});\n }\n int rem = B - (int)used;\n sort(fracs.begin(), fracs.end(),\n [](auto &a, auto &b){ return a.first > b.first; });\n for (int i = 0; i < rem && i < (int)fracs.size(); ++i)\n loops_cell[fracs[i].second]++;\n }\n\n vector loops_at_time(L0, 0);\n for (int id = 0; id < N2; ++id) {\n int b = loops_cell[id];\n if (b == 0) continue;\n const auto &vec = occ[id];\n int c = vec.size();\n if (c == 0) continue;\n int base = b / c;\n int rem = b % c;\n for (int k = 0; k < c; ++k) {\n int add = base + (k < rem ? 1 : 0);\n if (add) loops_at_time[vec[k]] += add;\n }\n }\n\n vector route;\n route.reserve(L0 + 2LL * B);\n int cur = 0;\n for (int t = 0; t < L0; ++t) {\n int loops = loops_at_time[t];\n if (loops > 0) {\n char dir = bounce_dir[cur];\n char back = opposite(dir);\n for (int l = 0; l < loops; ++l) {\n route.push_back(dir);\n route.push_back(back);\n }\n }\n route.push_back(base_moves[t]);\n cur = move_id(cur, base_moves[t]);\n }\n return route;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n N2 = N * N;\n\n vector h(N-1), v(N);\n for (int i = 0; i < N-1; ++i) cin >> h[i];\n for (int i = 0; i < N; ++i) cin >> v[i];\n\n dval.assign(N2, 0);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> dval[i * N + j];\n\n // Build adjacency\n adj.assign(N2, {});\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int id = i * N + j;\n if (i > 0 && h[i-1][j] == '0') adj[id].push_back({id-N, 'U'});\n if (i+1 < N && h[i][j] == '0') adj[id].push_back({id+N, 'D'});\n if (j > 0 && v[i][j-1] == '0') adj[id].push_back({id-1, 'L'});\n if (j+1 < N && v[i][j] == '0') adj[id].push_back({id+1, 'R'});\n }\n }\n for (int id = 0; id < N2; ++id)\n sort(adj[id].begin(), adj[id].end(),\n [&](const Neighbor& a, const Neighbor& b) {\n return dval[a.to] > dval[b.to];\n });\n\n // DFS base route\n visited.assign(N2, 0);\n base_moves.clear();\n base_moves.reserve(2 * N2);\n dfs(0);\n L0 = base_moves.size();\n\n // Occurrences\n occ.assign(N2, {});\n int cur = 0;\n for (int t = 0; t < L0; ++t) {\n occ[cur].push_back(t);\n if (t < L0 - 1) cur = move_id(cur, base_moves[t]);\n }\n\n // Bounce direction\n bounce_dir.assign(N2, 'U');\n for (int id = 0; id < N2; ++id)\n if (!adj[id].empty()) bounce_dir[id] = adj[id][0].dir;\n\n // Sort cells\n sorted_ids.resize(N2);\n iota(sorted_ids.begin(), sorted_ids.end(), 0);\n sort(sorted_ids.begin(), sorted_ids.end(),\n [&](int a, int b) { return dval[a] > dval[b]; });\n\n // Weights\n w_sqrt.resize(N2);\n for (int id = 0; id < N2; ++id)\n w_sqrt[id] = sqrt((long double)dval[id]);\n\n // Candidate search\n const int LMAX = 100000;\n int B_max = (LMAX - L0) / 2;\n if (B_max < 0) B_max = 0;\n\n vector best_route = base_moves;\n long double best_score = evaluate(base_moves);\n\n if (B_max > 0) {\n vector fracs = {0.1, 0.25, 0.5, 0.75, 1.0};\n int K_top = min(50, N2);\n vector K_choices = {N2};\n if (K_top < N2) K_choices.push_back(K_top);\n\n for (int useSqrtInt = 0; useSqrtInt < 2; ++useSqrtInt) {\n bool useSqrt = (useSqrtInt == 0);\n for (int K : K_choices) {\n for (double f : fracs) {\n int B = (int)floor(B_max * f + 1e-9);\n if (B <= 0) continue;\n vector route = build_route(B, useSqrt, K);\n long double score = evaluate(route);\n if (score < best_score) {\n best_score = score;\n best_route = std::move(route);\n }\n }\n }\n }\n }\n\n string out;\n out.reserve(best_route.size());\n for (char c : best_route) out.push_back(c);\n cout << out << '\\n';\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstruct Pos {\n int r, c;\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\n int si, sj;\n cin >> si >> sj;\n\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n\n vector words(M);\n for (int i = 0; i < M; i++) cin >> words[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 pos[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n\n // remove substrings\n auto removeContained = [&](vector& w) {\n int n = w.size();\n vector removed(n, false);\n for (int i = 0; i < n; i++) {\n if (removed[i]) continue;\n for (int j = 0; j < n; j++) {\n if (i == j) continue;\n if (w[i].size() > w[j].size()) continue;\n if (w[j].find(w[i]) != string::npos) {\n removed[i] = true;\n break;\n }\n }\n }\n vector nw;\n for (int i = 0; i < n; i++)\n if (!removed[i]) nw.push_back(w[i]);\n w.swap(nw);\n };\n\n // overlap length\n auto overlap = [&](const string& a, const string& b) {\n int maxk = min(a.size(), b.size());\n for (int k = maxk; k >= 1; k--) {\n if (a.compare(a.size() - k, k, b, 0, k) == 0) return k;\n }\n return 0;\n };\n\n // greedy superstring\n vector cur = words;\n while (true) {\n removeContained(cur);\n if (cur.size() == 1) break;\n\n int n = cur.size();\n int bestI = 0, bestJ = 1, bestOv = -1, bestLen = INT_MAX;\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (i == j) continue;\n int ov = overlap(cur[i], cur[j]);\n int mergedLen = (int)cur[i].size() + (int)cur[j].size() - ov;\n if (ov > bestOv || (ov == bestOv && mergedLen < bestLen)) {\n bestOv = ov;\n bestLen = mergedLen;\n bestI = i;\n bestJ = j;\n }\n }\n }\n\n string merged = cur[bestI] + cur[bestJ].substr(bestOv);\n vector nxt;\n for (int i = 0; i < n; i++) {\n if (i == bestI || i == bestJ) continue;\n nxt.push_back(cur[i]);\n }\n nxt.push_back(merged);\n cur.swap(nxt);\n }\n\n string S = cur[0];\n int L = S.size();\n\n // DP for minimum movement\n const long long INF = (1LL << 60);\n vector> parent(L);\n vector prevCost, curCost;\n\n int first = S[0] - 'A';\n auto& cand0 = pos[first];\n int d0 = cand0.size();\n prevCost.assign(d0, INF);\n parent[0].assign(d0, -1);\n\n for (int i = 0; i < d0; i++) {\n prevCost[i] = abs(si - cand0[i].r) + abs(sj - cand0[i].c) + 1;\n }\n\n for (int i = 1; i < L; i++) {\n int prevLetter = S[i - 1] - 'A';\n int curLetter = S[i] - 'A';\n auto& prevCand = pos[prevLetter];\n auto& curCand = pos[curLetter];\n\n int nPrev = prevCand.size();\n int nCur = curCand.size();\n\n curCost.assign(nCur, INF);\n parent[i].assign(nCur, -1);\n\n for (int j = 0; j < nCur; j++) {\n long long best = INF;\n int bestIdx = -1;\n for (int p = 0; p < nPrev; p++) {\n long long cost = prevCost[p]\n + abs(prevCand[p].r - curCand[j].r)\n + abs(prevCand[p].c - curCand[j].c)\n + 1;\n if (cost < best) {\n best = cost;\n bestIdx = p;\n }\n }\n curCost[j] = best;\n parent[i][j] = bestIdx;\n }\n prevCost.swap(curCost);\n }\n\n long long best = INF;\n int idx = 0;\n for (int j = 0; j < (int)prevCost.size(); j++) {\n if (prevCost[j] < best) {\n best = prevCost[j];\n idx = j;\n }\n }\n\n vector path(L);\n for (int i = L - 1; i >= 0; i--) {\n int letter = S[i] - 'A';\n path[i] = pos[letter][idx];\n idx = parent[i][idx];\n }\n\n for (auto& p : path) {\n cout << p.r << \" \" << p.c << \"\\n\";\n }\n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct Field {\n vector> cells;\n int max_i = 0, max_j = 0;\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 int N2 = N * N;\n\n vector fields(M);\n long long totalArea = 0;\n for (int k = 0; k < M; k++) {\n int d; cin >> d;\n totalArea += d;\n fields[k].cells.reserve(d);\n int max_i = 0, max_j = 0;\n for (int t = 0; t < d; t++) {\n int x, y; cin >> x >> y;\n fields[k].cells.push_back({x, y});\n max_i = max(max_i, x);\n max_j = max(max_j, y);\n }\n fields[k].max_i = max_i;\n fields[k].max_j = max_j;\n }\n\n // Precompute placements and coverage\n vector>> placementCells(M);\n vector>> coverByCell(M);\n for (int k = 0; k < M; k++) {\n coverByCell[k].assign(N2, {});\n const auto &shape = fields[k].cells;\n int max_i = fields[k].max_i;\n int max_j = fields[k].max_j;\n for (int di = 0; di + max_i < N; ++di) {\n for (int dj = 0; dj + max_j < N; ++dj) {\n int p = placementCells[k].size();\n placementCells[k].push_back({});\n auto &vec = placementCells[k].back();\n vec.reserve(shape.size());\n for (auto [x, y] : shape) {\n int ni = x + di;\n int nj = y + dj;\n int id = ni * N + nj;\n vec.push_back(id);\n coverByCell[k][id].push_back(p);\n }\n }\n }\n }\n\n vector> activeCoverCountField(M, vector(N2, 0));\n vector> activePlacement(M);\n vector activePlacementsCount(M, 0);\n vector globalCoverCount(N2, 0);\n\n for (int k = 0; k < M; k++) {\n int P = placementCells[k].size();\n activePlacementsCount[k] = P;\n activePlacement[k].assign(P, 1);\n for (int id = 0; id < N2; ++id) {\n int cnt = (int)coverByCell[k][id].size();\n activeCoverCountField[k][id] = cnt;\n globalCoverCount[id] += cnt;\n }\n }\n\n auto drill = [&](int i, int j) -> int {\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n int v;\n if (!(cin >> v)) exit(0);\n return v;\n };\n\n vector drilled(N2, false);\n vector> oilCells;\n long long sumFound = 0;\n int queries = 0;\n\n auto deactivate_placement = [&](int k, int p) {\n activePlacement[k][p] = 0;\n activePlacementsCount[k]--;\n for (int id : placementCells[k][p]) {\n activeCoverCountField[k][id]--;\n globalCoverCount[id]--;\n }\n };\n\n auto process_zero = [&](int cellId) {\n for (int k = 0; k < M; k++) {\n for (int p : coverByCell[k][cellId]) {\n if (activePlacement[k][p]) deactivate_placement(k, p);\n }\n }\n };\n\n auto select_cell = [&]() -> int {\n double bestScore = -1.0;\n int bestId = -1;\n for (int id = 0; id < N2; ++id) {\n if (drilled[id]) continue;\n if (globalCoverCount[id] == 0) continue;\n double score = 0.0;\n for (int k = 0; k < M; k++) {\n int denom = activePlacementsCount[k];\n if (denom == 0) continue;\n score += (double)activeCoverCountField[k][id] / denom;\n }\n if (score > bestScore) {\n bestScore = score;\n bestId = id;\n }\n }\n return bestId;\n };\n\n while (sumFound < totalArea && queries < 2 * N2) {\n int id = select_cell();\n if (id == -1) break;\n int i = id / N;\n int j = id % N;\n int v = drill(i, j);\n queries++;\n drilled[id] = true;\n if (v > 0) {\n oilCells.push_back({i, j});\n sumFound += v;\n } else {\n process_zero(id);\n }\n }\n\n // If still uncertain, drill all remaining cells\n if (sumFound < totalArea && queries < 2 * N2) {\n for (int id = 0; id < N2 && queries < 2 * N2; ++id) {\n if (drilled[id]) continue;\n int i = id / N;\n int j = id % N;\n int v = drill(i, j);\n queries++;\n drilled[id] = true;\n if (v > 0) {\n oilCells.push_back({i, j});\n sumFound += v;\n }\n }\n }\n\n cout << \"a \" << oilCells.size();\n for (auto [i, j] : oilCells) cout << \" \" << i << \" \" << j;\n cout << \"\\n\";\n cout.flush();\n\n int res;\n if (!(cin >> res)) return 0;\n if (res == 1) return 0;\n\n // Fallback (should not happen): drill rest & answer again\n for (int id = 0; id < N2 && queries < 2 * N2; ++id) {\n if (drilled[id]) continue;\n int i = id / N;\n int j = id % N;\n int v = drill(i, j);\n queries++;\n drilled[id] = true;\n if (v > 0) oilCells.push_back({i, j});\n }\n cout << \"a \" << oilCells.size();\n for (auto [i, j] : oilCells) cout << \" \" << i << \" \" << j;\n cout << \"\\n\";\n cout.flush();\n cin >> res;\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nstruct Rect {\n int i0, j0, i1, j1;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) cin >> a[d][k];\n }\n\n const int INF = 1e9;\n\n for (int d = 0; d < D; d++) {\n const vector& ad = a[d];\n\n // minH[l][r]: minimal height for segment [l,r)\n vector> minH(N, vector(N + 1, INF));\n\n for (int l = 0; l < N; l++) {\n for (int r = l + 1; r <= N; r++) {\n int max_need = 1;\n for (int k = l; k < r; k++) {\n max_need = max(max_need, (ad[k] + W - 1) / W);\n }\n if (max_need > W) continue;\n\n auto width_sum = [&](int h) -> int {\n int sum = 0;\n for (int k = l; k < r; k++) {\n sum += (ad[k] + h - 1) / h;\n if (sum > W) break;\n }\n return sum;\n };\n\n if (width_sum(W) > W) continue;\n\n int low = max_need, high = W;\n while (low < high) {\n int mid = (low + high) / 2;\n if (width_sum(mid) <= W) high = mid;\n else low = mid + 1;\n }\n minH[l][r] = low;\n }\n }\n\n // DP to partition into rows\n vector dpH(N + 1, INF), dpR(N + 1, INF), prev(N + 1, -1);\n dpH[0] = 0;\n dpR[0] = 0;\n for (int i = 1; i <= N; i++) {\n for (int j = 0; j < i; j++) {\n int h = minH[j][i];\n if (h == INF || dpH[j] == INF) continue;\n int candH = dpH[j] + h;\n int candR = dpR[j] + 1;\n if (candH < dpH[i] || (candH == dpH[i] && candR < dpR[i])) {\n dpH[i] = candH;\n dpR[i] = candR;\n prev[i] = j;\n }\n }\n }\n\n vector rects(N);\n\n if (dpH[N] > W || prev[N] == -1) {\n // Fallback: simple horizontal stripes\n for (int k = 0; k < N; k++) {\n rects[k] = {k, 0, k + 1, W};\n }\n } else {\n struct Row { int l, r, h; };\n vector rows;\n int idx = N;\n while (idx > 0) {\n int j = prev[idx];\n int h = minH[j][idx];\n rows.push_back({j, idx, h});\n idx = j;\n }\n reverse(rows.begin(), rows.end());\n\n int totalH = 0;\n for (auto &row : rows) totalH += row.h;\n if (totalH < W) rows.back().h += (W - totalH);\n\n int y = 0;\n for (auto &row : rows) {\n int l = row.l, r = row.r, h = row.h;\n vector widths;\n widths.reserve(r - l);\n int sumw = 0;\n for (int k = l; k < r; k++) {\n int w = (ad[k] + h - 1) / h;\n widths.push_back(w);\n sumw += w;\n }\n int leftover = W - sumw;\n if (!widths.empty()) widths.back() += leftover;\n\n int x = 0;\n for (int t = 0; t < (int)widths.size(); t++) {\n int k = l + t;\n int w = widths[t];\n rects[k] = {y, x, y + h, x + w};\n x += w;\n }\n y += h;\n }\n }\n\n // Output\n for (int k = 0; k < N; k++) {\n auto &r = rects[k];\n cout << r.i0 << \" \" << r.j0 << \" \" << r.i1 << \" \" << r.j1 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nconstexpr int N = 9;\nconstexpr int M = 20;\nconstexpr int K = 81;\nconstexpr int P = 998244353;\n\nstruct Op {\n int m, p, q;\n int cell[9];\n int val[9];\n};\n\nstruct XorShift {\n uint64_t x;\n XorShift(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n uint32_t next_u32() {\n x ^= x << 7;\n x ^= x >> 9;\n return (uint32_t)x;\n }\n double next_double() { return next_u32() / 4294967296.0; }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N_in, M_in, K_in;\n if (!(cin >> N_in >> M_in >> K_in)) return 0;\n\n int a[N][N];\n for (int i = 0; i < N; i++)\n for (int j = 0; j < N; j++)\n cin >> a[i][j];\n\n int s[M][3][3];\n for (int m = 0; m < M; m++)\n for (int i = 0; i < 3; i++)\n for (int j = 0; j < 3; j++)\n cin >> s[m][i][j];\n\n // Precompute all possible operations\n vector ops;\n ops.reserve(M * (N - 2) * (N - 2));\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 Op op;\n op.m = m; op.p = p; op.q = q;\n int idx = 0;\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n op.cell[idx] = (p + i) * N + (q + j);\n op.val[idx] = s[m][i][j];\n idx++;\n }\n }\n ops.push_back(op);\n }\n }\n }\n\n // Initial board\n int board[81];\n long long score = 0;\n for (int i = 0; i < N; i++)\n for (int j = 0; j < N; j++) {\n board[i * N + j] = a[i][j];\n score += a[i][j];\n }\n\n vector cur_ops;\n cur_ops.reserve(K);\n\n // Greedy initialization\n for (int step = 0; step < K; step++) {\n long long best_delta = 0;\n int best_id = -1;\n for (int id = 0; id < (int)ops.size(); id++) {\n const Op &op = ops[id];\n long long delta = 0;\n for (int k = 0; k < 9; k++) {\n int idx = op.cell[k];\n int cur = board[idx];\n int nv = cur + op.val[k];\n if (nv >= P) nv -= P;\n delta += (long long)nv - cur;\n }\n if (delta > best_delta) {\n best_delta = delta;\n best_id = id;\n }\n }\n if (best_id == -1) break;\n const Op &op = ops[best_id];\n for (int k = 0; k < 9; k++) {\n int idx = op.cell[k];\n int nv = board[idx] + op.val[k];\n if (nv >= P) nv -= P;\n board[idx] = nv;\n }\n score += best_delta;\n cur_ops.push_back(best_id);\n }\n\n vector best_ops = cur_ops;\n long long best_score = score;\n\n // Simulated Annealing\n XorShift rng(chrono::steady_clock::now().time_since_epoch().count());\n auto start = chrono::steady_clock::now();\n const double TIME_LIMIT = 1.85;\n const double T0 = 1e9, T1 = 1e6;\n\n struct Diff { int idx, diff; };\n Diff diffs[18];\n\n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration_cast>(now - start).count();\n if (elapsed >= TIME_LIMIT) break;\n\n double t = elapsed / TIME_LIMIT;\n double T = T0 + (T1 - T0) * t;\n\n int L = cur_ops.size();\n int move_type;\n if (L == 0) move_type = 0;\n else if (L == K) move_type = (rng.next_u32() & 1) ? 1 : 2;\n else {\n uint32_t r = rng.next_u32() % 100;\n if (r < 40) move_type = 0;\n else if (r < 60) move_type = 1;\n else move_type = 2;\n }\n\n if (move_type == 0) {\n int id = rng.next_u32() % ops.size();\n const Op &op = ops[id];\n long long delta = 0;\n for (int k = 0; k < 9; k++) {\n int idx = op.cell[k];\n int cur = board[idx];\n int nv = cur + op.val[k];\n if (nv >= P) nv -= P;\n delta += (long long)nv - cur;\n }\n if (delta >= 0 || rng.next_double() < exp((double)delta / T)) {\n for (int k = 0; k < 9; k++) {\n int idx = op.cell[k];\n int nv = board[idx] + op.val[k];\n if (nv >= P) nv -= P;\n board[idx] = nv;\n }\n score += delta;\n cur_ops.push_back(id);\n if (score > best_score) {\n best_score = score;\n best_ops = cur_ops;\n }\n }\n } else if (move_type == 1) {\n int idx_in_list = rng.next_u32() % L;\n int id = cur_ops[idx_in_list];\n const Op &op = ops[id];\n long long delta = 0;\n for (int k = 0; k < 9; k++) {\n int idx = op.cell[k];\n int cur = board[idx];\n int nv = cur - op.val[k];\n if (nv < 0) nv += P;\n delta += (long long)nv - cur;\n }\n if (delta >= 0 || rng.next_double() < exp((double)delta / T)) {\n for (int k = 0; k < 9; k++) {\n int idx = op.cell[k];\n int nv = board[idx] - op.val[k];\n if (nv < 0) nv += P;\n board[idx] = nv;\n }\n score += delta;\n cur_ops[idx_in_list] = cur_ops.back();\n cur_ops.pop_back();\n if (score > best_score) {\n best_score = score;\n best_ops = cur_ops;\n }\n }\n } else {\n int idx_in_list = rng.next_u32() % L;\n int old_id = cur_ops[idx_in_list];\n int new_id = rng.next_u32() % ops.size();\n if (old_id == new_id) continue;\n\n const Op &old_op = ops[old_id];\n const Op &new_op = ops[new_id];\n int cnt = 0;\n\n auto add_diff = [&](int cell, int diff) {\n for (int i = 0; i < cnt; i++) {\n if (diffs[i].idx == cell) {\n diffs[i].diff += diff;\n return;\n }\n }\n diffs[cnt++] = {cell, diff};\n };\n\n for (int k = 0; k < 9; k++) add_diff(old_op.cell[k], -old_op.val[k]);\n for (int k = 0; k < 9; k++) add_diff(new_op.cell[k], new_op.val[k]);\n\n long long delta = 0;\n for (int i = 0; i < cnt; i++) {\n int idx = diffs[i].idx;\n int diff = diffs[i].diff;\n if (diff == 0) continue;\n int cur = board[idx];\n int nv = cur + diff;\n if (nv >= P) nv -= P;\n else if (nv < 0) nv += P;\n delta += (long long)nv - cur;\n }\n\n if (delta >= 0 || rng.next_double() < exp((double)delta / T)) {\n for (int i = 0; i < cnt; i++) {\n int idx = diffs[i].idx;\n int diff = diffs[i].diff;\n if (diff == 0) continue;\n int nv = board[idx] + diff;\n if (nv >= P) nv -= P;\n else if (nv < 0) nv += P;\n board[idx] = nv;\n }\n score += delta;\n cur_ops[idx_in_list] = new_id;\n if (score > best_score) {\n best_score = score;\n best_ops = cur_ops;\n }\n }\n }\n }\n\n cout << best_ops.size() << \"\\n\";\n for (int id : best_ops) {\n const Op &op = ops[id];\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n return 0;\n}","ahc033":"#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> 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 vector ans(N);\n int turn = 0;\n\n auto append_turn = [&](char act_large) {\n if (turn == 0) {\n ans[0].push_back(act_large);\n for (int i = 1; i < N; i++) ans[i].push_back('B'); // bomb small cranes\n } else {\n ans[0].push_back(act_large);\n for (int i = 1; i < N; i++) ans[i].push_back('.');\n }\n turn++;\n };\n\n int r = 0, c = 0;\n auto move_to = [&](int tr, int tc) {\n while (r < tr) { append_turn('D'); r++; }\n while (r > tr) { append_turn('U'); r--; }\n while (c < tc) { append_turn('R'); c++; }\n while (c > tc) { append_turn('L'); c--; }\n };\n\n vector idx(N, 0);\n int processed = 0;\n\n while (processed < N * N) {\n int best = -1, bestVal = 1e9;\n for (int i = 0; i < N; i++) {\n if (idx[i] < N) {\n int v = A[i][idx[i]];\n if (v < bestVal) {\n bestVal = v;\n best = i;\n }\n }\n }\n if (best == -1) break;\n\n move_to(best, 0);\n append_turn('P');\n\n int cont = A[best][idx[best]];\n idx[best]++;\n processed++;\n\n int dest = cont / N;\n move_to(dest, N - 1);\n append_turn('Q');\n }\n\n for (int i = 0; i < N; i++) {\n cout << ans[i] << \"\\n\";\n }\n\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nusing ll = long long;\n\nvector> build_row_snake(int N) {\n vector> order;\n order.reserve(N * N);\n for (int i = 0; i < N; ++i) {\n if (i % 2 == 0) {\n for (int j = 0; j < N; ++j) order.emplace_back(i, j);\n } else {\n for (int j = N - 1; j >= 0; --j) order.emplace_back(i, j);\n }\n }\n return order;\n}\n\nvector> build_col_snake(int N) {\n vector> order;\n order.reserve(N * N);\n for (int j = 0; j < N; ++j) {\n if (j % 2 == 0) {\n for (int i = 0; i < N; ++i) order.emplace_back(i, j);\n } else {\n for (int i = N - 1; i >= 0; --i) order.emplace_back(i, j);\n }\n }\n return order;\n}\n\npair evaluate(const vector>& order,\n const vector>& h) {\n ll prefix = 0, min_pref = 0, sum_prefix = 0;\n int M = (int)order.size();\n for (int idx = 0; idx < M; ++idx) {\n auto [i,j] = order[idx];\n prefix += h[i][j];\n min_pref = min(min_pref, prefix);\n if (idx + 1 < M) sum_prefix += prefix;\n }\n ll B = -min_pref;\n int end_i = order.back().first;\n int end_j = order.back().second;\n ll steps = (ll)(M - 1) + llabs(end_i) + llabs(end_j);\n ll cost = 100 * steps + sum_prefix + B * steps;\n return {B, cost};\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 auto row = build_row_snake(N);\n auto col = build_col_snake(N);\n\n auto [B_row, cost_row] = evaluate(row, h);\n auto [B_col, cost_col] = evaluate(col, h);\n\n const vector>* order = &row;\n ll B = B_row;\n if (cost_col < cost_row) {\n order = &col;\n B = B_col;\n }\n\n vector ops;\n ops.reserve(2000);\n\n if (B > 0) ops.push_back(\"+\" + to_string(B));\n\n int cur_i = (*order)[0].first;\n int cur_j = (*order)[0].second;\n\n for (int idx = 0; idx < (int)order->size(); ++idx) {\n int i = (*order)[idx].first;\n int j = (*order)[idx].second;\n\n if (idx > 0) {\n if (i == cur_i + 1) ops.push_back(\"D\");\n else if (i == cur_i - 1) ops.push_back(\"U\");\n else if (j == cur_j + 1) ops.push_back(\"R\");\n else if (j == cur_j - 1) ops.push_back(\"L\");\n cur_i = i;\n cur_j = j;\n }\n\n int val = h[i][j];\n if (val > 0) ops.push_back(\"+\" + to_string(val));\n else if (val < 0) ops.push_back(\"-\" + to_string(-val));\n }\n\n // return to (0,0)\n while (cur_i > 0) { ops.push_back(\"U\"); cur_i--; }\n while (cur_j > 0) { ops.push_back(\"L\"); cur_j--; }\n\n if (B > 0) ops.push_back(\"-\" + to_string(B));\n\n for (auto &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 if (!(cin >> N >> M >> T)) return 0;\n\n const int SEED = 2 * N * (N - 1);\n const int P = N * N;\n\n vector> X(SEED, vector(M));\n for (int i = 0; i < SEED; i++) {\n for (int j = 0; j < M; j++) cin >> X[i][j];\n }\n\n // Precompute grid neighbors and edges\n vector> nbr(P);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int p = i * N + j;\n if (i > 0) nbr[p].push_back((i - 1) * N + j);\n if (i + 1 < N) nbr[p].push_back((i + 1) * N + j);\n if (j > 0) nbr[p].push_back(i * N + (j - 1));\n if (j + 1 < N) nbr[p].push_back(i * N + (j + 1));\n }\n }\n vector> edges;\n for (int p = 0; p < P; p++) {\n for (int q : nbr[p]) if (p < q) edges.push_back({p, q});\n }\n\n vector positions(P);\n iota(positions.begin(), positions.end(), 0);\n sort(positions.begin(), positions.end(), [&](int a, int b){\n int da = nbr[a].size(), db = nbr[b].size();\n if (da != db) return da > db;\n return a < b;\n });\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution dist01(0.0, 1.0);\n\n for (int t = 0; t < T; t++) {\n // Compute seed sums and current maxima\n vector V(SEED, 0);\n vector cur_max(M, 0);\n for (int i = 0; i < SEED; i++) {\n int s = 0;\n for (int j = 0; j < M; j++) {\n s += X[i][j];\n cur_max[j] = max(cur_max[j], X[i][j]);\n }\n V[i] = s;\n }\n\n // Count how many criteria each seed has maximum for\n vector cnt_max(SEED, 0);\n for (int j = 0; j < M; j++) {\n for (int i = 0; i < SEED; i++) {\n if (X[i][j] == cur_max[j]) cnt_max[i]++;\n }\n }\n\n // Selection\n int K = (t < T/2 ? 2 : 1);\n vector used(SEED, false);\n vector selected;\n selected.reserve(P);\n\n for (int j = 0; j < M; j++) {\n vector> arr;\n arr.reserve(SEED);\n for (int i = 0; i < SEED; i++) arr.push_back({X[i][j], i});\n sort(arr.begin(), arr.end(), [&](auto &a, auto &b){\n if (a.first != b.first) return a.first > b.first;\n return a.second < b.second;\n });\n for (int k = 0; k < K; k++) {\n int idx = arr[k].second;\n if (!used[idx]) {\n used[idx] = true;\n selected.push_back(idx);\n }\n }\n }\n\n if ((int)selected.size() > P) {\n sort(selected.begin(), selected.end(), [&](int a, int b){\n return V[a] > V[b];\n });\n selected.resize(P);\n fill(used.begin(), used.end(), false);\n for (int idx : selected) used[idx] = true;\n }\n\n vector order(SEED);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int a, int b){\n return V[a] > V[b];\n });\n for (int idx : order) {\n if ((int)selected.size() >= P) break;\n if (!used[idx]) {\n used[idx] = true;\n selected.push_back(idx);\n }\n }\n\n // Pair score matrix\n double beta = 0.2 + 0.6 * (double)t / max(1, T - 1);\n vector> w(SEED, vector(SEED, 0.0));\n for (int i = 0; i < SEED; i++) {\n for (int j = i + 1; j < SEED; j++) {\n int sum_max = 0;\n int sum_min = 0;\n for (int l = 0; l < M; l++) {\n int a = X[i][l], b = X[j][l];\n if (a >= b) { sum_max += a; sum_min += b; }\n else { sum_max += b; sum_min += a; }\n }\n double mean = 0.5 * (V[i] + V[j]);\n double val = (1.0 - beta) * sum_max + beta * mean;\n w[i][j] = w[j][i] = val;\n }\n }\n\n // Initial layout: important seeds to high-degree cells\n vector> imp;\n imp.reserve(P);\n const double bonus = 50.0;\n for (int idx : selected) {\n double importance = V[idx] + bonus * cnt_max[idx];\n imp.emplace_back(-importance, idx);\n }\n sort(imp.begin(), imp.end());\n\n vector pos2seed(P);\n for (int i = 0; i < P; i++) pos2seed[positions[i]] = imp[i].second;\n\n double score = 0.0;\n for (auto [p,q] : edges) score += w[pos2seed[p]][pos2seed[q]];\n\n // Simulated annealing / local search\n int ITER = 20000;\n double T0 = 1000.0, T1 = 10.0;\n for (int it = 0; it < ITER; it++) {\n int p = rng() % P;\n int q = rng() % P;\n if (p == q) continue;\n\n int sp = pos2seed[p];\n int sq = pos2seed[q];\n\n double delta = 0.0;\n for (int n : nbr[p]) {\n if (n == q) continue;\n int sn = pos2seed[n];\n delta += w[sq][sn] - w[sp][sn];\n }\n for (int n : nbr[q]) {\n if (n == p) continue;\n int sn = pos2seed[n];\n delta += w[sp][sn] - w[sq][sn];\n }\n\n double temp = T0 + (T1 - T0) * (double)it / ITER;\n if (delta >= 0 || exp(delta / temp) > dist01(rng)) {\n swap(pos2seed[p], pos2seed[q]);\n score += delta;\n }\n }\n\n // Output\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (j) cout << ' ';\n cout << pos2seed[i * N + j];\n }\n cout << '\\n';\n }\n cout.flush();\n\n // Read next generation\n for (int i = 0; i < SEED; i++) {\n for (int j = 0; j < M; j++) cin >> X[i][j];\n }\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Pos {\n int x, y;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, V;\n if (!(cin >> N >> M >> V)) 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 vector src, dst;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (s[i][j] == '1' && t[i][j] == '0') src.push_back({i, j});\n else if (s[i][j] == '0' && t[i][j] == '1') dst.push_back({i, j});\n }\n }\n\n int Vp = 1;\n Pos root = src.empty() ? Pos{0, 0} : src[0];\n int cx = root.x, cy = root.y;\n\n vector ops;\n\n auto add_cmd = [&](char move, bool act) {\n string S;\n S.push_back(move);\n S.push_back(act ? 'P' : '.');\n ops.push_back(S);\n };\n\n auto move_to = [&](int tx, int ty, bool action) {\n vector path;\n int x = cx, y = cy;\n while (x < tx) { path.push_back('D'); x++; }\n while (x > tx) { path.push_back('U'); x--; }\n while (y < ty) { path.push_back('R'); y++; }\n while (y > ty) { path.push_back('L'); y--; }\n\n if (path.empty()) {\n if (action) add_cmd('.', true);\n } else {\n for (size_t i = 0; i < path.size(); i++) {\n bool act = action && (i + 1 == path.size());\n add_cmd(path[i], act);\n }\n }\n cx = tx; cy = ty;\n };\n\n auto pop_nearest = [&](vector& vec, int x, int y) -> Pos {\n int best = 0;\n int bestDist = abs(vec[0].x - x) + abs(vec[0].y - y);\n for (int i = 1; i < (int)vec.size(); i++) {\n int d = abs(vec[i].x - x) + abs(vec[i].y - y);\n if (d < bestDist) {\n bestDist = d;\n best = i;\n }\n }\n Pos res = vec[best];\n vec[best] = vec.back();\n vec.pop_back();\n return res;\n };\n\n while (!src.empty()) {\n Pos pick = pop_nearest(src, cx, cy);\n move_to(pick.x, pick.y, true); // pick\n\n Pos drop = pop_nearest(dst, cx, cy);\n move_to(drop.x, drop.y, true); // drop\n }\n\n // Output\n cout << Vp << \"\\n\";\n cout << root.x << \" \" << root.y << \"\\n\";\n for (auto &cmd : ops) {\n cout << cmd << \"\\n\";\n }\n\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, x2, y1, y2;\n int score;\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 int M = 2 * N;\n\n vector xs(M), ys(M), ws(M);\n for (int i = 0; i < M; i++) {\n cin >> xs[i] >> ys[i];\n ws[i] = (i < N) ? 1 : -1; // mackerel = +1, sardine = -1\n }\n\n const int MAXC = 100000;\n const int G = 250; // grid size\n const int STEP = MAXC / G; // 400, divides 100000\n\n auto evalRect = [&](const Rect &r) {\n int sum = 0;\n for (int i = 0; i < M; i++) {\n if (xs[i] >= r.x1 && xs[i] <= r.x2 &&\n ys[i] >= r.y1 && ys[i] <= r.y2)\n sum += ws[i];\n }\n return sum;\n };\n\n // Build grid weights\n vector grid(G * G, 0);\n for (int i = 0; i < M; i++) {\n int ix = xs[i] / STEP;\n int iy = ys[i] / STEP;\n if (ix >= G) ix = G - 1;\n if (iy >= G) iy = G - 1;\n grid[ix * G + iy] += ws[i];\n }\n\n // 2D Kadane on grid\n int bestSumGrid = -1e9;\n int bestL=0, bestR=0, bestB=0, bestT=0;\n vector temp(G);\n for (int L = 0; L < G; L++) {\n fill(temp.begin(), temp.end(), 0);\n for (int R = L; R < G; R++) {\n for (int y = 0; y < G; y++) temp[y] += grid[R * G + y];\n int cur = 0, start = 0;\n for (int y = 0; y < G; y++) {\n if (cur <= 0) { cur = temp[y]; start = y; }\n else cur += temp[y];\n if (cur > bestSumGrid) {\n bestSumGrid = cur;\n bestL = L; bestR = R; bestB = start; bestT = y;\n }\n }\n }\n }\n\n auto rectFromGrid = [&](int L,int R,int B,int T) {\n Rect r;\n r.x1 = L * STEP;\n r.x2 = (R == G-1 ? MAXC : (R+1)*STEP - 1);\n r.y1 = B * STEP;\n r.y2 = (T == G-1 ? MAXC : (T+1)*STEP - 1);\n r.score = 0;\n return r;\n };\n\n Rect best = rectFromGrid(bestL, bestR, bestB, bestT);\n best.score = evalRect(best);\n\n auto considerRect = [&](Rect r) {\n if (r.x1 < 0 || r.x2 > MAXC || r.y1 < 0 || r.y2 > MAXC) return;\n if (r.x1 >= r.x2 || r.y1 >= r.y2) return;\n r.score = evalRect(r);\n if (r.score > best.score) best = r;\n };\n\n // Small rectangles around each mackerel\n for (int i = 0; i < N; i++) {\n Rect r;\n int x = xs[i], y = ys[i];\n if (x == 0) { r.x1 = 0; r.x2 = 1; }\n else if (x == MAXC) { r.x1 = MAXC - 1; r.x2 = MAXC; }\n else { r.x1 = x - 1; r.x2 = x + 1; }\n\n if (y == 0) { r.y1 = 0; r.y2 = 1; }\n else if (y == MAXC) { r.y1 = MAXC - 1; r.y2 = MAXC; }\n else { r.y1 = y - 1; r.y2 = y + 1; }\n\n considerRect(r);\n }\n\n // Random search\n mt19937 rng(712367);\n auto rnd = [&](int l, int r) {\n return uniform_int_distribution(l, r)(rng);\n };\n\n vector radii = {50,100,200,400,800,1200,2000,4000,8000,12000,20000,30000,40000,50000};\n\n int R1 = 2000;\n for (int t = 0; t < R1; t++) {\n int idx = rnd(0, N-1);\n int rx = radii[rnd(0, (int)radii.size()-1)];\n int ry = radii[rnd(0, (int)radii.size()-1)];\n Rect r;\n r.x1 = max(0, xs[idx] - rx);\n r.x2 = min(MAXC, xs[idx] + rx);\n r.y1 = max(0, ys[idx] - ry);\n r.y2 = min(MAXC, ys[idx] + ry);\n if (r.x1 == r.x2) { if (r.x2 < MAXC) r.x2++; else r.x1--; }\n if (r.y1 == r.y2) { if (r.y2 < MAXC) r.y2++; else r.y1--; }\n considerRect(r);\n }\n\n int R2 = 1000;\n for (int t = 0; t < R2; t++) {\n int i = rnd(0, N-1);\n int j = rnd(0, N-1);\n Rect r;\n r.x1 = min(xs[i], xs[j]);\n r.x2 = max(xs[i], xs[j]);\n r.y1 = min(ys[i], ys[j]);\n r.y2 = max(ys[i], ys[j]);\n if (r.x1 == r.x2) { if (r.x2 < MAXC) r.x2++; else r.x1--; }\n if (r.y1 == r.y2) { if (r.y2 < MAXC) r.y2++; else r.y1--; }\n considerRect(r);\n }\n\n // Local refinement\n vector steps = {10000,5000,2000,1000,500,200,100,50,20,10,5,1};\n Rect cur = best;\n for (int stepSize : steps) {\n for (int it = 0; it < 3; it++) {\n Rect bestMove = cur;\n int bestScore = cur.score;\n auto tryMove = [&](Rect r) {\n if (r.x1 < 0 || r.x2 > MAXC || r.y1 < 0 || r.y2 > MAXC) return;\n if (r.x1 >= r.x2 || r.y1 >= r.y2) return;\n int s = evalRect(r);\n if (s > bestScore) {\n bestScore = s;\n bestMove = r;\n bestMove.score = s;\n }\n };\n Rect r;\n\n r = cur; r.x1 = max(0, cur.x1 - stepSize); tryMove(r);\n r = cur; r.x1 = min(cur.x1 + stepSize, cur.x2 - 1); tryMove(r);\n r = cur; r.x2 = max(cur.x1 + 1, cur.x2 - stepSize); tryMove(r);\n r = cur; r.x2 = min(MAXC, cur.x2 + stepSize); tryMove(r);\n r = cur; r.y1 = max(0, cur.y1 - stepSize); tryMove(r);\n r = cur; r.y1 = min(cur.y1 + stepSize, cur.y2 - 1); tryMove(r);\n r = cur; r.y2 = max(cur.y1 + 1, cur.y2 - stepSize); tryMove(r);\n r = cur; r.y2 = min(MAXC, cur.y2 + stepSize); tryMove(r);\n\n if (bestScore > cur.score) {\n cur = bestMove;\n cur.score = bestScore;\n if (cur.score > best.score) best = cur;\n } else break;\n }\n }\n\n // Output rectangle as polygon\n cout << 4 << \"\\n\";\n cout << best.x1 << \" \" << best.y1 << \"\\n\";\n cout << best.x2 << \" \" << best.y1 << \"\\n\";\n cout << best.x2 << \" \" << best.y2 << \"\\n\";\n cout << best.x1 << \" \" << best.y2 << \"\\n\";\n\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nstruct Operation {\n int p;\n int r;\n char d;\n int b;\n};\n\nstruct Plan {\n vector ops;\n long long estW = 0, estH = 0;\n long long score() const { return estW + estH; }\n};\n\nint choose_orientation(long long cur_major, long long target,\n long long major0, long long minor0,\n long long major1, long long minor1,\n int mode, std::mt19937 &rng) {\n auto choose_by_mode = [&](long long M0, long long m0,\n long long M1, long long m1) {\n if (mode == 1) { // prefer smaller major\n if (M0 != M1) return (M0 < M1 ? 0 : 1);\n if (m0 != m1) return (m0 < m1 ? 0 : 1);\n } else { // prefer smaller minor\n if (m0 != m1) return (m0 < m1 ? 0 : 1);\n if (M0 != M1) return (M0 < M1 ? 0 : 1);\n }\n return (int)(rng() & 1);\n };\n\n if (cur_major == 0) {\n bool ok0 = major0 <= target;\n bool ok1 = major1 <= target;\n if (!ok0 && !ok1) {\n if (major0 != major1) return (major0 < major1 ? 0 : 1);\n if (minor0 != minor1) return (minor0 < minor1 ? 0 : 1);\n return (int)(rng() & 1);\n }\n if (ok0 && ok1) return choose_by_mode(major0, minor0, major1, minor1);\n return ok0 ? 0 : 1;\n } else {\n bool ok0 = cur_major + major0 <= target;\n bool ok1 = cur_major + major1 <= target;\n if (!ok0 && !ok1) {\n if (major0 != major1) return (major0 < major1 ? 0 : 1);\n if (minor0 != minor1) return (minor0 < minor1 ? 0 : 1);\n return (int)(rng() & 1);\n }\n if (ok0 && ok1) return choose_by_mode(major0, minor0, major1, minor1);\n return ok0 ? 0 : 1;\n }\n}\n\nPlan make_plan(const vector& w, const vector& h,\n long long target, bool horizontal, int mode, uint32_t seed) {\n int N = (int)w.size();\n Plan plan;\n plan.ops.resize(N);\n\n std::mt19937 rng(seed);\n\n long long cur_major = 0, cur_minor_max = 0;\n int cur_anchor = -1;\n int base_anchor = -1;\n\n auto finalize = [&]() {\n if (cur_major == 0) return;\n if (horizontal) {\n plan.estW = max(plan.estW, cur_major);\n plan.estH += cur_minor_max;\n } else {\n plan.estW += cur_minor_max;\n plan.estH = max(plan.estH, cur_major);\n }\n base_anchor = cur_anchor;\n cur_major = 0;\n cur_minor_max = 0;\n cur_anchor = -1;\n };\n\n for (int i = 0; i < N; ++i) {\n long long w0 = w[i], h0 = h[i];\n long long w1 = h[i], h1 = w[i];\n\n long long major0 = horizontal ? w0 : h0;\n long long minor0 = horizontal ? h0 : w0;\n long long major1 = horizontal ? w1 : h1;\n long long minor1 = horizontal ? h1 : w1;\n\n if (cur_major > 0 && min(cur_major + major0, cur_major + major1) > target) {\n finalize();\n }\n\n int rot = choose_orientation(cur_major, target, major0, minor0, major1, minor1, mode, rng);\n\n plan.ops[i] = {i, rot, horizontal ? 'L' : 'U', base_anchor};\n\n long long major = (rot == 0 ? major0 : major1);\n long long minor = (rot == 0 ? minor0 : minor1);\n\n cur_major += major;\n if (minor > cur_minor_max) {\n cur_minor_max = minor;\n cur_anchor = i;\n }\n }\n finalize();\n return plan;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T;\n long long sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n\n vector w(N), h(N);\n for (int i = 0; i < N; ++i) cin >> w[i] >> h[i];\n\n long double area = 0;\n for (int i = 0; i < N; ++i) area += (long double)w[i] * h[i];\n long double sqrtA = sqrt(max((long double)1.0, area));\n\n vector factors = {0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.6,1.8,2.0,2.2,2.5};\n\n vector plans;\n int seed = 12345;\n\n for (double f : factors) {\n long long target = max(1LL, (long long)(sqrtA * f));\n for (int mode = 0; mode < 2; ++mode) {\n plans.push_back(make_plan(w, h, target, true, mode, seed++));\n plans.push_back(make_plan(w, h, target, false, mode, seed++));\n }\n }\n\n std::mt19937 rng(54321);\n std::uniform_real_distribution dist(0.4, 2.5);\n while ((int)plans.size() < T) {\n double f = dist(rng);\n long long target = max(1LL, (long long)(sqrtA * f));\n bool horizontal = (rng() & 1);\n int mode = rng() % 2;\n plans.push_back(make_plan(w, h, target, horizontal, mode, seed++));\n }\n\n sort(plans.begin(), plans.end(),\n [](const Plan& a, const Plan& b) { return a.score() < b.score(); });\n\n vector outPlans;\n if ((int)plans.size() >= T) {\n outPlans.assign(plans.begin(), plans.begin() + T);\n } else {\n outPlans = plans;\n while ((int)outPlans.size() < T)\n outPlans.push_back(plans[outPlans.size() % plans.size()]);\n }\n\n for (int t = 0; t < T; ++t) {\n const auto &plan = outPlans[t];\n cout << N << '\\n';\n for (const auto &op : plan.ops) {\n cout << op.p << ' ' << op.r << ' ' << op.d << ' ' << op.b << '\\n';\n }\n cout.flush();\n\n long long Wp, Hp;\n if (!(cin >> Wp >> Hp)) break;\n }\n\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n cin >> N >> M >> H;\n\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n\n vector> G(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n G[u].push_back(v);\n G[v].push_back(u);\n }\n\n // Coordinates (unused)\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n\n // Precompute distances up to H\n vector> dist(N, vector(N, H + 1));\n for (int s = 0; s < N; s++) {\n queue q;\n dist[s][s] = 0;\n q.push(s);\n while (!q.empty()) {\n int v = q.front(); q.pop();\n if (dist[s][v] == H) continue;\n for (int to : G[v]) {\n if (dist[s][to] > dist[s][v] + 1) {\n dist[s][to] = dist[s][v] + 1;\n q.push(to);\n }\n }\n }\n }\n\n // Greedy root selection\n vector roots;\n vector covered(N, false), is_root(N, false);\n int uncovered = N;\n\n while (uncovered > 0) {\n int best = -1, best_cnt = -1, bestA = 1e9;\n for (int v = 0; v < N; v++) {\n if (is_root[v]) continue;\n int cnt = 0;\n for (int u = 0; u < N; u++) {\n if (!covered[u] && dist[v][u] <= H) cnt++;\n }\n if (cnt > best_cnt || (cnt == best_cnt && A[v] < bestA)) {\n best_cnt = cnt;\n bestA = A[v];\n best = v;\n }\n }\n roots.push_back(best);\n is_root[best] = true;\n for (int u = 0; u < N; u++) {\n if (!covered[u] && dist[best][u] <= H) {\n covered[u] = true;\n uncovered--;\n }\n }\n }\n\n // Remove redundant roots\n bool changed = true;\n while (changed) {\n changed = false;\n sort(roots.begin(), roots.end(), [&](int a, int b){ return A[a] > A[b]; });\n for (int idx = 0; idx < (int)roots.size(); idx++) {\n if (roots.size() <= 1) break;\n int r = roots[idx];\n bool ok = true;\n for (int v = 0; v < N && ok; v++) {\n int md = H + 1;\n for (int r2 : roots) {\n if (r2 == r) continue;\n md = min(md, dist[r2][v]);\n if (md == 0) break;\n }\n if (md > H) ok = false;\n }\n if (ok) {\n roots.erase(roots.begin() + idx);\n changed = true;\n break;\n }\n }\n }\n\n // Initial BFS forest\n vector parent(N, -1), depth(N, -1);\n queue q;\n for (int r : roots) {\n depth[r] = 0;\n parent[r] = -1;\n q.push(r);\n }\n while (!q.empty()) {\n int v = q.front(); q.pop();\n if (depth[v] == H) continue;\n for (int to : G[v]) {\n if (depth[to] == -1) {\n depth[to] = depth[v] + 1;\n parent[to] = v;\n q.push(to);\n }\n }\n }\n for (int v = 0; v < N; v++) {\n if (depth[v] == -1) {\n depth[v] = 0;\n parent[v] = -1;\n }\n }\n\n // Local improvement (subtree relocation)\n {\n int Nn = N;\n vector depth2(Nn), tin(Nn), tout(Nn), maxDepth(Nn);\n vector sumA(Nn);\n vector> children;\n\n auto recompute = [&]() {\n children.assign(Nn, {});\n vector roots2;\n for (int i = 0; i < Nn; i++) {\n if (parent[i] == -1) roots2.push_back(i);\n else children[parent[i]].push_back(i);\n }\n depth2.assign(Nn, 0);\n sumA.assign(Nn, 0);\n maxDepth.assign(Nn, 0);\n tin.assign(Nn, 0);\n tout.assign(Nn, 0);\n int timer = 0;\n\n function dfs = [&](int v) {\n tin[v] = timer++;\n sumA[v] = A[v];\n maxDepth[v] = depth2[v];\n for (int c : children[v]) {\n depth2[c] = depth2[v] + 1;\n dfs(c);\n sumA[v] += sumA[c];\n maxDepth[v] = max(maxDepth[v], maxDepth[c]);\n }\n tout[v] = timer;\n };\n\n for (int r : roots2) {\n depth2[r] = 0;\n dfs(r);\n }\n };\n\n auto start = chrono::steady_clock::now();\n const double TL = 1.7;\n\n while (true) {\n recompute();\n long long best_gain = 0;\n int best_v = -1, best_u = -1;\n for (int v = 0; v < Nn; v++) {\n for (int u : G[v]) {\n if (tin[v] <= tin[u] && tin[u] < tout[v]) continue;\n int delta = depth2[u] + 1 - depth2[v];\n if (delta <= 0) continue;\n if (maxDepth[v] + delta > H) continue;\n long long gain = 1LL * delta * sumA[v];\n if (gain > best_gain) {\n best_gain = gain;\n best_v = v;\n best_u = u;\n }\n }\n }\n if (best_gain <= 0) break;\n parent[best_v] = best_u;\n\n if (chrono::duration(chrono::steady_clock::now() - start).count() > TL)\n break;\n }\n }\n\n // Output\n for (int i = 0; i < N; i++) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << '\\n';\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstruct Candidate {\n char dir;\n int idx; // row or column index\n int k; // number of shifts\n int save; // saving compared to individual removals\n int cost; // 2*k\n int cnt; // number of Oni removed\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 C(N);\n for (int i = 0; i < N; i++) cin >> C[i];\n\n vector> fuku(N, vector(N, 0));\n vector> oni(N, vector(N, 0));\n\n int total_oni = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (C[i][j] == 'o') fuku[i][j] = 1;\n else if (C[i][j] == 'x') {\n oni[i][j] = 1;\n total_oni++;\n }\n }\n }\n\n // Fuku bounds\n vector left_fuku(N, N), right_fuku(N, -1);\n vector top_fuku(N, N), bottom_fuku(N, -1);\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (fuku[i][j]) {\n left_fuku[i] = min(left_fuku[i], j);\n right_fuku[i] = max(right_fuku[i], j);\n top_fuku[j] = min(top_fuku[j], i);\n bottom_fuku[j] = max(bottom_fuku[j], i);\n }\n }\n }\n\n // Minimal individual cost for each Oni\n vector> min_cost(N, vector(N, 0));\n const int INF = 1e9;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!oni[i][j]) continue;\n int best = INF;\n if (top_fuku[j] > i) best = min(best, 2 * (i + 1));\n if (bottom_fuku[j] < i) best = min(best, 2 * (N - i));\n if (left_fuku[i] > j) best = min(best, 2 * (j + 1));\n if (right_fuku[i] < j) best = min(best, 2 * (N - j));\n min_cost[i][j] = best;\n }\n }\n\n vector> rem = oni;\n int rem_count = total_oni;\n\n vector> ops;\n\n auto rev = [](char d)->char {\n if (d=='L') return 'R';\n if (d=='R') return 'L';\n if (d=='U') return 'D';\n return 'U'; // D\n };\n\n auto apply_op = [&](char d, int idx, int k) {\n char rd = rev(d);\n for (int t = 0; t < k; t++) ops.push_back({d, idx});\n for (int t = 0; t < k; t++) ops.push_back({rd, idx});\n\n if (d == 'L') {\n for (int j = 0; j < k; j++) if (rem[idx][j]) rem[idx][j] = 0, rem_count--;\n } else if (d == 'R') {\n for (int j = N-k; j < N; j++) if (rem[idx][j]) rem[idx][j] = 0, rem_count--;\n } else if (d == 'U') {\n for (int i = 0; i < k; i++) if (rem[i][idx]) rem[i][idx] = 0, rem_count--;\n } else if (d == 'D') {\n for (int i = N-k; i < N; i++) if (rem[i][idx]) rem[i][idx] = 0, rem_count--;\n }\n };\n\n // Greedy grouping by positive saving\n while (true) {\n Candidate best{'?',0,0,0,0,0};\n\n auto consider = [&](char dir, int idx, int k, int sum_cost, int cnt) {\n int cost = 2 * k;\n int save = sum_cost - cost;\n if (save <= 0) return;\n if (save > best.save ||\n (save == best.save && (cnt > best.cnt || (cnt == best.cnt && cost < best.cost)))) {\n best = {dir, idx, k, save, cost, cnt};\n }\n };\n\n // Rows\n for (int i = 0; i < N; i++) {\n int L = left_fuku[i];\n if (L > 0) {\n int sum = 0, cnt = 0;\n for (int j = 0; j < L; j++) {\n if (rem[i][j]) {\n sum += min_cost[i][j];\n cnt++;\n consider('L', i, j+1, sum, cnt);\n }\n }\n }\n int R = N - 1 - right_fuku[i];\n if (R > 0) {\n int sum = 0, cnt = 0;\n for (int j = N-1; j >= N-R; j--) {\n if (rem[i][j]) {\n sum += min_cost[i][j];\n cnt++;\n consider('R', i, N-j, sum, cnt);\n }\n }\n }\n }\n\n // Columns\n for (int j = 0; j < N; j++) {\n int U = top_fuku[j];\n if (U > 0) {\n int sum = 0, cnt = 0;\n for (int i = 0; i < U; i++) {\n if (rem[i][j]) {\n sum += min_cost[i][j];\n cnt++;\n consider('U', j, i+1, sum, cnt);\n }\n }\n }\n int D = N - 1 - bottom_fuku[j];\n if (D > 0) {\n int sum = 0, cnt = 0;\n for (int i = N-1; i >= N-D; i--) {\n if (rem[i][j]) {\n sum += min_cost[i][j];\n cnt++;\n consider('D', j, N-i, sum, cnt);\n }\n }\n }\n }\n\n if (best.save <= 0) break;\n apply_op(best.dir, best.idx, best.k);\n }\n\n // Remove remaining Oni individually (cheapest direction, tie-break by more removals)\n auto choose_dir = [&](int i, int j) {\n struct C { int cost, cnt; char dir; int k, idx; };\n vector cand;\n\n if (top_fuku[j] > i) {\n int k = i+1, cnt=0;\n for (int r = 0; r < k; r++) if (rem[r][j]) cnt++;\n cand.push_back({2*k, cnt, 'U', k, j});\n }\n if (bottom_fuku[j] < i) {\n int k = N-i, cnt=0;\n for (int r = N-k; r < N; r++) if (rem[r][j]) cnt++;\n cand.push_back({2*k, cnt, 'D', k, j});\n }\n if (left_fuku[i] > j) {\n int k = j+1, cnt=0;\n for (int c = 0; c < k; c++) if (rem[i][c]) cnt++;\n cand.push_back({2*k, cnt, 'L', k, i});\n }\n if (right_fuku[i] < j) {\n int k = N-j, cnt=0;\n for (int c = N-k; c < N; c++) if (rem[i][c]) cnt++;\n cand.push_back({2*k, cnt, 'R', k, i});\n }\n\n C best = cand[0];\n for (auto &c : cand) {\n if (c.cost < best.cost || (c.cost == best.cost && c.cnt > best.cnt)) {\n best = c;\n }\n }\n return best;\n };\n\n while (rem_count > 0) {\n bool found = false;\n for (int i = 0; i < N && !found; i++) {\n for (int j = 0; j < N && !found; j++) {\n if (rem[i][j]) {\n auto choice = choose_dir(i, j);\n apply_op(choice.dir, choice.idx, choice.k);\n found = true;\n }\n }\n }\n if (!found) break;\n }\n\n for (auto &op : ops) {\n cout << op.first << \" \" << op.second << \"\\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\n int N;\n long long L;\n if (!(cin >> N >> L)) return 0;\n\n vector T(N);\n for (int i = 0; i < N; i++) cin >> T[i];\n\n // 1) Build cycle order: sort by descending T\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int a, int b) {\n if (T[a] != T[b]) return T[a] > T[b];\n return a < b;\n });\n\n vector a(N), b(N);\n\n // a-edges = Hamiltonian cycle\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int v = order[(k + 1) % N];\n a[u] = v;\n }\n\n // 2) Remaining demand for b-edges\n vector rem(N, 0);\n for (int k = 0; k < N; k++) {\n int u = order[k];\n int pred = order[(k - 1 + N) % N];\n long long d = 2 * T[u] - T[pred];\n if (d > 0) rem[u] = d; // only positive demands\n }\n\n // 3) Max-heap of remaining demands\n priority_queue> pq;\n for (int i = 0; i < N; i++) {\n if (rem[i] > 0) pq.push({rem[i], i});\n }\n\n // 4) Process sources in descending weight\n vector sources(N);\n iota(sources.begin(), sources.end(), 0);\n sort(sources.begin(), sources.end(), [&](int x, int y) {\n if (T[x] != T[y]) return T[x] > T[y];\n return x < y;\n });\n\n for (int u : sources) {\n if (pq.empty()) {\n // Fallback (should rarely happen)\n b[u] = order[0];\n continue;\n }\n auto [r, v] = pq.top();\n pq.pop();\n\n b[u] = v;\n r -= T[u];\n if (r > 0) pq.push({r, v});\n }\n\n // Output\n for (int i = 0; i < N; i++) {\n cout << a[i] << \" \" << b[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nstruct GroupInfo {\n long long sumX = 0, sumY = 0, sumX2 = 0, sumY2 = 0;\n int size = 0;\n};\n\ndouble cost(const GroupInfo& g) {\n if (g.size <= 1) return 0.0;\n double sx = (double)g.sumX;\n double sy = (double)g.sumY;\n return (double)g.sumX2 + g.sumY2 - (sx * sx + sy * sy) / g.size;\n}\n\nuint64_t morton(int x, int y) {\n uint64_t res = 0;\n for (int b = 0; b < 15; ++b) { // 0..14 covers up to 2^15-1\n res |= ((uint64_t)((x >> b) & 1)) << (2 * b);\n res |= ((uint64_t)((y >> b) & 1)) << (2 * b + 1);\n }\n return res;\n}\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\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n vector lx(N), rx(N), ly(N), ry(N);\n vector cx2(N), cy2(N); // twice center (integer)\n for (int i = 0; i < N; ++i) {\n cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n cx2[i] = lx[i] + rx[i];\n cy2[i] = ly[i] + ry[i];\n }\n\n vector key(N);\n vector order(N);\n for (int i = 0; i < N; ++i) {\n key[i] = morton(cx2[i], cy2[i]);\n order[i] = i;\n }\n\n sort(order.begin(), order.end(), [&](int a, int b) {\n if (key[a] != key[b]) return key[a] < key[b];\n if (cx2[a] != cx2[b]) return cx2[a] < cx2[b];\n return cy2[a] < cy2[b];\n });\n\n vector> groups(M);\n vector groupOf(N), posInGroup(N);\n vector info(M);\n\n int ptr = 0;\n for (int k = 0; k < M; ++k) {\n groups[k].resize(G[k]);\n info[k].size = G[k];\n for (int j = 0; j < G[k]; ++j) {\n int v = order[ptr++];\n groups[k][j] = v;\n groupOf[v] = k;\n posInGroup[v] = j;\n long long x = cx2[v], y = cy2[v];\n info[k].sumX += x;\n info[k].sumY += y;\n info[k].sumX2 += x * x;\n info[k].sumY2 += y * y;\n }\n }\n\n // Local improvement: random swaps minimizing variance\n if (M > 1) {\n mt19937 rng(42);\n uniform_int_distribution distCity(0, N - 1);\n const int ITER = 200000;\n for (int it = 0; it < ITER; ++it) {\n int a = distCity(rng);\n int b = distCity(rng);\n int ga = groupOf[a], gb = groupOf[b];\n if (ga == gb) continue;\n\n GroupInfo A = info[ga];\n GroupInfo B = info[gb];\n double before = cost(A) + cost(B);\n\n long long xa = cx2[a], ya = cy2[a];\n long long xb = cx2[b], yb = cy2[b];\n\n GroupInfo A2 = A, B2 = B;\n A2.sumX += xb - xa;\n A2.sumY += yb - ya;\n A2.sumX2 += xb * xb - xa * xa;\n A2.sumY2 += yb * yb - ya * ya;\n\n B2.sumX += xa - xb;\n B2.sumY += ya - yb;\n B2.sumX2 += xa * xa - xb * xb;\n B2.sumY2 += ya * ya - yb * yb;\n\n double after = cost(A2) + cost(B2);\n if (after + 1e-9 < before) {\n info[ga] = A2;\n info[gb] = B2;\n\n int pa = posInGroup[a];\n int pb = posInGroup[b];\n groups[ga][pa] = b;\n groups[gb][pb] = a;\n posInGroup[b] = pa;\n posInGroup[a] = pb;\n groupOf[a] = gb;\n groupOf[b] = ga;\n }\n }\n }\n\n // Build MST for each group using estimated centers\n vector>> edges(M);\n for (int k = 0; k < M; ++k) {\n auto &grp = groups[k];\n int g = grp.size();\n if (g <= 1) continue;\n\n vector minDist(g, (1LL << 60));\n vector parent(g, -1);\n vector used(g, false);\n\n minDist[0] = 0;\n for (int it = 0; it < g; ++it) {\n int v = -1;\n for (int i = 0; i < g; ++i) {\n if (!used[i] && (v == -1 || minDist[i] < minDist[v])) v = i;\n }\n used[v] = true;\n for (int u = 0; u < g; ++u) {\n if (used[u]) continue;\n long long dx = cx2[grp[v]] - cx2[grp[u]];\n long long dy = cy2[grp[v]] - cy2[grp[u]];\n long long d = dx * dx + dy * dy;\n if (d < minDist[u]) {\n minDist[u] = d;\n parent[u] = v;\n }\n }\n }\n\n edges[k].reserve(g - 1);\n for (int i = 1; i < g; ++i) {\n edges[k].push_back({grp[i], grp[parent[i]]});\n }\n }\n\n // Output answer (no queries)\n cout << \"!\" << '\\n';\n for (int k = 0; k < M; ++k) {\n for (int i = 0; i < (int)groups[k].size(); ++i) {\n if (i) cout << ' ';\n cout << groups[k][i];\n }\n cout << '\\n';\n for (auto &e : edges[k]) {\n cout << e.first << ' ' << e.second << '\\n';\n }\n }\n cout.flush();\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nstruct Action {\n char a, d;\n};\n\nconst int dr[4] = {-1, 1, 0, 0};\nconst int dc[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\nstruct Planner {\n int n, sz, NONE, P, total;\n vector dist, prev, q;\n vector prevAct, prevDir;\n\n Planner(int n_) : n(n_) {\n sz = n * n;\n NONE = sz;\n P = sz + 1;\n total = sz * P;\n dist.assign(total, -1);\n prev.resize(total);\n prevAct.resize(total);\n prevDir.resize(total);\n q.resize(total);\n }\n\n vector solve(int startPos, int startBlock, int targetPos, int nextTargetPos, int &endBlock) {\n fill(dist.begin(), dist.end(), -1);\n int head = 0, tail = 0;\n\n int startIdx = startPos * P + startBlock;\n dist[startIdx] = 0;\n q[tail++] = startIdx;\n\n while (head < tail) {\n int idx = q[head++];\n int pos = idx / P;\n int block = idx % P;\n int r = pos / n;\n int c = pos % n;\n int blockR = -1, blockC = -1;\n if (block < sz) {\n blockR = block / n;\n blockC = block % n;\n }\n\n // Move\n for (int dir = 0; dir < 4; ++dir) {\n int nr = r + dr[dir], nc = c + dc[dir];\n if (nr < 0 || nr >= n || nc < 0 || nc >= n) continue;\n int newPos = nr * n + nc;\n if (newPos == block) continue;\n int newIdx = newPos * P + block;\n if (dist[newIdx] == -1) {\n dist[newIdx] = dist[idx] + 1;\n prev[newIdx] = idx;\n prevAct[newIdx] = 'M';\n prevDir[newIdx] = dirChar[dir];\n q[tail++] = newIdx;\n }\n }\n\n // Slide\n for (int dir = 0; dir < 4; ++dir) {\n int destPos = pos;\n if (dir == 0) { // up\n int destR = 0;\n if (block < sz && blockC == c && blockR < r) destR = blockR + 1;\n destPos = destR * n + c;\n } else if (dir == 1) { // down\n int destR = n - 1;\n if (block < sz && blockC == c && blockR > r) destR = blockR - 1;\n destPos = destR * n + c;\n } else if (dir == 2) { // left\n int destC = 0;\n if (block < sz && blockR == r && blockC < c) destC = blockC + 1;\n destPos = r * n + destC;\n } else { // right\n int destC = n - 1;\n if (block < sz && blockR == r && blockC > c) destC = blockC - 1;\n destPos = r * n + destC;\n }\n\n if (destPos == pos) continue;\n int newIdx = destPos * P + block;\n if (dist[newIdx] == -1) {\n dist[newIdx] = dist[idx] + 1;\n prev[newIdx] = idx;\n prevAct[newIdx] = 'S';\n prevDir[newIdx] = dirChar[dir];\n q[tail++] = newIdx;\n }\n }\n\n // Alter (toggle adjacent block)\n for (int dir = 0; dir < 4; ++dir) {\n int nr = r + dr[dir], nc = c + dc[dir];\n if (nr < 0 || nr >= n || nc < 0 || nc >= n) continue;\n int adj = nr * n + nc;\n int newBlock;\n if (block == adj) newBlock = NONE;\n else if (block == NONE) newBlock = adj;\n else continue; // keep at most one block\n int newIdx = pos * P + newBlock;\n if (dist[newIdx] == -1) {\n dist[newIdx] = dist[idx] + 1;\n prev[newIdx] = idx;\n prevAct[newIdx] = 'A';\n prevDir[newIdx] = dirChar[dir];\n q[tail++] = newIdx;\n }\n }\n }\n\n // pick best block at target\n int minDist = INT_MAX;\n for (int b = 0; b <= sz; ++b) {\n int d = dist[targetPos * P + b];\n if (d >= 0 && d < minDist) minDist = d;\n }\n\n int bestBlock = -1;\n int bestScore = INT_MAX;\n for (int b = 0; b <= sz; ++b) {\n int d = dist[targetPos * P + b];\n if (d != minDist) continue;\n int score;\n if (b == NONE) {\n score = 0;\n } else {\n score = 1;\n if (nextTargetPos != -1) {\n int br = b / n, bc = b % n;\n int tr = nextTargetPos / n, tc = nextTargetPos % n;\n score += abs(br - tr) + abs(bc - tc);\n if (b == nextTargetPos) score += 1000;\n }\n }\n if (score < bestScore) {\n bestScore = score;\n bestBlock = b;\n }\n }\n if (bestBlock == -1) bestBlock = NONE;\n endBlock = bestBlock;\n\n int goalIdx = targetPos * P + bestBlock;\n vector res;\n for (int idx = goalIdx; idx != startIdx; idx = prev[idx]) {\n res.push_back({prevAct[idx], prevDir[idx]});\n }\n reverse(res.begin(), res.end());\n return res;\n }\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 vector> p(M);\n for (int i = 0; i < M; ++i) cin >> p[i].first >> p[i].second;\n\n Planner planner(N);\n int curPos = p[0].first * N + p[0].second;\n int curBlock = N * N;\n\n vector all;\n for (int k = 1; k < M; ++k) {\n int targetPos = p[k].first * N + p[k].second;\n int nextPos = (k + 1 < M) ? p[k + 1].first * N + p[k + 1].second : -1;\n int endBlock;\n auto actions = planner.solve(curPos, curBlock, targetPos, nextPos, endBlock);\n all.insert(all.end(), actions.begin(), actions.end());\n curPos = targetPos;\n curBlock = endBlock;\n }\n\n // fallback safety (should never trigger)\n if ((int)all.size() > 1600) {\n all.clear();\n int r = p[0].first, c = p[0].second;\n for (int k = 1; k < M; ++k) {\n int tr = p[k].first, tc = p[k].second;\n while (r < tr) { all.push_back({'M','D'}); r++; }\n while (r > tr) { all.push_back({'M','U'}); r--; }\n while (c < tc) { all.push_back({'M','R'}); c++; }\n while (c > tc) { all.push_back({'M','L'}); c--; }\n }\n }\n\n for (auto &ac : all) {\n cout << ac.a << ' ' << ac.d << '\\n';\n }\n return 0;\n}"},"2":{"ahc001":"#include \nusing namespace std;\n\nstruct Rect {\n int l, r, b, t;\n};\n\ninline bool overlap(const Rect& a, const Rect& b) {\n return a.l < b.r && a.r > b.l && a.b < b.t && a.t > b.b;\n}\ninline bool in_bounds(const Rect& rc) {\n return 0 <= rc.l && rc.r <= 10000 && 0 <= rc.b && rc.t <= 10000\n && rc.l < rc.r && rc.b < rc.t;\n}\ninline bool contains(const Rect& rc, int x, int y) {\n return rc.l <= x && rc.r > x && rc.b <= y && rc.t > y;\n}\ninline double calc_score(long long r, long long s) {\n double mn = min(r, s);\n double mx = max(r, s);\n double ratio = mn / mx;\n double diff = 1.0 - ratio;\n return 1.0 - diff * diff;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n;\n cin >> n;\n vector x(n), y(n);\n vector r(n);\n for (int i = 0; i < n; ++i) cin >> x[i] >> y[i] >> r[i];\n\n vector rect(n);\n vector area(n);\n vector score(n);\n\n for (int i = 0; i < n; ++i) {\n rect[i] = {x[i], x[i] + 1, y[i], y[i] + 1};\n area[i] = 1;\n score[i] = calc_score(r[i], area[i]);\n }\n\n auto global_start = chrono::steady_clock::now();\n\n // --- Greedy expansion phase ---\n vector order(n);\n iota(order.begin(), order.end(), 0);\n\n vector steps = {256, 128, 64, 32, 16, 8, 4, 2, 1};\n for (int step : steps) {\n bool changed = true;\n while (changed) {\n changed = false;\n sort(order.begin(), order.end(), [&](int a, int b) {\n long long da = r[a] - area[a];\n long long db = r[b] - area[b];\n if (da != db) return da > db;\n return r[a] > r[b];\n });\n for (int idx : order) {\n Rect cur = rect[idx];\n Rect best = cur;\n double bestScore = score[idx];\n\n for (int dir = 0; dir < 4; ++dir) {\n Rect cand = cur;\n if (dir == 0) cand.l -= step;\n else if (dir == 1) cand.r += step;\n else if (dir == 2) cand.b -= step;\n else cand.t += step;\n\n if (!in_bounds(cand) || !contains(cand, x[idx], y[idx])) continue;\n\n bool ok = true;\n for (int j = 0; j < n; ++j) if (j != idx) {\n if (overlap(cand, rect[j])) { ok = false; break; }\n }\n if (!ok) continue;\n\n long long newArea = 1LL * (cand.r - cand.l) * (cand.t - cand.b);\n double newScore = calc_score(r[idx], newArea);\n if (newScore > bestScore + 1e-12) {\n bestScore = newScore;\n best = cand;\n }\n }\n\n if (bestScore > score[idx] + 1e-12) {\n rect[idx] = best;\n area[idx] = 1LL * (best.r - best.l) * (best.t - best.b);\n score[idx] = bestScore;\n changed = true;\n }\n }\n }\n }\n\n // --- Simulated annealing phase ---\n double elapsed_total = chrono::duration(chrono::steady_clock::now() - global_start).count();\n const double TOTAL_LIMIT = 4.9;\n double remaining = TOTAL_LIMIT - elapsed_total;\n\n if (remaining > 0.05) {\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n double invRand = 1.0 / (double)rng.max();\n auto rand01 = [&]() { return (double)rng() * invRand; };\n\n const double T_START = 0.30;\n const double T_END = 0.001;\n const double P_SHIFT = 0.12;\n\n auto sa_start = chrono::steady_clock::now();\n double sa_elapsed = 0.0, progress = 0.0;\n double temp = T_START;\n int iter = 0;\n\n while (true) {\n if ((iter & 255) == 0) {\n sa_elapsed = chrono::duration(chrono::steady_clock::now() - sa_start).count();\n if (sa_elapsed > remaining) break;\n progress = sa_elapsed / remaining;\n temp = T_START * pow(T_END / T_START, progress);\n }\n\n int i = rng() % n;\n if (rand01() < P_SHIFT) {\n // Shift move\n Rect cand = rect[i];\n int axis = rng() & 1;\n int minShift, maxShift;\n\n if (axis == 0) {\n minShift = max(x[i] + 1 - cand.r, -cand.l);\n maxShift = min(x[i] - cand.l, 10000 - cand.r);\n } else {\n minShift = max(y[i] + 1 - cand.t, -cand.b);\n maxShift = min(y[i] - cand.b, 10000 - cand.t);\n }\n\n if (minShift > maxShift || (minShift == 0 && maxShift == 0)) { iter++; continue; }\n int range = maxShift - minShift + 1;\n int s = minShift + (int)(rng() % range);\n if (s == 0) {\n if (range == 1) { iter++; continue; }\n s = (s == minShift ? s + 1 : s - 1);\n }\n\n if (axis == 0) { cand.l += s; cand.r += s; }\n else { cand.b += s; cand.t += s; }\n\n if (!in_bounds(cand) || !contains(cand, x[i], y[i])) { iter++; continue; }\n\n bool ok = true;\n for (int j = 0; j < n; ++j) if (j != i) {\n if (overlap(cand, rect[j])) { ok = false; break; }\n }\n if (ok) rect[i] = cand; // area, score unchanged\n } else {\n // Resize move\n int side = rng() % 4;\n int maxStep = 1 + (int)(8 * (1.0 - progress));\n int step = 1 + (int)(rng() % maxStep);\n\n bool wantExpand = (area[i] < r[i]);\n double pExpand = wantExpand ? 0.75 : 0.25;\n bool expand = rand01() < pExpand;\n int delta = expand ? step : -step;\n\n Rect cand = rect[i];\n if (side == 0) cand.l -= delta;\n else if (side == 1) cand.r += delta;\n else if (side == 2) cand.b -= delta;\n else cand.t += delta;\n\n if (!in_bounds(cand) || !contains(cand, x[i], y[i])) { iter++; continue; }\n\n if (expand) {\n bool ok = true;\n for (int j = 0; j < n; ++j) if (j != i) {\n if (overlap(cand, rect[j])) { ok = false; break; }\n }\n if (!ok) { iter++; continue; }\n }\n\n long long newArea = 1LL * (cand.r - cand.l) * (cand.t - cand.b);\n double newScore = calc_score(r[i], newArea);\n double deltaScore = newScore - score[i];\n\n if (deltaScore >= 0 || exp(deltaScore / temp) > rand01()) {\n rect[i] = cand;\n area[i] = newArea;\n score[i] = newScore;\n }\n }\n iter++;\n }\n }\n\n for (int i = 0; i < n; ++i) {\n cout << rect[i].l << \" \" << rect[i].b << \" \" << rect[i].r << \" \" << rect[i].t << \"\\n\";\n }\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nstruct XorShift {\n uint64_t x;\n XorShift(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n inline uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline double nextDouble() {\n return (next() >> 11) * (1.0 / 9007199254740992.0); // 2^53\n }\n inline int nextInt(int n) {\n return (int)(next() % n);\n }\n};\n\nstruct Params {\n double alpha, beta, noise;\n};\n\nstruct Path {\n vector nodes;\n int score;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int N = 50;\n const int V = N * N;\n\n int si, sj;\n if (!(cin >> si >> sj)) return 0;\n\n vector tile(V), val(V);\n int maxTile = -1;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int x;\n cin >> x;\n tile[i * N + j] = x;\n maxTile = max(maxTile, x);\n }\n }\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int x;\n cin >> x;\n val[i * N + j] = x;\n }\n }\n\n int M = maxTile + 1;\n vector tileMaxVal(M, 0);\n for (int i = 0; i < V; ++i) tileMaxVal[tile[i]] = max(tileMaxVal[tile[i]], val[i]);\n\n vector> adj(V);\n vector adjCnt(V, 0);\n int dirs[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int id = i * N + j;\n for (auto &d : dirs) {\n int ni = i + d[0], nj = j + d[1];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n int id2 = ni * N + nj;\n if (tile[id2] == tile[id]) continue;\n adj[id][adjCnt[id]++] = id2;\n }\n }\n }\n\n XorShift rng(chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto randomParams = [&](double progress) {\n Params p;\n p.alpha = 6.0 + rng.nextDouble() * 8.0; // 6-14\n p.beta = rng.nextDouble() * 0.3; // 0-0.3\n double baseNoise = 1.0 + rng.nextDouble() * 3.0;\n p.noise = baseNoise * (1.0 - progress);\n return p;\n };\n\n int compThreshold = max(200, M / 3);\n\n auto extend = [&](int start, vector& visited, int visitedCnt,\n const Params& param, bool useComp,\n vector& out, int &addScore) {\n out.clear();\n addScore = 0;\n int cur = start;\n int remaining = M - visitedCnt;\n\n vector compPot, compId, tileSeen, q;\n if (useComp) {\n compPot.assign(V, 0);\n compId.assign(V, -1);\n tileSeen.assign(M, -1);\n q.reserve(V);\n }\n\n while (true) {\n int cand[4], candDeg[4], candMax[4], cnt = 0;\n bool hasPos = false;\n\n for (int k = 0; k < adjCnt[cur]; ++k) {\n int nb = adj[cur][k];\n if (visited[tile[nb]]) continue;\n\n int d = 0, mx = 0;\n for (int k2 = 0; k2 < adjCnt[nb]; ++k2) {\n int nb2 = adj[nb][k2];\n if (visited[tile[nb2]]) continue;\n d++;\n mx = max(mx, val[nb2]);\n }\n if (d > 0) hasPos = true;\n\n cand[cnt] = nb;\n candDeg[cnt] = d;\n candMax[cnt] = mx;\n cnt++;\n }\n\n if (cnt == 0) break;\n\n int effectiveCnt = 0;\n for (int i = 0; i < cnt; i++) if (!hasPos || candDeg[i] > 0) effectiveCnt++;\n\n bool useCompStep = useComp && (remaining > compThreshold) && (effectiveCnt > 1);\n if (useCompStep) {\n fill(compPot.begin(), compPot.end(), 0);\n fill(compId.begin(), compId.end(), -1);\n fill(tileSeen.begin(), tileSeen.end(), -1);\n int cid = 0;\n\n for (int v = 0; v < V; ++v) {\n if (visited[tile[v]] || compId[v] != -1) continue;\n\n q.clear();\n q.push_back(v);\n compId[v] = cid;\n\n int head = 0;\n int pot = 0;\n while (head < (int)q.size()) {\n int u = q[head++];\n int tid = tile[u];\n if (tileSeen[tid] != cid) {\n tileSeen[tid] = cid;\n pot += tileMaxVal[tid];\n }\n for (int k = 0; k < adjCnt[u]; ++k) {\n int nb = adj[u][k];\n if (visited[tile[nb]]) continue;\n if (compId[nb] == -1) {\n compId[nb] = cid;\n q.push_back(nb);\n }\n }\n }\n for (int node : q) compPot[node] = pot;\n cid++;\n }\n }\n\n int best = -1;\n int bestPot = -1;\n double bestScore = -1e18;\n\n for (int i = 0; i < cnt; ++i) {\n if (hasPos && candDeg[i] == 0) continue;\n int pot = useCompStep ? compPot[cand[i]] : 0;\n if (useCompStep) {\n if (pot > bestPot) {\n bestPot = pot;\n bestScore = -1e18;\n best = cand[i];\n }\n if (pot < bestPot) continue;\n }\n double sc = val[cand[i]] + param.alpha * candDeg[i] + param.beta * candMax[i];\n if (param.noise > 1e-9) sc += (rng.nextDouble() * 2.0 - 1.0) * param.noise;\n if (sc > bestScore) {\n bestScore = sc;\n best = cand[i];\n }\n }\n\n if (best == -1) best = cand[0];\n\n visited[tile[best]] = 1;\n visitedCnt++;\n remaining = M - visitedCnt;\n out.push_back(best);\n addScore += val[best];\n cur = best;\n }\n };\n\n auto buildPath = [&](const Params& param, bool useComp) {\n vector visited(M, 0);\n int start = si * N + sj;\n visited[tile[start]] = 1;\n\n vector nodes;\n nodes.reserve(V);\n nodes.push_back(start);\n\n int score = val[start];\n vector ext; ext.reserve(V);\n int add;\n extend(start, visited, 1, param, useComp, ext, add);\n nodes.insert(nodes.end(), ext.begin(), ext.end());\n score += add;\n\n return Path{nodes, score};\n };\n\n Path best; best.score = -1;\n int initTries = 8;\n for (int t = 0; t < initTries; ++t) {\n Params p = (t == 0) ? Params{9.0, 0.15, 0.0} : randomParams(0.0);\n Path path = buildPath(p, true);\n if (path.score > best.score) best = path;\n }\n\n Path current = best;\n vector ext; ext.reserve(V);\n\n auto t0 = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 1.9;\n\n while (true) {\n double elapsed = chrono::duration(chrono::high_resolution_clock::now() - t0).count();\n if (elapsed > TIME_LIMIT) break;\n\n int len = current.nodes.size();\n if (len <= 1) break;\n\n int range = len - 1;\n int pos;\n double r = rng.nextDouble();\n if (range <= 1) pos = 0;\n else if (r < 0.2) pos = rng.nextInt(range);\n else if (r < 0.6) {\n double r2 = rng.nextDouble();\n pos = range - 1 - (int)(r2 * r2 * range);\n } else {\n double r2 = rng.nextDouble();\n pos = (int)(r2 * r2 * range);\n }\n pos = max(0, min(pos, range - 1));\n\n vector visited(M, 0);\n int prefixScore = 0;\n int visitedCnt = 0;\n for (int i = 0; i <= pos; ++i) {\n int node = current.nodes[i];\n int tid = tile[node];\n if (!visited[tid]) { visited[tid] = 1; visitedCnt++; }\n prefixScore += val[node];\n }\n\n Params p = randomParams(elapsed / TIME_LIMIT);\n int add;\n bool useComp = (M - visitedCnt > compThreshold);\n extend(current.nodes[pos], visited, visitedCnt, p, useComp, ext, add);\n\n int newScore = prefixScore + add;\n bool accept = newScore >= current.score;\n if (!accept) {\n double prob = 0.05 * (1.0 - elapsed / TIME_LIMIT);\n if (rng.nextDouble() < prob) accept = true;\n }\n\n if (accept || newScore > best.score) {\n vector newNodes;\n newNodes.reserve(pos + 1 + ext.size());\n newNodes.insert(newNodes.end(), current.nodes.begin(), current.nodes.begin() + pos + 1);\n newNodes.insert(newNodes.end(), ext.begin(), ext.end());\n\n if (newScore > best.score) {\n best.nodes = newNodes;\n best.score = newScore;\n }\n if (accept) {\n current.nodes = move(newNodes);\n current.score = newScore;\n }\n }\n }\n\n string out;\n out.reserve(best.nodes.size());\n for (size_t i = 1; i < best.nodes.size(); ++i) {\n int diff = best.nodes[i] - best.nodes[i - 1];\n if (diff == 1) out.push_back('R');\n else if (diff == -1) out.push_back('L');\n else if (diff == N) out.push_back('D');\n else if (diff == -N) out.push_back('U');\n }\n cout << out << \"\\n\";\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n const int N = 30;\n const double INIT = 5000.0;\n const double BASE_LR = 0.4;\n const double K = 5.0; // blending strength\n const double PRIOR = 1.0; // weight for unobserved edges\n const double EPS0 = 0.05; // exploration noise\n const double MIN_W = 500.0;\n const double MAX_W = 9500.0;\n\n static double h[N][N-1], v[N-1][N];\n static int hc[N][N-1], vc[N-1][N];\n static double wh[N][N-1], wv[N-1][N];\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N-1; ++j)\n h[i][j] = INIT, hc[i][j] = 0;\n for (int i = 0; i < N-1; ++i)\n for (int j = 0; j < N; ++j)\n v[i][j] = INIT, vc[i][j] = 0;\n\n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\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 // compute row/column means (weighted)\n double row_mean[N], col_mean[N];\n for (int i = 0; i < N; ++i) {\n double sum = 0.0, wsum = 0.0;\n for (int j = 0; j < N-1; ++j) {\n double w = hc[i][j] + PRIOR;\n sum += h[i][j] * w;\n wsum += w;\n }\n row_mean[i] = sum / wsum;\n }\n for (int j = 0; j < N; ++j) {\n double sum = 0.0, wsum = 0.0;\n for (int i = 0; i < N-1; ++i) {\n double w = vc[i][j] + PRIOR;\n sum += v[i][j] * w;\n wsum += w;\n }\n col_mean[j] = sum / wsum;\n }\n\n double eps = EPS0 * (1.0 - (double)q / 1000.0);\n uniform_real_distribution noise_dist(-eps, eps);\n\n // effective weights for this query (blend + noise)\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N-1; ++j) {\n double alpha = hc[i][j] / (hc[i][j] + K);\n double base = row_mean[i] * (1.0 - alpha) + h[i][j] * alpha;\n double noise = (eps > 0.0 ? noise_dist(rng) : 0.0);\n wh[i][j] = base * (1.0 + noise);\n }\n }\n for (int i = 0; i < N-1; ++i) {\n for (int j = 0; j < N; ++j) {\n double alpha = vc[i][j] / (vc[i][j] + K);\n double base = col_mean[j] * (1.0 - alpha) + v[i][j] * alpha;\n double noise = (eps > 0.0 ? noise_dist(rng) : 0.0);\n wv[i][j] = base * (1.0 + noise);\n }\n }\n\n // Dijkstra\n const double INF = 1e18;\n vector dist(N*N, INF);\n vector prev(N*N, -1);\n vector prev_dir(N*N);\n\n auto idx = [&](int x, int y){ return x * N + y; };\n int s = idx(si, sj);\n int t = idx(ti, tj);\n\n priority_queue, vector>,\n greater>> pq;\n dist[s] = 0.0;\n pq.push({0.0, s});\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u]) continue;\n if (u == t) break;\n int x = u / N, y = u % N;\n\n // up\n if (x > 0) {\n int vtx = idx(x-1, y);\n double w = wv[x-1][y];\n if (d + w < dist[vtx]) {\n dist[vtx] = d + w;\n prev[vtx] = u;\n prev_dir[vtx] = 'U';\n pq.push({dist[vtx], vtx});\n }\n }\n // down\n if (x + 1 < N) {\n int vtx = idx(x+1, y);\n double w = wv[x][y];\n if (d + w < dist[vtx]) {\n dist[vtx] = d + w;\n prev[vtx] = u;\n prev_dir[vtx] = 'D';\n pq.push({dist[vtx], vtx});\n }\n }\n // left\n if (y > 0) {\n int vtx = idx(x, y-1);\n double w = wh[x][y-1];\n if (d + w < dist[vtx]) {\n dist[vtx] = d + w;\n prev[vtx] = u;\n prev_dir[vtx] = 'L';\n pq.push({dist[vtx], vtx});\n }\n }\n // right\n if (y + 1 < N) {\n int vtx = idx(x, y+1);\n double w = wh[x][y];\n if (d + w < dist[vtx]) {\n dist[vtx] = d + w;\n prev[vtx] = u;\n prev_dir[vtx] = 'R';\n pq.push({dist[vtx], vtx});\n }\n }\n }\n\n // reconstruct path\n string path;\n int cur = t;\n while (cur != s) {\n char d = prev_dir[cur];\n path.push_back(d);\n cur = prev[cur];\n }\n reverse(path.begin(), path.end());\n\n cout << path << endl; // flush\n\n int observed;\n if (!(cin >> observed)) return 0;\n\n // gather edges and predicted length\n struct Edge { bool horiz; int i, j; };\n vector edges;\n edges.reserve(path.size());\n double S = 0.0;\n int cx = si, cy = sj;\n for (char d : path) {\n if (d == 'U') {\n edges.push_back({false, cx-1, cy});\n S += v[cx-1][cy];\n cx--;\n } else if (d == 'D') {\n edges.push_back({false, cx, cy});\n S += v[cx][cy];\n cx++;\n } else if (d == 'L') {\n edges.push_back({true, cx, cy-1});\n S += h[cx][cy-1];\n cy--;\n } else if (d == 'R') {\n edges.push_back({true, cx, cy});\n S += h[cx][cy];\n cy++;\n }\n }\n if (S <= 0.0) continue;\n\n double ratio = observed / S;\n\n // update edges\n for (auto &e : edges) {\n if (e.horiz) {\n int &cnt = hc[e.i][e.j];\n double lr = BASE_LR / sqrt(cnt + 1.0);\n double factor = 1.0 + lr * (ratio - 1.0);\n h[e.i][e.j] *= factor;\n h[e.i][e.j] = min(max(h[e.i][e.j], MIN_W), MAX_W);\n cnt++;\n } else {\n int &cnt = vc[e.i][e.j];\n double lr = BASE_LR / sqrt(cnt + 1.0);\n double factor = 1.0 + lr * (ratio - 1.0);\n v[e.i][e.j] *= factor;\n v[e.i][e.j] = min(max(v[e.i][e.j], MIN_W), MAX_W);\n cnt++;\n }\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ULL) : x(seed) {}\n inline uint64_t next() { x ^= x << 7; x ^= x >> 9; return x; }\n inline int next_int(int mod) { return (int)(next() % mod); }\n inline double next_double() { return (next() >> 11) * (1.0 / (1ULL << 53)); }\n};\n\nstruct Solver {\n int N, M;\n int maxLen = 0;\n static constexpr int DOT = 8;\n static constexpr int MAXN = 20;\n\n struct UString {\n int len;\n array c;\n int freq;\n int occ;\n };\n\n vector us;\n unordered_map id_of;\n vector lens;\n bool usedLen[13]{};\n uint64_t len_prefix[13];\n vector row_base;\n\n vector grid, best_grid;\n int satisfied = 0, best_satisfied = 0;\n long long total_occ = 0, best_total_occ = 0;\n\n vector unsat_ids, pos_in_unsat;\n\n RNG rng;\n\n Solver() : rng((uint64_t)chrono::steady_clock::now().time_since_epoch().count()) {}\n\n uint64_t encode(const string &s) {\n uint64_t code = 0;\n for (char ch : s) code = (code << 3) | (uint64_t)(ch - 'A');\n return ((uint64_t)s.size() << 36) | code;\n }\n\n void read_input() {\n cin >> N >> M;\n id_of.reserve(M * 2 + 1);\n id_of.max_load_factor(0.7);\n\n for (int i = 0; i < M; i++) {\n string s;\n cin >> s;\n maxLen = max(maxLen, (int)s.size());\n usedLen[s.size()] = true;\n uint64_t key = encode(s);\n auto it = id_of.find(key);\n if (it == id_of.end()) {\n int id = (int)us.size();\n id_of[key] = id;\n UString u;\n u.len = (int)s.size();\n u.freq = 1;\n u.occ = 0;\n u.c.fill(0);\n for (int k = 0; k < u.len; k++) u.c[k] = (uint8_t)(s[k] - 'A');\n us.push_back(u);\n } else {\n us[it->second].freq++;\n }\n }\n\n for (int len = 2; len <= 12; len++) if (usedLen[len]) lens.push_back(len);\n for (int len = 0; len <= 12; len++) len_prefix[len] = (uint64_t)len << 36;\n\n row_base.resize(N);\n for (int i = 0; i < N; i++) row_base[i] = i * N;\n\n grid.assign(N * N, 0);\n best_grid.assign(N * N, 0);\n\n pos_in_unsat.assign(us.size(), -1);\n }\n\n inline void reset_unsat() {\n int U = us.size();\n unsat_ids.resize(U);\n pos_in_unsat.resize(U);\n for (int i = 0; i < U; i++) {\n unsat_ids[i] = i;\n pos_in_unsat[i] = i;\n }\n }\n\n inline void add_occ(int id, int delta) {\n int before = us[id].occ;\n int after = before + delta;\n us[id].occ = after;\n total_occ += (long long)delta * us[id].freq;\n if (before == 0 && after > 0) {\n satisfied += us[id].freq;\n int pos = pos_in_unsat[id];\n if (pos != -1) {\n int last = unsat_ids.back();\n unsat_ids[pos] = last;\n pos_in_unsat[last] = pos;\n unsat_ids.pop_back();\n pos_in_unsat[id] = -1;\n }\n } else if (before > 0 && after == 0) {\n satisfied -= us[id].freq;\n pos_in_unsat[id] = (int)unsat_ids.size();\n unsat_ids.push_back(id);\n }\n }\n\n inline void update_row(int row, int pos, int delta) {\n int base = row_base[row];\n for (int len : lens) {\n for (int t = 0; t < len; t++) {\n int start = pos - t;\n if (start < 0) start += N;\n uint64_t code = 0;\n int idx = start;\n bool valid = true;\n for (int k = 0; k < len; k++) {\n uint8_t v = grid[base + idx];\n if (v >= DOT) { valid = false; break; }\n code = (code << 3) | v;\n idx++;\n if (idx == N) idx = 0;\n }\n if (!valid) continue;\n uint64_t key = len_prefix[len] | code;\n auto it = id_of.find(key);\n if (it != id_of.end()) add_occ(it->second, delta);\n }\n }\n }\n\n inline void update_col(int col, int pos, int delta) {\n for (int len : lens) {\n for (int t = 0; t < len; t++) {\n int start = pos - t;\n if (start < 0) start += N;\n uint64_t code = 0;\n int idx = start;\n bool valid = true;\n for (int k = 0; k < len; k++) {\n uint8_t v = grid[idx * N + col];\n if (v >= DOT) { valid = false; break; }\n code = (code << 3) | v;\n idx++;\n if (idx == N) idx = 0;\n }\n if (!valid) continue;\n uint64_t key = len_prefix[len] | code;\n auto it = id_of.find(key);\n if (it != id_of.end()) add_occ(it->second, delta);\n }\n }\n }\n\n inline void change_cell(int row, int col, uint8_t newVal) {\n int idx = row_base[row] + col;\n uint8_t oldVal = grid[idx];\n if (oldVal == newVal) return;\n update_row(row, col, -1);\n update_col(col, row, -1);\n grid[idx] = newVal;\n update_row(row, col, +1);\n update_col(col, row, +1);\n }\n\n void recompute_counts() {\n for (auto &u : us) u.occ = 0;\n satisfied = 0;\n total_occ = 0;\n reset_unsat();\n\n for (int row = 0; row < N; row++) {\n int base = row_base[row];\n for (int start = 0; start < N; start++) {\n uint64_t code = 0;\n int idx = start;\n for (int len = 1; len <= maxLen; len++) {\n uint8_t v = grid[base + idx];\n if (v >= DOT) break;\n code = (code << 3) | v;\n idx++;\n if (idx == N) idx = 0;\n if (len >= 2 && usedLen[len]) {\n uint64_t key = len_prefix[len] | code;\n auto it = id_of.find(key);\n if (it != id_of.end()) add_occ(it->second, +1);\n }\n }\n }\n }\n\n for (int col = 0; col < N; col++) {\n for (int start = 0; start < N; start++) {\n uint64_t code = 0;\n int idx = start;\n for (int len = 1; len <= maxLen; len++) {\n uint8_t v = grid[idx * N + col];\n if (v >= DOT) break;\n code = (code << 3) | v;\n idx++;\n if (idx == N) idx = 0;\n if (len >= 2 && usedLen[len]) {\n uint64_t key = len_prefix[len] | code;\n auto it = id_of.find(key);\n if (it != id_of.end()) add_occ(it->second, +1);\n }\n }\n }\n }\n }\n\n void random_init() {\n for (int i = 0; i < N * N; i++) grid[i] = rng.next_int(8);\n }\n\n void greedy_init() {\n vector cells(N * N);\n iota(cells.begin(), cells.end(), 0);\n for (int i = (int)cells.size() - 1; i > 0; --i) {\n int j = rng.next_int(i + 1);\n swap(cells[i], cells[j]);\n }\n for (int idx : cells) {\n int row = idx / N, col = idx % N;\n uint8_t cur = grid[idx];\n int bestSat = satisfied;\n long long bestOcc = total_occ;\n uint8_t bestVal = cur;\n for (uint8_t v = 0; v < 8; v++) {\n if (v == cur) continue;\n change_cell(row, col, v);\n if (satisfied > bestSat || (satisfied == bestSat && total_occ > bestOcc)) {\n bestSat = satisfied;\n bestOcc = total_occ;\n bestVal = v;\n }\n change_cell(row, col, cur);\n }\n if (bestVal != cur) change_cell(row, col, bestVal);\n }\n }\n\n int pick_string() {\n if (!unsat_ids.empty()) {\n int best = unsat_ids[rng.next_int((int)unsat_ids.size())];\n long long bestScore = (long long)us[best].len * us[best].freq;\n for (int t = 0; t < 2; t++) {\n int cand = unsat_ids[rng.next_int((int)unsat_ids.size())];\n long long sc = (long long)us[cand].len * us[cand].freq;\n if (sc > bestScore) { best = cand; bestScore = sc; }\n }\n return best;\n }\n return rng.next_int((int)us.size());\n }\n\n struct Placement { bool vertical; int r, c; int mism; };\n\n Placement find_best_placement(int id) {\n const auto &u = us[id];\n int L = u.len;\n Placement best{false, 0, 0, INT_MAX};\n int tie = 0;\n\n for (int r = 0; r < N; r++) {\n int base = row_base[r];\n for (int c = 0; c < N; c++) {\n int mism = 0;\n int col = c;\n for (int p = 0; p < L; p++) {\n if (grid[base + col] != u.c[p]) mism++;\n col++; if (col == N) col = 0;\n }\n if (mism < best.mism) { best = {false, r, c, mism}; tie = 1; }\n else if (mism == best.mism) { tie++; if (rng.next_int(tie) == 0) best = {false, r, c, mism}; }\n }\n }\n\n for (int c = 0; c < N; c++) {\n for (int r = 0; r < N; r++) {\n int mism = 0;\n int row = r;\n for (int p = 0; p < L; p++) {\n if (grid[row * N + c] != u.c[p]) mism++;\n row++; if (row == N) row = 0;\n }\n if (mism < best.mism) { best = {true, r, c, mism}; tie = 1; }\n else if (mism == best.mism) { tie++; if (rng.next_int(tie) == 0) best = {true, r, c, mism}; }\n }\n }\n return best;\n }\n\n inline bool accept_move(int delta_c, long long delta_occ, double Tc, double To) {\n if (delta_c > 0) return true;\n if (delta_c < 0) {\n double p = exp((double)delta_c / Tc);\n return rng.next_double() < p;\n }\n if (delta_occ >= 0) return true;\n double p = exp((double)delta_occ / To);\n return rng.next_double() < p;\n }\n\n void simulated_annealing(double time_limit) {\n best_grid = grid;\n best_satisfied = satisfied;\n best_total_occ = total_occ;\n\n const double Tc0 = 5.0, Tc1 = 0.1;\n const double To0 = 20.0, To1 = 1.0;\n const double shiftProb = 0.05;\n\n auto start = chrono::steady_clock::now();\n double Tc = Tc0, To = To0;\n double pString = 0.5;\n int iter = 0;\n\n while (true) {\n if ((iter & 1023) == 0) {\n double elapsed = chrono::duration(chrono::steady_clock::now() - start).count();\n if (elapsed > time_limit) break;\n double t = elapsed / time_limit;\n Tc = Tc0 + (Tc1 - Tc0) * t;\n To = To0 + (To1 - To0) * t;\n if (Tc < 1e-9) Tc = 1e-9;\n if (To < 1e-9) To = 1e-9;\n pString = 0.45 * (1.0 - t) + 0.1;\n }\n iter++;\n\n double r = rng.next_double();\n if (r < shiftProb) {\n if (rng.next_int(2) == 0) {\n int row = rng.next_int(N);\n int shift = rng.next_int(N - 1) + 1;\n uint8_t old[MAXN];\n for (int j = 0; j < N; j++) old[j] = grid[row_base[row] + j];\n int cols[MAXN]; uint8_t olds[MAXN]; int cnt = 0;\n\n int prev_sat = satisfied;\n long long prev_occ = total_occ;\n\n for (int j = 0; j < N; j++) {\n uint8_t newVal = old[(j - shift + N) % N];\n if (grid[row_base[row] + j] != newVal) {\n cols[cnt] = j; olds[cnt] = grid[row_base[row] + j]; cnt++;\n change_cell(row, j, newVal);\n }\n }\n\n int delta_c = satisfied - prev_sat;\n long long delta_occ = total_occ - prev_occ;\n if (!accept_move(delta_c, delta_occ, Tc, To)) {\n for (int k = 0; k < cnt; k++) change_cell(row, cols[k], olds[k]);\n }\n } else {\n int col = rng.next_int(N);\n int shift = rng.next_int(N - 1) + 1;\n uint8_t old[MAXN];\n for (int i = 0; i < N; i++) old[i] = grid[i * N + col];\n int rows[MAXN]; uint8_t olds[MAXN]; int cnt = 0;\n\n int prev_sat = satisfied;\n long long prev_occ = total_occ;\n\n for (int i = 0; i < N; i++) {\n uint8_t newVal = old[(i - shift + N) % N];\n if (grid[i * N + col] != newVal) {\n rows[cnt] = i; olds[cnt] = grid[i * N + col]; cnt++;\n change_cell(i, col, newVal);\n }\n }\n\n int delta_c = satisfied - prev_sat;\n long long delta_occ = total_occ - prev_occ;\n if (!accept_move(delta_c, delta_occ, Tc, To)) {\n for (int k = 0; k < cnt; k++) change_cell(rows[k], col, olds[k]);\n }\n }\n } else if (r < shiftProb + pString) {\n int id = pick_string();\n auto place = find_best_placement(id);\n int L = us[id].len;\n int prev_sat = satisfied;\n long long prev_occ = total_occ;\n int rs[12], cs[12]; uint8_t olds[12]; int cnt = 0;\n\n for (int p = 0; p < L; p++) {\n int r = place.vertical ? (place.r + p) % N : place.r;\n int c = place.vertical ? place.c : (place.c + p) % N;\n uint8_t cur = grid[row_base[r] + c];\n uint8_t desired = us[id].c[p];\n if (cur != desired) {\n rs[cnt] = r; cs[cnt] = c; olds[cnt] = cur; cnt++;\n change_cell(r, c, desired);\n }\n }\n\n int delta_c = satisfied - prev_sat;\n long long delta_occ = total_occ - prev_occ;\n if (!accept_move(delta_c, delta_occ, Tc, To)) {\n for (int k = 0; k < cnt; k++) change_cell(rs[k], cs[k], olds[k]);\n }\n } else {\n int idx = rng.next_int(N * N);\n int row = idx / N, col = idx % N;\n uint8_t oldVal = grid[idx];\n uint8_t newVal = rng.next_int(8);\n if (newVal == oldVal) continue;\n int prev_sat = satisfied;\n long long prev_occ = total_occ;\n change_cell(row, col, newVal);\n int delta_c = satisfied - prev_sat;\n long long delta_occ = total_occ - prev_occ;\n if (!accept_move(delta_c, delta_occ, Tc, To)) {\n change_cell(row, col, oldVal);\n }\n }\n\n if (satisfied > best_satisfied || (satisfied == best_satisfied && total_occ > best_total_occ)) {\n best_satisfied = satisfied;\n best_total_occ = total_occ;\n best_grid = grid;\n }\n }\n }\n\n void greedy_shift_improve() {\n for (int row = 0; row < N; row++) {\n uint8_t orig[MAXN];\n for (int j = 0; j < N; j++) orig[j] = grid[row_base[row] + j];\n\n int bestShift = 0;\n int bestSat = satisfied;\n long long bestOcc = total_occ;\n\n for (int shift = 1; shift < N; shift++) {\n for (int j = 0; j < N; j++) {\n uint8_t newVal = orig[(j - shift + N) % N];\n if (grid[row_base[row] + j] != newVal) change_cell(row, j, newVal);\n }\n if (satisfied > bestSat || (satisfied == bestSat && total_occ > bestOcc)) {\n bestSat = satisfied;\n bestOcc = total_occ;\n bestShift = shift;\n }\n for (int j = 0; j < N; j++) {\n if (grid[row_base[row] + j] != orig[j]) change_cell(row, j, orig[j]);\n }\n }\n\n if (bestShift != 0) {\n for (int j = 0; j < N; j++) {\n uint8_t newVal = orig[(j - bestShift + N) % N];\n if (grid[row_base[row] + j] != newVal) change_cell(row, j, newVal);\n }\n }\n }\n\n for (int col = 0; col < N; col++) {\n uint8_t orig[MAXN];\n for (int i = 0; i < N; i++) orig[i] = grid[i * N + col];\n\n int bestShift = 0;\n int bestSat = satisfied;\n long long bestOcc = total_occ;\n\n for (int shift = 1; shift < N; shift++) {\n for (int i = 0; i < N; i++) {\n uint8_t newVal = orig[(i - shift + N) % N];\n if (grid[i * N + col] != newVal) change_cell(i, col, newVal);\n }\n if (satisfied > bestSat || (satisfied == bestSat && total_occ > bestOcc)) {\n bestSat = satisfied;\n bestOcc = total_occ;\n bestShift = shift;\n }\n for (int i = 0; i < N; i++) {\n if (grid[i * N + col] != orig[i]) change_cell(i, col, orig[i]);\n }\n }\n\n if (bestShift != 0) {\n for (int i = 0; i < N; i++) {\n uint8_t newVal = orig[(i - bestShift + N) % N];\n if (grid[i * N + col] != newVal) change_cell(i, col, newVal);\n }\n }\n }\n }\n\n void remove_cells() {\n vector cells(N * N);\n iota(cells.begin(), cells.end(), 0);\n bool changed = true;\n while (changed) {\n changed = false;\n for (int i = (int)cells.size() - 1; i > 0; --i) {\n int j = rng.next_int(i + 1);\n swap(cells[i], cells[j]);\n }\n for (int idx : cells) {\n if (grid[idx] == DOT) continue;\n int row = idx / N, col = idx % N;\n uint8_t oldVal = grid[idx];\n change_cell(row, col, DOT);\n if (satisfied == M) {\n changed = true;\n } else {\n change_cell(row, col, oldVal);\n }\n }\n }\n }\n\n void output_grid(const vector &g) {\n for (int i = 0; i < N; i++) {\n string line;\n line.reserve(N);\n for (int j = 0; j < N; j++) {\n uint8_t v = g[i * N + j];\n if (v == DOT) line.push_back('.');\n else line.push_back(char('A' + v));\n }\n cout << line << '\\n';\n }\n }\n\n void solve() {\n random_init();\n recompute_counts();\n greedy_init();\n simulated_annealing(2.4);\n\n grid = best_grid;\n recompute_counts();\n greedy_shift_improve();\n if (satisfied > best_satisfied || (satisfied == best_satisfied && total_occ > best_total_occ)) {\n best_grid = grid;\n best_satisfied = satisfied;\n best_total_occ = total_occ;\n }\n\n grid = best_grid;\n recompute_counts();\n if (satisfied == M) {\n remove_cells();\n best_grid = grid;\n }\n\n output_grid(best_grid);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n Solver solver;\n solver.read_input();\n solver.solve();\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nconst int INF = 1e9;\n\nstruct HopcroftKarp {\n int nL, nR;\n vector> adj;\n vector dist, matchL, matchR;\n HopcroftKarp(int nL=0, int nR=0): nL(nL), nR(nR), adj(nL), dist(nL),\n matchL(nL, -1), matchR(nR, -1) {}\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> neigh;\nvector weight;\n\nvector dijkstra(int start, vector* prev=nullptr, int goal=-1){\n vector dist(R, INF);\n if(prev) prev->assign(R, -1);\n using P = pair;\n priority_queue, greater

> pq;\n dist[start]=0;\n pq.push({0,start});\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=dist[u]) continue;\n if(u==goal) break;\n for(int v: neigh[u]){\n int nd = d + weight[v];\n if(nd < dist[v]){\n dist[v]=nd;\n if(prev) (*prev)[v]=u;\n pq.push({nd,v});\n }\n }\n }\n return dist;\n}\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, si, sj;\n if(!(cin>>N>>si>>sj)) return 0;\n vector grid(N);\n for(int i=0;i>grid[i];\n\n vector> id(N, vector(N,-1));\n vector> pos;\n for(int i=0;i=N||ny<0||ny>=N) continue;\n int v=id[nx][ny];\n if(v!=-1) neigh[u].push_back(v);\n }\n }\n\n vector rowSegOf(R), colSegOf(R);\n vector> rowSegCells, colSegCells;\n\n for(int i=0;i> rowAdj(Rseg), rowAdjCell(Rseg);\n for(int cid=0; cid visL(Rseg,false), visR(Cseg,false);\n queue q;\n for(int r=0;r coverRows, coverCols;\n for(int r=0;r distStart = dijkstra(startId);\n\n vector rowToCover(Rseg,-1), colToCover(Cseg,-1);\n vector coverRowId, coverColId;\n for(int r: coverRows){ rowToCover[r]=(int)coverRowId.size(); coverRowId.push_back(r); }\n for(int c: coverCols){ colToCover[c]=(int)coverColId.size(); coverColId.push_back(c); }\n\n HopcroftKarp hk2((int)coverRowId.size(), (int)coverColId.size());\n for(int idx=0; idx<(int)coverRowId.size(); idx++){\n int r=coverRowId[idx];\n for(int c: rowAdj[r]){\n int j=colToCover[c];\n if(j!=-1) hk2.addEdge(idx, j);\n }\n }\n hk2.maxMatching();\n\n auto getCell = [&](int r, int c)->int{\n auto &adj = rowAdj[r];\n auto &cells = rowAdjCell[r];\n for(size_t k=0;k targets;\n vector isTarget(R,false);\n auto addTarget = [&](int cid){\n if(cid<0) return;\n if(!isTarget[cid]){\n isTarget[cid]=true;\n targets.push_back(cid);\n }\n };\n\n for(int i=0;i<(int)coverRowId.size();i++){\n int m=hk2.matchL[i];\n if(m!=-1){\n int r=coverRowId[i], c=coverColId[m];\n addTarget(getCell(r,c));\n }\n }\n for(int i=0;i<(int)coverRowId.size();i++){\n if(hk2.matchL[i]==-1){\n int r=coverRowId[i];\n int best=-1, bestDist=INF;\n for(int cid: rowSegCells[r]){\n if(distStart[cid] rowCount(Rseg,0), colCount(Cseg,0);\n for(int cid: targets){\n rowCount[rowSegOf[cid]]++;\n colCount[colSegOf[cid]]++;\n }\n vector alive(targets.size(), true);\n bool changed=true;\n while(changed){\n changed=false;\n for(size_t i=1;i1 && colCount[c]>1){\n alive[i]=false;\n rowCount[r]--; colCount[c]--;\n changed=true;\n }\n }\n }\n vector tmp;\n for(size_t i=0;i> distMat(K, vector(K, INF));\n for(int i=0;i order;\n vector used(K,false);\n order.push_back(0); used[0]=true;\n for(int step=1; step=3){\n for(int pass=0; pass<2; pass++){\n bool improved=false;\n for(int i=1;i{src};\n vector prev;\n auto dist = dijkstra(src, &prev, dst);\n vector path;\n int cur=dst;\n while(cur!=-1 && cur!=src){\n path.push_back(cur);\n cur=prev[cur];\n }\n if(cur==-1){\n path.clear(); path.push_back(src);\n return path;\n }\n path.push_back(src);\n reverse(path.begin(), path.end());\n return path;\n };\n\n string ans;\n ans.reserve(200000);\n for(int idx=0; idx\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) cin >> d[i][k];\n }\n\n vector> out(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 out[u].push_back(v);\n indeg[v]++;\n }\n\n // difficulty (sum of requirements)\n vector difficulty(N, 0);\n vector avg(K, 0.0);\n for (int i = 0; i < N; ++i) {\n int sum = 0;\n for (int k = 0; k < K; ++k) {\n sum += d[i][k];\n avg[k] += d[i][k];\n }\n difficulty[i] = sum;\n }\n for (int k = 0; k < K; ++k) avg[k] /= N;\n\n // critical path length (depth)\n vector depth(N, 1);\n for (int i = N - 1; i >= 0; --i) {\n int mx = 0;\n for (int v : out[i]) mx = max(mx, depth[v]);\n depth[i] = mx + 1;\n }\n\n // skill estimation\n vector> skill(M, vector(K));\n double init_factor = 0.8;\n for (int j = 0; j < M; ++j) {\n for (int k = 0; k < K; ++k) skill[j][k] = avg[k] * init_factor;\n }\n\n vector state(N, -1); // -1: not started, 0: in progress, 1: done\n vector rem = indeg;\n\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector done_cnt(M, 0);\n\n auto predict_time = [&](int w, int task) -> double {\n double wsum = 0.0;\n for (int k = 0; k < K; ++k) {\n double diff = d[task][k] - skill[w][k];\n if (diff > 0) wsum += diff;\n }\n return max(1.0, wsum);\n };\n\n auto update_skill = [&](int w, int task, int actual_time) {\n auto &s = skill[w];\n vector diff(K);\n double w_hat = 0.0;\n for (int k = 0; k < K; ++k) {\n diff[k] = d[task][k] - s[k];\n if (diff[k] > 0) w_hat += diff[k];\n }\n\n double target = (actual_time == 1 ? 0.0 : (double)actual_time);\n double e = w_hat - target;\n\n int cnt = ++done_cnt[w];\n double base_lr = 1.0;\n double lr = base_lr / sqrt((double)cnt);\n\n double tau = 2.0;\n double sumW = 0.0;\n vector weight(K);\n for (int k = 0; k < K; ++k) {\n double wgt = 1.0 / (1.0 + exp(-diff[k] / tau));\n weight[k] = wgt;\n sumW += wgt;\n }\n if (sumW < 1e-6) sumW = 1e-6;\n\n double coeff = lr * e / sumW;\n double max_skill = 100.0;\n for (int k = 0; k < K; ++k) {\n s[k] += coeff * weight[k];\n s[k] = max(0.0, min(max_skill, s[k]));\n }\n };\n\n auto cmp = [&](int a, int b) {\n if (depth[a] != depth[b]) return depth[a] > depth[b];\n if (difficulty[a] != difficulty[b]) return difficulty[a] > difficulty[b];\n return a < b;\n };\n\n int day = 1;\n while (true) {\n // available tasks\n vector available;\n for (int i = 0; i < N; ++i) {\n if (state[i] == -1 && rem[i] == 0) available.push_back(i);\n }\n\n // free workers\n vector free_workers;\n for (int j = 0; j < M; ++j) {\n if (current_task[j] == -1) free_workers.push_back(j);\n }\n\n vector> assign;\n if (!available.empty() && !free_workers.empty()) {\n sort(available.begin(), available.end(), cmp);\n\n for (int task : available) {\n if (free_workers.empty()) break;\n int best_idx = -1;\n double best_time = 1e18;\n for (int i = 0; i < (int)free_workers.size(); ++i) {\n int w = free_workers[i];\n double t = predict_time(w, task);\n if (t < best_time) {\n best_time = t;\n best_idx = i;\n }\n }\n int w = free_workers[best_idx];\n assign.emplace_back(w, task);\n\n free_workers[best_idx] = free_workers.back();\n free_workers.pop_back();\n\n current_task[w] = task;\n start_day[w] = day;\n state[task] = 0;\n }\n }\n\n // output\n cout << assign.size();\n for (auto &p : assign) {\n cout << \" \" << p.first + 1 << \" \" << p.second + 1;\n }\n cout << \"\\n\" << flush;\n\n int n;\n if (!(cin >> n)) return 0;\n if (n == -1) break;\n\n for (int i = 0; i < n; ++i) {\n int w; cin >> w; --w;\n int task = current_task[w];\n int duration = day - start_day[w] + 1;\n\n update_skill(w, task, duration);\n\n current_task[w] = -1;\n state[task] = 1;\n for (int v : out[task]) rem[v]--;\n }\n\n day++;\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int ax, ay, cx, cy, id;\n};\n\nstruct Node {\n int idx;\n bool pickup;\n};\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint32_t next() { x ^= x << 7; x ^= x >> 9; return (uint32_t)x; }\n int randint(int l, int r) { return l + (next() % (r - l + 1)); }\n double randdouble() { return (double)next() / 4294967296.0; }\n};\n\nstruct InsertInfo {\n long long delta;\n int pos_pick, pos_del;\n};\n\nstruct Option {\n long long delta;\n int idx, pos_pick, pos_del;\n};\n\nstruct Solution {\n vector seq;\n vector selected;\n long long cost;\n};\n\nconst int OFFICE_X = 400;\nconst int OFFICE_Y = 400;\n\nvector px, py, dx, dy, candId;\n\ninline int dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\ninline int getX(const Node &n) { return n.pickup ? px[n.idx] : dx[n.idx]; }\ninline int getY(const Node &n) { return n.pickup ? py[n.idx] : dy[n.idx]; }\n\nlong long calcCost(const vector &seq) {\n int x = OFFICE_X, y = OFFICE_Y;\n long long cost = 0;\n for (auto &n : seq) {\n int nx = getX(n), ny = getY(n);\n cost += abs(x - nx) + abs(y - ny);\n x = nx; y = ny;\n }\n cost += abs(x - OFFICE_X) + abs(y - OFFICE_Y);\n return cost;\n}\n\n// Best insertion of pickup+delivery into current route\nInsertInfo bestInsertion(const vector &seq, int oid) {\n int L = (int)seq.size();\n int Px = px[oid], Py = py[oid];\n int Dx = dx[oid], Dy = dy[oid];\n long long best = (1LL << 60);\n int bestI = 0, bestJ = 1;\n\n for (int i = 0; i <= L; ++i) {\n int Ax = (i == 0 ? OFFICE_X : getX(seq[i - 1]));\n int Ay = (i == 0 ? OFFICE_Y : getY(seq[i - 1]));\n int Bx = (i == L ? OFFICE_X : getX(seq[i]));\n int By = (i == L ? OFFICE_Y : getY(seq[i]));\n\n long long delta_pick = dist(Ax, Ay, Px, Py) + dist(Px, Py, Bx, By) - dist(Ax, Ay, Bx, By);\n\n for (int j = i + 1; j <= L + 1; ++j) {\n long long delta_del;\n if (j == i + 1) {\n delta_del = dist(Px, Py, Dx, Dy) + dist(Dx, Dy, Bx, By) - dist(Px, Py, Bx, By);\n } else {\n int prevx = getX(seq[j - 2]), prevy = getY(seq[j - 2]);\n int nextx, nexty;\n if (j - 1 == L) {\n nextx = OFFICE_X; nexty = OFFICE_Y;\n } else {\n nextx = getX(seq[j - 1]); nexty = getY(seq[j - 1]);\n }\n delta_del = dist(prevx, prevy, Dx, Dy) + dist(Dx, Dy, nextx, nexty) - dist(prevx, prevy, nextx, nexty);\n }\n long long delta = delta_pick + delta_del;\n if (delta < best) {\n best = delta;\n bestI = i;\n bestJ = j;\n }\n }\n }\n return {best, bestI, bestJ};\n}\n\nSolution buildSolution(RNG &rng, bool randomize) {\n int K = (int)px.size();\n vector seq;\n vector rem(K), pos(K);\n iota(rem.begin(), rem.end(), 0);\n iota(pos.begin(), pos.end(), 0);\n\n vector selected;\n selected.reserve(50);\n\n for (int step = 0; step < 50; ++step) {\n int TOP = randomize ? 3 : 1;\n vector

> pq;\n dist[start]=0;\n pq.push({0,start});\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=dist[u]) continue;\n for(int v: neigh[u]){\n int nd = d + weight[v];\n if(nd < dist[v]){\n dist[v]=nd;\n if(prev) (*prev)[v]=u;\n pq.push({nd,v});\n }\n }\n }\n return dist;\n}\n\nlong long tourCost(const vector& order, const vector>& distMat){\n long long res=0;\n int K=order.size();\n for(int i=0;i& order, const vector>& distMat){\n int K=order.size();\n if(K<=3) return false;\n vector prefF(K,0), prefR(K,0);\n for(int i=0;i& order, const vector>& distMat){\n int K=order.size();\n if(K<=3) return false;\n long long bestDelta=0;\n int bestI=-1, bestPos=-1;\n for(int i=1;i seq;\n seq.reserve(K-1);\n for(int k=0;k seq;\n for(int k=0;k newOrder;\n for(int k=0;k<=bestPos;k++) newOrder.push_back(seq[k]);\n newOrder.push_back(x);\n for(int k=bestPos+1;k<(int)seq.size();k++) newOrder.push_back(seq[k]);\n order.swap(newOrder);\n return true;\n }\n return false;\n}\n\nbool bestSwap(vector& order, const vector>& distMat){\n int K=order.size();\n if(K<=3) return false;\n long long bestDelta=0;\n int bi=-1,bj=-1;\n for(int i=1;i& order, const vector>& distMat){\n if(order.size()<=2) return;\n for(int iter=0; iter<200; iter++){\n if(best2opt(order, distMat)) continue;\n if(bestRelocate(order, distMat)) continue;\n if(bestSwap(order, distMat)) continue;\n break;\n }\n}\n\nvector build_nn(const vector>& distMat){\n int K=distMat.size();\n vector order;\n vector used(K,false);\n order.push_back(0);\n used[0]=true;\n for(int step=1; step build_ci(const vector>& distMat){\n int K=distMat.size();\n vector order;\n int v=1; long long best=LLONG_MAX;\n for(int j=1;j used(K,false);\n used[0]=used[v]=true;\n while((int)order.size() build_random(const vector>& distMat, mt19937& rng){\n int K=distMat.size();\n vector order;\n order.push_back(0);\n vector nodes;\n for(int i=1;i find_best_order(const vector>& distMat, mt19937& rng, const vector* base=nullptr){\n vector> candidates;\n if(base) candidates.push_back(*base);\n candidates.push_back(build_nn(distMat));\n candidates.push_back(build_ci(distMat));\n for(int t=0;t<2;t++) candidates.push_back(build_random(distMat, rng));\n\n long long bestCost=LLONG_MAX;\n vector bestOrder;\n for(auto ord: candidates){\n localSearch(ord, distMat);\n long long c= tourCost(ord, distMat);\n\n vector rev=ord;\n reverse(rev.begin()+1, rev.end());\n localSearch(rev, distMat);\n long long c2= tourCost(rev, distMat);\n if(c2>N>>si>>sj)) return 0;\n vector grid(N);\n for(int i=0;i>grid[i];\n\n vector> id(N, vector(N,-1));\n vector> pos;\n weight.clear();\n for(int i=0;i=N||ny<0||ny>=N) continue;\n int v=id[nx][ny];\n if(v!=-1) neigh[u].push_back(v);\n }\n }\n\n int startId = id[si][sj];\n vector distStart = dijkstra(startId);\n\n vector rowSegOf(R), colSegOf(R);\n vector> rowSegCells, colSegCells;\n for(int i=0;i> rowAdj(Rseg), rowAdjCell(Rseg);\n for(int cid=0; cid idx(rowAdj[r].size());\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(), [&](int a, int b){\n return distStart[rowAdjCell[r][a]] < distStart[rowAdjCell[r][b]];\n });\n vector newAdj, newCell;\n newAdj.reserve(idx.size());\n newCell.reserve(idx.size());\n for(int k: idx){\n newAdj.push_back(rowAdj[r][k]);\n newCell.push_back(rowAdjCell[r][k]);\n }\n rowAdj[r].swap(newAdj);\n rowAdjCell[r].swap(newCell);\n }\n\n HopcroftKarp hk(Rseg, Cseg);\n for(int r=0;r visL(Rseg,false), visR(Cseg,false);\n queue q;\n for(int r=0;r selectedRow(Rseg,false), selectedCol(Cseg,false);\n vector coverRows, coverCols;\n for(int r=0;r rowToCover(Rseg,-1), colToCover(Cseg,-1);\n vector coverRowId, coverColId;\n for(int r: coverRows){ rowToCover[r]=coverRowId.size(); coverRowId.push_back(r); }\n for(int c: coverCols){ colToCover[c]=coverColId.size(); coverColId.push_back(c); }\n\n HopcroftKarp hk2(coverRowId.size(), coverColId.size());\n for(int i=0;i<(int)coverRowId.size();i++){\n int r=coverRowId[i];\n for(size_t k=0;kint{\n auto &adj=rowAdj[r], &cells=rowAdjCell[r];\n for(size_t k=0;k targets;\n vector isTarget(R,false);\n auto addTarget = [&](int cid){\n if(cid<0) return;\n if(!isTarget[cid]){\n isTarget[cid]=true;\n targets.push_back(cid);\n }\n };\n\n for(int i=0;i<(int)coverRowId.size();i++){\n int m=hk2.matchL[i];\n if(m!=-1){\n int r=coverRowId[i], c=coverColId[m];\n addTarget(getCell(r,c));\n }\n }\n for(int i=0;i<(int)coverRowId.size();i++){\n if(hk2.matchL[i]==-1){\n int r=coverRowId[i], best=-1, bestDist=INF;\n for(int cid: rowSegCells[r])\n if(distStart[cid] rowCount(Rseg,0), colCount(Cseg,0);\n for(int cid: targets){\n rowCount[rowSegOf[cid]]++;\n colCount[colSegOf[cid]]++;\n }\n vector alive(targets.size(), true);\n bool changed=true;\n while(changed){\n changed=false;\n for(size_t i=1;i1;\n bool colOk = !selectedCol[c] || colCount[c]>1;\n if(rowOk && colOk){\n alive[i]=false;\n rowCount[r]--; colCount[c]--;\n changed=true;\n }\n }\n }\n vector newTargets;\n for(size_t i=0;i movableType(K,0), movableSeg(K,-1);\n for(int i=1;i> distAll, distMat;\n\n auto computeDistAll = [&](){\n distAll.assign(K, {});\n for(int i=0;i(K, INF));\n for(int i=0;i order = find_best_order(distMat, rng);\n\n auto optimize_positions = [&](const vector& order){\n vector posInOrder(K);\n for(int i=0;i newTargets = targets;\n for(int t=1;t& cand = (type==1 ? rowSegCells[movableSeg[t]] : colSegCells[movableSeg[t]]);\n int bestCell = targets[t];\n long long bestCost = (long long)distAll[pred][bestCell] + distAll[succ][bestCell]\n + weight[targets[succ]] - weight[bestCell];\n for(int c: cand){\n long long cost = (long long)distAll[pred][c] + distAll[succ][c]\n + weight[targets[succ]] - weight[c];\n if(cost < bestCost){\n bestCost = cost;\n bestCell = c;\n }\n }\n newTargets[t]=bestCell;\n }\n targets.swap(newTargets);\n };\n\n for(int iter=0; iter<2; iter++){\n optimize_positions(order);\n computeDistAll();\n computeDistMat();\n order = find_best_order(distMat, rng, &order);\n }\n\n vector> prevAll(K);\n distAll.assign(K, {});\n for(int i=0;i path;\n int cur=t;\n path.push_back(cur);\n while(cur!=s){\n cur=prevAll[sIdx][cur];\n if(cur==-1) break;\n path.push_back(cur);\n }\n reverse(path.begin(), path.end());\n for(size_t k=0;k+1\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) cin >> d[i][k];\n }\n\n vector> out(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 out[u].push_back(v);\n indeg[v]++;\n }\n\n // difficulty (sum of requirements)\n vector difficulty(N, 0);\n vector avg(K, 0.0);\n for (int i = 0; i < N; ++i) {\n int sum = 0;\n for (int k = 0; k < K; ++k) {\n sum += d[i][k];\n avg[k] += d[i][k];\n }\n difficulty[i] = sum;\n }\n for (int k = 0; k < K; ++k) avg[k] /= N;\n\n // critical path length (depth)\n vector depth(N, 1);\n for (int i = N - 1; i >= 0; --i) {\n int mx = 0;\n for (int v : out[i]) mx = max(mx, depth[v]);\n depth[i] = mx + 1;\n }\n\n // skill estimation\n vector> skill(M, vector(K));\n double init_factor = 0.8;\n for (int j = 0; j < M; ++j) {\n for (int k = 0; k < K; ++k) skill[j][k] = avg[k] * init_factor;\n }\n\n vector state(N, -1); // -1: not started, 0: in progress, 1: done\n vector rem = indeg;\n\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector done_cnt(M, 0);\n\n auto predict_time = [&](int w, int task) -> double {\n double wsum = 0.0;\n for (int k = 0; k < K; ++k) {\n double diff = d[task][k] - skill[w][k];\n if (diff > 0) wsum += diff;\n }\n return max(1.0, wsum);\n };\n\n auto update_skill = [&](int w, int task, int actual_time) {\n auto &s = skill[w];\n vector diff(K);\n double w_hat = 0.0;\n for (int k = 0; k < K; ++k) {\n diff[k] = d[task][k] - s[k];\n if (diff[k] > 0) w_hat += diff[k];\n }\n\n double target = (actual_time == 1 ? 0.0 : (double)actual_time);\n double e = w_hat - target;\n\n int cnt = ++done_cnt[w];\n double base_lr = 1.0;\n double lr = base_lr / sqrt((double)cnt);\n\n double tau = 2.0;\n double sumW = 0.0;\n vector weight(K);\n for (int k = 0; k < K; ++k) {\n double wgt = 1.0 / (1.0 + exp(-diff[k] / tau));\n weight[k] = wgt;\n sumW += wgt;\n }\n if (sumW < 1e-6) sumW = 1e-6;\n\n double coeff = lr * e / sumW;\n double max_skill = 100.0;\n for (int k = 0; k < K; ++k) {\n s[k] += coeff * weight[k];\n s[k] = max(0.0, min(max_skill, s[k]));\n }\n };\n\n auto cmp = [&](int a, int b) {\n if (depth[a] != depth[b]) return depth[a] > depth[b];\n if (difficulty[a] != difficulty[b]) return difficulty[a] > difficulty[b];\n return a < b;\n };\n\n int day = 1;\n while (true) {\n // available tasks\n vector available;\n for (int i = 0; i < N; ++i) {\n if (state[i] == -1 && rem[i] == 0) available.push_back(i);\n }\n\n // free workers\n vector free_workers;\n for (int j = 0; j < M; ++j) {\n if (current_task[j] == -1) free_workers.push_back(j);\n }\n\n vector> assign;\n if (!available.empty() && !free_workers.empty()) {\n sort(available.begin(), available.end(), cmp);\n\n for (int task : available) {\n if (free_workers.empty()) break;\n int best_idx = -1;\n double best_time = 1e18;\n for (int i = 0; i < (int)free_workers.size(); ++i) {\n int w = free_workers[i];\n double t = predict_time(w, task);\n if (t < best_time) {\n best_time = t;\n best_idx = i;\n }\n }\n int w = free_workers[best_idx];\n assign.emplace_back(w, task);\n\n free_workers[best_idx] = free_workers.back();\n free_workers.pop_back();\n\n current_task[w] = task;\n start_day[w] = day;\n state[task] = 0;\n }\n }\n\n // output\n cout << assign.size();\n for (auto &p : assign) {\n cout << \" \" << p.first + 1 << \" \" << p.second + 1;\n }\n cout << \"\\n\" << flush;\n\n int n;\n if (!(cin >> n)) return 0;\n if (n == -1) break;\n\n for (int i = 0; i < n; ++i) {\n int w; cin >> w; --w;\n int task = current_task[w];\n int duration = day - start_day[w] + 1;\n\n update_skill(w, task, duration);\n\n current_task[w] = -1;\n state[task] = 1;\n for (int v : out[task]) rem[v]--;\n }\n\n day++;\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint32_t next() { x ^= x << 7; x ^= x >> 9; return (uint32_t)x; }\n int randint(int l, int r) { return l + (next() % (r - l + 1)); }\n double randdouble() { return (double)next() / 4294967296.0; }\n};\n\nstruct Node {\n int idx;\n bool pickup;\n};\n\nstruct InsertInfo {\n long long delta;\n int pos_pick, pos_del;\n};\n\nstruct Option {\n long long delta;\n int id;\n int pos_pick, pos_del;\n int remIndex;\n};\n\nstruct Solution {\n vector seq;\n vector selected;\n long long cost;\n};\n\nconst int OFFICE_X = 400;\nconst int OFFICE_Y = 400;\n\nvector ax, ay, cx, cy;\n\ninline int dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\ninline int getX(const Node& n) { return n.pickup ? ax[n.idx] : cx[n.idx]; }\ninline int getY(const Node& n) { return n.pickup ? ay[n.idx] : cy[n.idx]; }\n\nlong long calcCost(const vector& seq) {\n int x = OFFICE_X, y = OFFICE_Y;\n long long cost = 0;\n for (const auto& n : seq) {\n int nx = getX(n), ny = getY(n);\n cost += abs(x - nx) + abs(y - ny);\n x = nx; y = ny;\n }\n cost += abs(x - OFFICE_X) + abs(y - OFFICE_Y);\n return cost;\n}\n\nInsertInfo bestInsertion(const vector& seq, int oid) {\n int L = seq.size();\n int Px = ax[oid], Py = ay[oid];\n int Dx = cx[oid], Dy = cy[oid];\n long long best = (1LL << 60);\n int bestI = 0, bestJ = 1;\n\n for (int i = 0; i <= L; ++i) {\n int Ax = (i == 0 ? OFFICE_X : getX(seq[i - 1]));\n int Ay = (i == 0 ? OFFICE_Y : getY(seq[i - 1]));\n int Bx = (i == L ? OFFICE_X : getX(seq[i]));\n int By = (i == L ? OFFICE_Y : getY(seq[i]));\n\n long long delta_pick = (long long)dist(Ax, Ay, Px, Py) + dist(Px, Py, Bx, By) - dist(Ax, Ay, Bx, By);\n\n for (int j = i + 1; j <= L + 1; ++j) {\n long long delta_del;\n if (j == i + 1) {\n delta_del = (long long)dist(Px, Py, Dx, Dy) + dist(Dx, Dy, Bx, By) - dist(Px, Py, Bx, By);\n } else {\n int prevx = getX(seq[j - 2]), prevy = getY(seq[j - 2]);\n int nextx, nexty;\n if (j - 1 == L) {\n nextx = OFFICE_X; nexty = OFFICE_Y;\n } else {\n nextx = getX(seq[j - 1]); nexty = getY(seq[j - 1]);\n }\n delta_del = (long long)dist(prevx, prevy, Dx, Dy) + dist(Dx, Dy, nextx, nexty) - dist(prevx, prevy, nextx, nexty);\n }\n long long delta = delta_pick + delta_del;\n if (delta < best) {\n best = delta;\n bestI = i; bestJ = j;\n }\n }\n }\n return {best, bestI, bestJ};\n}\n\nlong long removalDelta(const vector& seq, int ord, const vector& posPick, const vector& posDel) {\n int L = seq.size();\n int p = posPick[ord], d = posDel[ord];\n if (p < 0 || d < 0) return 0;\n if (p > d) swap(p, d);\n\n auto coord = [&](int idx)->pair {\n if (idx < 0 || idx >= L) return {OFFICE_X, OFFICE_Y};\n return {getX(seq[idx]), getY(seq[idx])};\n };\n\n auto [px, py] = coord(p);\n auto [dx, dy] = coord(d);\n\n int prevP = p - 1;\n int nextP = p + 1;\n auto [prevPx, prevPy] = coord(prevP);\n auto [nextPx, nextPy] = coord(nextP);\n\n long long deltaPick = (long long)dist(prevPx, prevPy, px, py) + dist(px, py, nextPx, nextPy) - dist(prevPx, prevPy, nextPx, nextPy);\n\n int prevD = (d == p + 1) ? (p - 1) : (d - 1);\n int nextD = (d == L - 1) ? L : d + 1;\n auto [prevDx, prevDy] = coord(prevD);\n auto [nextDx, nextDy] = coord(nextD);\n\n long long deltaDel = (long long)dist(prevDx, prevDy, dx, dy) + dist(dx, dy, nextDx, nextDy) - dist(prevDx, prevDy, nextDx, nextDy);\n\n return deltaPick + deltaDel;\n}\n\nSolution buildSolution(const vector& candidates, RNG& rng, bool randomize) {\n vector seq; seq.reserve(100);\n vector rem = candidates;\n vector selected; selected.reserve(50);\n const int TOP = 5;\n\n for (int step = 0; step < 50; ++step) {\n vector

> pq;\n dist[start]=0;\n pq.push({0,start});\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=dist[u]) continue;\n for(int v: neigh[u]){\n int nd=d+weight[v];\n if(nd> g;\n vector level, it;\n Dinic(int n=0): N(n), g(n), level(n), it(n) {}\n void addEdge(int fr,int to,ll cap){\n Edge a{to,cap,(int)g[to].size()};\n Edge b{fr,0,(int)g[fr].size()};\n g[fr].push_back(a);\n g[to].push_back(b);\n }\n bool bfs(int s,int t){\n fill(level.begin(), level.end(), -1);\n queue q;\n level[s]=0; q.push(s);\n while(!q.empty()){\n int v=q.front(); q.pop();\n for(auto &e:g[v]){\n if(e.cap>0 && level[e.to]<0){\n level[e.to]=level[v]+1;\n q.push(e.to);\n }\n }\n }\n return level[t]>=0;\n }\n ll dfs(int v,int t,ll f){\n if(v==t) return f;\n for(int &i=it[v]; i<(int)g[v].size(); i++){\n auto &e=g[v][i];\n if(e.cap>0 && level[v]0){\n e.cap-=d;\n g[e.to][e.rev].cap+=d;\n return d;\n }\n }\n }\n return 0;\n }\n ll maxflow(int s,int t){\n ll flow=0, inf=(1LL<<62);\n while(bfs(s,t)){\n fill(it.begin(), it.end(), 0);\n ll f;\n while((f=dfs(s,t,inf))>0) flow+=f;\n }\n return flow;\n }\n};\n\n// ----- MinCostMaxFlow -----\nstruct MinCostMaxFlow {\n struct Edge{int to, rev, cap; ll cost;};\n int N;\n vector> g;\n MinCostMaxFlow(int n=0): N(n), g(n) {}\n void addEdge(int fr,int to,int cap,ll cost){\n Edge a{to,(int)g[to].size(),cap,cost};\n Edge b{fr,(int)g[fr].size(),0,-cost};\n g[fr].push_back(a);\n g[to].push_back(b);\n }\n pair minCostMaxFlow(int s,int t,int maxf){\n int flow=0; ll cost=0;\n const ll INFLL=(1LL<<60);\n vector h(N,0), dist(N);\n vector pv(N), pe(N);\n while(flow, vector>, greater>> pq;\n pq.push({0,s});\n while(!pq.empty()){\n auto [d,v]=pq.top(); pq.pop();\n if(d!=dist[v]) continue;\n for(int i=0;i<(int)g[v].size();i++){\n auto &e=g[v][i];\n if(e.cap>0){\n ll nd=d+e.cost+h[v]-h[e.to];\n if(nd& order, const vector>& distMat){\n ll res=0;\n int K=order.size();\n for(int i=0;i& order, const vector>& distMat){\n int K=order.size();\n if(K<=3) return false;\n vector prefF(K,0), prefR(K,0);\n for(int i=0;i& order, const vector>& distMat){\n int K=order.size();\n if(K<=3) return false;\n ll bestDelta=0; int bestI=-1, bestPos=-1;\n for(int i=1;i seq;\n seq.reserve(K-1);\n for(int k=0;k seq;\n for(int k=0;k newOrder;\n for(int k=0;k<=bestPos;k++) newOrder.push_back(seq[k]);\n newOrder.push_back(x);\n for(int k=bestPos+1;k<(int)seq.size();k++) newOrder.push_back(seq[k]);\n order.swap(newOrder);\n return true;\n }\n return false;\n}\n\nbool bestSwap(vector& order, const vector>& distMat){\n int K=order.size();\n if(K<=3) return false;\n ll bestDelta=0; int bi=-1,bj=-1;\n for(int i=1;i& order, const vector>& distMat, int L){\n int K=order.size();\n if(K<=L+1) return false;\n ll bestDelta=0; int bestI=-1,bestJ=-1;\n vector inSeg(K);\n for(int i=1; i+L-1 < K; i++){\n fill(inSeg.begin(), inSeg.end(), false);\n for(int t=0;t seg;\n for(int t=0;t rem;\n rem.reserve(K-L);\n for(int idx=0; idx= bestI+L) rem.push_back(order[idx]);\n }\n int insertPos = (bestJ < bestI ? bestJ : bestJ - L);\n vector newOrder;\n newOrder.reserve(K);\n for(int idx=0; idx<=insertPos; idx++) newOrder.push_back(rem[idx]);\n for(int v: seg) newOrder.push_back(v);\n for(int idx=insertPos+1; idx<(int)rem.size(); idx++) newOrder.push_back(rem[idx]);\n order.swap(newOrder);\n return true;\n }\n return false;\n}\n\nvoid localSearch(vector& order, const vector>& distMat){\n const int MAX_IT = 120;\n for(int iter=0; iter build_nn(const vector>& distMat){\n int K=distMat.size();\n vector order;\n vector used(K,false);\n order.push_back(0); used[0]=true;\n for(int step=1; step build_ci(const vector>& distMat){\n int K=distMat.size();\n vector order;\n int v=1; ll best=LLONG_MAX;\n for(int j=1;j used(K,false);\n used[0]=used[v]=true;\n while((int)order.size() build_random(int K, mt19937& rng){\n vector order;\n order.push_back(0);\n vector nodes;\n for(int i=1;i doubleBridge(const vector& order, mt19937& rng){\n int K=order.size();\n if(K<8) return order;\n uniform_int_distribution dist(1, K-1);\n int a,b,c;\n for(int t=0;t<100;t++){\n a=dist(rng); b=dist(rng); c=dist(rng);\n if(a>b) swap(a,b);\n if(b>c) swap(b,c);\n if(a>b) swap(a,b);\n if(a>=1 && b>a+1 && c>b+1) break;\n }\n vector res;\n res.reserve(K);\n res.push_back(order[0]);\n res.insert(res.end(), order.begin()+1, order.begin()+a);\n res.insert(res.end(), order.begin()+b, order.begin()+c);\n res.insert(res.end(), order.begin()+a, order.begin()+b);\n res.insert(res.end(), order.begin()+c, order.end());\n return res;\n}\n\nvoid improve_with_reverse(vector& order, const vector>& distMat){\n localSearch(order, distMat);\n vector rev=order;\n reverse(rev.begin()+1, rev.end());\n localSearch(rev, distMat);\n if(tourCost(rev, distMat) < tourCost(order, distMat)) order.swap(rev);\n}\n\nvector iteratedSearch(vector order, const vector>& distMat,\n mt19937& rng, int ilsIter){\n improve_with_reverse(order, distMat);\n ll bestCost=tourCost(order, distMat);\n vector bestOrder=order;\n for(int it=0; it cand = doubleBridge(bestOrder, rng);\n improve_with_reverse(cand, distMat);\n ll c=tourCost(cand, distMat);\n if(c find_best_order(const vector>& distMat, mt19937& rng,\n const vector* base=nullptr, int ilsIter=10){\n int K=distMat.size();\n vector> candidates;\n if(base) candidates.push_back(*base);\n candidates.push_back(build_nn(distMat));\n candidates.push_back(build_ci(distMat));\n for(int t=0;t<2;t++) candidates.push_back(build_random(K, rng));\n ll best=LLONG_MAX;\n vector bestOrder;\n for(auto ord: candidates){\n ord = iteratedSearch(ord, distMat, rng, ilsIter);\n ll c = tourCost(ord, distMat);\n if(c& targets, int startId){\n auto it = find(targets.begin(), targets.end(), startId);\n if(it!=targets.begin()) swap(targets[0], *it);\n}\n\nbool pruneTargets(vector& targets,\n const vector& selectedRow,\n const vector& selectedCol, int startId){\n int K=targets.size();\n vector rowCount(Rseg,0), colCount(Cseg,0);\n for(int cid: targets){\n rowCount[rowSegOf[cid]]++;\n colCount[colSegOf[cid]]++;\n }\n vector alive(K,true);\n bool any=false, changed=true;\n while(changed){\n changed=false;\n for(int i=1;i1;\n bool colOk=!selectedCol[c] || colCount[c]>1;\n if(rowOk && colOk){\n alive[i]=false;\n rowCount[r]--; colCount[c]--;\n changed=true; any=true;\n }\n }\n }\n if(!any) return false;\n vector newT;\n for(int i=0;i& targets, vector>& distAll){\n int K=targets.size();\n distAll.resize(K);\n for(int i=0;i& targets, const vector>& distAll,\n vector>& distMat){\n int K=targets.size();\n distMat.assign(K, vector(K, INF));\n for(int i=0;i& targets, const vector& order,\n const vector>& distAll,\n const vector& selectedRow,\n const vector& selectedCol){\n int K=targets.size();\n vector posInOrder(K);\n for(int i=0;i& cand = (rsel ? rowSegCells[r] : colSegCells[c]);\n int idx=posInOrder[t];\n int pred=order[(idx-1+K)%K];\n int succ=order[(idx+1)%K];\n int bestCell=targets[t];\n ll bestCost=(ll)distAll[pred][bestCell]+distAll[succ][bestCell]\n + weight[targets[succ]] - weight[bestCell];\n for(int cell: cand){\n ll cost=(ll)distAll[pred][cell]+distAll[succ][cell]\n + weight[targets[succ]] - weight[cell];\n if(cost& targets, const vector>& prevAll,\n vector& pathRow, vector& pathCol,\n int& Wrow, int& Wcol){\n int K = targets.size();\n Wrow = (Rseg + 63) / 64;\n Wcol = (Cseg + 63) / 64;\n pathRow.assign((size_t)K*K*Wrow, 0);\n pathCol.assign((size_t)K*K*Wcol, 0);\n for(int i=0;i& order, const vector& pathRow,\n const vector& pathCol, int Wrow, int Wcol, int Kall){\n int K = order.size();\n vector visRow(Wrow,0), visCol(Wcol,0);\n for(int idx=0; idx> (r%64)) & 1ULL)==0 &&\n ((visCol[c/64] >> (c%64)) & 1ULL)==0)\n return false;\n }\n return true;\n}\n\nbool prune_order_by_path(vector& order, const vector>& distMat,\n const vector& pathRow, const vector& pathCol,\n int Wrow, int Wcol, int Kall){\n if(order.size()<=1) return false;\n bool improved=false;\n ll curCost = tourCost(order, distMat);\n bool changed=true;\n while(changed){\n changed=false;\n int K = order.size();\n for(int idx=1; idx= curCost) continue;\n vector cand = order;\n cand.erase(cand.begin()+idx);\n if(coverage_ok(cand, pathRow, pathCol, Wrow, Wcol, Kall)){\n order.swap(cand);\n curCost = newCost;\n improved=true;\n changed=true;\n break;\n }\n }\n }\n return improved;\n}\n\n// ----- Candidate -----\nstruct Candidate{\n vector targets;\n vector order;\n ll cost;\n vector selectedRow, selectedCol;\n};\n\nCandidate solveWithParams(long long base, long long penalty,\n uint64_t seed, int ilsIter){\n Candidate cand; cand.cost=LLONG_MAX;\n\n vector selectedRow(Rseg,false), selectedCol(Cseg,false);\n int S=0, rowOff=1, colOff=1+Rseg, T=1+Rseg+Cseg;\n Dinic din(T+1);\n const ll INF_CAP=(1LL<<60);\n for(int r=0;r reach(T+1,false);\n queue q;\n reach[S]=true; q.push(S);\n while(!q.empty()){\n int v=q.front(); q.pop();\n for(auto &e: din.g[v]){\n if(e.cap>0 && !reach[e.to]){\n reach[e.to]=true;\n q.push(e.to);\n }\n }\n }\n for(int r=0;r selRows, selCols;\n vector rowIndex(Rseg,-1), colIndex(Cseg,-1);\n for(int r=0;r> edgeCell(nL, vector(nR, -1));\n for(int i=0;i matchL(Nsize, -1);\n for(int i=0;i=Roff && e.to targets;\n vector isTarget(R,false);\n auto addTarget=[&](int cid){\n if(cid<0) return;\n if(!isTarget[cid]){\n isTarget[cid]=true;\n targets.push_back(cid);\n }\n };\n\n for(int i=0;i=0 && j order;\n vector> distAll, distMat;\n\n int posIter=2;\n for(int it=0; it improve_order_time(vector order, const vector>& distMat,\n mt19937& rng, chrono::steady_clock::time_point endTime){\n improve_with_reverse(order, distMat);\n ll bestCost = tourCost(order, distMat);\n vector bestOrder = order;\n int K=order.size();\n int iter=0;\n while(chrono::steady_clock::now() < endTime){\n vector cand = (iter%10==0) ? build_random(K, rng) : doubleBridge(bestOrder, rng);\n improve_with_reverse(cand, distMat);\n ll c = tourCost(cand, distMat);\n if(c < bestCost){\n bestCost = c;\n bestOrder = cand;\n }\n iter++;\n }\n return bestOrder;\n}\n\n// ----- Main -----\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> si >> sj;\n grid.resize(N);\n for(int i=0;i> grid[i];\n\n id.assign(N, vector(N,-1));\n for(int i=0;i=N||ny<0||ny>=N) continue;\n int v=id[nx][ny];\n if(v!=-1) neigh[u].push_back(v);\n }\n }\n\n startId = id[si][sj];\n distStart = dijkstra(startId);\n\n rowSegOf.assign(R,0);\n colSegOf.assign(R,0);\n for(int i=0;i(100000000LL, x);\n };\n vector bases = {\n 100000000LL,\n clampBase(maxDist*4),\n clampBase(maxDist*2),\n clampBase(maxDist),\n clampBase(maxDist/2),\n 0\n };\n sort(bases.begin(), bases.end());\n bases.erase(unique(bases.begin(), bases.end()), bases.end());\n\n vector pens = {0, avgDist/2, avgDist};\n sort(pens.begin(), pens.end());\n pens.erase(unique(pens.begin(), pens.end()), pens.end());\n\n uint64_t seed = 1234567u + N*100 + si*17 + sj;\n\n auto startTime = chrono::steady_clock::now();\n\n Candidate best;\n best.cost = LLONG_MAX;\n int ilsIterCandidate = 8;\n for(ll base: bases){\n for(ll pen: pens){\n Candidate cand = solveWithParams(base, pen, seed, ilsIterCandidate);\n if(cand.cost < best.cost){\n best = move(cand);\n }\n }\n }\n\n if(best.targets.size()==1){\n cout << \"\\n\";\n return 0;\n }\n\n vector> distAll, distMat;\n computeDistAll(best.targets, distAll);\n computeDistMat(best.targets, distAll, distMat);\n\n mt19937 rngFinal(seed ^ 0xdeadbeefULL);\n best.order = find_best_order(distMat, rngFinal, &best.order, 30);\n\n optimize_positions(best.targets, best.order, distAll, best.selectedRow, best.selectedCol);\n pruneTargets(best.targets, best.selectedRow, best.selectedCol, startId);\n\n computeDistAll(best.targets, distAll);\n computeDistMat(best.targets, distAll, distMat);\n\n best.order = find_best_order(distMat, rngFinal, nullptr, 30);\n\n auto endTime = startTime + chrono::milliseconds(2800);\n best.order = improve_order_time(best.order, distMat, rngFinal, endTime);\n\n // ---- Build prevAll for all targets ----\n int Kall = best.targets.size();\n vector> prevAll(Kall);\n for(int i=0;i pathRow, pathCol;\n build_path_bits(best.targets, prevAll, pathRow, pathCol, Wrow, Wcol);\n prune_order_by_path(best.order, distMat, pathRow, pathCol, Wrow, Wcol, Kall);\n\n // ---- Output ----\n int Kord = best.order.size();\n if(Kord==1){\n cout << \"\\n\";\n return 0;\n }\n\n string ans;\n ans.reserve(200000);\n for(int idx=0; idx path;\n int cur = t;\n path.push_back(cur);\n while(cur != s){\n cur = prevAll[sIdx][cur];\n if(cur==-1) break;\n path.push_back(cur);\n }\n reverse(path.begin(), path.end());\n for(size_t k=0;k+1\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) cin >> d[i][k];\n }\n\n vector> out(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 out[u].push_back(v);\n indeg[v]++;\n }\n\n // difficulty (sum of requirements)\n vector difficulty(N, 0);\n vector avg(K, 0.0);\n for (int i = 0; i < N; ++i) {\n int sum = 0;\n for (int k = 0; k < K; ++k) {\n sum += d[i][k];\n avg[k] += d[i][k];\n }\n difficulty[i] = sum;\n }\n for (int k = 0; k < K; ++k) avg[k] /= N;\n\n // critical path length (depth)\n vector depth(N, 1);\n for (int i = N - 1; i >= 0; --i) {\n int mx = 0;\n for (int v : out[i]) mx = max(mx, depth[v]);\n depth[i] = mx + 1;\n }\n\n // skill estimation\n vector> skill(M, vector(K));\n double init_factor = 0.8;\n for (int j = 0; j < M; ++j) {\n for (int k = 0; k < K; ++k) skill[j][k] = avg[k] * init_factor;\n }\n\n vector state(N, -1); // -1: not started, 0: in progress, 1: done\n vector rem = indeg;\n\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector done_cnt(M, 0);\n\n auto predict_time = [&](int w, int task) -> double {\n double wsum = 0.0;\n for (int k = 0; k < K; ++k) {\n double diff = d[task][k] - skill[w][k];\n if (diff > 0) wsum += diff;\n }\n return max(1.0, wsum);\n };\n\n auto update_skill = [&](int w, int task, int actual_time) {\n auto &s = skill[w];\n vector diff(K);\n double w_hat = 0.0;\n for (int k = 0; k < K; ++k) {\n diff[k] = d[task][k] - s[k];\n if (diff[k] > 0) w_hat += diff[k];\n }\n\n double target = (actual_time == 1 ? 0.0 : (double)actual_time);\n double e = w_hat - target;\n\n int cnt = ++done_cnt[w];\n double base_lr = 1.0;\n double lr = base_lr / sqrt((double)cnt);\n\n double tau = 2.0;\n double sumW = 0.0;\n vector weight(K);\n for (int k = 0; k < K; ++k) {\n double wgt = 1.0 / (1.0 + exp(-diff[k] / tau));\n weight[k] = wgt;\n sumW += wgt;\n }\n if (sumW < 1e-6) sumW = 1e-6;\n\n double coeff = lr * e / sumW;\n double max_skill = 100.0;\n for (int k = 0; k < K; ++k) {\n s[k] += coeff * weight[k];\n s[k] = max(0.0, min(max_skill, s[k]));\n }\n };\n\n auto cmp = [&](int a, int b) {\n if (depth[a] != depth[b]) return depth[a] > depth[b];\n if (difficulty[a] != difficulty[b]) return difficulty[a] > difficulty[b];\n return a < b;\n };\n\n int day = 1;\n while (true) {\n // available tasks\n vector available;\n for (int i = 0; i < N; ++i) {\n if (state[i] == -1 && rem[i] == 0) available.push_back(i);\n }\n\n // free workers\n vector free_workers;\n for (int j = 0; j < M; ++j) {\n if (current_task[j] == -1) free_workers.push_back(j);\n }\n\n vector> assign;\n if (!available.empty() && !free_workers.empty()) {\n sort(available.begin(), available.end(), cmp);\n\n for (int task : available) {\n if (free_workers.empty()) break;\n int best_idx = -1;\n double best_time = 1e18;\n for (int i = 0; i < (int)free_workers.size(); ++i) {\n int w = free_workers[i];\n double t = predict_time(w, task);\n if (t < best_time) {\n best_time = t;\n best_idx = i;\n }\n }\n int w = free_workers[best_idx];\n assign.emplace_back(w, task);\n\n free_workers[best_idx] = free_workers.back();\n free_workers.pop_back();\n\n current_task[w] = task;\n start_day[w] = day;\n state[task] = 0;\n }\n }\n\n // output\n cout << assign.size();\n for (auto &p : assign) {\n cout << \" \" << p.first + 1 << \" \" << p.second + 1;\n }\n cout << \"\\n\" << flush;\n\n int n;\n if (!(cin >> n)) return 0;\n if (n == -1) break;\n\n for (int i = 0; i < n; ++i) {\n int w; cin >> w; --w;\n int task = current_task[w];\n int duration = day - start_day[w] + 1;\n\n update_skill(w, task, duration);\n\n current_task[w] = -1;\n state[task] = 1;\n for (int v : out[task]) rem[v]--;\n }\n\n day++;\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint32_t next() { x ^= x << 7; x ^= x >> 9; return (uint32_t)x; }\n int randint(int l, int r) { return l + (next() % (r - l + 1)); }\n double randdouble() { return (double)next() / 4294967296.0; }\n};\n\nstruct Node {\n int idx;\n bool pickup;\n};\n\nstruct InsertInfo {\n long long delta;\n int pos_pick, pos_del;\n};\n\nstruct InsertInfo2 {\n long long best, second;\n int pos_pick, pos_del;\n};\n\nstruct Solution {\n vector seq;\n vector selected;\n long long cost;\n};\n\nconst int OFFICE_X = 400;\nconst int OFFICE_Y = 400;\nconst long long INF = (1LL << 60);\n\nvector ax, ay, cx, cy;\n\ninline int dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\ninline int getX(const Node &n) { return n.pickup ? ax[n.idx] : cx[n.idx]; }\ninline int getY(const Node &n) { return n.pickup ? ay[n.idx] : cy[n.idx]; }\n\nlong long calcCost(const vector& seq) {\n int x = OFFICE_X, y = OFFICE_Y;\n long long cost = 0;\n for (const auto &n : seq) {\n int nx = getX(n), ny = getY(n);\n cost += abs(x - nx) + abs(y - ny);\n x = nx; y = ny;\n }\n cost += abs(x - OFFICE_X) + abs(y - OFFICE_Y);\n return cost;\n}\n\nInsertInfo bestInsertion(const vector &seq, int oid) {\n int L = seq.size();\n int Px = ax[oid], Py = ay[oid];\n int Dx = cx[oid], Dy = cy[oid];\n\n long long best = INF;\n int bestI = 0, bestJ = 1;\n\n for (int i = 0; i <= L; ++i) {\n int Ax = (i == 0 ? OFFICE_X : getX(seq[i - 1]));\n int Ay = (i == 0 ? OFFICE_Y : getY(seq[i - 1]));\n int Bx = (i == L ? OFFICE_X : getX(seq[i]));\n int By = (i == L ? OFFICE_Y : getY(seq[i]));\n\n long long delta_pick = (long long)dist(Ax, Ay, Px, Py) + dist(Px, Py, Bx, By) - dist(Ax, Ay, Bx, By);\n\n for (int j = i + 1; j <= L + 1; ++j) {\n long long delta_del;\n if (j == i + 1) {\n delta_del = (long long)dist(Px, Py, Dx, Dy) + dist(Dx, Dy, Bx, By) - dist(Px, Py, Bx, By);\n } else {\n int prevx = getX(seq[j - 2]), prevy = getY(seq[j - 2]);\n int nextx, nexty;\n if (j - 1 == L) { nextx = OFFICE_X; nexty = OFFICE_Y; }\n else { nextx = getX(seq[j - 1]); nexty = getY(seq[j - 1]); }\n delta_del = (long long)dist(prevx, prevy, Dx, Dy) + dist(Dx, Dy, nextx, nexty) - dist(prevx, prevy, nextx, nexty);\n }\n long long delta = delta_pick + delta_del;\n if (delta < best) {\n best = delta;\n bestI = i;\n bestJ = j;\n }\n }\n }\n return {best, bestI, bestJ};\n}\n\nInsertInfo2 bestInsertion2(const vector &seq, int oid) {\n int L = seq.size();\n int Px = ax[oid], Py = ay[oid];\n int Dx = cx[oid], Dy = cy[oid];\n\n long long best = INF, second = INF;\n int bestI = 0, bestJ = 1;\n\n for (int i = 0; i <= L; ++i) {\n int Ax = (i == 0 ? OFFICE_X : getX(seq[i - 1]));\n int Ay = (i == 0 ? OFFICE_Y : getY(seq[i - 1]));\n int Bx = (i == L ? OFFICE_X : getX(seq[i]));\n int By = (i == L ? OFFICE_Y : getY(seq[i]));\n\n long long delta_pick = (long long)dist(Ax, Ay, Px, Py) + dist(Px, Py, Bx, By) - dist(Ax, Ay, Bx, By);\n\n for (int j = i + 1; j <= L + 1; ++j) {\n long long delta_del;\n if (j == i + 1) {\n delta_del = (long long)dist(Px, Py, Dx, Dy) + dist(Dx, Dy, Bx, By) - dist(Px, Py, Bx, By);\n } else {\n int prevx = getX(seq[j - 2]), prevy = getY(seq[j - 2]);\n int nextx, nexty;\n if (j - 1 == L) { nextx = OFFICE_X; nexty = OFFICE_Y; }\n else { nextx = getX(seq[j - 1]); nexty = getY(seq[j - 1]); }\n delta_del = (long long)dist(prevx, prevy, Dx, Dy) + dist(Dx, Dy, nextx, nexty) - dist(prevx, prevy, nextx, nexty);\n }\n long long delta = delta_pick + delta_del;\n if (delta < best) {\n second = best;\n best = delta;\n bestI = i; bestJ = j;\n } else if (delta < second) {\n second = delta;\n }\n }\n }\n return {best, second, bestI, bestJ};\n}\n\nstruct Option {\n long long delta;\n int id, pos_pick, pos_del, remIndex;\n};\n\nSolution buildSolution(const vector& candidates, int mode, RNG& rng) {\n vector seq;\n seq.reserve(100);\n vector rem = candidates;\n vector selected;\n selected.reserve(50);\n\n const int TOP = 3;\n\n for (int step = 0; step < 50; ++step) {\n if (mode == 2) { // regret\n long long bestReg = -1, bestCost = INF;\n int bestId = -1, bestPick = 0, bestDel = 1, bestRem = 0;\n for (int i = 0; i < (int)rem.size(); ++i) {\n int oid = rem[i];\n InsertInfo2 info = bestInsertion2(seq, oid);\n long long regret = (info.second >= INF / 2 ? 0 : info.second - info.best);\n if (regret > bestReg || (regret == bestReg && info.best < bestCost)) {\n bestReg = regret;\n bestCost = info.best;\n bestId = oid;\n bestPick = info.pos_pick;\n bestDel = info.pos_del;\n bestRem = i;\n }\n }\n seq.insert(seq.begin() + bestPick, Node{bestId, true});\n seq.insert(seq.begin() + bestDel, Node{bestId, false});\n selected.push_back(bestId);\n rem[bestRem] = rem.back();\n rem.pop_back();\n } else {\n vector

> pq;\n dist[start]=0; pq.push({0,start});\n while(!pq.empty()){\n auto [d,u]=pq.top(); pq.pop();\n if(d!=dist[u]) continue;\n for(int v: neigh[u]){\n int nd=d+weight[v];\n if(nd> g;\n vector level, it;\n Dinic(int n=0): N(n), g(n), level(n), it(n) {}\n void addEdge(int fr,int to,ll cap){\n Edge a{to,cap,(int)g[to].size()};\n Edge b{fr,0,(int)g[fr].size()};\n g[fr].push_back(a);\n g[to].push_back(b);\n }\n bool bfs(int s,int t){\n fill(level.begin(), level.end(), -1);\n queue q;\n level[s]=0; q.push(s);\n while(!q.empty()){\n int v=q.front(); q.pop();\n for(auto &e:g[v]){\n if(e.cap>0 && level[e.to]<0){\n level[e.to]=level[v]+1;\n q.push(e.to);\n }\n }\n }\n return level[t]>=0;\n }\n ll dfs(int v,int t,ll f){\n if(v==t) return f;\n for(int &i=it[v]; i<(int)g[v].size(); i++){\n auto &e=g[v][i];\n if(e.cap>0 && level[v]0){\n e.cap-=d;\n g[e.to][e.rev].cap+=d;\n return d;\n }\n }\n }\n return 0;\n }\n ll maxflow(int s,int t){\n ll flow=0, inf=(1LL<<62);\n while(bfs(s,t)){\n fill(it.begin(), it.end(), 0);\n ll f;\n while((f=dfs(s,t,inf))>0) flow+=f;\n }\n return flow;\n }\n};\n\n// ===== MinCostMaxFlow =====\nstruct MinCostMaxFlow {\n struct Edge{int to, rev, cap; ll cost;};\n int N;\n vector> g;\n MinCostMaxFlow(int n=0): N(n), g(n) {}\n void addEdge(int fr,int to,int cap,ll cost){\n Edge a{to,(int)g[to].size(),cap,cost};\n Edge b{fr,(int)g[fr].size(),0,-cost};\n g[fr].push_back(a);\n g[to].push_back(b);\n }\n pair minCostMaxFlow(int s,int t,int maxf){\n int flow=0; ll cost=0;\n const ll INFLL=(1LL<<60);\n vector h(N,0), dist(N);\n vector pv(N), pe(N);\n while(flow, vector>, greater>> pq;\n pq.push({0,s});\n while(!pq.empty()){\n auto [d,v]=pq.top(); pq.pop();\n if(d!=dist[v]) continue;\n for(int i=0;i<(int)g[v].size();i++){\n auto &e=g[v][i];\n if(e.cap>0){\n ll nd=d+e.cost+h[v]-h[e.to];\n if(nd& order, const vector>& distMat){\n ll res=0;\n int K=order.size();\n for(int i=0;i& order, const vector>& distMat){\n int K=order.size();\n if(K<=3) return false;\n vector prefF(K,0), prefR(K,0);\n for(int i=0;i& order, const vector>& distMat){\n int K=order.size();\n if(K<=3) return false;\n ll bestDelta=0; int bestI=-1,bestPos=-1;\n for(int i=1;i seq;\n seq.reserve(K-1);\n for(int k=0;k seq;\n for(int k=0;k newOrder;\n for(int k=0;k<=bestPos;k++) newOrder.push_back(seq[k]);\n newOrder.push_back(x);\n for(int k=bestPos+1;k<(int)seq.size();k++) newOrder.push_back(seq[k]);\n order.swap(newOrder);\n return true;\n }\n return false;\n}\n\nbool bestSwap(vector& order, const vector>& distMat){\n int K=order.size();\n if(K<=3) return false;\n ll bestDelta=0; int bi=-1,bj=-1;\n for(int i=1;i& order, const vector>& distMat, int L){\n int K=order.size();\n if(K<=L+1) return false;\n ll bestDelta=0; int bestI=-1,bestJ=-1;\n vector inSeg(K);\n for(int i=1; i+L-1 < K; i++){\n fill(inSeg.begin(), inSeg.end(), false);\n for(int t=0;t seg;\n for(int t=0;t rem;\n rem.reserve(K-L);\n for(int idx=0; idx= bestI+L) rem.push_back(order[idx]);\n }\n int insertPos = (bestJ < bestI ? bestJ : bestJ - L);\n vector newOrder;\n newOrder.reserve(K);\n for(int idx=0; idx<=insertPos; idx++) newOrder.push_back(rem[idx]);\n for(int v: seg) newOrder.push_back(v);\n for(int idx=insertPos+1; idx<(int)rem.size(); idx++) newOrder.push_back(rem[idx]);\n order.swap(newOrder);\n return true;\n }\n return false;\n}\n\nvoid localSearch(vector& order, const vector>& distMat){\n for(int iter=0; iter<200; iter++){\n if(best2opt(order, distMat)) continue;\n if(bestRelocate(order, distMat)) continue;\n if(bestOrOptLen(order, distMat, 2)) continue;\n if(bestOrOptLen(order, distMat, 3)) continue;\n if(bestSwap(order, distMat)) continue;\n break;\n }\n}\n\nvector build_nn(const vector>& distMat){\n int K=distMat.size();\n vector order;\n vector used(K,false);\n order.push_back(0); used[0]=true;\n for(int step=1; step build_ci(const vector>& distMat){\n int K=distMat.size();\n vector order;\n int v=1; ll best=LLONG_MAX;\n for(int j=1;j used(K,false);\n used[0]=used[v]=true;\n while((int)order.size() build_random(int K, mt19937& rng){\n vector order;\n order.push_back(0);\n vector nodes;\n for(int i=1;i doubleBridge(const vector& order, mt19937& rng){\n int K=order.size();\n if(K<8) return order;\n uniform_int_distribution dist(1, K-1);\n int a,b,c;\n for(int t=0;t<100;t++){\n a=dist(rng); b=dist(rng); c=dist(rng);\n if(a>b) swap(a,b);\n if(b>c) swap(b,c);\n if(a>b) swap(a,b);\n if(a>=1 && b>a+1 && c>b+1) break;\n }\n vector res;\n res.reserve(K);\n res.push_back(order[0]);\n res.insert(res.end(), order.begin()+1, order.begin()+a);\n res.insert(res.end(), order.begin()+b, order.begin()+c);\n res.insert(res.end(), order.begin()+a, order.begin()+b);\n res.insert(res.end(), order.begin()+c, order.end());\n return res;\n}\n\nvoid improve_with_reverse(vector& order, const vector>& distMat){\n localSearch(order, distMat);\n vector rev=order;\n reverse(rev.begin()+1, rev.end());\n localSearch(rev, distMat);\n if(tourCost(rev, distMat) < tourCost(order, distMat)) order.swap(rev);\n}\n\nvector iteratedSearch(vector order, const vector>& distMat,\n mt19937& rng, int ilsIter){\n improve_with_reverse(order, distMat);\n ll bestCost=tourCost(order, distMat);\n vector bestOrder=order;\n for(int it=0; it cand = doubleBridge(bestOrder, rng);\n improve_with_reverse(cand, distMat);\n ll c=tourCost(cand, distMat);\n if(c find_best_order(const vector>& distMat, mt19937& rng,\n const vector* base=nullptr, int ilsIter=6){\n int K=distMat.size();\n vector> candidates;\n if(base) candidates.push_back(*base);\n candidates.push_back(build_nn(distMat));\n candidates.push_back(build_ci(distMat));\n for(int t=0;t<2;t++) candidates.push_back(build_random(K, rng));\n ll best=LLONG_MAX;\n vector bestOrder;\n for(auto ord: candidates){\n ord = iteratedSearch(ord, distMat, rng, ilsIter);\n ll c = tourCost(ord, distMat);\n if(c& targets, int startId){\n auto it = find(targets.begin(), targets.end(), startId);\n if(it!=targets.begin()) swap(targets[0], *it);\n}\n\nbool pruneTargets(vector& targets,\n const vector& selectedRow,\n const vector& selectedCol, int startId){\n int K=targets.size();\n vector rowCount(Rseg,0), colCount(Cseg,0);\n for(int cid: targets){\n rowCount[rowSegOf[cid]]++;\n colCount[colSegOf[cid]]++;\n }\n vector alive(K,true);\n bool any=false, changed=true;\n while(changed){\n changed=false;\n for(int i=1;i1;\n bool colOk=!selectedCol[c] || colCount[c]>1;\n if(rowOk && colOk){\n alive[i]=false;\n rowCount[r]--; colCount[c]--;\n changed=true; any=true;\n }\n }\n }\n if(!any) return false;\n vector newT;\n for(int i=0;i& targets, vector>& distAll){\n int K=targets.size();\n distAll.resize(K);\n for(int i=0;i& targets, const vector>& distAll,\n vector>& distMat){\n int K=targets.size();\n distMat.assign(K, vector(K, INF));\n for(int i=0;i& targets, const vector& order,\n const vector>& distAll,\n const vector& selectedRow,\n const vector& selectedCol){\n int K=targets.size();\n vector posInOrder(K);\n for(int i=0;i& cand = (rsel ? rowSegCells[r] : colSegCells[c]);\n int idx=posInOrder[t];\n int pred=order[(idx-1+K)%K];\n int succ=order[(idx+1)%K];\n int bestCell=targets[t];\n ll bestCost=(ll)distAll[pred][bestCell]+distAll[succ][bestCell]\n + weight[targets[succ]] - weight[bestCell];\n for(int cell: cand){\n ll cost=(ll)distAll[pred][cell]+distAll[succ][cell]\n + weight[targets[succ]] - weight[cell];\n if(cost& targets, const vector>& prevAll,\n vector& pathRow, vector& pathCol,\n int& Wrow, int& Wcol){\n int K = targets.size();\n Wrow = (Rseg + 63) / 64;\n Wcol = (Cseg + 63) / 64;\n pathRow.assign((size_t)K*K*Wrow, 0);\n pathCol.assign((size_t)K*K*Wcol, 0);\n for(int i=0;i& order,\n const vector& pathRow, const vector& pathCol,\n int Wrow, int Wcol, int Kall){\n vector visRow(Wrow,0), visCol(Wcol,0);\n int K = order.size();\n for(int idx=0; idx> (r%64)) & 1ULL) continue;\n const auto& mask = rowMask[r];\n for(int w=0; w& order, const vector>& distMat,\n const vector& pathRow, const vector& pathCol,\n int Wrow, int Wcol, int Kall){\n if(order.size()<=1) return false;\n bool improved=false;\n ll curCost = tourCost(order, distMat);\n bool changed=true;\n while(changed){\n changed=false;\n int K = order.size();\n for(int idx=1; idx cand = order;\n cand.erase(cand.begin()+idx);\n if(coverage_ok(cand, pathRow, pathCol, Wrow, Wcol, Kall)){\n order.swap(cand);\n curCost += delta;\n improved=true;\n changed=true;\n break;\n }\n }\n }\n }\n return improved;\n}\n\nbool try_or_opt_coverage(vector& order, const vector>& distMat,\n const vector& pathRow, const vector& pathCol,\n int Wrow, int Wcol, int Kall, int L, ll &curCost,\n chrono::steady_clock::time_point endTime){\n int K = order.size();\n if(K<=L+1) return false;\n vector inSeg(K);\n for(int i=1; i+L-1 < K; i++){\n if(chrono::steady_clock::now() >= endTime) return false;\n fill(inSeg.begin(), inSeg.end(), false);\n for(int t=0;t seg(order.begin()+i, order.begin()+i+L);\n vector rem;\n rem.reserve(K-L);\n for(int idx=0; idx cand;\n cand.reserve(K);\n for(int idx=0; idx<=insertPos; idx++) cand.push_back(rem[idx]);\n for(int v: seg) cand.push_back(v);\n for(int idx=insertPos+1; idx<(int)rem.size(); idx++) cand.push_back(rem[idx]);\n if(coverage_ok(cand, pathRow, pathCol, Wrow, Wcol, Kall)){\n order.swap(cand);\n curCost += delta;\n return true;\n }\n }\n }\n }\n return false;\n}\n\nvoid coverage_local_search(vector& order,\n const vector>& distMat,\n const vector& pathRow,\n const vector& pathCol,\n int Wrow, int Wcol, int Kall,\n mt19937& rng,\n chrono::steady_clock::time_point endTime){\n if(order.size()<=1) return;\n ll curCost = tourCost(order, distMat);\n\n while(chrono::steady_clock::now() < endTime){\n bool improved=false;\n int K = order.size();\n\n // remove\n for(int idx=1; idx= endTime) return;\n int a = order[(idx-1+K)%K];\n int b = order[idx];\n int c = order[(idx+1)%K];\n ll delta = (ll)distMat[a][c] - distMat[a][b] - distMat[b][c];\n if(delta < 0){\n vector cand = order;\n cand.erase(cand.begin()+idx);\n if(coverage_ok(cand, pathRow, pathCol, Wrow, Wcol, Kall)){\n order.swap(cand);\n curCost += delta;\n improved=true;\n break;\n }\n }\n }\n if(improved) continue;\n\n // 2-opt\n vector prefF(K,0), prefR(K,0);\n for(int i=0;i= endTime) return;\n ll sumF=prefF[j]-prefF[i];\n ll sumR=prefR[j]-prefR[i];\n int a=order[i-1], b=order[i], c=order[j], d=order[(j+1)%K];\n ll oldCost=(ll)distMat[a][b]+sumF+distMat[c][d];\n ll newCost=(ll)distMat[a][c]+sumR+distMat[b][d];\n ll delta=newCost-oldCost;\n if(delta<0){\n vector cand=order;\n reverse(cand.begin()+i, cand.begin()+j+1);\n if(coverage_ok(cand, pathRow, pathCol, Wrow, Wcol, Kall)){\n order.swap(cand);\n curCost += delta;\n improved=true;\n }\n }\n }\n }\n if(improved) continue;\n\n // relocate\n for(int i=1;i= endTime) return;\n int x=order[i], a=order[i-1], b=order[(i+1)%K];\n ll deltaRemove=(ll)distMat[a][b]-distMat[a][x]-distMat[x][b];\n vector seq;\n seq.reserve(K-1);\n for(int k=0;k cand;\n cand.reserve(K);\n for(int k=0;k<=pos;k++) cand.push_back(seq[k]);\n cand.push_back(x);\n for(int k=pos+1;k= endTime) return;\n ll delta;\n if(j==i+1){\n int a=order[i-1], b=order[i], c=order[j], d=order[(j+1)%K];\n ll oldCost=(ll)distMat[a][b]+distMat[b][c]+distMat[c][d];\n ll newCost=(ll)distMat[a][c]+distMat[c][b]+distMat[b][d];\n delta=newCost-oldCost;\n }else{\n int a=order[i-1], b=order[i], c=order[(i+1)%K];\n int d=order[j-1], e=order[j], f=order[(j+1)%K];\n ll oldCost=(ll)distMat[a][b]+distMat[b][c]+distMat[d][e]+distMat[e][f];\n ll newCost=(ll)distMat[a][e]+distMat[e][c]+distMat[d][b]+distMat[b][f];\n delta=newCost-oldCost;\n }\n if(delta<0){\n vector cand=order;\n swap(cand[i], cand[j]);\n if(coverage_ok(cand, pathRow, pathCol, Wrow, Wcol, Kall)){\n order.swap(cand);\n curCost += delta;\n improved=true;\n }\n }\n }\n }\n if(improved) continue;\n\n // perturbation (coverage-aware ILS)\n for(int trial=0; trial<2 && chrono::steady_clock::now() cand = (trial==0 ? doubleBridge(order, rng) : build_random((int)order.size(), rng));\n localSearch(cand, distMat);\n ll c = tourCost(cand, distMat);\n if(c < curCost && coverage_ok(cand, pathRow, pathCol, Wrow, Wcol, Kall)){\n order.swap(cand);\n curCost = c;\n improved = true;\n break;\n }\n }\n if(!improved) break;\n }\n}\n\n// ===== Candidate =====\nstruct Candidate{\n vector targets;\n vector order;\n ll cost;\n vector selectedRow, selectedCol;\n};\n\nCandidate solveWithParams(long long base, long long penalty,\n uint64_t seed, int ilsIter){\n Candidate cand; cand.cost=LLONG_MAX;\n\n vector selectedRow(Rseg,false), selectedCol(Cseg,false);\n int S=0, rowOff=1, colOff=1+Rseg, T=1+Rseg+Cseg;\n Dinic din(T+1);\n const ll INF_CAP=(1LL<<60);\n for(int r=0;r reach(T+1,false);\n queue q;\n reach[S]=true; q.push(S);\n while(!q.empty()){\n int v=q.front(); q.pop();\n for(auto &e: din.g[v]){\n if(e.cap>0 && !reach[e.to]){\n reach[e.to]=true;\n q.push(e.to);\n }\n }\n }\n for(int r=0;r selRows, selCols;\n vector rowIndex(Rseg,-1), colIndex(Cseg,-1);\n for(int r=0;r> edgeCell(nL, vector(nR, -1));\n for(int i=0;i matchL(Nsize, -1);\n for(int i=0;i=Roff && e.to targets;\n vector isTarget(R,false);\n auto addTarget=[&](int cid){\n if(cid<0) return;\n if(!isTarget[cid]){\n isTarget[cid]=true;\n targets.push_back(cid);\n }\n };\n\n for(int i=0;i=0 && j order;\n vector> distAll, distMat;\n\n int posIter=2;\n for(int it=0; it> N >> si >> sj;\n grid.resize(N);\n for(int i=0;i> grid[i];\n\n id.assign(N, vector(N,-1));\n for(int i=0;i=N||ny<0||ny>=N) continue;\n int v=id[nx][ny];\n if(v!=-1) neigh[u].push_back(v);\n }\n }\n\n startId = id[si][sj];\n distStart = dijkstra(startId);\n\n rowSegOf.assign(R,0);\n colSegOf.assign(R,0);\n for(int i=0;i(Wcol,0));\n for(int cid=0; cid(100000000LL, x);\n };\n vector bases = {\n 100000000LL,\n clampBase(maxDist*4),\n clampBase(maxDist*2),\n clampBase(maxDist),\n clampBase(maxDist/2),\n 0\n };\n sort(bases.begin(), bases.end());\n bases.erase(unique(bases.begin(), bases.end()), bases.end());\n\n vector pens = {0, avgDist/2, avgDist};\n sort(pens.begin(), pens.end());\n pens.erase(unique(pens.begin(), pens.end()), pens.end());\n\n uint64_t seed = 1234567u + N*100 + si*17 + sj;\n\n Candidate best;\n best.cost = LLONG_MAX;\n int ilsIterCandidate = 4;\n for(ll base: bases){\n for(ll pen: pens){\n Candidate cand = solveWithParams(base, pen, seed, ilsIterCandidate);\n if(cand.cost < best.cost){\n best = move(cand);\n }\n }\n }\n\n if(best.targets.size()==1){\n cout << \"\\n\";\n return 0;\n }\n\n // strong refinement\n vector> distAll, distMat;\n mt19937 rngFinal(seed ^ 0xdeadbeefULL);\n int ilsIterFinal = 20;\n\n for(int it=0; it<2; it++){\n computeDistAll(best.targets, distAll);\n computeDistMat(best.targets, distAll, distMat);\n best.order = find_best_order(distMat, rngFinal, &best.order, ilsIterFinal);\n optimize_positions(best.targets, best.order, distAll, best.selectedRow, best.selectedCol);\n }\n computeDistAll(best.targets, distAll);\n computeDistMat(best.targets, distAll, distMat);\n best.order = find_best_order(distMat, rngFinal, &best.order, ilsIterFinal);\n\n if(pruneTargets(best.targets, best.selectedRow, best.selectedCol, startId)){\n computeDistAll(best.targets, distAll);\n computeDistMat(best.targets, distAll, distMat);\n best.order = find_best_order(distMat, rngFinal, nullptr, ilsIterFinal);\n }\n\n // prevAll + path bits\n int Kall = best.targets.size();\n vector> prevAll(Kall);\n for(int i=0;i pathRow, pathCol;\n build_path_bits(best.targets, prevAll, pathRow, pathCol, Wrow, Wcol2);\n\n prune_order_by_path(best.order, distMat, pathRow, pathCol, Wrow, Wcol2, Kall);\n\n auto endTime = startTime + chrono::milliseconds(2900);\n coverage_local_search(best.order, distMat, pathRow, pathCol, Wrow, Wcol2, Kall, rngFinal, endTime);\n\n // output\n int Kord = best.order.size();\n if(Kord==1){\n cout << \"\\n\";\n return 0;\n }\n string ans;\n ans.reserve(200000);\n for(int idx=0; idx path;\n int cur = t;\n path.push_back(cur);\n while(cur != s){\n cur = prevAll[sIdx][cur];\n if(cur==-1) break;\n path.push_back(cur);\n }\n reverse(path.begin(), path.end());\n for(size_t k=0;k+1\nusing namespace std;\n\nstatic inline double expected_time(double w) {\n if (w <= 0.0) return 1.0;\n if (w < 1.0) return (10.0 + 3.0 * w) / 7.0;\n if (w < 2.0) return (9.0 + 4.0 * w) / 7.0;\n if (w < 3.0) return (7.0 + 5.0 * w) / 7.0;\n if (w < 4.0) return (4.0 + 6.0 * w) / 7.0;\n return w;\n}\n\nstatic inline double clampd(double x, double lo, double hi) {\n return max(lo, min(hi, x));\n}\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 vector difficulty(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n cin >> d[i][k];\n difficulty[i] += d[i][k];\n }\n }\n\n vector> out(N);\n vector indeg(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v; cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg[v]++;\n }\n\n // Static depth\n vector depth(N, 1);\n for (int i = N - 1; i >= 0; --i) {\n int mx = 0;\n for (int v : out[i]) mx = max(mx, depth[v]);\n depth[i] = mx + 1;\n }\n\n // Initial skill estimate\n vector avgK(K, 0.0);\n for (int i = 0; i < N; ++i)\n for (int k = 0; k < K; ++k)\n avgK[k] += d[i][k];\n for (int k = 0; k < K; ++k) avgK[k] /= N;\n\n double init_factor = 0.8;\n vector> skill(M, vector(K));\n for (int w = 0; w < M; ++w)\n for (int k = 0; k < K; ++k)\n skill[w][k] = avgK[k] * init_factor;\n\n vector state(N, -1); // -1 not started, 0 in progress, 1 done\n vector rem = indeg;\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector done_cnt(M, 0);\n vector avail_day(N, -1);\n int done_total = 0;\n\n auto predict_time = [&](int w, int task) {\n double wsum = 0.0;\n for (int k = 0; k < K; ++k) {\n double diff = d[task][k] - skill[w][k];\n if (diff > 0) wsum += diff;\n }\n return expected_time(wsum);\n };\n\n auto update_skill = [&](int w, int task, int actual_time) {\n auto &s = skill[w];\n vector diff(K);\n double w_hat = 0.0;\n for (int k = 0; k < K; ++k) {\n diff[k] = d[task][k] - s[k];\n if (diff[k] > 0) w_hat += diff[k];\n }\n\n double target = (actual_time == 1 ? 0.0 : (double)actual_time);\n double e = clampd(w_hat - target, -10.0, 10.0);\n\n // Damp update for low-information tasks\n double info = min(1.0, w_hat / 4.0);\n e *= info;\n\n int cnt = ++done_cnt[w];\n double lr = 1.0 / sqrt((double)cnt);\n if (actual_time == 1) lr *= 0.25;\n\n double tau = 2.0;\n double sumW = 0.0;\n vector weight(K);\n for (int k = 0; k < K; ++k) {\n weight[k] = 1.0 / (1.0 + exp(-diff[k] / tau));\n sumW += weight[k];\n }\n if (sumW < 1e-9) return;\n\n double coeff = lr * e / sumW;\n for (int k = 0; k < K; ++k) {\n s[k] = clampd(s[k] + coeff * weight[k], 0.0, 100.0);\n }\n };\n\n int day = 1;\n while (true) {\n for (int i = 0; i < N; ++i) {\n if (state[i] == -1 && rem[i] == 0 && avail_day[i] == -1)\n avail_day[i] = day;\n }\n\n vector free_workers;\n for (int w = 0; w < M; ++w)\n if (current_task[w] == -1) free_workers.push_back(w);\n\n vector available;\n for (int i = 0; i < N; ++i)\n if (state[i] == -1 && rem[i] == 0)\n available.push_back(i);\n\n vector> assign;\n\n if (!free_workers.empty() && !available.empty()) {\n // avgPred = average predicted time across workers\n vector avgPred(N, 0.0);\n double sumPred = 0.0;\n int cntPred = 0;\n for (int i = 0; i < N; ++i) {\n if (state[i] == 1) continue;\n double ssum = 0.0;\n for (int w = 0; w < M; ++w) ssum += predict_time(w, i);\n avgPred[i] = ssum / M;\n sumPred += avgPred[i];\n cntPred++;\n }\n double meanPred = (cntPred ? sumPred / cntPred : 1.0);\n\n // dynamic rank\n vector rank(N, 0.0);\n for (int i = N - 1; i >= 0; --i) {\n if (state[i] == 1) { rank[i] = 0.0; continue; }\n double mx = 0.0;\n for (int v : out[i]) mx = max(mx, rank[v]);\n rank[i] = avgPred[i] + mx;\n }\n\n double lambda = min(0.9, done_total / 300.0);\n double age_w = 0.01 * meanPred;\n\n vector prio(N, 0.0);\n for (int t : available) {\n double staticScore = depth[t] * meanPred + 0.05 * difficulty[t];\n double age = (avail_day[t] >= 0 ? day - avail_day[t] : 0);\n prio[t] = lambda * rank[t] + (1.0 - lambda) * staticScore + age_w * age;\n }\n\n sort(available.begin(), available.end(), [&](int a, int b) {\n if (fabs(prio[a] - prio[b]) > 1e-9) return prio[a] > prio[b];\n if (depth[a] != depth[b]) return depth[a] > depth[b];\n return a < b;\n });\n\n int F = free_workers.size();\n int L = min((int)available.size(), max(4 * F, 50));\n vector cand(available.begin(), available.begin() + L);\n\n vector> pred(L, vector(M));\n vector bestAll(L, 1e18);\n for (int i = 0; i < L; ++i) {\n int task = cand[i];\n for (int w = 0; w < M; ++w) {\n pred[i][w] = predict_time(w, task);\n bestAll[i] = min(bestAll[i], pred[i][w]);\n }\n }\n\n double maxPrio = 1.0;\n for (int t : cand) maxPrio = max(maxPrio, prio[t]);\n\n double gamma = 0.12 + 0.33 * min(1.0, done_total / 250.0);\n double delta = 0.10 + 0.25 * min(1.0, done_total / 250.0);\n double epsilon = 0.05;\n double denom = meanPred + 1e-6;\n\n vector free = free_workers;\n vector used(L, false);\n\n while (!free.empty()) {\n double bestScore = -1e18;\n int bestTi = -1, bestWi = -1, bestW = -1;\n\n for (int i = 0; i < L; ++i) {\n if (used[i]) continue;\n\n double bestT = 1e18, secondT = 1e18;\n int bw = -1, bwi = -1;\n for (int idx = 0; idx < (int)free.size(); ++idx) {\n int w = free[idx];\n double t = pred[i][w];\n if (t < bestT) {\n secondT = bestT;\n bestT = t;\n bw = w;\n bwi = idx;\n } else if (t < secondT) {\n secondT = t;\n }\n }\n if (bw < 0) continue;\n\n double regret = (secondT < 1e17 ? secondT - bestT : 0.0);\n double gap = max(0.0, bestT - bestAll[i]);\n\n double score = (prio[cand[i]] / maxPrio)\n + gamma * (regret / denom)\n - delta * (gap / denom)\n - epsilon * (bestT / denom);\n\n if (score > bestScore) {\n bestScore = score;\n bestTi = i;\n bestWi = bwi;\n bestW = bw;\n }\n }\n\n if (bestTi < 0) break;\n\n int task = cand[bestTi];\n assign.emplace_back(bestW, task);\n\n used[bestTi] = true;\n free[bestWi] = free.back();\n free.pop_back();\n\n current_task[bestW] = task;\n start_day[bestW] = day;\n state[task] = 0;\n }\n }\n\n cout << assign.size();\n for (auto &p : assign) cout << \" \" << p.first + 1 << \" \" << p.second + 1;\n cout << \"\\n\" << flush;\n\n int n;\n if (!(cin >> n)) return 0;\n if (n == -1) break;\n\n for (int i = 0; i < n; ++i) {\n int w; cin >> w; --w;\n int task = current_task[w];\n int duration = day - start_day[w] + 1;\n\n update_skill(w, task, duration);\n\n current_task[w] = -1;\n state[task] = 1;\n done_total++;\n for (int v : out[task]) rem[v]--;\n }\n\n day++;\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed = 88172645463325252ull) : x(seed) {}\n uint32_t next() { x ^= x << 7; x ^= x >> 9; return (uint32_t)x; }\n int randint(int l, int r) { return l + (next() % (r - l + 1)); }\n double randdouble() { return (double)next() / 4294967296.0; }\n};\n\nstruct Node {\n int idx;\n bool pickup;\n};\n\nstruct InsertInfo {\n long long delta;\n int pos_pick, pos_del;\n};\n\nstruct InsertInfo2 {\n long long best, second;\n int pos_pick, pos_del;\n};\n\nstruct Solution {\n vector seq;\n vector selected;\n long long cost;\n};\n\nconst int OFFICE_X = 400;\nconst int OFFICE_Y = 400;\nconst long long INF = (1LL << 60);\n\nvector ax, ay, cx, cy;\n\ninline int dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\ninline int getX(const Node &n) { return n.pickup ? ax[n.idx] : cx[n.idx]; }\ninline int getY(const Node &n) { return n.pickup ? ay[n.idx] : cy[n.idx]; }\n\nlong long calcCost(const vector& seq) {\n int x = OFFICE_X, y = OFFICE_Y;\n long long cost = 0;\n for (const auto &n : seq) {\n int nx = getX(n), ny = getY(n);\n cost += abs(x - nx) + abs(y - ny);\n x = nx; y = ny;\n }\n cost += abs(x - OFFICE_X) + abs(y - OFFICE_Y);\n return cost;\n}\n\nInsertInfo bestInsertion(const vector &seq, int oid) {\n int L = seq.size();\n int Px = ax[oid], Py = ay[oid];\n int Dx = cx[oid], Dy = cy[oid];\n\n long long best = INF;\n int bestI = 0, bestJ = 1;\n\n for (int i = 0; i <= L; ++i) {\n int Ax = (i == 0 ? OFFICE_X : getX(seq[i - 1]));\n int Ay = (i == 0 ? OFFICE_Y : getY(seq[i - 1]));\n int Bx = (i == L ? OFFICE_X : getX(seq[i]));\n int By = (i == L ? OFFICE_Y : getY(seq[i]));\n\n long long delta_pick = (long long)dist(Ax, Ay, Px, Py) + dist(Px, Py, Bx, By) - dist(Ax, Ay, Bx, By);\n\n for (int j = i + 1; j <= L + 1; ++j) {\n long long delta_del;\n if (j == i + 1) {\n delta_del = (long long)dist(Px, Py, Dx, Dy) + dist(Dx, Dy, Bx, By) - dist(Px, Py, Bx, By);\n } else {\n int prevx = getX(seq[j - 2]), prevy = getY(seq[j - 2]);\n int nextx, nexty;\n if (j - 1 == L) { nextx = OFFICE_X; nexty = OFFICE_Y; }\n else { nextx = getX(seq[j - 1]); nexty = getY(seq[j - 1]); }\n delta_del = (long long)dist(prevx, prevy, Dx, Dy) + dist(Dx, Dy, nextx, nexty) - dist(prevx, prevy, nextx, nexty);\n }\n long long delta = delta_pick + delta_del;\n if (delta < best) {\n best = delta;\n bestI = i;\n bestJ = j;\n }\n }\n }\n return {best, bestI, bestJ};\n}\n\nInsertInfo2 bestInsertion2(const vector &seq, int oid) {\n int L = seq.size();\n int Px = ax[oid], Py = ay[oid];\n int Dx = cx[oid], Dy = cy[oid];\n\n long long best = INF, second = INF;\n int bestI = 0, bestJ = 1;\n\n for (int i = 0; i <= L; ++i) {\n int Ax = (i == 0 ? OFFICE_X : getX(seq[i - 1]));\n int Ay = (i == 0 ? OFFICE_Y : getY(seq[i - 1]));\n int Bx = (i == L ? OFFICE_X : getX(seq[i]));\n int By = (i == L ? OFFICE_Y : getY(seq[i]));\n\n long long delta_pick = (long long)dist(Ax, Ay, Px, Py) + dist(Px, Py, Bx, By) - dist(Ax, Ay, Bx, By);\n\n for (int j = i + 1; j <= L + 1; ++j) {\n long long delta_del;\n if (j == i + 1) {\n delta_del = (long long)dist(Px, Py, Dx, Dy) + dist(Dx, Dy, Bx, By) - dist(Px, Py, Bx, By);\n } else {\n int prevx = getX(seq[j - 2]), prevy = getY(seq[j - 2]);\n int nextx, nexty;\n if (j - 1 == L) { nextx = OFFICE_X; nexty = OFFICE_Y; }\n else { nextx = getX(seq[j - 1]); nexty = getY(seq[j - 1]); }\n delta_del = (long long)dist(prevx, prevy, Dx, Dy) + dist(Dx, Dy, nextx, nexty) - dist(prevx, prevy, nextx, nexty);\n }\n long long delta = delta_pick + delta_del;\n if (delta < best) {\n second = best;\n best = delta;\n bestI = i; bestJ = j;\n } else if (delta < second) {\n second = delta;\n }\n }\n }\n return {best, second, bestI, bestJ};\n}\n\nstruct Option {\n long long delta;\n int id, pos_pick, pos_del, remIndex;\n};\n\nSolution buildSolution(const vector& candidates, int mode, RNG& rng) {\n vector seq;\n seq.reserve(100);\n vector rem = candidates;\n vector selected;\n selected.reserve(50);\n\n const int TOP = 3;\n\n for (int step = 0; step < 50; ++step) {\n if (mode == 2) { // regret\n long long bestReg = -1, bestCost = INF;\n int bestId = -1, bestPick = 0, bestDel = 1, bestRem = 0;\n for (int i = 0; i < (int)rem.size(); ++i) {\n int oid = rem[i];\n InsertInfo2 info = bestInsertion2(seq, oid);\n long long regret = (info.second >= INF / 2 ? 0 : info.second - info.best);\n if (regret > bestReg || (regret == bestReg && info.best < bestCost)) {\n bestReg = regret;\n bestCost = info.best;\n bestId = oid;\n bestPick = info.pos_pick;\n bestDel = info.pos_del;\n bestRem = i;\n }\n }\n seq.insert(seq.begin() + bestPick, Node{bestId, true});\n seq.insert(seq.begin() + bestDel, Node{bestId, false});\n selected.push_back(bestId);\n rem[bestRem] = rem.back();\n rem.pop_back();\n } else {\n vector