{"model_name":"mimo-v2.5","codes":{"1":{"ahc001":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Company {\n int x, y, r, idx;\n};\n\nint main() {\n int n;\n cin >> n;\n vector companies(n);\n for (int i = 0; i < n; ++i) {\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n companies[i].idx = i;\n }\n\n // sort by x coordinate\n sort(companies.begin(), companies.end(),\n [](const Company& a, const Company& b) { return a.x < b.x; });\n\n // extract sorted data\n vector xs(n), ys(n), rs(n);\n for (int i = 0; i < n; ++i) {\n xs[i] = companies[i].x;\n ys[i] = companies[i].y;\n rs[i] = companies[i].r;\n }\n\n // precompute satisfaction for each possible width (1..10000) for each company\n vector> sat(n, vector(10001, 0.0));\n for (int i = 0; i < n; ++i) {\n long long r = rs[i];\n for (int w = 1; w <= 10000; ++w) {\n // height = round(r / w) clamped to [1, 10000]\n long long h = (r + w / 2) / w; // integer rounding\n if (h > 10000) h = 10000;\n if (h < 1) h = 1;\n long long s = w * h;\n double ratio = min(r, s) / (double)max(r, s);\n sat[i][w] = 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n }\n\n // initial widths: must cover xi and be at least ceil(r/10000)\n vector w(n);\n long long cur_start = 0;\n for (int i = 0; i < n; ++i) {\n long long w_min_cov = max(1LL, (long long)xs[i] - cur_start + 1);\n long long w_min_area = (rs[i] + 9999) / 10000; // ceil(r/10000)\n w[i] = max(w_min_cov, w_min_area);\n cur_start += w[i];\n }\n\n long long total_width = cur_start;\n long long excess = total_width - 10000;\n\n // reduce widths if total exceeds 10000\n while (excess > 0) {\n // recompute current starts\n vector start_pos(n);\n cur_start = 0;\n for (int i = 0; i < n; ++i) {\n start_pos[i] = cur_start;\n cur_start += w[i];\n }\n\n int best_i = -1;\n double best_loss = 1e18;\n for (int i = 0; i < n; ++i) {\n long long w_min_cov = max(1LL, (long long)xs[i] - start_pos[i] + 1);\n if (w[i] <= w_min_cov) continue; // cannot reduce without losing point\n double p_curr = sat[i][w[i]];\n double p_red = sat[i][w[i] - 1];\n double loss = p_curr - p_red;\n if (loss < best_loss) {\n best_loss = loss;\n best_i = i;\n }\n }\n if (best_i == -1) break; // no reduction possible\n w[best_i]--;\n excess--;\n }\n\n // compute final heights and output rectangles\n vector a(n), b(n), c(n), d(n);\n cur_start = 0;\n for (int i = 0; i < n; ++i) {\n int wi = w[i];\n long long h = (rs[i] + wi / 2) / wi;\n if (h > 10000) h = 10000;\n if (h < 1) h = 1;\n int ai = cur_start;\n int ci = ai + wi;\n int bi = max(0, ys[i] - (int)h + 1);\n int di = bi + (int)h;\n\n // store in original order\n int idx = companies[i].idx;\n a[idx] = ai;\n b[idx] = bi;\n c[idx] = ci;\n d[idx] = di;\n\n cur_start += wi;\n }\n\n // output\n for (int i = 0; i < n; ++i) {\n cout << a[i] << \" \" << b[i] << \" \" << c[i] << \" \" << d[i] << \"\\n\";\n }\n\n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int si, sj;\n cin >> si >> sj;\n\n vector> tile(50, vector(50));\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> tile[i][j];\n }\n }\n\n vector> value(50, vector(50));\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> value[i][j];\n }\n }\n\n // Find total number of tiles (M)\n int M = 0;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n M = max(M, tile[i][j] + 1);\n }\n }\n\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char dir_char[4] = {'U', 'D', 'L', 'R'};\n\n // Timestamp technique to avoid resetting visited array each trial\n vector visited_tiles(M, 0);\n int cur_timestamp = 0;\n\n random_device rd;\n mt19937 gen(rd());\n\n string best_path = \"\";\n int best_score = -1;\n\n const int num_trials = 20000; // will be plus one greedy trial\n for (int trial = 0; trial <= num_trials; ++trial) {\n ++cur_timestamp;\n int policy; // 0: uniform random, 1: weighted random, 2: greedy\n if (trial == num_trials) {\n policy = 2; // greedy at the end\n } else {\n policy = (gen() % 2); // 50% uniform, 50% weighted\n }\n\n int cur_r = si, cur_c = sj;\n visited_tiles[tile[cur_r][cur_c]] = cur_timestamp;\n int score = value[cur_r][cur_c];\n string path = \"\";\n\n while (true) {\n // Collect unvisited neighbors\n vector> candidates; // value, nr, nc, tid, dir\n for (int d = 0; d < 4; ++d) {\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr < 0 || nr >= 50 || nc < 0 || nc >= 50) continue;\n int tid = tile[nr][nc];\n if (visited_tiles[tid] == cur_timestamp) continue;\n candidates.emplace_back(value[nr][nc], nr, nc, tid, dir_char[d]);\n }\n if (candidates.empty()) break;\n\n int chosen_idx = 0;\n if (policy == 2) {\n // Greedy: choose the candidate with maximum value\n for (int i = 1; i < (int)candidates.size(); ++i) {\n if (get<0>(candidates[i]) > get<0>(candidates[chosen_idx])) {\n chosen_idx = i;\n }\n }\n } else {\n if (policy == 0) {\n // Uniform random\n chosen_idx = gen() % candidates.size();\n } else {\n // Weighted random (weights = value)\n int total = 0;\n for (const auto& cand : candidates) {\n total += get<0>(cand);\n }\n if (total == 0) {\n chosen_idx = gen() % candidates.size();\n } else {\n int r = gen() % total;\n int cum = 0;\n for (int i = 0; i < (int)candidates.size(); ++i) {\n cum += get<0>(candidates[i]);\n if (cum > r) {\n chosen_idx = i;\n break;\n }\n }\n }\n }\n }\n\n // Execute the chosen move\n auto [val, nr, nc, tid, dir] = candidates[chosen_idx];\n path += dir;\n cur_r = nr;\n cur_c = nc;\n visited_tiles[tid] = cur_timestamp;\n score += val;\n }\n\n if (score > best_score) {\n best_score = score;\n best_path = path;\n }\n }\n\n cout << best_path << endl;\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nint main() {\n const int N = 30;\n vector> est_h(N, vector(N-1, 5000.0)); // horizontal edges\n vector> est_v(N-1, vector(N, 5000.0)); // vertical edges\n\n double lr = 0.1; // learning rate\n int total_updates = 0;\n\n for (int query = 0; query < 1000; ++query) {\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n int start = si * N + sj;\n int target = ti * N + tj;\n\n // ---------- Dijkstra ----------\n const double INF = 1e18;\n vector dist(N * N, INF);\n vector prev(N * N, -1);\n vector prev_move(N * N); // direction that led to this node\n\n dist[start] = 0.0;\n priority_queue,\n vector>,\n greater>> pq;\n pq.emplace(0.0, start);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d > dist[u]) continue;\n int ui = u / N, uj = u % N;\n\n // up\n if (ui > 0) {\n int v = (ui - 1) * N + uj;\n double w = est_v[ui - 1][uj];\n if (dist[v] > d + w) {\n dist[v] = d + w;\n prev[v] = u;\n prev_move[v] = 'U';\n pq.emplace(dist[v], v);\n }\n }\n // down\n if (ui < N - 1) {\n int v = (ui + 1) * N + uj;\n double w = est_v[ui][uj];\n if (dist[v] > d + w) {\n dist[v] = d + w;\n prev[v] = u;\n prev_move[v] = 'D';\n pq.emplace(dist[v], v);\n }\n }\n // left\n if (uj > 0) {\n int v = ui * N + (uj - 1);\n double w = est_h[ui][uj - 1];\n if (dist[v] > d + w) {\n dist[v] = d + w;\n prev[v] = u;\n prev_move[v] = 'L';\n pq.emplace(dist[v], v);\n }\n }\n // right\n if (uj < N - 1) {\n int v = ui * N + (uj + 1);\n double w = est_h[ui][uj];\n if (dist[v] > d + w) {\n dist[v] = d + w;\n prev[v] = u;\n prev_move[v] = 'R';\n pq.emplace(dist[v], v);\n }\n }\n }\n\n // ---------- Reconstruct path ----------\n vector moves;\n struct Edge { bool hor; int i; int j; };\n vector path_edges;\n\n int cur = target;\n while (cur != start) {\n int p = prev[cur];\n char dir = prev_move[cur];\n moves.push_back(dir);\n\n int pi = p / N, pj = p % N;\n int ci = cur / N, cj = cur % N;\n\n if (pi == ci) { // horizontal move\n int j = min(pj, cj);\n path_edges.push_back({true, pi, j});\n } else { // vertical move\n int i = min(pi, ci);\n path_edges.push_back({false, i, pj});\n }\n cur = p;\n }\n reverse(moves.begin(), moves.end());\n reverse(path_edges.begin(), path_edges.end());\n\n // ---------- Output ----------\n for (char c : moves) cout << c;\n cout << endl;\n\n // ---------- Read feedback ----------\n int res;\n cin >> res;\n\n // ---------- Compute predicted length ----------\n double L_est = 0.0;\n for (auto& e : path_edges) {\n if (e.hor) L_est += est_h[e.i][e.j];\n else L_est += est_v[e.i][e.j];\n }\n int len = path_edges.size();\n double delta = lr * (res - L_est) / len;\n\n // ---------- Update estimates ----------\n for (auto& e : path_edges) {\n if (e.hor) {\n est_h[e.i][e.j] += delta;\n est_h[e.i][e.j] = max(1000.0, min(9000.0, est_h[e.i][e.j]));\n } else {\n est_v[e.i][e.j] += delta;\n est_v[e.i][e.j] = max(1000.0, min(9000.0, est_v[e.i][e.j]));\n }\n }\n\n total_updates += len;\n lr *= 0.999; // decay learning rate\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nconst int BASE = 131;\n\nstruct SubInfo {\n int start;\n int k;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n \n int N, M;\n cin >> N >> M;\n vector strs(M);\n for (int i = 0; i < M; ++i) {\n cin >> strs[i];\n }\n \n // Hash each string\n auto compute_hash_string = [](const string &s) -> uint64_t {\n uint64_t h = 0;\n for (char ch : s) {\n h = h * BASE + (ch - 'A' + 1);\n }\n return h;\n };\n vector str_hash(M);\n unordered_map hash_to_str;\n for (int i = 0; i < M; ++i) {\n str_hash[i] = compute_hash_string(strs[i]);\n hash_to_str[str_hash[i]] = i;\n }\n \n // Precompute for each cell the list of row/column substrings that contain it\n vector> cell_row_info(N * N);\n vector> cell_col_info(N * N);\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int cell = r * N + c;\n for (int k = 2; k <= 12; ++k) {\n // row substrings\n for (int s = 0; s < N; ++s) {\n bool in = false;\n if (s + k <= N) {\n if (c >= s && c < s + k) in = true;\n } else {\n if (c >= s || c < (s + k) % N) in = true;\n }\n if (in) cell_row_info[cell].push_back({s, k});\n }\n // column substrings\n for (int s = 0; s < N; ++s) {\n bool in = false;\n if (s + k <= N) {\n if (r >= s && r < s + k) in = true;\n } else {\n if (r >= s || r < (s + k) % N) in = true;\n }\n if (in) cell_col_info[cell].push_back({s, k});\n }\n }\n }\n }\n \n // Initialize random grid\n vector> grid(N, vector(N));\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist_letter(0, 7);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n grid[i][j] = 'A' + dist_letter(rng);\n }\n }\n \n // Helper functions for row/column hash using the current grid\n auto compute_hash_row = [&](int r, int start, int k) -> uint64_t {\n uint64_t h = 0;\n for (int i = 0; i < k; ++i) {\n int col = (start + i) % N;\n h = h * BASE + (grid[r][col] - 'A' + 1);\n }\n return h;\n };\n auto compute_hash_col = [&](int c, int start, int k) -> uint64_t {\n uint64_t h = 0;\n for (int i = 0; i < k; ++i) {\n int row = (start + i) % N;\n h = h * BASE + (grid[row][c] - 'A' + 1);\n }\n return h;\n };\n \n // Initialize count map for all substring hashes\n unordered_map cnt;\n for (int r = 0; r < N; ++r) {\n for (int s = 0; s < N; ++s) {\n for (int k = 2; k <= 12; ++k) {\n cnt[compute_hash_row(r, s, k)]++;\n }\n }\n }\n for (int c = 0; c < N; ++c) {\n for (int s = 0; s < N; ++s) {\n for (int k = 2; k <= 12; ++k) {\n cnt[compute_hash_col(c, s, k)]++;\n }\n }\n }\n \n // Initial satisfaction\n vector satisfied(M, false);\n int c_sat = 0;\n for (int i = 0; i < M; ++i) {\n if (cnt[str_hash[i]] > 0) {\n satisfied[i] = true;\n ++c_sat;\n }\n }\n \n // Simulated annealing parameters\n const int iterations = 200000;\n double temp = 10.0;\n const double cooling = 0.99995;\n uniform_real_distribution dist_real(0.0, 1.0);\n uniform_int_distribution dist_cell(0, N - 1);\n uniform_int_distribution dist_newchar(0, 7);\n \n for (int iter = 0; iter < iterations; ++iter) {\n int r = dist_cell(rng);\n int col = dist_cell(rng);\n int cell = r * N + col;\n char old_char = grid[r][col];\n char new_char = 'A' + dist_newchar(rng);\n if (new_char == old_char) continue;\n \n // Collect old hashes for row and column substrings through this cell\n vector old_hashes;\n for (auto &info : cell_row_info[cell]) {\n old_hashes.push_back(compute_hash_row(r, info.start, info.k));\n }\n for (auto &info : cell_col_info[cell]) {\n old_hashes.push_back(compute_hash_col(col, info.start, info.k));\n }\n \n // Temporarily change the cell to compute new hashes\n grid[r][col] = new_char;\n vector new_hashes;\n for (auto &info : cell_row_info[cell]) {\n new_hashes.push_back(compute_hash_row(r, info.start, info.k));\n }\n for (auto &info : cell_col_info[cell]) {\n new_hashes.push_back(compute_hash_col(col, info.start, info.k));\n }\n grid[r][col] = old_char; // revert\n \n // Compute net changes in hash counts\n unordered_map delta_count;\n for (size_t i = 0; i < old_hashes.size(); ++i) {\n if (old_hashes[i] != new_hashes[i]) {\n delta_count[old_hashes[i]]--;\n delta_count[new_hashes[i]]++;\n }\n }\n \n // Estimate change in number of satisfied strings\n int delta_c = 0;\n for (auto &[hash, d] : delta_count) {\n int old_cnt = cnt[hash];\n int new_cnt = old_cnt + d;\n if (old_cnt == 0 && new_cnt > 0) delta_c++;\n if (old_cnt > 0 && new_cnt == 0) delta_c--;\n }\n \n // Acceptance probability\n bool accept = false;\n if (delta_c > 0) {\n accept = true;\n } else if (temp > 1e-6) {\n double prob = exp(delta_c / temp);\n if (prob > dist_real(rng)) accept = true;\n }\n \n if (accept) {\n grid[r][col] = new_char;\n for (auto &[hash, d] : delta_count) {\n int old_cnt = cnt[hash];\n cnt[hash] = old_cnt + d;\n if (old_cnt == 0 && cnt[hash] > 0) {\n auto it = hash_to_str.find(hash);\n if (it != hash_to_str.end()) {\n satisfied[it->second] = true;\n ++c_sat;\n }\n }\n if (old_cnt > 0 && cnt[hash] == 0) {\n auto it = hash_to_str.find(hash);\n if (it != hash_to_str.end()) {\n satisfied[it->second] = false;\n --c_sat;\n }\n }\n }\n }\n \n temp *= cooling;\n if (c_sat == M) break; // early exit if all satisfied\n }\n \n // Output the matrix\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cout << grid[i][j];\n }\n cout << '\\n';\n }\n \n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct Point {\n int i, j;\n};\n\n// Hopcroft\u2013Karp for bipartite matching\nint hopcroft_karp(const vector>& adj, int L, int R,\n vector& matchL, vector& matchR) {\n vector dist(L, -1);\n queue q;\n for (int u = 0; u < L; ++u) {\n if (matchL[u] == -1) {\n dist[u] = 0;\n q.push(u);\n }\n }\n while (!q.empty()) {\n int u = q.front(); q.pop();\n for (int v : adj[u]) {\n if (matchR[v] != -1 && dist[matchR[v]] == -1) {\n dist[matchR[v]] = dist[u] + 1;\n q.push(matchR[v]);\n }\n }\n }\n function dfs = [&](int u) {\n for (int v : adj[u]) {\n if (matchR[v] == -1 ||\n (dist[matchR[v]] == dist[u] + 1 && dfs(matchR[v]))) {\n matchL[u] = v;\n matchR[v] = u;\n return true;\n }\n }\n dist[u] = -1;\n return false;\n };\n int matching = 0;\n for (int u = 0; u < L; ++u) {\n if (matchL[u] == -1 && dfs(u)) ++matching;\n }\n return matching;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid_str(N);\n for (int i = 0; i < N; ++i) cin >> grid_str[i];\n\n // Convert grid: -1 for obstacle, otherwise cost (5-9)\n vector> grid(N, vector(N, -1));\n vector roads;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c = grid_str[i][j];\n if (c != '#') {\n grid[i][j] = c - '0';\n roads.push_back({i, j});\n }\n }\n }\n\n // ---------- row segments ----------\n vector> row_seg(N, vector(N, -1));\n int L = 0;\n for (int i = 0; i < N; ++i) {\n int j = 0;\n while (j < N) {\n if (grid[i][j] != -1) {\n int start = j;\n while (j < N && grid[i][j] != -1) ++j;\n int end = j - 1;\n for (int k = start; k <= end; ++k) row_seg[i][k] = L;\n ++L;\n } else {\n ++j;\n }\n }\n }\n\n // ---------- column segments ----------\n vector> col_seg(N, vector(N, -1));\n int R = 0;\n for (int j = 0; j < N; ++j) {\n int i = 0;\n while (i < N) {\n if (grid[i][j] != -1) {\n int start = i;\n while (i < N && grid[i][j] != -1) ++i;\n int end = i - 1;\n for (int k = start; k <= end; ++k) col_seg[k][j] = R;\n ++R;\n } else {\n ++i;\n }\n }\n }\n\n // ---------- bipartite graph (row segments vs column segments) ----------\n vector> adj(L);\n vector>> edge_coord(L); // for each row segment: (col_segment, (i,j))\n for (auto& p : roads) {\n int u = row_seg[p.i][p.j];\n int v = col_seg[p.i][p.j];\n adj[u].push_back(v);\n edge_coord[u].push_back({v, {p.i, p.j}});\n }\n\n // ---------- minimum vertex cover (via maximum matching) ----------\n vector matchL(L, -1), matchR(R, -1);\n hopcroft_karp(adj, L, R, matchL, matchR);\n\n vector visL(L, false), visR(R, false);\n queue q;\n for (int u = 0; u < L; ++u) {\n if (matchL[u] == -1) {\n visL[u] = true;\n q.push(u);\n }\n }\n while (!q.empty()) {\n int u = q.front(); q.pop();\n for (int v : adj[u]) {\n if (!visR[v]) {\n visR[v] = true;\n if (matchR[v] != -1 && !visL[matchR[v]]) {\n visL[matchR[v]] = true;\n q.push(matchR[v]);\n }\n }\n }\n }\n vector selected_row(L, false), selected_col(R, false);\n for (int u = 0; u < L; ++u) selected_row[u] = !visL[u];\n for (int v = 0; v < R; ++v) selected_col[v] = visR[v];\n\n // ---------- selected segments ----------\n vector sel_row_list, sel_col_list;\n for (int u = 0; u < L; ++u) if (selected_row[u]) sel_row_list.push_back(u);\n for (int v = 0; v < R; ++v) if (selected_col[v]) sel_col_list.push_back(v);\n int L2 = sel_row_list.size(), R2 = sel_col_list.size();\n map row_idx, col_idx;\n for (int i = 0; i < L2; ++i) row_idx[sel_row_list[i]] = i;\n for (int i = 0; i < R2; ++i) col_idx[sel_col_list[i]] = i;\n\n // ---------- induced graph on selected segments ----------\n vector> adj2(L2);\n vector> radj2(R2);\n vector>> edge_coord2(L2); // (col_idx, (i,j))\n for (auto& p : roads) {\n int u = row_seg[p.i][p.j];\n int v = col_seg[p.i][p.j];\n if (selected_row[u] && selected_col[v]) {\n int u2 = row_idx[u];\n int v2 = col_idx[v];\n adj2[u2].push_back(v2);\n radj2[v2].push_back(u2);\n edge_coord2[u2].push_back({v2, {p.i, p.j}});\n }\n }\n\n // ---------- minimum edge cover on induced graph ----------\n vector matchL2(L2, -1), matchR2(R2, -1);\n hopcroft_karp(adj2, L2, R2, matchL2, matchR2);\n\n vector S; // squares to visit\n vector row_covered(L2, false), col_covered(R2, false);\n\n // 1. take all matching edges\n for (int u2 = 0; u2 < L2; ++u2) {\n if (matchL2[u2] != -1) {\n int v2 = matchL2[u2];\n for (auto& e : edge_coord2[u2]) {\n if (e.first == v2) {\n S.push_back({e.second.first, e.second.second});\n break;\n }\n }\n row_covered[u2] = true;\n col_covered[v2] = true;\n }\n }\n\n // 2. cover unmatched rows\n for (int u2 = 0; u2 < L2; ++u2) {\n if (!row_covered[u2]) {\n if (!adj2[u2].empty()) {\n int v2 = adj2[u2][0];\n for (auto& e : edge_coord2[u2]) {\n if (e.first == v2) {\n S.push_back({e.second.first, e.second.second});\n break;\n }\n }\n row_covered[u2] = true;\n col_covered[v2] = true;\n } else { // isolated row segment\n int u_orig = sel_row_list[u2];\n for (auto& p : roads) {\n if (row_seg[p.i][p.j] == u_orig) {\n S.push_back({p.i, p.j});\n break;\n }\n }\n row_covered[u2] = true;\n }\n }\n }\n\n // 3. cover unmatched columns\n for (int v2 = 0; v2 < R2; ++v2) {\n if (!col_covered[v2]) {\n if (!radj2[v2].empty()) {\n int u2 = radj2[v2][0];\n for (auto& e : edge_coord2[u2]) {\n if (e.first == v2) {\n S.push_back({e.second.first, e.second.second});\n break;\n }\n }\n col_covered[v2] = true;\n } else { // isolated column segment\n int v_orig = sel_col_list[v2];\n for (auto& p : roads) {\n if (col_seg[p.i][p.j] == v_orig) {\n S.push_back({p.i, p.j});\n break;\n }\n }\n col_covered[v2] = true;\n }\n }\n }\n\n // ---------- nodes for TSP (start + S without duplicates) ----------\n vector nodes;\n nodes.push_back({si, sj});\n set> visited_set;\n for (auto& p : S) {\n if (p.i == si && p.j == sj) continue;\n if (visited_set.insert({p.i, p.j}).second) {\n nodes.push_back(p);\n }\n }\n int n = nodes.size();\n\n // ---------- Dijkstra from each node, build distance matrix and predecessors ----------\n const int INF = 1e9;\n vector> dist_mat(n, vector(n, INF));\n vector>> pred(n, vector>(N, vector(N, 0)));\n\n auto dijkstra = [&](int src_idx) {\n int si = nodes[src_idx].i, sj = nodes[src_idx].j;\n vector> dist(N, vector(N, INF));\n dist[si][sj] = 0;\n pred[src_idx][si][sj] = 0; // 0 marks the source\n priority_queue>,\n vector>>,\n greater<>> pq;\n pq.push({0, {si, sj}});\n const int di[4] = {-1, 1, 0, 0};\n const int dj[4] = {0, 0, -1, 1};\n const char dir[4] = {'U', 'D', 'L', 'R'};\n while (!pq.empty()) {\n auto [d, pos] = pq.top(); pq.pop();\n int i = pos.first, j = pos.second;\n if (d != dist[i][j]) continue;\n for (int k = 0; k < 4; ++k) {\n int ni = i + di[k], nj = j + dj[k];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (grid[ni][nj] == -1) continue;\n int nd = d + grid[ni][nj];\n if (nd < dist[ni][nj]) {\n dist[ni][nj] = nd;\n pred[src_idx][ni][nj] = dir[k];\n pq.push({nd, {ni, nj}});\n }\n }\n }\n for (int t = 0; t < n; ++t) {\n int ti = nodes[t].i, tj = nodes[t].j;\n dist_mat[src_idx][t] = dist[ti][tj];\n }\n };\n for (int s = 0; s < n; ++s) dijkstra(s);\n\n // ---------- TSP heuristic (nearest neighbour + 2\u2011opt) ----------\n vector tour;\n vector vis(n, false);\n tour.push_back(0); // start at index 0\n vis[0] = true;\n int cur = 0;\n for (int iter = 0; iter < n - 1; ++iter) {\n int nxt = -1, best = INF;\n for (int v = 0; v < n; ++v) {\n if (!vis[v] && dist_mat[cur][v] < best) {\n best = dist_mat[cur][v];\n nxt = v;\n }\n }\n tour.push_back(nxt);\n vis[nxt] = true;\n cur = nxt;\n }\n tour.push_back(0); // return to start\n\n // 2\u2011opt\n bool improved = true;\n while (improved) {\n improved = false;\n int sz = tour.size();\n for (int i = 0; i < sz - 2; ++i) {\n for (int j = i + 2; j < sz - 1; ++j) {\n int a = tour[i], b = tour[i+1], c = tour[j], d = tour[j+1];\n int cur_cost = dist_mat[a][b] + dist_mat[c][d];\n // cost of original segment b->...->c\n int seg_orig = 0;\n for (int k = i+1; k < j; ++k) seg_orig += dist_mat[tour[k]][tour[k+1]];\n // new cost if we reverse segment i+1..j\n int new_cost = dist_mat[a][c] + dist_mat[b][d];\n int seg_rev = 0;\n for (int k = j; k > i+1; --k) seg_rev += dist_mat[tour[k]][tour[k-1]];\n if (cur_cost + seg_orig > new_cost + seg_rev) {\n reverse(tour.begin() + i + 1, tour.begin() + j + 1);\n improved = true;\n }\n }\n }\n }\n\n // ---------- build move string ----------\n string moves;\n for (int idx = 0; idx < (int)tour.size() - 1; ++idx) {\n int src_idx = tour[idx];\n int tgt_idx = tour[idx+1];\n int ci = nodes[tgt_idx].i, cj = nodes[tgt_idx].j;\n vector path;\n while (!(ci == nodes[src_idx].i && cj == nodes[src_idx].j)) {\n char d = pred[src_idx][ci][cj];\n path.push_back(d);\n // move to parent\n if (d == 'U') ci++;\n else if (d == 'D') ci--;\n else if (d == 'L') cj++;\n else if (d == 'R') cj--;\n }\n reverse(path.begin(), path.end());\n for (char c : path) moves.push_back(c);\n }\n\n cout << moves << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector> d(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n cin >> d[i][k];\n }\n }\n\n vector> children(N);\n vector prereq_count(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n children[u].push_back(v);\n prereq_count[v]++;\n }\n\n // Critical path length L[i]\n vector L(N, 1);\n for (int i = N - 1; i >= 0; --i) {\n for (int v : children[i]) {\n L[i] = max(L[i], 1 + L[v]);\n }\n }\n\n // Available tasks (prerequisites satisfied)\n vector avail;\n for (int i = 0; i < N; ++i) {\n if (prereq_count[i] == 0) {\n avail.push_back(i);\n }\n }\n\n // Task status: 0=not started, 1=started, 2=completed\n vector task_status(N, 0);\n\n // Team member state\n vector current_task(M, -1); // -1 if idle\n vector start_day(M, -1);\n vector> s_est(M, vector(K, 0.0)); // estimated skill levels\n\n const double learning_rate = 0.01;\n\n int cur_day = 1;\n\n while (true) {\n // Collect idle members\n vector idle_members;\n for (int j = 0; j < M; ++j) {\n if (current_task[j] == -1) {\n idle_members.push_back(j);\n }\n }\n\n // Collect currently available tasks (status 0)\n vector today_avail;\n for (int i : avail) {\n if (task_status[i] == 0) {\n today_avail.push_back(i);\n }\n }\n\n // Sort by critical path length descending\n sort(today_avail.begin(), today_avail.end(),\n [&](int a, int b) { return L[a] > L[b]; });\n\n vector> assignments; // (member, task)\n vector member_used(M, false);\n\n for (int i : today_avail) {\n if (idle_members.empty()) break;\n\n int best_j = -1;\n double best_w = 1e9;\n for (int j : idle_members) {\n if (member_used[j]) continue;\n double w = 0.0;\n for (int k = 0; k < K; ++k) {\n if (d[i][k] > s_est[j][k]) {\n w += d[i][k] - s_est[j][k];\n }\n }\n if (w < best_w) {\n best_w = w;\n best_j = j;\n }\n }\n if (best_j != -1) {\n assignments.emplace_back(best_j, i);\n member_used[best_j] = true;\n task_status[i] = 1; // mark as started\n }\n }\n\n // Output assignments\n cout << assignments.size();\n for (auto& p : assignments) {\n cout << \" \" << p.first + 1 << \" \" << p.second + 1;\n }\n cout << endl;\n cout.flush();\n\n // Read response line\n string line;\n getline(cin, line);\n if (line == \"-1\") {\n break;\n }\n\n istringstream iss(line);\n int n;\n iss >> n;\n vector completing;\n for (int i = 0; i < n; ++i) {\n int f;\n iss >> f;\n completing.push_back(f - 1); // to 0-index\n }\n\n // Process completions\n for (int j : completing) {\n int i = current_task[j];\n if (i == -1) continue; // should not happen\n\n int t = cur_day - start_day[j] + 1; // actual duration\n\n // Update skill estimates for member j\n double w_est = 0.0;\n for (int k = 0; k < K; ++k) {\n if (d[i][k] > s_est[j][k]) {\n w_est += d[i][k] - s_est[j][k];\n }\n }\n double error = t - w_est;\n for (int k = 0; k < K; ++k) {\n if (d[i][k] > s_est[j][k]) {\n s_est[j][k] -= learning_rate * error;\n if (s_est[j][k] < 0.0) s_est[j][k] = 0.0;\n }\n }\n\n // Mark task as completed\n task_status[i] = 2;\n current_task[j] = -1;\n\n // Update dependent tasks\n for (int v : children[i]) {\n prereq_count[v]--;\n if (prereq_count[v] == 0) {\n avail.push_back(v);\n }\n }\n }\n\n ++cur_day;\n }\n\n return 0;\n}","ahc006":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Order {\n int id; // 0-based index\n int a, b, c, d;\n};\n\nvector orders;\n\n// Manhattan distance\nint dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Compute total travel time for a given sequence of order indices\nint total_distance(const vector& seq) {\n int cur_x = 400, cur_y = 400;\n int total = 0;\n for (int idx : seq) {\n total += dist(cur_x, cur_y, orders[idx].a, orders[idx].b);\n total += dist(orders[idx].a, orders[idx].b, orders[idx].c, orders[idx].d);\n cur_x = orders[idx].c;\n cur_y = orders[idx].d;\n }\n total += dist(cur_x, cur_y, 400, 400);\n return total;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n orders.resize(1000);\n for (int i = 0; i < 1000; ++i) {\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i;\n }\n\n // Greedy construction of an initial sequence\n vector used(1000, false);\n vector seq; // sequence of order indices (0-based)\n int cur_x = 400, cur_y = 400;\n for (int step = 0; step < 50; ++step) {\n int best_idx = -1;\n int best_cost = 1e9;\n for (int i = 0; i < 1000; ++i) {\n if (used[i]) continue;\n int cost = dist(cur_x, cur_y, orders[i].a, orders[i].b) +\n dist(orders[i].a, orders[i].b, orders[i].c, orders[i].d);\n if (cost < best_cost) {\n best_cost = cost;\n best_idx = i;\n }\n }\n assert(best_idx != -1);\n seq.push_back(best_idx);\n used[best_idx] = true;\n cur_x = orders[best_idx].c;\n cur_y = orders[best_idx].d;\n }\n\n int total = total_distance(seq);\n\n // Local search: 2-opt on the order of orders\n auto start_time = clock();\n const double time_limit = 1.9 * CLOCKS_PER_SEC; // slightly less than 2 seconds\n\n while (true) {\n // Check time\n if (clock() - start_time > time_limit) break;\n\n // 2-opt phase\n bool improved = true;\n while (improved) {\n if (clock() - start_time > time_limit) break;\n improved = false;\n for (int i = 0; i < seq.size(); ++i) {\n for (int j = i + 1; j < seq.size(); ++j) {\n vector new_seq = seq;\n reverse(new_seq.begin() + i, new_seq.begin() + j + 1);\n int new_total = total_distance(new_seq);\n if (new_total < total) {\n seq = new_seq;\n total = new_total;\n improved = true;\n }\n }\n }\n }\n\n // Order replacement phase\n improved = true;\n while (improved) {\n if (clock() - start_time > time_limit) break;\n improved = false;\n for (int pos = 0; pos < seq.size(); ++pos) {\n for (int i = 0; i < 1000; ++i) {\n if (used[i]) continue;\n vector new_seq = seq;\n new_seq[pos] = i;\n int new_total = total_distance(new_seq);\n if (new_total < total) {\n used[seq[pos]] = false;\n used[i] = true;\n seq = new_seq;\n total = new_total;\n improved = true;\n }\n }\n }\n }\n\n // If no improvement in either phase, break\n // (We could also add a counter to limit iterations)\n // For simplicity, we break after one full cycle if time remains.\n break; // optional: remove to allow more cycles\n }\n\n // Output the selected orders (1-based indices)\n cout << 50;\n for (int idx : seq) {\n cout << ' ' << idx + 1;\n }\n cout << '\\n';\n\n // Output the route: office, then for each order: restaurant, destination, then office\n cout << 102; // 1 (start) + 50*2 + 1 (end) = 102\n cout << \" 400 400\"; // starting office\n for (int idx : seq) {\n cout << ' ' << orders[idx].a << ' ' << orders[idx].b;\n cout << ' ' << orders[idx].c << ' ' << orders[idx].d;\n }\n cout << \" 400 400\"; // return to office\n cout << '\\n';\n\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct DSU {\n vector parent, rank;\n int components;\n DSU(int n) : parent(n), rank(n, 0), components(n) {\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int x) {\n if (parent[x] != x) parent[x] = find(parent[x]);\n return parent[x];\n }\n bool unite(int x, int y) {\n x = find(x), y = find(y);\n if (x == y) return false;\n if (rank[x] < rank[y]) swap(x, y);\n parent[y] = x;\n if (rank[x] == rank[y]) rank[x]++;\n components--;\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n vector x(N), y(N);\n for (int i = 0; i < N; ++i) {\n cin >> x[i] >> y[i];\n }\n\n vector u(M), v(M), d(M);\n for (int i = 0; i < M; ++i) {\n cin >> u[i] >> v[i];\n double dx = x[u[i]] - x[v[i]];\n double dy = y[u[i]] - y[v[i]];\n double dist = sqrt(dx * dx + dy * dy);\n d[i] = (int)round(dist);\n }\n\n DSU dsu(N);\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n if (dsu.find(u[i]) == dsu.find(v[i])) {\n cout << 0 << endl;\n } else {\n int K = dsu.components;\n int rem = M - i;\n if (rem <= 2 * K) {\n cout << 1 << endl;\n dsu.unite(u[i], v[i]);\n } else {\n if (l <= 2 * d[i]) {\n cout << 1 << endl;\n dsu.unite(u[i], v[i]);\n } else {\n cout << 0 << endl;\n }\n }\n }\n cout.flush();\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nconst int MAXN = 30;\nint N, M;\nint px[20], py[20], pt[20];\nint hx[10], hy[10];\nbool passable[31][31]; // 1-indexed\n\nbool pet_at[31][31];\nbool human_at[31][31];\nbool adj_to_pet[31][31]; // adjacent to at least one pet at start of turn\n\nbool blocked_this_turn[31][31]; // squares that will be blocked this turn (by humans)\n\nrandom_device rd;\nmt19937 rng(rd());\n\n// BFS function: returns component size and sets pet_count\nint bfs(int sx, int sy, int& pet_count, bool temp_blocked, int tbx, int tby) {\n static bool visited[31][31];\n memset(visited, 0, sizeof(visited));\n queue> q;\n if (passable[sx][sy] && !blocked_this_turn[sx][sy] && !(temp_blocked && sx==tbx && sy==tby)) {\n q.push({sx, sy});\n visited[sx][sy] = true;\n }\n int size = 0;\n pet_count = 0;\n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n size++;\n if (pet_at[x][y]) pet_count++;\n for (int dx = -1; dx <= 1; dx++) {\n for (int dy = -1; dy <= 1; dy++) {\n if (abs(dx) + abs(dy) != 1) continue;\n int nx = x + dx, ny = y + dy;\n if (nx < 1 || nx > MAXN || ny < 1 || ny > MAXN) continue;\n if (!passable[nx][ny]) continue;\n if (blocked_this_turn[nx][ny]) continue;\n if (temp_blocked && nx==tbx && ny==tby) continue;\n if (visited[nx][ny]) continue;\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n return size;\n}\n\nint main() {\n // Read input\n cin >> N;\n for (int i = 0; i < N; i++) {\n cin >> px[i] >> py[i] >> pt[i];\n }\n cin >> M;\n for (int i = 0; i < M; i++) {\n cin >> hx[i] >> hy[i];\n }\n\n // Initialize passable grid\n for (int i = 1; i <= MAXN; i++) {\n for (int j = 1; j <= MAXN; j++) {\n passable[i][j] = true;\n }\n }\n\n // Loop for 300 turns\n for (int turn = 0; turn < 300; turn++) {\n // Precompute pet_at, human_at, adj_to_pet\n memset(pet_at, 0, sizeof(pet_at));\n for (int i = 0; i < N; i++) {\n pet_at[px[i]][py[i]] = true;\n }\n memset(human_at, 0, sizeof(human_at));\n for (int i = 0; i < M; i++) {\n human_at[hx[i]][hy[i]] = true;\n }\n memset(adj_to_pet, 0, sizeof(adj_to_pet));\n for (int i = 0; i < N; i++) {\n int x = px[i], y = py[i];\n for (int dx = -1; dx <= 1; dx++) {\n for (int dy = -1; dy <= 1; dy++) {\n if (abs(dx) + abs(dy) != 1) continue;\n int nx = x + dx, ny = y + dy;\n if (nx >= 1 && nx <= MAXN && ny >= 1 && ny <= MAXN) {\n adj_to_pet[nx][ny] = true;\n }\n }\n }\n }\n\n // Reset blocked_this_turn\n memset(blocked_this_turn, 0, sizeof(blocked_this_turn));\n\n // Random order for humans\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n\n string actions(M, '.'); // default action\n\n for (int idx : order) {\n int x = hx[idx], y = hy[idx];\n double best_value = -1.0;\n char best_action = '.';\n\n // Helper lambda to evaluate an action\n auto evaluate = [&](char action) -> double {\n int nx = x, ny = y;\n bool is_block = false;\n bool is_move = false;\n int tbx = -1, tby = -1;\n\n if (action == '.') {\n // stay\n } else if (action == 'u' || action == 'd' || action == 'l' || action == 'r') {\n // block\n is_block = true;\n if (action == 'u') { nx = x-1; ny = y; }\n else if (action == 'd') { nx = x+1; ny = y; }\n else if (action == 'l') { nx = x; ny = y-1; }\n else if (action == 'r') { nx = x; ny = y+1; }\n // Check legality for block\n if (nx < 1 || nx > MAXN || ny < 1 || ny > MAXN) return -1.0;\n if (!passable[nx][ny]) return -1.0;\n if (pet_at[nx][ny]) return -1.0;\n if (human_at[nx][ny]) return -1.0;\n if (adj_to_pet[nx][ny]) return -1.0;\n tbx = nx; tby = ny;\n } else if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n // move\n is_move = true;\n if (action == 'U') { nx = x-1; ny = y; }\n else if (action == 'D') { nx = x+1; ny = y; }\n else if (action == 'L') { nx = x; ny = y-1; }\n else if (action == 'R') { nx = x; ny = y+1; }\n // Check legality for move\n if (nx < 1 || nx > MAXN || ny < 1 || ny > MAXN) return -1.0;\n if (!passable[nx][ny]) return -1.0;\n if (blocked_this_turn[nx][ny]) return -1.0;\n } else {\n return -1.0;\n }\n\n // Now compute component from the human's new position after action\n int start_x = is_move ? nx : x;\n int start_y = is_move ? ny : y;\n int pet_count;\n int comp_size = bfs(start_x, start_y, pet_count, is_block, tbx, tby);\n double value = (comp_size / 900.0) * pow(2.0, -pet_count);\n return value;\n };\n\n // Evaluate each possible action\n vector actions_list = {'.', 'u', 'd', 'l', 'r', 'U', 'D', 'L', 'R'};\n for (char a : actions_list) {\n double val = evaluate(a);\n if (val > best_value) {\n best_value = val;\n best_action = a;\n }\n }\n\n // If best_value is still -1 (no legal action), stay\n if (best_value < 0) best_action = '.';\n\n actions[idx] = best_action;\n\n // If this human chose to block, add to blocked_this_turn\n if (best_action == 'u' || best_action == 'd' || best_action == 'l' || best_action == 'r') {\n int bx = x, by = y;\n if (best_action == 'u') bx = x-1;\n else if (best_action == 'd') bx = x+1;\n else if (best_action == 'l') by = y-1;\n else if (best_action == 'r') by = y+1;\n blocked_this_turn[bx][by] = true;\n }\n }\n\n // Output actions\n cout << actions << endl;\n cout.flush();\n\n // Read pet movements\n for (int i = 0; i < N; i++) {\n string s;\n cin >> s;\n // Apply movement\n for (char c : s) {\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 // else '.' do nothing\n }\n }\n\n // Update passable grid based on blocks placed this turn\n for (int i = 0; i < M; i++) {\n char a = actions[i];\n if (a == 'u' || a == 'd' || a == 'l' || a == 'r') {\n int bx = hx[i], by = hy[i];\n if (a == 'u') bx = hx[i]-1;\n else if (a == 'd') bx = hx[i]+1;\n else if (a == 'l') by = hy[i]-1;\n else if (a == 'r') by = hy[i]+1;\n passable[bx][by] = false;\n }\n }\n\n // Update human positions based on moves\n for (int i = 0; i < M; i++) {\n char a = actions[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 // End of turn\n }\n\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\n// Directions: 0:U, 1:D, 2:L, 3:R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\n// Precompute next cell for each cell and direction\nvector>>> precompute_next(\n const vector>& h,\n const vector>& v) {\n vector>>> next(4, vector>>(20, vector>(20)));\n for (int i = 0; i < 20; ++i) {\n for (int j = 0; j < 20; ++j) {\n // U\n if (i > 0 && v[i-1][j] == 0)\n next[0][i][j] = {i-1, j};\n else\n next[0][i][j] = {i, j};\n // D\n if (i < 19 && v[i][j] == 0)\n next[1][i][j] = {i+1, j};\n else\n next[1][i][j] = {i, j};\n // L\n if (j > 0 && h[i][j-1] == 0)\n next[2][i][j] = {i, j-1};\n else\n next[2][i][j] = {i, j};\n // R\n if (j < 19 && h[i][j] == 0)\n next[3][i][j] = {i, j+1};\n else\n next[3][i][j] = {i, j};\n }\n }\n return next;\n}\n\n// BFS to find a shortest path from start to target\nstring bfs_path(int si, int sj, int ti, int tj,\n const vector>& h,\n const vector>& v) {\n vector> visited(20, vector(20, false));\n vector>> parent(20, vector>(20, {-1, -1}));\n vector> move(20, vector(20, ' '));\n queue> q;\n q.emplace(si, sj);\n visited[si][sj] = true;\n\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break;\n // Try four directions\n for (int d = 0; d < 4; ++d) {\n int ni = i + dx[d];\n int nj = j + dy[d];\n if (ni < 0 || ni >= 20 || nj < 0 || nj >= 20) continue;\n // Check walls\n if (d == 0 && (i == 0 || v[i-1][j] == 1)) continue;\n if (d == 1 && (i == 19 || v[i][j] == 1)) continue;\n if (d == 2 && (j == 0 || h[i][j-1] == 1)) continue;\n if (d == 3 && (j == 19 || h[i][j] == 1)) continue;\n if (!visited[ni][nj]) {\n visited[ni][nj] = true;\n parent[ni][nj] = {i, j};\n move[ni][nj] = dir_char[d];\n q.emplace(ni, nj);\n }\n }\n }\n\n // Reconstruct path\n string path = \"\";\n int i = ti, j = tj;\n while (i != si || j != sj) {\n char m = move[i][j];\n path += m;\n auto p = parent[i][j];\n i = p.first;\n j = p.second;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// Simulate the stochastic process and compute expected score\ndouble simulate(const string& s,\n const vector>>>& next,\n int si, int sj, int ti, int tj, double p) {\n vector> dist(20, vector(20, 0.0));\n dist[si][sj] = 1.0;\n double score = 0.0;\n int L = s.size();\n for (int t = 1; t <= L; ++t) {\n char c = s[t-1];\n int d = -1;\n if (c == 'U') d = 0;\n else if (c == 'D') d = 1;\n else if (c == 'L') d = 2;\n else if (c == 'R') d = 3;\n vector> new_dist(20, vector(20, 0.0));\n for (int i = 0; i < 20; ++i) {\n for (int j = 0; j < 20; ++j) {\n double prob = dist[i][j];\n if (prob == 0.0) continue;\n // With probability p, forget and stay\n new_dist[i][j] += prob * p;\n // With probability 1-p, try to move\n auto [ni, nj] = next[d][i][j];\n if (ni == ti && nj == tj) {\n score += prob * (1-p) * (401 - t);\n } else {\n new_dist[ni][nj] += prob * (1-p);\n }\n }\n }\n dist = new_dist;\n }\n return score;\n}\n\n// Generate greedy nominal string (always try to move towards target)\nstring greedy_nominal(int si, int sj, int ti, int tj,\n const vector>& h,\n const vector>& v) {\n string cand = \"\";\n int cur_r = si, cur_c = sj;\n for (int step = 0; step < 200; ++step) {\n if (cur_r == ti && cur_c == tj) {\n cand += 'R'; // arbitrary after reaching target\n continue;\n }\n char best = 'R';\n bool moved = false;\n // Try right\n if (cur_c < tj && h[cur_r][cur_c] == 0) {\n best = 'R';\n moved = true;\n }\n // Try down\n if (!moved && cur_r < ti && v[cur_r][cur_c] == 0) {\n best = 'D';\n moved = true;\n }\n // Try left\n if (!moved && cur_c > tj && (cur_c > 0 && h[cur_r][cur_c-1] == 0)) {\n best = 'L';\n moved = true;\n }\n // Try up\n if (!moved && cur_r > ti && (cur_r > 0 && v[cur_r-1][cur_c] == 0)) {\n best = 'U';\n moved = true;\n }\n // If no move reduces Manhattan distance, try any possible move\n if (!moved) {\n if (cur_c < 19 && h[cur_r][cur_c] == 0) best = 'R';\n else if (cur_r < 19 && v[cur_r][cur_c] == 0) best = 'D';\n else if (cur_c > 0 && h[cur_r][cur_c-1] == 0) best = 'L';\n else if (cur_r > 0 && v[cur_r-1][cur_c] == 0) best = 'U';\n else best = 'R'; // should not happen\n }\n cand += best;\n // Update nominal position\n if (best == 'U' && cur_r > 0 && v[cur_r-1][cur_c] == 0) cur_r--;\n else if (best == 'D' && cur_r < 19 && v[cur_r][cur_c] == 0) cur_r++;\n else if (best == 'L' && cur_c > 0 && h[cur_r][cur_c-1] == 0) cur_c--;\n else if (best == 'R' && cur_c < 19 && h[cur_r][cur_c] == 0) cur_c++;\n }\n return cand;\n}\n\n// Generate alternating direction string (prioritize down then right)\nstring alternating_string(int si, int sj, int ti, int tj,\n const vector>& h,\n const vector>& v) {\n string cand = \"\";\n int cur_r = si, cur_c = sj;\n for (int step = 0; step < 200; ++step) {\n if (cur_r == ti && cur_c == tj) {\n cand += 'R';\n continue;\n }\n char dir = 'D';\n if (cur_r > ti) dir = 'U';\n else if (cur_c < tj) dir = 'R';\n else if (cur_c > tj) dir = 'L';\n // else cur_r < ti already set to 'D'\n bool possible = false;\n if (dir == 'D' && cur_r < 19 && v[cur_r][cur_c] == 0) possible = true;\n else if (dir == 'U' && cur_r > 0 && v[cur_r-1][cur_c] == 0) possible = true;\n else if (dir == 'R' && cur_c < 19 && h[cur_r][cur_c] == 0) possible = true;\n else if (dir == 'L' && cur_c > 0 && h[cur_r][cur_c-1] == 0) possible = true;\n if (!possible) {\n // Try any possible direction\n if (cur_r < 19 && v[cur_r][cur_c] == 0) dir = 'D';\n else if (cur_r > 0 && v[cur_r-1][cur_c] == 0) dir = 'U';\n else if (cur_c < 19 && h[cur_r][cur_c] == 0) dir = 'R';\n else if (cur_c > 0 && h[cur_r][cur_c-1] == 0) dir = 'L';\n else dir = 'R';\n }\n cand += dir;\n // Update nominal position\n if (dir == 'D' && cur_r < 19 && v[cur_r][cur_c] == 0) cur_r++;\n else if (dir == 'U' && cur_r > 0 && v[cur_r-1][cur_c] == 0) cur_r--;\n else if (dir == 'R' && cur_c < 19 && h[cur_r][cur_c] == 0) cur_c++;\n else if (dir == 'L' && cur_c > 0 && h[cur_r][cur_c-1] == 0) cur_c--;\n }\n return cand;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n\n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n\n vector> h(20, vector(19));\n for (int i = 0; i < 20; ++i) {\n string line;\n cin >> line;\n for (int j = 0; j < 19; ++j) {\n h[i][j] = line[j] - '0';\n }\n }\n vector> v(19, vector(20));\n for (int i = 0; i < 19; ++i) {\n string line;\n cin >> line;\n for (int j = 0; j < 20; ++j) {\n v[i][j] = line[j] - '0';\n }\n }\n\n // Precompute next cells\n auto next_cell = precompute_next(h, v);\n\n // Find a shortest path\n string shortest_path = bfs_path(si, sj, ti, tj, h, v);\n int k = shortest_path.size();\n\n // Generate candidates\n vector candidates;\n\n // 1. Shortest path itself\n if (k > 0) {\n candidates.push_back(shortest_path);\n }\n\n // 2. Repeat the whole path (padded to length 200)\n if (k > 0) {\n int t = 200 / k;\n int rem = 200 % k;\n string cand = \"\";\n for (int i = 0; i < t; ++i) cand += shortest_path;\n cand += shortest_path.substr(0, rem);\n candidates.push_back(cand);\n }\n\n // 3. Repeat each move m times (m = floor(200/k))\n if (k > 0) {\n int m = 200 / k;\n string cand = \"\";\n for (char c : shortest_path) {\n for (int i = 0; i < m; ++i) cand += c;\n }\n candidates.push_back(cand);\n }\n\n // 4. Greedy nominal moves\n candidates.push_back(greedy_nominal(si, sj, ti, tj, h, v));\n\n // 5. Alternating direction\n candidates.push_back(alternating_string(si, sj, ti, tj, h, v));\n\n // Evaluate each candidate and pick the best\n double best_score = -1.0;\n string best_str = \"\";\n for (const string& cand : candidates) {\n double score = simulate(cand, next_cell, si, sj, ti, tj, p);\n if (score > best_score) {\n best_score = score;\n best_str = cand;\n }\n }\n\n cout << best_str << endl;\n\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int STEPS = 100000;\n\n// Tile connectivity table as provided in the problem hint\nconst int to[8][4] = {\n {1, 0, -1, -1}, // tile 0\n {3, -1, -1, 0}, // tile 1\n {-1, -1, 3, 2}, // tile 2\n {-1, 2, 1, -1}, // tile 3\n {1, 0, 3, 2}, // tile 4\n {3, 2, 1, 0}, // tile 5\n {2, -1, 0, -1}, // tile 6\n {-1, 3, -1, 1} // tile 7\n};\n\n// Direction changes: left, up, right, down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\n// Function to compute the length of a loop line starting from (i,j) with incoming direction d\nint compute_loop_length(const vector& tiles, int si, int sj, int sd) {\n int i = si, j = sj, d = sd;\n int length = 0;\n \n while (true) {\n // Get the current tile type\n int t = tiles[i][j] - '0';\n \n // Determine outgoing direction\n int d2 = to[t][d];\n if (d2 == -1) return 0;\n \n // Move to next tile\n i += di[d2];\n j += dj[d2];\n \n // Check bounds\n if (i < 0 || i >= N || j < 0 || j >= N) return 0;\n \n // Reverse direction for incoming\n d = (d2 + 2) % 4;\n length++;\n \n // Check if we've returned to start\n if (i == si && j == sj && d == sd) return length;\n \n // Prevent infinite loops with a reasonable limit\n if (length > 4 * N * N) return 0;\n }\n}\n\n// Compute all loop lengths in the current configuration\nvector compute_all_loops(const vector& tiles) {\n vector loops;\n vector>> visited(N, vector>(N, vector(4, false)));\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 (visited[i][j][d]) continue;\n \n int length = compute_loop_length(tiles, i, j, d);\n if (length > 0) {\n loops.push_back(length);\n // Mark all positions in this loop as visited\n int ci = i, cj = j, cd = d;\n do {\n visited[ci][cj][cd] = true;\n int t = tiles[ci][cj] - '0';\n int d2 = to[t][cd];\n ci += di[d2];\n cj += dj[d2];\n cd = (d2 + 2) % 4;\n } while (ci != i || cj != j || cd != d);\n }\n }\n }\n }\n \n sort(loops.rbegin(), loops.rend());\n return loops;\n}\n\n// Compute score from loop lengths\nlong long compute_score(const vector& loops) {\n if (loops.size() < 2) return 0;\n return (long long)loops[0] * loops[1];\n}\n\n// Rotate a tile by r steps counterclockwise\nvoid rotate_tile(vector& tiles, int i, int j, int r) {\n int t = tiles[i][j] - '0';\n // Apply rotation r times\n for (int step = 0; step < r; step++) {\n if (t == 0) t = 1;\n else if (t == 1) t = 2;\n else if (t == 2) t = 3;\n else if (t == 3) t = 0;\n else if (t == 4) t = 5;\n else if (t == 5) t = 4;\n else if (t == 6) t = 7;\n else if (t == 7) t = 6;\n }\n tiles[i][j] = '0' + t;\n}\n\nint main() {\n // Read input\n vector tiles(N);\n for (int i = 0; i < N; i++) {\n cin >> tiles[i];\n }\n \n // Random number generator\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n // Current solution (rotations for each tile)\n vector> rotations(N, vector(N, 0));\n \n // Compute initial score\n vector initial_loops = compute_all_loops(tiles);\n long long current_score = compute_score(initial_loops);\n long long best_score = current_score;\n vector> best_rotations = rotations;\n \n // Simulated annealing parameters\n double temperature = 1000.0;\n double cooling_rate = 0.99995;\n \n for (int step = 0; step < STEPS; step++) {\n // Randomly select a tile to change\n int i = rng() % N;\n int j = rng() % N;\n int old_rotation = rotations[i][j];\n int new_rotation = rng() % 4;\n \n // Skip if no change\n if (new_rotation == old_rotation) continue;\n \n // Apply rotation\n int rot_diff = (new_rotation - old_rotation + 4) % 4;\n rotate_tile(tiles, i, j, rot_diff);\n rotations[i][j] = new_rotation;\n \n // Compute new score\n vector new_loops = compute_all_loops(tiles);\n long long new_score = compute_score(new_loops);\n \n // Decide whether to accept the change\n if (new_score > current_score || \n rng() % 10000 < 10000 * exp((new_score - current_score) / temperature)) {\n current_score = new_score;\n \n // Update best solution\n if (new_score > best_score) {\n best_score = new_score;\n best_rotations = rotations;\n }\n } else {\n // Revert the change\n rotate_tile(tiles, i, j, (4 - rot_diff) % 4);\n rotations[i][j] = old_rotation;\n }\n \n // Cool down\n temperature *= cooling_rate;\n }\n \n // Output the best rotations found\n string output;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n output += '0' + best_rotations[i][j];\n }\n }\n \n cout << output << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, T;\nvector> board;\nint empty_i, empty_j;\n\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\nconst int opposite[4] = {1, 0, 3, 2};\n\n// compute the size of the largest tree component\nint compute_S() {\n vector> visited(N, vector(N, false));\n int max_tree_vertices = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 0) continue;\n if (visited[i][j]) continue;\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int vertices = 0;\n int edges = 0;\n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n vertices++;\n int mask = board[x][y];\n for (int d = 0; d < 4; ++d) {\n if (!(mask & (1 << d))) continue;\n int nx = x + di[d];\n int ny = y + dj[d];\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n if (board[nx][ny] == 0) continue;\n int opp_mask = board[nx][ny];\n int opp_bit = 1 << opposite[d];\n if (opp_mask & opp_bit) {\n // count each edge only once (down or right)\n if (d == 1 || d == 3) {\n edges++;\n }\n if (!visited[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n }\n if (edges == vertices - 1) {\n max_tree_vertices = max(max_tree_vertices, vertices);\n }\n }\n }\n return max_tree_vertices;\n}\n\n// list of valid moves (U/D/L/R) for the empty cell\nvector get_valid_moves() {\n vector moves;\n for (int d = 0; d < 4; ++d) {\n int ni = empty_i + di[d];\n int nj = empty_j + dj[d];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n moves.push_back(dir_char[d]);\n }\n }\n return moves;\n}\n\n// apply move in direction d (empty moves in that direction)\nvoid apply_move(int d) {\n int ni = empty_i + di[d];\n int nj = empty_j + dj[d];\n swap(board[empty_i][empty_j], board[ni][nj]);\n empty_i = ni;\n empty_j = nj;\n}\n\n// undo move by applying the opposite direction\nvoid undo_move(int d) {\n apply_move(opposite[d]);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n cin >> N >> T;\n board.resize(N, vector(N));\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n char c = s[j];\n int val;\n if (c >= '0' && c <= '9') val = c - '0';\n else val = c - 'a' + 10;\n board[i][j] = val;\n if (val == 0) {\n empty_i = i;\n empty_j = j;\n }\n }\n }\n\n int current_S = compute_S();\n int best_S = current_S;\n string best_seq = \"\";\n string current_seq = \"\";\n string best_full_seq = \"\"; // best sequence that achieves a full tree\n\n double temp = 1.0;\n double cooling = 0.998; // cooling factor per iteration\n random_device rd;\n mt19937 gen(rd());\n uniform_real_distribution<> dis(0.0, 1.0);\n\n for (int iter = 0; iter < T; ++iter) {\n vector moves = get_valid_moves();\n if (moves.empty()) break;\n char move = moves[gen() % moves.size()];\n int d;\n for (int i = 0; i < 4; ++i) {\n if (dir_char[i] == move) {\n d = i;\n break;\n }\n }\n apply_move(d);\n int new_S = compute_S();\n double delta = new_S - current_S;\n if (delta > 0 || dis(gen) < exp(delta / temp)) {\n // accept move\n current_S = new_S;\n current_seq += move;\n if (new_S > best_S) {\n best_S = new_S;\n best_seq = current_seq;\n }\n if (new_S == N * N - 1) {\n // full tree achieved\n if (best_full_seq.empty() || current_seq.length() < best_full_seq.length()) {\n best_full_seq = current_seq;\n }\n }\n } else {\n // reject move\n undo_move(d);\n }\n temp *= cooling;\n }\n\n // output the best sequence found\n if (!best_full_seq.empty()) {\n if (best_seq.empty() || best_full_seq.length() < best_seq.length()) {\n cout << best_full_seq << endl;\n } else {\n cout << best_seq << endl;\n }\n } else {\n cout << best_seq << endl;\n }\n\n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\n// Global arrays\nint a[11]; // a[1]..a[10]\n\n// Compute the score for given vertical lines V and horizontal lines H\nint compute_score(const vector& V, const vector& H, const vector>& points) {\n int p = V.size();\n int q = H.size();\n int total_cells = (p+1)*(q+1);\n vector cell_counts(total_cells, 0);\n \n // Create boundary arrays including cake boundaries (-10000 and 10000)\n vector V_all(p+2), H_all(q+2);\n V_all[0] = -10000;\n for (int i=0; i b(11, 0); // index 1..10\n for (int cnt : cell_counts) {\n if (1 <= cnt && cnt <= 10) {\n b[cnt]++;\n }\n }\n int score = 0;\n for (int d=1; d<=10; ++d) {\n score += min(a[d], b[d]);\n }\n return score;\n}\n\n// Check if a vertical line at position x is valid (does not pass through any point)\nbool is_valid_vertical(int x, const vector>& points) {\n for (const auto& pt : points) {\n if (pt.first == x) return false;\n }\n return true;\n}\n\n// Check if a horizontal line at position y is valid\nbool is_valid_horizontal(int y, const vector>& points) {\n for (const auto& pt : points) {\n if (pt.second == y) return false;\n }\n return true;\n}\n\n// Find a free integer coordinate for a line, starting from a candidate and exploring nearby integers\nint find_free(int cand, const vector& lines, const vector>& points, bool is_vertical) {\n for (int d=0; ; ++d) {\n for (int sign : {0, 1, -1}) {\n int pos = cand + sign * d;\n if (pos < -10000 || pos > 10000) continue;\n // Check not already used by another line\n if (find(lines.begin(), lines.end(), pos) != lines.end()) continue;\n // Check not on any point\n if (is_vertical) {\n if (!is_valid_vertical(pos, points)) continue;\n } else {\n if (!is_valid_horizontal(pos, points)) continue;\n }\n return pos;\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n \n int N, K;\n cin >> N >> K;\n for (int d=1; d<=10; ++d) cin >> a[d];\n \n vector> points(N);\n for (int i=0; i> points[i].first >> points[i].second;\n }\n \n // We'll use p vertical and q horizontal lines with p+q = K\n // Since K=100, we try p=50, q=50\n int p = 50, q = K - p;\n \n // Extract x and y coordinates for initialization\n vector xs(N), ys(N);\n for (int i=0; i V;\n for (int i=1; i<=p; ++i) {\n int idx = i * N / (p+1);\n int cand = xs[idx];\n int pos = find_free(cand, V, points, true);\n V.push_back(pos);\n }\n sort(V.begin(), V.end());\n \n // Initialize horizontal lines\n vector H;\n for (int i=1; i<=q; ++i) {\n int idx = i * N / (q+1);\n int cand = ys[idx];\n int pos = find_free(cand, H, points, false);\n H.push_back(pos);\n }\n sort(H.begin(), H.end());\n \n // Compute initial score\n int best_score = compute_score(V, H, points);\n vector bestV = V, bestH = H;\n \n // Random number generator\n random_device rd;\n mt19937 rng(rd());\n uniform_int_distribution dist_line(0, (p+q)-1); // choose which line to modify\n uniform_int_distribution dist_offset(-10, 10);\n \n const int ITERATIONS = 5000;\n for (int iter=0; iter 10000) continue;\n if (new_pos == cur_pos) continue;\n \n // Create candidate line sets\n vector newV = V;\n vector newH = H;\n if (is_vertical) {\n newV[idx] = new_pos;\n // Check validity and no duplicates\n if (!is_valid_vertical(new_pos, points)) continue;\n sort(newV.begin(), newV.end());\n if (adjacent_find(newV.begin(), newV.end()) != newV.end()) continue;\n } else {\n newH[idx] = new_pos;\n if (!is_valid_horizontal(new_pos, points)) continue;\n sort(newH.begin(), newH.end());\n if (adjacent_find(newH.begin(), newH.end()) != newH.end()) continue;\n }\n \n // Compute new score\n int new_score = compute_score(newV, newH, points);\n if (new_score > best_score) {\n best_score = new_score;\n bestV = newV;\n bestH = newH;\n V = newV;\n H = newH;\n }\n }\n \n // Output\n cout << p + q << '\\n';\n // Vertical lines\n for (int x : bestV) {\n cout << x << \" \" << -10000 << \" \" << x << \" \" << 10000 << '\\n';\n }\n // Horizontal lines\n for (int y : bestH) {\n cout << -10000 << \" \" << y << \" \" << 10000 << \" \" << y << '\\n';\n }\n \n return 0;\n}","ahc014":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n};\n\n// Encode a unit segment into a 32-bit integer (canonical order: smaller x first, or if x equal, smaller y first)\nuint32_t encode_seg(int x1, int y1, int x2, int y2) {\n if (x1 > x2 || (x1 == x2 && y1 > y2)) {\n swap(x1, x2);\n swap(y1, y2);\n }\n // N <= 61, so 6 bits per coordinate are enough\n return (x1 << 18) | (y1 << 12) | (x2 << 6) | y2;\n}\n\n// Check condition 2 for axis-aligned rectangle: no other dots on the perimeter (excluding corners)\nbool check_perimeter_axis(int x1, int y1, int x2, int y2, const vector>& dot_grid) {\n // vertical sides\n for (int y = y1 + 1; y < y2; ++y) {\n if (dot_grid[x1][y] || dot_grid[x2][y])\n return false;\n }\n // horizontal sides\n for (int x = x1 + 1; x < x2; ++x) {\n if (dot_grid[x][y1] || dot_grid[x][y2])\n return false;\n }\n return true;\n}\n\n// Check condition 3 for axis-aligned rectangle: no overlapping segments\nbool check_used_segments_axis(int x1, int y1, int x2, int y2, const unordered_set& used_segments) {\n // vertical sides\n for (int y = y1; y < y2; ++y) {\n if (used_segments.count(encode_seg(x1, y, x1, y + 1)))\n return false;\n if (used_segments.count(encode_seg(x2, y, x2, y + 1)))\n return false;\n }\n // horizontal sides\n for (int x = x1; x < x2; ++x) {\n if (used_segments.count(encode_seg(x, y1, x + 1, y1)))\n return false;\n if (used_segments.count(encode_seg(x, y2, x + 1, y2)))\n return false;\n }\n return true;\n}\n\n// Check condition 2 for 45-degree rectangle\nbool check_perimeter_45(int x, int y, int a, int b, const vector>& dot_grid) {\n // side P->C: (x,y) to (x+a, y+a)\n for (int i = 1; i < a; ++i) {\n if (dot_grid[x + i][y + i])\n return false;\n }\n // side C->Q: (x+a, y+a) to (x+a+b, y+a-b)\n for (int i = 1; i < b; ++i) {\n if (dot_grid[x + a + i][y + a - i])\n return false;\n }\n // side Q->D: (x+a+b, y+a-b) to (x+b, y-b)\n for (int i = 1; i < a; ++i) {\n if (dot_grid[x + a + b - i][y + a - b - i])\n return false;\n }\n // side D->P: (x+b, y-b) to (x,y)\n for (int i = 1; i < b; ++i) {\n if (dot_grid[x + b - i][y - b + i])\n return false;\n }\n return true;\n}\n\n// Check condition 3 for 45-degree rectangle\nbool check_used_segments_45(int x, int y, int a, int b, const unordered_set& used_segments) {\n // side P->C\n for (int i = 0; i < a; ++i) {\n if (used_segments.count(encode_seg(x + i, y + i, x + i + 1, y + i + 1)))\n return false;\n }\n // side C->Q\n for (int i = 0; i < b; ++i) {\n if (used_segments.count(encode_seg(x + a + i, y + a - i, x + a + i + 1, y + a - i - 1)))\n return false;\n }\n // side Q->D\n for (int i = 0; i < a; ++i) {\n if (used_segments.count(encode_seg(x + a + b - i, y + a - b - i, x + a + b - i - 1, y + a - b - i - 1)))\n return false;\n }\n // side D->P\n for (int i = 0; i < b; ++i) {\n if (used_segments.count(encode_seg(x + b - i, y - b + i, x + b - i - 1, y - b + i + 1)))\n return false;\n }\n return true;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n\n vector initial(M);\n vector> dot_grid(N, vector(N, false));\n for (int i = 0; i < M; ++i) {\n cin >> initial[i].x >> initial[i].y;\n dot_grid[initial[i].x][initial[i].y] = true;\n }\n\n vector dots = initial; // current list of dots\n unordered_set used_segments;\n vector> operations;\n\n int c = (N - 1) / 2; // center coordinate\n clock_t start_time = clock();\n\n while (true) {\n // Check time limit (4.5 seconds margin)\n if ((clock() - start_time) / CLOCKS_PER_SEC >= 4.5)\n break;\n\n int best_weight = -1;\n array best_op;\n bool found = false;\n\n int Mcurr = dots.size();\n for (int i = 0; i < Mcurr; ++i) {\n for (int j = i + 1; j < Mcurr; ++j) {\n Point A = dots[i], B = dots[j];\n\n // ---------- Axis-aligned rectangle ----------\n int x1 = min(A.x, B.x), x2 = max(A.x, B.x);\n int y1 = min(A.y, B.y), y2 = max(A.y, B.y);\n if (x1 < x2 && y1 < y2) {\n bool c1 = dot_grid[x1][y1];\n bool c2 = dot_grid[x1][y2];\n bool c3 = dot_grid[x2][y1];\n bool c4 = dot_grid[x2][y2];\n int cnt = c1 + c2 + c3 + c4;\n if (cnt == 3) {\n Point D;\n if (!c1) D = {x1, y1};\n else if (!c2) D = {x1, y2};\n else if (!c3) D = {x2, y1};\n else D = {x2, y2};\n\n if (check_perimeter_axis(x1, y1, x2, y2, dot_grid) &&\n check_used_segments_axis(x1, y1, x2, y2, used_segments)) {\n int w = (D.x - c) * (D.x - c) + (D.y - c) * (D.y - c) + 1;\n if (w > best_weight) {\n best_weight = w;\n // Build operation in cyclic order\n array corners = { {x1, y1}, {x1, y2}, {x2, y2}, {x2, y1} };\n int idx = 0;\n for (int k = 0; k < 4; ++k) {\n if (corners[k].x == D.x && corners[k].y == D.y) {\n idx = k;\n break;\n }\n }\n best_op = {D.x, D.y,\n corners[(idx+1)%4].x, corners[(idx+1)%4].y,\n corners[(idx+2)%4].x, corners[(idx+2)%4].y,\n corners[(idx+3)%4].x, corners[(idx+3)%4].y};\n found = true;\n }\n }\n }\n }\n\n // ---------- 45-degree rectangle ----------\n // Try both orders (A as start, then B as start)\n for (int order = 0; order < 2; ++order) {\n Point start = (order == 0) ? A : B;\n Point opposite = (order == 0) ? B : A;\n int dx = opposite.x - start.x;\n int dy = opposite.y - start.y;\n int sum_diff = dx + dy;\n int sub_diff = dx - dy;\n if (sum_diff % 2 != 0 || sub_diff % 2 != 0) continue;\n int a = sum_diff / 2;\n int b = sub_diff / 2;\n if (a <= 0 || b <= 0) continue;\n\n // Other two corners\n Point C = {start.x + a, start.y + a};\n Point D = {start.x + b, start.y - b};\n if (C.x < 0 || C.x >= N || C.y < 0 || C.y >= N ||\n D.x < 0 || D.x >= N || D.y < 0 || D.y >= N) continue;\n\n bool cC = dot_grid[C.x][C.y];\n bool cD = dot_grid[D.x][D.y];\n if (cC + cD != 1) continue; // exactly one of C,D is a dot\n\n Point missing = cC ? D : C; // the one that is not a dot\n // The four corners in order: start -> C -> opposite -> D\n array corners = {start, C, opposite, D};\n\n if (check_perimeter_45(start.x, start.y, a, b, dot_grid) &&\n check_used_segments_45(start.x, start.y, a, b, used_segments)) {\n int w = (missing.x - c) * (missing.x - c) + (missing.y - c) * (missing.y - c) + 1;\n if (w > best_weight) {\n best_weight = w;\n int idx = 0;\n for (int k = 0; k < 4; ++k) {\n if (corners[k].x == missing.x && corners[k].y == missing.y) {\n idx = k;\n break;\n }\n }\n best_op = {missing.x, missing.y,\n corners[(idx+1)%4].x, corners[(idx+1)%4].y,\n corners[(idx+2)%4].x, corners[(idx+2)%4].y,\n corners[(idx+3)%4].x, corners[(idx+3)%4].y};\n found = true;\n }\n }\n }\n }\n }\n\n if (!found) break;\n\n // Perform the operation\n operations.push_back(best_op);\n Point new_dot = {best_op[0], best_op[1]};\n dot_grid[new_dot.x][new_dot.y] = true;\n dots.push_back(new_dot);\n\n // Add the four edges of the rectangle to used_segments\n for (int k = 0; k < 4; ++k) {\n int k2 = (k + 1) % 4;\n int x1 = best_op[2*k], y1 = best_op[2*k+1];\n int x2 = best_op[2*k2], y2 = best_op[2*k2+1];\n used_segments.insert(encode_seg(x1, y1, x2, y2));\n }\n }\n\n // Output\n cout << operations.size() << \"\\n\";\n for (const auto& op : operations) {\n for (int i = 0; i < 8; ++i) {\n cout << op[i];\n if (i < 7) cout << \" \";\n }\n cout << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \nusing namespace std;\n\nconst int SIZE = 10;\nusing Grid = vector>; // 1\u2011indexed, dimensions 11x11\n\n// Apply a tilt in the given direction to the grid and return the new grid.\nGrid apply_tilt(const Grid& grid, char dir) {\n Grid new_grid(SIZE + 1, vector(SIZE + 1, 0));\n if (dir == 'L') {\n for (int r = 1; r <= SIZE; ++r) {\n vector flavors;\n for (int c = 1; c <= SIZE; ++c)\n if (grid[r][c] != 0) flavors.push_back(grid[r][c]);\n int k = flavors.size();\n for (int i = 0; i < k; ++i) new_grid[r][i + 1] = flavors[i];\n }\n } else if (dir == 'R') {\n for (int r = 1; r <= SIZE; ++r) {\n vector flavors;\n for (int c = 1; c <= SIZE; ++c)\n if (grid[r][c] != 0) flavors.push_back(grid[r][c]);\n int k = flavors.size();\n for (int i = 0; i < k; ++i) new_grid[r][SIZE - k + 1 + i] = flavors[i];\n }\n } else if (dir == 'F') { // forward = up (towards row 1)\n for (int c = 1; c <= SIZE; ++c) {\n vector flavors;\n for (int r = 1; r <= SIZE; ++r)\n if (grid[r][c] != 0) flavors.push_back(grid[r][c]);\n int k = flavors.size();\n for (int i = 0; i < k; ++i) new_grid[i + 1][c] = flavors[i];\n }\n } else { // 'B' \u2013 backward = down (towards row 10)\n for (int c = 1; c <= SIZE; ++c) {\n vector flavors;\n for (int r = 1; r <= SIZE; ++r)\n if (grid[r][c] != 0) flavors.push_back(grid[r][c]);\n int k = flavors.size();\n for (int i = 0; i < k; ++i) new_grid[SIZE - k + 1 + i][c] = flavors[i];\n }\n }\n return new_grid;\n}\n\n// Compute sum of squares of sizes of connected components (by flavor).\nlong long compute_score(const Grid& grid) {\n bool visited[SIZE + 1][SIZE + 1] = {false};\n long long score = 0;\n const int dr[] = {1, -1, 0, 0};\n const int dc[] = {0, 0, 1, -1};\n for (int r = 1; r <= SIZE; ++r) {\n for (int c = 1; c <= SIZE; ++c) {\n if (grid[r][c] != 0 && !visited[r][c]) {\n int flavor = grid[r][c];\n int size = 0;\n vector> queue = {{r, c}};\n visited[r][c] = true;\n int idx = 0;\n while (idx < queue.size()) {\n auto [cr, cc] = queue[idx++];\n ++size;\n for (int d = 0; d < 4; ++d) {\n int nr = cr + dr[d];\n int nc = cc + dc[d];\n if (nr >= 1 && nr <= SIZE && nc >= 1 && nc <= SIZE &&\n !visited[nr][nc] && grid[nr][nc] == flavor) {\n visited[nr][nc] = true;\n queue.push_back({nr, nc});\n }\n }\n }\n score += (long long)size * size;\n }\n }\n }\n return score;\n}\n\nint main() {\n vector f(101); // 1\u2011indexed flavors of the 100 candies\n for (int i = 1; i <= 100; ++i) cin >> f[i];\n\n Grid grid(SIZE + 1, vector(SIZE + 1, 0)); // initially empty\n\n for (int t = 1; t <= 100; ++t) {\n int p;\n cin >> p;\n\n // Locate the p\u2011th empty cell (front\u2011to\u2011back, left\u2011to\u2011right).\n int count = 0;\n int placed_r = -1, placed_c = -1;\n for (int r = 1; r <= SIZE; ++r) {\n for (int c = 1; c <= SIZE; ++c) {\n if (grid[r][c] == 0) {\n ++count;\n if (count == p) {\n placed_r = r;\n placed_c = c;\n break;\n }\n }\n }\n if (placed_r != -1) break;\n }\n grid[placed_r][placed_c] = f[t]; // place the candy\n\n if (t == 100) break; // last candy \u2013 no need to tilt or output\n\n // Evaluate all four directions.\n char best_dir = 'F';\n long long best_score = -1;\n for (char dir : {'F', 'B', 'L', 'R'}) {\n Grid new_grid = apply_tilt(grid, dir);\n long long score = compute_score(new_grid);\n if (score > best_score) {\n best_score = score;\n best_dir = dir;\n }\n }\n\n // Output the chosen direction and update the grid.\n cout << best_dir << endl;\n grid = apply_tilt(grid, best_dir);\n }\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nconst int N = 100;\n\nint main() {\n int M;\n double epsilon;\n cin >> M >> epsilon;\n\n // Precompute expected sorted degree lists for each possible a (1..N)\n vector> exp_sorted(N + 1);\n for (int a = 1; a <= N; ++a) {\n vector degs;\n if (a == N) {\n double mu = (N - 1) * (1 - epsilon);\n degs.assign(N, mu);\n } else {\n double muA = (a - 1) * (1 - epsilon) + (N - a) * epsilon;\n double muB = (N - a - 1) * (1 - epsilon) + a * epsilon;\n for (int i = 0; i < a; ++i) degs.push_back(muA);\n for (int i = 0; i < N - a; ++i) degs.push_back(muB);\n sort(degs.begin(), degs.end());\n }\n exp_sorted[a] = degs;\n }\n\n // Precompute L1 distances between any two a\n vector> dist(N + 1, vector(N + 1, 0.0));\n for (int a1 = 1; a1 <= N; ++a1) {\n for (int a2 = a1 + 1; a2 <= N; ++a2) {\n double d = 0.0;\n for (int i = 0; i < N; ++i) {\n d += abs(exp_sorted[a1][i] - exp_sorted[a2][i]);\n }\n dist[a1][a2] = d;\n dist[a2][a1] = d;\n }\n }\n\n // Greedy selection of M a values\n vector selected;\n selected.push_back(50); // start with middle to cover the range\n vector used(N + 1, false);\n used[50] = true;\n for (int step = 1; step < M; ++step) {\n int best_a = -1;\n double best_min_dist = -1.0;\n for (int a = 1; a <= N; ++a) {\n if (used[a]) continue;\n double min_dist = 1e18;\n for (int b : selected) {\n min_dist = min(min_dist, dist[a][b]);\n }\n if (min_dist > best_min_dist) {\n best_min_dist = min_dist;\n best_a = a;\n }\n }\n selected.push_back(best_a);\n used[best_a] = true;\n }\n\n // Sort selected a in increasing order for output order\n sort(selected.begin(), selected.end());\n\n // Create mapping from a to index\n vector index_of_a(N + 1, -1);\n for (int i = 0; i < M; ++i) {\n index_of_a[selected[i]] = i;\n }\n\n // Output N\n cout << N << endl;\n\n // Output M graphs\n for (int a : selected) {\n string graph;\n graph.resize(N * (N - 1) / 2, '0');\n int pos = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = i + 1; j < N; ++j) {\n bool same_clique = false;\n if (a == N) {\n same_clique = true; // complete graph\n } else {\n if (i < a && j < a) same_clique = true;\n else if (i >= a && j >= a) same_clique = true;\n }\n if (same_clique) graph[pos] = '1';\n pos++;\n }\n }\n cout << graph << endl;\n }\n cout.flush();\n\n // Process 100 queries\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n // Compute degrees\n vector deg(N, 0);\n int pos = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = i + 1; j < N; ++j) {\n if (H[pos] == '1') {\n deg[i]++;\n deg[j]++;\n }\n pos++;\n }\n }\n sort(deg.begin(), deg.end());\n\n // Find the a with minimum L1 distance\n int best_idx = -1;\n double best_dist = 1e18;\n for (int a : selected) {\n double d = 0.0;\n for (int i = 0; i < N; ++i) {\n d += abs(deg[i] - exp_sorted[a][i]);\n }\n if (d < best_dist) {\n best_dist = d;\n best_idx = index_of_a[a];\n }\n }\n\n cout << best_idx << endl;\n cout.flush();\n }\n\n return 0;\n}","ahc017":"#include \nusing namespace std;\nusing ll = long long;\n\nconst ll INF = 1e18;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n\n vector u(M), v(M), w(M);\n vector> edge_idx(N, vector(N, -1));\n for (int i = 0; i < M; ++i) {\n cin >> u[i] >> v[i] >> w[i];\n u[i]--; v[i]--;\n edge_idx[u[i]][v[i]] = i;\n edge_idx[v[i]][u[i]] = i;\n }\n\n vector coord_x(N), coord_y(N);\n for (int i = 0; i < N; ++i) {\n cin >> coord_x[i] >> coord_y[i];\n }\n\n // midpoints of edges\n vector mid_x(M), mid_y(M);\n for (int i = 0; i < M; ++i) {\n mid_x[i] = (coord_x[u[i]] + coord_x[v[i]]) * 0.5;\n mid_y[i] = (coord_y[u[i]] + coord_y[v[i]]) * 0.5;\n }\n\n // adjacency list\n vector>> adj(N);\n for (int i = 0; i < M; ++i) {\n adj[u[i]].emplace_back(v[i], w[i]);\n adj[v[i]].emplace_back(u[i], w[i]);\n }\n\n // all-pairs shortest paths and parent selection\n vector> dist(N, vector(N, INF));\n vector> parent(N, vector(N, -1));\n\n for (int s = 0; s < N; ++s) {\n dist[s][s] = 0;\n priority_queue, vector>, greater<>> pq;\n pq.emplace(0, s);\n\n while (!pq.empty()) {\n auto [d, node] = pq.top();\n pq.pop();\n if (d != dist[s][node]) continue;\n for (auto [nbr, weight] : adj[node]) {\n ll nd = d + weight;\n if (nd < dist[s][nbr]) {\n dist[s][nbr] = nd;\n parent[s][nbr] = node;\n pq.emplace(nd, nbr);\n } else if (nd == dist[s][nbr] && node < parent[s][nbr]) {\n parent[s][nbr] = node;\n }\n }\n }\n }\n\n // criticality of each edge (cnt)\n vector cnt(M, 0);\n for (int s = 0; s < N; ++s) {\n // build shortest\u2011path tree from parent[s]\n vector> tree(N);\n for (int v = 0; v < N; ++v) {\n if (v == s) continue;\n int p = parent[s][v];\n int eidx = edge_idx[p][v];\n tree[p].push_back(v);\n tree[v].push_back(p);\n }\n\n // iterative DFS to get postorder\n vector order;\n vector visited(N, false);\n stack stk;\n stk.push(s);\n visited[s] = true;\n while (!stk.empty()) {\n int node = stk.top();\n stk.pop();\n order.push_back(node);\n for (int nbr : tree[node]) {\n if (!visited[nbr]) {\n visited[nbr] = true;\n stk.push(nbr);\n }\n }\n }\n\n // compute subtree sizes (using parent[s] to know children)\n vector sz(N, 0);\n for (int i = order.size() - 1; i >= 0; --i) {\n int node = order[i];\n sz[node] = 1;\n for (int nbr : tree[node]) {\n if (nbr == s) continue;\n if (parent[s][nbr] == node) {\n sz[node] += sz[nbr];\n }\n }\n }\n\n // add contributions\n for (int v = 0; v < N; ++v) {\n if (v == s) continue;\n int p = parent[s][v];\n int eidx = edge_idx[p][v];\n cnt[eidx] += sz[v];\n }\n }\n\n // assign edges to days\n vector day_assign(M, -1);\n vector day_sum(D, 0);\n vector day_cnt(D, 0);\n vector sum_mid_x(D, 0), sum_mid_y(D, 0);\n\n // order edges by decreasing criticality\n vector order_edges(M);\n iota(order_edges.begin(), order_edges.end(), 0);\n sort(order_edges.begin(), order_edges.end(),\n [&](int a, int b) { return cnt[a] > cnt[b]; });\n\n for (int e : order_edges) {\n // find minimum day_sum among days with free slots\n ll min_sum = INF;\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K) {\n min_sum = min(min_sum, day_sum[d]);\n }\n }\n\n // among those with min_sum, choose the one farthest from the edge\n int best_day = -1;\n double best_dist2 = -1.0;\n for (int d = 0; d < D; ++d) {\n if (day_cnt[d] < K && day_sum[d] == min_sum) {\n double dist2;\n if (day_cnt[d] == 0) {\n dist2 = 1e18; // prefer empty days\n } else {\n double avg_x = sum_mid_x[d] / day_cnt[d];\n double avg_y = sum_mid_y[d] / day_cnt[d];\n double dx = mid_x[e] - avg_x;\n double dy = mid_y[e] - avg_y;\n dist2 = dx * dx + dy * dy;\n }\n if (dist2 > best_dist2) {\n best_dist2 = dist2;\n best_day = d;\n }\n }\n }\n\n // assign\n day_assign[e] = best_day;\n day_sum[best_day] += cnt[e];\n day_cnt[best_day]++;\n sum_mid_x[best_day] += mid_x[e];\n sum_mid_y[best_day] += mid_y[e];\n }\n\n // output\n for (int i = 0; i < M; ++i) {\n cout << day_assign[i] + 1;\n if (i < M - 1) cout << ' ';\n }\n cout << '\\n';\n\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint D; // global, needed for canonical shape normalization\n\n// 24 rotation matrices\nvector, 3>> rotations;\n\n// generate all rotations (determinant = 1)\nvoid generate_rotations() {\n vector axes = {0, 1, 2};\n do {\n // sign of permutation\n int perm_sign = 1;\n if (axes[0] == 0 && axes[1] == 1 && axes[2] == 2) perm_sign = 1;\n else if (axes[0] == 0 && axes[1] == 2 && axes[2] == 1) perm_sign = -1;\n else if (axes[0] == 1 && axes[1] == 0 && axes[2] == 2) perm_sign = -1;\n else if (axes[0] == 1 && axes[1] == 2 && axes[2] == 0) perm_sign = 1;\n else if (axes[0] == 2 && axes[1] == 0 && axes[2] == 1) perm_sign = 1;\n else perm_sign = -1;\n\n for (int s0 : {-1, 1}) {\n for (int s1 : {-1, 1}) {\n // s2 determined by determinant = s0 * s1 * s2 * perm_sign = 1\n int s2 = (perm_sign * s0 * s1 == 1) ? 1 : -1;\n array, 3> mat{};\n mat[0][axes[0]] = s0;\n mat[1][axes[1]] = s1;\n mat[2][axes[2]] = s2;\n rotations.push_back(mat);\n }\n }\n } while (next_permutation(axes.begin(), axes.end()));\n}\n\nusing Point = array;\n\n// canonical shape of a block: normalized to min (0,0,0) and all rotations considered\nvector canonical_shape(const vector& cubes) {\n // find current min\n Point min = {D, D, D};\n for (auto& p : cubes) {\n for (int i = 0; i < 3; ++i) min[i] = min(min[i], p[i]);\n }\n vector rel;\n for (auto& p : cubes) {\n rel.push_back({p[0] - min[0], p[1] - min[1], p[2] - min[2]});\n }\n\n vector best = rel;\n sort(best.begin(), best.end());\n\n // try all rotations\n for (const auto& rot : rotations) {\n vector rotated;\n for (auto& p : rel) {\n Point np;\n for (int i = 0; i < 3; ++i) {\n np[i] = 0;\n for (int j = 0; j < 3; ++j) np[i] += rot[i][j] * p[j];\n }\n rotated.push_back(np);\n }\n // normalize after rotation\n Point minr = {D, D, D};\n for (auto& p : rotated) {\n for (int i = 0; i < 3; ++i) minr[i] = min(minr[i], p[i]);\n }\n vector norm;\n for (auto& p : rotated) {\n norm.push_back({p[0] - minr[0], p[1] - minr[1], p[2] - minr[2]});\n }\n sort(norm.begin(), norm.end());\n if (norm < best) best = norm;\n }\n return best;\n}\n\n// a connected component (block)\nstruct Component {\n vector cubes;\n int volume;\n vector canon; // canonical shape\n int block_id;\n bool used; // for matching\n};\n\n// generate minimal object from silhouette pair\nvector generate_object(const vector& f, const vector& r) {\n vector cubes;\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 // guaranteed non-empty per problem statement\n if (X.size() <= Y.size()) {\n // match each x to a distinct y\n for (size_t i = 0; i < X.size(); ++i) {\n cubes.push_back({X[i], Y[i], z});\n }\n // remaining y\n for (size_t i = X.size(); i < Y.size(); ++i) {\n cubes.push_back({X[0], Y[i], z});\n }\n } else {\n // match each y to a distinct x\n for (size_t i = 0; i < Y.size(); ++i) {\n cubes.push_back({X[i], Y[i], z});\n }\n // remaining x\n for (size_t i = Y.size(); i < X.size(); ++i) {\n cubes.push_back({X[i], Y[0], z});\n }\n }\n }\n return cubes;\n}\n\n// extract connected components from a set of cubes\nvector get_components(const vector& cubes) {\n // boolean grid\n vector>> grid(D, vector>(D, vector(D, false)));\n for (auto& p : cubes) grid[p[0]][p[1]][p[2]] = true;\n\n vector visited(D * D * D, false);\n vector comps;\n\n int dx[6] = {1, -1, 0, 0, 0, 0};\n int dy[6] = {0, 0, 1, -1, 0, 0};\n int dz[6] = {0, 0, 0, 0, 1, -1};\n\n for (auto& p : cubes) {\n int idx = p[0] * D * D + p[1] * D + p[2];\n if (!visited[idx]) {\n // BFS\n vector comp_cubes;\n queue q;\n q.push(p);\n visited[idx] = true;\n while (!q.empty()) {\n Point cur = q.front(); q.pop();\n comp_cubes.push_back(cur);\n for (int d = 0; d < 6; ++d) {\n int nx = cur[0] + dx[d], ny = cur[1] + dy[d], nz = cur[2] + dz[d];\n if (nx >= 0 && nx < D && ny >= 0 && ny < D && nz >= 0 && nz < D && grid[nx][ny][nz]) {\n int nidx = nx * D * D + ny * D + nz;\n if (!visited[nidx]) {\n visited[nidx] = true;\n q.push({nx, ny, nz});\n }\n }\n }\n }\n Component comp;\n comp.cubes = comp_cubes;\n comp.volume = comp_cubes.size();\n comp.canon = canonical_shape(comp_cubes);\n comp.used = false;\n comps.push_back(comp);\n }\n }\n return comps;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> D;\n\n // read silhouettes\n vector f0(D), r0(D), f1(D), r1(D);\n for (int i = 0; i < D; ++i) cin >> f0[i];\n for (int i = 0; i < D; ++i) cin >> r0[i];\n for (int i = 0; i < D; ++i) cin >> f1[i];\n for (int i = 0; i < D; ++i) cin >> r1[i];\n\n generate_rotations();\n\n // minimal objects\n vector obj0_cubes = generate_object(f0, r0);\n vector obj1_cubes = generate_object(f1, r1);\n\n // components for each object\n vector comp0 = get_components(obj0_cubes);\n vector comp1 = get_components(obj1_cubes);\n\n // sort by volume (largest first) to prioritize matching large blocks\n sort(comp0.begin(), comp0.end(),\n [](const Component& a, const Component& b) { return a.volume > b.volume; });\n sort(comp1.begin(), comp1.end(),\n [](const Component& a, const Component& b) { return a.volume > b.volume; });\n\n // map from canonical shape to list of indices in comp1\n map, vector> shape_to_idx1;\n for (size_t i = 0; i < comp1.size(); ++i) {\n shape_to_idx1[comp1[i].canon].push_back(i);\n }\n\n int block_id = 1;\n // match components with same shape\n for (size_t i = 0; i < comp0.size(); ++i) {\n auto it = shape_to_idx1.find(comp0[i].canon);\n if (it != shape_to_idx1.end() && !it->second.empty()) {\n int j = it->second.back();\n it->second.pop_back();\n comp0[i].block_id = block_id;\n comp1[j].block_id = block_id;\n comp0[i].used = true;\n comp1[j].used = true;\n ++block_id;\n }\n }\n\n // assign ids to unmatched components\n for (auto& comp : comp0) {\n if (!comp.used) comp.block_id = block_id++;\n }\n for (auto& comp : comp1) {\n if (!comp.used) comp.block_id = block_id++;\n }\n int n = block_id - 1;\n\n // build output arrays\n vector b0(D * D * D, 0), b1(D * D * D, 0);\n for (auto& comp : comp0) {\n for (auto& p : comp.cubes) {\n b0[p[0] * D * D + p[1] * D + p[2]] = comp.block_id;\n }\n }\n for (auto& comp : comp1) {\n for (auto& p : comp.cubes) {\n b1[p[0] * D * D + p[1] * D + p[2]] = comp.block_id;\n }\n }\n\n // output\n cout << n << '\\n';\n for (size_t i = 0; i < b0.size(); ++i) {\n if (i) cout << ' ';\n cout << b0[i];\n }\n cout << '\\n';\n for (size_t i = 0; i < b1.size(); ++i) {\n if (i) cout << ' ';\n cout << b1[i];\n }\n cout << '\\n';\n\n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long INF = 1e18;\nconst double EPS = 1e-9;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K;\n cin >> N >> M >> K;\n\n vector x(N), y(N);\n for (int i = 0; i < N; ++i) {\n cin >> x[i] >> y[i];\n }\n\n // Read edges and build distance matrix\n vector> distV(N, vector(N, INF));\n for (int i = 0; i < N; ++i) distV[i][i] = 0;\n\n vector> edges(M);\n map, int> edgeIndex; // (min(u,v), max(u,v)) -> edge index\n for (int j = 0; j < M; ++j) {\n int u, v;\n long long w;\n cin >> u >> v >> w;\n --u; --v;\n edges[j] = {u, v, w};\n if (u > v) swap(u, v);\n edgeIndex[{u, v}] = j;\n distV[u][v] = min(distV[u][v], w);\n distV[v][u] = min(distV[v][u], w);\n }\n\n // Floyd-Warshall with next matrix for path reconstruction\n vector> next(N, vector(N, -1));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (i != j && distV[i][j] < INF) {\n next[i][j] = j;\n }\n }\n }\n\n for (int k = 0; k < N; ++k) {\n for (int i = 0; i < N; ++i) {\n if (distV[i][k] == INF) continue;\n for (int j = 0; j < N; ++j) {\n if (distV[k][j] == INF) continue;\n if (distV[i][j] > distV[i][k] + distV[k][j]) {\n distV[i][j] = distV[i][k] + distV[k][j];\n next[i][j] = next[i][k];\n }\n }\n }\n }\n\n // Read residents\n vector a(K), b(K);\n for (int k = 0; k < K; ++k) {\n cin >> a[k] >> b[k];\n }\n\n // Distance from each vertex to each resident\n vector> distVtoR(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n double dx = x[i] - a[k];\n double dy = y[i] - b[k];\n distVtoR[i][k] = sqrt(dx*dx + dy*dy);\n }\n }\n\n // Initial assignment: each resident to nearest vertex\n vector assign(K);\n vector> residentList(N);\n for (int k = 0; k < K; ++k) {\n int best = 0;\n for (int i = 1; i < N; ++i) {\n if (distVtoR[i][k] < distVtoR[best][k] - EPS) {\n best = i;\n }\n }\n assign[k] = best;\n residentList[best].push_back(k);\n }\n\n // Compute initial P[i]\n vector P(N, 0);\n for (int i = 0; i < N; ++i) {\n if (residentList[i].empty()) {\n P[i] = 0;\n } else {\n double maxDist = 0;\n for (int k : residentList[i]) {\n maxDist = max(maxDist, distVtoR[i][k]);\n }\n P[i] = (int)ceil(maxDist);\n // Ensure not exceeding 5000 (though problem guarantees within 5000)\n if (P[i] > 5000) P[i] = 5000;\n }\n }\n\n // Compute initial sum of squares\n long long sumSq = 0;\n for (int i = 0; i < N; ++i) {\n sumSq += (long long)P[i] * P[i];\n }\n\n // Function to compute Steiner tree cost for a set of terminals\n auto computeSteinerCost = [&](const vector& T) -> long long {\n int n = T.size();\n if (n <= 1) return 0;\n vector inMST(n, false);\n vector minDist(n, INF);\n minDist[0] = 0;\n long long total = 0;\n for (int iter = 0; iter < n; ++iter) {\n int u = -1;\n for (int v = 0; v < n; ++v) {\n if (!inMST[v] && (u == -1 || minDist[v] < minDist[u])) {\n u = v;\n }\n }\n if (u == -1) break;\n inMST[u] = true;\n total += minDist[u];\n for (int v = 0; v < n; ++v) {\n if (!inMST[v]) {\n long long d = distV[T[u]][T[v]];\n if (d < minDist[v]) {\n minDist[v] = d;\n }\n }\n }\n }\n return total;\n };\n\n // Build initial T (vertex 0 + vertices with P>0)\n vector currentT;\n currentT.push_back(0);\n for (int i = 1; i < N; ++i) {\n if (P[i] > 0) {\n currentT.push_back(i);\n }\n }\n long long currentSteinerCost = computeSteinerCost(currentT);\n long long currentCost = sumSq + currentSteinerCost;\n\n // Local search\n int maxIter = 10000;\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution residentDist(0, K-1);\n\n for (int iter = 0; i < maxIter; ++iter) {\n int k = residentDist(gen);\n int i = assign[k];\n bool improved = false;\n for (int j = 0; j < N; ++j) {\n if (j == i) continue;\n\n // Simulate move\n int oldP_i = P[i], oldP_j = P[j];\n\n // Compute new lists without scanning entire list each time? We'll copy temporarily.\n vector newList_i, newList_j;\n for (int r : residentList[i]) {\n if (r != k) newList_i.push_back(r);\n }\n for (int r : residentList[j]) {\n newList_j.push_back(r);\n }\n newList_j.push_back(k);\n\n // Compute new P_i and P_j\n int newP_i = 0, newP_j = 0;\n if (!newList_i.empty()) {\n double maxDist = 0;\n for (int r : newList_i) {\n maxDist = max(maxDist, distVtoR[i][r]);\n }\n newP_i = (int)ceil(maxDist);\n if (newP_i > 5000) newP_i = 5000;\n }\n if (!newList_j.empty()) {\n double maxDist = 0;\n for (int r : newList_j) {\n maxDist = max(maxDist, distVtoR[j][r]);\n }\n newP_j = (int)ceil(maxDist);\n if (newP_j > 5000) newP_j = 5000;\n }\n\n long long newSumSq = sumSq - (long long)oldP_i*oldP_i - (long long)oldP_j*oldP_j\n + (long long)newP_i*newP_i + (long long)newP_j*newP_j;\n\n // Check if T changes\n vector newT = currentT;\n if (i != 0 && oldP_i > 0 && newP_i == 0) {\n // Remove i from newT\n newT.erase(remove(newT.begin(), newT.end(), i), newT.end());\n }\n if (j != 0 && oldP_j == 0 && newP_j > 0) {\n // Add j to newT\n newT.push_back(j);\n }\n\n long long newCost;\n if (newT == currentT) {\n newCost = newSumSq + currentSteinerCost;\n } else {\n long long newSteinerCost = computeSteinerCost(newT);\n newCost = newSumSq + newSteinerCost;\n if (newCost < currentCost - EPS) {\n // Accept move\n // Update structures\n sumSq = newSumSq;\n P[i] = newP_i;\n P[j] = newP_j;\n residentList[i] = newList_i;\n residentList[j] = newList_j;\n assign[k] = j;\n currentT = newT;\n currentSteinerCost = newSteinerCost;\n currentCost = newCost;\n improved = true;\n break;\n }\n }\n if (newCost < currentCost - EPS) {\n // Accept move\n sumSq = newSumSq;\n P[i] = newP_i;\n P[j] = newP_j;\n residentList[i] = newList_i;\n residentList[j] = newList_j;\n assign[k] = j;\n currentT = newT;\n currentCost = newCost;\n improved = true;\n break;\n }\n }\n // If no improvement, continue to next iteration\n }\n\n // Final T for output\n vector finalT;\n finalT.push_back(0);\n for (int i = 1; i < N; ++i) {\n if (P[i] > 0) {\n finalT.push_back(i);\n }\n }\n\n // Compute Steiner tree edges\n set onEdges;\n auto addPath = [&](int u, int v) {\n while (u != v) {\n int nxt = next[u][v];\n int a = u, b = nxt;\n if (a > b) swap(a, b);\n onEdges.insert(edgeIndex[{a, b}]);\n u = nxt;\n }\n };\n\n // Compute MST on metric closure of finalT\n int n = finalT.size();\n if (n > 1) {\n vector inMST(n, false);\n vector minDist(n, INF);\n vector parent(n, -1);\n minDist[0] = 0;\n for (int iter = 0; iter < n; ++iter) {\n int u = -1;\n for (int v = 0; v < n; ++v) {\n if (!inMST[v] && (u == -1 || minDist[v] < minDist[u])) {\n u = v;\n }\n }\n inMST[u] = true;\n for (int v = 0; v < n; ++v) {\n if (!inMST[v]) {\n long long d = distV[finalT[u]][finalT[v]];\n if (d < minDist[v]) {\n minDist[v] = d;\n parent[v] = u;\n }\n }\n }\n }\n // Reconstruct MST edges\n for (int v = 1; v < n; ++v) {\n int u = parent[v];\n if (u != -1) {\n addPath(finalT[u], finalT[v]);\n }\n }\n }\n\n // Output P[i]\n for (int i = 0; i < N; ++i) {\n cout << P[i];\n if (i < N-1) cout << \" \";\n }\n cout << \"\\n\";\n\n // Output B[j]\n for (int j = 0; j < M; ++j) {\n cout << (onEdges.count(j) ? 1 : 0);\n if (j < M-1) cout << \" \";\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconst int N = 30;\nconst int TOTAL = N * (N + 1) / 2; // 465\n\n// Convert (x,y) to index (row-major order)\nint to_index(int x, int y) {\n return x * (x + 1) / 2 + y;\n}\n\n// Convert index to (x,y)\npair to_coord(int idx) {\n int x = 0;\n while (idx >= x + 1) {\n idx -= (x + 1);\n x++;\n }\n return {x, idx};\n}\n\n// Directions: six neighbors as deltas (dx, dy)\nconst int dx[6] = {-1, -1, 0, 0, 1, 1};\nconst int dy[6] = {-1, 0, -1, 1, 0, 1};\n\n// Check if coordinates are valid\nbool valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y <= x;\n}\n\nint main() {\n // Read input\n vector ball(TOTAL);\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n int b;\n cin >> b;\n ball[to_index(x, y)] = b;\n }\n }\n\n // Create sorted list of all ball numbers\n vector sorted = ball;\n sort(sorted.begin(), sorted.end());\n\n // Target: row-major order with sorted numbers\n vector target(TOTAL);\n for (int i = 0; i < TOTAL; ++i) {\n target[i] = sorted[i];\n }\n\n // Precompute adjacency list\n vector> adj(TOTAL);\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n int u = to_index(x, y);\n for (int d = 0; d < 6; ++d) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (valid(nx, ny)) {\n int v = to_index(nx, ny);\n adj[u].push_back(v);\n }\n }\n }\n }\n\n // Current position of each ball (by number)\n vector pos(TOTAL);\n for (int i = 0; i < TOTAL; ++i) {\n pos[ball[i]] = i;\n }\n\n vector fixed(TOTAL, false);\n vector> swaps; // (x1,y1,x2,y2)\n\n // Helper to perform a swap between two adjacent positions\n auto do_swap = [&](int i, int j) {\n // Record the swap\n auto [x1, y1] = to_coord(i);\n auto [x2, y2] = to_coord(j);\n swaps.emplace_back(x1, y1, x2, y2);\n // Update ball and pos arrays\n int b1 = ball[i], b2 = ball[j];\n swap(ball[i], ball[j]);\n pos[b1] = j;\n pos[b2] = i;\n };\n\n // BFS to find shortest path from src to dest avoiding fixed nodes (except dest)\n auto bfs = [&](int src, int dest, const vector& fixed) -> vector {\n vector parent(TOTAL, -1);\n vector visited(TOTAL, false);\n queue q;\n q.push(src);\n visited[src] = true;\n while (!q.empty()) {\n int u = q.front(); q.pop();\n if (u == dest) break;\n for (int v : adj[u]) {\n if (!visited[v] && (v == dest || !fixed[v])) {\n visited[v] = true;\n parent[v] = u;\n q.push(v);\n }\n }\n }\n if (parent[dest] == -1) return {}; // no path\n vector path;\n for (int cur = dest; cur != -1; cur = parent[cur]) {\n path.push_back(cur);\n }\n reverse(path.begin(), path.end());\n return path;\n };\n\n // Process positions in row-major order\n for (int i = 0; i < TOTAL; ++i) {\n if (fixed[i]) continue;\n if (ball[i] == target[i]) {\n fixed[i] = true;\n continue;\n }\n int want = target[i];\n int src = pos[want];\n if (src == i) {\n fixed[i] = true;\n continue;\n }\n // Find path from src to i avoiding fixed nodes (except i)\n vector path = bfs(src, i, fixed);\n // In case no path found, we try to relax by allowing fixed nodes temporarily?\n // For safety, if no path, we simply skip? But should not happen.\n if (path.empty()) {\n // Fallback: just swap directly if adjacent? Not necessarily.\n // We'll try to find any path without avoiding fixed, but that might disturb fixed.\n // Instead, we can try to find a path that goes through fixed but then we need to re-fix them.\n // To keep it simple, we assume a path always exists (should be true for connected graph).\n // If not, we break.\n continue;\n }\n // Perform swaps along the path\n for (size_t k = 0; k + 1 < path.size(); ++k) {\n do_swap(path[k], path[k + 1]);\n }\n // Now i should have the correct ball\n fixed[i] = true;\n // Note: intermediate positions along the path are not fixed, so we leave them.\n }\n\n // Output\n cout << swaps.size() << endl;\n for (auto [x1, y1, x2, y2] : swaps) {\n cout << x1 << \" \" << y1 << \" \" << x2 << \" \" << y2 << endl;\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nconst int D = 9;\nconst int entrance_i = 0, entrance_j = 4;\n\nint main() {\n int N;\n cin >> D >> N; // D is always 9, but read anyway\n bool obstacle[D][D] = {false};\n for (int k = 0; k < N; ++k) {\n int ri, rj;\n cin >> ri >> rj;\n obstacle[ri][rj] = true;\n }\n\n int M = D * D - 1 - N; // number of containers\n\n bool occupied[D][D] = {false};\n int label_of[D][D];\n int parent_i[D][D], parent_j[D][D];\n vector> children[D][D];\n\n vector seen_labels;\n\n // process containers one by one\n for (int d = 0; d < M; ++d) {\n int t;\n cin >> t;\n\n // BFS from entrance through empty squares\n int dist[D][D];\n memset(dist, -1, sizeof(dist));\n pair bfs_parent[D][D];\n queue> q;\n dist[entrance_i][entrance_j] = 0;\n q.push({entrance_i, entrance_j});\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n const int di[4] = {1, -1, 0, 0};\n const int dj[4] = {0, 0, 1, -1};\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni >= 0 && ni < D && nj >= 0 && nj < D &&\n !obstacle[ni][nj] && !occupied[ni][nj] && dist[ni][nj] == -1) {\n dist[ni][nj] = dist[i][j] + 1;\n bfs_parent[ni][nj] = {i, j};\n q.push({ni, nj});\n }\n }\n }\n\n // collect leaves (empty squares with exactly one empty neighbor)\n vector> leaves; // (distance, i, j)\n const int di[4] = {1, -1, 0, 0};\n const int dj[4] = {0, 0, 1, -1};\n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n if (i == entrance_i && j == entrance_j) continue;\n if (dist[i][j] == -1) continue;\n int empty_neighbors = 0;\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni >= 0 && ni < D && nj >= 0 && nj < D &&\n !obstacle[ni][nj] && !occupied[ni][nj]) {\n empty_neighbors++;\n }\n }\n if (empty_neighbors == 1) {\n leaves.push_back({dist[i][j], i, j});\n }\n }\n }\n\n // sort leaves by distance (closest first)\n sort(leaves.begin(), leaves.end());\n\n // compute quantile of current label among seen labels\n double quantile;\n if (seen_labels.empty()) {\n quantile = 0.0;\n } else {\n int count_smaller = 0;\n for (int lbl : seen_labels) {\n if (lbl < t) count_smaller++;\n }\n quantile = (double)count_smaller / seen_labels.size();\n }\n\n // choose leaf according to quantile\n int L = leaves.size();\n int idx = (int)round(quantile * (L - 1));\n idx = max(0, min(L - 1, idx));\n auto [dist_val, pi, pj] = leaves[idx];\n\n // output placement\n cout << pi << \" \" << pj << endl;\n\n // record placement\n occupied[pi][pj] = true;\n label_of[pi][pj] = t;\n parent_i[pi][pj] = bfs_parent[pi][pj].first;\n parent_j[pi][pj] = bfs_parent[pi][pj].second;\n children[parent_i[pi][pj]][parent_j[pi][pj]].push_back({pi, pj});\n\n seen_labels.push_back(t);\n }\n\n // determine and output transport order\n priority_queue>,\n vector>>,\n greater<>> pq;\n bool removed[D][D] = {false};\n\n // initially, containers whose parent is the entrance are removable\n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n if (occupied[i][j] && parent_i[i][j] == entrance_i && parent_j[i][j] == entrance_j) {\n pq.push({label_of[i][j], {i, j}});\n }\n }\n }\n\n while (!pq.empty()) {\n auto [lbl, coords] = pq.top(); pq.pop();\n int i = coords.first, j = coords.second;\n cout << i << \" \" << j << endl;\n removed[i][j] = true;\n\n // children of the removed container become removable\n for (auto child : children[i][j]) {\n int ci = child.first, cj = child.second;\n pq.push({label_of[ci][cj], {ci, cj}});\n }\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nconst int N = 50;\nconst int M = 100;\n\nstruct Point {\n int x, y;\n Point(int x=0, int y=0) : x(x), y(y) {}\n bool operator<(const Point& p) const {\n return x < p.x || (x == p.x && y < p.y);\n }\n bool operator==(const Point& p) const {\n return x == p.x && y == p.y;\n }\n};\n\n// BFS to find shortest path between two sets in a graph defined by allowed cells\nvector bfs_path(const vector>& allowed, \n const set& start_set, \n const set& end_set,\n int n) {\n vector> visited(n, vector(n, false));\n vector> prev(n, vector(n, Point(-1, -1)));\n queue q;\n \n for (const Point& p : start_set) {\n visited[p.x][p.y] = true;\n q.push(p);\n }\n \n const int dx[] = {0, 0, 1, -1};\n const int dy[] = {1, -1, 0, 0};\n \n while (!q.empty()) {\n Point cur = q.front();\n q.pop();\n \n if (end_set.count(cur)) {\n // Reconstruct path\n vector path;\n Point at = cur;\n while (!(at.x == -1 && at.y == -1)) {\n path.push_back(at);\n at = prev[at.x][at.y];\n }\n reverse(path.begin(), path.end());\n return path;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = cur.x + dx[d];\n int ny = cur.y + dy[d];\n if (nx >= 0 && nx < n && ny >= 0 && ny < n && allowed[nx][ny] && !visited[nx][ny]) {\n visited[nx][ny] = true;\n prev[nx][ny] = cur;\n q.push(Point(nx, ny));\n }\n }\n }\n return {}; // No path found\n}\n\n// Check if removing a point disconnects a set of points\nbool is_articulation(const set& region, const Point& p, int n) {\n if (!region.count(p)) return false;\n \n set remaining = region;\n remaining.erase(p);\n \n if (remaining.empty()) return false;\n \n // Find first point in remaining\n Point start = *remaining.begin();\n set component;\n queue q;\n q.push(start);\n component.insert(start);\n \n const int dx[] = {0, 0, 1, -1};\n const int dy[] = {1, -1, 0, 0};\n \n while (!q.empty()) {\n Point cur = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = cur.x + dx[d];\n int ny = cur.y + dy[d];\n Point np(nx, ny);\n if (remaining.count(np) && !component.count(np)) {\n component.insert(np);\n q.push(np);\n }\n }\n }\n \n return component.size() != remaining.size();\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n = N, m = M;\n vector> grid(n, vector(n));\n \n // Read input\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n \n // Build adjacency information\n vector> adj_colors(m + 1); // neighbors for each color\n // For each unordered pair (c,d), store a list of adjacent cell pairs\n vector>>> adj_pairs(m + 1, vector>>(m + 1));\n \n const int dx[] = {0, 0, 1, -1};\n const int dy[] = {1, -1, 0, 0};\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d];\n int nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int color = grid[ni][nj];\n if (color != c) {\n // Ensure c < color for consistent ordering\n if (c < color) {\n adj_colors[c].insert(color);\n adj_colors[color].insert(c);\n adj_pairs[c][color].push_back({Point(i, j), Point(ni, nj)});\n } else if (c > color) {\n adj_colors[color].insert(c);\n adj_colors[c].insert(color);\n adj_pairs[color][c].push_back({Point(ni, nj), Point(i, j)});\n }\n }\n }\n }\n }\n }\n \n // Anchor selection: for each edge (c,d), choose one pair\n vector> anchors(m + 1);\n \n for (int c = 1; c <= m; c++) {\n for (int d : adj_colors[c]) {\n if (c >= d) continue; // process each edge once\n \n // Check if we already have an adjacent pair in anchors\n bool already_adjacent = false;\n for (const Point& p1 : anchors[c]) {\n for (int dir = 0; dir < 4; dir++) {\n Point p2(p1.x + dx[dir], p1.y + dy[dir]);\n if (anchors[d].count(p2)) {\n already_adjacent = true;\n break;\n }\n }\n if (already_adjacent) break;\n }\n if (already_adjacent) continue;\n \n // Try to find a pair that uses existing anchors\n bool found = false;\n for (auto& pr : adj_pairs[c][d]) {\n Point u = pr.first, v = pr.second;\n if (anchors[c].count(u)) {\n anchors[d].insert(v);\n found = true;\n break;\n } else if (anchors[d].count(v)) {\n anchors[c].insert(u);\n found = true;\n break;\n }\n }\n if (!found && !adj_pairs[c][d].empty()) {\n // Add both cells\n Point u = adj_pairs[c][d][0].first;\n Point v = adj_pairs[c][d][0].second;\n anchors[c].insert(u);\n anchors[d].insert(v);\n }\n }\n }\n \n // For colors with no anchors, add an arbitrary cell\n for (int c = 1; c <= m; c++) {\n if (anchors[c].empty()) {\n // Find any cell of this color\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (grid[i][j] == c) {\n anchors[c].insert(Point(i, j));\n break;\n }\n }\n if (!anchors[c].empty()) break;\n }\n }\n }\n \n // Build Steiner trees for each color\n vector> kept(m + 1); // kept cells for each color\n \n for (int c = 1; c <= m; c++) {\n // Create allowed matrix for this color\n vector> allowed(n, vector(n, false));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (grid[i][j] == c) {\n allowed[i][j] = true;\n }\n }\n }\n \n set terminals = anchors[c];\n set current = terminals;\n \n // Connect components iteratively\n while (true) {\n // Find connected components of current\n vector> components;\n set visited;\n \n for (const Point& p : current) {\n if (visited.count(p)) continue;\n \n set comp;\n queue q;\n q.push(p);\n comp.insert(p);\n visited.insert(p);\n \n while (!q.empty()) {\n Point cur = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n Point np(cur.x + dx[d], cur.y + dy[d]);\n if (np.x >= 0 && np.x < n && np.y >= 0 && np.y < n && \n allowed[np.x][np.y] && current.count(np) && !visited.count(np)) {\n comp.insert(np);\n visited.insert(np);\n q.push(np);\n }\n }\n }\n components.push_back(comp);\n }\n \n if (components.size() <= 1) break;\n \n // Connect first two components\n set comp1 = components[0], comp2 = components[1];\n vector path = bfs_path(allowed, comp1, comp2, n);\n \n if (!path.empty()) {\n for (const Point& p : path) {\n current.insert(p);\n }\n } else {\n // Should not happen since graph is connected\n break;\n }\n }\n \n // Prune leaves that are not terminals\n set tree = current;\n bool changed = true;\n while (changed) {\n changed = false;\n vector to_remove;\n for (const Point& p : tree) {\n if (terminals.count(p)) continue;\n \n int deg = 0;\n for (int d = 0; d < 4; d++) {\n Point np(p.x + dx[d], p.y + dy[d]);\n if (tree.count(np)) deg++;\n }\n if (deg <= 1) {\n to_remove.push_back(p);\n }\n }\n \n for (const Point& p : to_remove) {\n tree.erase(p);\n changed = true;\n }\n }\n \n kept[c] = tree;\n }\n \n // Build output grid\n vector> output(n, vector(n, 0));\n for (int c = 1; c <= m; c++) {\n for (const Point& p : kept[c]) {\n output[p.x][p.y] = c;\n }\n }\n \n // Check connectivity of 0\n vector> visited0(n, vector(n, false));\n queue q0;\n \n // Start from boundary 0 cells (connected to outside)\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if ((i == 0 || i == n-1 || j == 0 || j == n-1) && output[i][j] == 0) {\n q0.push(Point(i, j));\n visited0[i][j] = true;\n }\n }\n }\n \n while (!q0.empty()) {\n Point cur = q0.front();\n q0.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = cur.x + dx[d];\n int ny = cur.y + dy[d];\n if (nx >= 0 && nx < n && ny >= 0 && ny < n && \n output[nx][ny] == 0 && !visited0[nx][ny]) {\n visited0[nx][ny] = true;\n q0.push(Point(nx, ny));\n }\n }\n }\n \n // If there are unvisited 0 cells, try to fix\n bool disconnected = false;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (output[i][j] == 0 && !visited0[i][j]) {\n disconnected = true;\n break;\n }\n }\n if (disconnected) break;\n }\n \n if (disconnected) {\n // Try to remove some non-zero cells to connect 0\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (output[i][j] != 0 && !visited0[i][j]) {\n int c = output[i][j];\n Point p(i, j);\n \n // Check if this cell can be removed\n bool can_remove = true;\n \n // Check if it's a leaf in its tree and not a terminal\n if (kept[c].count(p)) {\n int deg = 0;\n for (int d = 0; d < 4; d++) {\n Point np(i + dx[d], j + dy[d]);\n if (kept[c].count(np)) deg++;\n }\n if (deg > 1) can_remove = false;\n \n // Check if it's the only anchor for some neighbor\n for (int d : adj_colors[c]) {\n if (d == 0) continue;\n bool has_other = false;\n for (const Point& q : kept[c]) {\n if (q == p) continue;\n for (int dir = 0; dir < 4; dir++) {\n Point nq(q.x + dx[dir], q.y + dy[dir]);\n if (nq.x >= 0 && nq.x < n && nq.y >= 0 && nq.y < n && \n output[nq.x][nq.y] == d) {\n has_other = true;\n break;\n }\n }\n if (has_other) break;\n }\n if (!has_other) {\n can_remove = false;\n break;\n }\n }\n } else {\n can_remove = false;\n }\n \n if (can_remove) {\n // Change to 0 and update\n output[i][j] = 0;\n kept[c].erase(p);\n \n // Re-run BFS for 0 connectivity\n fill(visited0.begin(), visited0.end(), vector(n, false));\n queue q0;\n for (int ii = 0; ii < n; ii++) {\n for (int jj = 0; jj < n; jj++) {\n if ((ii == 0 || ii == n-1 || jj == 0 || jj == n-1) && output[ii][jj] == 0) {\n q0.push(Point(ii, jj));\n visited0[ii][jj] = true;\n }\n }\n }\n while (!q0.empty()) {\n Point cur = q0.front();\n q0.pop();\n for (int d = 0; d < 4; d++) {\n int nx = cur.x + dx[d];\n int ny = cur.y + dy[d];\n if (nx >= 0 && nx < n && ny >= 0 && ny < n && \n output[nx][ny] == 0 && !visited0[nx][ny]) {\n visited0[nx][ny] = true;\n q0.push(Point(nx, ny));\n }\n }\n }\n \n // Check if still disconnected\n disconnected = false;\n for (int ii = 0; ii < n; ii++) {\n for (int jj = 0; jj < n; jj++) {\n if (output[ii][jj] == 0 && !visited0[ii][jj]) {\n disconnected = true;\n break;\n }\n }\n if (disconnected) break;\n }\n if (!disconnected) break;\n }\n }\n }\n if (!disconnected) break;\n }\n }\n \n // Output result\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cout << output[i][j];\n if (j < n-1) cout << \" \";\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint N, D, Q;\nint queries_used = 0;\n\n// perform a query with given left and right sets, return the comparison result\nchar query(const vector& L, const vector& R) {\n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << endl;\n string s;\n cin >> s;\n queries_used++;\n return s[0];\n}\n\n// compare two individual items\nchar compare(int i, int j) {\n return query({i}, {j});\n}\n\nint main() {\n cin >> N >> D >> Q;\n vector items; // sorted order as much as we know\n\n // Insert items one by one using binary search with comparisons\n for (int i = 0; i < N; ++i) {\n if (queries_used >= Q) {\n // no queries left, just append\n items.push_back(i);\n continue;\n }\n int left = 0, right = items.size();\n while (left < right && queries_used < Q) {\n int mid = (left + right) / 2;\n char res = compare(i, items[mid]);\n if (res == '<') {\n right = mid;\n } else {\n left = mid + 1;\n }\n }\n items.insert(items.begin() + left, i);\n }\n\n // Use any remaining queries (dummy comparisons)\n while (queries_used < Q) {\n compare(0, 1); // always valid as N >= 2\n }\n\n // Assign items to buckets in snake order according to the (partially) sorted list\n vector ans(N);\n for (int i = 0; i < N; ++i) {\n int item = items[i];\n int bucket = i % D;\n if ((i / D) % 2 == 1) {\n bucket = D - 1 - bucket;\n }\n ans[item] = bucket;\n }\n\n // Output the final division\n for (int i = 0; i < N; ++i) {\n if (i > 0) cout << \" \";\n cout << ans[i];\n }\n cout << endl;\n\n return 0;\n}","ahc026":"#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n, m;\n cin >> n >> m;\n int h = n / m;\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) {\n cin >> stacks[i][j];\n }\n }\n\n for (int v = 1; v <= n; ++v) {\n // Find the stack and position of box v\n int s = -1, pos = -1;\n for (int i = 0; i < m; ++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 if (s != -1) break;\n }\n\n if (pos == (int)stacks[s].size() - 1) {\n // v is already on top: remove it\n cout << v << \" 0\\n\";\n stacks[s].pop_back();\n } else {\n // Need to move the boxes above v\n int T = stacks[s].back(); // top of the group to be moved\n // Choose destination stack d according to the heuristic\n int d = -1;\n bool found_empty = false;\n int empty_d = -1;\n int best_d = -1;\n int best_top = -1;\n\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n if (stacks[i].empty()) {\n found_empty = true;\n if (empty_d == -1) empty_d = i;\n } else {\n int top = stacks[i].back();\n if (top > best_top) {\n best_top = top;\n best_d = i;\n }\n }\n }\n\n if (found_empty) {\n if (best_d == -1 || T > best_top) {\n d = empty_d;\n } else {\n d = best_d;\n }\n } else {\n d = best_d;\n }\n\n // Move the suffix starting at the box just above v\n int w = stacks[s][pos + 1];\n cout << w << \" \" << d + 1 << \"\\n\";\n\n vector suffix(stacks[s].begin() + pos + 1, stacks[s].end());\n stacks[s].erase(stacks[s].begin() + pos + 1, stacks[s].end());\n stacks[d].insert(stacks[d].end(), suffix.begin(), suffix.end());\n\n // Now v is on top, remove it\n cout << v << \" 0\\n\";\n stacks[s].pop_back();\n }\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nconst int dx[] = {1, -1, 0, 0}; // D, U, R, L\nconst int dy[] = {0, 0, 1, -1};\nconst char dir_char[] = {'D', 'U', 'R', 'L'};\n\nstruct Cell {\n int i, j, id;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n\n vector h(N-1), v(N);\n for (int i = 0; i < N-1; ++i) cin >> h[i];\n for (int i = 0; i < N; ++i) cin >> v[i];\n\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n cin >> d[i][j];\n\n // assign ids\n vector> id(N, vector(N));\n vector cells(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 id[i][j] = idx;\n cells[idx] = {i, j, idx};\n }\n\n // build graph with directions\n vector>> graph(N*N);\n auto add_edge = [&](int i1, int j1, int i2, int j2, char dir) {\n int u = id[i1][j1], v = id[i2][j2];\n graph[u].emplace_back(v, dir);\n graph[v].emplace_back(u, dir_char[(string(\"DURL\").find(dir) + 2) % 4]); // opposite direction\n };\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n // down\n if (i+1 < N && h[i][j] == '0') add_edge(i, j, i+1, j, 'D');\n // right\n if (j+1 < N && v[i][j] == '0') add_edge(i, j, i, j+1, 'R');\n }\n }\n\n // target frequencies f_v = round(sqrt(d))\n vector f(N*N);\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n f[id[i][j]] = max(1, (int)round(sqrt(d[i][j])));\n\n // BFS to get spanning tree\n vector parent(N*N, -1);\n vector parent_dir(N*N);\n vector> children(N*N);\n queue q;\n q.push(0);\n parent[0] = -2; // root\n while (!q.empty()) {\n int u = q.front(); q.pop();\n int ui = cells[u].i, uj = cells[u].j;\n for (auto [v, dir] : graph[u]) {\n if (parent[v] == -1) {\n parent[v] = u;\n parent_dir[v] = dir;\n children[u].push_back(v);\n q.push(v);\n }\n }\n }\n\n // compute current degree in tree\n vector deg_cur(N*N, 0);\n for (int v = 1; v < N*N; ++v) {\n deg_cur[v]++; // edge to parent\n deg_cur[parent[v]]++;\n }\n\n // adjust f if needed to satisfy 2*f >= deg_cur\n for (int v = 0; v < N*N; ++v) {\n while (2 * f[v] < deg_cur[v]) {\n f[v]++;\n }\n }\n\n // compute deficit\n vector deficit(N*N);\n for (int v = 0; v < N*N; ++v) {\n deficit[v] = 2 * f[v] - deg_cur[v];\n }\n\n // post-order traversal to compute extra multiplicities on tree edges\n vector extra(N*N, 0); // extra copies on edge from child to parent\n function dfs = [&](int u) {\n for (int v : children[u]) {\n dfs(v);\n extra[v] = deficit[v];\n deficit[u] += deficit[v];\n deficit[v] = 0;\n }\n };\n dfs(0);\n\n // adjust root if necessary\n if (deficit[0] != 0) {\n f[0] += deficit[0] / 2;\n deficit[0] = 0;\n }\n\n // build multigraph with multiplicities\n vector>> multigraph(N*N); // neighbor, multiplicity\n vector> move_dir(N*N); // direction char from this vertex to neighbor (parallel to multigraph)\n // initialize with tree edges\n for (int v = 1; v < N*N; ++v) {\n int u = parent[v];\n int mul = 1 + extra[v];\n if (mul > 0) {\n multigraph[u].emplace_back(v, mul);\n multigraph[v].emplace_back(u, mul);\n // store directions: from u to v is parent_dir[v], from v to u is opposite\n char dir_uv = parent_dir[v];\n char dir_vu = dir_char[(string(\"DURL\").find(dir_uv) + 2) % 4];\n // We'll store direction when traversing from u to v or v to u. We'll handle during tour.\n }\n }\n\n // For Eulerian tour, we need to store the direction for each edge in both directions.\n // We'll create separate adjacency lists for the multigraph that include direction.\n struct Edge {\n int to;\n int mul;\n char dir; // direction from current vertex to 'to'\n };\n vector> euler_adj(N*N);\n for (int v = 1; v < N*N; ++v) {\n int u = parent[v];\n int mul = 1 + extra[v];\n char dir_uv = parent_dir[v];\n char dir_vu = dir_char[(string(\"DURL\").find(dir_uv) + 2) % 4];\n euler_adj[u].push_back({v, mul, dir_uv});\n euler_adj[v].push_back({u, mul, dir_vu});\n }\n\n // Hierholzer's algorithm\n vector circuit;\n vector ptr(N*N, 0);\n stack stk;\n stk.push(0);\n while (!stk.empty()) {\n int u = stk.top();\n if (ptr[u] < (int)euler_adj[u].size()) {\n Edge &e = euler_adj[u][ptr[u]];\n if (e.mul > 0) {\n // traverse edge\n e.mul--;\n // find the reverse edge and decrement\n for (Edge &rev : euler_adj[e.to]) {\n if (rev.to == u && rev.mul > 0) {\n rev.mul--;\n break;\n }\n }\n stk.push(e.to);\n } else {\n ptr[u]++;\n }\n } else {\n circuit.push_back(u);\n stk.pop();\n }\n }\n reverse(circuit.begin(), circuit.end());\n\n // Build move string\n string moves;\n for (size_t i = 0; i + 1 < circuit.size(); ++i) {\n int u = circuit[i], v = circuit[i+1];\n // find direction from u to v\n for (const Edge &e : euler_adj[u]) {\n if (e.to == v) {\n moves += e.dir;\n break;\n }\n }\n }\n\n cout << moves << endl;\n\n return 0;\n}","ahc028":"#include \nusing namespace std;\n\ntypedef pair pii;\n\nstruct Candidate {\n vector pos; // 5 positions\n int internal_cost; // cost to type this occurrence from scratch\n vector tail_cost; // tail_cost[k]: cost from position k to end (including letter at k)\n};\n\nint manhattan(const pii& a, const pii& b) {\n return abs(a.first - b.first) + abs(a.second - b.second);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N >> M;\n pii start;\n cin >> start.first >> start.second;\n\n vector> A(N, vector(N));\n vector> pos_list(26); // positions for each letter\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> A[i][j];\n pos_list[A[i][j] - 'A'].emplace_back(i, j);\n }\n }\n\n vector targets(M);\n for (int i = 0; i < M; ++i) {\n cin >> targets[i];\n }\n\n // Random number generator\n mt19937 rng(123456); // fixed seed for reproducibility\n uniform_int_distribution dist;\n\n const int CANDIDATE_COUNT = 100;\n const int KEEP = 10;\n\n vector> candidates(M);\n\n // Generate candidate occurrences for each target\n for (int idx = 0; idx < M; ++idx) {\n const string& t = targets[idx];\n vector cands;\n for (int iter = 0; iter < CANDIDATE_COUNT; ++iter) {\n vector pos(5);\n for (int k = 0; k < 5; ++k) {\n char ch = t[k];\n const auto& lst = pos_list[ch - 'A'];\n uniform_int_distribution d(0, (int)lst.size() - 1);\n pos[k] = lst[d(rng)];\n }\n\n // Compute internal cost\n int internal = 5; // cost for typing the letters themselves\n for (int k = 0; k < 4; ++k) {\n internal += manhattan(pos[k], pos[k + 1]);\n }\n\n // Compute tail costs\n vector tail(5);\n tail[4] = 1; // cost to type the last letter\n for (int k = 3; k >= 0; --k) {\n tail[k] = 1 + manhattan(pos[k], pos[k + 1]) + tail[k + 1];\n }\n\n cands.push_back({pos, internal, tail});\n }\n\n // Keep the best KEEP candidates by internal cost\n sort(cands.begin(), cands.end(),\n [](const Candidate& a, const Candidate& b) { return a.internal_cost < b.internal_cost; });\n if (cands.size() > KEEP) cands.resize(KEEP);\n candidates[idx] = cands;\n }\n\n // Precompute valid overlaps between targets\n vector>> valid(M, vector>(M));\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < M; ++j) {\n const string& si = targets[i];\n const string& sj = targets[j];\n vector v;\n for (int k = 1; k <= 4; ++k) {\n if (si.substr(5 - k) == sj.substr(0, k)) {\n v.push_back(k);\n }\n }\n v.push_back(0); // k=0 always allowed\n valid[i][j] = v;\n }\n }\n\n // Greedy construction of the path\n vector order_targets;\n vector order_candidate_idx;\n vector order_overlap; // overlap used to reach this target (for i>0)\n vector covered(M, false);\n\n pii cur_pos = start;\n int cur_target = -1; // index of the last target in the current path\n\n for (int step = 0; step < M; ++step) {\n double best_add = 1e18;\n int best_j = -1, best_c = -1, best_k = -1;\n\n for (int j = 0; j < M; ++j) {\n if (covered[j]) continue;\n for (size_t c = 0; c < candidates[j].size(); ++c) {\n const Candidate& cand = candidates[j][c];\n if (cur_target == -1) {\n // First target: cost from start to first position + internal cost\n int add = manhattan(cur_pos, cand.pos[0]) + cand.internal_cost;\n if (add < best_add) {\n best_add = add;\n best_j = j;\n best_c = c;\n best_k = 0; // not used\n }\n } else {\n // Consider all valid overlaps\n for (int k : valid[cur_target][j]) {\n int add = manhattan(cur_pos, cand.pos[k]) + cand.tail_cost[k];\n if (add < best_add) {\n best_add = add;\n best_j = j;\n best_c = c;\n best_k = k;\n }\n }\n }\n }\n }\n\n // Append the chosen target\n covered[best_j] = true;\n order_targets.push_back(best_j);\n order_candidate_idx.push_back(best_c);\n if (cur_target != -1) {\n order_overlap.push_back(best_k);\n }\n\n // Update current state\n cur_target = best_j;\n cur_pos = candidates[best_j][best_c].pos[4]; // last position of the occurrence\n }\n\n // Build the output sequence of moves\n vector moves;\n for (size_t i = 0; i < order_targets.size(); ++i) {\n const Candidate& occ = candidates[order_targets[i]][order_candidate_idx[i]];\n if (i == 0) {\n for (int j = 0; j < 5; ++j) {\n moves.push_back(occ.pos[j]);\n }\n } else {\n int k = order_overlap[i];\n for (int j = k; j < 5; ++j) {\n moves.push_back(occ.pos[j]);\n }\n }\n }\n\n // Output the moves\n for (const pii& p : moves) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc030":"#include \n#include \n#include \nusing namespace std;\n\nint main() {\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n \n // Read oil field shapes (not used in this simple solution)\n for (int k = 0; k < M; ++k) {\n int d;\n cin >> d;\n for (int i = 0; i < d; ++i) {\n int x, y;\n cin >> x >> y;\n }\n }\n \n vector> oil_cells;\n \n // Drill every square\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cout << \"q 1 \" << i << \" \" << j << endl;\n int val;\n cin >> val;\n if (val > 0) {\n oil_cells.push_back({i, j});\n }\n }\n }\n \n // Output the guess\n cout << \"a \" << oil_cells.size();\n for (auto [i, j] : oil_cells) {\n cout << \" \" << i << \" \" << j;\n }\n cout << endl;\n \n // Read response (should be 1)\n int resp;\n cin >> resp;\n // If response is 0, we could try again, but drilling all should be correct.\n // For safety, if resp == 0, we could drill again? But problem says operation ends if correct.\n // We'll just exit.\n \n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nconst int W = 1000;\n\nstruct Rect {\n int x1, y1, x2, y2;\n int area() const { return (x2 - x1) * (y2 - y1); }\n};\n\n// Greedy allocation of target areas B_k\nvector allocateB(const vector>& A, int D, int N) {\n vector B(N, 0);\n long long total_remaining = (long long)W * W;\n // For each k, collect desires and sort\n vector> sortedA(N);\n for (int k = 0; k < N; ++k) {\n for (int d = 0; d < D; ++d) {\n sortedA[k].push_back(A[d][k]);\n }\n sort(sortedA[k].begin(), sortedA[k].end());\n }\n // Create segments: each (benefit, length, k)\n struct Segment {\n int benefit, len, k;\n bool operator<(const Segment& other) const {\n return benefit < other.benefit; // max-heap\n }\n };\n vector segments;\n for (int k = 0; k < N; ++k) {\n int prev = 0;\n for (size_t i = 0; i < sortedA[k].size(); ++i) {\n int cur = sortedA[k][i];\n if (cur > prev) {\n int benefit = 100 * (D - i);\n int len = cur - prev;\n segments.push_back({benefit, len, k});\n }\n prev = cur;\n }\n // After the last desire, benefit becomes 0, ignore.\n }\n priority_queue pq(segments.begin(), segments.end());\n while (total_remaining > 0 && !pq.empty()) {\n Segment seg = pq.top(); pq.pop();\n if (seg.benefit == 0) break;\n long long take = min((long long)seg.len, total_remaining);\n B[seg.k] += take;\n total_remaining -= take;\n seg.len -= take;\n if (seg.len > 0) {\n pq.push(seg);\n }\n }\n // Distribute remaining area arbitrarily (benefit 0)\n if (total_remaining > 0) {\n for (int k = 0; k < N && total_remaining > 0; ++k) {\n long long add = min(total_remaining, (long long)1);\n B[k] += add;\n total_remaining -= add;\n }\n }\n return B;\n}\n\n// Shelf packing for rectangles with target areas B\nvector packRectangles(const vector& B) {\n int N = B.size();\n vector rects(N);\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n // For each rectangle, choose dimensions to achieve at least B[k] with minimal waste\n vector> dims(N); // (height, width)\n for (int k = 0; k < N; ++k) {\n long long area = B[k];\n int best_h = 1, best_w = area;\n long long best_waste = best_w * best_h - area;\n for (int h = 1; h <= W; ++h) {\n long long w = (area + h - 1) / h; // ceil\n if (w > W) continue;\n long long waste = w * h - area;\n if (waste < best_waste) {\n best_waste = waste;\n best_h = h;\n best_w = w;\n }\n }\n dims[k] = {best_h, best_w};\n }\n // Sort indices by height descending\n sort(indices.begin(), indices.end(), [&](int i, int j) {\n return dims[i].first > dims[j].first;\n });\n // Shelf packing\n struct Shelf {\n int y1, y2; // vertical range\n int x; // current x position\n };\n vector shelves;\n int current_y = 0;\n for (int idx : indices) {\n int h = dims[idx].first, w = dims[idx].second;\n bool placed = false;\n for (auto& shelf : shelves) {\n if (shelf.y2 - shelf.y1 >= h && shelf.x + w <= W) {\n rects[idx] = {shelf.x, shelf.y1, shelf.x + w, shelf.y1 + h};\n shelf.x += w;\n placed = true;\n break;\n }\n }\n if (!placed) {\n // Create new shelf at current_y\n int y2 = min(W, current_y + h);\n Shelf shelf{current_y, y2, 0};\n rects[idx] = {0, current_y, w, y2};\n shelf.x = w;\n shelves.push_back(shelf);\n current_y = y2;\n placed = true;\n }\n }\n return rects;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D, N;\n cin >> W >> D >> N;\n vector> A(D, vector(N));\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n cin >> A[d][k];\n }\n }\n\n vector B = allocateB(A, D, N);\n vector rects = packRectangles(B);\n\n // Compute actual areas and sort indices by area ascending\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int i, int j) {\n return rects[i].area() < rects[j].area();\n });\n\n // Output for each day\n for (int d = 0; d < D; ++d) {\n // Sort reservations by desired area ascending\n vector day_order(N);\n iota(day_order.begin(), day_order.end(), 0);\n sort(day_order.begin(), day_order.end(), [&](int i, int j) {\n return A[d][i] < A[d][j];\n });\n // Create assignment: smallest rect to smallest desire\n vector assigned(N);\n for (int i = 0; i < N; ++i) {\n int k = day_order[i]; // reservation index\n int rect_idx = order[i]; // rectangle index\n assigned[k] = rects[rect_idx];\n }\n // Output in reservation order (0..N-1)\n for (int k = 0; k < N; ++k) {\n const Rect& r = assigned[k];\n cout << r.x1 << ' ' << r.y1 << ' ' << r.x2 << ' ' << r.y2 << '\\n';\n }\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconstexpr int MOD = 998244353;\nconstexpr int N = 9;\nconstexpr int M = 20;\nconstexpr int K = 81;\n\nstruct Move {\n int m, p, q;\n vector> cells; // (index, value)\n};\n\nstruct State {\n array board;\n long long score;\n State* parent;\n int m, p, q; // move that led to this state, or -1 for initial\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n vector a(N*N);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> a[i*N + j];\n }\n }\n\n vector, 3>> stamps(M);\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 >> stamps[m][i][j];\n }\n }\n }\n\n // Precompute all possible moves\n vector moves;\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 Move move;\n move.m = m;\n move.p = p;\n move.q = q;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int idx = (p+i)*N + (q+j);\n int val = stamps[m][i][j] % MOD;\n move.cells.emplace_back(idx, val);\n }\n }\n moves.push_back(move);\n }\n }\n }\n\n // Beam search\n const int beam_width = 10;\n vector all_states;\n State* initial = new State;\n initial->parent = nullptr;\n initial->m = initial->p = initial->q = -1;\n copy(a.begin(), a.end(), initial->board.begin());\n initial->score = accumulate(a.begin(), a.end(), 0LL);\n all_states.push_back(initial);\n\n State* global_best = initial;\n long long global_best_score = initial->score;\n\n vector current_beam;\n current_beam.push_back(initial);\n\n for (int step = 0; step < K; ++step) {\n vector candidates;\n\n for (State* s : current_beam) {\n // Option: do nothing\n candidates.push_back(s);\n\n // Try every move\n for (const Move& move : moves) {\n array new_board = s->board;\n long long gain = 0;\n\n for (auto [idx, val] : move.cells) {\n int old_rem = new_board[idx];\n int new_rem = (old_rem + val) % MOD;\n gain += new_rem - old_rem;\n new_board[idx] = new_rem;\n }\n\n long long new_score = s->score + gain;\n\n State* new_state = new State;\n new_state->board = new_board;\n new_state->score = new_score;\n new_state->parent = s;\n new_state->m = move.m;\n new_state->p = move.p;\n new_state->q = move.q;\n\n candidates.push_back(new_state);\n all_states.push_back(new_state);\n\n if (new_score > global_best_score) {\n global_best = new_state;\n global_best_score = new_score;\n }\n }\n }\n\n // Select top beam_width states\n sort(candidates.begin(), candidates.end(),\n [](State* a, State* b) { return a->score > b->score; });\n\n if (!candidates.empty() && candidates[0]->score > global_best_score) {\n global_best = candidates[0];\n global_best_score = candidates[0]->score;\n }\n\n current_beam.clear();\n for (int i = 0; i < beam_width && i < candidates.size(); ++i) {\n current_beam.push_back(candidates[i]);\n }\n }\n\n // Reconstruct the sequence of moves\n vector> sequence;\n State* cur = global_best;\n while (cur->parent != nullptr) {\n sequence.emplace_back(cur->m, cur->p, cur->q);\n cur = cur->parent;\n }\n reverse(sequence.begin(), sequence.end());\n\n // Output\n cout << sequence.size() << \"\\n\";\n for (auto [m, p, q] : sequence) {\n cout << m << \" \" << p << \" \" << q << \"\\n\";\n }\n\n // Clean up\n for (State* s : all_states) {\n delete s;\n }\n\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nconst int N = 5;\nconst int MAX_TURNS = 10000;\n\nstruct Crane {\n int r, c;\n int holding = -1; // container ID or -1\n enum State { IDLE, MOVING_TO_PICKUP, PICKING_UP, MOVING_TO_DROPOFF, DROPPING_OFF, WAITING };\n State state = IDLE;\n int target_r = -1, target_c = -1;\n int dest_row = -1; // for large crane: destination row for parking\n vector> path;\n int path_idx = 0;\n \n Crane(int r, int c) : r(r), c(c) {}\n};\n\nint grid[N][N]; // -1 empty, else container ID\nint gate_next_idx[N]; // next index to place for each left gate\nvector gate_queues[N]; // A[i][0..4]\nint dispatch_next_needed[N]; // next needed ID for each row\nvector dispatched[N]; // dispatched IDs per row\nbool container_dispatched[N*N] = {false};\nCrane cranes[N] = {Crane(0,0), Crane(1,0), Crane(2,0), Crane(3,0), Crane(4,0)};\n\n// Check if a cell is occupied by a container\nbool has_container(int r, int c) {\n return grid[r][c] != -1;\n}\n\n// Check if a cell is occupied by another crane (excluding self)\nbool has_other_crane(int r, int c, int self_idx) {\n for (int i = 0; i < N; ++i) {\n if (i != self_idx && cranes[i].r == r && cranes[i].c == c) {\n return true;\n }\n }\n return false;\n}\n\n// Check if a crane can move to a cell\nbool can_move_to(int r, int c, int crane_idx, bool carrying) {\n if (r < 0 || r >= N || c < 0 || c >= N) return false;\n if (has_other_crane(r, c, crane_idx)) return false;\n if (carrying && has_container(r, c)) return false; // small crane with container can't move to occupied\n // Large crane (index 0) can move to cells with containers even while carrying\n if (crane_idx == 0) return true;\n return true;\n}\n\n// BFS to find next move direction from (sr,sc) to (tr,tc)\npair find_next_move(int sr, int sc, int tr, int tc, int crane_idx, bool carrying) {\n if (sr == tr && sc == tc) return {0, 0};\n \n // BFS\n vector>> prev(N, vector>(N, {-1,-1}));\n vector> visited(N, vector(N, false));\n queue> q;\n q.push({sr, sc});\n visited[sr][sc] = true;\n \n while (!q.empty()) {\n auto [r, c] = q.front(); q.pop();\n if (r == tr && c == tc) break;\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (can_move_to(nr, nc, crane_idx, carrying) && !visited[nr][nc]) {\n visited[nr][nc] = true;\n prev[nr][nc] = {r, c};\n q.push({nr, nc});\n }\n }\n }\n \n // Reconstruct path and return first step\n if (!visited[tr][tc]) return {0, 0}; // no path, stay\n \n // Trace back\n int r = tr, c = tc;\n while (prev[r][c] != make_pair(sr, sc)) {\n auto [pr, pc] = prev[r][c];\n r = pr; c = pc;\n }\n // Now (r,c) is one step from (sr,sc)\n return {r - sr, c - sc};\n}\n\n// Find free parking spot in row (columns 1-3)\nint find_free_parking(int row) {\n for (int c = 1; c <= 3; ++c) {\n if (!has_container(row, c) && !has_other_crane(row, c, -1)) {\n return c;\n }\n }\n return -1;\n}\n\n// Check if a container is parked in a given row\nbool is_parked_in_row(int container_id, int row) {\n for (int c = 1; c <= 3; ++c) {\n if (grid[row][c] == container_id) return true;\n }\n return false;\n}\n\n// Find the cell where a container is parked in a row\npair find_parked_cell(int container_id, int row) {\n for (int c = 1; c <= 3; ++c) {\n if (grid[row][c] == container_id) return {row, c};\n }\n return {-1, -1};\n}\n\nvoid simulate(vector& actions) {\n // Initialize\n memset(grid, -1, sizeof(grid));\n fill(gate_next_idx, gate_next_idx + N, 0);\n fill(dispatch_next_needed, dispatch_next_needed + N, 0);\n for (int i = 0; i < N; ++i) dispatched[i].clear();\n fill(container_dispatched, container_dispatched + N*N, false);\n for (int i = 0; i < N; ++i) {\n cranes[i].holding = -1;\n cranes[i].state = Crane::IDLE;\n cranes[i].path.clear();\n }\n \n actions.resize(N);\n for (int t = 0; t < MAX_TURNS; ++t) {\n // Step 1: Place containers at gates\n for (int i = 0; i < N; ++i) {\n if (gate_next_idx[i] >= N) continue;\n bool can_place = true;\n if (has_container(i, 0)) can_place = false;\n for (int k = 0; k < N; ++k) {\n if (cranes[k].r == i && cranes[k].c == 0 && cranes[k].holding != -1) {\n can_place = false;\n break;\n }\n }\n if (can_place) {\n int container_id = gate_queues[i][gate_next_idx[i]];\n grid[i][0] = container_id;\n gate_next_idx[i]++;\n }\n }\n \n // Step 2: Crane actions\n vector turn_actions(N, '.');\n \n // Process large crane (index 0) first\n auto& lc = cranes[0];\n switch (lc.state) {\n case Crane::IDLE: {\n // Look for a container at a left gate that needs to be moved to parking\n for (int i = 0; i < N; ++i) {\n if (!has_container(i, 0)) continue;\n int container_id = grid[i][0];\n int dest = container_id / N;\n int free_c = find_free_parking(dest);\n if (free_c != -1) {\n // Set target to pick up this container\n lc.target_r = i;\n lc.target_c = 0;\n lc.dest_row = dest;\n lc.state = Crane::MOVING_TO_PICKUP;\n break;\n }\n }\n break;\n }\n case Crane::MOVING_TO_PICKUP: {\n auto [dr, dc] = find_next_move(lc.r, lc.c, lc.target_r, lc.target_c, 0, lc.holding != -1);\n if (dr == 0 && dc == 0) {\n // Reached, pick up\n turn_actions[0] = 'P';\n lc.holding = grid[lc.r][lc.c];\n grid[lc.r][lc.c] = -1;\n lc.state = Crane::PICKING_UP;\n } else {\n // Move\n lc.r += dr;\n lc.c += dc;\n turn_actions[0] = (dr == -1 ? 'U' : dr == 1 ? 'D' : dc == -1 ? 'L' : 'R');\n }\n break;\n }\n case Crane::PICKING_UP: {\n // Set target for dropoff\n int free_c = find_free_parking(lc.dest_row);\n if (free_c == -1) {\n // No free spot, wait\n lc.state = Crane::WAITING;\n } else {\n lc.target_r = lc.dest_row;\n lc.target_c = free_c;\n lc.state = Crane::MOVING_TO_DROPOFF;\n }\n break;\n }\n case Crane::MOVING_TO_DROPOFF: {\n auto [dr, dc] = find_next_move(lc.r, lc.c, lc.target_r, lc.target_c, 0, true);\n if (dr == 0 && dc == 0) {\n // Reached, drop\n turn_actions[0] = 'Q';\n grid[lc.r][lc.c] = lc.holding;\n lc.holding = -1;\n lc.state = Crane::DROPPING_OFF;\n } else {\n // Move\n lc.r += dr;\n lc.c += dc;\n turn_actions[0] = (dr == -1 ? 'U' : dr == 1 ? 'D' : dc == -1 ? 'L' : 'R');\n }\n break;\n }\n case Crane::DROPPING_OFF: {\n lc.state = Crane::IDLE;\n break;\n }\n case Crane::WAITING: {\n // Check if a free spot became available\n int free_c = find_free_parking(lc.dest_row);\n if (free_c != -1) {\n lc.target_r = lc.dest_row;\n lc.target_c = free_c;\n lc.state = Crane::MOVING_TO_DROPOFF;\n }\n break;\n }\n }\n \n // Process small cranes (indices 1-4)\n for (int i = 1; i < N; ++i) {\n auto& sc = cranes[i];\n switch (sc.state) {\n case Crane::IDLE: {\n int need = dispatch_next_needed[i];\n if (need < i*N || need >= (i+1)*N) break; // invalid\n if (container_dispatched[need]) break;\n auto [pr, pc] = find_parked_cell(need, i);\n if (pr != -1) {\n sc.target_r = pr;\n sc.target_c = pc;\n sc.state = Crane::MOVING_TO_PICKUP;\n }\n break;\n }\n case Crane::MOVING_TO_PICKUP: {\n auto [dr, dc] = find_next_move(sc.r, sc.c, sc.target_r, sc.target_c, i, sc.holding != -1);\n if (dr == 0 && dc == 0) {\n turn_actions[i] = 'P';\n sc.holding = grid[sc.r][sc.c];\n grid[sc.r][sc.c] = -1;\n sc.state = Crane::PICKING_UP;\n } else {\n sc.r += dr;\n sc.c += dc;\n turn_actions[i] = (dr == -1 ? 'U' : dr == 1 ? 'D' : dc == -1 ? 'L' : 'R');\n }\n break;\n }\n case Crane::PICKING_UP: {\n sc.target_r = i;\n sc.target_c = N-1;\n sc.state = Crane::MOVING_TO_DROPOFF;\n break;\n }\n case Crane::MOVING_TO_DROPOFF: {\n auto [dr, dc] = find_next_move(sc.r, sc.c, sc.target_r, sc.target_c, i, true);\n if (dr == 0 && dc == 0) {\n turn_actions[i] = 'Q';\n grid[sc.r][sc.c] = sc.holding;\n sc.holding = -1;\n sc.state = Crane::DROPPING_OFF;\n } else {\n sc.r += dr;\n sc.c += dc;\n turn_actions[i] = (dr == -1 ? 'U' : dr == 1 ? 'D' : dc == -1 ? 'L' : 'R');\n }\n break;\n }\n case Crane::DROPPING_OFF: {\n sc.state = Crane::IDLE;\n break;\n }\n case Crane::WAITING: {\n break;\n }\n }\n }\n \n // Step 3: Dispatch containers from right gates\n for (int i = 0; i < N; ++i) {\n if (has_container(i, N-1)) {\n int container_id = grid[i][N-1];\n dispatched[i].push_back(container_id);\n container_dispatched[container_id] = true;\n grid[i][N-1] = -1;\n // Update next needed for this row\n while (dispatch_next_needed[i] < (i+1)*N && container_dispatched[dispatch_next_needed[i]]) {\n dispatch_next_needed[i]++;\n }\n }\n }\n \n // Record actions\n for (int i = 0; i < N; ++i) {\n actions[i] += turn_actions[i];\n }\n \n // Check if all containers dispatched\n bool all_done = true;\n for (int id = 0; id < N*N; ++id) {\n if (!container_dispatched[id]) {\n all_done = false;\n break;\n }\n }\n if (all_done) break;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N;\n for (int i = 0; i < N; ++i) {\n gate_queues[i].resize(N);\n for (int j = 0; j < N; ++j) {\n cin >> gate_queues[i][j];\n }\n }\n \n vector actions;\n simulate(actions);\n \n // Pad shorter strings with '.'\n size_t max_len = 0;\n for (const string& s : actions) {\n max_len = max(max_len, s.size());\n }\n for (string& s : actions) {\n if (s.size() < max_len) {\n s.append(max_len - s.size(), '.');\n }\n }\n \n for (const string& s : actions) {\n cout << s << '\\n';\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\n\n// Generate snake path by rows: (0,0) -> (0,1) -> ... -> (0,N-1) -> (1,N-1) -> ... -> (N-1,0)\nvector> generate_path_rows() {\n vector> path;\n for (int i = 0; i < N; ++i) {\n if (i % 2 == 0) {\n for (int j = 0; j < N; ++j) path.emplace_back(i, j);\n } else {\n for (int j = N - 1; j >= 0; --j) path.emplace_back(i, j);\n }\n }\n return path;\n}\n\n// Generate snake path by columns: (0,0) -> (1,0) -> ... -> (N-1,0) -> (N-1,1) -> ... -> (0,N-1)\nvector> generate_path_cols() {\n vector> path;\n for (int j = 0; j < N; ++j) {\n if (j % 2 == 0) {\n for (int i = 0; i < N; ++i) path.emplace_back(i, j);\n } else {\n for (int i = N - 1; i >= 0; --i) path.emplace_back(i, j);\n }\n }\n return path;\n}\n\n// Compute the total load-distance for a loading tour along the given path\nint compute_load_distance(const vector>& path, const vector>& h) {\n int load = 0;\n int total = 0;\n for (int idx = 0; idx < (int)path.size(); ++idx) {\n int i = path[idx].first, j = path[idx].second;\n if (h[i][j] > 0) load += h[i][j];\n if (idx < (int)path.size() - 1) total += load;\n }\n return total;\n}\n\n// Determine move direction from (i,j) to (ni,nj) assuming they are adjacent\nstring get_move(int i, int j, int ni, int nj) {\n if (ni == i - 1) return \"U\";\n if (ni == i + 1) return \"D\";\n if (nj == j - 1) return \"L\";\n if (nj == j + 1) return \"R\";\n assert(false);\n return \"\";\n}\n\nint main() {\n // Read input\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 // Generate two candidate paths\n vector> path_rows = generate_path_rows();\n vector> path_cols = generate_path_cols();\n\n // Choose the path with smaller load-distance for loading tour\n int dist_rows = compute_load_distance(path_rows, h);\n int dist_cols = compute_load_distance(path_cols, h);\n vector> best_path = (dist_rows <= dist_cols) ? path_rows : path_cols;\n\n // Make a copy of heights for simulation\n vector> cur_h = h;\n vector ops;\n int load = 0;\n\n // Loading tour along best_path\n int cur_i = best_path[0].first, cur_j = best_path[0].second;\n for (int idx = 0; idx < (int)best_path.size(); ++idx) {\n int i = best_path[idx].first, j = best_path[idx].second;\n // Load if positive\n if (cur_h[i][j] > 0) {\n int d = cur_h[i][j];\n ops.push_back(\"+\" + to_string(d));\n load += d;\n cur_h[i][j] = 0;\n }\n // Move to next cell if not last\n if (idx < (int)best_path.size() - 1) {\n int ni = best_path[idx+1].first, nj = best_path[idx+1].second;\n ops.push_back(get_move(cur_i, cur_j, ni, nj));\n cur_i = ni;\n cur_j = nj;\n }\n }\n\n // Unloading tour along the reverse of best_path\n for (int idx = (int)best_path.size() - 1; idx >= 0; --idx) {\n int i = best_path[idx].first, j = best_path[idx].second;\n // Unload if negative\n if (cur_h[i][j] < 0) {\n int amount = min(load, -cur_h[i][j]);\n if (amount > 0) {\n ops.push_back(\"-\" + to_string(amount));\n load -= amount;\n cur_h[i][j] += amount;\n }\n }\n // Move to previous cell if not first\n if (idx > 0) {\n int pi = best_path[idx-1].first, pj = best_path[idx-1].second;\n ops.push_back(get_move(cur_i, cur_j, pi, pj));\n cur_i = pi;\n cur_j = pj;\n }\n }\n\n // Output the operation sequence\n for (const string& op : ops) {\n cout << op << '\\n';\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n const int N = 6;\n const int M = 15;\n const int T = 10;\n const int K = 2 * N * (N - 1); // 60\n\n // Read initial seeds\n vector> seeds(K, vector(M));\n for (int i = 0; i < K; ++i) {\n for (int l = 0; l < M; ++l) {\n cin >> seeds[i][l];\n }\n }\n\n // Center of the grid (0-indexed)\n const int center_i = 3, center_j = 3;\n\n for (int turn = 0; turn < T; ++turn) {\n // Compute total sums\n vector sums(K, 0);\n for (int i = 0; i < K; ++i) {\n for (int l = 0; l < M; ++l) {\n sums[i] += seeds[i][l];\n }\n }\n\n // Select top 36 seeds by sum\n vector indices(K);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(),\n [&](int i, int j) { return sums[i] > sums[j]; });\n vector S_indices(indices.begin(), indices.begin() + 36);\n\n // Champion is the best seed\n int champion_idx = S_indices[0];\n const auto& champion_vec = seeds[champion_idx];\n\n // Compute complementarity (potential max sum) for each candidate\n vector> candidate_P; // (P, index)\n for (int i = 1; i < 36; ++i) {\n int idx = S_indices[i];\n int P_val = 0;\n for (int l = 0; l < M; ++l) {\n P_val += max(champion_vec[l], seeds[idx][l]);\n }\n candidate_P.emplace_back(P_val, idx);\n }\n sort(candidate_P.begin(), candidate_P.end(), greater<>());\n\n // Choose up to 4 mates\n vector mate_indices;\n for (int i = 0; i < min(4, (int)candidate_P.size()); ++i) {\n mate_indices.push_back(candidate_P[i].second);\n }\n\n // Build the grid\n vector> grid(N, vector(N, -1));\n vector seed_used(K, false);\n\n // Place champion\n grid[center_i][center_j] = champion_idx;\n seed_used[champion_idx] = true;\n\n // Place mates in the four orthogonal neighbours\n vector> offsets = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int i = 0; i < (int)mate_indices.size(); ++i) {\n int ni = center_i + offsets[i].first;\n int nj = center_j + offsets[i].second;\n grid[ni][nj] = mate_indices[i];\n seed_used[mate_indices[i]] = true;\n }\n\n // Collect remaining seeds from S_indices\n vector remaining_seeds;\n for (int idx : S_indices) {\n if (!seed_used[idx]) {\n remaining_seeds.push_back(idx);\n }\n }\n\n // Collect empty cells\n vector> empty_cells;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] == -1) {\n empty_cells.emplace_back(i, j);\n }\n }\n }\n\n // Fill the remaining cells\n for (size_t i = 0; i < remaining_seeds.size(); ++i) {\n auto [r, c] = empty_cells[i];\n grid[r][c] = remaining_seeds[i];\n }\n\n // Output comments for debugging (ignored by judge)\n cout << \"# Turn \" << turn << endl;\n cout << \"# Champion: index=\" << champion_idx << \" sum=\" << sums[champion_idx] << endl;\n cout << \"# Mates: \";\n for (size_t i = 0; i < mate_indices.size(); ++i) {\n int idx = mate_indices[i];\n cout << idx << \" (sum=\" << sums[idx] << \", P=\" << candidate_P[i].first << \") \";\n }\n cout << endl;\n\n // Output the grid\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (j > 0) cout << \" \";\n cout << grid[i][j];\n }\n cout << endl;\n }\n cout.flush();\n\n // Read the next set of seeds (for the next turn)\n for (int i = 0; i < K; ++i) {\n for (int l = 0; l < M; ++l) {\n cin >> seeds[i][l];\n }\n }\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point() {}\n Point(int x, int y) : x(x), y(y) {}\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n};\n\nint manhattan(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\n\n// direction encoding: 0: right (0,+1), 1: down (+1,0), 2: left (0,-1), 3: up (-1,0)\nint get_dir(const Point& from, const Point& to) {\n int dx = to.x - from.x;\n int dy = to.y - from.y;\n if (dx == 1 && dy == 0) return 1; // down\n if (dx == -1 && dy == 0) return 3; // up\n if (dx == 0 && dy == 1) return 0; // right\n if (dx == 0 && dy == -1) return 2; // left\n // not adjacent\n return -1;\n}\n\n// minimal rotation steps from cur_dir to target_dir (0..3)\nint rot_steps(int cur_dir, int target_dir) {\n int diff = (target_dir - cur_dir + 4) % 4;\n if (diff == 0) return 0;\n if (diff == 2) return 2;\n return 1; // diff == 1 or 3\n}\n\n// choose rotation character to go from cur_dir to target_dir in one step (if possible)\nchar rot_char(int cur_dir, int target_dir) {\n int diff = (target_dir - cur_dir + 4) % 4;\n if (diff == 1) return 'R';\n if (diff == 3) return 'L';\n return '.'; // no rotation or need two steps (handled separately)\n}\n\nint main() {\n int N, M, V;\n cin >> N >> M >> V;\n\n vector s_grid(N), t_grid(N);\n for (int i = 0; i < N; ++i) cin >> s_grid[i];\n for (int i = 0; i < N; ++i) cin >> t_grid[i];\n\n // collect sources and targets\n vector sources, targets;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (s_grid[i][j] == '1') sources.emplace_back(i, j);\n if (t_grid[i][j] == '1') targets.emplace_back(i, j);\n }\n }\n\n // pair sources and targets greedily\n vector used_target(M, false);\n vector> pairs;\n for (const Point& src : sources) {\n int best_idx = -1;\n int best_dist = INT_MAX;\n for (int i = 0; i < M; ++i) {\n if (used_target[i]) continue;\n int d = manhattan(src, targets[i]);\n if (d < best_dist) {\n best_dist = d;\n best_idx = i;\n }\n }\n pairs.emplace_back(src, targets[best_idx]);\n used_target[best_idx] = true;\n }\n\n // design tree: star with root 0 and leaves 1..V-1, all length 1\n cout << V << '\\n';\n for (int i = 1; i < V; ++i) {\n cout << 0 << ' ' << 1 << '\\n';\n }\n\n // initial root position (choose center for convenience)\n int init_x = N / 2, init_y = N / 2;\n cout << init_x << ' ' << init_y << '\\n';\n\n // simulation state\n int rx = init_x, ry = init_y;\n int leaf_dir = 0; // initially right\n bool leaf_holding = false;\n\n // track current takoyaki positions (initially all sources)\n vector> has_takoyaki(N, vector(N, false));\n for (const Point& p : sources) has_takoyaki[p.x][p.y] = true;\n // track filled targets\n vector> target_filled(N, vector(N, false));\n\n vector ops;\n\n // helper to add a turn\n auto add_turn = [&](char move, int rot_vertex, char rot, int grab_vertex, char grab) {\n string s(2 * V, '.');\n s[0] = move;\n if (rot_vertex != -1) {\n s[1 + rot_vertex] = rot; // rotation slots start at index 1\n }\n if (grab_vertex != -1) {\n s[V + grab_vertex] = grab; // grab slots start at index V\n }\n ops.push_back(s);\n };\n\n // process each pair\n for (const auto& p : pairs) {\n const Point& src = p.first;\n const Point& dst = p.second;\n\n // --- pickup ---\n // find best neighbor for pickup\n int best_pick_dist = INT_MAX;\n int best_pick_rot_diff = INT_MAX;\n Point best_pick_root;\n int best_pick_dir = -1;\n for (int d = 0; d < 4; ++d) {\n int nx = src.x + (d == 1 ? 1 : (d == 3 ? -1 : 0));\n int ny = src.y + (d == 0 ? 1 : (d == 2 ? -1 : 0));\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n int dist = manhattan(Point(rx, ry), Point(nx, ny));\n int dir_from_root = (d + 2) % 4; // opposite direction\n int rot_diff = rot_steps(leaf_dir, dir_from_root);\n if (dist < best_pick_dist || (dist == best_pick_dist && rot_diff < best_pick_rot_diff)) {\n best_pick_dist = dist;\n best_pick_rot_diff = rot_diff;\n best_pick_root = Point(nx, ny);\n best_pick_dir = dir_from_root;\n }\n }\n // move to best_pick_root\n int px = best_pick_root.x, py = best_pick_root.y;\n // generate moves\n vector moves;\n while (rx != px) {\n if (rx > px) {\n moves.push_back('U');\n --rx;\n } else {\n moves.push_back('D');\n ++rx;\n }\n }\n while (ry != py) {\n if (ry > py) {\n moves.push_back('L');\n --ry;\n } else {\n moves.push_back('R');\n ++ry;\n }\n }\n // execute moves, with rotations as needed\n for (size_t i = 0; i < moves.size(); ++i) {\n char move = moves[i];\n if (i == moves.size() - 1) {\n // last move: also rotate and grab\n int steps = rot_steps(leaf_dir, best_pick_dir);\n if (steps == 0) {\n add_turn(move, 1, '.', 1, 'P');\n leaf_dir = best_pick_dir;\n leaf_holding = true;\n } else if (steps == 1) {\n char rot = rot_char(leaf_dir, best_pick_dir);\n add_turn(move, 1, rot, 1, 'P');\n leaf_dir = best_pick_dir;\n leaf_holding = true;\n } else { // steps == 2\n // first rotation in this move (no grab)\n char rot1 = rot_char(leaf_dir, (leaf_dir + 1) % 4); // arbitrary direction\n add_turn(move, 1, rot1, -1, '.');\n leaf_dir = (leaf_dir + 1) % 4;\n // second rotation and grab in next turn\n char rot2 = rot_char(leaf_dir, best_pick_dir);\n add_turn('.', 1, rot2, 1, 'P');\n leaf_dir = best_pick_dir;\n leaf_holding = true;\n }\n } else {\n add_turn(move, 1, '.', -1, '.');\n }\n }\n // remove takoyaki from source\n has_takoyaki[src.x][src.y] = false;\n\n // --- drop ---\n // find best neighbor for drop (must be empty target)\n best_pick_dist = INT_MAX;\n best_pick_rot_diff = INT_MAX;\n Point best_drop_root;\n int best_drop_dir = -1;\n for (int d = 0; d < 4; ++d) {\n int nx = dst.x + (d == 1 ? 1 : (d == 3 ? -1 : 0));\n int ny = dst.y + (d == 0 ? 1 : (d == 2 ? -1 : 0));\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n if (target_filled[nx][ny]) continue; // cannot land on filled target\n int dist = manhattan(Point(rx, ry), Point(nx, ny));\n int dir_from_root = (d + 2) % 4; // opposite direction\n int rot_diff = rot_steps(leaf_dir, dir_from_root);\n if (dist < best_pick_dist || (dist == best_pick_dist && rot_diff < best_pick_rot_diff)) {\n best_pick_dist = dist;\n best_pick_rot_diff = rot_diff;\n best_drop_root = Point(nx, ny);\n best_drop_dir = dir_from_root;\n }\n }\n // move to best_drop_root\n int dx = best_drop_root.x, dy = best_drop_root.y;\n moves.clear();\n while (rx != dx) {\n if (rx > dx) {\n moves.push_back('U');\n --rx;\n } else {\n moves.push_back('D');\n ++rx;\n }\n }\n while (ry != dy) {\n if (ry > dy) {\n moves.push_back('L');\n --ry;\n } else {\n moves.push_back('R');\n ++ry;\n }\n }\n for (size_t i = 0; i < moves.size(); ++i) {\n char move = moves[i];\n if (i == moves.size() - 1) {\n // last move: rotate and release\n int steps = rot_steps(leaf_dir, best_drop_dir);\n if (steps == 0) {\n add_turn(move, 1, '.', 1, 'P');\n leaf_dir = best_drop_dir;\n leaf_holding = false;\n } else if (steps == 1) {\n char rot = rot_char(leaf_dir, best_drop_dir);\n add_turn(move, 1, rot, 1, 'P');\n leaf_dir = best_drop_dir;\n leaf_holding = false;\n } else { // steps == 2\n // first rotation\n char rot1 = rot_char(leaf_dir, (leaf_dir + 1) % 4);\n add_turn(move, 1, rot1, -1, '.');\n leaf_dir = (leaf_dir + 1) % 4;\n // second rotation and release\n char rot2 = rot_char(leaf_dir, best_drop_dir);\n add_turn('.', 1, rot2, 1, 'P');\n leaf_dir = best_drop_dir;\n leaf_holding = false;\n }\n } else {\n add_turn(move, 1, '.', -1, '.');\n }\n }\n // mark target filled\n target_filled[dst.x][dst.y] = true;\n }\n\n // output operations\n for (const string& s : ops) {\n cout << s << '\\n';\n }\n\n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nconst int MAX_COORD = 100000;\nconst int MAX_PERIMETER = 400000;\n\nstruct Rectangle {\n int left, right, top, bottom; // grid indices\n int net;\n int x_min, x_max, y_min, y_max;\n\n Rectangle() : net(0) {}\n Rectangle(int l, int r, int t, int b, int net_val,\n const vector& x_start, const vector& x_end,\n const vector& y_start, const vector& y_end)\n : left(l), right(r), top(t), bottom(b), net(net_val) {\n x_min = x_start[left];\n x_max = x_end[right];\n y_min = y_start[top];\n y_max = y_end[bottom];\n }\n\n int perimeter() const {\n int width = x_max - x_min + 1;\n int height = y_max - y_min + 1;\n return 2 * (width + height);\n }\n};\n\nRectangle find_best_rectangle(const vector>& net, int G) {\n int rows = net.size();\n int cols = net[0].size();\n\n // Precompute x and y boundaries for each grid index\n vector x_start(cols), x_end(cols);\n for (int j = 0; j < cols; ++j) {\n x_start[j] = j * G;\n x_end[j] = (j == cols-1) ? MAX_COORD : (j+1) * G - 1;\n }\n vector y_start(rows), y_end(rows);\n for (int i = 0; i < rows; ++i) {\n y_start[i] = i * G;\n y_end[i] = (i == rows-1) ? MAX_COORD : (i+1) * G - 1;\n }\n\n // Default: an empty cell with net=0\n Rectangle best;\n best.net = 0;\n for (int i = 0; i < rows; ++i) {\n for (int j = 0; j < cols; ++j) {\n if (net[i][j] == 0) {\n best = Rectangle(j, j, i, i, 0, x_start, x_end, y_start, y_end);\n break;\n }\n }\n if (best.net == 0) break;\n }\n\n // Search for the best rectangle\n for (int top = 0; top < rows; ++top) {\n vector col_sum(cols, 0);\n for (int bottom = top; bottom < rows; ++bottom) {\n for (int c = 0; c < cols; ++c) {\n col_sum[c] += net[bottom][c];\n }\n // Kadane's algorithm for maximum subarray in col_sum\n int cur = 0, best_cur = 0;\n int start = 0, best_start = 0, best_end = -1;\n for (int c = 0; c < cols; ++c) {\n if (cur <= 0) {\n cur = col_sum[c];\n start = c;\n } else {\n cur += col_sum[c];\n }\n if (cur > best_cur) {\n best_cur = cur;\n best_start = start;\n best_end = c;\n }\n }\n if (best_end == -1) continue;\n\n Rectangle candidate(best_start, best_end, top, bottom, best_cur,\n x_start, x_end, y_start, y_end);\n // Check perimeter constraint\n if (candidate.perimeter() <= MAX_PERIMETER) {\n if (candidate.net > best.net) {\n best = candidate;\n }\n }\n }\n }\n return best;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector> mackerels(N), sardines(N);\n for (int i = 0; i < N; ++i) {\n cin >> mackerels[i].first >> mackerels[i].second;\n }\n for (int i = 0; i < N; ++i) {\n cin >> sardines[i].first >> sardines[i].second;\n }\n\n // Try a few grid sizes to balance resolution and search cost\n vector grid_sizes = {500, 1000};\n Rectangle best_overall;\n best_overall.net = 0;\n\n for (int G : grid_sizes) {\n int rows = (MAX_COORD + G) / G; // number of cells to cover 0..MAX_COORD\n int cols = rows;\n\n vector> count_m(rows, vector(cols, 0));\n vector> count_s(rows, vector(cols, 0));\n\n for (auto& p : mackerels) {\n int x = p.first, y = p.second;\n int i = x / G;\n int j = y / G;\n // Coordinates are within [0, MAX_COORD], so i and j are valid\n if (i < rows && j < cols) {\n count_m[i][j]++;\n }\n }\n for (auto& p : sardines) {\n int x = p.first, y = p.second;\n int i = x / G;\n int j = y / G;\n if (i < rows && j < cols) {\n count_s[i][j]++;\n }\n }\n\n vector> net(rows, vector(cols));\n for (int i = 0; i < rows; ++i) {\n for (int j = 0; j < cols; ++j) {\n net[i][j] = count_m[i][j] - count_s[i][j];\n }\n }\n\n Rectangle best_rect = find_best_rectangle(net, G);\n if (best_rect.net > best_overall.net) {\n best_overall = best_rect;\n }\n }\n\n // Output the polygon (rectangle)\n cout << \"4\\n\";\n cout << best_overall.x_min << \" \" << best_overall.y_min << \"\\n\";\n cout << best_overall.x_max << \" \" << best_overall.y_min << \"\\n\";\n cout << best_overall.x_max << \" \" << best_overall.y_max << \"\\n\";\n cout << best_overall.x_min << \" \" << best_overall.y_max << \"\\n\";\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Normal distribution with given mean and stddev, rounded to integer, clamped to [1,1e9]\nint normal_int(double mean, double stddev, mt19937& rng) {\n normal_distribution dist(mean, stddev);\n double val = dist(rng);\n int res = (int)round(val);\n if (res < 1) res = 1;\n if (res > 1000000000) res = 1000000000;\n return res;\n}\n\n// Structure for a placement instruction\nstruct Placement {\n int p; // rectangle index\n int r; // rotation: 0 or 1\n char d; // direction: 'U' or 'L'\n int b; // reference index or -1\n};\n\n// Simulation state: bounding boxes of placed rectangles\nstruct Rect {\n double x1, y1, x2, y2;\n};\n\n// Check if two rectangles overlap (allowing touching)\nbool overlap(const Rect& a, const Rect& b) {\n return (a.x1 < b.x2 && a.x2 > b.x1 && a.y1 < b.y2 && a.y2 > b.y1);\n}\n\n// Simulate the placement sequence using estimated dimensions.\n// Returns true if valid (no overlap, all coordinates non-negative).\n// Also returns the bounding box (W, H).\nbool simulate(const vector& seq, const vector& w_est, const vector& h_est,\n double& W, double& H, map& boxes) {\n boxes.clear();\n W = 0.0;\n H = 0.0;\n set placed;\n for (const Placement& pl : seq) {\n int id = pl.p;\n double w, h;\n if (pl.r == 0) {\n w = w_est[id];\n h = h_est[id];\n } else {\n w = h_est[id];\n h = w_est[id];\n }\n Rect r;\n if (pl.d == 'U') {\n if (pl.b == -1) {\n r.x1 = 0.0;\n r.y1 = 0.0;\n } else {\n if (boxes.find(pl.b) == boxes.end()) return false;\n const Rect& ref = boxes[pl.b];\n r.x1 = ref.x2;\n r.y1 = ref.y2;\n }\n r.x2 = r.x1 + w;\n r.y2 = r.y1 + h;\n } else if (pl.d == 'L') {\n if (pl.b == -1) {\n r.x2 = 0.0;\n r.y2 = 0.0;\n } else {\n if (boxes.find(pl.b) == boxes.end()) return false;\n const Rect& ref = boxes[pl.b];\n r.x2 = ref.x1;\n r.y2 = ref.y1;\n }\n r.x1 = r.x2 - w;\n r.y1 = r.y2 - h;\n } else {\n return false; // invalid direction\n }\n // Check bounds\n if (r.x1 < 0.0 || r.y1 < 0.0) return false;\n // Check overlap with existing rectangles\n for (const auto& kv : boxes) {\n if (overlap(r, kv.second)) return false;\n }\n boxes[id] = r;\n placed.insert(id);\n W = max(W, r.x2);\n H = max(H, r.y2);\n }\n return true;\n}\n\n// Greedy packing based on estimated dimensions.\n// Returns a placement sequence.\nvector greedy_packing(const vector& w_est, const vector& h_est, mt19937& rng, bool randomize = true) {\n int N = w_est.size();\n vector seq;\n map current_boxes;\n double curW = 0.0, curH = 0.0;\n set placed;\n\n for (int i = 0; i < N; ++i) {\n // Try all options for rectangle i\n struct Option {\n double delta; // increase in W+H\n Placement pl;\n };\n vector